（三）动手学线性神经网络：从数学原理到代码实现

1 线性回归

线性回归是一种基本的预测模型，用于根据输入特征预测连续的输出值。它是机器学习和深度学习中最简单的模型之一，但却是理解更复杂模型的基础。

1.1 线性回归的基本元素

概念理解：
线性回归假设输入特征和输出之间存在线性关系。具体来说，假设有一个输入特征向量 x x x 和一个目标值 y y y，线性回归模型的目标是找到一个线性函数 f ( x ) f(x) f(x) ，使得 f ( x ) f(x) f(x)尽可能接近 y y y。

线性回归模型的基本形式为：
y ^ = X w + b \hat{y} = Xw + b y^​=Xw+b
其中：

  • X X X是输入特征矩阵，每一行表示一个样本，每一列表示一个特征。
  • w w w 是权重向量，表示每个特征的权重。
  • b b b是偏置项，是一个标量，用于调整模型的整体偏移。
  • y ^ \hat{y} y^​ 是预测值，是一个向量，表示每个样本的预测结果。

代码示例：
假设我们有一个简单的线性回归问题，输入特征是一个一维向量 X X X，目标值是一个标量 y y y。

import numpy as np
import matplotlib.pyplot as plt# 生成数据
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)# 绘制数据
plt.scatter(X, y)
plt.xlabel('X')
plt.ylabel('y')
plt.title('Generated Data')
plt.show()
1.2 向量化加速

概念理解：
向量化是一种利用矩阵和数组操作来替换显式循环的技术。它可以显著提高代码的执行效率，尤其是在现代硬件（如GPU）上。在深度学习中，向量化操作是构建高效模型的关键。

代码示例：
在上述数据生成代码中，我们使用了 NumPy 的向量化操作来生成数据。这种操作比使用循环生成数据要快得多。

1.3 正态分布与平方损失

概念理解：
线性回归通常假设误差项（即真实值与预测值之间的差异）服从正态分布。因此，线性回归常用的损失函数是均方误差（MSE），它衡量了预测值与真实值之间的平方误差。

均方误差的公式为：
[ \text{MSE} = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 ]
其中：

  • ( y_i ) 是第 ( i ) 个样本的真实值。
  • ( \hat{y}_i ) 是第 ( i ) 个样本的预测值。
  • ( n ) 是样本总数。

代码示例：
定义均方误差损失函数。

def mean_squared_error(y_true, y_pred):return ((y_true - y_pred) ** 2).mean()# 测试损失函数
y_true = np.array([3, 2, 4, 5])
y_pred = np.array([2.5, 2, 4, 5.5])
mse = mean_squared_error(y_true, y_pred)
print(f'Mean Squared Error: {mse}')
1.4 从线性回归到深度网络

概念理解：
线性回归是深度学习的一个特例，其中网络仅包含一个线性层。深度学习模型通过堆叠多个线性层和非线性激活函数来处理更复杂的数据。这些非线性激活函数（如 ReLU、Sigmoid）使得模型能够学习数据中的非线性关系。

代码示例：
构建一个简单的深度神经网络模型（包含一个隐藏层）。

import torch
import torch.nn as nn# 定义模型
class SimpleNN(nn.Module):def __init__(self):super(SimpleNN, self).__init__()self.linear1 = nn.Linear(1, 10)  # 输入特征维度为1，隐藏层维度为10self.relu = nn.ReLU()self.linear2 = nn.Linear(10, 1)  # 输出维度为1def forward(self, x):x = self.linear1(x)x = self.relu(x)x = self.linear2(x)return x# 实例化模型
model = SimpleNN()# 打印模型结构
print(model)
1.5 训练线性回归模型

概念理解：
训练线性回归模型的目标是找到最优的权重 w w w和偏置 b b b，使得损失函数（如均方误差）最小。这通常通过优化算法（如梯度下降法）来实现。

代码示例：
训练一个简单的线性回归模型。

import torch.optim as optim# 转换数据为张量
X_tensor = torch.from_numpy(X).float()
y_tensor = torch.from_numpy(y).float()# 定义模型
model = nn.Linear(1, 1)# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):# 前向传播y_pred = model(X_tensor)loss = criterion(y_pred, y_tensor)# 反向传播optimizer.zero_grad()loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')# 打印训练后的参数
print(f'Estimated weight: {model.weight.item():.2f}, Estimated bias: {model.bias.item():.2f}')
1.6 模型评估

