cuda在神经网络gpu加速时必须要用吗神经网络训练显卡

转载

小题大作 2024-03-06 05:19:04

文章标签 神经网络显卡就是开发板 keras littledata 数据集 文章分类 神经网络人工智能

对于神经网络的应用，最短的路径当然是使用具有理论基础和实践基础的成型网络，但是针对某些特殊场景，预先定义和训练好的网络不足以完成当前的任务，这时就要自己去训练网络莱适应当前任务，这一期我们使用 Kares 来演示一个神经网络的调试过程。在寻找这方面的素材过程中我发现 Kares 的作者 Francois Chollet 的一篇blog《 Building powerful image classification models using very little data 》非常适合我们的演示主题，所以我就直接引用他的例子来做这一期的演示，原文地址:
https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html
这篇文章的主题是在只有很少的数据集的情况下怎么优化神经网络的准确率。演示的数据集使用了 Kaggle 上的猫狗大战的数据的一小部分 https://www.kaggle.com/c/dogs-vs-cats/data ，各取1000张猫狗照片作为训练数据，再各取400张猫狗照片作为验证数据。我已经将数据整理出来，可以通过网盘下载 https://pan.baidu.com/s/1dE5PrHJ 将 data.tgz 解出来就可以使用。
文章一共有三个实验：
1. 第一个实验使用自定义的神经网络对数据集进行训练，三层卷积加两层全连接，训练并验证网络的准确率；
2. 第二个实验使用VGG16网络对数据进行训练，为了适应自定义的数据集，将VGG16网络的全连接层去掉，作者称之为 “Feature extraction”, 再在上面添加自己实现的全连接层，然后训练并验证网络准确性；
3. 第三个实验称为 “fine-tune” ，利用第二个实验的实验模型和weight，重新训练VGG16的最后一个卷积层和自定义的全连接层，然后验证网络准确性；
不用做实验就可以推断出，这三个网络的准确率肯定是逐个递增的，通过亲手实践，可以感性的认识一个神经网络调优的思路，具体的理论还是要看文献，我才疏学浅讲不明白，blog中的代码片段有点小错误，我更正了一下。
对应代码地址 https://github.com/aggresss/GPUDemo/blob/master/classifier_from_little_data.ipynb

第一个实验的代码：

from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense
from keras import backend as K

# dimensions of our images.
img_width, img_height = 150, 150

train_data_dir = 'data/train'
validation_data_dir = 'data/validation'
nb_train_samples = 2000
nb_validation_samples = 800
epochs = 50
batch_size = 16

if K.image_data_format() == 'channels_first':
    input_shape = (3, img_width, img_height)
else:
    input_shape = (img_width, img_height, 3)

model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=input_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

# this is the augmentation configuration we will use for training
train_datagen = ImageDataGenerator(
    rescale=1. / 255,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True)

# this is the augmentation configuration we will use for testing:
# only rescaling
test_datagen = ImageDataGenerator(rescale=1. / 255)

train_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size=(img_width, img_height),
    batch_size=batch_size,
    class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
    validation_data_dir,
    target_size=(img_width, img_height),
    batch_size=batch_size,
    class_mode='binary')

