tensorflow学习1 --先跑个简单例程熟悉流程

PyCharm Community Edition 2021.3.2
/Miniconda3-py38_4.9.2
cudnn7.6.5 cuda10.1 tf2.2.0 keras2.3.1
重要学习资源
Keras中文文档
pandas说明文档官网

多分类例程

基本分类：对服装图像进行分类

选定数据库

fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

keras.datasets是官方数据集 这些数据集不仅标好了标签，还分配好了训练和测试的数量，但标签分类对应的字符串含义要我们自己写个枚举。
其中
boston_housing：波斯顿房屋价格回归数据集
cifar10：CIFAR10小图像分类数据集
cifar100：CIFAR100小图像分类数据集
fashion_mnist：Fashion-MNIST 数据集.
imdb：IMDB 分类数据集
mnist：MNIST手写数字数据集
reuters：路透社主题分类数据集

keras.datasets的官方说明文档

构建模型【建立网络

# 预处理 将这些值缩小至 0 到 1 之间
train_images = train_images / 255.0   #图片的数据居然是可以直接除的吗
test_images = test_images / 255.0
# 建立3层网络
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)), # 网络第一层 把二维像素展成一维
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)  # 返回10类分类结果
])
# 设置 优化器、损失函数、指标
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

Sequential 的意思是连续的、有序的。被Sequential（）赋值的model可以用.add方法来增加一层网络，也可以直接在Sequential（）的初始化里直接设置。等model开始训练时会挨个进行这些网络的运算。第一层必须设定大小（或者形状或者深度）
深入学习Keras中Sequential模型及方法
activation=激活函数，为了让神经网络的计算变成非线性 以使其能逼近任何函数。S型不好用，反向传播的时候会削弱梯度；现在用_/比较多，收敛比较快。
常用激活函数（激励函数）理解与总结

训练模型

model.fit(train_images, train_labels, epochs=10)

将已经标好标签的数据，标签，标签数量传进网络（即 将训练数据馈送给模型）

1875/1875 [==============================] - 3s 1ms/step - loss: 0.2366 - accuracy: 0.9122

在模型训练期间，会显示损失和准确率指标
训练集跑得好不代表什么，它有可能欠拟合或者过拟合。

评估模型【用测试集检查正确率

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

如果说训练模型是上课学习，测试集就是写作业自己对答案
这一步是出师的关键，如果没问题就能投入使用了，不然就要重新处理数据、修改网络

进行预测 （开始打工

probability_model = tf.keras.Sequential([model, 
                                         tf.keras.layers.Softmax()])
predictions = probability_model.predict(test_images)

给模型在输出前加一层Softmax变换，让它输出概率
预测结果是对每个图像记录所有种类的置信度
上面的示例是用测试集做的预测，如果是自己的图

probability_model = tf.keras.Sequential([model, 
                                         tf.keras.layers.Softmax()])
img = (np.expand_dims(input_img,0))   
predictions_single = probability_model.predict(img)

在网站教程指导下练习的代码，有输出和注释

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow import keras

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'] #


# 输入（图片序号，对应图片的预测结果，测试集所有标好的标签，测试集所有图片）
#
def plot_image(i, predictions_array, true_label, img):
    predictions_array, true_label, img = predictions_array, true_label[i], img[i]  # 我就说嘛 拿整个测试集图片又没用 当然只拿一张
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img, cmap=plt.cm.binary)  # 显示图片

    predicted_label = np.argmax(predictions_array)  # 返回预测结果中的最大值
    if predicted_label == true_label:  # 依据正误改变画笔颜色
        color = 'blue'
    else:
        color = 'red'

    # 在图片下方说明预测情况
    plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                         100 * np.max(predictions_array),
                                         class_names[true_label]),
               color=color)


def plot_value_array(i, predictions_array, true_label):
    predictions_array, true_label = predictions_array, true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    plt.yticks([])  # 相当于给个空集 所以就是不显示了
    thisplot = plt.bar(range(10), predictions_array, color="#777777")  # 画柱状图
    plt.ylim([0, 1])
    predicted_label = np.argmax(predictions_array)

    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')  # 如果预测得对就会覆盖掉 妙呀


# 获取数据库数据
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

# train_images.shape
print(train_images.shape)  # (60000, 28, 28)有 60,000 个图像，每个图像有 28 x 28 的像素
print(train_labels)  # 每个图像的标签值（0~9

# 展示某张数据
# plt.figure()  # 画布
# plt.imshow(train_images[9])
# plt.colorbar()# 色卡
# plt.grid()# 网格
# plt.show() #这句看不出存在意义 注释掉这句 但plt.imshow(train_images[9])也能显示图片

# 预处理 将这些值缩小至 0 到 1 之间
train_images = train_images / 255.0
test_images = test_images / 255.0

# # 再次展示一下一系列的数据图
# plt.figure(figsize=(10, 10))  # 画布大小 宽*长不是图片布局
# for i in range(25):
#     plt.subplot(5, 5, i + 1)  # 行，列，当前编号
#     plt.xticks([])  # 取消掉x轴的数值 好让每个图片下面的标签显示出来
#     plt.yticks([])
#     plt.imshow(train_images[i], cmap=plt.cm.binary)  # cmap不明意义
#     plt.xlabel(class_names[train_labels[i]])   # 按枚举显示标签
# plt.show()

# 建立3层网络
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),  # 网络第一层 把二维像素展成一维
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)  # 返回10类分类结果
])

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])
# 优化器  损失函数  指标
# 学习
model.fit(train_images, train_labels, epochs=10)
# 写作业对答案
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

probability_model = tf.keras.Sequential([model,
                                         tf.keras.layers.Softmax()])
predictions = probability_model.predict(test_images)

print(predictions[0])

