Tensorflow模型保存

2021-01-25 13:22:47 28 收藏
分类专栏： 深度学习 文章标签： 网络 tensorflow 深度学习 python 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44575660/article/details/113104269
版权

保存整个模型

此方法保存以下所有内容：
1.权重值 2.模型配置（架构） 3.优化器配置
整个模型可以保存到一个文件中，其中包含权重值、模型配置乃至优化器配置。这样，您就可以为模型设置检查点，并稍后从完全相同的状态继续训练，而无需访问原始代码。在 Keras 中保存完全可正常使用的模型非常有用，您可以在 TensorFlow.js 中加载它们，然后在网络浏览器中训练和运行它们。Keras 使用 HDF5 标准提供基本的保存格式。
模型保存

model.save('less_model.h5')

模型加载

new_model = tf.keras.models.load_model('less_model.h5')

实例

import numpy as np
import tensorflow as tf
import gzip
import gzip

import numpy as np
import tensorflow as tf


def get_data():
    # 文件获取
    train_image = r"../../dataset/fashion-mnist/train-images-idx3-ubyte.gz"
    test_image = r"../../dataset/fashion-mnist/t10k-images-idx3-ubyte.gz"
    train_label = r"../../dataset/fashion-mnist/train-labels-idx1-ubyte.gz"
    test_label = r"../../dataset/fashion-mnist/t10k-labels-idx1-ubyte.gz"  # 文件路径
    paths = [train_label, train_image, test_label, test_image]

    with gzip.open(paths[0], 'rb') as lbpath:
        y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[1], 'rb') as imgpath:
        x_train = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)

    with gzip.open(paths[2], 'rb') as lbpath:
        y_test = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[3], 'rb') as imgpath:
        x_test = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)

    return (x_train, y_train), (x_test, y_test)


(train_image, train_label), (test_image, test_label) = get_data()

train_image = train_image / 255
test_image = test_image / 255

model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))  # 28*28
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))

print(model.summary())

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['acc']
              )
model.fit(train_image, train_label, epochs=3)
print(model.evaluate(test_image, test_label, verbose=0))

model.save('less_model.h5')

new_model = tf.keras.models.load_model('less_model.h5')
print(new_model.summary())
new_model.fit(train_image, train_label, epochs=3)
print(new_model.evaluate(test_image, test_label, verbose=0))

仅保存架构

有时我们只对模型的架构感兴趣，而无需保存权重值或优化器。在这种情况下，可以仅保存模型的“配置” 。

获取权重

json_config = model.to_json()

加载权重

reinitialized_model = tf.keras.models.model_from_json(json_config)

实例

import gzip

import numpy as np
import tensorflow as tf


def get_data():
    # 文件获取
    train_image = r"../../dataset/fashion-mnist/train-images-idx3-ubyte.gz"
    test_image = r"../../dataset/fashion-mnist/t10k-images-idx3-ubyte.gz"
    train_label = r"../../dataset/fashion-mnist/train-labels-idx1-ubyte.gz"
    test_label = r"../../dataset/fashion-mnist/t10k-labels-idx1-ubyte.gz"  # 文件路径
    paths = [train_label, train_image, test_label, test_image]

    with gzip.open(paths[0], 'rb') as lbpath:
        y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[1], 'rb') as imgpath:
        x_train = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)

    with gzip.open(paths[2], 'rb') as lbpath:
        y_test = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[3], 'rb') as imgpath:
        x_test = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)

    return (x_train, y_train), (x_test, y_test)


(train_image, train_label), (test_image, test_label) = get_data()

train_image = train_image / 255
test_image = test_image / 255

model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))  # 28*28
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))

print(model.summary())

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['acc']
              )
model.fit(train_image, train_label, epochs=3)
print(model.evaluate(test_image, test_label, verbose=0))

model_json = model.to_json()
with open('model.json', 'w') as file:
    file.write(model_json)

with open('model.json', 'r') as file:
    json_config = file.read()
reinitialized_model = tf.keras.models.model_from_json(json_config)
reinitialized_model.summary()
reinitialized_model.compile(optimizer='adam',
                            loss='sparse_categorical_crossentropy',
                            metrics=['acc']
                            )

print(reinitialized_model.evaluate(test_image, test_label, verbose=0))

仅保存权重

有时我们只需要保存模型的状态（其权重值），而对模型架构不感兴趣。在这种情况下，可以通过get_weights()获取权重值，并通过set_weights()设置权重值
保存权重

model.save_weights('less_weights.h5')

读取权重

reinitialized_model.load_weights('less_weights.h5')

