RNN避坑指南：从数学推导到LSTM/GRU工业级部署实战流程

news2025/6/12 9:54:08

本文较长，建议点赞收藏，以免遗失。更多AI大模型应用开发学习视频及资料，尽在聚客AI学院。

本文全面剖析RNN核心原理，深入讲解梯度消失/爆炸问题，并通过LSTM/GRU结构实现解决方案，提供时间序列预测和文本生成完整代码实现。

一、RNN基础：循环神经网络原理

1.1 RNN基本结构
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
# 手动实现RNN单元
class SimpleRNNCell:
    def __init__(self, input_size, hidden_size):
        # 权重初始化
        self.W_xh = torch.randn(input_size, hidden_size) * 0.01
        self.W_hh = torch.randn(hidden_size, hidden_size) * 0.01
        self.b_h = torch.zeros(1, hidden_size)
    
    def forward(self, x, h_prev):
        """
        x: 当前输入 (1, input_size)
        h_prev: 前一刻隐藏状态 (1, hidden_size)
        """
        # RNN核心计算
        h_next = torch.tanh(torch.mm(x, self.W_xh) + 
                           torch.mm(h_prev, self.W_hh) + 
                           self.b_h)
        return h_next
# 示例：处理序列数据
input_size = 3
hidden_size = 4
seq_length = 5
# 创建RNN单元
rnn_cell = SimpleRNNCell(input_size, hidden_size)
# 初始化隐藏状态
h = torch.zeros(1, hidden_size)
# 模拟输入序列 (5个时间步，每个时间步3维向量)
inputs = [torch.randn(1, input_size) for _ in range(seq_length)]
# 循环处理序列
hidden_states = []
for t in range(seq_length):
    h = rnn_cell.forward(inputs[t], h)
    hidden_states.append(h.detach().numpy())
    print(f"时间步 {t+1}, 隐藏状态: {h}")
# 可视化隐藏状态变化
plt.figure(figsize=(10, 6))
for i in range(hidden_size):
    plt.plot(range(1, seq_length+1), [h[0,i] for h in hidden_states], 
             label=f'隐藏单元 {i+1}')
plt.title('RNN隐藏状态随时间变化')
plt.xlabel('时间步')
plt.ylabel('隐藏状态值')
plt.legend()
plt.grid(True)
plt.show()

image.png

RNN数学原理：

image.png

RNN核心特点：

  • 时间展开：在不同时间步共享相同权重

  • 隐藏状态：传递序列历史信息

  • 参数共享：显著减少参数量

1.2 PyTorch内置RNN实现
# 使用PyTorch内置RNN
rnn = nn.RNN(input_size=3, hidden_size=4, num_layers=1, batch_first=True)
# 输入数据格式: (batch_size, seq_length, input_size)
inputs = torch.randn(1, 5, 3)  # 批量1, 序列长度5, 输入维度3
h0 = torch.zeros(1, 1, 4)      # 初始隐藏状态 (num_layers, batch_size, hidden_size)
# 前向传播
output, hn = rnn(inputs, h0)
print("输出形状:", output.shape)  # (1, 5, 4)
print("最终隐藏状态形状:", hn.shape)  # (1, 1, 4)

二、梯度消失与爆炸问题

2.1 梯度消失问题分析
# 模拟梯度消失
def simulate_vanishing_grad(seq_length=20, num_runs=100):
    # 初始化权重
    W = torch.randn(1, 1) * 0.8  # |W| < 1
    
    grad_history = []
    for _ in range(num_runs):
        # 初始化梯度
        grad = 1.0
        
        # 反向传播模拟
        for t in range(seq_length):
            grad = grad * W.item()
        
        grad_history.append(grad)
    
    return grad_history
# 模拟梯度爆炸
def simulate_exploding_grad(seq_length=20, num_runs=100):
    # 初始化权重
    W = torch.randn(1, 1) * 1.2  # |W| > 1
    
    grad_history = []
    for _ in range(num_runs):
        # 初始化梯度
        grad = 1.0
        
        # 反向传播模拟
        for t in range(seq_length):
            grad = grad * W.item()
        
        grad_history.append(grad)
    
    return grad_history
