企业官网建设流程全解析

1. 从零开始理解TensorFlow到底在算什么

很多人第一次接触TensorFlow，脑子里冒出来的第一个问题不是“怎么用”，而是“它到底在算什么”。我刚开始也一样，看了一堆文档，满眼都是张量、计算图、会话，感觉每个字都认识，连在一起就不知道在说什么。后来我换了个角度，把它当成一个“数学流水线工厂”来理解，一下子就通了。

TensorFlow的核心工作，说白了就是把数学运算组织成一张有向图，然后让数据沿着这张图流动。你定义好每个节点做什么运算，节点之间怎么连接，然后喂数据进去，它按照图的拓扑顺序一步步算出来。这个“图”就是计算图，数据就是张量。张量你可以理解成多维数组，零维是标量，一维是向量，二维是矩阵，三维以上就是高维数组。TensorFlow这个名字本身就说明了它的定位：Tensor（张量）在Flow（流动）。

那为什么非要搞成图呢？直接写Python代码算不就行了吗？这里就涉及到TensorFlow的设计哲学了。用计算图有几个实实在在的好处：第一，图可以被优化，比如把多个小运算合并成一个大运算，减少中间结果的存储和传输开销；第二，图可以分布式执行，同一张图可以拆到多台机器上跑；第三，图可以跨平台部署，训练好的图可以导出到移动端、嵌入式设备甚至浏览器里运行。这些特性在工业级应用里非常关键，也是TensorFlow能在生产环境站稳脚跟的根本原因。

不过要注意，TensorFlow经历了两个大版本的变化。1.x时代是“静态图”模式，你得先定义完整的计算图，再开一个会话去执行，调试起来比较麻烦，因为图定义阶段看不到中间结果。2.x时代默认切换到了“动态图”模式，也就是Eager Execution，写起来跟普通Python代码几乎一样，每行代码执行完立刻就能拿到结果，调试体验好了非常多。但静态图并没有被抛弃，你仍然可以用tf.function装饰器把Python函数编译成图，兼顾开发效率和运行性能。这个设计思路的转变，是理解现代TensorFlow用法的关键分水岭。

对于刚入门的人来说，我建议先从动态图模式入手，把基本的张量操作、自动求导、模型搭建流程跑通，再去理解图优化的部分。因为动态图更符合直觉，学习曲线平缓得多。等你对整体流程有了感觉，再回头看静态图的优化机制，就会觉得顺理成章。

2. 环境搭建中最容易翻车的几个环节

环境配置这件事，看起来简单，实际上坑非常多。我见过太多人卡在安装这一步就放弃了，其实不是TensorFlow本身有多难装，而是Python生态的版本兼容性问题太复杂。下面我把几个高频翻车点拆开讲。

2.1 Python版本与TensorFlow版本的对应关系

TensorFlow对Python版本有明确的兼容范围，装错了版本，轻则import报错，重则直接装不上。截至我写这篇内容的时候，TensorFlow 2.15支持Python 3.9到3.11，TensorFlow 2.16开始支持Python 3.9到3.12。如果你用的是Python 3.8或更低版本，很多新版本的TensorFlow已经不支持了。反过来，如果你用的是最新的Python 3.13，也可能因为wheel包还没发布而装不上。

我的建议是：用conda创建一个独立的虚拟环境，指定Python版本为3.10或3.11，这两个版本目前兼容性最好，绝大多数第三方库也都支持。不要用系统自带的Python，也不要在base环境里直接装，否则后面依赖冲突会让你痛不欲生。

conda create -n tf_env python=3.10 conda activate tf_env pip install tensorflow

如果你有NVIDIA显卡并且想用GPU加速，那安装命令要换成pip install tensorflow[and-cuda]，而且需要提前装好对应版本的CUDA和cuDNN。这里有个很容易忽略的点：TensorFlow对CUDA和cuDNN的版本要求非常严格，不是越新越好。比如TensorFlow 2.15要求CUDA 12.2和cuDNN 8.9，你装了CUDA 12.4就可能识别不到GPU。所以装之前一定去官网查一下版本对应表，别凭感觉来。

2.2 验证安装是否真正成功

装完之后，很多人只跑一句import tensorflow as tf看到没报错就以为搞定了。其实这只能说明Python层面能导入，不代表GPU能用、不代表核心功能正常。我一般会跑一段完整的验证代码：