实例

import numpy as np
import tensorflow as tf
import gzip
import gzip

import numpy as np
import tensorflow as tf


def get_data():
    # 文件获取
    train_image = r"../../dataset/fashion-mnist/train-images-idx3-ubyte.gz"
    test_image = r"../../dataset/fashion-mnist/t10k-images-idx3-ubyte.gz"
    train_label = r"../../dataset/fashion-mnist/train-labels-idx1-ubyte.gz"
    test_label = r"../../dataset/fashion-mnist/t10k-labels-idx1-ubyte.gz"  # 文件路径
    paths = [train_label, train_image, test_label, test_image]

    with gzip.open(paths[0], 'rb') as lbpath:
        y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[1], 'rb') as imgpath:
        x_train = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)

    with gzip.open(paths[2], 'rb') as lbpath:
        y_test = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[3], 'rb') as imgpath:
        x_test = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)

    return (x_train, y_train), (x_test, y_test)


(train_image, train_label), (test_image, test_label) = get_data()

train_image = train_image / 255
test_image = test_image / 255

model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))  # 28*28
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))

print(model.summary())

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['acc']
              )
model.fit(train_image, train_label, epochs=3)
print(model.evaluate(test_image, test_label, verbose=0))

model.save_weights('less_weights.h5')
with open('model.json', 'r') as file:
    json_config = file.read()
reinitialized_model = tf.keras.models.model_from_json(json_config)
reinitialized_model.summary()
reinitialized_model.compile(optimizer='adam',
                            loss='sparse_categorical_crossentropy',
                            metrics=['acc']
                            )
reinitialized_model.load_weights('less_weights.h5')
print(reinitialized_model.evaluate(test_image, test_label, verbose=0))

保存检查点

在训练期间或训练结束时自动保存检查点。这样一来，您便可以使用经过训练的模型，而无需重新训练该模型，或从上次暂停的地方继续训练，以防训练过程中断。
保存检查点

checkpoint_path = 'training_cp/cp.ckpt'
cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
                                                 save_weights_only=True)
# 在训练时使用回调函数指定
model.fit(train_image, train_label, epochs=3, callbacks=[cp_callback])

读取检查点

model.load_weights(checkpoint_path)

实例

import numpy as np
import tensorflow as tf
import gzip
import gzip

import numpy as np
import tensorflow as tf
def get_data():
    # 文件获取
    train_image = r"../../dataset/fashion-mnist/train-images-idx3-ubyte.gz"
    test_image = r"../../dataset/fashion-mnist/t10k-images-idx3-ubyte.gz"
    train_label = r"../../dataset/fashion-mnist/train-labels-idx1-ubyte.gz"
    test_label = r"../../dataset/fashion-mnist/t10k-labels-idx1-ubyte.gz"  # 文件路径
    paths = [train_label, train_image, test_label, test_image]

    with gzip.open(paths[0], 'rb') as lbpath:
        y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[1], 'rb') as imgpath:
        x_train = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)

    with gzip.open(paths[2], 'rb') as lbpath:
        y_test = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[3], 'rb') as imgpath:
        x_test = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)

    return (x_train, y_train), (x_test, y_test)


(train_image, train_label), (test_image, test_label) = get_data()

train_image = train_image / 255
test_image = test_image / 255

checkpoint_path = 'training_cp/cp.ckpt'
cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
                                                 save_weights_only=True)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28)))  # 28*28
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['acc']
)
# model.fit(train_image, train_label, epochs=3, callbacks=[cp_callback])
# print(model.evaluate(test_image, test_label, verbose=0))

model.load_weights(checkpoint_path)
print(model.evaluate(test_image, test_label, verbose=0))

自定义训练中保存检查点

import datetime
import gzip
import os

import numpy as np
import tensorflow as tf

# 创建常量
v = tf.Variable(0.0)
# 通过assign改变常量的值
v.assign(5)
# 通过assign_add将变量+1
v.assign_add(1)


# print(v)
# print(v.read_value().numpy())

# w = tf.Variable([[1.0]])
# with tf.GradientTape() as t:
#     loss = w * w
# grad = t.gradient(loss, w)
# print(grad)

# 常量需要添加监听
# ww = tf.constant(3.0)
# with tf.GradientTape() as t:
#     t.watch(ww)
#     loss = ww * ww
# grad = t.gradient(loss, ww)
# print(grad)

# 通过persistent=Ture永久的记录计算
# w = tf.constant(3.0)
# with tf.GradientTape(persistent=True) as t:
#     t.watch(w)
#     y = w * w
#     z = y * y
# dy_dw = t.gradient(y, w)
# print(dy_dw)
# dz_dw = t.gradient(z, w)
# print(dz_dw)