概念理解：
评估线性回归模型的性能通常使用均方误差（MSE）或其他回归指标（如均方根误差 RMSE、平均绝对误差 MAE）。

代码示例：
评估训练后的模型性能。

# 使用训练后的模型进行预测
y_pred = model(X_tensor).detach().numpy()# 计算均方误差
mse = mean_squared_error(y, y_pred)
print(f'Mean Squared Error: {mse:.4f}')# 绘制真实值和预测值
plt.scatter(X, y, color='blue', label='True data')
plt.plot(X, y_pred, color='red', linewidth=2, label='Fitted line')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Linear Regression')
plt.legend()
plt.show()

通过上述步骤，你可以从理论和实践两个方面理解线性回归模型。线性回归是深度学习的基础，掌握它有助于你更好地理解和构建更复杂的神经网络模型。

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

2.1 生成数据集

首先生成一个简单的模拟数据集用于训练和测试我们的线性回归模型。我们假设真实模型是 y = 4 + 3 X y= 4 + 3X y=4+3X + 噪声 ，其中噪声服从正态分布。

import numpy as np# 设置随机种子以确保结果可复现
np.random.seed(42)# 生成训练数据
X_train = 2 * np.random.rand(100, 1)  # 特征
y_train = 4 + 3 * X_train + np.random.randn(100, 1)  # 目标值，包含噪声# 生成测试数据
X_test = 2 * np.random.rand(20, 1)
y_test = 4 + 3 * X_test + np.random.randn(20, 1)

2.2 数据预处理

在训练模型之前，通常需要对数据进行预处理。在这里，我们将数据转换为适合进行矩阵运算的形式。

# 数据预处理：将数据转换为矩阵形式
X_train = np.hstack((np.ones((X_train.shape[0], 1)), X_train))  # 添加偏置项
X_test = np.hstack((np.ones((X_test.shape[0], 1)), X_test))

2.3 初始化模型参数

初始化线性回归模型的权重向量。在我们这个简单例子中，权重向量包含偏置项和特征的系数。

# 初始化权重向量（包括偏置项）
theta = np.random.randn(2, 1)  # 2行1列，对应偏置和一个特征的权重

2.4 定义模型

定义线性回归模型的正向传播过程。这一步就是根据当前的权重向量计算预测值。

# 定义线性回归模型
def linear_regression(X, theta):return X.dot(theta)

2.5 定义损失函数

选择均方误差（MSE）作为损失函数，它衡量了预测值与真实值之间的差异。

# 定义均方误差损失函数
def mean_squared_error(y_true, y_pred):return np.mean((y_true - y_pred) ** 2)

2.6 定义优化算法

使用小批量随机梯度下降法（Mini-batch Gradient Descent）来优化模型参数。我们手动计算梯度并更新参数。

# 定义小批量随机梯度下降法
def minibatch_gradient_descent(X, y, theta, learning_rate, epochs, batch_size):m = len(y)for epoch in range(epochs):# 打乱数据indices = np.arange(m)np.random.shuffle(indices)X_shuffled = X[indices]y_shuffled = y[indices]# 分成小批次for i in range(0, m, batch_size):X_batch = X_shuffled[i:i+batch_size]y_batch = y_shuffled[i:i+batch_size]# 正向传播y_pred = linear_regression(X_batch, theta)# 计算梯度gradient = (2 / batch_size) * X_batch.T.dot(y_pred - y_batch)# 更新参数theta -= learning_rate * gradient# 每隔一定迭代次数打印损失if epoch % 100 == 0:y_pred = linear_regression(X, theta)loss = mean_squared_error(y, y_pred)print(f'Epoch {epoch}, Loss: {loss}')return theta

2.7 训练模型

现在开始训练模型，使用我们刚才定义的梯度下降法来优化模型参数。

# 设置超参数
learning_rate = 0.01
epochs = 1000
batch_size = 10# 训练模型
theta = minibatch_gradient_descent(X_train, y_train, theta, learning_rate, epochs, batch_size)# 输出最终的模型参数
print(f'Estimated parameters: {theta.flatten()}')