import tensorflow as tf print("TensorFlow版本:", tf.__version__) print("GPU可用:", tf.config.list_physical_devices('GPU')) print("CPU设备:", tf.config.list_physical_devices('CPU')) # 做一个简单的张量运算 a = tf.constant([[1.0, 2.0], [3.0, 4.0]]) b = tf.constant([[5.0, 6.0], [7.0, 8.0]]) c = tf.matmul(a, b) print("矩阵乘法结果:\n", c) # 验证自动求导 x = tf.Variable(3.0) with tf.GradientTape() as tape: y = x ** 2 + 2 * x + 1 dy_dx = tape.gradient(y, x) print("dy/dx at x=3:", dy_dx.numpy())

这段代码覆盖了版本信息、设备识别、张量运算、自动求导四个核心功能。如果全都能正常输出，说明环境基本没问题。如果GPU列表是空的，但你确实有NVIDIA显卡，那大概率是CUDA/cuDNN版本不匹配，或者驱动版本太旧。

注意：在Windows上，TensorFlow 2.11之后已经不再支持GPU加速了，只有Linux和WSL2环境下才能用GPU。如果你在Windows上想用GPU训练模型，要么装WSL2，要么直接用Linux。

2.3 依赖冲突的排查思路

Python生态里最让人头疼的就是依赖冲突。你可能装了TensorFlow，然后又装了某个数据分析库，结果那个库依赖了不同版本的numpy，导致TensorFlow import的时候报错。这种问题的排查思路是：先看报错信息里提到的包名和版本号，然后用pip list查看实际安装的版本，对比TensorFlow要求的版本范围，找到冲突的包之后，要么降级要么升级，实在不行就重建虚拟环境。

我个人的经验是：虚拟环境要按项目隔离，不要在一个环境里装太多不相关的东西。做深度学习就专门建一个环境，只装TensorFlow和必要的辅助库（numpy、matplotlib、pandas等），需要其他工具时再另建环境。这样虽然占一点磁盘空间，但能省下大量排查依赖冲突的时间。

3. 张量操作：TensorFlow的“基本功”该怎么练

张量是TensorFlow里最基础的数据结构，所有运算都是围绕张量展开的。你可以把张量理解成NumPy的ndarray，但TensorFlow的张量多了几个重要特性：可以在GPU上运行、支持自动求导、可以分布在多台设备上。掌握张量操作是后续搭建模型的前提，这部分基本功练扎实了，后面学起来会轻松很多。

3.1 创建张量的几种常用方式

TensorFlow提供了多种创建张量的方法，不同场景下选择不同的方式：

import tensorflow as tf # 从Python列表创建 a = tf.constant([1, 2, 3, 4]) # 创建全零张量 b = tf.zeros([3, 4]) # 创建全一张量 c = tf.ones([2, 3]) # 创建指定值的张量 d = tf.fill([2, 2], 7.0) # 创建随机正态分布张量 e = tf.random.normal([3, 3], mean=0.0, stddev=1.0) # 创建序列 f = tf.range(0, 10, 2) # 从NumPy数组转换 import numpy as np g = tf.constant(np.array([[1.0, 2.0], [3.0, 4.0]]))

这里有个细节值得注意：tf.constant创建的是不可变张量，一旦创建就不能修改。如果需要可变的变量（比如模型参数），要用tf.Variable。这两者的区别在训练模型时非常关键，因为只有tf.Variable才会被自动求导机制追踪，才会在反向传播时更新。

3.2 形状变换与广播机制

张量的形状变换是高频操作，常见的包括reshape、transpose、expand_dims、squeeze等。这些操作本身不难，但组合使用的时候容易搞混维度顺序。我的建议是：每次变换形状之后，立刻打印shape确认，不要凭脑子记。

x = tf.random.normal([2, 3, 4]) print(x.shape) # (2, 3, 4) # 改变形状 y = tf.reshape(x, [2, 12]) print(y.shape) # (2, 12) # 转置 z = tf.transpose(x, perm=[0, 2, 1]) print(z.shape) # (2, 4, 3) # 增加维度 w = tf.expand_dims(x, axis=0) print(w.shape) # (1, 2, 3, 4) # 减少维度 v = tf.squeeze(w, axis=0) print(v.shape) # (2, 3, 4)

