TensorFlow2.0函数使用学习

一.使用TensorFlow对MNITS数据集进行深度学习

from __future__ import absolute_import, division, print_function

from abc import ABC

from tensorflow.keras.datasets import mnist
from tensorflow.keras import Model, layers
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np

# MNIST数据集参数
num_classes = 10  # 总的图像类别 (数字0-9).
num_features = 784  # 一张图像所拥有的特征点，即像素点个数 (图像大小: 28*28=784).

# 训练参数.
learning_rate = 0.1  # 学习率，控制收敛的过程
training_steps = 2000  # 迭代训练次数
batch_size = 256  # 训练时所使用的样本数，一般从总样本中随机抽取
display_step = 100  # 计算过程中，显示训练结果的间隔

# 神经网络的结构
n_hidden_1 = 128  # 第一层网络的神经元个数
n_hidden_2 = 256  # 第二层神经元的个数

# 准备MNIST数据集用于训练
(x_train, y_train), (x_test, y_test) = mnist.load_data()  # 从MNIST数据源加载数据,train:60000组(28,28)的uint8数据
x_train, x_test = np.array(x_train, np.float32), np.array(x_test, np.float32)  # 将从MNIST加载的uint8型数据转换成float32型数据
x_train, x_test = x_train.reshape([-1, num_features]), x_test.reshape([-1, num_features])  # 将（28,28）的数组转换为（784,1）的数组
x_train, x_test = x_train / 255., x_test / 255.  # 将0-255的数据范围映射到0-1的范围内

# 使用 tf.data API 打乱数据组并选取部分数据作为样本，选取的样本数量由batch_size决定
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(5000).batch(batch_size).prefetch(1)


# 创建用于生成神经网络实例的类
class NeuralNet(Model, ABC):
    # Set layers.
    def __init__(self):
        super(NeuralNet, self).__init__()
        # First fully-connected hidden layer.
        self.fc1 = layers.Dense(n_hidden_1, activation=tf.nn.relu)
        # First fully-connected hidden layer.
        self.fc2 = layers.Dense(n_hidden_2, activation=tf.nn.relu)
        # Second fully-connected hidden layer.
        self.out = layers.Dense(num_classes)

    # Set forward pass.
    def call(self, x, is_training=False):
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.out(x)
        if not is_training:
            # tf cross entropy expect logits without softmax, so only
            # apply softmax when not training.
            x = tf.nn.softmax(x)
        return x


# 创建一个神经网络模型.
neural_net = NeuralNet()


# Cross-Entropy Loss.交叉熵损失计算函数
def cross_entropy_loss(x, y):
    """
      计算logits和labels之间的稀疏softmax交叉熵
      :param x:
      :param y:
      :return:  计算张量tensor沿着指定的数轴（tensor的某一维度）上的的平均值
    """
    y = tf.cast(y, tf.int64)  # 将标签张量转换为指定数据（int64）
    loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=x)  # 计算logits和labels之间的稀疏softmax交叉熵
    return tf.reduce_mean(loss)  # 计算张量tensor沿着指定的数轴（tensor的某一维度）上的的平均值


# Accuracy metric.准确率计算
def accuracy(y_pred, y_true):
    """
      计算预测值y_pred和真实值y_true之间的准确率
      :param y_pred:
      :param y_true:
      :return:  准确率的平均值
    """
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.cast(y_true, tf.int64))  # 计算准确率
    return tf.reduce_mean(tf.cast(correct_prediction, tf.float32), axis=-1)  # 计算准确率的平均值


# Stochastic gradient descent optimizer.
optimizer = tf.optimizers.SGD(learning_rate)


# Optimization process.优化过程
def run_optimization(x, y):
    """
    对参数进行优化
    :param x: 训练样本
    :param y: 训练标签
    :return:
    """
    # Wrap computation inside a GradientTape for automatic differentiation.
    with tf.GradientTape() as g:
        pred = neural_net(x, is_training=True)  # 生成计算用的神经网络实例对象
        loss = cross_entropy_loss(pred, y)  # 计算交叉熵损失

    trainable_variables = neural_net.trainable_variables  # 创建训练用的变量
    gradients = g.gradient(loss, trainable_variables)  # 计算梯度
    optimizer.apply_gradients(zip(gradients, trainable_variables))  # 通过梯度更新参数w和b