2.8 模型评估

训练完成后，我们对模型进行评估，看看它在测试集上的表现。

# 在测试集上进行预测
y_test_pred = linear_regression(X_test, theta)# 计算测试集上的损失
test_loss = mean_squared_error(y_test, y_test_pred)
print(f'Test Loss: {test_loss}')# 可视化结果
import matplotlib.pyplot as plt# 绘制训练数据和测试数据
plt.scatter(X_train[:, 1], y_train, label='Training Data')
plt.scatter(X_test[:, 1], y_test, label='Test Data')# 绘制预测线
X_plot = np.linspace(0, 2, 100).reshape(-1, 1)
X_plot = np.hstack((np.ones((X_plot.shape[0], 1)), X_plot))
y_plot_pred = linear_regression(X_plot, theta)
plt.plot(X_plot[:, 1], y_plot_pred, color='red', label='Fitted Line')plt.xlabel('X')
plt.ylabel('y')
plt.title('Linear Regression from Scratch')
plt.legend()
plt.show()

3 线性回归的简洁实现

将使用PyTorch的高级API来实现线性回归模型。这种方法更加简洁，利用了PyTorch的内置功能，减少了代码量并提高了开发效率。

3.1 生成数据集

我们继续使用之前生成的数据，但如果需要重新生成，可以使用以下代码：

import numpy as np
import torch
from torch.utils.data import TensorDataset, DataLoader# 生成数据集
np.random.seed(42)
X = 2 * np.random.rand(100, 1)  # 100个样本，每个样本1个特征
y = 4 + 3 * X + np.random.randn(100, 1)  # 真实模型 y = 3x + 4 加上一些噪声# 转换为张量
X_tensor = torch.from_numpy(X).float()
y_tensor = torch.from_numpy(y).float()# 创建数据集和数据加载器
dataset = TensorDataset(X_tensor, y_tensor)
data_loader = DataLoader(dataset, batch_size=10, shuffle=True)
3.2 定义模型

使用PyTorch的 nn.Linear 来定义线性回归模型：

import torch.nn as nn# 定义模型
model = nn.Linear(1, 1)  # 输入特征维度为1，输出维度为1
3.3 初始化模型参数

初始化模型的权重和偏置：

# 初始化参数
nn.init.normal_(model.weight, mean=0, std=0.01)
nn.init.zeros_(model.bias)
3.4 定义损失函数

使用PyTorch内置的均方误差损失函数：

# 定义损失函数
loss_fn = nn.MSELoss()
3.5 定义优化算法

使用PyTorch的 torch.optim 模块来定义优化器：

# 定义优化算法
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
3.6 训练模型

训练模型并评估性能：

# 训练模型
num_epochs = 100
for epoch in range(num_epochs):for X_batch, y_batch in data_loader:# 前向传播y_pred = model(X_batch)loss = loss_fn(y_pred, y_batch)# 反向传播optimizer.zero_grad()loss.backward()optimizer.step()if (epoch + 1) % 10 == 0:print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')print(f'Estimated weight: {model.weight.item():.2f}, Estimated bias: {model.bias.item():.2f}')
3.7 模型评估

评估训练后的模型性能，并绘制预测结果：

import matplotlib.pyplot as plt# 使用训练后的模型进行预测
X_new = torch.tensor([[0], [2]]).float()
y_predict = model(X_new).detach().numpy()# 绘制数据和预测结果
plt.scatter(X, y, color='blue', label='True data')
plt.plot(X_new.numpy(), y_predict, color='red', linewidth=2, label='Fitted line')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Linear Regression')
plt.legend()
plt.show()
3.8 完整代码

将上述代码整合在一起，可以直接运行以下代码来实现线性回归模型的简洁版：