def get_data():
    # 文件获取
    train_image = r"../../dataset/fashion-mnist/train-images-idx3-ubyte.gz"
    test_image = r"../../dataset/fashion-mnist/t10k-images-idx3-ubyte.gz"
    train_label = r"../../dataset/fashion-mnist/train-labels-idx1-ubyte.gz"
    test_label = r"../../dataset/fashion-mnist/t10k-labels-idx1-ubyte.gz"  # 文件路径
    paths = [train_label, train_image, test_label, test_image]

    with gzip.open(paths[0], 'rb') as lbpath:
        y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[1], 'rb') as imgpath:
        x_train = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)

    with gzip.open(paths[2], 'rb') as lbpath:
        y_test = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[3], 'rb') as imgpath:
        x_test = np.frombuffer(
            imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)

    return (x_train, y_train), (x_test, y_test)


(train_image, train_label), (test_image, test_label) = get_data()
train_image = tf.expand_dims(train_image, -1)
test_image = tf.expand_dims(test_image, -1)
print(train_image.shape)
train_image = tf.cast(train_image / 255, tf.float32)
test_image = tf.cast(test_image / 255, tf.float32)
train_label = tf.cast(train_label, tf.int64)
test_label = tf.cast(test_label, tf.int64)
dataset = tf.data.Dataset.from_tensor_slices((train_image, train_label))
test_dataset = tf.data.Dataset.from_tensor_slices((test_image, test_label))
dataset = dataset.shuffle(10000).batch(32)
test_dataset = test_dataset.batch(32)
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(16, [3, 3], activation='relu', input_shape=(None, None, 1)),
    tf.keras.layers.Conv2D(32, [3, 3], activation='relu'),
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(10)
])
optimizer = tf.keras.optimizers.Adam()
# 顺序编码使用SparseCategoricalCrossentropy,最后一层没有激活使用from_logits=True
loss_func = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

# 取出一个批次
fratures, labels = next(iter(dataset))

predictions = model(fratures)
# 在第一个维度查看predictions最大值
print(tf.argmax(predictions, axis=1))

