企业官网建设流程全解析

如果你正站在 PyTorch 和 TensorFlow 的岔路口犹豫“先学哪个”，这篇文章就是为你准备的。与其被“二选一”的争论消耗时间，不如看清两个框架的底层逻辑、优势边界和协作方式，把它们都变成你手里的工具。本文会从安装、第一个模型、数据加载、训练循环到部署思路，给你一套可执行的对照路线，而不是空泛的推荐。

1. 别再纠结“二选一”，真正的问题是“我需要哪个”

打开任何技术社区，输入“PyTorch 还是 TensorFlow”，你都能看到大量争论。有人从学术论文复现角度告诉你无脑选 PyTorch，也有人从工业部署角度论证 TensorFlow 生态更成熟。这些观点单独看都没错，但放在真实的开发者场景里，它们可能都在误导你。

先看一个更现实的问题：你根本不是在“选一个框架”，而是在选一个能完成任务的工具链。如果你的任务是快速验证一个论文里新出的注意力机制，PyTorch 的动态图天然适合这种随时改结构、打印中间张量的工作流。如果你的任务是训练一个图像分类模型，并把它部署到移动端或嵌入式设备上，TensorFlow 的 TFLite 工具链和成熟的模型优化方案更省心。

更常见的场景是：你在 GitHub 上找到一份很好的预训练模型代码，它用的是 PyTorch；但公司内部的生产推理服务却跑在 TensorFlow Serving 上。这时候，你不需要“选”，你需要“都能看懂、都能改、都能接得上”。这才是两个框架都掌握的真实价值。

从工程角度看，这两个框架的重叠度远比你想的高。它们都支持 GPU 加速、自动求导、分布式训练、ONNX 模型导出，核心概念高度相似。你完全可以在理解“张量、计算图、自动求导”这些底层概念的基础上，用一套方法论同时驾驭两个框架。与其纠结选哪个，不如先建立一个通用心智模型，然后在具体场景里选择最合适的工具。

2. 基础概念与核心差异：为什么它们长得像，用起来却不一样

2.1 张量与自动求导，两个框架的共同底座

不管 PyTorch 还是 TensorFlow，最核心的数据结构都是张量。简单理解，张量就是多维数组的泛化：标量是 0 维张量，向量是 1 维张量，矩阵是 2 维张量，图像数据通常是 3 维或 4 维张量，视频或 3D 卷积用到的则可能是 5 维张量。

自动求导则是深度学习框架最关键的“魔法”。你只需要定义前向计算过程，框架会自动记录运算路径，并在反向传播时自动计算梯度。PyTorch 用autograd机制实现，TensorFlow 用GradientTape实现。二者背后的数学原理完全一致，只是 API 设计取向不同。

这两个共同底座决定了：你在一个框架里建立的张量操作、形状变换、损失函数设计、梯度下降理解，放到另一个框架里 80% 可以直接迁移。真正让你感到不习惯的，是 API 风格和程序执行方式的差异。

2.2 动态图与静态图：最核心的体验差异

PyTorch 从诞生起就采用动态图机制，代码在运行时逐行执行，if语句、for循环、print调试都可以直接写在模型代码里。这极大降低了调试成本，也是 PyTorch 在学术圈迅速流行的关键原因。你可以在前向传播过程里加断点，查看任意中间变量的形状和数值，就像调试普通 Python 程序一样自然。

TensorFlow 早期版本采用静态图机制，需要先定义完整的计算图，再在会话中执行。这种方式对性能优化和部署迁移很友好，但调试体验差，早期开发者经常抱怨“报错信息完全看不懂”。TensorFlow 2.x 之后，默认开启了 Eager Execution（动态执行模式），同时通过tf.function保留静态图优化的能力。

这意味着，现在两者的日常开发体验已经趋同。但底层哲学差异仍然存在：PyTorch 的“默认动态、按需优化”更符合研究探索，TensorFlow 的“默认 Eager、编译加速”则偏向工程稳定。理解这一点，你就明白为什么学术论文代码大多用 PyTorch，而很多生产系统仍在 TensorFlow 生态上运行。

