【动手学深度学习】深入浅出深度学习之线性神经网络

目录

🌞一、实验目的

🌞二、实验准备

🌞三、实验内容

🌼1. 线性回归

🌻1.1 矢量化加速

🌻1.2 正态分布与平方损失

🌼2. 线性回归的从零开始实现

🌻2.1. 生成数据集

🌻2.2 读取数据集

🌻2.3. 初始化模型参数

🌻2.4. 定义模型

🌻2.5. 定义损失函数

🌻2.6. 定义优化算法

🌻2.7. 训练

🌻2.8 小结

🌻2.9 练习

🌼3. 线性回归的简洁实现

🌻3.1. 生成数据集

🌻3.2. 读取数据集

🌻3.3 定义模型

🌻3.4 初始化模型参数

🌻3.5 定义损失函数

🌻3.6 定义优化算法

🌻3.7 训练

🌻3.8 小结

🌻3.9 练习

🌞四、实验心得

🌞一、实验目的

  1. 熟悉PyTorch框架：了解PyTorch的基本概念、数据结构和核心函数；
  2. 创建线性回归模型：使用PyTorch构建一个简单的线性回归模型，该模型能够学习输入特征和目标变量之间的线性关系；
  3. 线性回归从零开始实现及其简洁实现，并完成章节后习题。

🌞二、实验准备

  1. 根据GPU安装pytorch版本实现GPU运行实验代码；
  2. 配置环境用来运行 Python、Jupyter Notebook和相关库等相关库。

🌞三、实验内容

资源获取：关注公众号【科创视野】回复  深度学习

🌼1. 线性回归

（1）使用jupyter notebook新增的pytorch环境新建ipynb文件，完成线性回归从零开始实现的实验代码与练习结果如下：

🌻1.1 矢量化加速
%matplotlib inline
import math
import time
import numpy as np
import torch
from d2l import torch as d2ln = 10000
a = torch.ones([n])
b = torch.ones([n])class Timer:  #@save"""记录多次运行时间"""def __init__(self):self.times = []self.start()def start(self):"""启动计时器"""self.tik = time.time()def stop(self):"""停止计时器并将时间记录在列表中"""self.times.append(time.time() - self.tik)return self.times[-1]def avg(self):"""返回平均时间"""return sum(self.times) / len(self.times)def sum(self):"""返回时间总和"""return sum(self.times)def cumsum(self):"""返回累计时间"""return np.array(self.times).cumsum().tolist()c = torch.zeros(n)
timer = Timer()
for i in range(n):c[i] = a[i] + b[i]
f'{timer.stop():.5f} sec'

输出结果

🌻1.2 正态分布与平方损失
def normal(x, mu, sigma):p = 1 / math.sqrt(2 * math.pi * sigma**2)return p * np.exp(-0.5 / sigma**2 * (x - mu)**2)# 再次使用numpy进行可视化
x = np.arange(-7, 7, 0.01)# 均值和标准差对
params = [(0, 1), (0, 2), (3, 1)]
d2l.plot(x, [normal(x, mu, sigma) for mu, sigma in params], xlabel='x',ylabel='p(x)', figsize=(4.5, 2.5),legend=[f'mean {mu}, std {sigma}' for mu, sigma in params])

输出结果

🌼2. 线性回归的从零开始实现

%matplotlib inline
import random
import torch
from d2l import torch as d2l
🌻2.1. 生成数据集
def synthetic_data(w, b, num_examples):  #@save"""生成y=Xw+b+噪声"""X = torch.normal(0, 1, (num_examples, len(w)))y = torch.matmul(X, w) + by += torch.normal(0, 0.01, y.shape)return X, y.reshape((-1, 1))true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)print('features:', features[0],'\nlabel:', labels[0])

输出结果

d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1);

输出结果

🌻2.2 读取数据集
def data_iter(batch_size, features, labels):num_examples = len(features)indices = list(range(num_examples))# 这些样本是随机读取的，没有特定的顺序random.shuffle(indices)for i in range(0, num_examples, batch_size):batch_indices = torch.tensor(indices[i: min(i + batch_size, num_examples)])yield features[batch_indices], labels[batch_indices]batch_size = 10for X, y in data_iter(batch_size, features, labels):print(X, '\n', y)break

输出结果

🌻2.3. 初始化模型参数
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
w,b

输出结果

