CNN借用别人模型

import tensorflow as tf

import numpy as np

import matplotlib.pyplot as plt

import scipy

import keras

print(tf.config.list_physical_devices('GPU'))

设置GPU设备

gpus = tf.config.experimental.list_physical_devices('GPU')

try:

if gpus:

tf.config.experimental.set_visible_devices(gpus[0], 'GPU')

tf.config.experimental.set_memory_growth(gpus[0], True)

print("GPU set successfully!")

except Exception as e:

print(e)

rom keras.applications import VGG16

from keras.models import Model

from keras.layers import Dense, GlobalAveragePooling2D

include_top=False,因为后边有时间序列的网络,而序列一般是按水平摆放,

#所以这种不带时间序列的网络是竖起来放的,top层就是后边他们自己模型处理分类的那些层

我们只要他们前面抓几何图案的层,要全部设置好的系数,输入图形形状是(150,150,3)

base_model = VGG16(weights='imagenet', include_top=False,input_shape=(150,150,3))

#要估计的参数

#(9*3+1)*64,(9*64+1)*64,(9*64+1)*128,(9*128+1)*128,

#(9*128+1)*256,(9*256+1)*256,(9*256+1)*256,

#(9*256+1)*512,(9*512+1)*512,后面几层一样,input_deep

#output_deep都是512,使用的卷积是3x3,卷积层做了填充0

#使用的是最大池化,抓2x2中的最大数

#卷积神经网络通用的使用方法,滤镜越用越多个

#参数是14,714,688个,目前是可训练状态,后面我们要设为不可训练

#状态

base_model.summary()

from keras.utils import plot_model#画模型

#有向无环图,input,四维张量(样本数,某一层通道的宽,某层通道的高,层数)

plot_model(base_model,show_shapes=True,to_file='VGG16.png')

import os,shutil

from keras.preprocessing.image import ImageDataGenerator

basedir='../datasets/cats_dogs_s'

train_dir=os.path.join(basedir,'train')#训练数据文件夹

test_dir=os.path.join(basedir,'test')#测试数据文件夹

yz_dir=os.path.join(basedir,'yz')#验证数据文件夹

第一种方法,把数据过一下base_model(别人的模型),转化成特征图数据

batch_size=20#小批量的丢进去,每个批量20个样本

datagen=ImageDataGenerator(rescale=1./255)#把图片变成数据的生成器,rescale是最后把像素数据变成0-1之间

#提取特征方法,参数:要提取特征的文件夹,样本数

def extract_features(directory,ybs):

print('ybs:',ybs)

#初始化一个4维张量,4x4是滚过VGG16之后的图片大小,512是最后一层有512个神经元

#这个是存储特征图形的容器(2000,4,4,512)

features=np.zeros(shape=(ybs,4,4,512))

#初始化了一个一维张量,用来存放标签

#标签是用来分类的,0-猫,1-狗

labels=np.zeros(shape=(ybs))

这个方法处理后,图片就变成了4维张量数据,并被设置了y

#就是标签,你要读取的文件夹下有几类,标签就会设成几类

#类似0-猫,1-狗之类的,每个批次20个样本,设置的图片大小是(150,150)

#经过这个方法后,图片数据形状是(20,150,150,3),这个是个死循环

generator=datagen.flow_from_directory(

#读取的图片的文件夹

directory,

设置的图片大小

target_size=(150,150),

batch_size=batch_size,#每次生成20个图片数据

class_mode='binary'#二分类

)

i=0 #设置的标志位,遍历生成器,得到的是输入张量和输出标签

inputs_batch(20,150,150,3),labels_batch(20,)里面是0,1

for inputs_batch,labels_batch in generator:

经过这个处理后的特征图形是(20,4,4,512)

features_batch=base_model.predict(inputs_batch)

print('fetures_batch:',features_batch.shape)

i=99时,切片位置是[1980:2000],这个数把每次迭代的20个特征图

#数据放进容器,一次是放20个特征图,每个特征图是512层

features[i*batch_size:(i+1)*batch_size]=features_batch

这个是上面输入数据对应的标签,也就是y真实值

labels[i*batch_size:(i+1)*batch_size]=labels_batch

i+=1

i等于99就退出了

if i*batch_size>=ybs:

print('i:',i)

break

return features,labels

#经过别人模型处理的特征图和标签,特征图保留的是特别的几何图形,用来识别类别的

train_features,train_labels=extract_features(train_dir,2000)

yz_features,yz_labels=extract_features(yz_dir,1000)

test_features,test_labels=extract_features(test_dir,1000)