import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader
import matplotlib.pyplot as plt# 生成数据集
np.random.seed(42)
X = 2 * np.random.rand(100, 1)  # 100个样本，每个样本1个特征
y = 4 + 3 * X + np.random.randn(100, 1)  # 真实模型 y = 3x + 4 加上一些噪声# 转换为张量
X_tensor = torch.from_numpy(X).float()
y_tensor = torch.from_numpy(y).float()# 创建数据集和数据加载器
dataset = TensorDataset(X_tensor, y_tensor)
data_loader = DataLoader(dataset, batch_size=10, shuffle=True)# 定义模型
model = nn.Linear(1, 1)  # 输入特征维度为1，输出维度为1# 初始化参数
nn.init.normal_(model.weight, mean=0, std=0.01)
nn.init.zeros_(model.bias)# 定义损失函数
loss_fn = nn.MSELoss()# 定义优化算法
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 100
for epoch in range(num_epochs):for X_batch, y_batch in data_loader:# 前向传播y_pred = model(X_batch)loss = loss_fn(y_pred, y_batch)# 反向传播optimizer.zero_grad()loss.backward()optimizer.step()if (epoch + 1) % 10 == 0:print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')print(f'Estimated weight: {model.weight.item():.2f}, Estimated bias: {model.bias.item():.2f}')# 使用训练后的模型进行预测
X_new = torch.tensor([[0], [2]]).float()
y_predict = model(X_new).detach().numpy()# 绘制数据和预测结果
plt.scatter(X, y, color='blue', label='True data')
plt.plot(X_new.numpy(), y_predict, color='red', linewidth=2, label='Fitted line')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Linear Regression')
plt.legend()
plt.show()
概念理解
  • 简洁实现：使用PyTorch的高级API（如 nn.Linear、torch.optim）可以大大减少代码量，提高开发效率。
  • 模型定义：nn.Linear 是PyTorch中定义线性层的模块，自动管理权重和偏置。
  • 损失函数：使用PyTorch内置的 MSELoss，无需手动定义。
  • 优化器：使用PyTorch的 torch.optim 模块中的优化器（如SGD），自动更新模型参数。
  • 训练过程：通过循环调用 DataLoader，自动处理数据的分批和随机打乱。

通过这种简洁实现，你可以更高效地构建和训练线性回归模型，同时利用PyTorch的强大功能来处理复杂的任务。

4 softmax回归

Softmax回归是用于多分类问题的线性模型。它通过Softmax函数将线性回归的输出转换为概率分布，从而实现多类分类。

4.1 Softmax回归的基本概念

概念理解：
Softmax回归适用于多分类问题，其中目标值是离散的类别。模型通过学习输入特征和类别之间的关系，预测每个类别的概率。

Softmax回归的模型形式为：
y ^ \hat{y} y^​= s o f t m a x softmax softmax( X W + b XW + \mathbf{b} XW+b)
其中：

  • X X X 是输入特征矩阵。
  • W W W 是权重矩阵，每一列对应一个类别的权重向量。
  • b \mathbf{b} b 是偏置向量，每个元素对应一个类别的偏置。
  • y ^ \hat{y} y^​ 是预测的类别概率分布。

Softmax函数的定义为：
softmax ( z ) i \text{softmax}(\mathbf{z})_i softmax(z)i​ = exp ⁡ ( z i ) ∑ j = 1 K exp ⁡ ( z j ) \frac{\exp(z_i)}{\sum_{j = 1}^{K} \exp(z_j)} ∑j=1K​exp(zj​)exp(zi​)​
其中：

  • z z z 是线性回归的输出。
  • K K K 是类别的总数。
  • softmax ( z ) i ) \text{softmax}(\mathbf{z})_i) softmax(z)i​) 是第 i i i 个类别的概率。
4.2 Softmax回归的从零开始实现
4.2.1 生成数据集

为了演示，我们生成一个简单的多分类数据集，假设是一个三分类问题。

import numpy as np
import matplotlib.pyplot as plt# 生成数据集
np.random.seed(42)
X = np.random.rand(300, 2)
y = np.random.randint(0, 3, 300)# 绘制数据
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='red', label='Class 0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='blue', label='Class 1')
plt.scatter(X[y == 2][:, 0], X[y == 2][:, 1], color='green', label='Class 2')
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('Generated Data')
plt.legend()
plt.show()
4.2.2 定义Softmax函数

Softmax函数将线性回归的输出转换为概率分布。

def softmax(z):exp_z = np.exp(z - np.max(z, axis=1, keepdims=True))  # 防止数值溢出return exp_z / np.sum(exp_z, axis=1, keepdims=True)
4.2.3 定义模型

Softmax回归模型的前向传播。

def model(X, W, b):return softmax(X @ W + b)
4.2.4 定义损失函数