🌻2.4. 定义模型
def linreg(X, w, b):  #@save"""线性回归模型"""return torch.matmul(X, w) + b
🌻2.5. 定义损失函数
def squared_loss(y_hat, y):  #@save"""均方损失"""return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
🌻2.6. 定义优化算法
def sgd(params, lr, batch_size):  #@save"""小批量随机梯度下降"""with torch.no_grad():for param in params:param -= lr * param.grad / batch_sizeparam.grad.zero_()
🌻2.7. 训练
lr = 0.03
num_epochs = 3
net = linreg
loss = squared_lossfor epoch in range(num_epochs):for X, y in data_iter(batch_size, features, labels):l = loss(net(X, w, b), y)  # X和y的小批量损失# 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，# 并以此计算关于[w,b]的梯度l.sum().backward()sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数with torch.no_grad():train_l = loss(net(features, w, b), labels)print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

输出结果

print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

输出结果

🌻2.8 小结

我们学习了深度网络是如何实现和优化的。在这一过程中只使用张量和自动微分，不需要定义层或复杂的优化器。这一节只触及到了表面知识。在下面的部分中，我们将基于刚刚介绍的概念描述其他模型，并学习如何更简洁地实现其他模型。

🌻2.9 练习

1.如果我们将权重初始化为零，会发生什么。算法仍然有效吗？

# 在单层网络中(一层线性回归层)，将权重初始化为零时可以的，但是网络层数加深后，在全连接的情况下，
# 在反向传播的时候，由于权重的对称性会导致出现隐藏神经元的对称性，使得多个隐藏神经元的作用就如同
# 1个神经元，算法还是有效的，但是效果不大好。参考：https://zhuanlan.zhihu.com/p/75879624。

2.假设试图为电压和电流的关系建立一个模型。自动微分可以用来学习模型的参数吗？

# 可以的，建立模型U=IW+b，然后采集(U，I)的数据集，通过自动微分即可学习W和b的参数。
import torch
import random
from d2l import torch as d2l
#生成数据集
def synthetic_data(r, b, num_examples):I = torch.normal(0, 1, (num_examples, len(r)))u = torch.matmul(I, r) + bu += torch.normal(0, 0.01, u.shape) # 噪声return I, u.reshape((-1, 1)) # 标量转换为向量true_r = torch.tensor([20.0])
true_b = 0.01
features, labels = synthetic_data(true_r, true_b, 1000)#读取数据集
def data_iter(batch_size, features, labels):num_examples = len(features)indices = list(range(num_examples))random.shuffle(indices)for i in range(0, num_examples, batch_size):batch_indices = torch.tensor(indices[i: min(i + batch_size, num_examples)])yield features[batch_indices],labels[batch_indices]batch_size = 10
# 初始化权重
r = torch.normal(0,0.01,size = ((1,1)), requires_grad = True)
b = torch.zeros(1, requires_grad = True)# 定义模型
def linreg(I, r, b):return torch.matmul(I, r) + b
# 损失函数
def square_loss(u_hat, u):return (u_hat - u.reshape(u_hat.shape)) ** 2/2
# 优化算法
def sgd(params, lr, batch_size):with torch.no_grad():for param in params:param -= lr * param.grad/batch_sizeparam.grad.zero_()lr = 0.03
num_epochs = 10
net = linreg
loss = square_lossfor epoch in range(num_epochs):for I, u in data_iter(batch_size, features, labels):l = loss(net(I, r, b), u)l.sum().backward()sgd([r, b], lr, batch_size)with torch.no_grad():train_l = loss(net(features, r, b), labels)print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')
print(r)
print(b)
print(f'r的估计误差: {true_r - r.reshape(true_r.shape)}')
print(f'b的估计误差: {true_b - b}')

输出结果

3.能基于普朗克定律使用光谱能量密度来确定物体的温度吗？

u _ { \lambda } = \frac { 8 \pi h v ^ { 3 } } { c ^ { 3 } } \frac { 1 } { e ^ { h v / k T } - 1 }

