东莞米可网络怎么样/新站seo优化快速上排名

东莞米可网络怎么样,新站seo优化快速上排名,网站内地图位置怎么做,建设网站平台的用语目录 PyTorch 定义 核心作用 应用场景 Pytorch 基本语法 1. 张量的创建 2. 张量的类型转换 3. 张量数值计算 4. 张量运算函数 5. 张量索引操作 6. 张量形状操作 7. 张量拼接操作 8. 自动微分模块 9. 案例-线性回归案例 PyTorch 定义 PyTorch 是一个基于 Python 深…

目录

PyTorch 定义

核心作用

应用场景

Pytorch 基本语法

1. 张量的创建

2. 张量的类型转换

3. 张量数值计算

4. 张量运算函数

5. 张量索引操作

6. 张量形状操作

7. 张量拼接操作

8. 自动微分模块

9. 案例-线性回归案例

PyTorch 定义

PyTorch 是一个基于 Python 深度学习框架，由 Facebook（现 Meta）的 AI 研究团队开发并维护。它专注于 深度学习和 张量计算， 它将数据封装成张量（Tensor）来进行处理。PyTorch 中的张量就是元素为同一种数据 类型的多维矩阵。在 PyTorch 中，张量以 "类" 的形式封装起来，对张量的一些运算、处理的方法被封装在类中。
Pytorch的安装：
# 清华镜像
pip install torch==2.0.1 -i https://pypi.tuna.tsinghua.edu.cn/simple
其他的镜像源:

# 阿里云镜像
https://mirrors.aliyun.com/pypi/simple/

# 豆瓣镜像
https://pypi.doubanio.com/simple/

# 中科大镜像
https://pypi.mirrors.ustc.edu.cn/simple/

核心作用

  1. 张量计算（Tensor Computations）
    PyTorch 提供高效的 Tensor 库（类似 NumPy），支持 GPU 加速，能够处理高维数组的数学运算（如矩阵乘法、卷积等），是构建神经网络的数学基础。

  2. 自动微分（Autograd）
    通过 autograd 模块，PyTorch 可以自动计算张量的梯度（导数），这是训练神经网络的核心功能（如反向传播）。

  3. 动态计算图（Dynamic Computation Graph）
    与 TensorFlow 的静态图不同，PyTorch 使用动态图机制（即 "Define-by-Run"），允许在代码运行时动态构建计算图。这使得调试更直观，灵活性更高，尤其适合研究场景。

  4. 深度学习模型构建
    提供 torch.nn 模块，包含预定义的神经网络层（如全连接层、卷积层、RNN 等），简化了复杂模型的搭建过程。

  5. 部署与生产化
    支持通过 TorchScript 或 ONNX 格式将模型导出到生产环境（如移动端、服务器端），并与 C++ 无缝集成。

应用场景

  • 学术研究：PyTorch 的灵活性和易用性使其成为学术界的主流工具，大量论文代码基于 PyTorch 实现。

  • 自然语言处理（NLP）：如 Transformer、BERT 等模型的实现。

  • 计算机视觉（CV）：图像分类、目标检测、生成对抗网络（GAN）等。

  • 强化学习：与 OpenAI Gym 等工具结合，训练智能体。

  • 工业原型开发：快速迭代和部署模型。

Pytorch 基本语法

