当前位置：首页 > news >正文

深度学习实战：案例解析

news 来源：原创 2025/6/28 11:19:50

深度学习自我学习实践

以下是关于深度学习自我学习实践的100个实用案例分类整理，涵盖基础到进阶的应用场景，帮助系统性学习：

基础理论与工具

使用TensorFlow/PyTorch实现线性回归预测房价

PyTorch和Rust（通过tch-rs绑定）

以下是一个使用PyTorch和Rust（通过tch-rs绑定）进行房价回归预测的实例Demo，分为Python部分和Rust部分：

Python版（PyTorch）

import torch
import torch.nn as nn
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import StandardScaler# 加载数据
data = fetch_california_housing()
X, y = data.data, data.target# 数据标准化
scaler = StandardScaler()
X = scaler.fit_transform(X)
y = y.reshape(-1, 1)# 转换为Tensor
X_tensor = torch.FloatTensor(X)
y_tensor = torch.FloatTensor(y)# 定义模型
model = nn.Sequential(nn.Linear(X.shape[1], 32),nn.ReLU(),nn.Linear(32, 1)
)# 训练配置
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)# 训练循环
for epoch in range(100):optimizer.zero_grad()outputs = model(X_tensor)loss = criterion(outputs, y_tensor)loss.backward()optimizer.step()if epoch % 10 == 0:print(f'Epoch {epoch}, Loss: {loss.item():.4f}')# 预测示例
sample = X_tensor[0:1]
pred = model(sample)
print(f"Predicted: {pred.item():.2f}, Actual: {y[0][0]:.2f}")

Rust版（tch-rs）

use tch::{nn, nn::Module, Tensor};fn main() {// 模拟数据 (实际应用中需加载真实数据)let features = 8; // 加州房价数据集特征数let samples = 100;let x_train = Tensor::randn(&[samples, features], (tch::Kind::Float, tch::Device::Cpu));let y_train = Tensor::randn(&[samples, 1], (tch::Kind::Float, tch::Device::Cpu));// 定义模型let vs = nn::VarStore::new(tch::Device::Cpu);let model = nn::seq().add(nn::linear(&vs.root(), features, 32, Default::default())).add_fn(|x| x.relu()).add(nn::linear(&vs.root(), 32, 1, Default::default()));// 训练配置let mut opt = nn::Adam::default().build(&vs, 0.01).unwrap();// 训练循环for epoch in 1..=100 {let loss = model.forward(&x_train).mse_loss(&y_train, tch::Reduction::Mean);opt.backward_step(&loss);if epoch % 10 == 0 {println!("Epoch {:4}, Loss: {:.4}", epoch, f64::from(loss));}}// 预测示例let sample = x_train.narrow(0, 0, 1);let pred = model.forward(&sample);println!("Predicted: {:.2}", f64::from(pred));
}

关键说明

数据准备

Python版使用sklearn的加州房价数据集
Rust版需手动加载数据或使用第三方库如ndarray

上海2024年房价回归预测

以下是一个使用PyTorch和Rust（通过PyTorch的C++ API）进行上海2024年房价回归预测的示。示例分为两部分：Python端模型训练和Rust端推理部署。

Python端：PyTorch模型训练

import torch
import torch.nn as nn
import numpy as np
from sklearn.preprocessing import StandardScaler# 假设的上海房价数据集（年份, 人口, GDP, 房价）
data = np.array([[2010, 2301.9, 1.72, 2.1],[2015, 2415.2, 2.53, 3.8],[2020, 2487.0, 3.87, 5.5],[2021, 2490.0, 4.32, 6.1],[2022, 2475.0, 4.42, 6.3],[2023, 2480.0, 4.60, 6.5] #这里可以修改为读取csv文件，准备更多数据
])# 数据预处理
X = data[:, :-1]  # 特征：年份, 人口(万), GDP(万亿)
y = data[:, -1:]  # 标签：房价(万/平米)scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)# 转换为Tensor
X_tensor = torch.FloatTensor(X_scaled)
y_tensor = torch.FloatTensor(y)# 定义模型
class HousePriceModel(nn.Module):def __init__(self):super().__init__()self.linear = nn.Linear(3, 1)def forward(self, x):return self.linear(x)model = HousePriceModel()
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 训练
for epoch in range(1000):optimizer.zero_grad()outputs = model(X_tensor)loss = criterion(outputs, y_tensor)loss.backward()optimizer.step()# 保存模型和scaler参数
torch.save(model.state_dict(), 'house_price_model.pth')
np.save('scaler_mean.npy', scaler.mean_)
np.save('scaler_scale.npy', scaler.scale_)