2.3 生态定位差异：学术研究与工业部署

PyTorch 的生态核心在 Hugging Face（Transformer 模型库）和各大研究实验室。新模型、新方法几乎当天就会出 PyTorch 实现，你看到的大多数论文开源代码也是 PyTorch。如果你研究 NLP、多模态、生成模型，PyTorch 生态的资源密度明显更高。

TensorFlow 的生态核心在 Google 系产品和企业级解决方案。TensorFlow Serving、TFLite、TensorFlow.js、TFX 构成了一个覆盖服务端、移动端、浏览器端的完整部署链条。如果团队的模型最终要进入线上服务，对延迟、吞吐、模型大小有严格要求，TensorFlow 的部署工具链比 PyTorch 更成熟。

但要注意，这个边界正在模糊。PyTorch 推出了 TorchServe 和 TorchScript，部署能力在增强；TensorFlow 通过 Keras 这套高级 API 大幅降低了学术原型开发的代码量。不要用几年前的老印象来评判今天的框架。

3. 环境准备：一套 Anaconda，两个框架共存

很多人在安装环节就被劝退，其实只要规划好虚拟环境，PyTorch 和 TensorFlow 完全可以在同一台机器上和平共处。

3.1 提前确认的硬件与软件条件

操作系统方面，Windows、Linux、macOS 都能安装，但强烈建议开发和训练环境用 Linux。很多生产部署、GPU 驱动、分布式训练工具对 Linux 的支持最完善。macOS 的 M 系列芯片只能 CPU 训练，新版本的 PyTorch 和 TensorFlow 对 Apple Silicon 都有原生支持，但生态工具链仍然不如 Linux 完整。

GPU 是深度学习的硬性条件。训练一个 ResNet、Transformer 这样的模型，CPU 跑一轮可能需要数小时，GPU 往往几分钟就能完成。确认 GPU 是否可用，核心看三件事：NVIDIA 显卡型号、CUDA 驱动版本、cuDNN 版本。

nvidia-smi

上面这条命令会显示 GPU 型号和驱动支持的 CUDA 版本。注意，nvidia-smi输出的 CUDA 版本是驱动支持的最高版本，不一定要与框架所需的 CUDA 完全一致，通常满足“驱动版本 >= 所需版本”即可。具体安装时，优先采用框架官方推荐的组合，不要自己随意搭配。

3.2 用 Anaconda 创建独立的 Python 环境

Anaconda 是目前最主流的 Python 环境管理工具，它能帮助你把不同项目的依赖隔离，避免“装一个包把另一个搞坏”。这里直接给出命令：

conda create -n pytorch_env python=3.11 -y conda create -n tf_env python=3.11 -y

上面两条命令分别创建两个互不干扰的虚拟环境：pytorch_env负责 PyTorch 相关项目，tf_env负责 TensorFlow 相关项目。切换环境的命令是：

conda activate pytorch_env conda deactivate

Python 版本建议使用 3.10 或 3.11，这两个版本对当前主流框架的兼容性最稳妥。如果你有老的 TensorFlow 1.x 项目，可能需要更低的 Python 版本，这就更需要依赖虚拟环境来隔离。

3.3 PyTorch 安装：用官网命令最省心

PyTorch 的安装命令会根据操作系统、CUDA 版本、包管理工具动态生成，所以不要背安装命令，直接访问 PyTorch 官网首页，选择你的环境配置，把生成的命令复制执行即可。关键点在于，官网会让你选择 CUDA 版本，这一个选项决定了你能否调用 GPU。

如果你暂时没有 NVIDIA GPU，或者只想先跑通代码，选择 CPU 版本即可：

pip install torch torchvision torchaudio

如果要安装 GPU 版本，以 CUDA 12.x 为例，命令大概是：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

安装完成后，验证 GPU 是否可用：

import torch print(torch.__version__) print(torch.cuda.is_available()) print(torch.cuda.get_device_name(0))

如果第二行输出True，说明 PyTorch 已经正确识别 GPU。输出False的话，大概率是安装的 PyTorch 版本与 CUDA 不匹配，或者安装成了 CPU 版本。