#变一下形,就是摊平,我们没用vgg16密集连接层,因为他们处理的是1000分类

train_features=train_features.reshape(2000,4*4*512)

yz_features=yz_features.reshape(1000,4*4*512)

test_features=test_features.reshape(1000,4*4*512)

print(np.max(train_features),np.min(train_features),np.argmax(train_features))

#VGG16处理后的特征图像素的最大值是10.988969802856445,最小值是0

a=train_features.reshape(-1)

print(a[13438107])

from keras import layers

from keras import models

from keras import optimizers

#第一种用别人模型的方法,只是用别人模型处理一下自己的数据,变成特征图

model=models.Sequential()

#隐藏层

model.add(layers.Dense(256,activation='relu',input_dim=4*4*512))

dropout层

model.add(layers.Dropout(0.5))

二分类问题,sigmoid,输出层

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

#我们自己要估计的参数(8192+1)*256,256+1,8192是摊平了

4*4*512

model.summary()

model.compile(optimizer=optimizers.RMSprop(learning_rate=1e-4),\

loss='binary_crossentropy',metrics=['acc'])

#loss: 0.1419 - acc: 0.9460 - val_loss: 0.2610 - val_acc: 0.8860

his=model.fit(train_features,train_labels,

epochs=20, # 训练轮数

verbose=2, # 日志显示模式

batch_size=20,

validation_data=(yz_features,yz_labels),

shuffle=True

)

#训练损失,验证损失,训练准确率,验证准确率

xl_loss=his.history['loss']

yz_loss=his.history['val_loss']

xl_acc=his.history['acc']

yz_acc=his.history['val_acc']

plt.rcParams['font.size'] = 22

plt.figure(figsize=(20,9),dpi=100)

plt.subplot((121))

#横坐标是迭代次数,纵坐标是损失

x=range(1,len(xl_loss)+1)

plt.plot(x,xl_loss,'b',label='xl_loss')

plt.plot(x,yz_loss,'bo',label='yz_loss')

plt.legend()

plt.subplot((122))

plt.plot(x,xl_acc,'r',label='xl_acc')

plt.plot(x,yz_acc,'ro',label='yz_acc')

plt.legend()

plt.show()

第二种用别人模型的方法,我们要增强数据,

就得把别人的前面处理几何图形的层都加进来

但不能动人家模型的参数

model_=models.Sequential()

model_.add(base_model)#别人模型的处理空间相关性的那些层

model_.add(layers.Flatten())#拍平特征图数据

model_.add(layers.Dense(256,activation='relu'))

model_.add(layers.Dropout(0.5))

二分类问题,sigmoid,输出层

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

冻结之前,Non-trainable params: 0

model_.summary()

#冻结别人模型之前,要估计的层数,别人的13层+自己的2层,15层,有w和b两个,所以是30

print('冻结别人模型之前:',len(model_.trainable_weights))

#冻结别人模型

base_model.trainable=False

#之所以是4,可训练的层数,是因为我们自己加的就两层,每一层都要估计w和b两个张量,2*2=4

print('冻结别人模型之后:',len(model_.trainable_weights))

#冻结之后,模型参数,Non-trainable params: 14,714,688

model_.summary()

#增强数据

#因为训练准确率高,所以给训练增加难度,又是旋转

#又是平移,让电脑能抓住本质,fill_mode='nearest'是默认

train_datagen=ImageDataGenerator(

#图片数据*rescale设定值

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

)

#验证资料就不要数据增强了,数据增强是为了让电脑抓到

#输入数据被贴上特定标签的本质原因,验证数据

是展示数据增强的成果的

yz_datagen=ImageDataGenerator(rescale=1./255)

train_datagen经历过图片平移,旋转之类的,增强训练难度

相当于我们在模拟考试前训练有些难度的题目

train_generator=train_datagen.flow_from_directory(

train_dir,

target_size=(150,150),

batch_size=20,

class_mode='binary'

)

yz_datagen只是把数据变到0-1,电脑喜欢小一些的浮点数据

vald_generator=yz_datagen.flow_from_directory(

yz_dir,

target_size=(150,150),

batch_size=20,

class_mode='binary'

)

learning_rate=1e-4,损失函数,二元交叉熵,衡量模型标准:准确率

model_.compile(optimizer=optimizers.RMSprop(learning_rate=5e-5),\

loss='binary_crossentropy',metrics=['acc'])

#loss: 0.3203 - acc: 0.8540 - val_loss: 0.2496 - val_acc: 0.8960

