I want to apply augmentation on the traning dataset.But i am recieving an error with the system is crushed after it used the available RAM - tensorflow

Question

I am using Resent50 model to classify ultrasound images in to fatty liver and normal liver.while training the model i have received high accuracy on the training set than validation set.The model is suffering from over fitting due to small dateset and imbalanced datasets between normal and abnormal classes.to deal this i want to apply data augmentation but the system doesn't allow me to apply on the training batches.It displays an error "the system is crushed after using all the available memory" .would you pleas help me how i can apply data augmentation with the code I have attached below?
typimport PIL
print('Pillow Version:', PIL.__version__)
import matplotlib.pyplot as plt
import numpy as np
import os
import tensorflow as tf
import cv2
from google.colab import drive
drive.mount('/content/drive')
train_dataset='/content/drive/MyDrive/preprocessed us image V2/train'
test_dataset='/content/drive/MyDrive/preprocessed us image V2/test'
validation_dataset='/content/drive/MyDrive/preprocessed us image V2/validation'
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Activation, Dense, Flatten, BatchNormalization, Conv2D, MaxPool2D
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.metrics import confusion_matrix
import itertools
import os
import shutil
import random
import glob
import matplotlib.pyplot as plt
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
%matplotlib inline
train_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.vgg16.preprocess_input) \
.flow_from_directory(directory=train_dataset, target_size=(224,224), classes=['train_abnormal', 'train_normal'], batch_size=10)
valid_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.vgg16.preprocess_input) \
.flow_from_directory(directory=validation_dataset, target_size=(224,224), classes=['val_abnormal', 'val_normal'], batch_size=10)
test_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.vgg16.preprocess_input) \
.flow_from_directory(directory=test_dataset, target_size=(224,224), classes=['test_abnormal', 'test_normal'], batch_size=10, shuffle=False)
imgs, labels = next(train_batches)
def plotImages(images_arr):
fig, axes = plt.subplots(1, 10, figsize=(20,20))
axes = axes.flatten()
for img, ax in zip( images_arr, axes):
ax.imshow(img)
ax.axis('off')
plt.tight_layout()
plt.show()
plotImages(imgs)
print(labels)
from keras.applications import ResNet50
from keras.layers import Dense, Dropout, Activation, Flatten, GlobalAveragePooling2D
from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D
IMG_SHAPE = (224,224, 3)
resnet_50 = ResNet50(weights = 'imagenet',
include_top = False,
input_shape = (224,224, 3))
for layer in resnet_50.layers:
layer.trainable = False
print("number of layers:", len(resnet_50.layers))
resnet_50.summary()
#Adding custom Layers
x = resnet_50.output#takes the out put of resnet50 model as input to the archetectur
x = GlobalAveragePooling2D()(x)#applies a 2D a global averaging layer
x = Dense(1024, activation="relu")(x)#densely connected neurones with unit 1024
x = Dropout(0.2)(x)#prevents the model from oerfitting by dropping some neurons/layers
x = Dense(512, activation="relu")(x)#densely connected neurones with unit 512
predictions = Dense(2, activation="softmax")(x)#calculates the probability distribution of the two classses using softmax function
from tensorflow.keras.models import Model
# creating the final model
model_ = Model(inputs=resnet_50.input, outputs=predictions)
# Lock initial layers to do not be trained
#for layer in model_.layers[:52]:
#layer.trainable = False
num_classes = 2
model_.compile(optimizer='adam', loss = 'categorical_crossentropy',metrics = ['accuracy'])
history = model_.fit(x=train_batches,
steps_per_epoch=len(train_batches),
validation_data=valid_batches,
validation_steps=len(valid_batches),
epochs=30,
verbose=2)
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1])
plt.title('Training and Validation Accuracy')
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([0,1.0])
plt.title('Training and Validation Loss')
plt.xlabel('epoch')
plt.show()
test_imgs, test_labels = next(test_batches)
plotImages(test_imgs)
print(test_labels)
#one_hot encoding
test_batches.classes#since our test dataset is not shuffeled we want to hae direct mapping between samples and labeles
predictions = model_.predict(x=test_batches,verbose=0) #verbose=0(to get no output whenever we run the predictions)
np.round(predictions)
cm = confusion_matrix(y_true=test_batches.classes, y_pred=np.argmax(predictions, axis=-1))
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normalization')
print(cm)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
test_batches.class_indices
cm_plot_labels = ['abnormal','normal']
plot_confusion_matrix(cm=cm, classes=cm_plot_labels, title='Confusion Matrix')
plt.ylabel('true label')
plt.xlabel('predicted label')
loss, acc = model_.evaluate(test_batches)
model_.save('models/medical_trial_model.h5')
from tensorflow.keras.models import load_model
new_model = load_model('models/medical_trial_model.h5')
new_model.summary()
new_model.optimizer
from keras import utils as np_utils
datagen = keras.preprocessing.image.ImageDataGenerator(rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
validation_split=0.2)
#datagen.fit(train_batches)
#gen = ImageDataGenerator(rotation_range=0.2, horizontal_flip=True)
chosen_image = random.choice(os.listdir('/content/drive/MyDrive/train_dataset/normal'))
image_path = '/content/drive/MyDrive/train_dataset/normal/' + chosen_image
image = tf.expand_dims(plt.imread(image_path),0)
plt.imshow(image[0])
aug_iter = datagen.flow(image)
#datagen.fit(train_batches)
aug_images = [next(aug_iter)[0] for i in range(10)]
plotImages(aug_images)
aug_iter = datagen.flow(image, save_to_dir='/content/drive/MyDrive', save_prefix='aug-image-', save_format='png')
train_batches=aug_iter
history = model.fit(x=train_batches,
steps_per_epoch=len(train_batches),
validation_data=valid_batches,
validation_steps=len(valid_batches),
epochs=10,
verbose=2
)
datagen.fit(train_batches)
x_train, y_train), (x_test, y_test) =
import PIL
print('Pillow Version:', PIL.__version__)
import matplotlib.pyplot as plt
import numpy as np
import os
import tensorflow as tf
import cv2
from google.colab import drive
drive.mount('/content/drive')
train_dataset='/content/drive/MyDrive/preprocessed us image V2/train'
test_dataset='/content/drive/MyDrive/preprocessed us image V2/test'
validation_dataset='/content/drive/MyDrive/preprocessed us image V2/validation'
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Activation, Dense, Flatten, BatchNormalization, Conv2D, MaxPool2D
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.metrics import confusion_matrix
import itertools
import os
import shutil
import random
import glob
import matplotlib.pyplot as plt
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
%matplotlib inline
train_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.vgg16.preprocess_input) \
.flow_from_directory(directory=train_dataset, target_size=(224,224), classes=['train_abnormal', 'train_normal'], batch_size=10)
valid_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.vgg16.preprocess_input) \
.flow_from_directory(directory=validation_dataset, target_size=(224,224), classes=['val_abnormal', 'val_normal'], batch_size=10)
test_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.vgg16.preprocess_input) \
.flow_from_directory(directory=test_dataset, target_size=(224,224), classes=['test_abnormal', 'test_normal'], batch_size=10, shuffle=False)
imgs, labels = next(train_batches)
def plotImages(images_arr):
fig, axes = plt.subplots(1, 10, figsize=(20,20))
axes = axes.flatten()
for img, ax in zip( images_arr, axes):
ax.imshow(img)
ax.axis('off')
plt.tight_layout()
plt.show()
plotImages(imgs)
print(labels)
from keras import utils as np_utils
datagen = keras.preprocessing.image.ImageDataGenerator(rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
validation_split=0.2)
train_generator=datagen.fit(train_batches)
from keras.applications import ResNet50
from keras.layers import Dense, Dropout, Activation, Flatten, GlobalAveragePooling2D
from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D
IMG_SHAPE = (224,224, 3)
resnet_50 = ResNet50(weights = 'imagenet',
include_top = False,
input_shape = (224,224, 3))
for layer in resnet_50.layers:
layer.trainable = False
print("number of layers:", len(resnet_50.layers))
resnet_50.summary()
#Adding custom Layers
x = resnet_50.output#takes the out put of resnet50 model as input to the archetectur
x = GlobalAveragePooling2D()(x)#applies a 2D a global averaging layer
x = Dense(1024, activation="relu")(x)#densely connected neurones with unit 1024
x = Dropout(0.2)(x)#prevents the model from oerfitting by dropping some neurons/layers
x = Dense(512, activation="relu")(x)#densely connected neurones with unit 512
predictions = Dense(2, activation="softmax")(x)
from tensorflow.keras.models import Model
# creating the final model
model_ = Model(inputs=resnet_50.input, outputs=predictions)
# Lock initial layers to do not be trained
#for layer in model_.layers[:52]:
#layer.trainable = False
num_classes = 2
model.compile(optimizer=Adam(learning_rate=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])
history = model.fit(x=train_batches,
steps_per_epoch=len(train_batches),
validation_data=valid_batches,
validation_steps=len(valid_batches),
epochs=10,
verbose=2)
test_imgs, test_labels = next(test_batches)
plotImages(test_imgs)
print(test_labels)
#one_hot encoding
test_batches.classes#since our test dataset is not shuffeled we want to hae direct mapping between samples and labeles
predictions = model.predict(x=test_batches,verbose=0) #verbose=0(to get no output whenever we run the predictions)
np.round(predictions)
cm = confusion_matrix(y_true=test_batches.classes, y_pred=np.argmax(predictions, axis=-1))
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normalization')
print(cm)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
test_batches.class_indices
cm_plot_labels = ['abnormal','normal']
plot_confusion_matrix(cm=cm, classes=cm_plot_labels, title='Confusion Matrix')
plt.ylabel('true label')
plt.xlabel('predicted label')
loss, acc = model.evaluate(test_batches)
model.save('models/medical_trial_model.h5')
from tensorflow.keras.models import load_model
new_model = load_model('models/medical_trial_model.h5')
new_model.summary()
new_model.optimizer
)
I have tried different techniques like apply augmentation on the single image and then to the whole datasets but it doesn't work.