广播机制是另一个需要重点理解的概念。当两个形状不同的张量做运算时，TensorFlow会自动尝试对齐它们的形状，把维度为1的轴扩展成匹配的大小。比如形状为(3, 1)和(1, 4)的两个张量相加，结果形状是(3, 4)。广播能省去很多手动复制的操作，但也容易引入隐蔽的bug。如果你不确定广播的结果是否符合预期，可以用tf.broadcast_dynamic_shape来验证。

3.3 自动求导机制的工作原理

自动求导是TensorFlow做深度学习的核心能力。它的实现依赖于tf.GradientTape这个上下文管理器。你把前向计算的过程放在with tf.GradientTape() as tape:块里面，TensorFlow会自动记录所有涉及tf.Variable的运算，然后调用tape.gradient()就能算出梯度。

x = tf.Variable(2.0) y = tf.Variable(3.0) with tf.GradientTape() as tape: z = x ** 2 + y ** 3 + x * y # 对x求偏导 dz_dx = tape.gradient(z, x) print("dz/dx:", dz_dx.numpy()) # 2*x + y = 7 # 对y求偏导 dz_dy = tape.gradient(z, y) print("dz/dy:", dz_dy.numpy()) # 3*y^2 + x = 29

这里有个容易踩的坑：GradientTape默认只记录一次梯度，调用一次gradient()之后就会释放记录。如果你需要对同一个前向过程求多次梯度（比如求二阶导数），需要在创建tape时加上persistent=True参数，并且在用完手动调用del tape释放资源。

另外，如果你在tape的作用域内做了跟变量无关的操作（比如用Python的math库算了一个常数），这些操作不会被记录，梯度也不会流经它们。所以做自定义训练循环的时候，一定要确保所有需要求导的运算都在tape作用域内，并且操作的是tf.Variable或由它衍生出来的张量。

4. 用Keras搭模型：从线性回归到多层网络

Keras是TensorFlow的高层API，它把模型搭建、训练、评估、预测这些流程封装得非常简洁。对于大多数常见任务，用Keras几行代码就能搭出一个可用的模型。但简洁不代表简单，底层的东西还是得理解，否则出了问题不知道怎么排查。

4.1 三种搭模型的方式及适用场景

Keras提供了三种搭模型的方式，分别适用于不同复杂度的场景：

第一种是Sequential顺序模型，适合层与层之间是简单串联关系的场景。比如一个全连接网络，从输入到输出一路直连，没有分支、没有跳跃连接，用Sequential最省事。

model = tf.keras.Sequential([ tf.keras.layers.Dense(64, activation='relu', input_shape=(10,)), tf.keras.layers.Dense(32, activation='relu'), tf.keras.layers.Dense(1) ])

第二种是Functional API函数式模型，适合有分支、多输入多输出、共享层等复杂拓扑结构的场景。比如你要做一个模型同时接收图像和文本两个输入，或者一个模型有多个输出头，那就得用Functional API。

inputs = tf.keras.Input(shape=(10,)) x = tf.keras.layers.Dense(64, activation='relu')(inputs) x = tf.keras.layers.Dense(32, activation='relu')(x) outputs = tf.keras.layers.Dense(1)(x) model = tf.keras.Model(inputs=inputs, outputs=outputs)

第三种是Model子类化，适合需要自定义前向传播逻辑的场景。你继承tf.keras.Model，在__init__里定义层，在call方法里定义前向计算。这种方式最灵活，但调试起来也最麻烦，因为模型结构不是预先定义好的图，而是运行时动态构建的。

class MyModel(tf.keras.Model): def __init__(self): super().__init__() self.dense1 = tf.keras.layers.Dense(64, activation='relu') self.dense2 = tf.keras.layers.Dense(32, activation='relu') self.out = tf.keras.layers.Dense(1) def call(self, inputs): x = self.dense1(inputs) x = self.dense2(x) return self.out(x)

我的建议是：能用Sequential就用Sequential，需要分支就用Functional API，只有前两种都搞不定的时候才用子类化。因为前两种方式模型结构是显式定义的，Keras可以自动做很多优化和检查，出问题也容易定位。子类化方式虽然灵活，但很多Keras的内置功能（比如模型摘要打印、层自动追踪）可能用不了，需要自己处理。

4.2 编译、训练、评估的标准流程

