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

news2024/11/17 5:29:07

目录

🌞一、实验目的

🌞二、实验准备

🌞三、实验内容

🌼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 d2l

n = 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) + b
    y += 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 = 10

for 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_size
            param.grad.zero_()

🌻2.7. 训练
lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

for 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) + b
    u += 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_size
            param.grad.zero_()

lr = 0.03
num_epochs = 10
net = linreg
loss = square_loss

for 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_size
            param.grad.zero_()

lr = 0.001
num_epochs = 10
net = planck_formula
loss = square_loss

for 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 torch

x = torch.randn((2), requires_grad=True)
y = x**3

dy = 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*x

print("======================================================")
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 d2l

true_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 nn

net = 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 F

class HuberLoss(nn.Module):
    def __init__(self, sigma):
        super(HuberLoss, self).__init__()
        self.sigma = sigma
    def forward(self, y, y_hat):
        if F.l1_loss(y, y_hat) > self.sigma:
            loss = F.l1_loss(y, y_hat) - self.sigma/2
        else:
            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.coloradmin.cn/o/1550624.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

H4020 40V输入EN智能控制 带线补 同步降压控制器芯片

40V输入EN智能控制带线补的同步降压控制器芯片的工作原理涉及多个方面,以下是其关键部分的解释: 输入电压管理:芯片能够接收高达40V的输入电压。这通常需要一个前端电路来处理高电压,比如使用电阻分压、电容器滤波或者其他保护电…

C++:变量和常量(3)

变量 什么是变量:变量就是一个装东西的盒子 通俗:变量是用于存放数据的容器。我们通过变量名获取数据,甚至数据可以修改 变量的作用:给指定的内存空间起名,后期通过起的名字就可以调用整个内存空间 定义变量的格式 &a…

LVS负载均衡-DR模式配置

LVS:Linux virtual server ,即Linux虚拟服务器 LVS自身是一个负载均衡器(Director),不直接处理请求,而是将请求转发至位于它后端的真实服务器real server上。 LVS是四层(传输层 tcp/udp)负载均衡…

基于javaweb(springboot)汽车配件管理系统设计和实现以及文档报告

基于javaweb(springboot)汽车配件管理系统设计和实现以及文档报告 博主介绍:多年java开发经验,专注Java开发、定制、远程、文档编写指导等,csdn特邀作者、专注于Java技术领域 作者主页 央顺技术团队 Java毕设项目精品实战案例《1000套》 欢迎点赞 收藏 ⭐…

python--冒泡排序和main函数

1.判断是不是回文数: x int(input("请输入一个正整数:")) x str(x) if x x[::-1]:print("是回文数。") else:print("不是回文数。") 2.冒泡排序 # 冒泡排序: # [30,8,-10, 50&am…

【漏洞复现】网络验证系统getInfo接口处存在SQL注入漏洞

免责声明:文章来源互联网收集整理,请勿利用文章内的相关技术从事非法测试,由于传播、利用此文所提供的信息或者工具而造成的任何直接或者间接的后果及损失,均由使用者本人负责,所产生的一切不良后果与文章作者无关。该…

【算法】KMP-快速文本匹配

