tensorflow2常用模块之网络构建基础

保持成长

已于 2024-06-06 21:00:36 修改

阅读量873

点赞数 8

文章标签： tensorflow 人工智能 python 深度学习 numpy 神经网络 keras

于 2024-05-29 02:25:45 首次发布

本文链接：https://blog.csdn.net/qq_43127132/article/details/139281834

版权

tensorflow2常用模块之网络构建基础

1、构建模型

1.1构建堆叠模型

常见的模型类型是层的堆叠：tf.keras.Sequential模型

import tensorflow as tf
print(tf.__version__)
print(tf.keras.__version__)
import tensorflow.keras.layers as layers
model = tf.keras.Sequential()
model.add(layers.Dense(32,activation='relu'))
model.add(layers.Dense(32,activation='relu'))
model.add(layers.Dense(32,activation='softmax'))

1.2函数式模型

函数试模型主要利用tf.keras.input和tf.keras.Model构建，比tf.keras.Sequential模型复杂，但效果更好，可以同时/分阶段输入变量，分阶段输出数据；你的模型需要多于一个输出，那么就选择函数式模型

多输入模型
多输出模型
具有共享层的模型
具有非序列数据流的模型

模型堆叠（.Sequential）vs（Model）

#以上层的输出作为下一层的输入
x = tf.keras.Input(shape=(32,))
h1 = layers.Dense(32,activation='relu')(x)
h2 = layers.Dense(32,activation='relu')(h1)
y = layers.Dense(10,activation='softmax')(h2)
model_sample_2 = tf.keras.models.Model(x,y)

#打印输出
model_sample_2.summary()

#############结果输出##############
Model: "functional_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_2 (InputLayer)         [(None, 32)]              0         
_________________________________________________________________
dense_6 (Dense)              (None, 32)                1056      
_________________________________________________________________
dense_7 (Dense)              (None, 32)                1056      
_________________________________________________________________
dense_8 (Dense)              (None, 10)                330       
=================================================================
Total params: 2,442
Trainable params: 2,442
Non-trainable params: 0

1.3网络层构建（主要接口tf.keras.layers：配置神经网络层）

tf.keras.layers模块的主要作用为配置神经网络层。其中常用的类包括
tf.keras.layers.Dense：构建全连接层；
tf.keras.layers.Conv2D：构建2维卷积层；
tf.keras.layers.MaxPooling2D/AveragePooling2D：构建最大/平均池化层；
tf.keras.layers.RNN：构建循环神经网络层
tf.keras.layers.LSTM/tf.keras.layers.LSTMCell：构建LSTM网络层/LSTMunit;
tf.keras.layers.GRU/tf.keras.layers.GRUCell：构建GRUunit/GRU网络层；
tf.keras.1layers.Embedding嵌入层将正整数（下标）转换为具有固定大小的向量，如［[4]，［20]->[[0.25,0.1]，［0.6,-0.2]]。Embedding层只能作为模型的第一层；
tf.keras.layers.Dropout：构建dropout层等。（防止过拟合）

下面主要讲解tf.keras.layers.Dense、tf.keras.layers.Conv2D、tf.keras.layers.MaxPooling2D/AveragePooling2D。tf.keras.layers.LSTM/tf.keras.layers.LSTMCell。

tf.keras.layers中主要的网络配置参数如下：

activation：设置层的激活函数。默认情况下，系统不会应用任何激活函数。
kernel_initializer和bias_initializer：创建层权重（核和偏置）的初始化方案。默认为"Glorotuniform"初始化器。
kemel_regularizer和bias_regularizer：应用层权重（核和偏置）的正则化方案，例如L1或L2正则化。默认情况下，系统不会应用正则化函数。

1.3.1 tf.keras.layers.Dense —构建平铺层

