Tensorflow2.0学习笔记

简单神经网络

简单的神经网络

import tensorflow as tf
import numpy as np
import tensorflow.keras as keras
import tensorflow.keras.layers as layers
input_data = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=float)
out_data = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=float)
l0 = layers.Dense(units=4, input_shape=[1])
l1 = layers.Dense(units=4)
l2 = layers.Dense(units=1)
model = keras.Sequential([l0, l1, l2])
model.compile(loss='mean_squared_error', optimizer=keras.optimizers.Adam(0.1))
model.fit(input_data, out_data, epochs=500, verbose=False)
print("Finished training the model")
print(model.predict([100]))

衣服分类识别
数据集 fashion_mnist

import tensorflow as tf
import numpy as np
import tensorflow.keras as keras
import tensorflow.keras.layers as layers
import tensorflow_datasets as tfds
from tensorflow.python.keras.utils import get_file
import gzip
import math
import matplotlib.pyplot as plt
dataset, metadata = tfds.load('fashion_mnist', as_supervised=True, with_info=True)
train_dataset, test_dataset = dataset['train'], dataset['test']
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress','Coat',
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
num_train_examples = metadata.splits['train'].num_examples
num_test_examples = metadata.splits['test'].num_examples
print ("train data nums: {}".format(num_train_examples))
print ("test data nums: {}".format(num_test_examples))
def normalize(images, labels):
images = tf.cast(images, tf.float32)
images /= 255
return images, labels
train_dataset = train_dataset.map(normalize)
test_dataset = test_dataset.map(normalize)
for image, label in test_dataset.take(1):
break
image = image.numpy().reshape((28, 28))
#plt.figure()
#plt.imshow(image, cmap=plt.cm.binary)
#plt.colorbar()
#plt.grid(False)
#plt.show()
#
model = keras.Sequential([
layers.Flatten(input_shape=(28, 28, 1)),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
BATCH_SIZE = 32
train_dataset = train_dataset.repeat().shuffle(num_train_examples).batch(BATCH_SIZE)
test_dataset = test_dataset.batch(BATCH_SIZE)
model.fit(train_dataset, epochs=5, steps_per_epoch=math.ceil(num_train_examples/BATCH_SIZE))
test_loss, test_accuracy = model.evaluate(test_dataset, steps=math.ceil(num_test_examples/32))
print("Accuracy on test dataset: ", test_accuracy)
for test_images, test_labels in test_dataset.take(1):
test_images = test_images.numpy()
test_labels = test_labels.numpy()
predictions = model.predict(test_images)
print(predictions.shape)
print(predictions[0])
np.argmax(predictions[0])
test_labels[0]
def plot_image(i, predictions_array, true_labels, images):
predictions_array, true_label, img = predictions_array[i], true_labels[i], images[i]
plt.grid(False)
plt.xticks([])
plt.yticks([])
plt.imshow(img[...,0], 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)
#plt.show()
def plot_value_array(i, predictions_array, true_label):
predictions_array, true_label = predictions_array[i], true_label[i]
plt.grid(False)
plt.xticks([])
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')
i = 0
plt.figure(figsize=(6, 3))
plt.subplot(1, 2, 1)
plot_image(i, predictions, test_labels, test_images)
plt.show()
plt.subplot(1, 2, 2)
plot_value_array(i, predictions, test_labels)
plt.show()
i = 12
plt.figure(figsize=(6, 3))
plt.subplot(1, 2, 1)
plot_image(i, predictions, test_labels, test_images)
plt.show()
plt.subplot(1, 2, 2)
plot_value_array(i, predictions, test_labels)
num_rows = 5
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
plt.subplot(num_rows, 2*num_cols, 2*i+1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(num_rows, 2*num_cols, 2*i+2)
plot_value_array(i, predictions, test_labels)
plt.show()
img = test_images[0]
print(img.shape)
img = np.array([img])
print(img.shape)
predictions_single = model.predict(img)
print(predictions_single)
plot_value_array(0, predictions_single, test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)
print(np.argmax(predictions_single[0]))

CNN卷积神经网络

识别黑白服饰图像

import tensorflow as tf
import numpy as np
import tensorflow.keras as keras
import tensorflow.keras.layers as layers
import tensorflow_datasets as tfds
import gzip
import math
import matplotlib.pyplot as plt
dataset, metadata = tfds.load('fashion_mnist', as_supervised=True, with_info=True)
train_dataset, test_dataset = dataset['train'], dataset['test']
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress','Coat',
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
num_train_examples = metadata.splits['train'].num_examples
num_test_examples = metadata.splits['test'].num_examples
print ("train data nums: {}".format(num_train_examples))
print ("test data nums: {}".format(num_test_examples))
def normalize(images, labels):
images = tf.cast(images, tf.float32)
images /= 255
return images, labels
train_dataset = train_dataset.map(normalize)
test_dataset = test_dataset.map(normalize)
for image, label in test_dataset.take(1):
break
image = image.numpy().reshape((28, 28))
plt.figure()
plt.imshow(image, cmap=plt.cm.binary)
plt.colorbar()
plt.grid(False)
plt.show()
plt.figure(figsize=(10, 10))
i = 0
for (image, label) in test_dataset.take(25):
image = image.numpy().reshape((28, 28))
plt.subplot(5, 5, i + 1)
plt.grid(False)
plt.xticks([])
plt.yticks([])
plt.imshow(image, cmap=plt.cm.binary)
plt.xlabel(class_names[label])
i += 1
plt.show()
model = keras.Sequential([
layers.Conv2D(32, (3,3), padding='same',
activation=tf.nn.relu, input_shape=(28, 28, 1)),
layers.MaxPooling2D((2, 2), strides=2),
layers.Conv2D(64, (3,3), padding='same', activation=tf.nn.relu),
layers.MaxPooling2D((2, 2), strides=2),
layers.Flatten(),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
BATCH_SIZE = 32
train_dataset = train_dataset.repeat().shuffle(num_train_examples).batch(BATCH_SIZE)
test_dataset = test_dataset.batch(BATCH_SIZE)
model.fit(train_dataset, epochs=10, steps_per_epoch=math.ceil(num_train_examples/BATCH_SIZE))
test_loss, test_accuracy = model.evaluate(test_dataset, steps=math.ceil(num_test_examples/32))
print("Accuracy on test dataset: ", test_accuracy)
for test_images, test_labels in test_dataset.take(1):
test_images = test_images.numpy()
test_labels = test_labels.numpy()
predictions = model.predict(test_images)
print(predictions.shape)
print(predictions[0])
np.argmax(predictions[0])
test_labels[0]
def plot_image(i, predictions_array, true_labels, images):
predictions_array, true_label, img = predictions_array[i], true_labels[i], images[i]
plt.grid(False)
plt.xticks([])
plt.yticks([])
plt.imshow(img[...,0], 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[i], true_label[i]
plt.grid(False)
plt.xticks([])
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')
i = 0
plt.figure(figsize=(6, 3))
plt.subplot(1, 2, 1)
plot_image(i, predictions, test_labels, test_images)
plt.show()
plt.subplot(1, 2, 2)
plot_value_array(i, predictions, test_labels)
plt.show()
i = 12
plt.figure(figsize=(6, 3))
plt.subplot(1, 2, 1)
plot_image(i, predictions, test_labels, test_images)
plt.show()
plt.subplot(1, 2, 2)
plot_value_array(i, predictions, test_labels)
plt.show()
num_rows = 5
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
plt.subplot(num_rows, 2*num_cols, 2*i+1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(num_rows, 2*num_cols, 2*i+2)
plot_value_array(i, predictions, test_labels)
plt.show()
img = test_images[0]
print(img.shape)
img = np.array([img])
print(img.shape)
predictions_single = model.predict(img)
print(predictions_single)
plot_value_array(0, predictions_single, test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)
print(np.argmax(predictions_single[0]))

识别彩色图像
数据集: cats_and_dogs_filter.zip
https://pan.baidu.com/s/1rzP4jLocYit2iMQv2o30Cw

import os
import tensorflow as tf
import numpy as np
import tensorflow.keras as keras
import tensorflow.keras.layers as layers
import tensorflow_datasets as tfds
import gzip
import math
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing.image import ImageDataGenerator
#_URL = "ftp://cats_and_dogs_filtered.zip"
#zip_dir = keras.utils.get_file('cats_and_dogs_filtered.zip', origin=_URL, extract=True)
zip_dir = "datasets/cats_and_dogs_filtered"
base_dir = os.path.join(os.path.dirname(zip_dir), "cats_and_dogs_filtered")
train_dir = os.path.join(base_dir, "train")
validation_dir = os.path.join(base_dir, "validation")
train_cats_dir = os.path.join(train_dir, "cats")
train_dogs_dir = os.path.join(train_dir, "dogs")
validation_cats_dir = os.path.join(validation_dir, "cats")
validation_dogs_dir = os.path.join(validation_dir, "dogs")
num_cats_tr = len(os.listdir(train_cats_dir))
num_dogs_tr = len(os.listdir(train_dogs_dir))
num_cats_val = len(os.listdir(validation_cats_dir))
num_dogs_val = len(os.listdir(validation_dogs_dir))
total_train = num_cats_tr + num_dogs_tr
total_val = num_cats_val + num_dogs_val
print("total training cat images:", num_cats_tr)
print("total training dog images:", num_dogs_tr)
print("total validation cat images:", num_cats_val)
print("total validation dog images:", num_dogs_val)
print("--")
print("Total training images:", total_train)
print("Total validation images:", total_val)
BATCH_SIZE = 100
IMG_SHAPE = 150
train_image_generator = ImageDataGenerator(rescale=1./255)
validation_image_generator = ImageDataGenerator(rescale=1./255)
train_data_gen = train_image_generator.flow_from_directory(batch_size=BATCH_SIZE,
directory=train_dir,
shuffle=True,
target_size=(IMG_SHAPE,IMG_SHAPE),
class_mode='binary')
val_data_gen = validation_image_generator.flow_from_directory(batch_size=BATCH_SIZE,
directory=validation_dir,
shuffle=False,
target_size=(IMG_SHAPE,IMG_SHAPE),
class_mode='binary')
def plotImages(images_arr):
fig, axes = plt.subplots(1, 5, figsize=(20,20))
axes = axes.flatten()
for img, ax in zip(images_arr, axes):
ax.imshow(img)
plt.tight_layout()
plt.show()
sample_training_images, _ = next(train_data_gen)
#plotImages(sample_training_images[:5])
model = keras.models.Sequential([
layers.Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)),
layers.MaxPooling2D(2, 2),
layers.Conv2D(64, (3,3), activation='relu'),
layers.MaxPooling2D(2, 2),
layers.Conv2D(128, (3,3), activation='relu'),
layers.MaxPooling2D(2, 2),
layers.Conv2D(128, (3,3), activation='relu'),
layers.MaxPooling2D(2, 2),
layers.Flatten(),
layers.Dense(512, activation='relu'),
layers.Dense(2, activation='softmax'),
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.summary()
EPOCHS = 5
history = model.fit_generator(
train_data_gen,
steps_per_epoch=int(np.ceil(total_train / float(BATCH_SIZE))),
epochs=EPOCHS,
validation_data=val_data_gen,
validation_steps=int(np.ceil(total_val / float(BATCH_SIZE)))
)
#print model training history
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(EPOCHS)
plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.savefig('./foo.png')
plt.show()

Softmax 与 S 型函数
在这个模型中，我们使用了以下 CNN 结构：

model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Conv2D(128, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Conv2D(128, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512, activation='relu'),
tf.keras.layers.Dense(2, activation='softmax')
])

注意，最后一个层级（分类器）由一个 Dense 层（具有 2 个输出单元）和一个 softmax 激活函数组成，如下所示：

tf.keras.layers.Dense(2, activation='softmax')

在处理二元分类问题时，另一个常见方法是：分类器由一个 Dense 层（具有 1 个输出单元）和一个 sigmoid 激活函数组成，如下所示：

tf.keras.layers.Dense(1, activation='sigmoid')

这两种方法都适合二元分类问题，但是请注意，如果决定在分类器中使用 sigmoid 激活函数，需要将 model.compile() 方法中的 loss 参数从 ‘sparse_categorical_crossentropy’ 更改为’binary_crossentropy’，如下所示：

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

过拟合问题的解决方法：

防止过拟合的三种不同技巧：

早停法：对于此方法，我们会在训练过程中跟踪验证集的损失，并根据该损失判断何时停止训练，使模型很准确，但是不会过拟合。

图像增强：通过向训练集中的现有图像应用随机图像转换，人为地增加训练集中的图像数量。通过向原始训练集应用各种随机图像转换创建新的训练图像（随机旋转、水平翻转、随机缩放等等）

image_gen_train = ImageDataGenerator(rescale=1./255,
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')

丢弃：在训练过程中，从神经网络中随机选择固定数量的神经元并关闭这些神经元。

layers.Dropout(0.5)

但是，这些并非防止过拟合的唯一技巧。请点击以下链接，深入了解这些技巧和其他技巧：
Memorizing is not learning! — 6 tricks to prevent overfitting in machine learning

总结

学习了如何使用卷积神经网络处理彩色图像，并且学习了避免过拟合的各种技巧。知识要点包括：

使用 CNN 处理不同尺寸的 RGB 图像：

• 调整尺寸：在处理不同尺寸的图像时，我们必须将所有图像调整为相同的尺寸，这样才能传入 CNN。
• 彩色图像：计算机会将彩色图像解析为三维数组。
• RGB 图像：彩色图像由三个颜色通道组成：红、绿和蓝。
• 卷积：在处理 RGB图像时，我们使用各自的卷积过滤器对每个颜色通道执行卷积运算。对每个颜色通道执行卷积运算的过程与灰阶图像一样，即对卷积过滤器（核）与输入数组的一部分执行元素级乘法运算。将每次卷积的结果相加，并加上偏差值，得出卷积输出。
• 最大池化：在处理 RGB
  图像时，我们会使用相同的窗口大小和步长对每个颜色通道执行最大池化运算。对每个颜色通道执行最大池化运算的过程与灰阶图像一样，即从每个窗口中选择最大值。
• 验证集：我们使用验证集检查模型在训练过程中的效果。我们可以根据验证集应用早停法技巧，防止过拟合；并且可以使用验证集比较不同的模型，然后选择最佳模型。

防止过拟合的方法：

• 早停法：对于此方法，我们会在训练过程中跟踪验证集的损失，并根据该损失判断何时停止训练，使模型很准确，但是不会过拟合。
• 图像增强：通过向训练集中的现有图像应用随机图像转换，人为地增加训练集中的图像数量。
• 丢弃：在训练过程中，从神经网络中随机选择固定数量的神经元并关闭这些神经元。

创建并训练了一个分类猫狗图像的卷积神经网络，并且查看了应用及未应用图像增强和丢弃技巧后的效果。发现图像增强和丢弃能够显著降低过拟合问题并提高准确率。

• 创建一个分类花朵图像的 CNN

最后

以上就是结实秀发为你收集整理的Tensorflow2.0学习笔记的全部内容，希望文章能够帮你解决Tensorflow2.0学习笔记所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。