# 使用导入的数据对模型进行训练
for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):
    run_optimization(batch_x, batch_y)  # 启动参数优化

    if step % display_step == 0:
        pred = neural_net(batch_x, is_training=True)  # 提取神经网络中的参数
        loss = cross_entropy_loss(pred, batch_y)  # 提取交叉熵损失
        acc = accuracy(pred, batch_y)  # 计算准确率
        print("step: %i, loss: %f, accuracy: %f" % (step, loss, acc))  # 输出计算结果


# 计算生成的模型在验证数据集上的正确率
pred = neural_net(x_test, is_training=False)
print("Test Accuracy: %f" % accuracy(pred, y_test))
neural_net.summary()  # 生成的模型一览
neural_net.save("G:\\MNIST_model")  # 保存训练好的模型

# 从数据集上提取5张照片，验证结果的正确性
n_images = 5
test_images = x_test[100:100 + n_images]
predictions = neural_net(test_images)

# 显示图像
for i in range(n_images):
    plt.imshow(np.reshape(test_images[i], [28, 28]), cmap='gray')
    plt.show()
    print("Model prediction: %i" % np.argmax(predictions.numpy()[i]))

二.使用TensorFlow生成的model对图像进行预测

from __future__ import absolute_import, division, print_function

from matplotlib import pyplot as plt
from tensorflow import keras
import numpy as np
import cv2

neural_net = keras.models.load_model("G:\\MNIST_model")  # 导入生成的模型

test_images = cv2.imread("G:\\2.png")  # 读取图片
test_images = cv2.cvtColor(test_images, cv2.COLOR_RGB2GRAY)  # 将RGB图片转换为灰度值图片
test_images = np.array(test_images, np.float32)  # 将加载的uint8型数据转换成float32型数据
test_images = test_images.reshape(-1, 784)  # 将（28,28）的数组转换为（784,1）的数组
test_images = test_images / 255.  # 将0-255的数据范围映射到0-1的范围内

predictions = neural_net(test_images)  # 使用模型对图片进行预测
plt.imshow(np.reshape(test_images, [28, 28]), cmap='gray')
plt.show()  # 显示图像
print("Model prediction: %i" % np.argmax(predictions.numpy()))  # 打印预测的结果

输入图像:

预测结果:

三.使用TensorFlow求解线性回归

import tensorflow.compat.v1 as tf
import random

tf.disable_v2_behavior()


m = tf.get_variable("m", [], initializer=tf.constant_initializer(0.))  # 创建变量
b = tf.get_variable("b", [], initializer=tf.constant_initializer(0.))  # 创建变量
init = tf.global_variables_initializer()  # 初始化变量

input_placeholder = tf.placeholder(tf.float32)  # 创建输入占位符
output_placeholder = tf.placeholder(tf.float32)  # 创建输出占位符

x = input_placeholder
y = output_placeholder
y_guess = m * x + b  # 创建运算表达式

loss = tf.square(y - y_guess)  # 定义损失函数

optimizer = tf.train.GradientDescentOptimizer(1e-3)  # 设置优化阈值
train_op = optimizer.minimize(loss)  # 设置极小值

sess = tf.Session()  # 创建会话
sess.run(init)  # 启动会话

true_m = random.random()  # 设置数据源
true_b = random.random()  # 设置数据源
for update_i in range(50000):

    input_data = random.random()  # 设置输入
    output_data = true_m * input_data + true_b  # 设置输出
    _loss, _ = sess.run([loss, train_op], feed_dict={input_placeholder: input_data, output_placeholder: output_data})
    print(update_i, _loss)

print("True parameters: m=%s, b=%s" % (true_m, true_b))  # 打印设置的数据源
print("Learned parameters: m=%s, b=%s" % (tuple(sess.run([m, b]))))  # 打印拟合的数据源