tf.keras.layers.Dense可配置的参数，主要有：
units:神经元个数
activation：激活函数；
use_bias：是否使用偏置项。默认为使用；
kernel_initializer：创建层权重核的初始化方案；
bias_initializer：创建层权重偏置的初始化方案：
kernei_regularizer：应用层权重核的正则化方案
bias_regularizer：应用层权重偏置的正则化方案；
activity_regularizer：施加在输出上的正则项，为Regularizer对象；
kernel_constraint：施加在权重上的约束项；
bias_constraint：施加在权重上的约束项。

#创建包含32个神经元的全连接层，其中的激活函数设置为sigmoid。
layers.Dense(32, activation='sigmoid')
layers.Dense(32, activation=tf.sigmoid)

#设置kernel_initializer参数
layers.Dense(32, kernel_initializer=tf.keras.initializers.he_normal)

#设置kernel_regularizer为L2正则
layers.Dense(32, kernel_regularizer=tf.keras.regularizers.l2(0.01))

#############结果输出##############
outs:<tensorflow.python.keras.layers.core.Dense at 0x1d24d7d0160>

1.3.2 tf.keras.layers.Conv2D --构建卷积层

filters：卷积核的数目（即输出的维度）；

kernel_size：卷积核的宽度和长度；

strides：卷积的步长。

padding：补0策略。
padding=“valid”代表只进行有效的卷积，即对边界数据不处理。padding=“same”代表保留边界处的卷积结果，通常会导致输出shape与输入shape相同;

activation：激活函数；

tata_format，教据格式，为“chansels_first”或“chtannel:_last”之—，以128x128的RGB图像力例，“chaanels_first"应将数据组织为（3,128,128），而“charne1s_Last”应将数据适织力（128,128,3），该参数数的默值是~/.keras/kera.json中设置的值，若从未读置过，则为“chamels_last"。

其他参数还包括：
use_bias; kernel_initializer; bias_initializer; kernel_regularizer; bias_regularizer; activity_regularizer; kernel_constraints; bias_constraints.

#创建2维卷积层，卷积核为64，卷积核宽和高均为1，步长为2，padding为same，激活函数relu
layers.Conv2D(64,[1,1],2,padding='same',activation="relu")

#############结果输出##############
<tensorflow.python.keras.layers.convolutional.Conv2D at 0x1d2538152e0>

1.3.3 tf.keras.layers.MaxPooling2D/AveragePooling2D —构建池化层

tf.keras.layers.MaxPooling2D/AveragePooling2D可配置的参数，主要有：

pool_size：池化kernel的大小。如取矩阵（2，2）将使图片在两个维度上均变为原长的一半。为整数意为各个维度值都为该数字。
strides：步长值:

其他参数还包括：
padding;data_format。

#构建pool——size的kernel为2*2,步长为2的池化层
layers.MaxPooling2D(pool_size=(2,2),strides=(2,1)) 

#############结果输出##############
<tensorflow.python.keras.layers.pooling.MaxPooling2D at 0x1d2538156d0>

1.3.4 tf.keras.layers.LSTM/tf.keras.layers.LSTMCell —构建LSTM神经网络

tf.keras.layers.LSTM/tf.keras.layers.LSTMCel可配置的参数，主要有：

units：单元数；
input_shape （timestep，input_dim），timestep可以设置为None，input_dim为输入数据维度。
return_sequences：=True时，返回全部序列；=False时，返回输出序列中的最后一个cell的输出。

import tensorflow as tf
import numpy as np 
import tensorflow.keras.layers as layers

inputs = tf.keras.Input(shape=(3,1))
#print(inputs)
#构建return_sequences：=True
lstm = layers.LSTM(1, return_sequences=True)(inputs)
model_lstm_1 = tf.keras.models.Model(inputs=inputs,outputs=lstm) 

inputs = tf.keras.Input(shape=(3,1)) 
#构建return_sequences：=False
lstm = layers.LSTM(1, return_sequences=False,input_shape=(3,1))(inputs) 
model_lstm_2=tf.keras.models.Model(inputs=inputs,outputs=lstm) 
 