1. 张量的创建
import torch
import numpy as np"""
创建张量的方式
• torch.tensor 根据指定数据创建张量
• torch.Tensor 根据形状创建张量, 其也可用来创建指定数据的张量
"""
# 1.torch.tensor() 根据指定数据创建张量
# 0维张量:标量(scalar)
print(torch.tensor(10))
# 1维张量:向量(vector)
print(torch.tensor([10,10]))
# 2维张量:矩阵(matrix)
print(torch.tensor([[10,10],[10,10],[10,10]]))
# 多维张量
print(torch.tensor([[[10,10],[10,10],[10,10]]]))# numpy 数组, 由于 data 为 float64, 下面代码也使用该类型
data_np=np.random.rand(2,3)
print(data_np)
print(torch.tensor(data_np))data =[[10.,20,30],[20,30,40]]
print(data)
print(torch.tensor(data))#2.torch.Tensor() 根据指定形状创建张量，也可以用来创建指定数据的张量
#创建2行3列的张量, 默认 dtype 为 float32
data = torch.Tensor(2, 3)
print(data)
# 注意: 如果传递列表, 则创建包含指定元素的张量
print(torch.Tensor([2]))
print(torch.Tensor([[2, 3, 4], [5, 6, 7]]))"""
创建线性和随机张量
• torch.arrange() 和 torch.linspace() 创建线性张量
• torch.randn() 创建随机张量
"""
#创建线性
# 1. 在指定区间按照步长生成元素 [start, end, step)
data = torch.arange(0, 10, 2)
print(data)
# 2. 在指定区间按照元素个数生成 [start, end, num]
data = torch.linspace(0, 11, 10)
print(data)#torch.randn() 创建随机张量
# 1. 创建随机张量
data = torch.randn(2, 3) # 创建2行3列张量
print(data)"""
创建01张量
• torch.zeros() 创建全0张量
• torch.ones() 创建全1张量
• torch.full() 创建全为指定值张量
"""
#创建0、1、指定值张量
# 1. 创建指定形状全0张量
data = torch.zeros(2, 3)
print(data)
# 2. 创建指定形状全1张量
# torch.ones()创建全1张量
data = torch.ones(2, 3)
print(data)
# 3. 创建指定形状指定值的张量
# torch.full()创建全为指定值张量
data = torch.full([2, 3], 10)
print(data)"""
张量元素类型转换
data.type(torch.DoubleTensor) 
• data.double()
"""
#张量的类型转换
#data.type(torch.DoubleTensor)
data = torch.full([2, 3], 10)
print(data.dtype)
# 将 data 元素类型转换为 float64 类型
data = data.type(torch.DoubleTensor)
print(data.dtype)
# 转换为其他类型
data = data.type(torch.IntTensor)
data = data.type(torch.LongTensor)
data = data.type(torch.FloatTensor)# data.double()
data = torch.full([2, 3], 10)
print(data.dtype)
# 将 data 元素类型转换为 float64 类型
data = data.double()
print(data.dtype)
# 转换为其他类型
data = data.int()
data = data.long()
data = data.float()
2. 张量的类型转换
import numpy as np
import torch"""
张量转换为NumPy数组
• data_tensor.numpy()
"""
#使用Tensor.numpy()函数可以将张量转换为ndarray数组
# 1. 将张量转换为 numpy 数组
data_tensor = torch.tensor([2, 3, 4])
# 使用张量对象中的 numpy 函数进行转换
data_numpy = data_tensor.numpy()
print(type(data_tensor))
print(type(data_numpy))
print(data_numpy)"""
NumPy数组转换为张量
• 使用 from_numpy 可以将 ndarray 数组转换为 Tensor。torch.from_numpy(data_numpy)
• 使用 torch.tensor 可以将 ndarray 数组转换为 Tensor。torch.tensor(data_numpy)
"""
#使用from_numpy()可以将ndarray数组转换为Tensor
data_numpy = np.array([2, 3, 4])
# 将 numpy 数组转换为张量类型
# 1. from_numpy
# 2. torch.tensor(ndarray)
data_tensor = torch.from_numpy(data_numpy)
print(data_tensor)
print(data_numpy)# 使用torch.tensor()可以将ndarray数组转换为Tensor。
data_numpy = np.array([2, 3, 4])
data_tensor = torch.tensor(data_numpy)
print(data_tensor)
print(data_numpy)"""
标量张量和数字转换
• data.item()
"""
# 当张量只包含一个元素时, 可以通过 item() 函数提取出该值
data = torch.tensor([30,])
print(data.item())
data = torch.tensor(30)
print(data.item())
3. 张量数值计算

