tensorflow使用（待完善）

使用tensorflow实现一个神经元

• 实现一个神经元计算 Y=2X-1 方程

• 在训练的过程中会打印loss的变小过程

  ............
  Epoch 499/500

  1/1 [==============================] - 0s 878us/step - loss: 0.0486

  Epoch 500/500

  1/1 [==============================] - 0s 824us/step - loss: 0.0485

#导包
import tensorflow.keras as keras
import numpy as np
from tensorflow.keras.layers import Dense

# 构建模型：一个神经元个数为1，输入为个数1的一个隐藏层
model = keras.Sequential(Dense(1, input_shape=[1]))

# 指定优化和损失函数
model.compile(optimizer='sgd', loss='mean_squared_error')

# 训练数据
x = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], dtype=float)
y = np.array([-2.0, -1.0, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 13.0, 15.0], dtype=float)

# 训练
model.fit(x, y, epochs=500)

# 预测结果
print(model.predict([10.0]))

---

加载官方提供的学习数据:FashionMNIST

• 第一次执行的时候会触发下载

import matplotlib.pyplot as plt

from tensorflow import keras

# 加载FashionMNIST
fashion_mnist = keras.datasets.fashion_mnist
# 下载使用使用官方的图片数据，自动分为训练集和测试集
(train_images, train_labels), (test_image, test_labels) = fashion_mnist.load_data()
#
print("训练集图片个数", train_images.shape)
print("训练集label个数", train_labels.shape)
print("第一个训练数据\n", train_images[0])
print("第一个训练数据的像素个数\n", train_images[0].shape)
print("前5个标签\n", train_labels[:5])
print("查看第一张图片")
plt.imshow(train_images[0])

---

构建全连接的神经网络

# 官方28*28像素MNISIT图片训练的神经网络
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import Flatten, Dense

fashion_mnist = keras.datasets.fashion_mnist
# 下载使用使用官方的图片数据，自动分为训练集和测试集
(train_images, train_labels), (test_image, test_labels) = fashion_mnist.load_data()

model = keras.Sequential()
# 构建输入层，及输入层的数据矩阵格式
model.add(Flatten(input_shape=(28, 28)))
# 构建一个隐藏层，该层有128个神经元。该层的每个神经元都接收28*28=784个数据，该层总共接收784*128=
model.add(Dense(128, activation=tf.nn.relu))
# 构建输出层，该层有10个神经元
model.add(Dense(10, activation=tf.nn.softmax))
# 查看构建的网络结构
# moudle.summary()

# 指定优化、损失函数、
model.compile(optimizer=tf.optimizers.Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
train_images = train_images / 255  # 处理训练数据为0-1直接的数，可以优化训练
# 通过训练数据和训练标签及训练指定次数，开始训练
model.fit(train_images, train_labels, epochs=10)  # 训练次数过多会出现过拟合情况。当loss出现最低点是就表示发生了

# test_image = test_image / 255  # 需要做同样的优化

print("查看测试数据的损失度")
# model.evaluate(test_image, test_labels)
print("预测第0张测试图片类别，应该取最大的np.argmax")
# 增加数组维度，将维度变为(1,28,28) https://blog.csdn.net/weixin_45954454/article/details/114437165
predict_data = tf.reshape(test_image[2], (1, 28, 28))
# print(model.predict(predict_data))
print(np.argmax(model.predict(predict_data / 255)))
print(test_labels[2])
model.save_weights('./models/model')

---

恢复上面保存的训练过的模型

# 恢复使用 MNISITNNetword 中保存的模型
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.python.keras.layers import Flatten, Dense, Conv2D, MaxPooling2D

fashion_mnist = keras.datasets.fashion_mnist
# 下载使用使用官方的图片数据，自动分为训练集和测试集
(train_images, train_labels), (test_image, test_labels) = fashion_mnist.load_data()

# 构建和保存时相同的神经网络结构
model = keras.models.Sequential([
    Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1)),  # 64个过滤器，每个过滤器大小3*3，激活函数relu。该层输入的shape
    MaxPooling2D(2, 2),  #
    Conv2D(64, (3, 3), activation='relu'),  # 这里为什么要把input_shape=(28, 28, 1)删掉
    MaxPooling2D(2, 2),
    Flatten(),  # 这里为什么要把input_shape=(28, 28)删掉
    Dense(128, activation=tf.nn.relu),
    Dense(10, activation=tf.nn.softmax)
])