#t1,t2,t3序列 
data = [[[0.1], 
[0.2], 
[0.3]]] 

print(data)
print("当return_sequences=True时的输出",model_lstm_1.predict(data)) 
print("当return_sequences=False时的输出",model_lstm_2.predict(data))


#############结果输出##############
[[[0.1], [0.2], [0.3]]]
当return_sequences=True时的输出 [[[-0.01980805]
  [-0.06022627]
  [-0.1222221 ]]]
当return_sequences=False时的输出 [[0.00971688]]

LSTMcell是LSTM层的实现单元。

LSTM是一个LSTM网络层
LSTMCe是一个单步的计算单元，即一个LSTMUNIT。

下面是一个对比例子

#LSTM 
 
tf.keras.layers.LSTM(16,return_sequences=True) 

#LSTMCel1 
x = tf.keras.Input((None,3)) 
y = layers.RNN(layers.LSTMCell(16))(x)
modellstm3 = tf.keras.Model(x,y)

2、训练与评估

2.1模型编译，确定训练流程

构建好模型后，通过调用compile配置该模型的学习流程

compile(optimizer=‘rmsprop’,loss=None,metrics=None,loss_weights=None)
optimizer:优化器：
loss: 损失函数，对于二分类任务就是交叉熵，回归任务就是mse之类的；
metrics：在训练和测试期间的模型评估标准。比如metrics=［‘accuracy’]。指定不同的评估标准，需要传递一个字典，如metrics=（‘output_a’：‘accuracy’}。
loss_weights：如果的模型有多个任务输出，在优化全局loss的时候，需要给每个输出指定相应的权重。

model = tf.keras.Sequential() 

model.add(layers.Dense(10, activation='softmax')) 

#确定优化器（optimizer）、损失函数（loss），模型评估方法（metrics） 
model.compile(optimizer = tf.keras.optimizers.Adam(0.001),  #Adam优化器
			 loss = tf.keras.losses.categorical_crossentropy, 
			 metrics = [tf.keras.metrics.categorical_accuracy])

2.2 模型训练

#数据量小可以用fit进行训练

fit(x=None,y=None,batch_size=None,epochs=1,verbose=1,callbacks=None,validation_split=0.0,validation_data=None,shuffle=True,class_weight=None,sample_weight=None,initial_epoch=0,steps_per_epoch=None,validation_steps=None)

x：输入训练数据；
y：目标（标签）数据；

batch_size：每次梯度更新的样本数。如果未指定，默认为32；

epochs：训练模型选代轮次；

verbose：0，1或2，日志显示模式，0=不显示，1=进度条，2=每轮显示一行

cal1backs：在训练时使用的回调函数；

validation_split：验证集与训练数据的比例；

validation_data：验证集；这个参数会覆盖validation_split；

shuffle：是否在每轮迭代之前混洗数据。当steps_per_epoch非None时，这个参数无效；

initial_epoch：开始训练的轮次，常用于恢复之前的训练权重；

steps_per_epoch：每轮更新多少次梯度；steps_per.epoch=数据集大小/batch_size

import tensorflow as tf
import numpy as np 

train_x = np.random.random((1000,36)) 
train_y = np.random.random((1000,10)) 

val_x = np.random.random((200,36)) 
val_y = np.random.random((200,10))

model.fit(train_x,train_y,epochs=10,batch_size=100 
		  validation_data=(val_x,val_y)) 