model.fit_generator(
    train_generator,
    steps_per_epoch=nb_train_samples // batch_size,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=nb_validation_samples // batch_size)

model.save_weights('first_try.h5')

通过训练自定的网络大约可以达到75%左右的准确率，可见一层卷积网络的准确率并不乐观。

第二个实验的代码：

import numpy as np
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Dropout, Flatten, Dense
from keras import applications

# dimensions of our images.
img_width, img_height = 150, 150

top_model_weights_path = 'bottleneck_fc_model.h5'
train_data_dir = 'data/train'
validation_data_dir = 'data/validation'
nb_train_samples = 2000
nb_validation_samples = 800
epochs = 50
batch_size = 16

def save_bottlebeck_features():
    datagen = ImageDataGenerator(rescale=1. / 255)

    # build the VGG16 network
    model = applications.VGG16(include_top=False, weights='imagenet')

    generator = datagen.flow_from_directory(
        train_data_dir,
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode=None,
        shuffle=False)
    bottleneck_features_train = model.predict_generator(
        generator, nb_train_samples // batch_size)
    np.save(open('bottleneck_features_train.npy', 'w'),
            bottleneck_features_train)

    generator = datagen.flow_from_directory(
        validation_data_dir,
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode=None,
        shuffle=False)
    bottleneck_features_validation = model.predict_generator(
        generator, nb_validation_samples // batch_size)
    np.save(open('bottleneck_features_validation.npy', 'w'),
            bottleneck_features_validation)

def train_top_model():
    train_data = np.load(open('bottleneck_features_train.npy'))
    train_labels = np.array(
        [0] * (nb_train_samples / 2) + [1] * (nb_train_samples / 2))

    validation_data = np.load(open('bottleneck_features_validation.npy'))
    validation_labels = np.array(
        [0] * (nb_validation_samples / 2) + [1] * (nb_validation_samples / 2))

    model = Sequential()
    model.add(Flatten(input_shape=train_data.shape[1:]))
    model.add(Dense(256, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(1, activation='sigmoid'))

    model.compile(optimizer='rmsprop',
                  loss='binary_crossentropy', metrics=['accuracy'])

    model.fit(train_data, train_labels,
              epochs=epochs,
              batch_size=batch_size,
              validation_data=(validation_data, validation_labels))
    model.save_weights(top_model_weights_path)

save_bottlebeck_features()
train_top_model()

第二个实验通过Keras的Application 接口引入预定义的VGG16网络，参数 include_top=False 可以去掉全连接层，然后重写全连接层以适应当前的数据集，经过50轮训练后这个网络可以达到90%左右的准确率，刚刚及格。

第三个实验代码：

from keras import applications
from keras.preprocessing.image import ImageDataGenerator
from keras import optimizers
from keras.models import Sequential
from keras.models import Model
from keras.layers import Dropout, Flatten, Dense

# path to the model weights files.
top_model_weights_path = 'bottleneck_fc_model.h5'
# dimensions of our images.
img_width, img_height = 150, 150

train_data_dir = 'data/train'
validation_data_dir = 'data/validation'
nb_train_samples = 2000
nb_validation_samples = 800
epochs = 50
batch_size = 16

# build the VGG16 network
base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(150,150,3))
print('Model loaded.')

# build a classifier model to put on top of the convolutional model
top_model = Sequential()
top_model.add(Flatten(input_shape=base_model.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(1, activation='sigmoid'))

# note that it is necessary to start with a fully-trained
# classifier, including the top classifier,
# in order to successfully do fine-tuning
top_model.load_weights(top_model_weights_path)

# add the model on top of the convolutional base
# model.add(top_model)
model = Model(inputs=base_model.input, outputs=top_model(base_model.output))

# set the first 25 layers (up to the last conv block)
# to non-trainable (weights will not be updated)
for layer in model.layers[:15]:
    layer.trainable = False

# compile the model with a SGD/momentum optimizer
# and a very slow learning rate.
model.compile(loss='binary_crossentropy',
              optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
              metrics=['accuracy'])

# prepare data augmentation configuration
train_datagen = ImageDataGenerator(
    rescale=1. / 255,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True)

test_datagen = ImageDataGenerator(rescale=1. / 255)

train_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
    validation_data_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary')

model.summary()

# fine-tune the model
model.fit_generator(
    train_generator,
    steps_per_epoch=nb_train_samples // batch_size,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=nb_validation_samples // batch_size,
    verbose=2)

上面的实验，将最后的卷积层的变成 trainable , 然后训练，准确率可以提升到 93%左右，如果想再提高这个网络的准确率,作者的观点是:
1.使用 “data augmentation” ，将数据集的图片进行随机化处理;
2.通过调节 dropout 来提升;
3.使用L1和L2正则化;
4.继续增加训练的层数，但同时也会面临过拟合的风险.

备注：VGG16网络结构

cuda在神经网络gpu加速时必须要用吗神经网络训练显卡_keras