神经网络与PyTorch入门

import numpy as np
def neuron(x, w, b):
    z = np.dot(x, w) + b          # 加权求和 + 偏置
    return 1 if z > 0 else 0      # 阶跃激活

x = np.array([2, 1])              # 输入信号
w = np.array([0.5, -1.0])        # 权重
print("输出：", neuron(x, w, b=0.0))

import numpy as np
w, lr = 5.0, 0.1                  # 起点、步长
for step in range(10):
    grad = 2 * w                  # f(w)=w² 的梯度
    w = w - lr * grad             # 朝下坡走一步
    print(f"第{step+1}步: w = {w:.3f}")
print("山谷（最优点）在 w = 0")

import torch
x = torch.tensor(3.0, requires_grad=True)   # 开启求导
y = x ** 2 + 2 * x                          # y = x² + 2x
y.backward()                                # 自动算梯度
print("y 对 x 的梯度：", x.grad)             # 2x+2 在 x=3 处

import torch.nn as nn
net = nn.Sequential(
    nn.Linear(2, 4), nn.ReLU(),     # 隐藏层
    nn.Linear(4, 1), nn.Sigmoid())  # 输出层

X = torch.tensor([[0.,0.],[0.,1.],[1.,0.],[1.,1.]])
y = torch.tensor([[0.],[1.],[1.],[0.]])
loss_fn = nn.BCELoss()
opt = torch.optim.Adam(net.parameters(), lr=0.01)
for i in range(2000):              # 训练 2000 步
    opt.zero_grad()                # ① 清梯度
    pred = net(X)                  # ② 前向
    loss = loss_fn(pred, y)        # ③ 算损失
    loss.backward()                # ④ 反向
    opt.step()                     # ⑤ 更新
print("预测：", net(X).flatten().round())

import torch, torch.nn as nn
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Flatten(),
            nn.Linear(784, 128), nn.ReLU(),
            nn.Linear(128, 10))          # 10 个数字类别
    def forward(self, x):
        return self.net(x)

model = Net()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
# for X, y in train_loader:            # DataLoader 小批量喂
#     opt.zero_grad()
#     loss = loss_fn(model(X), y)
#     loss.backward(); opt.step()
print("训练后可达 97%+ 准确率")

import torch.nn as nn
cnn = nn.Sequential(
    nn.Conv2d(1, 32, 3, padding=1),  # 卷积：提局部特征
    nn.ReLU(),
    nn.MaxPool2d(2),                 # 池化：特征减半抗位移
    nn.Conv2d(32, 64, 3, padding=1), # 越往后特征越高级
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),         # 全局池化
    nn.Flatten(),
    nn.Linear(64, 10))               # 输出 10 类
# 输入 (批, 1通道, 28, 28) → 输出 (批, 10)

# 1998 年识别手写数字的网络，CNN 鼻祖
# 卷积(提特征) → 池化(压缩) → 全连接(做判断)
layers = [
    "Conv 1×6@28×28  (5×5 卷积核)",
    "AvgPool 2×2     (尺寸减半)",
    "Conv 6×16@14×14",
    "AvgPool 2×2     → 16×5×5",
    "Flatten → FC120 → FC84 → FC10",
]
for l in layers:
    print(" ", l)
print("精髓：层数加深 + 多卷积核 → 特征从边缘到整体逐级抽象")

from torchvision import transforms as T
aug = T.Compose([
    T.RandomHorizontalFlip(),       # 随机水平翻转
    T.RandomRotation(15),           # 随机旋转 ±15°
    T.ColorJitter(0.2, 0.2),         # 颜色抖动
    T.ToTensor(),
])
# img = aug(img)：同一张图，每次喂给模型的都不一样
print("一张图变一百张，模型不再死记硬背")

import torch
model = torchvision.resnet18(weights="DEFAULT")
for p in model.parameters():         # 冻结全部
    p.requires_grad = False
model.fc = nn.Linear(512, 2)         # 只换最后一层：猫/狗
# 只训练这最后一层的参数（几万 vs 上千万）

# 分类：这是猫 → 检测：猫在哪（画框）
# YOLO 一眼看全图，一次前向就输出所有框：
#   [置信度, x中心, y中心, 宽, 高, 类别]
pred = [[0.92, 0.30, 0.40, 0.20, 0.35, "cat"],
        [0.87, 0.70, 0.55, 0.25, 0.40, "dog"]]
for conf, cx, cy, w, h, cls in pred:
    print(f"{cls}: 置信度 {conf:.0%}, 框=({cx:.0%},{cy:.0%}) {w:.0%}×{h:.0%}")
print("调用：from ultralytics import YOLO; YOLO('yolov8n.pt)")

import joblib
# 训练好的模型存盘，下次秒加载
# joblib.dump(model, "model.pkl")
# model = joblib.load("model.pkl")
print("sklearn 模型：joblib 一存一取")
print("PyTorch：torch.save(state_dict) → torch.load()")
print("部署三选一：")
print("  ① Web API（Flask + 一个 /predict 接口）")
print("  ② 手机端（模型转 ONNX / CoreML）")
print("  ③ 打包桌面小工具（Tkinter 界面）")