##################################结果输出##############################################
Epoch 1/10
100/100 [==============================] - 0s 4ms/step - loss: 12.8765 - categorical_accuracy: 0.0910 - val_loss: 13.0460 - val_categorical_accuracy: 0.0900
Epoch 2/10
100/100 [==============================] - 0s 1ms/step - loss: 12.7989 - categorical_accuracy: 0.0860 - val_loss: 12.9967 - val_categorical_accuracy: 0.0850
Epoch 3/10
100/100 [==============================] - 0s 1ms/step - loss: 12.7540 - categorical_accuracy: 0.0850 - val_loss: 12.9633 - val_categorical_accuracy: 0.0800
Epoch 4/10
100/100 [==============================] - 0s 1ms/step - loss: 12.7394 - categorical_accuracy: 0.0870 - val_loss: 12.9328 - val_categorical_accuracy: 0.0850
Epoch 5/10
100/100 [==============================] - 0s 1ms/step - loss: 12.7014 - categorical_accuracy: 0.0860 - val_loss: 12.9066 - val_categorical_accuracy: 0.0850
Epoch 6/10
100/100 [==============================] - 0s 1ms/step - loss: 12.6816 - categorical_accuracy: 0.0870 - val_loss: 12.8843 - val_categorical_accuracy: 0.0900
Epoch 7/10
100/100 [==============================] - 0s 1ms/step - loss: 12.6597 - categorical_accuracy: 0.0860 - val_loss: 12.8615 - val_categorical_accuracy: 0.0850
Epoch 8/10
100/100 [==============================] - 0s 1ms/step - loss: 12.6351 - categorical_accuracy: 0.0870 - val_loss: 12.8401 - val_categorical_accuracy: 0.0850
Epoch 9/10
100/100 [==============================] - 0s 2ms/step - loss: 12.6240 - categorical_accuracy: 0.0890 - val_loss: 12.8357 - val_categorical_accuracy: 0.0850
Epoch 10/10
100/100 [==============================] - 0s 1ms/step - loss: 12.6102 - categorical_accuracy: 0.0880 - val_loss: 12.8128 - val_categorical_accuracy: 0.0850
<tensorflow.python.keras.callbacks.History at 0x2452f03dc40>

对于大型数据训练，可以使用tf.data构建训练输入

dataset = tf.data.Dataset.from_tensor_slices((train_x,train_y))#使用fit训练，需要将大型数据分批
dataset = dataset.batch(32)  #定义批次
dataset = dataset.repeat()   #使用repeat函数将数据分割

val_dataset = tf.data.Dataset.from_tensor_slices((val_x, val_y))
val_dataset = val_dataset.batch(32)
val_dataset = val_dataset.repeat()
model.fit(dataset, epochs=10,steps_per_epoch=30,   
		  validation_data=val_dataset,validation_steps=3)

##################################结果输出##############################################

30/30 [==============================] - 0s 6ms/step - loss: 12.6341 - categorical_accuracy: 0.0875 - val_loss: 12.7524 - val_categorical_accuracy: 0.0729
Epoch 2/10
30/30 [==============================] - 0s 1ms/step - loss: 12.5962 - categorical_accuracy: 0.0865 - val_loss: 12.7520 - val_categorical_accuracy: 0.0729
Epoch 3/10
30/30 [==============================] - 0s 2ms/step - loss: 12.5993 - categorical_accuracy: 0.0876 - val_loss: 12.7503 - val_categorical_accuracy: 0.0729
Epoch 4/10
30/30 [==============================] - 0s 2ms/step - loss: 12.6031 - categorical_accuracy: 0.0865 - val_loss: 12.7478 - val_categorical_accuracy: 0.0729
Epoch 5/10
30/30 [==============================] - 0s 2ms/step - loss: 12.5648 - categorical_accuracy: 0.0887 - val_loss: 12.7457 - val_categorical_accuracy: 0.0729
Epoch 6/10
30/30 [==============================] - 0s 1ms/step - loss: 12.6010 - categorical_accuracy: 0.0855 - val_loss: 12.7435 - val_categorical_accuracy: 0.0729
Epoch 7/10
30/30 [==============================] - 0s 1ms/step - loss: 12.6279 - categorical_accuracy: 0.0855 - val_loss: 12.7413 - val_categorical_accuracy: 0.0729
Epoch 8/10
30/30 [==============================] - 0s 2ms/step - loss: 12.5763 - categorical_accuracy: 0.0876 - val_loss: 12.7396 - val_categorical_accuracy: 0.0729
Epoch 9/10
30/30 [==============================] - 0s 1ms/step - loss: 12.5956 - categorical_accuracy: 0.0897 - val_loss: 12.7386 - val_categorical_accuracy: 0.0729
Epoch 10/10
30/30 [==============================] - 0s 1ms/step - loss: 12.5312 - categorical_accuracy: 0.0876 - val_loss: 12.7380 - val_categorical_accuracy: 0.0729
<tensorflow.python.keras.callbacks.History at 0x2452f3a5eb0>

