keras学习笔记（2）

1.卷积神经网络卫星图片识别

import tensorflow as tf
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import pandas as pd
import pathlib#面向对象的路径管理工具，类似os

data_dir='./2_class'

data_root=pathlib.Path(data_dir)#创建路径对象

data_root#WindowsPath('2_class')

#对目录迭代
for item in data_root.iterdir():#对象的提取目录方法
    print(item)#2_classairplane， 2_classlake

#提取出所有路径，对象的提取所有文件方法
all_image_path=list(data_root.glob('*/*'))#正则，提取出所有目录下的所有文件

image_count=len(all_image_path)#一共1400张

all_image_path[:3]

all_image_path[-3:]

#设置路径，变成纯正路径

all_image_path=[str(path) for path in all_image_path]

#图片路径乱序
import random
random.shuffle(all_image_path)

#设置标签
label_names=sorted(item.name for item in data_root.glob('*/'))#，提取路径的左右目录，两个文件夹的名字

label_names

label_to_index=dict((name,index) for index,name in enumerate(label_names))#将标签（文件名）换成数字

label_to_index



all_image_label=[label_to_index[pathlib.Path(p).parent.name] for p in all_image_path]

all_image_label[:5]

all_image_path[:5]

import IPython.display as display

index_to_label=dict((v,k )for k,v in label_to_index.items())

index_to_label

for n in range(3):
    image_index=random.choice(range(len(all_image_path)))
    display.display(display.Image(all_image_path[image_index]))
    print(index_to_label[all_image_label[image_index]])
    print()

img_path=all_image_path[0]

img_path

img_raw=tf.io.read_file(img_path)#tensor类型的图片二进制文件

#图片解码
img_tensor=tf.image.decode_image(img_raw)

print(img_tensor.shape)

img_tensor.dtype

img_tensor

#图片标准化
img_tensor=tf.cast(img_tensor,tf.float32)
img_tensor=img_tensor/255

img_tensor.numpy().max()

img_tensor.numpy().min()

#写成与i个函数
def load_preprosess_image(img_path):
    img_raw=tf.io.read_file(img_path)
    img_tensor=tf.image.decode_jpeg(img_raw,channels=3)
    img_tensor=tf.image.resize(img_tensor,[256,256])
    img_tensor=tf.cast(img_tensor,tf.float32)
    img=img_tensor/255
    return img

plt.imshow(load_preprosess_image(all_image_path[100]))#取第100张图片看一下

path_ds=tf.data.Dataset.from_tensor_slices(all_image_path)

path_ds

image_dataset=path_ds.map(load_preprosess_image)#图片数据

#标签数据
label_dataset=tf.data.Dataset.from_tensor_slices(all_image_label)

for label in label_dataset.take(10):
    print(label.numpy())

image_dataset

for img in image_dataset.take(1):
    print(img)

#数据标签合并成一个数据
dataset=tf.data.Dataset.zip((image_dataset,label_dataset))

dataset

#划分数据集
test_count=int(image_count*0.2)
train_count=image_count-test_count

test_count,train_count

train_dataset=dataset.skip(test_count)

test_dataset=dataset.take(test_count)

BATCH_SIZE=32

#repeat方法可以使dataset源源不断的产生数据
train_dataset=train_dataset.repeat().shuffle(buffer_size=train_count).batch(BATCH_SIZE)

test_dataset=test_dataset.batch(BATCH_SIZE)