3.4 TensorFlow 安装：注意 2.x 版本的命名规则

TensorFlow 2.x 的安装命令相对简单：

pip install tensorflow

这条命令默认安装支持 NVIDIA GPU 的版本。如果你的机器没有 NVIDIA GPU，或者 CUDA 环境配置繁琐，可以安装 CPU 版本：

pip install tensorflow-cpu

验证安装：

import tensorflow as tf print(tf.__version__) print(tf.config.list_physical_devices('GPU'))

如果输出为空列表，说明 TensorFlow 没有识别到 GPU，需要检查 CUDA、cuDNN 和 TensorFlow 版本的匹配关系。TensorFlow 对 CUDA 和 cuDNN 有严格的版本要求，官方文档里的“软件版本要求”表格是最权威的依据。

4. 核心流程拆解：手写数字识别任务的双框架实现

前几步属于环境准备，接下来用一个经典任务——MNIST 手写数字识别——分别用 PyTorch 和 TensorFlow 实现。这个例子足够简单，能让你看清两个框架在数据加载、模型定义、训练循环上的核心差异。

4.1 数据加载的对比

PyTorch 使用torch.utils.data.Dataset和DataLoader。你需要定义如何读取一条数据，DataLoader负责把数据打包成 batch、打乱顺序、并行加载。

TensorFlow 则使用tf.data.Dataset这个管线 API，它把数据读取、预处理、shuffle、batch 等操作组合成一个计算图管道。

写代码前，先确保你已经激活对应环境的命令。如果是在 PyTorch 环境就输入conda activate pytorch_env，TensorFlow 环境就输入conda activate tf_env。下面每个代码块开头也标注了环境。

4.2 模型构建的对比

PyTorch 的模型定义偏向“显式”：你继承torch.nn.Module，在__init__里声明层，在forward里手写前向传播逻辑。

TensorFlow 的 Keras API 提供了两种方式：Sequential适合线性堆叠的简单模型，函数式 API 适合有分支或共享层的模型；子类化方式则与 PyTorch 的写法更接近。

4.3 训练循环的对比

PyTorch 的训练循环完全手动：你遍历数据、清空梯度、前向传播、计算损失、反向传播、更新参数。这看起来很繁琐，但每一步都在你的掌控之中。

TensorFlow 的model.fit()封装了完整训练流程：你只需要传入训练数据、指定 epoch 数和验证集，它会自动完成 batch 切分、梯度更新和指标监控。

5. 完整示例代码：PyTorch 版本的 MNIST 分类

这一节给出完整的 PyTorch 手写数字识别代码。由于 MNIST 数据集小、训练快，代码可以在 CPU 上运行，也支持 GPU 自动加速。

# 文件路径：pytorch_mnist.py # 运行环境：conda activate pytorch_env import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms from torch.utils.data import DataLoader # 1. 数据预处理：将像素值归一化到 [-1, 1] transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ]) # 2. 加载 MNIST 数据集 train_dataset = torchvision.datasets.MNIST( root='./data', train=True, download=True, transform=transform ) test_dataset = torchvision.datasets.MNIST( root='./data', train=False, download=True, transform=transform ) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False) # 3. 定义卷积神经网络模型 class CNN(nn.Module): def __init__(self): super(CNN, self).__init__() self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1) self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) self.pool = nn.MaxPool2d(2, 2) self.fc1 = nn.Linear(64 * 7 * 7, 128) self.fc2 = nn.Linear(128, 10) self.relu = nn.ReLU() self.dropout = nn.Dropout(0.25) def forward(self, x): x = self.pool(self.relu(self.conv1(x))) x = self.pool(self.relu(self.conv2(x))) x = x.view(x.size(0), -1) x = self.relu(self.fc1(x)) x = self.dropout(x) x = self.fc2(x) return x # 4. 初始化模型、损失函数、优化器 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = CNN().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 5. 训练循环 def train(epochs=5): model.train() for epoch in range(epochs): running_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) # 清空梯度 optimizer.zero_grad() # 前向传播 outputs = model(images) # 计算损失 loss = criterion(outputs, labels) # 反向传播 loss.backward() # 更新参数 optimizer.step() running_loss += loss.item() print(f'Epoch [{epoch+1}/{epochs}], Loss: {running_loss/len(train_loader):.4f}') # 6. 测试函数 def evaluate(): model.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in test_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print(f'Test Accuracy: {100 * correct / total:.2f}%') if __name__ == '__main__': train(epochs=5) evaluate()

