tensorflow-Keras高层接口

1. 模型的装配、训练和测试

import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import Sequential,layers

x = tf.constant([1.,2.])

# 实例化 一个softmax
softmax = keras.layers.Softmax()

softmax(x)

#直接用不能用，只能先实例化
keras.layers.Softmax(x)

# sequential,内部写，网络的输入之后考虑
network = Sequential([
    #全连接
    layers.Dense(3), # 三个神经元
    layers.ReLU(), #神经元可以写里面，也可以写在外面
    layers.Dense(2,activation=layers.ReLU())
])

x = tf.random.truncated_normal([4,3])
network(x)

# 参数还包括偏执
network.summary()

# 也可以通过add增加新的层，动态实现网络维护
model = Sequential()
model.add(layers.Dense(3))
model.add(layers.Dense(3))
model.build((None, 4)) # None指的是样本个数为任意值，4是指有多少个特征和3个神经# 元做连接
model.summary()

2. 模型的装配、训练与测试

# 装配
model = Sequential([
    layers.Dense(256,activation='relu'),
    layers.Dense(128,activation='relu'),
    layers.Dense(64,activation='relu'),
    layers.Dense(32,activation='relu'),
    layers.Dense(10,activation='softmax')
])

model.build(input_shape=(None,784))

model.summary()

# 确定优化器optimizer(求梯度的方式)、损失函数loss、监控指标metrics等
model.compile(
            optimizer=keras.optimizers.SGD(learning_rate=0.01),
              loss = tf.keras.losses.CategoricalCrossentropy(),
              metrics = ['accuracy']
              )

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

def preprocess(x,y):
    x = tf.cast(x,dtype=tf.float32)/255.
    x = tf.reshape(x,[-1,784])
    y = tf.one_hot(y,depth=10)
    return x,y

# 合并
train_db = tf.data.Dataset.from_tensor_slices( (x_train , y_train) )
# 打乱操作
train_db = train_db.shuffle(10000) #buffer_size 缓冲区大小，防止随机每次按照不一定的随机。
# 每次训练只是进行 小批量训练
# batch_size ，每一批训练的样本大小
train_db = train_db.batch(128)
# 预处理
#一开始的数据不满足我门的要求
# 直接就是一个映射
train_db = train_db.map(preprocess)