# 可视化
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
vanishing_grads = simulate_vanishing_grad()
plt.plot(vanishing_grads)
plt.title('梯度消失 (|W| < 1)')
plt.xlabel('训练样本')
plt.ylabel('梯度值')
plt.subplot(1, 2, 2)
exploding_grads = simulate_exploding_grad()
plt.plot(exploding_grads)
plt.title('梯度爆炸 (|W| > 1)')
plt.xlabel('训练样本')
plt.ylabel('梯度值')
plt.tight_layout()
plt.show()

梯度消失/爆炸原因：

  • 梯度消失：当权重矩阵特征值 < 1 时，梯度指数衰减

  • 梯度爆炸：当权重矩阵特征值 > 1 时，梯度指数增长

  • 根本原因：反向传播时梯度连乘

2.2 解决方案对比

image.png

三、LSTM：长短期记忆网络

3.1 LSTM核心结构

image.png

class LSTMCellManual:
    def __init__(self, input_size, hidden_size):
        # 输入门参数
        self.W_xi = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_hi = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_i = nn.Parameter(torch.zeros(1, hidden_size))
        
        # 遗忘门参数
        self.W_xf = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_hf = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_f = nn.Parameter(torch.zeros(1, hidden_size))
        
        # 候选记忆参数
        self.W_xc = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_hc = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_c = nn.Parameter(torch.zeros(1, hidden_size))
        
        # 输出门参数
        self.W_xo = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_ho = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_o = nn.Parameter(torch.zeros(1, hidden_size))
        
        self.hidden_size = hidden_size
    
    def forward(self, x, state):
        h_prev, c_prev = state
        
        # 输入门
        i = torch.sigmoid(x @ self.W_xi + h_prev @ self.W_hi + self.b_i)
        
        # 遗忘门
        f = torch.sigmoid(x @ self.W_xf + h_prev @ self.W_hf + self.b_f)
        
        # 候选记忆
        c_hat = torch.tanh(x @ self.W_xc + h_prev @ self.W_hc + self.b_c)
        
        # 更新细胞状态
        c_next = f * c_prev + i * c_hat
        
        # 输出门
        o = torch.sigmoid(x @ self.W_xo + h_prev @ self.W_ho + self.b_o)
        
        # 更新隐藏状态
        h_next = o * torch.tanh(c_next)
        
        return h_next, c_next
# LSTM结构可视化
plt.figure(figsize=(10, 8))
plt.imshow(plt.imread('lstm_cell.png'))  # 实际使用时替换为LSTM结构图
plt.axis('off')
plt.title('LSTM单元结构')
plt.show()

LSTM核心组件：

遗忘门：控制前一刻记忆保留程度 $f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$

输入门：控制新记忆写入程度 $i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$

候选记忆：生成新记忆内容 $\tilde{C}t = \tanh(W_C \cdot [h{t-1}, x_t] + b_C)$

细胞状态更新：$C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$

输出门：控制输出内容 $o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$

隐藏状态输出：$h_t = o_t \odot \tanh(C_t)$

3.2 PyTorch LSTM实战
# 时间序列预测：正弦波
time_steps = np.linspace(0, 50, 500)
data = np.sin(time_steps)
# 创建序列数据集
def create_dataset(seq, lookback=10):
    X, y = [], []
    for i in range(len(seq)-lookback):
        X.append(seq[i:i+lookback])
        y.append(seq[i+lookback])
    return np.array(X), np.array(y)
lookback = 20
X, y = create_dataset(data, lookback)
X = X.reshape(-1, lookback, 1)  # (样本数, 时间步, 特征数)
y = y.reshape(-1, 1)
# 转换为PyTorch张量
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32)
# 定义LSTM模型
class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_size=64, output_size=1):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.linear = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        # LSTM层
        out, (h_n, c_n) = self.lstm(x)  # out: (batch, seq, hidden)
        
        # 只取最后一个时间步
        out = self.linear(out[:, -1, :])
        return out
# 训练配置
model = LSTMModel()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
# 训练循环
epochs = 100
losses = []
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)
    loss.backward()
    optimizer.step()
    losses.append(loss.item())
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.6f}')
# 可视化训练损失
plt.plot(losses)
plt.title('LSTM训练损失')
plt.xlabel('Epoch')
plt.ylabel('MSE Loss')
plt.grid(True)
plt.show()
# 预测结果可视化
with torch.no_grad():
    predictions = model(X_tensor).numpy()