his_=model_.fit(train_generator,

epochs=30, # 训练轮数

verbose=2, # 日志显示模式

steps_per_epoch=100, # 每个epoch需要完成的步数,通常设置为训练集的总样本数除以批次大小

validation_data=vald_generator, # 如果有验证集的话,这里也应该是另一个DirectoryIterator实例

validation_steps=50, # 验证集的步数

shuffle=True

)

model_.compile(optimizer=optimizers.RMSprop(learning_rate=1e-5),\

loss='binary_crossentropy',metrics=['acc'])

#loss: 0.2657 - acc: 0.8850 - val_loss: 0.2505 - val_acc: 0.8970

model_.fit(train_generator,

epochs=20, # 训练轮数

verbose=2, # 日志显示模式

steps_per_epoch=100, # 每个epoch需要完成的步数,通常设置为训练集的总样本数除以批次大小

validation_data=vald_generator, # 如果有验证集的话,这里也应该是另一个DirectoryIterator实例

validation_steps=50, # 验证集的步数

shuffle=True

)

设置VGG16 block5_conv1层和之后的层可训练

base_model.trainable=True# 先设置VGG16所有层都可训练

set_trainable=False# 设个标志

for layer in base_model.layers:#遍历VGG16的层

if layer.name=='block5_conv1':# 如果是block5_conv1(它是Ture的话,它后边的层也会是True)

set_trainable=True

if set_trainable:# 标志是Ture,就把那层设为可训练

layer.trainable=True

else:# 否则设为不可训练

layer.trainable=False

自己的两层+VGG16的3层,5*2,w和b

print('设置之后:',len(model_.trainable_weights))

set_trainable之后,trainable params: 9,177,089,自己设置的(2097408+257),base_model的7079424

#和起来就是9177089

model_.summary()

model_.save('cats_and_dogs_small_32.h5')

如果按第二种添加别人模型的方法,而且自己训练的模型loss,acc都差不多

#的情况下,就可以解冻别人模型的block5_conv1之后得层,因为这些层

都多少是为他们自己的分类器设置系数了,我们这样设置后,就会更新这些层的系数

#learning_rate=1e-5微调就行

model_.compile(optimizer=optimizers.RMSprop(learning_rate=1e-5),\

loss='binary_crossentropy',metrics=['acc'])

#在开启别人的一些参数可训练之前,一定要已经

经过(base_model参数不可训练的)的模型训练差不多之后,参数不需要大幅度调整

#不然,反向传播会打乱别人模型里的增加的可调参数,达不到预期

loss: 0.0790 - acc: 0.9700 - val_loss: 0.2804 - val_acc: 0.9330

#有些时候val_acc和这个差不多,可是val_loss却非常大,都到1以上了,

#应该是学习率调的过大,搞坏了模型,但是为啥显示的验证准确率却很高呢,

#看那验证损失都1.5了.最好的模型应该是验证准确率和验证损失都比较小.

#而且训练准确率和训练损失也会和验证准确率和验证损失一致

#不能出现准确率显示很高,损失却很大的情况,如果出现说明学习率调大了

#搞坏了模型

history=model_.fit(train_generator,

epochs=30, # 训练轮数

verbose=2, # 日志显示模式

steps_per_epoch=100, # 每个epoch需要完成的步数,通常设置为训练集的总样本数除以批次大小

validation_data=vald_generator, # 如果有验证集的话,这里也应该是另一个DirectoryIterator实例

validation_steps=50, # 验证集的步数

shuffle=True

)

#在之前的30次epoch上继续微调

#loss: 0.0385 - acc: 0.9870 - val_loss: 0.2845 - val_acc: 0.9400

model_.compile(optimizer=optimizers.RMSprop(learning_rate=1e-5),\

loss='binary_crossentropy',metrics=['acc'])

history=model_.fit(train_generator,

epochs=20, # 训练轮数

verbose=2, # 日志显示模式

steps_per_epoch=100, # 每个epoch需要完成的步数,通常设置为训练集的总样本数除以批次大小

validation_data=vald_generator, # 如果有验证集的话,这里也应该是另一个DirectoryIterator实例

validation_steps=50, # 验证集的步数

shuffle=True

)

model_.save('cats_and_dogs_small_33.h5')#保存一下模型

#在之前的模型上继续调整,学习率调为5e-6,

#loss: 0.0248 - acc: 0.9895 - val_loss: 0.2841 - val_acc: 0.9540

#这是猫狗训练图片才2000张的情况下,准确率就已经95.4%,损失也不大