Rust端：模型推理

use tch::{Tensor, nn, Device};
use numpy::{ndarray::Array1, PyArray};
use pyo3::{Python, PyResult};// 加载模型结构
fn load_model() -> nn::Linear {let vs = nn::VarStore::new(Device::Cpu);let linear = nn::linear(vs.root(), 3, 1, nn::LinearConfig::default());vs.load("house_price_model.pth").unwrap();linear
}// 预测函数
fn predict(year: f32, population: f32, gdp: f32) -> PyResult<f32> {// 加载scaler参数（实际应用中需从文件加载）let mean = Array1::from_vec(vec![2018.0, 2441.5, 3.58]); // 示例均值let scale = Array1::from_vec(vec![4.0, 60.0, 1.0]); // 示例标准差// 数据标准化let x = Tensor::of_slice(&[(year - mean[0]) / scale[0],(population - mean[1]) / scale[1],(gdp - mean[2]) / scale[2],]);let model = load_model();let prediction = model.forward(&x);Ok(prediction.double_value(&[]))
}// Python接口
#[pyfunction]
fn predict_price(_py: Python, year: f32, population: f32, gdp: f32) -> PyResult<f32> {predict(year, population, gdp)
}

使用方法

训练模型
运行Python脚本生成模型文件house_price_model.pth和标准化参数。
Rust部署
编译Rust项目为动态库，通过PyO3暴露接口给Python调用：
```
[lib]
name = "price_predictor"
crate-type = ["cdylib"]
```

预测2024年房价

import price_predictor
predicted_price = price_predictor.predict_price(2024.0, 2500.0, 5.0)
print(f"Predicted 2024 Shanghai price: {predicted_price:.2f}万/平米")

注意事项

实际数据需替换为真实上海房价数据集（如链家、统计局数据）。
标准化参数需与Python训练时完全一致。
更复杂场景建议使用LibTorch的C++ API直接集成。

上海2025年房价回归预测

以下是一个使用Rust进行上海2025年房价回归预测的简化示例框架，结合线性回归模型和可能的特征工程步骤。示例假设使用历史房价数据（需自行准备或模拟）。

数据准备

use csv::Reader;
use std::error::Error;struct HousingData {year: f32,      // 年份（如2020）price: f32,     // 平均房价（元/平米）gdp: f32,       // 上海GDP（可选特征）population: f32 // 人口数（可选特征）
}fn load_data(path: &str) -> Result<Vec<HousingData>, Box<dyn Error>> {let mut reader = Reader::from_path(path)?;let mut data = Vec::new();for record in reader.deserialize() {let record: HousingData = record?;data.push(record);}Ok(data)
}

特征处理与模型训练

使用linfa库实现线性回归：

use linfa::Dataset;
use linfa_linear::LinearRegression;fn train_model(data: Vec<HousingData>) -> LinearRegression<f32> {let features: Vec<_> = data.iter().map(|d| vec![d.year, d.gdp, d.population]).collect();let targets: Vec<_> = data.iter().map(|d| d.price).collect();let dataset = Dataset::new(features, targets);LinearRegression::default().fit(&dataset).unwrap()
}

预测2025年房价

fn predict_2025(model: &LinearRegression<f32>) -> f32 {// 假设2025年GDP和人口数据（需替换为实际预测值）let input = vec![2025.0, 45000.0 /*GDP*/, 25.0 /*人口（百万）*/];model.predict(&input).unwrap()
}

完整流程示例

fn main() -> Result<(), Box<dyn Error>> {let data = load_data("shanghai_housing.csv")?;let model = train_model(data);let predicted_price = predict_2025(&model);println!("预测2025年上海房价: {:.2} 元/平米", predicted_price);Ok(())
}

注意事项

实际数据需包含历史年份（如2010-2023）的房价及相关经济指标
需安装依赖：linfa = "0.7", linfa-linear = "0.7", csv = "1.2"
更复杂场景可考虑：
- 时间序列特征（ARIMA/LSTM）
- 特征缩放（标准化）
- 交叉验证评估模型

示例假设线性关系，实际应用中可能需要尝试多项式回归或其它算法。经济指标预测需结合外部数据源。

Rust语言实现一个简单的自动编毛衣程序