模型搭好之后，用compile方法配置训练过程，指定优化器、损失函数和评估指标，然后用fit方法训练。

model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='mse', metrics=['mae'] ) history = model.fit( x_train, y_train, epochs=50, batch_size=32, validation_split=0.2, verbose=1 )

这里有几个参数值得展开说。learning_rate控制每次参数更新的步长，太大容易震荡不收敛，太小收敛太慢。Adam的默认学习率是0.001，大多数情况下够用，但如果训练loss一直不降，可以试试调小到0.0001。batch_size影响梯度估计的稳定性和内存占用，太小梯度噪声大，太大内存吃紧且泛化可能变差，32到256之间是比较常见的范围。validation_split从训练数据里划一部分出来做验证，方便监控过拟合情况。

训练完成之后，用evaluate在测试集上评估最终性能，用predict做预测：

test_loss, test_mae = model.evaluate(x_test, y_test) predictions = model.predict(x_test)

4.3 回调函数：训练过程中的“自动化助手”

回调函数是Keras里非常实用的一个机制，它允许你在训练的不同阶段插入自定义逻辑。最常用的几个回调包括：

• ModelCheckpoint：每隔一段时间保存模型权重，防止训练中断丢失进度。
• EarlyStopping：监控验证集loss，如果连续多个epoch不下降就提前停止训练，避免过拟合。
• ReduceLROnPlateau：验证集loss不下降时自动降低学习率，帮助模型跳出局部最优。
• TensorBoard：把训练过程可视化，方便分析loss曲线、权重分布等。

callbacks = [ tf.keras.callbacks.ModelCheckpoint( 'best_model.keras', monitor='val_loss', save_best_only=True ), tf.keras.callbacks.EarlyStopping( monitor='val_loss', patience=5, restore_best_weights=True ), tf.keras.callbacks.ReduceLROnPlateau( monitor='val_loss', factor=0.5, patience=3 ) ] model.fit(x_train, y_train, epochs=100, callbacks=callbacks, validation_split=0.2)

这几个回调组合使用，能省下大量手动调参和监控的时间。特别是EarlyStopping，我几乎每次训练都会加上，因为很多时候模型在验证集上的表现早就到瓶颈了，继续训练只会越来越过拟合。

5. 数据管道：tf.data的高效使用技巧

数据量小的时候，直接把numpy数组传给fit方法就行。但数据量一大，比如几十GB的图像数据集，全部加载到内存里就不现实了。这时候就需要用tf.data来构建数据管道，实现按需加载、并行预处理、批次组装。

5.1 从内存数据到Dataset的转换

如果你已经有numpy数组，可以用tf.data.Dataset.from_tensor_slices把它转成Dataset：

dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) dataset = dataset.shuffle(buffer_size=10000) dataset = dataset.batch(32) dataset = dataset.prefetch(tf.data.AUTOTUNE)

这几步操作的含义分别是：shuffle打乱数据顺序，batch按批次组装，prefetch在GPU计算当前批次的时候提前准备下一批次的数据。prefetch这个操作看起来不起眼，但对训练速度的提升非常明显，因为它把数据准备和模型计算重叠起来了，GPU不用等数据。

5.2 从磁盘文件构建数据管道

实际项目中，数据通常是存在磁盘上的图片、文本或二进制文件。这时候需要用tf.data.Dataset.list_files列出文件路径，然后用map方法对每个文件做加载和预处理：

def load_and_preprocess(path, label): image = tf.io.read_file(path) image = tf.image.decode_jpeg(image, channels=3) image = tf.image.resize(image, [224, 224]) image = image / 255.0 return image, label file_paths = tf.data.Dataset.list_files('data/images/*.jpg') labels = ... # 对应的标签 dataset = tf.data.Dataset.from_tensor_slices((file_paths, labels)) dataset = dataset.map(load_and_preprocess, num_parallel_calls=tf.data.AUTOTUNE) dataset = dataset.batch(32).prefetch(tf.data.AUTOTUNE)

num_parallel_calls参数指定并行处理的线程数，设为tf.data.AUTOTUNE让TensorFlow自动决定。这个参数对IO密集型任务影响很大，设小了数据加载会成为瓶颈，设大了会跟模型计算抢CPU资源。

5.3 数据增强的集成方式