model.load_weights('./models/model')

predict_data = tf.reshape(test_image[0], (1, 28, 28,1))
print(np.argmax(model.predict(predict_data / 255)))
print(test_labels[0])

---

卷积神经网络

# 识别物品的特征来判断物品
# 使用一个过滤器扫描输入，这个过滤器可以找到特征
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import Flatten, Dense, Conv2D, MaxPooling2D

fashion_mnist = keras.datasets.fashion_mnist
# 下载使用使用官方的图片数据，自动分为训练集和测试集
(train_images, train_labels), (test_image, test_labels) = fashion_mnist.load_data()

model = keras.models.Sequential([
    Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1)),  # 64个过滤器，每个过滤器大小3*3，激活函数relu。该层输入的shape
    MaxPooling2D(2, 2),  #
    Conv2D(64, (3, 3), activation='relu'),  # 这里为什么要把input_shape=(28, 28, 1)删掉
    MaxPooling2D(2, 2),
    Flatten(),  # 这里为什么要把input_shape=(28, 28)删掉
    Dense(128, activation=tf.nn.relu),
    Dense(10, activation=tf.nn.softmax)
])

fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_image, test_labels) = fashion_mnist.load_data()
model.compile(optimizer=tf.optimizers.Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
train_images = train_images / 255
model.fit(train_images.reshape(-1, 28, 28, 1), train_labels, epochs=2)

predict_data = tf.reshape(test_image[2], (1, 28, 28,1))
# print(model.predict(predict_data))
print(np.argmax(model.predict(predict_data / 255)))
print(test_labels[2])
model.save_weights('./models/model')

---

到达某个损失度时自动停止训练

• 继承自callback类，并且实现on_epoch_end方法

# 自动终止训练
# 次数太多会出现过拟合的情况:训练的时候loss一直降低，但是测试的时候loss确有最低值的情况
# 需要添加训练的回调方法，在回调中判断是否调用 self.model.stop_training = True 停止训练
import tensorflow as tf

class MyCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        if logs.get('loss') < 0.4:
            print("损失度达到较小值，停止训练")
            self.model.stop_training = True
            
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import Flatten, Dense

fashion_mnist = keras.datasets.fashion_mnist
# 下载使用使用官方的图片数据，自动分为训练集和测试集
(train_images, train_labels), (test_image, test_labels) = fashion_mnist.load_data()

model = keras.Sequential()
# 构建输入层，及输入层的数据矩阵格式
model.add(Flatten(input_shape=(28, 28)))
# 构建一个隐藏层，该层有128个神经元。该层的每个神经元都接收28*28=784个数据，该层总共接收784*128=
model.add(Dense(128, activation=tf.nn.relu))
# 构建输出层，该层有10个神经元
model.add(Dense(10, activation=tf.nn.softmax))
# 查看构建的网络结构
# moudle.summary()

# 指定优化、损失函数、
model.compile(optimizer=tf.optimizers.Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
train_images = train_images / 255  # 处理训练数据为0-1直接的数，可以优化训练
# 通过训练数据和训练标签及训练指定次数，开始训练
################################################## 创建mycallback并传入下面的callbacks数组中 ##########################################################
mycallback = MyCallback()
model.fit(train_images, train_labels, epochs=10, callbacks=[mycallback])  # 训练次数过多会出现过拟合情况。当loss出现最低点是就表示发生了
#
# test_image = test_image / 255  # 需要做同样的优化

print("查看测试数据的损失度")
# model.evaluate(test_image, test_labels)
print("预测第0张测试图片类别，应该取最大的np.argmax")
# 增加数组维度，将维度变为(1,28,28) https://blog.csdn.net/weixin_45954454/article/details/114437165
predict_data = tf.reshape(test_image[2], (1, 28, 28))
# print(model.predict(predict_data))
print(np.argmax(model.predict(predict_data / 255)))
print(test_labels[2])
model.save_weights('./models/model')