文章目录 一、KMP算法说明二、详细实现1. next数组定义2. 使用next加速匹配3. next数组如何快速生成4. 时间复杂度O(mn)的证明a) next生成的时间复杂度b) 匹配过程时间复杂度 三、例题1. [leetcode#572](https://leetcode.cn/problems/subtree-of-another-tree/description/)2.…

Python 从0开始 一步步基于Django创建项目(13)将数据关联到用户

在city_infos应用程序中,每个城市信息条目是关联到城市的,所以只需要将城市条目关联到用户即可。 将数据关联到用户,就是把‘顶层’数据关联到用户。 设计思路: 1、修改顶层数据模型,向其中添加‘用户’属性 2、根…

虹科Pico汽车示波器 | 免拆诊断案例 | 2018款东风风神AX7车发动机怠速抖动、加速无力

一、故障现象 一辆2018款东风风神AX7车,搭载10UF01发动机,累计行驶里程约为5.3万km。该车因发动机怠速抖动、加速无力及发动机故障灯异常点亮而进厂维修,维修人员用故障检测仪检测,提示气缸3失火;与其他气缸对调点火线…

HCIP-Datacom(H12-821)题库补充(3/28)

最新 HCIP-Datacom(H12-821)完整题库请扫描上方二维码访问,持续更新中。 如图所示组网,以下关于R4优选路由的描述,正确的是哪一项? A:无法判断,MED不能作为AS之间BGP选路的条件 B&a…

JAVA版鸿鹄云商B2B2C:解析多商家入驻直播带货商城系统的实现与应用

一、技术选型 java开发语言:java是一种跨平台的编程语言,适用于大型企业级应用开发。使用java开发直播商城可以保证系统的稳定性和可扩展性。 spring boot框架:spring boot是一个快速构建spring应用的框架,简化了开发过程&#xf…

2D Fantasy sprite bundle

使用精灵形状和手绘精灵创建独特的景观,非常适合侧滚动或平台游戏等2d游戏。 2D Fantasy sprite bundle是一个包含9个资源的捆绑包,价格折扣约为50%。 捆绑资产: -海岛精灵包, -森林精灵包, -地牢精灵包, -山精灵包, -古老的森林精灵包, -冰雪精灵包, -熔岩地牢精灵包…

MybatisPlus速成

MybatisPlus快速入门 快速入门入门案例常见注解常见配置 核心功能条件构造器自定义SQLService接口 扩展功能代码生成静态工具逻辑删除枚举处理器JSON处理器 插件功能分页插件通用分页实体 参考文档 mybatis-plus参考文档 全部资料链接 讲义 快速入门 入门案例 <dependency…

Phoenix伪分布安装

引言 Phoenix是构建在HBase上的一个SQL层&#xff0c;能让我们用标准的JDBC APIs而不是HBase客户端APIs来创建表&#xff0c;插入数据和对HBase数据进行查询。Phoenix完全使用Java编写&#xff0c;作为HBase内嵌的JDBC驱动。Phoenix查询引擎会将SQL查询转换为一个或多个HBase扫…

win11 查看 wifi 密码

** win11 查看 wifi 密码 ** 第一种方法&#xff1a; 1.点击桌面左下角的开始菜单&#xff0c;选择“设置”。 2.在网络和internet中选择“高级网络设置”。 3.在相关设置下方点击“更多网络适配器选项”。 4.右击“WLAN”&#xff0c;在WLAN信息窗口点击“状态”。 5.…

IoT是什么?如何实现设备智能化?

设备智能化 IoT 是什么&#xff1f; The Internet of Things,物联网&#xff0c;是指通过 各种信息传感器、射频识别技术、全球定位系统、红外感应器、激光扫描器等各种装置与技术&#xff0c;实时采集任何需要监控、 连接、互动的物体或过程&#xff0c;采集其声、光、热、电…

【单例模式】—— C++设计模式【附百度Apollo单例模式详细解读】

参考资料&#xff1a; &#xff08;1&#xff09;单例模式—— 代码随想录 &#xff08;2&#xff09;我给面试官讲解了单例模式后&#xff0c;他对我竖起了大拇指&#xff01; &#xff08;3&#xff09;C 单例模式详解 &#xff08;4&#xff09;单例模式之C实现&#xff0c;…

腾讯云2核2G服务器CVM S5和轻量应用服务器优惠价格

腾讯云2核2G服务器多少钱一年&#xff1f;轻量服务器61元一年&#xff0c;CVM 2核2G S5服务器313.2元15个月&#xff0c;腾讯云2核2G服务器优惠活动 txyfwq.com/go/txy 链接打开如下图&#xff1a; 腾讯云2核2G服务器价格 轻量61元一年&#xff1a;轻量2核2G3M、3M带宽、200GB月…

自然语言处理: 第二十章Dify本地部署

项目地址: dify a. 理论基础 Dify 是一个 LLM 应用开发平台&#xff0c;已经有超过 10 万个应用基于 Dify.AI 构建。它融合了 Backend as Service 和 LLMOps 的理念&#xff0c;涵盖了构建生成式 AI 原生应用所需的核心技术栈&#xff0c;包括一个内置 RAG 引擎。使用 Dify&a…

SpringBoot使用Jedis步骤

基础连接方式 引入依赖 <!-- Jedis --><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId></dependency>创建Jedis对象&#xff0c;建立连接 操作字符串 方法名与Rdeis命令一致 操作Hash类型 释放资源 测…