数据增强是防止过拟合的重要手段。用tf.data做增强的好处是，增强操作在CPU上执行，跟GPU上的模型计算可以并行，不会拖慢训练速度。常见的增强操作包括随机翻转、随机裁剪、颜色抖动等：

def augment(image, label): image = tf.image.random_flip_left_right(image) image = tf.image.random_brightness(image, max_delta=0.2) image = tf.image.random_contrast(image, lower=0.8, upper=1.2) image = tf.clip_by_value(image, 0.0, 1.0) return image, label train_dataset = train_dataset.map(augment, num_parallel_calls=tf.data.AUTOTUNE)

注意增强操作只应该应用在训练集上，验证集和测试集不要做增强，否则评估结果会失真。另外，增强的强度要适中，太弱起不到正则化效果，太强会让模型学到错误的特征。我一般会先可视化几张增强后的图片，确认人眼还能正常识别，再开始训练。

6. 模型保存与部署的几种路径选择

模型训练完之后，下一步就是保存和部署。TensorFlow提供了多种保存格式，适用于不同的部署场景。选错了格式，后面部署的时候会多走很多弯路。

6.1 SavedModel格式与Keras格式的区别

Keras格式（.keras或.h5）保存的是模型的架构、权重和训练配置，适合在Python环境里继续训练或推理。SavedModel格式是TensorFlow的标准序列化格式，它保存了完整的计算图，不依赖原始代码，可以被TensorFlow Serving、TensorFlow Lite、TensorFlow.js等不同运行时加载。

# 保存为Keras格式 model.save('my_model.keras') # 保存为SavedModel格式 model.save('my_model_savedmodel', save_format='tf') # 加载 loaded_model = tf.keras.models.load_model('my_model.keras')

如果你的模型只在Python环境里用，Keras格式就够了。但如果要部署到服务器、移动端或浏览器，就得用SavedModel格式。另外，SavedModel格式对自定义层的支持更好，因为计算图里包含了完整的运算定义，不依赖原始Python类。

6.2 用tf.function加速推理

tf.function装饰器能把Python函数编译成静态图，减少Python解释器的开销，提升推理速度。对于小模型，这个提升可能不明显；但对于大模型或者高频调用的场景，效果很显著。

@tf.function def predict_step(inputs): return model(inputs, training=False) # 第一次调用会触发图编译，之后调用都走编译好的图 result = predict_step(tf.constant(x_test[:1]))

这里有个细节：tf.function第一次调用时会追踪函数，根据输入的形状和类型生成图。如果后续调用的输入形状变了，会触发重新追踪，产生新的图。所以如果你的输入形状不固定，最好用input_signature参数指定输入签名，避免反复追踪。

6.3 部署到不同平台的注意事项

部署到服务器端，可以用TensorFlow Serving，它支持模型热更新、版本管理、批量推理等功能。部署到移动端，用TensorFlow Lite把模型转换成.tflite格式，体积会大幅缩小，推理速度也更快。部署到浏览器，用TensorFlow.js把模型转换成JSON格式，直接在网页里运行。

不同平台的转换工具对算子支持程度不一样。比如TensorFlow Lite对某些自定义算子不支持，转换的时候会报错。所以如果你计划部署到移动端，搭模型的时候就要尽量用标准算子，避免用太冷门的操作。这个约束在项目初期就要考虑进去，不要等模型训练完了才发现转换不了。

7. 几个让我印象深刻的踩坑经历

说几个我在实际项目里踩过的坑，都是文档里不会写、但实际会遇到的问题。

第一个坑是GPU内存碎片化。训练一个比较大的模型时，显存明明够用，但就是报OOM错误。后来发现是TensorFlow默认会一次性申请所有显存，导致其他进程没法用。解决办法是设置显存按需增长：

gpus = tf.config.list_physical_devices('GPU') for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True)

这样TensorFlow会根据实际需要逐步申请显存，而不是一开始就占满。

第二个坑是数据管道的shuffle顺序问题。用tf.data做shuffle的时候，如果buffer_size设得太小，打乱效果不好，模型可能学到数据的顺序规律。我一般会把buffer_size设成跟数据集大小相当，或者至少几万。另外，shuffle之后如果再做batch，每个epoch的数据顺序都会不同；但如果先batch再shuffle，打乱的是批次顺序而不是样本顺序，效果差很多。

