TensorFlow 和 PyTorch两大深度学习框架训练数据，并协作一个电商推荐系统

TensorFlow (由Google开发)： 更像一个工业化、高度优化的精密生产工具包。它设计严谨，适合大规模部署和生产环境，最初需要先定义好整个计算图再运行（静态图）。因其完整的生态系统（如TensorFlow Serving, TensorFlow Lite）而拥有强大优势。适合工业界/生产部署

PyTorch (由Facebook开发)： 更像一个灵活、易用的科研实验工具包。它非常符合Python的直觉，支持动态定义计算图（更易调试），深受研究人员和初学者的喜爱。

共同功能：

• 提供张量计算：强大的N维数组（称为张量）操作，支持GPU加速。
• 自动求导（Autograd）：自动计算梯度，这是训练神经网络的核心。
• 预构建的神经网络层：提供了大量现成的层（如卷积层、LSTM层），让你像搭积木一样构建网络。
• 丰富的生态系统：提供从数据加载、模型训练到部署的全套工具。

用PyTorch训练一个图像分类器

一、环境准备，安装PyTorch。通常使用pip或conda安装

pip install torch torchvision

二、定义数据转换，加载训练数据集

• 深度学习项目大量时间花在数据准备上。PyTorch提供了Dataset和DataLoader来高效处理数据。
• transforms.Compose() 将图像数据转换为Tensor，并做归一化
• datasets.MNIST()
• DataLoader()

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# 定义数据转换：将图像数据转换为Tensor，并做归一化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,)) # MNIST数据集的均值和标准差
])

# 下载并加载训练数据集
train_dataset = datasets.MNIST(
    root='./data', 
    train=True, 
    download=True, 
    transform=transform
)
train_loader = DataLoader(
    dataset=train_dataset, 
    batch_size=64, # 每次训练64张图片
    shuffle=True   # 打乱数据顺序
)

# 下载并加载测试数据集
test_dataset = datasets.MNIST(
    root='./data', 
    train=False, 
    download=True, 
    transform=transform
)
test_loader = DataLoader(
    dataset=test_dataset, 
    batch_size=64, 
    shuffle=False
)

三、构建神经网络模型 (nn.Module)

• 通过继承nn.Module类来定义我们自己的网络结构

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        # 定义网络层
        self.fc1 = nn.Linear(28*28, 128) # 全连接层1: 输入28*28=784, 输出128
        self.fc2 = nn.Linear(128, 64)    # 全连接层2: 输入128, 输出64
        self.fc3 = nn.Linear(64, 10)     # 全连接层3: 输入64, 输出10 (10个类别)

    def forward(self, x):
        # 定义数据如何向前传播
        x = x.view(-1, 28*28)    # 将图片展平 [batch_size, 784]
        x = F.relu(self.fc1(x))  # 通过第一层后使用ReLU激活函数
        x = F.relu(self.fc2(x))  # 通过第二层后使用ReLU激活函数
        x = self.fc3(x)          # 最后一层不需要激活函数（配合CrossEntropyLoss）
        return x

# 创建模型实例，并移至GPU（如果可用）
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SimpleNN().to(device)

四、定义损失函数和优化器

criterion = nn.CrossEntropyLoss()  # 损失函数：对于多分类问题常用交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.001) # 优化器：使用Adam来更新权重

五、训练模型

• 前向传播 -> 计算损失 -> 反向传播 -> 更新权重

num_epochs = 5
for epoch in range(num_epochs):
    model.train()  # 设置模型为训练模式
    for batch_idx, (data, targets) in enumerate(train_loader):
        # 将数据移至设备（GPU/CPU）
        data = data.to(device=device)
        targets = targets.to(device=device)
        
        # 前向传播
        scores = model(data)
        loss = criterion(scores, targets)
        
        # 反向传播
        optimizer.zero_grad() # 清零上一轮的梯度
        loss.backward()       # 自动计算梯度（反向传播）
        
        # 更新模型参数
        optimizer.step()      # 根据梯度更新权重

六、评估模型性能

• 训练完成后，我们需要在测试集上检查模型的表现

def check_accuracy(loader, model):
    model.eval()  # 设置模型为评估模式
    num_correct = 0
    num_samples = 0
    
    with torch.no_grad(): # 在评估时不需要计算梯度，节省内存和计算
        for x, y in loader:
            x = x.to(device=device)
            y = y.to(device=device)
            
            scores = model(x)
            _, predictions = scores.max(1) # 获取概率最高的类别作为预测结果
            num_correct += (predictions == y).sum()
            num_samples += predictions.size(0)
            
    accuracy = float(num_correct) / float(num_samples) * 100
    print(f'Got {num_correct} / {num_samples} with accuracy {accuracy:.2f}%')

check_accuracy(test_loader, model)

七、进行预测

# 取一个批次的数据进行演示
data_iter = iter(test_loader)
images, labels = next(data_iter)
img = images[0] # 取第一张图片

# 需要添加一个批次维度 [1, 1, 28, 28]
img = img.unsqueeze(0).to(device)

# 预测
model.eval()
with torch.no_grad():
    output = model(img)
    _, predicted = torch.max(output.data, 1)
    print(f'Predicted digit: {predicted.item()}')

用TensorFlow 2.x的高级API Keras 来实现

import tensorflow as tf
from tensorflow.keras import layers, models

# 1. 加载数据
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0 # 归一化