2.3 回调函数*

回调函数是传递给模型以自定义和扩展其在训练期间的行为的对象。我们可以编写自己的自定义回调，或使用tf.keras.callbacks中的内置函数，常用内置回调函数
如下：

tf.keras.callbacks.ModelCheckpoint：定期保存模型。
tf.keras.callbacks.LearningRateScheduler：动态更改学习率。
tf.keras.callbacks.EarlyStopping：提前终止。
tf.keras7callbacks.TensorBoard：使用TensorBoard。

#超参设置 

Epochs=10 

#定义一个学习率动态设置函数 
def lr_Scheduler(epoch) : 
    if epoch > 0.9*Epochs: 
    	lr = 0.0001 
    elif epoch > 0.5*Epochs: 
    	lr = 0.001 
    elif epoch > 0.25*Epochs 
    	lr = 0.01 
    else: 
    	lr = 0.1 

    print(lr) 
    return lr 


callbacks=[ 
    #早停： 
    tf.keras.callbacks.EarlyStopping( 
        #不再提升的关注指标 
        monitor='val_1oss',
        #不再提升的阀值 
        min_delta=le-2, 
        #不再提升的轮次 
        patience=2), 
    
    
    #定期保存模型： 
    tf.keras.callbacks.ModelCheckpoint( 
        #模型路径 
        filepath=testmodel_(epoch).h5, 
        #是否保存最佳模型 
        save_best_only=True, 
        #监控指标 
 		monitor='val_1oss'),
    
    #动态更改学习率 
    tf.keras.callbacks.LearningRateScheduler(lr_Scheduler) 
    
    #使用TensorBoard
    #
]

model.fit(train_x,train_y,epochs=Epochs,batch_size=16, 		      					             callbacks=callbacks,validation_data=(val_x,val_y))


##################################结果输出##############################################