# 3
# 普朗克公式
# x:波长
# T:温度
import torch
import random
from d2l import torch as d2l#生成数据集
def synthetic_data(x, num_examples):T = torch.normal(0, 1, (num_examples, len(x)))u = c1 / ((x ** 5) * ((torch.exp(c2 / (x * T))) - 1));u += torch.normal(0, 0.01, u.shape) # 噪声return T, u.reshape((-1, 1)) # 标量转换为向量c1 = 3.7414*10**8  # c1常量
c2 = 1.43879*10**4  # c2常量
true_x = torch.tensor([500.0])features, labels = synthetic_data(true_x, 1000)#读取数据集
def data_iter(batch_size, features, labels):num_examples = len(features)indices = list(range(num_examples))random.shuffle(indices)for i in range(0, num_examples, batch_size):batch_indices = torch.tensor(indices[i: min(i + batch_size, num_examples)])yield features[batch_indices],labels[batch_indices]batch_size = 10
# 初始化权重
x = torch.normal(0,0.01,size = ((1,1)), requires_grad = True)# 定义模型
def planck_formula(T, x):return c1 / ((x ** 5) * ((torch.exp(c2 / (x * T))) - 1))
# 损失函数
def square_loss(u_hat, u):return (u_hat - u.reshape(u_hat.shape)) ** 2/2
# 优化算法
def sgd(params, lr, batch_size):with torch.no_grad():for param in params:param -= lr * param.grad/batch_sizeparam.grad.zero_()lr = 0.001
num_epochs = 10
net = planck_formula
loss = square_lossfor epoch in range(num_epochs):for T, u in data_iter(batch_size, features, labels):l = loss(net(T, x), u)l.sum().backward()sgd([x], lr, batch_size)with torch.no_grad():train_l = loss(net(features, x), labels)print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')print(f'r的估计误差: {true_x - x.reshape(true_x.shape)}')

输出结果

4.计算二阶导数时可能会遇到什么问题？这些问题可以如何解决？

#  一阶导数的正向计算图无法直接获得，可以通过保存一阶导数的计算图使得可以求二阶导数(create_graph和retain_graph都置为True，
# 保存原函数和一阶导数的正向计算图)。实验如下：
import torchx = torch.randn((2), requires_grad=True)
y = x**3dy = torch.autograd.grad(y, x, grad_outputs=torch.ones(x.shape),retain_graph=True, create_graph=True)
dy2 = torch.autograd.grad(dy, x, grad_outputs=torch.ones(x.shape))dy_ = 3*x**2
dy2_ = 6*xprint("======================================================")
print(dy, dy_)
print("======================================================")
print(dy2, dy2_)

输出结果

5.为什么在squared_loss函数中需要使用reshape函数？

# 以防y^和y，一个是行向量、一个是列向量，使用reshape，可以确保shape一样。

6.尝试使用不同的学习率，观察损失函数值下降的快慢。

# ①学习率过大前期下降很快，但是后面不容易收敛；
# ②学习率过小损失函数下降会很慢。

7.如果样本个数不能被批量大小整除，data_iter函数的行为会有什么变化？

# 报错。

🌼3. 线性回归的简洁实现

（1）使用jupyter notebook新增的pytorch环境新建ipynb文件，完成线性回归的简洁实现的实验代码与练习结果如下：

🌻3.1. 生成数据集
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2ltrue_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)
🌻3.2. 读取数据集
def load_array(data_arrays, batch_size, is_train=True):  #@save"""构造一个PyTorch数据迭代器"""dataset = data.TensorDataset(*data_arrays)return data.DataLoader(dataset, batch_size, shuffle=is_train)batch_size = 10
data_iter = load_array((features, labels), batch_size)next(iter(data_iter))

输出结果

🌻3.3 定义模型
# nn是神经网络的缩写
from torch import nnnet = nn.Sequential(nn.Linear(2, 1))
🌻3.4 初始化模型参数
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

输出结果

🌻3.5 定义损失函数
loss = nn.MSELoss()
🌻3.6 定义优化算法
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
🌻3.7 训练
num_epochs = 3
for epoch in range(num_epochs):for X, y in data_iter:l = loss(net(X) ,y)trainer.zero_grad()l.backward()trainer.step()l = loss(net(features), labels)print(f'epoch {epoch + 1}, loss {l:f}')

输出结果

w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

输出结果

🌻3.8 小结
  1. 我们可以使用PyTorch的高级API更简洁地实现模型。
  2. 在PyTorch中，data模块提供了数据处理工具，nn模块定义了大量的神经网络层和常见损失函数。
  3. 我们可以通过_结尾的方法将参数替换，从而初始化参数。
🌻3.9 练习