# 2. 构建模型 (极其简洁的API)
model = models.Sequential([
  layers.Flatten(input_shape=(28, 28)),
  layers.Dense(128, activation='relu'),
  layers.Dense(64, activation='relu'),
  layers.Dense(10)
])

# 3. 编译模型 (定义损失和优化器)
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# 4. 训练模型
model.fit(x_train, y_train, epochs=5)

# 5. 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'\nTest accuracy: {test_acc}')

T

TensorFlow 与 PyTorch 的协作与共存

项目：电商个性化推荐系统
根据用户的实时行为（点击、浏览、加购），快速预测其可能感兴趣的商品并展示

架构设计：

• PyTorch：用于研究和快速迭代推荐系统的核心深度学习模型（如基于 Transformer的深度兴趣网络）。其动态图特性方便调试和实验新想法。
• TensorFlow：用于大规模特征处理（使用 TFX 组件）和高性能线上推理服务（使用 TensorFlowServing）。其静态图和在部署端的优化能保证线上服务的稳定性与效率。
• 协作方式：模型服务化接口。将 PyTorch 训练好的最终模型转换为 ONNX 或 TorchScript 格式，并在TensorFlow Serving 的定制化Docker 镜像中集成 ONNX Runtime 来加载和服务，对外提供统一的gRPC/REST API。

一、模型研发与训练 (PyTorch 环境)

• 环境：安装 PyTorch, TorchVision, ONNX, pandas, scikit-learn 等库
• 数据预处理与特征工程：使用 PyTorch 的 DataLoader 和 Pandas 处理用户和商品数据，构建特征
• 模型构建与训练：在 PyTorch 中定义、训练并验证推荐模型
• 模型导出：训练完成后，将模型导出为 ONNX 格式，以便在其他环境中使用

#conda create -n reco_research python=3.10
#conda activate reco_research
#pip install torch torchvision onnx pandas scikit-learn

# 示例：简单的特征处理
import pandas as pd
import torch
from torch.utils.data import Dataset

class RecoDataset(Dataset):
    def __init__(self, data_path):
        self.data = pd.read_parquet(data_path)
        self.user_features = ... # 处理用户特征
        self.item_features = ... # 处理商品特征
        self.labels = self.data['label'].values

    def __getitem__(self, index):
        return (torch.tensor(self.user_features[index], dtype=torch.float),
                torch.tensor(self.item_features[index], dtype=torch.float),
                torch.tensor(self.labels[index], dtype=torch.float))

    def __len__(self):
        return len(self.data)


# 示例：定义一个简单的神经网络
import torch.nn as nn

class DIN(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 1),
            nn.Sigmoid()
        )

    def forward(self, user_feat, item_feat):
        x = torch.cat([user_feat, item_feat], dim=1)
        return self.encoder(x)

# 训练循环（伪代码）
model = DIN(input_dim=user_dim + item_dim)
criterion = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters())
# ... 在DataLoader上循环进行训练和评估 ...

# 导出模型为ONNX格式
dummy_user_input = torch.randn(1, user_dim)
dummy_item_input = torch.randn(1, item_dim)
torch.onnx.export(model,
                  (dummy_user_input, dummy_item_input),
                  "din_model.onnx",
                  input_names=["user_input", "item_input"],
                  output_names=["output"],
                  dynamic_axes={"user_input": {0: "batch_size"},
                                "item_input": {0: "batch_size"},
                                "output": {0: "batch_size"}})

二、生产环境部署 (TensorFlow 生态系统)

①、环境准备：准备生产环境，可能需要使用 Docker。在镜像中同时安装 TensorFlow Serving 和 ONNX Runtime

# 基于TensorFlow Serving的官方镜像，安装ONNX Runtime
FROM tensorflow/serving:latest
# ... 安装ONNX Runtime的步骤 ...

②、配置 TensorFlow Serving：将导出的 din_model.onnx 模型放入 TensorFlow Serving 的模型仓库目录，并编写配置文件 (models.config) 指定模型名称、路径等

model_config_list: {
    config: {
        name: "dIN_model",
        base_path: "/models/din_model",
        model_platform: "onnx", # 表明是ONNX模型
    }
}

③、启动服务：启动 TensorFlow Serving 容器，并指定配置文件和端口映射

docker run -p 8501:8501 \
   --mount type=bind,source=/path/to/your/model_repo/,target=/models \
   -t tensorflow/serving:latest \
   --model_config_file=/models/models.config

三、线上推理 (应用端)

①、客户端请求：线上的应用服务（如 Java, Go 或 Python 编写）通过 HTTP/REST 或 gRPC 向 TensorFlow Serving 服务发起推理请求。请求体中需要包含序列化后的特征数据（格式需要与导出 ONNX 模型时的输入一致）

# 示例：使用Python客户端发送请求
import requests
import json

# 准备请求数据
data = {
    "signature_name": "serving_default",
    "inputs": {
        "user_input": user_feat_list.tolist(),   # 用户特征向量
        "item_input": item_feat_list.tolist()    # 商品特征向量
    }
}

# 发送请求到TensorFlow Serving
headers = {"content-type": "application/json"}
response = requests.post('http://localhost:8501/v1/models/dIN_model:predict',
                         data=json.dumps(data), headers=headers)
predictions = response.json()['outputs']  # 获取预测结果

2、结果返回与处理：应用端接收到预测结果后，根据得分进行排序、过滤等后续业务逻辑处理，最终将推荐列表展示给用户。