Softmax回归使用交叉熵损失函数。

def cross_entropy_loss(y_pred, y_true):return -np.mean(np.log(y_pred[np.arange(len(y_true)), y_true]))
4.2.5 定义优化算法

使用随机梯度下降法更新模型参数。

def gradient_descent(X, y, W, b, learning_rate):y_pred = model(X, W, b)loss = cross_entropy_loss(y_pred, y)# 计算梯度m = len(X)y_one_hot = np.eye(3)[y]  # 将标签转换为one-hot编码dW = X.T @ (y_pred - y_one_hot) / mdb = np.sum(y_pred - y_one_hot, axis=0) / m# 更新参数W -= learning_rate * dWb -= learning_rate * dbreturn loss
4.2.6 训练模型

训练Softmax回归模型。

# 初始化参数
W = np.random.randn(2, 3)
b = np.zeros(3)# 训练参数
learning_rate = 0.1
num_epochs = 100# 训练过程
losses = []
for epoch in range(num_epochs):loss = gradient_descent(X, y, W, b, learning_rate)losses.append(loss)if (epoch + 1) % 10 == 0:print(f'Epoch {epoch + 1}, Loss: {loss:.4f}')# 绘制损失曲线
plt.plot(losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Loss Curve')
plt.show()
4.3 Softmax回归的简洁实现

使用PyTorch的高级API来实现Softmax回归，更加简洁高效。

4.3.1 定义模型

使用PyTorch的 nn.Linear 和 nn.Softmax 定义模型。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader# 转换为张量
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.long)# 创建数据集和数据加载器
dataset = TensorDataset(X_tensor, y_tensor)
data_loader = DataLoader(dataset, batch_size=32, shuffle=True)# 定义模型
model = nn.Sequential(nn.Linear(2, 3),  # 输入特征维度为2，输出类别数为3nn.Softmax(dim=1)  # 对输出应用Softmax函数
)# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)
4.3.2 训练模型

训练Softmax回归模型。

# 训练模型
num_epochs = 100
losses = []for epoch in range(num_epochs):for X_batch, y_batch in data_loader:# 前向传播y_pred = model(X_batch)loss = criterion(y_pred, y_batch)# 反向传播optimizer.zero_grad()loss.backward()optimizer.step()losses.append(loss.item())if (epoch + 1) % 10 == 0:print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')# 绘制损失曲线
plt.plot(losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Loss Curve')
plt.show()
4.4 模型评估

评估训练后的模型性能，计算准确率。

# 计算准确率
model.eval()  # 设置为评估模式
with torch.no_grad():y_pred = model(X_tensor)_, predicted = torch.max(y_pred, 1)accuracy = (predicted == y_tensor).sum().item() / len(y_tensor)print(f'Accuracy: {accuracy * 100:.2f}%')
4.5 完整代码

将上述代码整合在一起，可以直接运行以下代码来实现Softmax回归模型的简洁版：

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
import matplotlib.pyplot as plt### 生成数据集
np.random.seed(42)
X = np.random.rand(300, 2)
y = np.random.randint(0, 3, 300)### 转换为张量
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.long)### 创建数据集和数据加载器
dataset = TensorDataset(X_tensor, y_tensor)
data_loader = DataLoader(dataset, batch_size=32, shuffle=True)### 定义模型
model = nn.Sequential(nn.Linear(2, 3),  # 输入特征维度为2，输出类别数为3nn.Softmax(dim=1)  # 对输出应用Softmax函数
)### 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)### 训练模型
num_epochs = 100
losses = []for epoch in range(num_epochs):for X_batch, y_batch in data_loader:# 前向传播y_pred = model(X_batch)loss = criterion(y_pred, y_batch)# 反向传播optimizer.zero_grad()loss.backward()optimizer.step()losses.append(loss.item())if (epoch + 1) % 10 == 0:print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')### 绘制损失曲线
plt.plot(losses)
plt

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

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

相关文章

二十五、面向对象底层逻辑-SpringMVC九大组件之HandlerMapping接口设计

二十五、面向对象底层逻辑-SpringMVC九大组件之HandlerMapping接口设计