plt.figure(figsize=(12, 6))
plt.plot(time_steps[lookback:], data[lookback:], label='真实值')
plt.plot(time_steps[lookback:], predictions, label='预测值', alpha=0.7)
plt.title('LSTM时间序列预测')
plt.legend()
plt.grid(True)
plt.show()

四、GRU：门控循环单元

5a147a75-0c4c-431b-b464-88d2971a4700.jpg

4.1 GRU结构解析
class GRUCellManual:
    def __init__(self, input_size, hidden_size):
        # 更新门参数
        self.W_xz = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_hz = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_z = nn.Parameter(torch.zeros(1, hidden_size))
        
        # 重置门参数
        self.W_xr = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_hr = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_r = nn.Parameter(torch.zeros(1, hidden_size))
        
        # 候选激活参数
        self.W_xh = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_hh = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_h = nn.Parameter(torch.zeros(1, hidden_size))
        
        self.hidden_size = hidden_size
    
    def forward(self, x, h_prev):
        # 更新门
        z = torch.sigmoid(x @ self.W_xz + h_prev @ self.W_hz + self.b_z)
        
        # 重置门
        r = torch.sigmoid(x @ self.W_xr + h_prev @ self.W_hr + self.b_r)
        
        # 候选激活
        h_hat = torch.tanh(x @ self.W_xh + (r * h_prev) @ self.W_hh + self.b_h)
        
        # 更新隐藏状态
        h_next = (1 - z) * h_prev + z * h_hat
        
        return h_next
# GRU结构可视化
plt.figure(figsize=(8, 6))
plt.imshow(plt.imread('gru_cell.png'))  # 实际使用时替换为GRU结构图
plt.axis('off')
plt.title('GRU单元结构')
plt.show()

GRU核心组件：

更新门：控制状态更新程度 $z_t = \sigma(W_z \cdot [h_{t-1}, x_t])$

重置门：控制历史信息重置程度 $r_t = \sigma(W_r \cdot [h_{t-1}, x_t])$

候选激活：$\tilde{h}t = \tanh(W \cdot [r_t \odot h{t-1}, x_t])$

状态更新：$h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t$

LSTM vs GRU对比：

image.png

4.2 GRU文本生成实战
# 文本数据预处理
text = "循环神经网络是处理序列数据的强大模型。"
chars = sorted(set(text))
char_to_idx = {ch: i for i, ch in enumerate(chars)}
idx_to_char = {i: ch for i, ch in enumerate(chars)}
# 创建训练数据
seq_length = 10
sequences = []
next_chars = []
for i in range(0, len(text) - seq_length):
    seq = text[i:i + seq_length]
    next_char = text[i + seq_length]
    sequences.append([char_to_idx[ch] for ch in seq])
    next_chars.append(char_to_idx[next_char])
# 转换为张量
X = torch.tensor(sequences, dtype=torch.long)
y = torch.tensor(next_chars, dtype=torch.long)
# 定义GRU模型
class GRUTextGenerator(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_size):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.gru = nn.GRU(embedding_dim, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, vocab_size)
    
    def forward(self, x, h=None):
        # 嵌入层
        x = self.embedding(x)
        
        # GRU层
        if h is None:
            out, h = self.gru(x)
        else:
            out, h = self.gru(x, h)
        
        # 全连接层
        out = self.fc(out[:, -1, :])  # 取最后一个时间步
        return out, h
    
    def generate(self, start_str, length=100, temperature=0.8):
        # 初始化隐藏状态
        h = None
        input_seq = [char_to_idx[ch] for ch in start_str]
        generated_chars = list(start_str)
        
        # 生成文本
        for _ in range(length):
            x = torch.tensor([input_seq[-seq_length:]], dtype=torch.long)
            logits, h = self.forward(x, h)
            
            # 应用温度参数
            logits = logits / temperature
            probs = nn.functional.softmax(logits, dim=-1)
            
            # 采样下一个字符
            next_idx = torch.multinomial(probs, 1).item()
            next_char = idx_to_char[next_idx]
            
            generated_chars.append(next_char)
            input_seq.append(next_idx)
        
        return ''.join(generated_chars)