np.argmax(predictions[0])
i = 1
plt.figure(figsize=(6, 3))
plt.subplot(1, 2, 1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1, 2, 2)
plot_value_array(i, predictions[i], test_labels)
plt.show()

# 自己选定图片进行预测
img = test_images[1]
print(img.shape)
img = (np.expand_dims(img,0))# 就算只有一张图 也要编号
print(img.shape) #(1, 28, 28)

predictions_single = probability_model.predict(img)# predictions_single[0]里存着那个图片的10个分类的置信度
print(predictions_single)
#展示预测结果
plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)
plt.show()

二分类例程

电影评论文本分类

选定数据库

imdb = keras.datasets.imdb
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)

数据是把文字中的每个单词编号
train_data[0]是[1, 14, 22, 16, 43, 530, 973, 1622, ……, 5345, 19, 178, 32]
因为每句话长度不一样，所以等会要把长度都补成一样才能放进网络
二分类，标签是0或1。
0 代表消极评论，1 代表积极评论。

将整数转换回单词

word_index = imdb.get_word_index() # 获得数据库中把单词映射到数字编号的字典
# 这一段就是往字典前面加入这些标识
word_index = {k:(v+3) for k,v in word_index.items()} # 让编号整体挨个+3 【其中有一个是原本就有的标，后挪3位之后重新挪回去。
word_index["<PAD>"] = 0
word_index["<START>"] = 1
word_index["<UNK>"] = 2  # unknown
word_index["<UNUSED>"] = 3

reverse_word_index = dict([(value, key) for (key, value) in word_index.items()]) # 把字典反转 用词对应数字
def decode_review(text): # 翻译数据并整合成句子用的子函数
    return ' '.join([reverse_word_index.get(i, '?') for i in text])
    
print(decode_review(train_data[0]))# 就能看到一句正常的英文

python语法 1

word_index = {k:(v+3) for k,v in word_index.items()}
这句是遍历字典并给每个值+3 后赋值给word_index 输出类型是<class ‘dict’>

举一反三可得 如果要对调字典的key和value就
word_index = {v:k for k,v in word_index.items()}
代码后续有
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
这dict([]) 不加的时候print(type(empty))输出是<class ‘generator’>加了之后是<class ‘dict’>

python语法 2

return ’ ‘.join([reverse_word_index.get(i,’?') for i in text])
这句是遍历text数组里的每个数字 然后跟字典对应找出字符串 然后拼接成一句话并返回
‘ ’.join() 的意思，代表将括号里面的元素拼接成一个新的字符串
dict.get(a,[b])
a表示字典中的键，b为可选择参数，表示默认值，当没有从字典中找到键a时，返回默认值b，如果不写b，则没找到会返回None。

填充评论长度

train_data = keras.preprocessing.sequence.pad_sequences(train_data,
                                                        value=word_index["<PAD>"],
                                                        padding='post',
                                                        maxlen=256)

test_data = keras.preprocessing.sequence.pad_sequences(test_data,
                                                       value=word_index["<PAD>"],
                                                       padding='post',
                                                       maxlen=256)

嘛，就是在数组的项里的数据末尾【‘post’】填充【0】直到长度为256. 这样

构建模型【建立网络

# 输入形状是用于电影评论的词汇数目（10,000 词）
vocab_size = 10000

model = keras.Sequential() #多分类构建模型也用到这个 而且是直接在输入里用了 keras.layers
model.add(keras.layers.Embedding(vocab_size, 16))
model.add(keras.layers.GlobalAveragePooling1D())
model.add(keras.layers.Dense(16, activation='relu'))
model.add(keras.layers.Dense(1, activation='sigmoid'))

model.summary()

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])
              

不是很懂具体逻辑，后续再补机器视觉的课 咕咕咕

训练模型

# 分出1w份用来测试
x_val = train_data[:10000]
partial_x_train = train_data[10000:]

y_val = train_labels[:10000]
partial_y_train = train_labels[10000:]

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=40,
                    batch_size=512,
                    validation_data=(x_val, y_val),
                    verbose=1)

以 512 个样本的 mini-batch 大小迭代 40 个 epoch 来训练模型。
在训练过程中，监测来自验证集的 10,000 个样本上的损失值（loss）和准确率（accuracy）：

Epoch（时期）： 当一个完整的数据集通过了神经网络一次并且返回了一次，这个过程称为一次epoch。（也就是说，所有训练样本在神经网络中都 进行了一次正向传播和一次反向传播 ） 再通俗一点，一个Epoch就是将所有训练样本训练一次的过程。
然而，当一个Epoch的样本（也就是所有的训练样本）数量可能太过庞大（对于计算机而言），就需要把它分成多个小块，也就是就是分成多个Batch来进行训练。
Batch（批 / 一批样本）： 将整个训练样本分成若干个Batch。
深度学习 | 三个概念：Epoch, Batch, Iteration

评估模型【用测试集检查正确率

results = model.evaluate(test_data,  test_labels, verbose=2)

创建一个准确率（accuracy）和损失值（loss）随时间变化的图表

model.fit() 返回一个 History 对象，该对象包含一个字典

dict_keys([‘loss’, ‘accuracy’, ‘val_loss’, ‘val_accuracy’])

import matplotlib.pyplot as plt

history_dict = history.history
acc = history_dict['accuracy']
val_acc = history_dict['val_accuracy']
loss = history_dict['loss']
val_loss = history_dict['val_loss']

epochs = range(1, len(acc) + 1) # 横轴为训练次数

# “bo”代表 "蓝点"
plt.plot(epochs, loss, 'bo', label='Training loss')
# b代表“蓝色实线”
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()
#plt.clf()   # 想要换个数据再画就先清除数字然后按上面再写一套