张量基本运算

import torch"""
张量基本运算
加减乘除取负号：
• add、sub、mul、div、neg等函数
• add_、sub_、mul_、div_、neg_等函数（其中带下划线的版本会修改原数据）
"""
data = torch.randint(0, 10, [2, 3])
print(data)
# 1. 不修改原数据
new_data = data.add(10) # 等价 new_data = data + 10
print(new_data)
# 2. 直接修改原数据 注意: 带下划线的函数为修改原数据本身
data.add_(10) # 等价 data += 10
print(data)
# 3. 其他函数
print(data.sub(100))
print(data.mul(100))
print(data.div(100))
print(data.neg())
点乘运算
点乘指（Hadamard）的是两个同维数组对应位置的元素相乘，使用 mul 和运算符 * 实现。 
"""
张量的点乘运算
• mul和运算符*
"""
data1 = torch.tensor([[1, 2], [3, 4]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 第一种方式
data = torch.mul(data1, data2)
print(data)
# 第二种方式
data = data1 * data2
print(data)

乘法运算

数组乘法运算要求第一个数组 shape: (n, m)，第二个数组 shape: (m, p), 两个数组乘法运算 shape 为: (n, p)。
1. 运算符 @ 用于进行两个矩阵的乘积运算
2. torch.matmul 中输入的 shape 不同的张量, 对应的维度必须符合数组乘法的运算规则 
"""
矩阵乘法运算
• 运算符@用于进行两个矩阵的乘法运算
• torch.matmul 对应的维度必须符合矩阵运算规则
"""
# 乘法运算
data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 方式一:
data3 = data1 @ data2
print("data3-->", data3)
# 方式二:
data4 = torch.matmul(data1, data2)
print("data4-->", data4)
4. 张量运算函数 
import torch"""
张量运算函数
Sum,mean,sqrt,pow,exp,log等
"""data = torch.randint(0, 10, [2, 3], dtype=torch.float64)
print(data)
# 1. 计算均值
# 注意: tensor 必须为 Float 或者 Double 类型
print(data.mean())
# 2. 计算总和
print(data.sum())
# 3. 计算平方
print(torch.pow(data, 2))
# 4. 计算平方根
print(data.sqrt())
# 5. 指数计算, e^n 次方
print(data.exp())
# 6. 对数计算
print(data.log()) # 以 e 为底
print(data.log2())
print(data.log10())
5. 张量索引操作
索引操作
在操作张量时，经常需要去获取某些元素就进行处理或者修改操作，我们需要了解在torch中的索引操作。  
import torch# 数据准备
# 随机生成数据
data = torch.randint(0, 10, [4, 5])
print(data)"""
• 简单行列索引的使用
"""
print(data[0])
print(data[:, 0])"""
• 列表索引的使用
"""
# 返回 (0, 1)、(1, 2) 两个位置的元素
print(data[[0, 1], [1, 2]])
# 返回 0、1 行的 1、2 列共4个元素
print(data[[[0], [1]], [1, 2]])"""
• 范围索引的使用
"""
# 前3行的前2列数据
print(data[:3, :2])
# 第2行到最后的前2列数据
print(data[2:, :2])"""
• 多维索引的使用
"""
data = torch.randint(0, 10, [3, 4, 5])
print(data)
# 获取0轴上的第一个数据
print(data[0, :, :])
# 获取1轴上的第一个数据
print(data[:, 0, :])
# 获取2轴上的第一个数据
print(data[:, :, 0])
6. 张量形状操作
reshape()函数
reshape 函数可以在保证张量数据不变的前提下改变数据的维度，将其转换成指定的形状。 
"""
1.reshape 函数可以在保证张量数据不变的前提下改变数
据的维度
"""
data = torch.tensor([[10, 20, 30], [40, 50, 60]])
# 1. 使用 shape 属性或者 size 方法都可以获得张量的形状
print(data.shape)
print(data.size)
# 2. 使用 reshape 函数修改张量形状
new_data = data.reshape(1, 6)
print(new_data)
print(new_data.shape)
squeeze()和unsqueeze()函数
squeeze 函数删除形状为 1 的维度（降维），unsqueeze 函数添加形状为1的维度（升维）。 
"""
2.squeeze 和 unsqueeze 函数可以用来减少或者增加维
度
"""
mydata1 = torch.tensor([1, 2, 3, 4, 5])
print('mydata1--->', mydata1.shape, mydata1) # 一个普通的数组 1维数据
mydata2 = mydata1.unsqueeze(dim=0)
print('在0维度上 拓展维度：', mydata2, mydata2.shape) #1*5
mydata3 = mydata1.unsqueeze(dim=1)
print('在1维度上 拓展维度：', mydata3, mydata3.shape) #5*1
mydata4 = mydata1.unsqueeze(dim=-1)
print('在-1维度上 拓展维度：', mydata4, mydata4.shape) #5*1
mydata5 = mydata4.squeeze()
print('压缩维度：', mydata5, mydata5.shape) #1*5
transpose()和permute()函数
transpose 函数可以实现交换张量形状的指定维度, 例如: 一个张量的形状为 (2, 3, 4) 可以通过 transpose 函数把 3 和4 进行交换, 将张量的形状变为 (2, 4, 3) 。 permute 函数可以一次交换更多的维度。 
"""
3.transpose 函数可以实现交换张量形状的指定维度, 
permute 可以一次交换更多的维度
"""
data = torch.tensor(np.random.randint(0, 10, [3, 4, 5]))
print(data)
print('data shape:', data.size())
# 1 交换1和2维度
mydata2 = torch.transpose(data, 1, 2)
print('mydata2.shape--->', mydata2.shape)
# 2 将data 的形状修改为 (4, 5, 3), 需要变换多次
mydata3 = torch.transpose(data, 0, 1)
mydata4 = torch.transpose(mydata3, 1, 2)
print('mydata4.shape--->', mydata4.shape)
# 3 使用 permute 函数将形状修改为 (4, 5, 3)
# 3-1 方法1
mydata5 = torch.permute(data, [1, 2, 0])
print('mydata5.shape--->', mydata5.shape)
# 3-2 方法2
mydata6 = data.permute([1, 2, 0])
print('mydata6.shape--->', mydata6.shape)
view()和contiguous()函数
view 函数也可以用于修改张量的形状，只能用于存储在整块内存中的张量。在 PyTorch 中，有些张量是由不同的数据块组成的，它们并没有存储在整块的内存中，view 函数无法对这样的张量进行变形处理。 
"""
4.view 函数也可以用于修改张量的形状, 但是它要求被转
换的张量内存必须连续，所以一般配合 contiguous 函数使
用
"""
# 1 若要使用view函数, 需要使用contiguous() 变成连续以后再使用view函数
# 2 判断张量是否使用整块内存
data = torch.tensor( [[10, 20, 30],[40, 50, 60]])
print('data--->', data, data.shape)
# 1 判断是否使用整块内存
print(data.is_contiguous()) # True
# 2 view
mydata2 = data.view(3, 2)
print('mydata2--->', mydata2, mydata2.shape)
7. 张量拼接操作
torch.cat()
torch.cat()函数可以将两个张量根据指定的维度拼接起来，不改变维度数 
import torch
"""
1.cat()函数可以将张量按照指定的维度拼接起来
"""
data1 = torch.randint(0, 10, [1, 2, 3])
data2 = torch.randint(0, 10, [1, 2, 3])
print(data1)
print(data2)
# 1. 按0维度拼接
new_data = torch.cat([data1, data2], dim=0)
print(new_data.shape)
# 2. 按1维度拼接
new_data = torch.cat([data1, data2], dim=1)
print(new_data.shape)
# 3. 按2维度拼接
new_data = torch.cat([data1, data2], dim=2)
print(new_data.shape)
8. 自动微分模块
        训练神经网络时，最常用的算法就是反向传播。在该算法中，参数（模型权重）会根据损失函数关于对应 参数的梯度进行调整。为了计算这些梯度，PyTorch内置了名为 torch.autograd 的微分引擎。它支持任 意计算图的自动梯度计算。
        
使用 backward 方法、grad 属性来实现梯度的计算和访问。 
import torch"""
1. 当X为标量时梯度的计算
"""
def test01():x = torch.tensor(5)# 目标值y = torch.tensor(0.)# 设置要更新的权重和偏置的初始值w = torch.tensor(1., requires_grad=True, dtype=torch.float32)b = torch.tensor(3., requires_grad=True, dtype=torch.float32)# 设置网络的输出值z = x * w + b  # 矩阵乘法# 设置损失函数，并进行损失的计算loss = torch.nn.MSELoss()loss = loss(z, y)# 自动微分loss.backward()# 打印 w,b 变量的梯度# backward 函数计算的梯度值会存储在张量的 grad 变量中print("W的梯度:", w.grad)print("b的梯度", b.grad)
test01()"""
2. 当X为矩阵时梯度的计算
"""
def test02():# 输入张量 2*5x = torch.ones(2,5)# 目标值是 2*3y = torch.zeros(2,3)# 设置要更新的权重和偏置的初始值w = torch.randn(5, 3,requires_grad=True)b = torch.randn(3, requires_grad=True)# 设置网络的输出值z = torch.matmul(x, w) + b # 矩阵乘法# 设置损失函数，并进行损失的计算loss = torch.nn.MSELoss()loss = loss(z, y)# 自动微分loss.backward()# 打印 w,b 变量的梯度# backward 函数计算的梯度值会存储在张量的 grad 变量中print("W的梯度:", w.grad)print("b的梯度", b.grad)
test02()
9. 案例-线性回归案例

线性回归：一种用于建立输入特征（X）与连续型输出（y）之间线性关系的监督学习模型。

模型公式：

  • w：权重（斜率），控制每个特征的影响力
  • b：偏置（截距），调整整体偏移

目标：找到最佳的 w 和 b，使预测值最接近真实值。

损失函数：用于衡量模型预测值与真实值之间的差异。

在线性回归中，常用的损失函数是均方误差（MSE），即所有样本预测值与真实值差的平方的平均值。

均方误差（MSE）公式：

梯度下降：是一种优化算法，用于找到损失函数的最小值。通过计算损失函数关于参数的梯度（导数），然后沿着梯度的反方向更新参数，逐步逼近最小值。

参数更新公式：

梯度计算（以MSE为例）：

  • 关键参数：

    • 学习率（ηη）：控制步长，过大易震荡，过小收敛慢

    • 迭代次数：决定更新轮次

线性回归，损失函数和梯度下降，三者的协同工作流程

  1. 初始化参数：随机设置 ww 和 bb 的初始值

  2. 前向传播：计算预测值 y^=wX+by^​=wX+b

  3. 损失计算：通过MSE评估预测误差

  4. 梯度计算：求损失对 ww 和 bb 的偏导数

  5. 参数更新：沿负梯度方向调整 ww 和 bb

  6. 重复2-5步：直到损失收敛或达到最大迭代次数

实例演示（房价预测）
场景：用房屋面积（xx）预测房价（yy）

  • 数据：

    面积（㎡）房价（万元）
    80320
    100400
    120480

步骤：

  1. 假设模型：

  2. 初始化：设 w=3, b=50

  3. 预测值：

    • 第一样本：

  4. 计算损失：

  5. 计算梯度：

  6. 更新参数（设 η=0.0001η=0.0001）：

在pytorch中进行模型构建的整个流程一般分为四个步骤：
  • 准备训练集数据
  • 构建要使用的模型
  • 设置损失函数和优化器
  • 模型训练

代码案例

import torch
from torch.utils.data import TensorDataset # 构造数据集对象
from torch.utils.data import DataLoader # 数据加载器
from torch import nn # nn模块中有平方损失函数和假设函数
from torch import optim # optim模块中有优化器函数
from sklearn.datasets import make_regression # 创建线性回归模型数据集
import matplotlib.pyplot as pltplt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号# 构建数据集
def create_dataset():x,y,coef=make_regression(n_samples=100,n_features=1,noise=10,coef=True,bias=1.5,random_state=0)x = torch.tensor(x)y = torch.tensor(y)return x,y,coef# 构造数据集
x, y, coef = create_dataset()
# 构造数据集对象
dataset = TensorDataset(x, y)
# 构造数据加载器
# dataset=:数据集对象
# batch_size=:批量训练样本数据
# shuffle=:样本数据是否进行乱序
dataloader = DataLoader(dataset=dataset, batch_size=16, shuffle=True)
# 构造模型
# in_features指的是输入张量的大小size
# out_features指的是输出张量的大小size
model = nn.Linear(in_features=1, out_features=1)# 损失和优化器
# 构造平方损失函数
criterion = nn.MSELoss()
# 构造优化函数
optimizer = optim.SGD(params=model.parameters(), lr=1e-2)epochs = 100
# 损失的变化
loss_epoch = []
total_loss=0.0
train_sample=0.0
for _ in range(epochs):for train_x, train_y in dataloader:# 将一个batch的训练数据送入模型y_pred = model(train_x.type(torch.float32))# 计算损失值loss = criterion(y_pred, train_y.reshape(-1, 1).type(torch.float32))total_loss += loss.item()train_sample += len(train_y)# 梯度清零optimizer.zero_grad()# 自动微分(反向传播)loss.backward()# 更新参数optimizer.step()# 获取每个batch的损失loss_epoch.append(total_loss/train_sample)# 绘制损失变化曲线
plt.plot(range(epochs), loss_epoch)
plt.title('损失变化曲线')
plt.grid()
plt.show()# 绘制拟合直线
plt.scatter(x, y)
x = torch.linspace(x.min(), x.max(), 1000)
y1 = torch.tensor([v * model.weight + model.bias for v in x])
y2 = torch.tensor([v * coef + 1.5 for v in x])
plt.plot(x, y1, label='训练')
plt.plot(x, y2, label='真实')
plt.grid()
plt.legend()
plt.show()

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

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

相关文章

Spring Cloud 中的服务注册与发现: Eureka详解

Spring Cloud 中的服务注册与发现: Eureka详解

1. 背景 1.1 问题描述 我们如果通过 RestTamplate 进行远程调用时，URL 是写死的，例如： String url "http://127.0.0.1:9090/product/" orderInfo.getProductId(); 当机器更换或者新增机器时，这个 URL 就需要相应地变…
阅读更多...
网页制作15-Javascipt时间特效の记录网页停留时间

网页制作15-Javascipt时间特效の记录网页停留时间

01效果图： 02运用： window.setTimeout（）刷新function（）函数document.forms（）：表单if条件语句window.alert（）窗口警示 03、操作代码：…
阅读更多...
C++ std::list超详细指南：基础实践（手搓list）

C++ std::list超详细指南：基础实践（手搓list）

目录 一.核心特性 1.双向循环链表结构 2.头文件：#include 3.时间复杂度 4.内存特性 二.构造函数 三.list iterator的使用 1.学习list iterator之前我们要知道iterator的区分 ​编辑 2.begin()end() 3.rbegin()rend() 四.list关键接口 1.empty() 2. size…
阅读更多...
996引擎 - 红点系统

996引擎 - 红点系统

996引擎 - 红点系统 总结NPC 红点（TXT红点）Lua 红点1. Red_Point.lua2. UI_Ex.lua参考资料以下内容是在三端 lua 环境下测试的 总结 红点系统分几个部分组成。 M2中设置变量推送。 配置红点表。 Envir\Data\cfg_redpoint.xls 2.1. UI元素中找到ID填写 ids 列。 主界面挂载…
阅读更多...
PySide(PyQt)，使用types.MethodType动态定义事件

PySide(PyQt)，使用types.MethodType动态定义事件

以PySide(PyQt)的图片项为例，比如一个视窗的场景底图是一个QGraphicsPixmapItem，需要修改它的鼠标滚轮事件，以实现鼠标滚轮缩放显示的功能。为了达到这个目的，可以重新定义一个QGraphicsPixmapItem类，并重写它的wheelE…
阅读更多...
【eNSP实战】三层交换机使用ACL实现网络安全

【eNSP实战】三层交换机使用ACL实现网络安全

拓图 要求： vlan1可以访问Internetvlan2和vlan3不能访问Internet和vlan1vlan2和vlan3之间可以互相访问PC配置如图所示，这里不展示 LSW1接口vlan配置 vlan batch 10 20 30 # interface Vlanif1ip address 192.168.40.2 255.255.255.0 # interface Vla…
阅读更多...
Unity中WolrdSpace下的UI展示在上层

Unity中WolrdSpace下的UI展示在上层

一、问题描述 Unity 中 Canvas使用World Space布局的UI，想让它不被3d物体遮挡，始终显示在上层。 二、解决方案 使用shader解决 在 UI 的材质中禁用深度测试（ZTest），强制 UI 始终渲染在最上层。 Shader "Custo…
阅读更多...
五子棋小游戏-简单开发版

五子棋小游戏-简单开发版

一、需求分析 开发一个基于 Pygame 库的五子棋小游戏，允许两名玩家在棋盘上轮流落子，当有一方达成五子连珠时游戏结束，显示获胜信息，并提供退出游戏和重新开始游戏的操作选项。 1.棋盘显示 ： 显示一个 15x15 的五子棋…
阅读更多...
小秋的矩阵

小秋的矩阵

0小秋的矩阵 - 蓝桥云课 问题描述 给你一个 n 行 m 列只包含 0 和 1 的矩阵，求它的所有子矩阵中，是方阵而且恰好包含 k 个 0 的数量。 方阵是行数和列数相等的矩阵。 子矩阵是从一个矩阵当中选取某些行和某些列交叉位置所组成的新矩阵（保…
阅读更多...
晶晨S905L3芯片_原机安卓4升级安卓9.0_通刷线刷固件包

晶晨S905L3芯片_原机安卓4升级安卓9.0_通刷线刷固件包

晶晨S905L3芯片_原机安卓4升级安卓9.0_通刷线刷固件包 线刷方法：（新手参考借鉴一下） 1、准备好一根双公头USB线刷刷机线，长度30-50CM长度最佳，同时准备一台电脑； 2、电脑上安装好刷机工具Amlogic USB Bu…
阅读更多...
谷歌Chrome或微软Edge浏览器修改网页任意内容

谷歌Chrome或微软Edge浏览器修改网页任意内容

在谷歌或微软浏览器按F12，打开开发者工具，切换到console选项卡： 在下面的输入行输入下面的命令回车： document.body.contentEditable"true"效果如下：
阅读更多...
【生日蛋糕——DFS剪枝优化】

【生日蛋糕——DFS剪枝优化】

题目 分析 代码 #include <bits/stdc.h> using namespace std;const int N 24; const int inf 0x3f3f3f3f;int mins[N], minv[N]; int R[N], H[N]; int n, m, ans inf;void dfs(int u, int v, int s) {if(v minv[u] > n) return;if(s mins[u] > ans) return;…
阅读更多...
短视频下载去水印，用什么工具好？

短视频下载去水印，用什么工具好？

去除视频和图片水印是许多用户的需求&#xff0c;尤其是在分享或保存内容时。以下是6款超好用的工具&#xff0c;帮助你轻松去除水印&#xff0c;享受纯净的视觉体验&#xff1a; 1. 易下载去水印小程序 特点&#xff1a; 操作简单&#xff0c;支持抖音、快手、小红书、哔哩哔哩…
阅读更多...
设计模式(行为型)-备忘录模式

设计模式(行为型)-备忘录模式

目录 定义 类图 角色 角色详解 &#xff08;一&#xff09;发起人角色&#xff08;Originator&#xff09;​ &#xff08;二&#xff09;备忘录角色&#xff08;Memento&#xff09;​ &#xff08;三&#xff09;备忘录管理员角色&#xff08;Caretaker&#xff09;​…
阅读更多...
【技术报告】谷歌开源多模态大模型 Gemma-3

【技术报告】谷歌开源多模态大模型 Gemma-3

【技术报告】谷歌开源多模态大模型 Gemma-3 1. Gemma-3 简介1.1 Gemma-3 的新功能1.2 与现有工作流的集成1.3 开始使用 Gemma-3 Gemma-3 技术报告&#xff1a;摘要Gemma-3 技术报告&#xff1a;1. 引言Gemma-3 技术报告&#xff1a;2. 模型架构2.1 视觉模态2.2 预训练2.3 量化感…
阅读更多...
[ISP] 人眼中的颜色

[ISP] 人眼中的颜色

相机是如何记录颜色的&#xff0c;又是如何被显示器还原的&#xff1f; 相机通过记录RGB数值然后显示器显示RGB数值来实现颜色的记录和呈现。道理是这么个道理&#xff0c;但实际上各厂家生产的相机对光的响应各不相同&#xff0c;并且不同厂家显示器对三原色的显示也天差地别&…
阅读更多...
InfiniBand可靠连接（RC）模式：设计原理、核心机制与应用实践

InfiniBand可靠连接（RC）模式：设计原理、核心机制与应用实践

引言 InfiniBand作为一种高性能网络互连技术&#xff0c;广泛应用于超算集群、分布式存储和金融交易系统等领域。其可靠连接&#xff08;Reliable Connection, RC&#xff09;模式以硬件级的有序性、可靠性和低延迟特性成为关键场景的首选。本文结合技术原理、机制对比和实际应…
阅读更多...
【网络】Caddy 服务器如何提供 TLS（Transport Layer Security）（传输层安全协议）

【网络】Caddy 服务器如何提供 TLS（Transport Layer Security）（传输层安全协议）

这张图片介绍了 Caddy 服务器如何提供 TLS&#xff08;传输层安全协议&#xff09; 支持&#xff0c;确保通信的安全性。以下是对图片内容的详细分析 1. Caddy 是什么&#xff1f; Caddy 是一个现代化的 Web 服务器&#xff0c;以其简单易用和自动化的 HTTPS 支持而闻名。它内…
阅读更多...
GHCTF web方向题解

GHCTF web方向题解

upload?SSTI! import os import refrom flask import Flask, request, jsonify,render_template_string,send_from_directory, abort,redirect from werkzeug.utils import secure_filename import os from werkzeug.utils import secure_filenameapp Flask(__name__)# 配置…
阅读更多...
《Python实战进阶》No21：数据存储：Redis 与 MongoDB 的使用场景

《Python实战进阶》No21：数据存储：Redis 与 MongoDB 的使用场景

第21集&#xff1a;数据存储&#xff1a;Redis 与 MongoDB 的使用场景 摘要 在现代应用开发中&#xff0c;数据存储的选择直接影响系统的性能、扩展性和成本。Redis 和 MongoDB 是两种极具代表性的数据库技术&#xff0c;它们分别擅长解决不同场景下的问题。本文将深入探讨 Re…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023