# 训练配置
vocab_size = len(chars)
embedding_dim = 32
hidden_size = 128
model = GRUTextGenerator(vocab_size, embedding_dim, hidden_size)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.005)
# 训练循环
epochs = 500
for epoch in range(epochs):
    optimizer.zero_grad()
    output, _ = model(X)
    loss = criterion(output, y)
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 50 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
        
        # 示例文本生成
        generated = model.generate("循环神经", length=20)
        print(f"生成文本: {generated}")
# 最终文本生成
print("\n最终生成结果:")
print(model.generate("神经网络", length=100, temperature=0.7))

五、RNN应用场景与变体

5.1 RNN典型应用领域

image.png

5.2 RNN高级变体
双向RNN：
bidirectional_rnn = nn.RNN(input_size=10, hidden_size=16, 
                          bidirectional=True, batch_first=True)

  • 同时考虑过去和未来信息

  • 适用于需要上下文理解的任务

深度RNN：

deep_rnn = nn.RNN(input_size=10, hidden_size=16, 
                 num_layers=3, batch_first=True)

Attention机制：

class AttentionRNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super().__init__()
        self.rnn = nn.GRU(input_size, hidden_size, batch_first=True)
        self.attention = nn.Linear(hidden_size * 2, 1)
        self.fc = nn.Linear(hidden_size, 1)
    
    def forward(self, x):
        outputs, _ = self.rnn(x)  # (batch, seq, hidden)
        
        # 注意力机制
        seq_len = outputs.size(1)
        hidden_repeat = outputs[:, -1:, :].repeat(1, seq_len, 1)
        attention_input = torch.cat((outputs, hidden_repeat), dim=2)
        attention_scores = torch.softmax(self.attention(attention_input), dim=1)
        context = torch.sum(attention_scores * outputs, dim=1)
        
        return self.fc(context)

  • 动态关注重要时间步

  • 提升长序列处理能力

关键要点总结

RNN核心公式：

image.png

梯度问题解决方案：

graph LR
A[梯度消失/爆炸] --> B[梯度裁剪]
A --> C[权重初始化]
A --> D[ReLU激活]
A --> E[LSTM/GRU]
A --> F[残差连接]

LSTM/GRU选择指南：

image.png

RNN训练最佳实践：

使用梯度裁剪防止爆炸：nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

  • 选择合适的序列长度（不宜过长）

  • 使用双向RNN获取上下文信息

  • 结合注意力机制提升性能

  • 使用学习率调度器优化训练

通过掌握RNN、LSTM和GRU的原理与实践，你已具备处理序列数据的基础能力。下一步可探索Transformer架构、注意力机制等更先进的序列建模技术！更多AI大模型应用开发学习视频内容及资料，尽在聚客AI学院。

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

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

相关文章

学习STC51单片机32（芯片为STC89C52RCRC）OLED显示屏2

学习STC51单片机32（芯片为STC89C52RCRC）OLED显示屏2

每日一言 今天的每一份坚持&#xff0c;都是在为未来积攒底气。 案例&#xff1a;OLED显示一个A 这边观察到一个点&#xff0c;怎么雪花了就是都是乱七八糟的占满了屏幕。。 解释 &#xff1a; 如果代码里信号切换太快&#xff08;比如 SDA 刚变&#xff0c;SCL 立刻变&#…
阅读更多...
3-11单元格区域边界定位(End属性)学习笔记

3-11单元格区域边界定位(End属性)学习笔记

返回一个Range 对象&#xff0c;只读。该对象代表包含源区域的区域上端下端左端右端的最后一个单元格。等同于按键 End 向上键(End(xlUp))、End向下键(End(xlDown))、End向左键(End(xlToLeft)End向右键(End(xlToRight)) 注意&#xff1a;它移动的位置必须是相连的有内容的单元格…
阅读更多...
蓝桥杯3498 01串的熵

蓝桥杯3498 01串的熵

问题描述 对于一个长度为 23333333的 01 串, 如果其信息熵为 11625907.5798&#xff0c; 且 0 出现次数比 1 少, 那么这个 01 串中 0 出现了多少次? #include<iostream> #include<cmath> using namespace std;int n 23333333;int main() {//枚举 0 出现的次数//因…
阅读更多...
什么是Ansible Jinja2

