TensorFlow笔记_tf.keras搭建神经网络

1.import：导入相关模块

2.train,test：指定输入网络的训练集和测试集

3.model = tf.keras.models.Sequential：逐层搭建神经网络

或class MyModel(Model) model=MyModel

4.model.compile：配置训练方法，选择训练时使用的优化器、损失函数和最终评价指标

5.model.fit：执行训练过程，告知训练集和测试集输入值和标签、每个batch的大小和数据集的迭代次数

6.model.summary：打印网络结构，统计参数数目

'''
model = tf.keras.models.Sequential([网络结构]) #描述各层网络

网络结构举例：

拉直层：tf.keras.layers.Flatten( )

全连接层：tf.keras.layers.Dense(神经元个数, activation="激活函数" ,
                                kernel_regularizer=正则化）                        
activation（字符串给出）可选: relu、softmax、sigmoid 、tanh
kernel_regularizer可选:tf.keras.regularizers.l1()、tf.keras.regularizers.l2()

卷积层：tf.keras.layers.Conv2D(filters = 卷积核个数, kernel_size= 卷积核尺寸,
                                strides = 卷积步长，padding = " valid" or "same")

LSTM层：tf.keras.layers.LSTM()

class MyModel(Model):
    def __init__(self):
        super(MyModel, self).__init__()
        定义网络结构块
    def call(self, x):
        调用网络结构块，实现前向传播
        return y
model= MyModel()

model.compile(optimizer = 优化器,loss = 损失函数,metrics = [“准确率”] )
Optimizer可选:
‘sgd’ortf.keras.optimizers.SGD(lr=学习率,momentum=动量参数)
‘adagrad’ortf.keras.optimizers.Adagrad(lr=学习率)
‘adadelta’ortf.keras.optimizers.Adadelta(lr=学习率)
‘adam’ortf.keras.optimizers.Adam(lr=学习率, beta_1=0.9, beta_2=0.999)
loss可选:
‘mse’ortf.keras.losses.MeanSquaredError()
‘sparse_categorical_crossentropy’ortf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
Metrics可选:
‘accuracy’ ：y_和y都是数值，如y_=[1] y=[1]
‘categorical_accuracy’ ：y_和y都是独热码(概率分布)，如y_=[0,1,0] y=[0.256,0.695,0.048]
‘sparse_categorical_accuracy’ ：y_是数值，y是独热码(概率分布),如y_=[1] y=                                                       
                                                                      [0.256,0.695,0.048]

model.fit (训练集的输入特征, 训练集的标签, 
            batch_size= , epochs= ,
            validation_data=(测试集的输入特征，测试集的标签),
            validation_split=从训练集划分多少比例给测试集，
            validation_freq= 多少次epoch测试一次)


'''

 用Sequential实现鸢尾花分类

#第一步
import tensorflow as tf
from sklearn import datasets
import numpy as np

#第二步
x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

#第三步
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])

#第四步
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

#第五步
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

#第六步
model.summary()

  用Classl实现鸢尾花分类

#第一步
import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
from sklearn import datasets
import numpy as np

#第二步
x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

#第三步
class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x):
        y = self.d1(x)
        return y

model = IrisModel()

#第四步
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

#第五步
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

#第六步
model.summary()