5.1 代码核心逻辑说明

这段代码总共做了四件事：把 MNIST 图像数据归一化并加载、定义一个包含两个卷积层和两个全连接层的 CNN、用 Adam 优化器和交叉熵损失构建训练流程、在测试集上评估准确率。

真正值得关注的是training阶段的“手动感”：optimizer.zero_grad()清空梯度、loss.backward()自动求导、optimizer.step()更新权重。这三行是 PyTorch 训练循环的黄金三步，任何 PyTorch 项目里你都会反复看到它们。

model.eval()和with torch.no_grad():的作用是切换到评估模式：关闭 Dropout、BatchNorm 的统计更新，并关闭自动求导以减少内存消耗。很多初学者忘记加model.eval()，导致训练和测试结果不一致，这是一个非常典型的坑。

运行方式：

python pytorch_mnist.py

预期输出为每个 epoch 的 loss 递减，最终测试准确率在 99% 左右。如果准确率明显偏低，很大概率是数据归一化写错了，或者模型中的全连接层输入维度计算不对。

6. 完整示例代码：TensorFlow 版本的 MNIST 分类

同样的任务，用 TensorFlow 的 Keras API 重写一遍。为了公平对比，网络结构尽量保持一致。

# 文件路径：tf_mnist.py # 运行环境：conda activate tf_env import tensorflow as tf from tensorflow.keras import layers, models # 1. 加载 MNIST 数据集 (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data() # 2. 数据预处理：增加通道维度并归一化 x_train = x_train[..., tf.newaxis].astype('float32') / 255.0 x_test = x_test[..., tf.newaxis].astype('float32') / 255.0 # 3. 定义模型 model = models.Sequential([ layers.Conv2D(32, (3, 3), padding='same', activation='relu', input_shape=(28, 28, 1)), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), padding='same', activation='relu'), layers.MaxPooling2D((2, 2)), layers.Flatten(), layers.Dense(128, activation='relu'), layers.Dropout(0.25), layers.Dense(10, activation='softmax') ]) # 4. 编译模型 model.compile( optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'] ) # 5. 训练模型 history = model.fit( x_train, y_train, batch_size=64, epochs=5, validation_data=(x_test, y_test) ) # 6. 评估模型 test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2) print(f'Test Accuracy: {test_acc:.4f}')

6.1 代码核心逻辑说明

TensorFlow 版本的代码量明显更少，主要原因是 Keras 的SequentialAPI 把模型定义、编译、训练流程高度封装。model.compile()用来指定优化器、损失函数和评估指标，model.fit()一行完成训练。

要注意的是sparse_categorical_crossentropy这个损失函数：当标签是整数（0-9）时用它；如果标签做了 one-hot 编码，则改用categorical_crossentropy。选错会导致训练报错或效果极差。

history对象记录了每个 epoch 的损失和准确率，你可以用它画出训练曲线，判断过拟合情况。

运行方式：

python tf_mnist.py

最终准确率应该和 PyTorch 版本相当。如果你发现两个框架的精度有细微差异，这是正常的：权重初始化随机性、数据归一化方式、Dropout 的具体行为都会导致结果波动，不代表框架本身有优劣。

7. PyTorch 与 TensorFlow 的 API 对照与思维迁移

学完一个框架再学另一个时，最大的瓶颈不是概念，而是“明明知道原理，却不知道对应 API 叫什么”。下面这张对照表能帮你快速定位。

这张表最有价值的地方在于，它揭示了两个框架的“思维惯性差异”：PyTorch 倾向于显式暴露底层操作，TensorFlow/Keras 倾向于把流程封装成高级 API。