1.如果将小批量的总损失替换为小批量损失的平均值，需要如何更改学习率？

# 将学习率除以batchsize。

2.查看深度学习框架文档，它们提供了哪些损失函数和初始化方法？

用Huber损失代替原损失，即

# Huber损失可以用torch自带的函数解决
torch.nn.SmoothL1Loss()
# 也可以自己写
import torch.nn as nn
import torch.nn.functional as Fclass HuberLoss(nn.Module):def __init__(self, sigma):super(HuberLoss, self).__init__()self.sigma = sigmadef forward(self, y, y_hat):if F.l1_loss(y, y_hat) > self.sigma:loss = F.l1_loss(y, y_hat) - self.sigma/2else:loss = (1/(2*self.sigma))*F.mse_loss(y, y_hat)return loss#%%
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l#%%
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)def load_array(data_arrays, batch_size, is_train = True): #@save'''pytorch数据迭代器'''dataset = data.TensorDataset(*data_arrays) # 把输入的两类数据一一对应；*表示对list解开入参return data.DataLoader(dataset, batch_size, shuffle = is_train) # 重新排序batch_size = 10
data_iter = load_array((features, labels), batch_size) # 和手动实现中data_iter使用方法相同#%%
# 构造迭代器并验证data_iter的效果
next(iter(data_iter))  # 获得第一个batch的数据#%% 定义模型
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))  # Linear中两个参数一个表示输入形状一个表示输出形状
# sequential相当于一个存放各层数据的list，单层时也可以只用Linear#%% 初始化模型参数
# 使用net[0]选择神经网络中的第一层
net[0].weight.data.normal_(0, 0.01) # 正态分布
net[0].bias.data.fill_(0)#%% 定义损失函数
loss = torch.nn.HuberLoss()
#%% 定义优化算法
trainer = torch.optim.SGD(net.parameters(), lr=0.03) # optim module中的SGD
#%% 训练
num_epochs = 3
for epoch in range(num_epochs):for X, y in data_iter:l = loss(net(X), y)trainer.zero_grad()l.backward()trainer.step()l = loss(net(features), labels)print(f'epoch {epoch+1}, loss {l:f}')#%% 查看误差
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

输出结果

3.如何访问线性回归的梯度？

#假如是多层网络，可以用一个self.xxx=某层，然后在外面通过net.xxx.weight.grad和net.xxx.bias.grad把梯度给拿出来。
net[0].weight.grad
net[0].bias.grad

输出结果

🌞四、实验心得

通过此次实验，我熟悉了PyTorch框架以及PyTorch的基本概念、数据结构和核心函数；创建了线性回归模型，使用PyTorch构建一个简单的线性回归模型；完成了线性回归从零开始实现及其简洁实现以及章节后习题。明白了以下几点：

1.深度学习的关键要素包括训练数据、损失函数、优化算法以及模型本身。这些要素相互作用，共同决定了模型的性能和表现。

2.矢量化是一种重要的数学表达方式，它能使数学计算更加简洁高效。通过使用向量和矩阵运算，可以将复杂的计算过程转化为简单的线性代数运算，从而提高计算效率。

3.最小化目标函数和执行极大似然估计是等价的。在机器学习中，通常通过最小化损失函数来优化模型。而在概率统计中，可以通过最大化似然函数来估计模型参数。这两种方法在数学上是等价的，都可以用于优化模型。

4.线性回归模型可以被看作是一个简单的神经网络模型。它只包含一个输入层和一个输出层，其中输入层的神经元数量与输入特征的维度相同，输出层的神经元数量为1。线性回归模型可以用于解决回归问题，通过学习输入特征与输出之间的线性关系来进行预测。

5.在深度学习中，学习了如何实现和优化深度神经网络。在这个过程中，只使用张量（Tensor）和自动微分（Automatic Differentiation），而不需要手动定义神经网络层或复杂的优化器。张量是深度学习中的基本数据结构，它可以表示多维数组，并支持各种数学运算。自动微分是一种计算梯度的技术，它能够自动计算函数相对于输入的导数，从而实现了反向传播算法。

6.为了更加简洁地实现模型，可以利用PyTorch的高级API。在PyTorch中，data模块提供了数据处理工具，包括数据加载、预处理和批处理等功能，使得数据的处理变得更加方便和高效。nn模块则提供了大量的神经网络层和常见损失函数的定义，可以直接使用这些层和函数来构建和训练模型，无需手动实现。此外还可以通过使用_结尾的方法来进行参数的替换和初始化，从而更加灵活地管理模型的参数。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/288868.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