model.fit(train_db,epochs=10

# 合并
test_db = tf.data.Dataset.from_tensor_slices( (x_test , y_test) )
# 打乱操作
test_db = test_db.shuffle(10000) #buffer_size 缓冲区大小，防止随机每次按照不一定的随机。
# 每次训练只是进行 小批量训练
# batch_size ，每一批训练的样本大小
test_db = test_db.batch(128)
# 预处理
#一开始的数据不满足我门的要求
# 直接就是一个映射
test_db = test_db.map(preprocess)

model.predict(test_db)

model.evaluate(test_db)

3. 模型的保存和加载

!dir
# 以张量的形式保存
model.save_weights('weight.ckpt') #以此保存是最轻量级的，并没有保存模型的结构

!dir

# 删除模型
del model

# 装配
model = Sequential([
    layers.Dense(256,activation='relu'),
    layers.Dense(128,activation='relu'),
    layers.Dense(64,activation='relu'),
    layers.Dense(32,activation='relu'),
    layers.Dense(10,activation='softmax')
])

# 确定优化器optimizer(求梯度的方式)、损失函数loss、监控指标metrics等
model.compile(
            optimizer=keras.optimizers.SGD(learning_rate=0.01),
              loss = tf.keras.losses.CategoricalCrossentropy(),
              metrics = ['accuracy']
              )

model.load_weights('weight.ckpt')

model.evaluate(test_db)

model.save('model.h5')

!dir

del model

model = keras.models.load_model('model.h5')

model.evaluate(test_db)

# 部署在实际中，具有平台的无惯性
tf.compat.v1.keras.experimental.export_saved_model(model,'save_model')

!dir

del model

model = tf.compat.v1.keras.experimental.load_from_saved_model('save_model')

# 这样读取的还是一个sequential
model

# 我们还需要把compile加进来
# 确定优化器optimizer(求梯度的方式)、损失函数loss、监控指标metrics等
model.compile(
            optimizer=keras.optimizers.SGD(learning_rate=0.01),
              loss = tf.keras.losses.CategoricalCrossentropy(),
              metrics = ['accuracy']
              )

model.evaluate(test_db)

4. 自定义网络层类

        继承tf.keras.layers.Layer 类，并重写init、 build 、和call三个方法

• __init__ ，可以在其中执行所有与输入无关的初始化
• build，你可以在其中了解输入张量的 形状，并可以执行其余的初始化
• call，在这里进行正向计算

import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import Sequential,layers

tf.test.is_gpu_available()

class MyDense_relu(tf.keras.layers.Layer):
    # 自定义的全连接层
    def __init__(self,units):
        super().__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_variable(name='w',
                                   shape=[input_shape[-1],self.units],#第一个维度是输入的最后形状最后一个数，即特征个数，第二个维度是网络神经元个数
                                   initializer = tf.initializers.RandomNormal() #初始化
                                   )
        self.b = self.add_variable(name='b',
                                   shape=[self.units],
                                   initializer = tf.initializers.Zeros())

    def call(self, inputs, **kwargs):
        # w*x + b
        # w [input_shape[-1] ,units]
        # x [50000]
        return tf.nn.relu(inputs @self.w + self.b)

class MyDense_softmax(tf.keras.layers.Layer):
    # 自定义的全连接层
    def __init__(self,units):
        super().__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_variable(name='w',
                                   shape=[input_shape[-1],self.units],#第一个维度是输入的最后形状最后一个数，即特征个数，第二个维度是网络神经元个数
                                   initializer = tf.initializers.RandomNormal() #初始化
                                   )
        self.b = self.add_variable(name='b',
                                   shape=[self.units],
                                   initializer = tf.initializers.Zeros())

    def call(self, inputs, **kwargs):
        # w*x + b
        # w [input_shape[-1] ,units]
        # x [50000]
        return tf.nn.softmax(inputs @self.w + self.b)

class MyMdoel(keras.Model):
    def __init__(self):
        super().__init__()
        self.fc1 = MyDense_relu(512)
        self.fc2 = MyDense_relu(256)
        self.fc3 = MyDense_relu(128)
        self.fc4 = MyDense_softmax(10)

    def call(self,inputs):
        fc1w_out = self.fc1(inputs)
        fc2w_out = self.fc2(fc1w_out)
        fc3w_out = self.fc3(fc2w_out)
        fc4w_out = self.fc4(fc3w_out)
        return fc4w_out

myModel = MyMdoel()
myModel.build(input_shape=(None,784))
myModel.summary()

myModel.compile(optimizer=keras.optimizers.SGD(),
                loss=keras.losses.CategoricalCrossentropy(),
                metrics=['accuracy'])

def preprocess(x,y):
    x = tf.cast(x,dtype=tf.float32)/255.
    x = tf.reshape(x,[-1,784])
    y = tf.one_hot(y,depth=10)
    return x,y

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 合并
train_db = tf.data.Dataset.from_tensor_slices( (x_train , y_train) )
# 打乱操作
train_db = train_db.shuffle(10000) #buffer_size 缓冲区大小，防止随机每次按照不一定的随机。
# 每次训练只是进行 小批量训练
# batch_size ，每一批训练的样本大小
train_db = train_db.batch(128)
# 预处理
#一开始的数据不满足我门的要求
# 直接就是一个映射
train_db = train_db.map(preprocess)

# 合并
test_db = tf.data.Dataset.from_tensor_slices( (x_test , y_test) )
# 打乱操作
test_db = test_db.shuffle(10000) #buffer_size 缓冲区大小，防止随机每次按照不一定的随机。
# 每次训练只是进行 小批量训练
# batch_size ，每一批训练的样本大小
test_db = test_db.batch(128)
# 预处理
#一开始的数据不满足我门的要求
# 直接就是一个映射
test_db = test_db.map(preprocess)

myModel.fit(train_db,epochs=10)

myModel.evaluate(test_db)

5. 测量工具和可视化

        新建测量器->写入数据->读入统计数据->清零测量器

        

import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow import keras
import numpy as np
from tensorflow.keras import Sequential,layers
tf.test.is_gpu_available()

# y_hat[0,1,1]
# y [0,1,2]

# 新建测量器
m= keras.metrics.Accuracy() #适用于实值
# 写入数据
m.update_state([0,1,1],[0,1,2])
# 读取统计信息
m.result()

#不清除的话，若是循环，肯定会在新建那里出问题
m.reset_states()

m.result()

# y_hat[0,1,1]
# y [0,1,2]

# 新建测量器
m= keras.metrics.CategoricalAccuracy()
# 写入数据
m.update_state([ [0,0,1] ,[0,1,0]],[ [0.1,0.9,0.8], [0.05,0.95,0]] )
# 读取统计信息
m.result()


#不清除的话，若是循环，肯定会在新建那里出问题
m.reset_states()

acc_meter = keras.metrics.Accuracy()
loss_meter = tf.keras.metrics.Mean()

# 装配
model = Sequential([
    layers.Dense(256,activation='relu'),
    layers.Dense(128,activation='relu'),
    layers.Dense(64,activation='relu'),
    layers.Dense(32,activation='relu'),
    layers.Dense(10,activation='softmax')
])

model.build(input_shape=(None,784))
model.compile(optimizer=keras.optimizers.SGD(),
                loss=keras.losses.CategoricalCrossentropy(),
                metrics=['CategoricalAccuracy'])

def preprocess(x,y):
    x = tf.cast(x,dtype=tf.float32)/255.
    x = tf.reshape(x,[-1,784])
    y = tf.one_hot(y,depth=10)
    return x,y
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 合并
train_db = tf.data.Dataset.from_tensor_slices( (x_train , y_train) )
# 打乱操作
train_db = train_db.shuffle(10000) #buffer_size 缓冲区大小，防止随机每次按照不一定的随机。
# 每次训练只是进行 小批量训练
# batch_size ，每一批训练的样本大小
train_db = train_db.batch(128)
# 预处理
#一开始的数据不满足我门的要求
# 直接就是一个映射
train_db = train_db.map(preprocess)
# 合并
test_db = tf.data.Dataset.from_tensor_slices( (x_test , y_test) )
# 打乱操作
test_db = test_db.shuffle(10000) #buffer_size 缓冲区大小，防止随机每次按照不一定的随机。
# 每次训练只是进行 小批量训练
# batch_size ，每一批训练的样本大小
test_db = test_db.batch(128)
# 预处理
#一开始的数据不满足我门的要求
# 直接就是一个映射
test_db = test_db.map(preprocess)

op = tf.optimizers.Adam(0.01)

for epoch in range(5):
    for step, (x,y) in enumerate(train_db):
        with tf.GradientTape() as tape:
            loss = tf.losses.categorical_crossentropy(y,model(x))
            loss_meter.update_state(loss)
        grads = tape.gradient(loss,model.trainable_variables)
        op.apply_gradients(zip(grads,model.trainable_variables))
        if step % 100 == 1:
            print("epoch: ",epoch ,'step' , step ,'loss' ,loss_meter.result().numpy())
        loss_meter.update_state(loss)

    for step, (x,y) in enumerate(test_db):
        out = model(x)
        pred = tf.cast(tf.argmax(out,axis = -1) , dtype = tf.int32)
        y = tf.cast(tf.argmax(y,axis = -1) , dtype = tf.int32)
        acc_meter.update_state(y,pred)
    print('epoch:' , epoch , 'acc:' ,acc_meter.result().numpy())
    acc_meter.reset_states()