从架构设计角度理解，PyTorch 的回调机制像手动挡汽车，你控制每一个环节；Keras 的fit更像自动挡，大部分细节被隐藏。自动挡上手快，但遇到问题你需要更深入排查；手动挡初期繁琐，但内部机制透明度高，调试路径清晰。

学习迁移的实用策略是：不要试图记住所有 API，而是把每个概念的“意图”记清楚。当你想在 TensorFlow 里实现“PyTorch 里的nn.Linear”，你要搜索的不是“torch Linear in tensorflow”，而是“全连接层 tensorflow 怎么写”。理解了意图，API 名称就是个查询问题。

8. 两个框架的实战技巧：数据加载、模型保存与自定义训练

基础训练能跑通后，实际项目还会频繁遇到三类问题：复杂数据怎么加载、模型怎么保存与恢复、自定义训练逻辑怎么写。这一节给出实用技巧。

8.1 自定义数据加载

PyTorch 处理自定义数据集的标准姿势是继承torch.utils.data.Dataset类：

import torch from torch.utils.data import Dataset, DataLoader class CustomDataset(Dataset): def __init__(self, image_paths, labels, transform=None): self.image_paths = image_paths self.labels = labels self.transform = transform def __len__(self): return len(self.image_paths) def __getitem__(self, idx): # 这里根据实际数据读取逻辑修改 image = load_image(self.image_paths[idx]) # 读取图像 label = self.labels[idx] if self.transform: image = self.transform(image) return image, label

TensorFlow 对应的是tf.data.Dataset管道，可以从文件路径列表创建：

import tensorflow as tf def load_and_preprocess_image(image_path, label): image = tf.io.read_file(image_path) image = tf.image.decode_image(image, channels=3) image = tf.image.resize(image, [224, 224]) image = image / 255.0 return image, label image_paths = ['cat1.jpg', 'cat2.jpg', 'dog1.jpg'] labels = [0, 0, 1] dataset = tf.data.Dataset.from_tensor_slices((image_paths, labels)) dataset = dataset.map(load_and_preprocess_image).batch(32).shuffle(100)

两者的本质逻辑完全一样：定义如何从原始数据得到一个(输入, 标签)样本，然后交给框架去批处理、打乱和并行加载。区别只是 PyTorch 要求你把它写成类的形式，TensorFlow 则倾向于函数式管道。

8.2 模型保存与恢复

PyTorch 官方推荐的保存方式是只保存状态字典，而不是整个模型对象：

# 保存 torch.save(model.state_dict(), 'model_weights.pth') # 加载 model = CNN() # 需要先重新定义模型结构 model.load_state_dict(torch.load('model_weights.pth')) model.eval()

TensorFlow 的 Keras API 可以直接保存完整模型：

# 保存 model.save('mnist_model.keras') # 加载 model = tf.keras.models.load_model('mnist_model.keras')

如果你需要把模型导出到其他平台，两个框架都支持 ONNX（开放神经网络交换格式）。ONNX 是深度学习模型的通用“翻译官”，理论上你可以在 PyTorch 训练、导出 ONNX，再在 TensorFlow 或 ONNX Runtime 推理。但实际转换时，某些算子可能不兼容，需要做针对性调整。

8.3 自定义训练循环

Keras 的model.fit()能解决 90% 场景，但研究型工作经常需要自定义训练步骤，比如自监督学习、对抗训练、混合精度控制等。TensorFlow 2.x 可以通过继承keras.Model并重写train_step来实现：

import tensorflow as tf class CustomModel(tf.keras.Model): def train_step(self, data): x, y = data with tf.GradientTape() as tape: y_pred = self(x, training=True) loss = self.compiled_loss(y, y_pred) grads = tape.gradient(loss, self.trainable_variables) self.optimizer.apply_gradients(zip(grads, self.trainable_variables)) self.compiled_metrics.update_state(y, y_pred) return {m.name: m.result() for m in self.metrics}

这与 PyTorch 手动训练循环的机制如出一辙：用GradientTape记录反向传播所需梯度，再手动更新参数。到这里你会发现，两个框架的底层逻辑正在融合——它们都在向“动态执行 + 可按需自定义”的方向演进。

9. 常见问题与排查思路