网络安全：Kali Linux 进行SQL注入与XSS漏洞利用

网络安全：Kali Linux 进行SQL注入与XSS漏洞利用

目录 一、实验 1.环境 2.Kali Linux 进行SQL注入 3.Kali Linux 进行XSS漏洞利用 二、问题 1.XSS分类 2.如何修改beef-xss的密码 3.beef-xss 服务如何管理 4.运行beef报错 5.beef 命令的颜色有哪些区别 6.owasp-top-10 有哪些变化 一、实验 1.环境 （1&a…
阅读更多...
2024年腾讯云4核8g服务器并发数、优惠价格、支持多少人在线？

2024年腾讯云4核8g服务器并发数、优惠价格、支持多少人在线？

腾讯云4核8G服务器价格：轻量4核8G12M优惠价格646元15个月、CVM S5服务器4核8G配置1437元买1年送3个月。腾讯云4核8G服务器支持多少人同时在线？支持30个并发数，可容纳日均1万IP人数访问。腾讯云百科txybk.com整理4核8G服务器支持多少人同时在线…
阅读更多...
Chrome之解决：浏览器插件不能使用问题(十三)

Chrome之解决：浏览器插件不能使用问题(十三)

简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！ 优质专栏：Audio工程师进阶系列【原创干货持续更新中……】🚀 优质专栏：多媒…
阅读更多...
C程序编译、链接与项目构建

C程序编译、链接与项目构建

C程序编译、链接与项目构建 摘要C编译环境静、动态库介绍gcc与g和程序编译、链接Visual Studio创建和链接库动态库的显示调用Windows下显示动态库的加载/查找方式 Make介绍安装使用 CMake介绍安装使用构建方式内部构建外部构建构建使用静/动态库常用[系统]变量常用指令CMake模块…
阅读更多...
YOLOv9改进策略：block优化 | Transformer架构ConvNeXt 网络在检测中大放异彩

YOLOv9改进策略：block优化 | Transformer架构ConvNeXt 网络在检测中大放异彩

💡💡💡本文改进内容：Transformer架构 ConvNeXt 网络在图像分类和识别、分割领域大放异彩，同时对比 Swin-T 模型，在多种任务中其模型的大小和准确率均有一些提升，模型的 FLOPs 较大的减小且 Acc …
阅读更多...
Tire树-不学面试后悔

Tire树-不学面试后悔

先来一张图，看多少同学在面试中遇到这个题，然后被迫放弃，那就太可惜，因为这个题只要你往下看就会了 Trie（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字…
阅读更多...
Spring-ThreadLocal内存泄漏原因及解决办法

Spring-ThreadLocal内存泄漏原因及解决办法

ThreadLocal原理回顾 ThreadLocal的原理：每个Thread内部维护着一个ThreadLocalMap，它是一个Map。这个映射表的Key是一个弱引用，其实就是ThreadLocal本身，Value是真正存的线程变量Object。 也就是说ThreadLocal本身并不真正存储线…
阅读更多...
电源模块 YULIN俞霖科技DC/DC电源模块 直流升压 高压稳压

电源模块 YULIN俞霖科技DC/DC电源模块 直流升压 高压稳压

Features 最低工作电压：0.7V电压隔离：1000VDC /3000VDC 平均无故障时间： > 800,000 小时短路与电弧保护无最低负载要求：可空载工作输入电压：5、12、15、24VDCOutput 100,200、300、400、500 、600、800、 1000、1…
阅读更多...
关于使用TCP-S7协议读写西门子PLC字符串的问题

关于使用TCP-S7协议读写西门子PLC字符串的问题

我们可以使用TCP-S7协议读写西门子PLC， 比如PLC中定义一个String[50] 的地址DB300.20 地址DB300.20 DB块编号为300，偏移量【地址】是30 S7协议是西门子PLC自定义的协议，默认端口102，本质仍然是TCP协议的一种具体实现&#xff…
阅读更多...
答题小程序功能细节揭秘：如何提升用户体验和满足用户需求？

答题小程序功能细节揭秘：如何提升用户体验和满足用户需求？