train_loss = tf.keras.metrics.Mean('train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
test_loss = tf.keras.metrics.Mean('test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('test_accuracy')

# -----------------第一步-----------------------------
# 创建文件编写器
current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'tensorboard/logs/' + current_time + '/train'
test_log_dir = 'tensorboard/logs/' + current_time + '/test'
train_summary_writer = tf.summary.create_file_writer(train_log_dir)
test_summary_writer = tf.summary.create_file_writer(test_log_dir)

cp_dir = './customtrain_cp'
cp_prefix = os.path.join(cp_dir, 'ckpt')
checkpoint = tf.train.Checkpoint(optimizer=optimizer,
                                 model=model
                                 )


def loss(model, x, y):
    y_ = model(x)
    return loss_func(y, y_)


# 对一个batchsh数据进行优化
def train_step(model, images, labels):
    # 计算损失值
    with tf.GradientTape() as t:
        pred = model(images)
        loss_step = loss_func(labels, pred)
    # 计算梯度
    grads = t.gradient(loss_step, model.trainable_variables)
    # 优化
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    train_loss(loss_step)
    # 第一个参数为正确结果，第二个参数为预测结果
    train_accuracy(labels, pred)


# 对一个batchsh数据进行优化
def test_step(model, images, labels):
    # 计算损失值
    pred = model(images)
    loss_step = loss_func(labels, pred)
    test_loss(loss_step)
    # 第一个参数为正确结果，第二个参数为预测结果
    test_accuracy(labels, pred)


# 对每一个循环进行训练
def train():
    for epoch in range(3):
        for (batch, (images, labels)) in enumerate(dataset):
            train_step(model, images, labels)

        # -----------------第二步-----------------------------
        # 保存训练的loss和acc
        train_summary_writer.set_as_default()
        tf.summary.scalar('loss', train_loss.result(), step=epoch)
        tf.summary.scalar('acc', train_accuracy.result(), step=epoch)

        for (batch, (images, labels)) in enumerate(test_dataset):
            test_step(model, images, labels)

        # -----------------第三步-----------------------------
        # 保存测试的loss和acc
        test_summary_writer.set_as_default()
        tf.summary.scalar('loss', test_loss.result(), step=epoch)
        tf.summary.scalar('acc', test_accuracy.result(), step=epoch)

    print('Epoch{} loss is {},accuracy is {},test_loss is {},test_accuracy is {}'.format(epoch, train_loss.result(),
                                                                                         train_accuracy.result(),
                                                                                         test_loss.result(),
                                                                                         test_accuracy.result()))
    # 重置状态
    train_loss.reset_states()
    train_accuracy.reset_states()
    test_loss.reset_states()
    test_accuracy.reset_states()

    if (epoch + 1) % 2 == 0:
        checkpoint.save(file_prefix=cp_prefix)


# train()
# 汇总计算模块
m = tf.keras.metrics.Mean('acc')
m(10)
m([10, 2, 34, 34])
m.result().numpy()
# 重置指标计算模块状态
m.reset_states()
a = tf.keras.metrics.SparseCategoricalAccuracy('acc')
a(labels, model(fratures))

# 恢复检查点
checkpoint.restore(tf.train.latest_checkpoint(cp_dir))
# 查看准确率
print((tf.argmax(model(train_image, training=False), axis=-1).numpy() == train_label).sum()/len(train_label))
已标记关键词 清除标记
tensorflow保存和恢复模型的两种方法介绍
fly_time2012的专栏
09-28 1万+
一、前言 本文将会介绍tensorflow保存和恢复模型的两种方法，一种是传统的Saver类save保存和restore恢复方法，还有一种是比较新颖的SavedModelBuilder类的builder保存和loader文件里的load恢复方法。通过了解这两种方法，我们可以解决如何保存和恢复一个已经训练好的神经网络模型用于推理预测的现实需求，也可以辅助查看分析一个长时间训练的模型性能，最重要的是...
表情包
插入表情
还能输入1000个字符
相关推荐
tensorflow将.h5模型转换成.pb
大鱼的博客
12-04 2177
keras使用起来十分简洁，我们经常会拿来训练数据，然后保存为模型.h5，然而对于tensorflow来说，.pb才是它的通用格式，因为tensorflow-js，tensorflow-lite,tensorflow-serving都会使用到，因此转换是具有很强的实际意义的。 import tensorflow as tf tf.keras.backend.set_learning_...
tensorflow2之模型加载恢复(h5)
v7xyy的博客
08-13 3268
使用new_model = tf.keras.models.load_model('my_model.h5') 创建一个与 my_model相同的模型并加载权重测试。 创建model_hand_h5_load.py #encoding=utf-8 # 手动创建和加载 *.h5 模型和权重值 from __future__ import absolute_import, division...
TensorFlow模型保存和提取方法
marsjhao Blog
06-01 7万+
一、TensorFlow模型保存和提取方法 1. TensorFlow通过tf.train.Saver类实现神经网络模型的保存和提取。tf.train.Saver对象saver的save方法将TensorFlow模型保存到指定路径中，saver.save(sess,"Model/model.ckpt")，实际在这个文件目录下会生成4个人文件： checkpoint文件保存了一个录下多有的模
最全Tensorflow模型保存和提取的方法——附实例
缘分天空，美丽的梦的博客
05-06 1万+
一、Tensorflow模型的保存和提取方法1、Tensorflow通过tf.train.Saver类实现神经网络模型的保存和提取。tf.train.Saver对象saver的save方法将Tensoreflow模型保存到指定的路径中，saver.save(sess,'model/model.ckpt).实际在这个文件目录下有4个文件：checkpoint 文件保存了一个录下多有的模型文件列表，m...
Tensorflow模型的保存和加载
归去来兮的博客
04-18 9540
刚接触深度学习，Tensorflow模型的保存和加载尚不清楚，根据教程的翻译做一记录，不当之处敬请指正。原文地址：http://cv-tricks.com/tensorflow-tutorial/save-restore-tensorflow-models-quick-complete-tutorial/在本教程中，将作出如下讲解：    I.   Tensorflow模型是什么样的？    II...
『TensorFlow』模型载入方法汇总
weixin_34178244的博客
08-09 217
『TensorFlow』第七弹_保存&载入会话_霸王回马 一、TensorFlow常规模型加载方法 保存模型 tf.train.Saver()类，.save(sess, ckpt文件目录)方法 参数名称 功能说明 默认值 var_list Saver中存储变量集合 全局变量集合 reshape 加载时是否恢复变量形状 True ...
tensorflow保存模型和加载模型
tsfx051435adsl的博客
03-21 1333
又在公司的电脑上偷偷学习，趁boss没发现，赶紧发个blog 保存模型 关键代码： saver = tf.train.Saver(max_to_step) saver.save(session,filename) 例子：一元线性函数回归并保存模型 def line_regression(): x_data = np.random.rand(100) y_data = x_da...
TensorFlow模型保存和加载方法
跟着大数据和AI去旅行
01-28 5044
TensorFlow模型保存和加载方法 模型保存 import tensorflow as tf w1 = tf.Variable(tf.constant(2.0, shape=[1]), name="w1-name") w2 = tf.Variable(tf.constant(3.0, shape=[1]), name="w2-name") a = tf.placeholder(dt
tensorflow模型持久化保存和加载
weixin_30642869的博客
04-23 233
模型文件的保存tensorflow将模型保持到本地会生成4个文件：meta文件：保存了网络的图结构，包含变量、op、集合等信息ckpt文件： 二进制文件，保存了网络中所有权重、偏置等变量数值，分为两个文件，一个是.data-00000-of-00001 文件，一个是 .index 文件checkpoint文件：文本文件，记录了最新保持的5个模型文件列表tf中模型保...
tensorflow 保存训练模型ckpt 查看ckpt文件中的变量名和对应值
weixin_34405332的博客
11-01 1421
  TensorFlow 模型保存与恢复   一个快速完整的教程，以保存和恢复Tensorflow模型。 在本教程中，我将会解释： TensorFlow模型是什么样的？ 如何保存TensorFlow模型？ 如何恢复预测/转移学习的TensorFlow模型？ 如何使用导入的预先训练的模型进行微调和修改? 这个教程假设你已经对神经网络有了一定的了解。如果不了解的话请查阅相关资料。 1. 什么是Te...
TensorFlow中的模型保存文件
flyminnnnn的博客
06-09 500
文件构成 由TensorFlow保存的训练模型文件由四个文件组成： . ├── checkpoint ├── v18.ckpt-2333.data-00000-of-00001 ├── v18.ckpt-2333.index └── v18.ckpt-2333.meta 每个文件的内容为： 文件 描述 checkpoint 指示文件夹中多个不同训练结果的属性，即如果在训练过程中保...
Tensorflow实现简单的一元线性回归并保存和加载模型
wangTongGen
09-21 2661
简介：本文章以tensorflow为平台建立了一个简单的线性回归模型，并得到了不错的效果。同时实现了模型的保存与加载，当一个模型的训练时间非常长的时候，利用模型的加载可以实现开启程序时接着上次训练。 平台：Python 3.6 IDE：Pycharm 一、线性回归模型介绍 简单来说：线性回归就是利用一曲线段对一些连续的数据进行拟合，进而可以用这条曲线预测新的输出值。数学模型如下： 其中：w...
如何使用Tensorflow保存或者加载模型(三) -- Keras
mp43ily的博客
08-22 399
1.背景 Keras是一个非常易于上手，好用的深度学习框架。不仅容易构建模型，而且容易保存模型。目前，Keras已经被纳入到Tensorflow框架中了，因此站长打算在介绍Tensorflow模型保存的时候，可以一并把Keras的模型训练和保存也介绍了。 1.1 模型构建 下面可以以一个简单的demo模型来作为说明，构建模型结构。 # -*- coding: utf-8 -*- # @Time ...
tensorflow模型加载与保存的两种方式
ShenWeiKKX的博客
09-26 452
pass
tensorflow模型保存与加载
shuzfan的专栏
01-29 9699
tensorflow版本为1.4.1 tensorflow提供了Saver类用于模型的保存与导入。该类定义在tensorflow/python/training/saver.py.中。 Saver类的默认初始化函数如下： __init__( var_list=None, reshape=False, sharded=False, max_to_keep=5
Tensorflow训练的模型，如何保存与载入？
GeekZW的博客
05-15 6344
Tensorflow训练的模型，如何保存与载入？目的：学习tensorflow框架的DNN，掌握如何将tensorflow训练得到的模型保存并载入，做预测？内容：1、tensorflow模型保存与载入的两种方法2、实例分析1——线性回归3、实例分析2——mnist分类一、tensorflow模型保存与载入的两种方法参考网址：https://blog.csdn.net/thriving_fcl/ar...
tensorflow入门教程(四十二)ckpt,pb模型的保存,固化和加载操作
韦访的专栏
05-25 5765
# #作者：韦访 #博客：https://blog.csdn.net/rookie_wei #微信：1007895847 #添加微信的备注一下是CSDN的 #欢迎大家一起学习 # ------韦访 20190525 1、概述 又是25号，老天保佑我摇到车牌啊～～开玩笑，这不是今天的重点。有网友表示，模型训练出来以后，不知道要怎么用，今天就来聊聊tensorflow模型的保存、固化、加载等操作...
©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页