两个框架安装和运行中遇到的问题高度集中在版本匹配、GPU 识别、内存这几个方面。下表整理了高频问题。

这里特别提醒一下 PyTorch 2.6 的weights_only变化。从 PyTorch 2.6 开始，torch.load的weights_only参数默认值变为True，这是出于安全考虑：不允许加载任意 Python 对象，只允许加载基础张量数据。如果你之前保存的是整个模型对象（torch.save(model, path)），升级 PyTorch 后用torch.load直接加载就会报错。更稳妥的做法是始终保存model.state_dict()，并在加载时重建模型结构。这不仅是兼容性问题，也是安全性要求。

10. 最佳实践与工程建议

两个框架都走过一遍基础流程后，你需要建立一套跨框架的工程规范，避免每次切换框架时从头踩坑。

第一，环境隔离是第一优先级，永远不要在一个环境里混装两个框架。你的日常开发机器上至少要有pytorch_env和tf_env两个独立环境，必要时再为具体项目额外创建环境。每次重建环境后，建议把pip freeze > requirements.txt导出依赖清单，方便复现。

第二，统一 GPU 环境管理。深度学习版本的匹配问题几乎都出在 CUDA 上。建议的做法是：先通过nvidia-smi确定驱动支持的最高 CUDA 版本，再分别查看 PyTorch 官网和 TensorFlow 官网推荐的 CUDA 版本，最后选择两者都满足的配置。不要为了追求新版本无脑升级 CUDA，稳定才是训练环境的关键。

第三，代码结构要规划好。在两个框架的对比学习阶段，很多人会随手写一堆脚本，最后自己都分不清哪个代码依赖哪个环境。更合理的目录结构是：

deep_learning_practice/ ├── pytorch_envs/ │ ├── mnist_cnn.py │ └── utils.py ├── tensorflow_envs/ │ ├── mnist_cnn.py │ └── utils.py └── data/ # 两个框架共享的数据目录，避免重复下载

这里真正值得强调的是数据目录共享：MNIST、CIFAR 这类公共数据集的下载动辄几十 MB 到几百 MB，如果每个框架各下载一份到不同目录，很浪费磁盘带宽和时间。把数据统一放在data/目录，代码中指定root='../data'（PyTorch）或data_dir='/path/to/data'（TensorFlow），是更干净的工程习惯。

第四，理解并主动使用版本管理。你迟早会遇到“昨天还能跑的代码今天报错”的问题，大概率是某个依赖被升级了。无论是 PyTorch、TensorFlow 还是 CUDA 版本，都要在项目文档或requirements.txt里锁定。如果团队协作，建议直接用 Docker 镜像把训练环境固话，这样大家跑出来的结果才可复现。

第五，不要把训练和推理混为一谈。训练阶段追求的是迭代速度和调试便利性，所以你会喜欢 PyTorch 的动态图和 Keras 的高级 API；推理阶段追求的是延迟、吞吐量和资源占用，这时候静态图优化、量化、剪枝等技术才是重点。先跑通模型，再考虑用哪个工具链做部署优化。

11. 总结与后续学习方向

回到文章开头的问题：PyTorch 和 TensorFlow 到底怎么选？答案其实很清楚——不要被“二选一”的框架之争限制住。你的目标应该是建立一套跨框架的方法论，用 PyTorch 快速验证想法，用 TensorFlow 工程化落地，在具体场景里选择顺手的那一个。两个框架都学的时间成本并未翻倍，因为你反复使用的核心概念是同一套。

接下来可以按这个路径继续深入：先确保两套环境都装好、MNIST 示例都跑通，这是所有后续学习的地基。然后用自己的图片数据分别训练一个分类模型，体验完整的数据加载、训练、评估流程。之后再接触 Transformer、迁移学习等进阶内容，建议用 PyTorch 读 Hugging Face 的源码，用 TensorFlow 练 Keras 的生产部署链路。

对了，文章里所有代码都建议收藏备用。环境安装和第一个模型的代码是最容易被反复查阅的内容，实际动手时你会发现，真正难的往往不是模型结构，而是环境和数据链路。祝顺利跑通第一个模型。