一、引言：MVC架构的交通枢纽 在Spring MVC框架中，HandlerMapping接口扮演着"请求导航仪"的关键角色，它决定了HTTP请求如何被路由到对应的Controller处理器。作为MVC模式的核心组件之一，HandlerMapping在请求处理的生命…
阅读更多...
凌晨四点的星光

凌晨四点的星光

凌晨四点的城市像台停止运转的老旧机器，陈明裹紧外套踩着路灯的残影往家走。键盘敲击声仿佛还在耳边回响，他揉了揉酸涩的眼睛，手机屏幕突然亮起，是妻子发来的消息：“孩子又发烧了，我带他去医院。” 这是他…
阅读更多...
Kyosan K5BMC ELECTRONIC INTERLOCKING MANUAL 电子联锁

Kyosan K5BMC ELECTRONIC INTERLOCKING MANUAL 电子联锁

Kyosan K5BMC ELECTRONIC INTERLOCKING MANUAL 电子联锁
阅读更多...
LeetCode 热题 100 74. 搜索二维矩阵

LeetCode 热题 100 74. 搜索二维矩阵

LeetCode 热题 100 | 74. 搜索二维矩阵 大家好，今天我们来解决一道经典的算法题——搜索二维矩阵。这道题在 LeetCode 上被标记为中等难度，要求我们在一个满足特定条件的二维矩阵中查找一个目标值。如果目标值在矩阵中，返回 true&#xff1b…
阅读更多...
如何在 HTML 中添加按钮

如何在 HTML 中添加按钮

原文：如何在 HTML 中添加按钮 | w3cschool笔记 （请勿将文章标记为付费！！！！） 在网页开发中，按钮是用户界面中不可或缺的元素之一。无论是用于提交表单、触发动作还是导航&#xff0…
阅读更多...
一篇文章实现Android图片拼接并保存至相册

一篇文章实现Android图片拼接并保存至相册

系列文章目录 一篇文章实现Android图片拼接并保存至相册 文章目录 系列文章目录前言实现功能类定义和成员变量onCreate方法权限检查和图片选择处理选择的图片图片拼接功能图片保存功能 使用ImageStitcher类拼接图片代码解释：ImageStitcher.java类定义和方法计算拼接…
阅读更多...
2025.06.06【Ribo-seq】|riboWaltz：P-site定位与三碱基周期性分析流程

2025.06.06【Ribo-seq】|riboWaltz：P-site定位与三碱基周期性分析流程

文章目录 一、前言二、riboWaltz简介三、安装与依赖四、分析流程总览1. 数据准备2. 典型分析流程2.1 读取注释和BAM2.2 P-site定位2.3 三碱基周期性与元分析2.4 密码子使用偏好分析 五、可视化与结果解读六、常见问题与注意事项七、实战经验与建议八、参考资料九、结语 一、前言…
阅读更多...
思维链的 内部机制和简单理解

思维链的 内部机制和简单理解

思维链的 内部机制和简单理解 思维链是对解决问题的步骤进行规划，规划后将作为上下文 在LLM中继续输出。因为Transform都是一个一个单词生成，没新生成一个单词都会将新生的作为上下文。 可以这么理解，但更准确的简化描述是： 思维链是让模型在回答问题时，先“内部生成”或…
阅读更多...
Charles 全流程指南：安装、设置、抓包与注意事项

Charles 全流程指南：安装、设置、抓包与注意事项

Charles 是一款功能强大的网络抓包工具，支持 HTTP/HTTPS 流量监控、请求/响应分析、断点调试等功能。本文将从安装到实战抓包，提供完整流程及关键注意事项。 一、安装 Charles 官网下载：访问 Charles 官网，选择对应系统版本&…
阅读更多...
全球长序列高分辨率光合有效辐射（PAR）（1984-2018）

全球长序列高分辨率光合有效辐射（PAR）（1984-2018）

时间分辨率：时空间分辨率：1km - 10km共享方式：开放获取数据大小：188.92 GB数据时间范围：1984-01-01 — 2018-12-31元数据更新时间：2022-04-29 数据集摘要 本数据集是一个包含接近35年（1984-201…
阅读更多...
【Zephyr 系列 11】使用 NVS 实现 BLE 参数持久化：掉电不丢配置，开机自动加载

【Zephyr 系列 11】使用 NVS 实现 BLE 参数持久化：掉电不丢配置，开机自动加载