0.1
Epoch 1/10
46/63 [====================>.........] - ETA: 0s - loss: 12.6606 - categorical_accuracy: 0.0788WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 4ms/step - loss: 12.6753 - categorical_accuracy: 0.0840 - val_loss: 13.4119 - val_categorical_accuracy: 0.1200
0.1
Epoch 2/10
45/63 [====================>.........] - ETA: 0s - loss: 12.9329 - categorical_accuracy: 0.0764    WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 2ms/step - loss: 12.9935 - categorical_accuracy: 0.0780 - val_loss: 13.0164 - val_categorical_accuracy: 0.0900
0.1
Epoch 3/10
48/63 [=====================>........] - ETA: 0s - loss: 12.9947 - categorical_accuracy: 0.0951    WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 2ms/step - loss: 12.9298 - categorical_accuracy: 0.0930 - val_loss: 13.1422 - val_categorical_accuracy: 0.0950
0.01
Epoch 4/10
48/63 [=====================>........] - ETA: 0s - loss: 12.5810 - categorical_accuracy: 0.0924WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 1ms/step - loss: 12.5548 - categorical_accuracy: 0.0940 - val_loss: 12.6619 - val_categorical_accuracy: 0.0950
0.01
Epoch 5/10
48/63 [=====================>........] - ETA: 0s - loss: 12.5022 - categorical_accuracy: 0.0885WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 2ms/step - loss: 12.5085 - categorical_accuracy: 0.0890 - val_loss: 12.6971 - val_categorical_accuracy: 0.0950
0.01
Epoch 6/10
58/63 [==========================>...] - ETA: 0s - loss: 12.5059 - categorical_accuracy: 0.0862WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 2ms/step - loss: 12.5396 - categorical_accuracy: 0.0850 - val_loss: 12.7777 - val_categorical_accuracy: 0.0900
0.001
Epoch 7/10
44/63 [===================>..........] - ETA: 0s - loss: 12.5396 - categorical_accuracy: 0.0753WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 2ms/step - loss: 12.5434 - categorical_accuracy: 0.0830 - val_loss: 12.7591 - val_categorical_accuracy: 0.1000
0.001
Epoch 8/10
50/63 [======================>.......] - ETA: 0s - loss: 12.5329 - categorical_accuracy: 0.0812    WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 2ms/step - loss: 12.5384 - categorical_accuracy: 0.0830 - val_loss: 12.7497 - val_categorical_accuracy: 0.1000
0.001
Epoch 9/10
52/63 [=======================>......] - ETA: 0s - loss: 12.4816 - categorical_accuracy: 0.0841WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 1ms/step - loss: 12.5203 - categorical_accuracy: 0.0840 - val_loss: 12.7448 - val_categorical_accuracy: 0.1000
0.001
Epoch 10/10
42/63 [===================>..........] - ETA: 0s - loss: 12.6494 - categorical_accuracy: 0.0893WARNING:tensorflow:Early stopping conditioned on metric `val_1oss` which is not available. Available metrics are: loss,categorical_accuracy,val_loss,val_categorical_accuracy
WARNING:tensorflow:Can save best model only with val_1oss available, skipping.
63/63 [==============================] - 0s 2ms/step - loss: 12.5310 - categorical_accuracy: 0.0880 - val_loss: 12.7390 - val_categorical_accuracy: 0.0900
<tensorflow.python.keras.callbacks.History at 0x245307ecc10>

2.4 模型的评估与预测

评估与预测函数：tf.keras.Model.evaluate和tf.keras.Model.predict方法

模型评估

test_x = np.random.random((1000,36))
test_y = np.random.random((1000,10)) 
model.evaluate(test_x,test_y,batch_size=32) 

##################################结果输出##############################################

32/32 [==============================] - 0s 1ms/step - loss: 12.5258 - categorical_accuracy: 0.1160
[12.525825500488281, 0.11599999666213989]

模型预测

pre_x = np.random.random((10,36)) 
result = model.predict(test_x,) 
print(result)

                         
##################################结果输出##############################################

[[0.03654892 0.01916202 0.1991373  ... 0.20491382 0.10902504 0.11124324]
 [0.05139336 0.02793015 0.3111167  ... 0.16176026 0.04527703 0.1301884 ]
 [0.07207417 0.0237806  0.1965947  ... 0.12523043 0.04965992 0.08322566]
 ...
 [0.05207794 0.02095552 0.22237633 ... 0.17053828 0.1045985  0.07939726]
 [0.06515923 0.0335626  0.27689597 ... 0.10591245 0.07574768 0.11249919]
 [0.08424474 0.01881361 0.2780208  ... 0.14866856 0.06979021 0.06097808]]

3、模型保存与恢复

3.1 权重保存

import numpy as np 

#模型保存 
model.save('./model/the_save_model.h5') 

#导入模型 
new_model = tf.keras.models.load_model('./model/the_save_model.h5') 
new_prediction = new_model.predict(test_x) 
#np.testing.assertallclose：判断两个对象的近似程度是否超出了指定的容差限。若是，则抛出异常。： 
#atol:指定的容差限 
np.testing.assert_allclose(result,new_prediction,atol=1e-6)
#查看对应路径下保存成功
#无报错则证明模型保存后重新加载后与原来的reault结果一致，证明本次操作无误

只保存权重

model.save_weights('./model/modelweights') 
model.save_weights('./model/modelweights.h5') 
#权重加载 
model.load_weights('./model/model_weights')
model.load_weights('./model/model_weights.h5') 

#查看对应路径下保存成功