使用卷积神经网络构建图像分类模型检测肺炎

 DATA
 │
 ├── train
 │    ├── NORMAL
 │    └── PNEUMONIA
 │
 ├── test
 │    ├── NORMAL
 │    └── PNEUMONIA
 │
 └── validation
      ├── NORMAL
      └── PNEUMONIA

 from tensorflow.keras.preprocessing import image, image_dataset_from_directory
 from tensorflow.keras import models, layers, optimizers
 from tensorflow.keras.callbacks import EarlyStopping
 
 # initiating generator that rescale and resize the images in a directory
 train_g = image.ImageDataGenerator(rescale = 1/255).flow_from_directory(train_dir,
                                                                   target_size = (256,256),
                                                                   color_mode='grayscale',
                                                                   class_mode='binary')
 val_g = image.ImageDataGenerator(rescale = 1/255).flow_from_directory(val_dir,
                                                                 target_size = (256,256),
                                                                 color_mode='grayscale',
                                                                 class_mode='binary')
 
 # setting up the architecture
 model = models.Sequential()
 model.add(layers.Conv2D(filters = 32, kernel_size = 3,
                         activation = 'relu', padding = 'same',
                         input_shape=(256, 256, 1)))
 model.add(layers.MaxPooling2D(pool_size = (2, 2)))
 model.add(layers.Flatten())
 model.add(layers.Dense(128, activation = 'relu'))
 model.add(layers.Dense(1, activation='sigmoid'))
 
 # compiling models
 model.compile(loss='binary_crossentropy',
               optimizer=optimizers.RMSprop(lr=1e-4),
               metrics=['accuracy', 'Recall'])
 
 # setting up an early stopping callbacks to avoid overfitting
 # stop if a validation loss is not reduced for 5 epochs
 cp = EarlyStopping(patience = 5, restore_best_weights=True)
 
 # fitting the model
 history = model.fit(train_g, # fit train generator
                     epochs=100, # it will be stopped before 100 epochs (early stopping)
                     validation_data = val_g, # use the assigned generator as a validation set
                     callbacks = [cp], # use cp as callback
                     verbose = 2 # report each epoch without progress bar
                    )
 # evaluating the model
 model.evaluate(val_g) # evaluate the best weight on validation set

 import matplotlib.pyplot as plt
 %matplotlib inline
 
 def plot_performance(hist):
     '''
     takes the fitted model as input
     plot accuracy and loss
     '''
     hist_ = hist.history
     epochs = hist.epoch
     
     plt.plot(epochs, hist_['accuracy'], label='Training Accuracy')
     plt.plot(epochs, hist_['val_accuracy'], label='Validation Accuracy')
     plt.title('Training and validation accuracy')
     plt.legend()
     
     plt.figure()
     plt.plot(epochs, hist_['loss'], label='Training loss')
     plt.plot(epochs, hist_['val_loss'], label='Validation loss')
     plt.title('Training and validation loss')
     plt.legend()
     
     plt.show()

 # redefining training generator
 data_aug_train = image.ImageDataGenerator(rescale = 1/255,
                                           # allow rotation withing 15 degree
                                           rotation_range = 15,
                                           # adjust range of brightness (1 = same)
                                           brightness_range = [0.9, 1.1],
                                           # allow shear by up to 5 degree
                                           shear_range=5,
                                           # zoom range of [0.8, 1.2]
                                           zoom_range = 0.2)
 # attach generator to the directory
 train_g2 = data_aug_train.flow_from_directory(train_dir,
                                               target_size = (256,256),
                                               color_mode='grayscale',
                                               class_mode='binary')
 
 # define architecture
 model = models.Sequential()
 model.add(layers.Conv2D(32, 3, activation = 'relu', padding = 'same', input_shape=(256, 256, 1)))
 model.add(layers.MaxPooling2D((2, 2)))
 model.add(layers.Conv2D(64, 3, activation = 'relu', padding = 'same'))
 model.add(layers.MaxPooling2D((2, 2)))
 model.add(layers.Conv2D(128, 3, activation = 'relu', padding = 'same'))
 model.add(layers.MaxPooling2D((2, 2)))
 model.add(layers.Conv2D(256, 3, activation = 'relu', padding = 'same'))
 model.add(layers.MaxPooling2D((2, 2)))
 model.add(layers.Conv2D(512, 3, activation = 'relu', padding = 'same'))
 model.add(layers.MaxPooling2D((2, 2)))
 model.add(layers.Flatten())
 model.add(layers.Dense(2048, activation = 'relu'))
 model.add(layers.Dense(1, activation='sigmoid'))
 
 # configure
 model.compile(loss='binary_crossentropy',
               optimizer=optimizers.Adam(amsgrad = True),
               metrics=['accuracy'])
 
 # train
 history = model.fit(train_g2,
                     epochs=100, # it won't run all 100
                     validation_data = val_g,
                     callbacks = [cp],
                     verbose = 2
                    )
 # evaluate
 model.evaluate(val_g)

 # create a test generator to apply rescaling
 test_g = image.ImageDataGenerator(rescale = 1/255).flow_from_directory(test_dir,
                                                                 target_size = (256,256),
                                                                 color_mode='grayscale',
                                                                 class_mode='binary',
                                                                 shuffle=False)
 # evaluate to get evaluation metrics
 model.evaluate(test_g)
 
 # use predict to get the actual prediction
 y_pred_prob = model.predict(test_g)
 y_pred = [int(x) for x in y_pred_prob]