答题小程序功能细节体现 随着移动互联网的快速发展，答题小程序成为了用户获取知识、娱乐休闲的重要平台。一款优秀的答题小程序不仅应该具备简洁易用的界面设计，更应该在功能细节上做到极致，以提升用户体验和满足用户需求。本文将从题库随机…
阅读更多...
【YOLOv5改进系列(5)】高效涨点----添加密集小目标检测NWD方法

【YOLOv5改进系列(5)】高效涨点----添加密集小目标检测NWD方法

文章目录 🚀🚀🚀前言一、1️⃣ 修改loss.py文件1.1 🎓 修改11.2 ✨ 修改21.3 ⭐️相关代码的解释 二、2️⃣NWD实验2.1 🎓 实验一：基准模型2.2 ✨实验二：NWD权重设置0.52.3 ⭐️实验三&#xf…
阅读更多...
蓝桥杯练习题——博弈论

蓝桥杯练习题——博弈论

1.必胜态后继至少存在一个必败态 2.必败态后继均为必胜态 Nim游戏 思路 2 3，先手必赢，先拿 1，然后变成 2 2，不管后手怎么拿，先手同样操作，后手一定先遇到 0 0 a1 ^ a2 ^ a3 … ^ an 0，先…
阅读更多...
MySQL数据库----------探索高级SQL查询语句 （二）

MySQL数据库----------探索高级SQL查询语句 （二）

目录 一、子查询 1.1多表查询 1.2多层嵌套 1.3 insert语句子查询 1.4update语句子查询 1.5delete语句子查询 1.6EXISTS 1.7子查询，别名as 二、mysql视图 2.1mysql视图介绍 2.2mysql作用场景[图]: 2.3视图功能： 2.4视图和表的区别和联系 区别…
阅读更多...
保障校园网络安全用堡垒机的几个原因分析

保障校园网络安全用堡垒机的几个原因分析

校园，人人都熟悉的地方，梦想知识开始的地方。在互联网数字化快速发展的今天，网络安全的学习环境是非常必要的。所以采购保障校园网络安全工具是必要的。那为什么一定要用堡垒机呢？这里我们一起来简单分析一下原因。 保障校园网络…
阅读更多...
前端如何判断元素是否到达可视区域

前端如何判断元素是否到达可视区域

以图片显示为例： window.innerHeight 是浏览器可视区的高度；document.body.scrollTop || document.documentElement.scrollTop 是浏览器滚动的过的距离；imgs.offsetTop 是元素顶部距离文档顶部的高度（包括滚动条的距离&#xff0…
阅读更多...
LeetCode 27 移除元素

LeetCode 27 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面…
阅读更多...
【技巧】PyTorch限制GPU显存的可使用上限

【技巧】PyTorch限制GPU显存的可使用上限

转载请注明出处：小锋学长生活大爆炸[xfxuezhang.cn] 从 PyTorch 1.4 版本开始，引入了一个新的功能 torch.cuda.set_per_process_memory_fraction(fraction, device)，这个功能允许用户为特定的 GPU 设备设置进程可使用的显存上限比例。 测试代…
阅读更多...
展示大屏-24小时天气预报

展示大屏-24小时天气预报

一、项目说明 展示大屏显示未来一周天气和24小时天气详情。 二、技术工具 1.语言&框架：java、springboot 2.UI界面：jQuery、HTML、CSS、 VUE 3.开发工具：IntelliJ IDEA、Eclipse 三、实现步骤 后端步骤 1.调取免费或收费的API接口。 …
阅读更多...
数据结构——快速排序的三种方法和非递归实现快速排序

数据结构——快速排序的三种方法和非递归实现快速排序

数据结构——快速排序的三种方法和非递归实现快速排序（升序） 快速排序的单趟排序hoare法挖坑法前后指针法 快速排序的实现key基准值的选取快速排序代码快速排序的优化 快速排序（非递归） 快速排序的单趟排序 hoare法 思路:从给定…
阅读更多...
AndroidStudio中一些实用插件

AndroidStudio中一些实用插件

1.RainbowBrackets插件为圆括号、方括号和花括号内的代码添加了漂亮的彩虹色 2.CodeGlance类似于Sublime或Xcode，CodeGlance插件在编辑器中嵌入了代码迷你图。滚动条也有所增大。在CodeGlance预览文件的代码模式下，用户可以快速导航到目标处。 3.ADBWifi…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023