model_.compile(optimizer=optimizers.RMSprop(learning_rate=5e-6),\

loss='binary_crossentropy',metrics=['acc'])

history=model_.fit(train_generator,

epochs=20, # 训练轮数

verbose=2, # 日志显示模式

steps_per_epoch=100, # 每个epoch需要完成的步数,通常设置为训练集的总样本数除以批次大小

validation_data=vald_generator, # 如果有验证集的话,这里也应该是另一个DirectoryIterator实例

validation_steps=50, # 验证集的步数

shuffle=True

)

可以看到验证准确率最大出现在第20次epoch,而验证损失最小是出现在第8次epoch

print(np.max(history.history['val_acc']),np.argmax(history.history['val_acc']))

print(np.min(history.history['val_loss']),np.argmin(history.history['val_loss']))

xl_loss=history.history['loss']

yz_loss=history.history['val_loss']

xl_acc=history.history['acc']

yz_acc=history.history['val_acc']

plt.rcParams['font.size'] = 22

plt.figure(figsize=(20,9),dpi=100)

plt.subplot((121))

x=range(1,len(xl_loss)+1)

plt.plot(x,xl_loss,'b',label='xl_loss')

plt.plot(x,yz_loss,'bo',label='yz_loss')

plt.legend()

plt.subplot((122))

plt.plot(x,xl_acc,'r',label='xl_acc')

plt.plot(x,yz_acc,'ro',label='yz_acc')

plt.legend()

plt.show()

#经过指数平滑处理的图表,指数平滑EMA

def smth_(points,w=0.8):

#装平滑点的集合

smt_ps=[]

for point in points:

if not smt_ps:

print(smt_ps)

smt_ps.append(point)

else:

平滑点集合里的最后一个,就是上一个点

syg_ps=smt_ps[-1]

print('----',smt_ps)

smt_ps.append(w*syg_ps+(1-w)*point)

return smt_ps

xl_loss=smth_(history.history['loss'])

yz_loss=smth_(history.history['val_loss'])

xl_acc=smth_(history.history['acc'])

yz_acc=smth_(history.history['val_acc'])

plt.rcParams['font.size'] = 22

plt.figure(figsize=(20,9),dpi=100)

plt.subplot((121))

x=range(1,len(xl_loss)+1)

plt.plot(x,xl_loss,'b',label='xl_loss')

plt.plot(x,yz_loss,'bo',label='yz_loss')

plt.title('xl_loss,yz_loss')

plt.legend()

plt.subplot((122))

plt.plot(x,xl_acc,'r',label='xl_acc')

plt.plot(x,yz_acc,'ro',label='yz_acc')

plt.title('xl_acc,yz_acc')

plt.legend()

plt.show()

model_.save('./cats_and_dogs_small_36.h5')

test_generator=yz_datagen.flow_from_directory(

test_dir,

target_size=(150,150),

batch_size=20,

class_mode='binary'

)

#预测测试资料:test_loss,0.2628508508205414,test_acc,0.9449999928474426

test_loss,test_acc=model_.evaluate(test_generator,steps=50)

print('test_loss',test_loss)

print('test_acc',test_acc)

相关推荐
不去幼儿园28 分钟前
【MARL】深入理解多智能体近端策略优化(MAPPO)算法与调参
人工智能·python·算法·机器学习·强化学习
想成为高手49934 分钟前
生成式AI在教育技术中的应用:变革与创新
人工智能·aigc
YSGZJJ1 小时前
股指期货的套保策略如何精准选择和规避风险?
人工智能·区块链
无脑敲代码,bug漫天飞1 小时前
COR 损失函数
人工智能·机器学习
HPC_fac130520678162 小时前
以科学计算为切入点:剖析英伟达服务器过热难题
服务器·人工智能·深度学习·机器学习·计算机视觉·数据挖掘·gpu算力
小陈phd5 小时前
OpenCV从入门到精通实战(九)——基于dlib的疲劳监测 ear计算
人工智能·opencv·计算机视觉
Guofu_Liao6 小时前
大语言模型---LoRA简介;LoRA的优势;LoRA训练步骤;总结
人工智能·语言模型·自然语言处理·矩阵·llama
秀儿还能再秀9 小时前
神经网络(系统性学习三):多层感知机(MLP)
神经网络·学习笔记·mlp·多层感知机
ZHOU_WUYI10 小时前
3.langchain中的prompt模板 (few shot examples in chat models)
人工智能·langchain·prompt
如若12310 小时前
主要用于图像的颜色提取、替换以及区域修改
人工智能·opencv·计算机视觉