第三个坑是学习率调度器的使用时机。我一开始训练模型的时候，学习率从头到尾固定不变，结果要么收敛太慢，要么在最优解附近震荡。后来学会了用余弦退火或者阶梯下降的学习率调度，训练效果稳定了很多。Keras里可以用LearningRateScheduler回调或者tf.keras.optimizers.schedules来实现。

第四个坑是Batch Normalization在推理时的行为。训练时BN层用当前批次的均值和方差做归一化，推理时用训练过程中累积的移动平均。如果你在推理时忘了设置training=False，BN层会继续用当前批次的统计量，导致结果不稳定。这个问题在用小批量数据推理时特别明显，因为单个批次的统计量跟全局统计量偏差很大。

8. 从能跑到跑好：性能调优的实战思路

模型能跑起来只是第一步，跑得快、跑得稳、效果好才是目标。性能调优涉及多个层面，从数据加载到模型结构再到训练策略，每个环节都有优化空间。

8.1 输入管道的瓶颈定位

训练速度慢，首先要判断瓶颈在数据加载还是模型计算。一个简单的判断方法是：把数据管道去掉，直接用随机生成的张量喂给模型训练，如果速度明显变快，说明瓶颈在数据加载；如果速度差不多，说明瓶颈在模型计算。

数据加载的优化手段包括：增加num_parallel_calls、使用prefetch、把数据转成TFRecord格式减少IO开销、用cache把数据缓存在内存或本地磁盘。模型计算的优化手段包括：减小批次大小、用混合精度训练、用更高效的算子实现、减少不必要的CPU-GPU数据传输。

8.2 混合精度训练的实际收益

混合精度训练是指同时使用float16和float32两种精度。float16的运算速度更快、显存占用更少，但数值范围小，容易溢出。TensorFlow提供了自动混合精度的支持：

policy = tf.keras.mixed_precision.Policy('mixed_float16') tf.keras.mixed_precision.set_global_policy(policy)

开启之后，大部分层的前向计算会用float16，但变量更新和损失计算仍然用float32保证数值稳定性。实测下来，在支持Tensor Core的GPU上，混合精度能带来1.5到3倍的速度提升，显存占用也能减少30%到50%。但要注意，混合精度对某些模型可能不适用，比如涉及大量小数值累加的模型，float16的精度可能不够。

8.3 分布式训练的入门配置

当单卡训练太慢或者模型太大单卡放不下时，就需要用到分布式训练。TensorFlow提供了MirroredStrategy用于单机多卡，MultiWorkerMirroredStrategy用于多机多卡。最简单的单机多卡配置：

strategy = tf.distribute.MirroredStrategy() print('设备数量:', strategy.num_replicas_in_sync) with strategy.scope(): model = build_model() model.compile(optimizer='adam', loss='mse')

在strategy.scope()里定义的模型和优化器会自动处理梯度同步和变量复制。批次大小要按设备数量放大，比如单卡用32，双卡就用64，保证每张卡拿到的数据量一致。分布式训练涉及的概念比较多，建议先用单卡把流程跑通，再逐步扩展到多卡。

9. 写在最后的一些个人体会

TensorFlow这个框架，刚上手的时候确实会觉得东西多、概念杂，但用久了会发现它的设计是有内在逻辑的。从张量到计算图，从Keras高层API到tf.data数据管道，从单机训练到分布式部署，每一层都在解决特定场景下的问题。我的建议是不要试图一次性把所有东西都学会，而是带着具体任务去学。比如你想做一个图像分类器，那就从数据加载、模型搭建、训练评估这条主线走一遍，遇到什么问题查什么文档。走完一遍之后，再回头看那些之前不理解的概念，会有豁然开朗的感觉。

另外，TensorFlow的官方文档和教程质量其实很高，但很多人不看文档直接搜博客，结果被各种过时的、不准确的教程带偏。我的习惯是：遇到问题先查官方API文档，确认函数签名和参数含义，再去社区看别人的使用经验。官方文档可能读起来枯燥，但准确性是最高的。

还有一个体会是，版本管理非常重要。TensorFlow的API在不同版本之间变化很大，网上很多教程还是1.x时代的写法，直接拿来用会报一堆错。所以看教程的时候一定要先确认对应的TensorFlow版本，最好在虚拟环境里锁定版本号，避免因为版本升级导致代码跑不通。