什么是Ansible Jinja2

理解 Ansible Jinja2 模板 Ansible 是一款功能强大的开源自动化工具&#xff0c;可让您无缝地管理和配置系统。Ansible 的一大亮点是它使用 Jinja2 模板&#xff0c;允许您根据变量数据动态生成文件、配置设置和脚本。本文将向您介绍 Ansible 中的 Jinja2 模板&#xff0c;并通…
阅读更多...
优选算法第十二讲：队列 + 宽搜 优先级队列

优选算法第十二讲：队列 + 宽搜 优先级队列

优选算法第十二讲&#xff1a;队列 宽搜 && 优先级队列 1.N叉树的层序遍历2.二叉树的锯齿型层序遍历3.二叉树最大宽度4.在每个树行中找最大值5.优先级队列 -- 最后一块石头的重量6.数据流中的第K大元素7.前K个高频单词8.数据流的中位数 1.N叉树的层序遍历 2.二叉树的锯…
阅读更多...
项目部署到Linux上时遇到的错误（Redis，MySQL，无法正确连接，地址占用问题）

项目部署到Linux上时遇到的错误（Redis，MySQL，无法正确连接，地址占用问题）

Redis无法正确连接 在运行jar包时出现了这样的错误 查询得知问题核心在于Redis连接失败&#xff0c;具体原因是客户端发送了密码认证请求&#xff0c;但Redis服务器未设置密码 1.为Redis设置密码&#xff08;匹配客户端配置&#xff09; 步骤&#xff1a; 1&#xff09;.修…
阅读更多...
智能分布式爬虫的数据处理流水线优化：基于深度强化学习的数据质量控制

智能分布式爬虫的数据处理流水线优化：基于深度强化学习的数据质量控制

在数字化浪潮席卷全球的今天&#xff0c;数据已成为企业和研究机构的核心资产。智能分布式爬虫作为高效的数据采集工具&#xff0c;在大规模数据获取中发挥着关键作用。然而&#xff0c;传统的数据处理流水线在面对复杂多变的网络环境和海量异构数据时&#xff0c;常出现数据质…
阅读更多...
OPenCV CUDA模块图像处理-----对图像执行 均值漂移滤波（Mean Shift Filtering）函数meanShiftFiltering()

OPenCV CUDA模块图像处理-----对图像执行 均值漂移滤波（Mean Shift Filtering）函数meanShiftFiltering()

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 在 GPU 上对图像执行 均值漂移滤波&#xff08;Mean Shift Filtering&#xff09;&#xff0c;用于图像分割或平滑处理。 该函数将输入图像中的…
阅读更多...
AI书签管理工具开发全记录（十九）：嵌入资源处理

AI书签管理工具开发全记录（十九）：嵌入资源处理

1.前言 &#x1f4dd; 在上一篇文章中&#xff0c;我们完成了书签的导入导出功能。本篇文章我们研究如何处理嵌入资源&#xff0c;方便后续将资源打包到一个可执行文件中。 2.embed介绍 &#x1f3af; Go 1.16 引入了革命性的 embed 包&#xff0c;彻底改变了静态资源管理的…
阅读更多...
分布式增量爬虫实现方案

分布式增量爬虫实现方案

之前我们在讨论的是分布式爬虫如何实现增量爬取。增量爬虫的目标是只爬取新产生或发生变化的页面&#xff0c;避免重复抓取&#xff0c;以节省资源和时间。 在分布式环境下&#xff0c;增量爬虫的实现需要考虑多个爬虫节点之间的协调和去重。 另一种思路&#xff1a;将增量判…
阅读更多...
Maven 概述、安装、配置、仓库、私服详解

Maven 概述、安装、配置、仓库、私服详解

目录 1、Maven 概述 1.1 Maven 的定义 1.2 Maven 解决的问题 1.3 Maven 的核心特性与优势 2、Maven 安装 2.1 下载 Maven 2.2 安装配置 Maven 2.3 测试安装 2.4 修改 Maven 本地仓库的默认路径 3、Maven 配置 3.1 配置本地仓库 3.2 配置 JDK 3.3 IDEA 配置本地 Ma…
阅读更多...
Mac下Android Studio扫描根目录卡死问题记录