以下是使用Rust语言实现一个简单的“自动编毛衣程序”的示例框架。该示例通过生成针织图案的数学模型并输出指令，模拟自动化编织过程。需要注意的是，实际工业应用需结合硬件控制，这里仅展示软件逻辑。

数据结构设计

定义编织图案的基础数据结构，包括针脚类型、行列数和颜色编码：

#[derive(Debug, Clone, Copy)]
enum Stitch {Knit,    // 下针Purl,    // 上针YarnOver, // 空针（加针）
}struct KnittingPattern {rows: usize,cols: usize,stitches: Vec<Vec<Stitch>>,color_codes: Vec<Vec<u32>>, // 可选：多色编织
}

图案生成算法

实现基础图案生成逻辑，例如生成平针或麻花花样：

impl KnittingPattern {fn generate_plain_stitch(rows: usize, cols: usize) -> Self {let stitches = vec![vec![Stitch::Knit; cols]; rows];KnittingPattern {rows,cols,stitches,color_codes: vec![vec![0; cols]; rows],}}fn generate_cable_stitch(&mut self, twist_pos: usize) {// 模拟麻花针：交换针脚位置for row in (0..self.rows).step_by(4) {if twist_pos + 1 < self.cols {self.stitches[row][twist_pos] = Stitch::Purl;self.stitches[row + 1][twist_pos + 1] = Stitch::Knit;}}}
}

指令输出

将图案转换为机器可读的编织指令（模拟格式）：

fn export_to_instructions(pattern: &KnittingPattern) -> Vec<String> {pattern.stitches.iter().enumerate().map(|(i, row)| {format!("Row {}: {}",i + 1,row.iter().map(|stitch| match stitch {Stitch::Knit => "K",Stitch::Purl => "P",Stitch::YarnOver => "YO",}).collect::<Vec<_>>().join(" "))}).collect()
}

示例调用

生成一个10行20列的平针织物并添加麻花花样：

fn main() {let mut pattern = KnittingPattern::generate_plain_stitch(10, 20);pattern.generate_cable_stitch(5); // 在第5针位置添加麻花let instructions = export_to_instructions(&pattern);instructions.iter().for_each(|line| println!("{}", line));
}

扩展方向

硬件集成：通过串口通信控制编织机（需使用serialport库）。
图形化预览：用egui或piston库渲染图案可视化。
高级算法：实现自适应图案生成，如根据尺寸自动计算针数。

注意：实际工业级应用需结合具体编织机API和纱线张力控制等物理参数。

差异点

Rust通过tch-rs调用LibTorch的C++后端
Rust需显式管理变量存储（VarStore）
损失计算需指定Reduction模式

扩展建议

添加数据预处理流水线
实现自定义Dataset加载器
添加验证集评估
模型保存/加载功能

注意：Rust实际运行需配置Cargo.toml依赖：

[dependencies]
tch = "0.13"

MNIST手写数字识别全连接网络构建
用Keras搭建第一个CNN网络
数据增强技术在图像分类中的应用
学习率调度器的对比实验

使用Rust实现机器人自动编织毛衣

Rust语言因其高性能和安全性，非常适合用于控制硬件设备如编织机器人。以下是实现自动编织毛衣的关键步骤。

硬件准备

编织机或机器人平台：选择支持API或GPIO控制的硬件，如Brother KH-930编织机或开源3D打印编织机器人。
传感器：安装张力传感器、线轴检测传感器确保编织过程稳定。
Rust兼容接口：使用Rust的gpio-cdev或rppal库控制树莓派GPIO，或通过串口通信（serialport库）与商业编织机交互。

软件架构

// 示例：串口控制指令发送
use serialport::{SerialPort, SerialPortSettings};
let port = serialport::new("/dev/ttyUSB0", 9600).open().expect("Failed to open port");
port.write(b"KNIT:ROW=1,PATTERN=K10P5\n").unwrap();

编织逻辑实现

模式解析：将毛衣设计图转换为机器指令。例如，平针为K，反针为P，用二维数组表示每行针法：
```
let pattern = vec![vec!['K'; 10], // 第1行10针平针vec!['P'; 10], // 第2行10针反针
];
```
错误恢复：通过传感器数据实时检测断线或卡针，调用emergency_stop()函数暂停机器：
```
fn check_tension(sensor_value: f32) -> bool {sensor_value < MIN_TENSION || sensor_value > MAX_TENSION
}
```