Keras的简单应用（三分类问题）——改编自cifar10vgg16

悠悠 2022-05-26 02:12 141阅读 0赞

此为改编自cifar10的三分类问题：

from __future__ import print_function  #此为在老版本的python中兼顾新特性的一种方法
    import keras
    from keras.preprocessing.image import ImageDataGenerator
    from keras.preprocessing import image
    from keras.models import Sequential
    from keras.models import model_from_json
    from keras.layers import Dense, Dropout, Activation, Flatten
    from keras.layers import Conv2D, MaxPooling2D, BatchNormalization
    from keras import optimizers
    from keras import backend as K
    from keras import regularizers
    from keras.applications.imagenet_utils import preprocess_input
    
    import scipy.misc
    import numpy as np
    import matplotlib.pyplot as plt
    import h5py
    
    
    #from keras.datasets import cifar10
    #from keras.layers.core import Lambda
    #from matplotlib.pyplot import imshow
    
    
    class teeth3vgg:
        def __init__(self,train=False):
            self.num_classes = 3
            self.weight_decay = 0.0005  #权值衰减,目的是防止过拟合
            self.x_shape = [32,32,3]
    
            self.model = self.build_model()
            if train:
                self.model = self.train(self.model)
            else:
                #self.model.load_weights('weight.h5')
    
                # 加载模型数据和weights
                self.model = model_from_json(open('my_model_architecture.json').read())
                self.model.load_weights('my_model_weights.h5')
    
    
        def build_model(self):
            # Build the network of vgg for 10 classes with massive dropout and weight decay as described in the paper.
    
            model = Sequential()
            weight_decay = self.weight_decay
    
            model.add(Conv2D(64, (3, 3), padding='same',input_shape=self.x_shape,kernel_regularizer=regularizers.l2(weight_decay)))
            #kernel_regularizer表示施加在权重上的正则项
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            #该层在每个batch（批次）上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1
            model.add(Dropout(0.3))
    
            model.add(Conv2D(64, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
    
            model.add(MaxPooling2D(pool_size=(2, 2)))
    
            model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            model.add(Dropout(0.4))
    
            model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
    
            model.add(MaxPooling2D(pool_size=(2, 2)))
    
            model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            model.add(Dropout(0.4))
    
            model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            model.add(Dropout(0.4))
    
            model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
    
            model.add(MaxPooling2D(pool_size=(2, 2)))
    
    
            model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            model.add(Dropout(0.4))
    
            model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            model.add(Dropout(0.4))
    
            model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
    
            model.add(MaxPooling2D(pool_size=(2, 2)))
    
    
            model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            model.add(Dropout(0.4))
    
            model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
            model.add(Dropout(0.4))
    
            model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
    
            model.add(MaxPooling2D(pool_size=(2, 2)))
            model.add(Dropout(0.5))
    
            model.add(Flatten())  #即把多维的输入一维化，常用于卷积层到全连接层的过渡
            model.add(Dense(512,kernel_regularizer=regularizers.l2(weight_decay)))
            model.add(Activation('relu'))
            model.add(BatchNormalization())
    
            model.add(Dropout(0.5))
            model.add(Dense(self.num_classes))  #该全连接层的输出维度为3
            model.add(Activation('softmax'))
            return model
    
    
        def normalize(self, X_train, X_valida, X_test):
            #this function normalize inputs for zero mean and unit variance
            # it is used when training a model.
            # Input: training set and test set
            # Output: normalized training set and test set according to the trianing set statistics.
            mean = np.mean(X_train, axis=(0, 1, 2, 3)) #计算均值
            std = np.std(X_train, axis=(0, 1, 2, 3)) #计算标准差
            X_train = (X_train-mean)/(std+1e-7)
            X_valida = (X_valida- mean)/(std + 1e-7)
            X_test = (X_test-mean)/(std+1e-7)
            return X_train, X_valida, X_test
    
        def normalize_production(self,x):
            #this function is used to normalize instances in production according to saved training set statistics
            # Input: X - a training set
            # Output X - a normalized training set according to normalization constants.
    
            #these values produced during first training and are general for the standard cifar10 training set normalization
            mean = np.mean(x)
            std = np.std(x)
            return (x-mean)/(std+1e-7)
        #'''
        def predict(self, x, normalize=True, batch_size=50):
            if normalize:
                x = self.normalize_production(x)
            return self.model.predict(x, batch_size)
        #'''
        def train(self,model):
    
            #training parameters
            #batch_size = 128
            batch_size = 100
            #maxepoches = 250
            maxepoches = 150
            learning_rate = 0.01
            lr_decay = 1e-6
            lr_drop = 20
            # The data, shuffled and split between train and test sets:
    
            #(x_train, y_train), (x_test, y_test) = cifar10.load_data()
            train_dataset = h5py.File('data.h5', 'r')
            x_train = np.array(train_dataset['X_train'][:])  # your train set features
            y_train = np.array(train_dataset['y_train'][:])  # your train set labels
            x_valida = np.array(train_dataset['X_valida'][:])  # your valida set features
            y_valida = np.array(train_dataset['y_valida'][:])  # your valida set labels
            x_test = np.array(train_dataset['X_test'][:])  # your test set features
            y_test = np.array(train_dataset['y_test'][:])  # your test set labels
            train_dataset.close()
    
            x_train = x_train.astype('float32')
            x_valida = x_valida.astype('float32')
            x_test = x_test.astype('float32')
            x_train, x_valida, x_test = self.normalize(x_train, x_valida, x_test)
    
            y_train = keras.utils.to_categorical(y_train, self.num_classes)
            y_valida = keras.utils.to_categorical(y_valida, self.num_classes)
            y_test = keras.utils.to_categorical(y_test, self.num_classes)
    
            def lr_scheduler(epoch):
                return learning_rate * (0.5 ** (epoch // lr_drop))
            reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
    
            #data augmentation
            datagen = ImageDataGenerator(  #图片生成器
                featurewise_center=False,  # set input mean to 0 over the dataset
                samplewise_center=False,  # set each sample mean to 0
                featurewise_std_normalization=False,  # divide inputs by std of the dataset
                samplewise_std_normalization=False,  # divide each input by its std
                zca_whitening=False,  # apply ZCA whitening
                rotation_range=15,  # randomly rotate images in the range (degrees, 0 to 180)
                width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
                height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
                horizontal_flip=True,  # randomly flip images
                vertical_flip=False)  # randomly flip images
            # (std, mean, and principal components if ZCA whitening is applied).
            datagen.fit(x_train)
            print('***********************')
            print(x_train.shape)
    
    
            #optimization details  #优化器
            sgd = optimizers.SGD(lr=learning_rate, decay=lr_decay, momentum=0.9, nesterov=True)
            model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=['accuracy'])
    
    
            # training process in a for loop with learning rate drop every 25 epoches.
    
            historytemp = model.fit_generator(datagen.flow(x_train, y_train,
                                             batch_size=batch_size),
                                steps_per_epoch=x_train.shape[0] // batch_size,
                                epochs=maxepoches,
                                validation_data=(x_valida, y_valida), callbacks=[reduce_lr],verbose=2)  #verbose用来设置进度条
            # verbose是屏显模式，官方这么说的：verbose: 0 for no logging to stdout, 1 for progress bar logging, 2 for one log line per epoch.
            # 就是说0是不屏显，1是显示一个进度条，2是每个epoch都显示一行数据
    
            #model.save_weights('weight.h5')
            json_string = model.to_json()  # 等价于 json_string = model.get_config()
            open('my_model_architecture.json', 'w').write(json_string)
            model.save_weights('my_model_weights.h5')
    
            return model
    
    if __name__ == '__main__':
    
    
        #(x_train, y_train), (x_test, y_test) = cifar10.load_data()
        train_dataset = h5py.File('data.h5', 'r')
        x_train = np.array(train_dataset['X_train'][:])  # your train set features
        y_train = np.array(train_dataset['y_train'][:])  # your train set labels
        x_valida = np.array(train_dataset['X_valida'][:])  # your valida set features
        y_valida = np.array(train_dataset['y_valida'][:])  # your valida set labels
        x_test = np.array(train_dataset['X_test'][:])  # your test set features
        y_test = np.array(train_dataset['y_test'][:])  # your test set labels
        #train_dataset.close()
    
        x_train = x_train.astype('float32')
        x_valida = x_valida.astype('float32')
        x_test = x_test.astype('float32')
    
        y_train = keras.utils.to_categorical(y_train, 3)  #把类别转化成了one-hot的格式
        y_valida = keras.utils.to_categorical(y_valida, 3)
        y_test = keras.utils.to_categorical(y_test, 3)
    
        print('读取数据成功啦！来看看标签吧！')
        print(y_train[0])
        print(y_train[1])
        print(y_train[2])
        print(y_train[3])
        print(y_train[4])
        print(y_train[5])
        print(y_train[6])
        print(y_train[7])
        print(y_train[8])
        print(y_train[9])
        print(y_train[10])
        #print(x_train[0])
    
        model = teeth3vgg()
    
        print('模型建立完毕！')
    
        #对验证集进行正向传播评估正确率
        predicted_x = model.predict(x_valida)
        print(model.predict(x_valida))
    
        residuals = (np.argmax(predicted_x, 1) == np.argmax(y_valida, 1))  #argmax返回的是最大数的索引
        print('------------------------***')
        print(residuals)
        print(sum(residuals))
        print(len(residuals))
        loss = sum(residuals)/len(residuals)
        print("the validation 0/1 loss is: ",loss)
    
        # 对测试集进行正向传播评估正确率
        predicted_x1 = model.predict(x_test)
        print(predicted_x1.shape)
        print(y_test.shape)
        #print(model.predict(x_test))
    
        residuals1 = (np.argmax(predicted_x1, 1) == np.argmax(y_test, 1))  # argmax返回的是最大数的索引
        print('------------------------***')
        #print(residuals1)
        print(sum(residuals1))
        print(len(residuals1))
        loss1 = sum(residuals1) / len(residuals1)
        print("the test 0/1 loss is: ", loss1)
    
        '''
        score = model.evaluate(x_test, y_test, batch_size=10, verbose=1)
        print("loss  :",score[0])
        print("acc  :", score[1])
        
        score = model.evaluate(x_test, y_test, verbose=0)
        print('Val loss:', score[0])
        print('Val accuracy:', score[1])
        '''
        #model.evaluate(x_test, y_test, batch_size=100, show_accuracy=True, verbose=1)  # show_accuracy就是显示每次迭代后的正确率
        img_path = 'E:/MatlabWorkspace/picdst14/247.jpg'
        img = image.load_img(img_path, target_size=(32, 32))
        x = image.img_to_array(img)
        print('Source input image shape:', x.shape)
        x = np.expand_dims(x, 0) #增加维度，在下标为dim=0的轴上增加一维；-1表示最后一维
        x = preprocess_input(x)  #数据预处理，提高算法的效率
        print('Input image shape:', x.shape)
        my_image = scipy.misc.imread(img_path)
        plt.imshow(my_image)
        print("class prediction vector [p(0), p(1), p(2)] = ")
        px=model.predict(x)
        print(px)
        #print(model.predict(x_test[3]))
        if np.argmax(px,1)==0:
            print('该区域为牙齿！')
        elif np.argmax(px,1)==1:
            print('该区域为牙菌斑！')
        else:
            print('该区域为其他！')
        K.clear_session()
        '''
        fig, ax = plt.subplots(2, 1)
        ax[0].plot(history.history['loss'], color='b', label="Training loss")
        ax[0].plot(history.history['val_loss'], color='r', label="validation loss", axes=ax[0])
        ax[0].legend(loc='best', shadow=True)
        ax[1].plot(history.history['acc'], color='b', label="Training accuracy")
        ax[1].plot(history.history['val_acc'], color='r', label="Validation accuracy")
        ax[1].legend(loc='best', shadow=True)
        plt.show()
        '''

张量：A tensor is something that transforms like a tensor! 一个量，在不同的参考系下按照某种特定的法则进行变换，就是张量。

YouTube视频：[https://www.youtube.com/watch?v=f5liqUk0ZTw][https_www.youtube.com_watch_v_f5liqUk0ZTw]

[https_www.youtube.com_watch_v_f5liqUk0ZTw]: https://www.youtube.com/watch?v=f5liqUk0ZTw