Mac下Android Studio扫描根目录卡死问题记录

环境信息 操作系统: macOS 15.5 (Apple M2芯片)Android Studio版本: Meerkat Feature Drop | 2024.3.2 Patch 1 (Build #AI-243.26053.27.2432.13536105, 2025年5月22日构建) 问题现象 在项目开发过程中&#xff0c;提示一个依赖外部头文件的cpp源文件需要同步&#xff0c;点…
阅读更多...
dify打造数据可视化图表

dify打造数据可视化图表

一、概述 在日常工作和学习中&#xff0c;我们经常需要和数据打交道。无论是分析报告、项目展示&#xff0c;还是简单的数据洞察&#xff0c;一个清晰直观的图表&#xff0c;往往能胜过千言万语。 一款能让数据可视化变得超级简单的 MCP Server&#xff0c;由蚂蚁集团 AntV 团队…
阅读更多...
使用 Streamlit 构建支持主流大模型与 Ollama 的轻量级统一平台

使用 Streamlit 构建支持主流大模型与 Ollama 的轻量级统一平台

🎯 使用 Streamlit 构建支持主流大模型与 Ollama 的轻量级统一平台 📌 项目背景 随着大语言模型（LLM）的广泛应用，开发者常面临多个挑战： 各大模型（OpenAI、Claude、Gemini、Ollama）接口风格不统一；缺乏一个统一平台进行模型调用与测试；本地模型 Ollama 的集成与前…
阅读更多...
Unity | AmplifyShaderEditor插件基础（第七集：平面波动shader）

Unity | AmplifyShaderEditor插件基础（第七集：平面波动shader）

目录 一、&#x1f44b;&#x1f3fb;前言 二、&#x1f608;sinx波动的基本原理 三、&#x1f608;波动起来 1.sinx节点介绍 2.vertexPosition 3.集成Vector3 a.节点Append b.连起来 4.波动起来 a.波动的原理 b.时间节点 c.sinx的处理 四、&#x1f30a;波动优化…
阅读更多...
企业如何增强终端安全？

企业如何增强终端安全？

在数字化转型加速的今天&#xff0c;企业的业务运行越来越依赖于终端设备。从员工的笔记本电脑、智能手机&#xff0c;到工厂里的物联网设备、智能传感器&#xff0c;这些终端构成了企业与外部世界连接的 “神经末梢”。然而&#xff0c;随着远程办公的常态化和设备接入的爆炸式…
阅读更多...
GC1808高性能24位立体声音频ADC芯片解析

GC1808高性能24位立体声音频ADC芯片解析

1. 芯片概述 GC1808是一款24位立体声音频模数转换器&#xff08;ADC&#xff09;&#xff0c;支持8kHz~96kHz采样率&#xff0c;集成Δ-Σ调制器、数字抗混叠滤波器和高通滤波器&#xff0c;适用于高保真音频采集场景。 2. 核心特性 高精度&#xff1a;24位分辨率&#xff0c…
阅读更多...
有限自动机到正规文法转换器v1.0

有限自动机到正规文法转换器v1.0

1 项目简介 这是一个功能强大的有限自动机&#xff08;Finite Automaton, FA&#xff09;到正规文法&#xff08;Regular Grammar&#xff09;转换器&#xff0c;它配备了一个直观且完整的图形用户界面&#xff0c;使用户能够轻松地进行操作和观察。该程序基于编译原理中的经典…
阅读更多...
均衡后的SNRSINR

均衡后的SNRSINR

本文主要摘自参考文献中的前两篇&#xff0c;相关文献中经常会出现MIMO检测后的SINR不过一直没有找到相关数学推到过程&#xff0c;其中文献[1]中给出了相关原理在此仅做记录。 1. 系统模型 复信道模型 n t n_t nt​ 根发送天线&#xff0c; n r n_r nr​ 根接收天线的 MIMO 系…
阅读更多...
Linux --进程控制

Linux --进程控制

本文从以下五个方面来初步认识进程控制&#xff1a; 目录 进程创建 进程终止 进程等待 进程替换 模拟实现一个微型shell 进程创建 在Linux系统中我们可以在一个进程使用系统调用fork()来创建子进程&#xff0c;创建出来的进程就是子进程&#xff0c;原来的进程为父进程。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023