#构造模型
model=tf.keras.Sequential()
model.add(tf.keras.layers.Conv2D(64,(3,3),input_shape=(256,256,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Conv2D(64,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPooling2D())
model.add(tf.keras.layers.Conv2D(128,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Conv2D(128,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPooling2D())
model.add(tf.keras.layers.Conv2D(256,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Conv2D(256,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPooling2D())
model.add(tf.keras.layers.Conv2D(512,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPooling2D())
model.add(tf.keras.layers.Conv2D(512,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPooling2D())
model.add(tf.keras.layers.Conv2D(1024,(3,3),activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.GlobalAveragePooling2D())
model.add(tf.keras.layers.Dense(1024,activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Dense(256,activation='relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Dense(10,activation='sigmoid'))

model.summary()

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

steps_per_epoch=train_count//BATCH_SIZE
validation_steps=test_count//BATCH_SIZE

history=model.fit(train_dataset,epochs=1,steps_per_epoch=steps_per_epoch,validation_data=test_dataset,validation_steps=validation_steps)

history

　2.序列问题，电影评论数据

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

(x_train,y_train),(x_test,y_test)=keras.datasets.imdb.load_data(num_words=10000)#每条评论的单词对应的索引不超过10000

x_train.shape

x_train[0]

y_train.shape

[len(x) for x in x_train]#每条评论的长度

x_train=keras.preprocessing.sequence.pad_sequences(x_train,300)#每条评论填充成300个单词长
x_test=keras.preprocessing.sequence.pad_sequences(x_test,300)

[len(x) for x in x_train]#每条评论的长度

test='i am a student'
dict((word,test.split().index(word)) for word in test.split())

model=keras.models.Sequential()


model.add(layers.Embedding(10000,50,input_length=300))#输入数据最大10000，映射成维50的密集向量(25000,300)>>>>>>(25000,300,50)

#model.add(layers.Flatten())#(25000,300,50)>>>>>>>>>(25000,300*50)


model.add(layers.GlobalAveragePooling1D())#可以代替Flatten层，#(25000,300,50)>>>>>>>>>(25000,50)

model.add(layers.Dense(128,activation='relu'))

model.add(layers.Dropout(0.3))

model.add(layers.Dense(1,activation='sigmoid'))

model.summary()

model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.001),loss='binary_crossentropy',metrics=['acc'])

history=model.fit(x_train,y_train,epochs=10,batch_size=256,validation_data=(x_test,y_test))

history.history.keys()

import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(history.epoch,history.history['loss'],'r')
plt.plot(history.epoch,history.history['val_loss'],'b--')

plt.plot(history.epoch,history.history['acc'],'r')
plt.plot(history.epoch,history.history['val_acc'],'b--')

　3.猫狗数据集 图片数据增强

import keras
from keras import layers
import numpy as np
import os
import shutil

base_dir = './dataset/cat_dog'
train_dir = os.path.join(base_dir , 'train')
train_dir_dog = os.path.join(train_dir , 'dog')
train_dir_cat = os.path.join(train_dir , 'cat')

test_dir = os.path.join(base_dir , 'test')
test_dir_dog = os.path.join(test_dir , 'dog')
test_dir_cat = os.path.join(test_dir , 'cat')
dc_dir = './dataset/dc/train'

if not os.path.exists(base_dir):
    os.mkdir(base_dir)
    os.mkdir(train_dir)
    os.mkdir(train_dir_dog)
    os.mkdir(train_dir_cat)
    os.mkdir(test_dir)
    os.mkdir(test_dir_dog)
    os.mkdir(test_dir_cat)

    fnames = ['cat.{}.jpg'.format(i) for i in range(1000)]
    for fname in fnames:
        s = os.path.join(dc_dir, fname)
        d = os.path.join(train_dir_cat, fname)
        shutil.copyfile(s, d)

    fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)]
    for fname in fnames:
        s = os.path.join(dc_dir, fname)
        d = os.path.join(test_dir_cat, fname)
        shutil.copyfile(s, d)

    fnames = ['dog.{}.jpg'.format(i) for i in range(1000)]
    for fname in fnames:
        s = os.path.join(dc_dir, fname)
        d = os.path.join(train_dir_dog, fname)
        shutil.copyfile(s, d)

    fnames = ['dog.{}.jpg'.format(i) for i in range(1000, 1500)]
    for fname in fnames:
        s = os.path.join(dc_dir, fname)
        d = os.path.join(test_dir_dog, fname)
        shutil.copyfile(s, d)

(1) 读取图片

（2）将图片解码

（3）预处理图片，大小

（4）图片归一化

from keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(rescale=1/255,
                                  rotation_range=40,
                                  width_shift_range=0.2,      
                                  height_shift_range=0.2,
                                  brightness_range=(0.6, 1),
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    vertical_flip=True)
test_datagen = ImageDataGenerator(rescale=1/255)

train_generator = train_datagen.flow_from_directory(train_dir,
                                                    target_size=(200, 200),
                                                    batch_size=20,
                                                    class_mode='binary'
)

import matplotlib.pyplot as plt
%matplotlib inline

for im_batch in train_generator:
    for im in im_batch:
        plt.imshow(im[0])
        break
    break

test_generator = test_datagen.flow_from_directory(test_dir,
                                                    target_size=(200, 200),
                                                    batch_size=20,
                                                    class_mode='binary'
)





model = keras.Sequential()

model.add(layers.Conv2D(64, (3, 3), activation="relu", input_shape=(200, 200, 3)))
model.add(layers.Conv2D(64, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))

model.add(layers.Conv2D(64, (3, 3), activation="relu"))
model.add(layers.Conv2D(64, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))

model.add(layers.Conv2D(64, (3, 3), activation="relu"))
model.add(layers.Conv2D(64, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))

model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dropout(0.5))

model.add(layers.Dense(1, activation='sigmoid'))

model.summary()

model.compile(optimizer=keras.optimizers.Adam(lr),
              loss='binary_crossentropy',
              metrics=['acc']
)

history = model.fit_generator(
    train_generator,
    epochs=30,
    steps_per_epoch=100,
    validation_data=test_generator,
    validation_steps=50
)

keras.optimizers

　4.Eager模式

import tensorflow as tf

tf.executing_eagerly()

x=[[2,]]

m=tf.matmul(x,x)#矩阵相乘

m#Tensor的两个属性：shape，dtype。不可变

m.numpy()#tensor的方法

a=tf.constant([[1,2],[3,4]])

a

b=tf.add(a,1)

b

c=tf.multiply(a,b)#对应元素相乘

c

num=tf.convert_to_tensor(10)#数字转换成tensor类型，tensor不仅可以在cpu工作，也可以在gpu工作

num

for i in range(num.numpy()):
    i=tf.constant(i)
    if int(i%2)==0:#tenor对象应用numpy的计算方法时，会自动地转换成numpu类型，ndarray和tensor可以直接运算
        print('even')
    else:
        print('odd')

v=tf.Variable(0.0)#定义变量

v+1

v.assign(5)#改变变量的值

v.assign_add(1)#变量加1

#读取变量、
v.read_value()

#记录运算过程，方便求解梯度,跟踪变量运算,必须是float类型
w=tf.Variable([[1.0]])
with tf.GradientTape() as t:
    loss=w*w

grad=t.gradient(loss,w)

grad

#跟踪常量运算
w=tf.constant(3.0)
with tf.GradientTape() as t:
    t.watch(w)
    loss=w*w

dloss_dw=t.gradient(loss,w)

dloss_dw

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)

dy_dw

dz_dw=t.gradient(z,w)

dz_dw

(train_image,train_labels),(test_image,test_labels)=tf.keras.datasets.mnist.load_data()

train_image.shape

train_labels

#扩张图像的维度
train_image=tf.expand_dims(train_image,-1)#最后一维扩张

test_image=tf.expand_dims(test_image,-1)

train_image.shape

#改变数据类型，float
train_image=tf.cast(train_image/255,tf.float32)

test_image=tf.cast(test_image/255,tf.float32)

#转换标签数据类型
train_labels=tf.cast(train_labels,tf.int64)

test_labels=tf.cast(test_labels,tf.int64)

#作为tf.data加载进来
dataset=tf.data.Dataset.from_tensor_slices((train_image,train_labels))#输入必须时元组类型

#作为tf.data加载进来
test_dataset=tf.data.Dataset.from_tensor_slices((test_image,test_labels))#输入必须时元组类型

dataset

dataset=dataset.shuffle(10000).batch(32)#数据混洗

test_dataset=test_dataset.batch(32)

dataset

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.GlobalMaxPooling2D(),
                          tf.keras.layers.Dense(10)])

model.trainable_variables

#自定义循环
optimizer=tf.keras.optimizers.Adam()

loss_func=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

features,labels=next(iter(dataset))

features.shape

labels.shape

predictions=model(features)

predictions.shape

tf.argmax(predictions,axis=1)#每行的最大值下标

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

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')



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)

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(10):
        for (batch,(images,labels)) in enumerate(dataset):
            train_step(model,images,labels)
        print('Epoch{} loss is {},acc is{}'.format(epoch,train_loss.result(),train_accuracy.result()))
        for (batch,(images,labels)) in enumerate(test_dataset):
            test_step(model,images,labels)
            print('Epoch{} test_loss is {},acc is{}'.format(epoch,test_loss.result(),test_accuracy.result()))
        train_loss.reset_states()
        train_accuracy.reset_states()
        test_loss.reset_states()
        test_accuracy.reset_states()

train()

#tf.keras.metrics汇总计算模块
m=tf.keras.metrics.Mean('acc')#初始化求均值对象m.result(),m.reset_states()重置

a=tf.keras.metrics.SparseCategoricalAccuracy('acc')
a(labels,model(features))

　5.Tensorboard可视化

import tensorflow  as tf
import datetime

tf.__version__

(train_image, train_labels), (test_image, test_labels) = tf.keras.datasets.mnist.load_data()

train_image.shape

train_image = tf.expand_dims(train_image, -1)

test_image = tf.expand_dims(test_image, -1)

train_image.shape

train_image = tf.cast(train_image/255, tf.float32)

test_image = tf.cast(test_image/255, tf.float32)

train_labels = tf.cast(train_labels, tf.int64)

test_labels = tf.cast(test_labels, tf.int64)

dataset = tf.data.Dataset.from_tensor_slices((train_image, train_labels))

test_dataset = tf.data.Dataset.from_tensor_slices((test_image, test_labels))

dataset

dataset = dataset.repeat(1).shuffle(60000).batch(128)

test_dataset = test_dataset.repeat(1).batch(128)

dataset

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.GlobalMaxPooling2D(),
    tf.keras.layers.Dense(10, activation='softmax')
])

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

import datetime
import os

log_dir=os.path.join("logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

file_writer = tf.summary.create_file_writer(log_dir + "/metrics")
file_writer.set_as_default()

def lr_schedule(epoch):
    """
    Returns a custom learning rate that decreases as epochs progress.
    """
    learning_rate = 0.2
    if epoch > 5:
        learning_rate = 0.02
    if epoch > 10:
        learning_rate = 0.01
    if epoch > 20:
        learning_rate = 0.005

    tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
    return learning_rate

lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_schedule)

model.fit(dataset,
          epochs=5,
          steps_per_epoch=60000//128,
          validation_data=test_dataset,
          validation_steps=10000//128,
          callbacks=[tensorboard_callback])

%load_ext tensorboard
%matplotlib inline

%tensorboard --logdir logs
'''SCALARS 面板主要用于记录诸如准确率、损失和学习率等单个值的变化趋势。在代码中用 tf.summary.scalar() 来将其记录到文件中

每个图的右下角都有 3 个小图标，第一个是查看大图，第二个是是否对 y 轴对数化，第三个是如果你拖动或者缩放了坐标轴，再重新回到原始位置。

GRAPHS 面板展示出你所构建的网络整体结构，显示数据流的方向和大小，也可以显示训练时每个节点的用时、耗费的内存大小以及参数多少。默认显示的图分为两部分：主图（Main Graph）和辅助节点（Auxiliary Nodes）。其中主图显示的就是网络结构，辅助节点则显示的是初始化、训练、保存等节点。我们可以双击某个节点或者点击节点右上角的 + 来展开查看里面的情况，也可以对齐进行缩放

DISTRIBUTIONS 主要用来展示网络中各参数随训练步数的增加的变化情况，可以说是 多分位数折线图 的堆叠。

HISTOGRAMS 和 DISTRIBUTIONS 是对同一数据不同方式的展现。与 DISTRIBUTIONS 不同的是，HISTOGRAMS 可以说是 频数分布直方图 的堆叠。

# 记录自定义标量

重新调整回归模型并记录自定义学习率。这是如何做：

使用创建文件编写器tf.summary.create_file_writer()。

定义自定义学习率功能。这将被传递给Keras LearningRateScheduler回调。

在学习率功能内，用于tf.summary.scalar()记录自定义学习率。

将LearningRateScheduler回调传递给Model.fit（）。

通常，要记录自定义标量，您需要使用tf.summary.scalar()文件编写器。文件编写器负责将此运行的数据写入指定的目录，并在使用时隐式使用tf.summary.scalar()。
'''
model.fit(dataset,
          epochs=30,
          steps_per_epoch=60000//128,
          validation_data=test_dataset,
          validation_steps=10000//128,
          callbacks=[tensorboard_callback, lr_callback])





# 自定义训练中使用Tensorboard

optimizer = tf.keras.optimizers.Adam()

loss_func = tf.keras.losses.SparseCategoricalCrossentropy()

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

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')

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)

def test_step(model, images, labels):
    pred = model(images)
    loss_step = loss_func(labels, pred)
    test_loss(loss_step)
    test_accuracy(labels, pred)

current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'logs/gradient_tape/' + current_time + '/train'
test_log_dir = 'logs/gradient_tape/' + 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)

def train():
    for epoch in range(10):
        for (batch, (images, labels)) in enumerate(dataset):
            train_step(model, images, labels)
            print('.', end='')
    
        with train_summary_writer.as_default():
            tf.summary.scalar('loss', train_loss.result(), step=epoch)
            tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)
        
        for (batch, (images, labels)) in enumerate(test_dataset):
            test_step(model, images, labels)
            print('*', end='')
            
        with test_summary_writer.as_default():
            tf.summary.scalar('loss', test_loss.result(), step=epoch)
            tf.summary.scalar('accuracy', test_accuracy.result(), step=epoch)
        template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
        print(template.format(epoch+1,
                               train_loss.result(), 
                               train_accuracy.result()*100,
                               test_loss.result(), 
                               test_accuracy.result()*100))
        
        train_loss.reset_states()
        train_accuracy.reset_states()
        test_loss.reset_states()
        test_accuracy.reset_states()

train()

%tensorboard --logdir logs/gradient_tape