🧠关键词：Zephyr、NVS、非易失存储、掉电保持、Flash、AT命令保存、配置管理 📌目标读者：希望在 BLE 模块中实现掉电不丢配置、支持产测参数注入与自动加载功能的开发者 📊文章长度：约 5200 字 🔍 为什么要使用 NVS？ 在实际产品中，我们经常面临以下场景： 用户或…
阅读更多...
解锁Java线程池：性能优化的关键

解锁Java线程池：性能优化的关键

一、引言 在 Java 并发编程的世界里，线程池是一个至关重要的概念。简单来说，线程池就是一个可以复用线程的 “池子”，它维护着一组线程，这些线程可以被重复使用来执行多个任务，而不是为每个任务都创建一个新的线程。​…
阅读更多...
一站式直播工具：助力内容创作者高效开启直播新时代

一站式直播工具：助力内容创作者高效开启直播新时代

近年来，随着互联网技术的不断进步和短视频、直播行业的爆发式增长，越来越多的企业和个人投入到直播电商、互动娱乐、在线教育等场景。直播运营过程中，涉及到数据统计、弹幕互动、流程自动化、内容同步等诸多环节。如何提升运营效率、减少人工…
阅读更多...
数论——同余问题全家桶3 __int128和同余方程组

数论——同余问题全家桶3 __int128和同余方程组

数论——同余问题全家桶3 __int128和同余方程组 快速读写和__int128快速读写__int128 中国剩余定理和线性同余方程组中国剩余定理(CRT)中国剩余定理OJ示例模板题曹冲养猪 - 洛谷模板题猜数字 - 洛谷 扩展中国剩余定理扩展中国剩余定理OJ示例模板题扩展中国剩余定理（…
阅读更多...
Python爬虫实战：研究MechanicalSoup库相关技术

Python爬虫实战：研究MechanicalSoup库相关技术

一、MechanicalSoup 库概述 1.1 库简介 MechanicalSoup 是一个 Python 库，专为自动化交互网站而设计。它结合了 requests 的 HTTP 请求能力和 BeautifulSoup 的 HTML 解析能力，提供了直观的 API，让我们可以像人类用户一样浏览网页、填写表单和提交请求。 1.2 主要功能特点…
阅读更多...
㊗️高考加油

㊗️高考加油

以下是极为详细的高考注意事项清单，涵盖考前、考中、考后全流程，建议逐条核对： 一、考前准备 1. 证件与物品 必带清单： 准考证：打印2份（1份备用），塑封或夹在透明文件袋中防皱湿。身…
阅读更多...
学习路之PHP--webman安装及使用、webman/admin安装

学习路之PHP--webman安装及使用、webman/admin安装

学习路之PHP--webman安装及使用、webman/admin安装 一、安装webman二、运行三、安装webman/admin四、效果五、配置Nginx反向代理（生产环境：可选）六、win10运行问题集七、使用 一、安装webman 准备： PHP > 8.1 Composer > 2…
阅读更多...
mamba架构和transformer区别

mamba架构和transformer区别

Mamba 架构和 Transformer 架构存在多方面的区别，具体如下： 计算复杂度1 Transformer：自注意力机制的计算量会随着上下文长度的增加呈平方级增长，例如上下文增加 32 倍时，计算量可能增长 1000 倍，在处理长序…
阅读更多...
Python爬虫实战：研究mechanize库相关技术

Python爬虫实战：研究mechanize库相关技术

1. 引言 随着互联网数据量的爆炸式增长，网络爬虫已成为数据采集和信息挖掘的重要工具。Python 作为一种功能强大且易于学习的编程语言，拥有丰富的爬虫相关库，如 Requests、BeautifulSoup、Scrapy 等。Mechanize 库作为其中的一员，特别擅长处理复杂的表单提交和会话管理，为…
阅读更多...
如何使用索引和条件批量更改Series数据

如何使用索引和条件批量更改Series数据

视频演示 如何通过索引与布尔条件修改 pandas Series？实操演示来了 一、前言：掌握Series数据修改是数据处理的基础 在使用Python进行数据分析时，Pandas库的Series对象是最常用的结构之一。在上一个视频中我们已经学习了如何创建Series对象&a…
阅读更多...
最新文章

Copyright @ 2022~2023