def train(tr_gen):
"""
Constructs and trains a CNN
Several Convolution2D and MaxPooling2D layers,
then one hidden dense layer.
The last layer does softmax to the number of classes.
All layers but last use relu activation.
Uses Adam optimzer.
Args
tr_gen (DirectoryIterator): The loaded data and labels
Returns
model (Sequential): A compiled and trained model
"""
# math some constants
num_classes = len(tr_gen.class_indices)
# build a neural network
model = Sequential()
# first layer
model.add(
Convolution2D(filters=16,
kernel_size=(3, 3),
input_shape=(IMG_DIM, IMG_DIM, 3),
activation='relu',
name='input'))
# pool to reduce number of features
model.add(MaxPooling2D(pool_size=2))
# additional layers
model.add(Convolution2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Convolution2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
# flatten into single vector
model.add(Flatten())
# a hidden dense layer
model.add(Dense(512))
# last layer
model.add(Dense(num_classes, activation='softmax', name='output'))
# compile
model.compile(optimizer=Adam(lr=LEARN_RATE),
loss='categorical_crossentropy',
metrics=['accuracy'])
# train.. lost of options to mess with in this function
model.fit_generator(tr_gen, epochs=EPOCHS)
return model
def main():
batch_size = 54
epochs = 100
img_height = 50
img_width = 50
train_set, test_set, valid_set = data(batch_size, img_height, img_width)
model = Sequential([
Flatten(),
Dense(1250, activation='sigmoid'),
Dense(512, activation='sigmoid'),
Dense(10, activation='sigmoid'),
Dense(1, activation='sigmoid')
])
print("Built model successfully!~")
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit_generator(
train_set,
steps_per_epoch=5003 // batch_size,
epochs=epochs,
validation_data=valid_set,
validation_steps=2001 // batch_size
)
json_str = model.to_json()
with open(r'C:\Users\user1\PycharmProjects\gender-classification-1\Multilayer Perceptron\models\MLP_model.json',
'w') as outfile:
json.dump(json.loads(json_str), outfile, indent=4)
model.save_weights(
r"C:\Users\user1\PycharmProjects\gender-classification-1\Multilayer Perceptron\models\weights_MLP_model.h5",
save_format="h5")
print("Saved model to disk")
print('\n# Evaluate on test data')
results_test = model.evaluate_generator(test_set)
print('test loss, test acc:', results_test)
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(epochs)
plt.figure(figsize=(6, 6))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
def upload():
from tensorflow.keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,zoom_range = 0.2,horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1)
x_train = train_datagen.flow_from_directory(r'C:\Users\Washifa\Desktop\dataset\train_set',target_size=(64,64),batch_size=32,class_mode='binary')
x_test = test_datagen.flow_from_directory(r'C:\Users\Washifa\Desktop\dataset\test_set',target_size=(64,64),batch_size=32,class_mode='binary')
print(x_train.class_indices)
import tensorflow as tf
from tensorflow.python.keras.layers import Dense
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Convolution2D
from tensorflow.keras.layers import MaxPooling2D
from tensorflow.keras.layers import Flatten
model = Sequential()
model.add(Convolution2D(32,(3,3),input_shape = (64,64,3)))
model.add(MaxPooling2D(pool_size = (2,2)))
model.add(Flatten())
model.add(Dense(units = 128,kernel_initializer = 'uniform'))
model.add(Dense(units = 1,kernel_initializer = 'uniform'))
model.compile(loss='binary_crossentropy',optimizer = "adam",metrics = ["accuracy"])
model.fit_generator(x_train,validation_data=x_test, steps_per_epoch=10)
if request.method == 'POST':
f = request.files['image']
print("current path")
basepath = os.path.dirname(__file__)
print("current path", basepath)
filepath = os.path.join(basepath,'uploads\image',f.filename)
print("upload folder is ", filepath)
f.save(filepath)
test_datagen = ImageDataGenerator(rescale = 1./255)
vals = ['cancer','no cancer']
print(vals)
test_generator = test_datagen.flow_from_directory(r'C:\Users\Washifa\Desktop\pavithra\uploads',target_size =(64,64),class_mode ='categorical',batch_size = 32)
print(test_generator)
pred = model.predict_generator(test_generator)
print(pred)
y=str(vals[np.argmax(pred)])
os.remove(filepath)
return y
def train(X, y):
N = np.unique(y).size
model = Sequential()
model.add(Reshape((64, 64, 1)))
model.add(Convolution2D(32, (3, 3), input_shape = (64, 64), activation = 'relu'))
model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Convolution2D(16, (3, 3), activation = 'relu'))
model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Flatten())
model.add(Dense(units = 128, activation = 'relu'))
model.add(Dense(units = 128, activation = 'relu'))
model.add(Dense(units = N, activation = 'softmax'))
model.compile(optimizer = 'adam', metrics = ['accuracy'], loss = 'sparse_categorical_crossentropy')
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.1)
number_of_training_samples = len(list(X_train))
number_of_testing_samples = len(list(X_test))
X_train = X_train.reshape((number_of_training_samples, 64, 64, 1))
X_test = X_test.reshape((number_of_testing_samples, 64, 64, 1))
datagen = ImageDataGenerator(width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.2,
shear_range=0.1,
rotation_range=10.)
datagen.fit(X_train)
batches = datagen.flow(X_train, y_train, batch_size = 15)
X_batch, y_batch = next(batches)
model.fit_generator(datagen.flow(X_train, y_train, batch_size = 50),
steps_per_epoch = 2 * number_of_training_samples,
epochs=1, validation_data = (X_test, y_test))
return model
verbose=1,
restore_best_weights=True) #keeps the best weigths once stopped
# In[ ]:
ReduceLR = ReduceLROnPlateau(patience=3, verbose=1)
# In[ ]:
callbacks = [earlystop, checkpoint, ReduceLR]
# In[ ]:
history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=32),
epochs=10,
verbose=1,
callbacks=callbacks,
validation_data=(x_valid, y_validate))
# In[ ]:
import pickle
pickle_out = open("Trained_cnn_history.pickle", "wb")
pickle.dump(history.history, pickle_out)
pickle_out.close()
# In[ ]:
pickle_in = open("Trained_cnn_history.pickle", "rb")
saved_history = pickle.load(pickle_in)
class ModelBidirectDNA():
def __init__(self, params):
"""
It initializes the model before the training
"""
# defines where to save the model's checkpoints
self.results_base_dir = params['result_base_dir']
self.pretrained_model = params.get('pretrained_model', None)
if self.pretrained_model is not None:
# pretrained model load params from pickle
print("loading model")
train_dir = "/"
train_dir = train_dir.join(
params['pretrained_model'].split("/")[:-1])
print(train_dir)
with open(os.path.join(train_dir, "network_params"),
'rb') as params_pickle:
self.params = pickle.load(params_pickle)
self.params['result_base_dir'] = self.results_base_dir
else:
## new model
self.params = params
self.seeds = [42, 101, 142, 23, 53]
self.learning_rate = self.params['lr']
self.batch_size = self.params['batch_size']
weight_decay = self.params['weight_decay']
# Architecture --- emoji network
weight_init = tf.keras.initializers.glorot_uniform
recurrent_init = tf.keras.initializers.orthogonal(seed=42)
# Model definition
self.model = Sequential()
self.model.add(
Masking(mask_value=[1., 0., 0., 0., 0.],
input_shape=(self.params['maxlen'],
self.params['vocabulary_len'])))
self.model.add(
tf.keras.layers.Conv1D(
self.params['conv_num_filter'],
self.params['conv_kernel_size'],
activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
kernel_initializer=weight_init(self.seeds[2]),
activity_regularizer=tf.keras.regularizers.l2(weight_decay)))
self.model.add(tf.keras.layers.MaxPool1D())
self.model.add(
tf.keras.layers.Dropout(self.params['dropout_1_rate'],
seed=self.seeds[0]))
self.model.add(
tf.keras.layers.Conv1D(
self.params['conv_num_filter'],
self.params['conv_kernel_size'],
activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(weight_decay),
kernel_initializer=weight_init(self.seeds[3]),
activity_regularizer=tf.keras.regularizers.l2(weight_decay)))
self.model.add(tf.keras.layers.MaxPool1D())
self.model.add(
Bidirectional(
LSTM((int)(self.params['lstm_units']),
return_sequences=False,
dropout=self.params['lstm_input_dropout'],
kernel_initializer=weight_init(self.seeds[0]),
recurrent_initializer=recurrent_init,
kernel_regularizer=l2(self.params['weight_decay']))))
self.model.add(
Dropout(self.params['lstm_output_dropout'], seed=self.seeds[2]))
self.model.add(
Dense(8,
activation='relu',
kernel_initializer=weight_init(self.seeds[0])))
self.model.add(
Dropout(self.params['dense_dropout_rate'], seed=self.seeds[3]))
self.model.add(
Dense(1,
activation='sigmoid',
kernel_initializer=weight_init(self.seeds[4]),
kernel_regularizer=l2(self.params['weight_decay'])))
# Check if the user wants a pre-trained model. If yes load the weights
if self.pretrained_model is not None:
self.model.load_weights(self.pretrained_model)
def build(self, logger=None):
"""
It compiles the model by defining optimizer, loss and learning rate
"""
optimizer = tf.keras.optimizers.RMSprop(lr=self.learning_rate,
clipnorm=1.0)
self.model.compile(loss='binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy', f1_m, precision_m, recall_m])
if (logger is not None):
self.model.summary(print_fn=lambda x: logger.info(x))
else:
self.model.summary()
# Print params onto the logger
if logger is not None:
logger.info("\n" + json.dumps(self.params, indent=4))
def fit(self,
X_tr,
y_tr,
epochs,
callbacks_list,
validation_data,
shuffle=True):
"""
Fit the model with the provided data and returns the results
Inputs:
- X_tr: samples
- y_tr: labels related to the samples
- epochs: number of epochs before stopping the training
- callbacks_list
- validation_data: data the model is validated on each time a epoch is completed
- shuffle: if the dataset has to be shuffled before being fed into the network
Outputs:
- history: it contains the results of the training
"""
callbacks_list = self._get_callbacks()
history = self.model.fit(x=X_tr,
y=y_tr,
epochs=epochs,
shuffle=True,
batch_size=self.batch_size,
callbacks=callbacks_list,
validation_data=validation_data)
trained_epochs = callbacks_list[0].stopped_epoch - callbacks_list[
0].patience + 1 if callbacks_list[0].stopped_epoch != 0 else epochs
return history, trained_epochs
def fit_early_stopping_by_loss_val(self,
X_tr,
y_tr,
epochs,
early_stopping_loss,
callbacks_list,
validation_data,
shuffle=True):
"""
Train model until current validation loss reaches holdout training loss specified by early_stopping_loss parameter.
Algorithm 7.3 (Ian Goodfellow, Yoshua Bengio, and Aaron Courville. 2016. Deep Learning. The MIT Press, pp. 246-250.)
Params:
-------
:X_tr: training samples
:y_tr: training labels
:epochs: number of epochs training is performed on
:early_stopping_loss: threshold loss - Once reached this loss the training is stopped
:callbacks_list: list of callbacks to use in the training phase
:validation_data: data to evaluate the model on at the end of each epoch
:shuffle: if True, it shuffles data before starting the training
"""
print(f"early stopping loss: {early_stopping_loss}")
callbacks_list = self._get_callbacks(train=True)
callbacks_list.append(
EarlyStoppingByLossVal(monitor='val_loss',
value=early_stopping_loss))
history = self.model.fit(x=X_tr,
y=y_tr,
epochs=epochs,
batch_size=self.batch_size,
shuffle=True,
callbacks=callbacks_list,
validation_data=validation_data)
return history
def evaluate(self, features, labels):
"""
It evalutes the trained model onto the provided data
Inputs:
- features: sample of data to validate
- labels: classes the data belong to
Outputs:
- loss
- accuracy
- f1_score
- precision
- recall
"""
loss, accuracy, f1_score, precision, recall = self.model.evaluate(
features, labels, verbose=0)
metrics_value = [loss, accuracy, f1_score, precision, recall]
results_dict = dict(zip(self.model.metrics_names, metrics_value))
return results_dict
def print_metric(self, name, value):
print('{}: {}'.format(name, value))
def save_weights(self):
"""
It saves the model's weights into a hd5 file
"""
with open(os.path.join(self.results_base_dir, "network_params"),
'wb') as params_pickle:
pickle.dump(self.params, params_pickle)
self.model.save_weights(
os.path.join(self.results_base_dir, 'my_model_weights.h5'))
model_json = self.model.to_json()
with open(os.path.join(self.results_base_dir, "model.json"),
"w") as json_file:
json_file.write(model_json)
def fit_generator(self,
generator,
steps_per_epoch,
epochs,
validation_data=None,
shuffle=True,
callbacks_list=None):
"""
Train the model for the same number of update step as in holdout validation phase
Algorithm 7.2(Ian Goodfellow, Yoshua Bengio, and Aaron Courville. 2016. Deep Learning. The MIT Press, pp. 246-250.)
"""
history = self.model.fit_generator(
generator,
steps_per_epoch,
epochs,
shuffle=False,
callbacks=self._get_callbacks(train=True),
validation_data=validation_data)
return history
def _get_callbacks(self, train=True):
"""
It defines the callbacks for this specific architecture
"""
callbacks_list = [
keras.callbacks.EarlyStopping(monitor='val_loss',
patience=10,
restore_best_weights=True),
keras.callbacks.ModelCheckpoint(filepath=os.path.join(
self.results_base_dir, 'model_checkpoint_weights.h5'),
monitor='val_loss',
save_best_only=True,
verbose=0),
keras.callbacks.CSVLogger(
os.path.join(self.results_base_dir, 'history.csv')),
keras.callbacks.ReduceLROnPlateau(patience=10,
monitor='val_loss',
factor=0.75,
verbose=1,
min_lr=5e-6)
]
return callbacks_list
def predict(self,
x_test,
batch_size: int = 32,
verbose: int = 0) -> np.array:
"""
Wrapper method for Keras model's method 'precict'
Params:
-------
:x_test: test samples
:batch_size: default=32
:verbose: verbosity level
"""
return self.model.predict(
x_test,
batch_size=batch_size,
verbose=verbose,
).ravel()
def predict_classes(self,
x_test,
batch_size: int = 32,
verbose: int = 1) -> np.array:
"""
Wrapper method for Keras model's method 'precict_classes'
Params:
-------
:x_test: test samples
:batch_size: default=32
:verbose: verbosity level
Raise:
Exception
"""
try:
return self.model.predict_classes(x_test)
except Exception as err:
print(f"EXCEPTION-RAISED: {err}")
sys.exit(-1)
pass
class_mode='binary')
model = Sequential()
model.add(
layers.Conv2D(200, (3, 3), input_shape=(100, 100, 3), activation='relu'))
model.add(layers.MaxPooling2D(
pool_size=(2, 2),
strides=2)) #if stride not given it equal to pool filter size
model.add(layers.Conv2D(32, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=2))
model.add(layers.Flatten())
model.add(layers.Dense(units=128, activation='relu'))
model.add(layers.Dense(units=128, activation='relu'))
model.add(layers.Dense(units=1, activation='sigmoid'))
model.compile(optimizer='adam', loss='mse')
model.fit_generator(train_set, epochs=200, steps_per_epoch=10)
#1
for repeat in range(1, 20):
img1 = image.load_img(
'C:\\Users\\ahmed\\PycharmProjects\\untitled\\catanddog\\test1\\{}.jpg'
.format(repeat),
target_size=(100, 100))
img = image.img_to_array(img1)
img = img / 255
img = np.expand_dims(img, axis=0)
prediction = model.predict_classes(img)
plt.text(20,
62,
prediction,
color='red',
fontsize=18,
valid_gen = data_gen.flow_from_directory(spath,
target_size=(224, 224),
batch_size=batchSize,
class_mode="categorical",
subset="validation")
model = Sequential()
MobNet = MobileNetV2((224, 224, 3), include_top=False)
model.add(MobNet)
model.add(AveragePooling2D((7, 7)))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(2, activation="softmax"))
model.compile(optimizer="adam", loss="binary_crossentropy", metrics="accuracy")
his = model.fit_generator(generator=train_gen,
steps_per_epoch=len(train_gen) // batchSize,
validation_data=valid_gen,
validation_steps=len(valid_gen) // batchSize,
epochs=epochNum)
model.save("mask_detector.h5", save_format='h5')
plt.style.use("ggplot")
plt.figure()
plt.plot(range(epochNum), his.history['loss'], label="loss")
plt.plot(range(epochNum), his.history['accuracy'], label="accuracy")
plt.show()
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, # dimesion reduction
rotation_range=0.5, # randomly rotate images in the range 5 degrees
zoom_range = 0.5, # Randomly zoom image 5%
width_shift_range=0.5, # randomly shift images horizontally 5%
height_shift_range=0.5, # randomly shift images vertically 5%
horizontal_flip=False, # randomly flip images
vertical_flip=False) # randomly flip images
datagen.fit(X_train)
# fit the model
history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size), epochs = epochs, validation_data = (X_val,y_val), steps_per_epoch=X_train.shape[0] // batch_size)
#
plt.plot(history.history['val_loss'], color='purple', label="validation loss")
plt.title("Test Loss")
plt.xlabel("Number of Epochs")
plt.ylabel("Loss")
plt.legend()
plt.show()
# confusion matrix
import seaborn as sns
Y_pred = model.predict(X_val)
Y_pred_classes = np.argmax(Y_pred,axis = 1)
model.add(Dense(1024))
model.add(Activation("relu"))
model.add(BatchNormalization())
model.add(Dropout(0.5))
# softmax classifier
model.add(Dense(len(classes)))
model.add(Activation("softmax"))
# -
# Compile model with optimizer, loss function, and metrics
optimizer = Adam(learning_rate=learning_rate, epsilon=1e-08, clipnorm=1.0)
model.compile(optimizer=optimizer,
loss='binary_crossentropy',
metrics=['accuracy'])
# Train the model
model.fit_generator(train_generator,
steps_per_epoch=steps_per_epoch,
epochs=num_epochs,
validation_data=valid_generator,
validation_steps=10,
callbacks=[AmlLogger()],
verbose=1)
# Save the output model
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model.save(os.path.join(output_dir, 'model.h5'))
shutil.copyfile('classes.txt', os.path.join(output_dir, 'classes.txt'))
class RECOGNIZE_FLOWERS():
def __init__(self):
self.num_epochs = 3
self.batch_size = 40
self.input_height = 500
self.input_width = 500
self.channels = 3
self.input_shape = (self.input_height, self.input_width, self.channels)
self.train_dir = "Flower_images/data/train"
self.train_files = []
for i in range(0, 200):
self.train_files.append(str(i) + ".jpg")
self.labels = pd.read_csv("Flower_images/data/train.csv")
self.train_labels = self.labels[:280]
self.train_labels_dict = {
i: j
for i, j in zip(self.train_labels["image_id"],
self.train_labels["category"])
}
self.validation_files = []
for i in range(200, 280):
self.validation_files.append(str(i) + ".jpg")
self.steps_per_epoch = 5
def buildAndCompileModel(self):
self.model = Sequential()
self.model.add(
Conv2D(16, (3, 3), padding='same', input_shape=self.input_shape))
self.model.add(Activation('relu'))
self.model.add(Conv2D(16, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(Conv2D(16, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(Flatten())
self.model.add(Dense(256))
self.model.add(Activation('relu'))
self.model.add(Dense(102, activation='sigmoid'))
self.model.compile(optimizer='adam',
loss="binary_crossentropy",
metrics=["accuracy"])
def train_model(self):
training_generator = self.image_datagenerator(self.train_files)
validation_generator = self.image_datagenerator(self.validation_files)
self.model.fit_generator(training_generator,
steps_per_epoch=self.steps_per_epoch,
validation_data=validation_generator,
validation_steps=2,
epochs=self.num_epochs)
self.model.predict_generator(self.validation_generator, verbose=1)
def image_datagenerator(self, input_filenames):
input_files = []
for i in input_filenames:
input_files.append(self.train_dir + "/" + i)
counter = 0
random.shuffle(input_files)
while True:
images = np.zeros(
(self.batch_size, self.input_width, self.input_height, 3))
labels = []
if counter + self.batch_size >= len(input_files):
counter = 0
for i in range(self.batch_size):
img = str(input_files[counter + i])
images[i] = np.array(Image.open(img)) / 255.0
file_number = img.replace("Flower_images/data/train/",
"").replace(".jpg", "")
labels.append(self.train_labels_dict[int(file_number)])
yield (images, labels)
counter += self.batch_size
metrics=['accuracy'])
if i == 0:
model.summary()
# set callbacks
mcloss_cb = callbacks.ModelCheckpoint(filepath=path + os.sep + str(i) + os.sep + 'lowValLoss.hdf5', monitor='val_loss', save_best_only=True)
mcacc_cb = callbacks.ModelCheckpoint(filepath=path + os.sep + str(i) + os.sep + 'bestAcc.hdf5', monitor='val_acc', save_best_only=True)
esloss_cb = callbacks.EarlyStopping(patience=1)
cbs = []
cbs.append(mcloss_cb)
cbs.append(mcacc_cb)
cbs.append(esloss_cb)
# fits the model on batches with real-time data augmentation:
his = model.fit_generator(datagen.flow(x_train, y_train, batch_size=8, save_to_dir=path + os.sep + str(i) + os.sep, save_prefix='train'), validation_data=(x_test,y_test),
callbacks= cbs, steps_per_epoch=100, epochs=epoch, verbose=1)
accs[i,0:len(his.history['acc'])] = his.history['acc']
val_accs[i,0:len(his.history['val_acc'])] = his.history['val_acc']
loss[i,0:len(his.history['loss'])] = his.history['loss']
val_loss[i,0:len(his.history['val_loss'])] = his.history['val_loss']
np.save(path + os.sep + 'acc', accs)
np.save(path + os.sep + 'val_acc', val_accs)
np.save(path + os.sep + 'val_loss', val_loss)
np.save(path + os.sep + 'loss', loss)
i += 1
np.save(path + os.sep + 'acc', accs)
np.save(path + os.sep + 'val_acc', val_accs)
valid = train_datagen.flow_from_directory(directory=train_dir, target_size=(img_height, img_lenght),
class_mode="categorical", batch_size=32, subset="validation")
mobilenet = MobileNetV2(weights = "imagenet",include_top = False,input_shape=(150,150,3))
for layer in mobilenet.layers:
layer.trainable = False
model = Sequential()
model.add(mobilenet)
model.add(Flatten())
model.add(Dense(2,activation="sigmoid"))
model.compile(optimizer="adam",loss="categorical_crossentropy",metrics ="accuracy")
checkpoint = ModelCheckpoint("moblenet_facemask.h5",monitor="val_accuracy",save_best_only=True,verbose=1)
earlystop = EarlyStopping(monitor="val_acc",patience=5,verbose=1)
history = model.fit_generator(generator=train,steps_per_epoch=len(train)// 32,validation_data=valid,
validation_steps = len(valid)//32,callbacks=[checkpoint,earlystop],epochs=15)
model.evaluate_generator(valid)
model.save("face_mask.h5")
pred = model.predict_classes(valid)
pred[:15]
#check
#without mask
mask = "../input/with-and-without-mask/"
plt.figure(figsize=(8, 7))
label = {0: "With Mask", 1: "Without Mask"}
color_label = {0: (0, 255, 0), 1: (0, 0, 255)}
cascade = cv2.CascadeClassifier("../input/frontalface/haarcascade_frontalface_default.xml")
count = 0
i = "../input/with-and-without-mask/mask9.jpg"
model.add(Dropout(0.4))
model.add(LSTM(100, activation = 'tanh', recurrent_activation = 'sigmoid', unroll = False, use_bias = True, recurrent_dropout = 0,return_sequences= True))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(1, activation = 'linear'))
'''
adadelta = Adadelta(learning_rate=1.0, rho=0.95)
model.compile(loss='mse',
optimizer=adadelta,
metrics=[tf.keras.metrics.MeanAbsolutePercentageError()])
model.summary()
##### TRAINING #####
history = model.fit_generator(train_gen,
epochs=100,
verbose=2,
shuffle=False,
validation_data=test_gen)
##### PLOTTING LOSS ######
plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
plt.show()
score = model.evaluate_generator(test_gen, verbose=1)
print()
print('Test loss:', score[0])
print('Test accuracy:', score[1])
print()
###### RESHAPE ACTUAL DATA #######
def train(ticker):
#Initializing the Paths
create_dir(model_dir + '/' + ticker)
output = {}
present_date = date.today()
prev_date = date.today() - timedelta(days=5457)
dataset = get_stock_data(ticker,
start_date=prev_date,
end_date=present_date,
drop_na=True).reset_index(drop=True)
dataset.to_csv(model_dir + '/' + ticker + '/' + str(ticker) + '.csv',
index=False)
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(dataset.values)
pickle.dump(scaler, open(model_dir + '/' + ticker + '/scaler.pkl', 'wb'))
##### TRAIN TEST SPLITTING #####
'''
train_gen = TimeseriesGenerator(scaled, scaled[:,0:4], start_index = 0, end_index = int(len(scaled) * 0.90), length = 1, batch_size = 256)
test_gen = TimeseriesGenerator(scaled, scaled[:,0:4], start_index = int(len(scaled) * 0.90), end_index = int(len(scaled) - 1), length = 1, batch_size = 256)
'''
train_gen = TimeseriesGenerator(scaled,
scaled[:, :4],
start_index=0,
end_index=int(len(scaled) * 0.85),
length=5,
batch_size=16)
test_gen = TimeseriesGenerator(scaled,
scaled[:, :4],
start_index=int(len(scaled) * 0.85),
end_index=int(len(scaled) - 1),
length=5,
batch_size=16)
##### MODEL CREATION ######
'''
model = Sequential()
model.add(Conv1D(18, kernel_size=3, activation='relu', padding = 'valid', strides=1, input_shape=(1,18), data_format='channels_first'))
model.add(Conv1D(18, kernel_size=3, activation='relu', padding = 'valid', strides=1))
#model.add(MaxPooling1D(pool_size=2))
model.add(LSTM(100, activation = 'tanh', recurrent_activation = 'sigmoid', unroll = False, use_bias = True, recurrent_dropout = 0, return_sequences=True))
model.add(Dropout(0.4))
model.add(LSTM(100, activation = 'tanh', recurrent_activation = 'sigmoid', unroll = False, use_bias = True, recurrent_dropout = 0,return_sequences=True))
model.add(Dropout(0.4))
model.add(LSTM(100, activation = 'tanh', recurrent_activation = 'sigmoid', unroll = False, use_bias = True, recurrent_dropout = 0,return_sequences= True))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(4, activation = 'linear'))
adadelta = Adadelta(learning_rate=1.0, rho=0.95)
model.compile(loss= 'mae', optimizer = adadelta, metrics=[tf.keras.metrics.MeanAbsolutePercentageError()])
#model.summary()
'''
from tensorflow.keras.regularizers import l1
model = Sequential()
model.add(
Conv1D(18,
kernel_size=3,
activation='relu',
padding='valid',
strides=1,
input_shape=(5, 18),
data_format='channels_first'))
model.add(
Conv1D(18,
kernel_size=4,
activation='relu',
padding='valid',
strides=1))
#model.add(MaxPooling1D(pool_size=2))
model.add(
LSTM(100,
activation='tanh',
recurrent_activation='sigmoid',
unroll=False,
use_bias=True,
recurrent_dropout=0,
return_sequences=True,
kernel_regularizer=l1(0.001)))
model.add(Dropout(0.4))
model.add(
LSTM(50,
activation='tanh',
recurrent_activation='sigmoid',
unroll=False,
use_bias=True,
recurrent_dropout=0,
return_sequences=True,
activity_regularizer=l1(0.001)))
model.add(Dropout(0.4))
model.add(
LSTM(25,
activation='tanh',
recurrent_activation='sigmoid',
unroll=False,
use_bias=True,
recurrent_dropout=0,
return_sequences=True,
activity_regularizer=l1(0.001)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(4, activation='linear'))
adadelta = Adadelta(learning_rate=1.0, rho=0.95)
model.compile(loss='mse',
optimizer=adadelta,
metrics=[tf.keras.metrics.RootMeanSquaredError()])
model.summary()
##### TRAINING #####
my_callbacks = [
#tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', patience=4, factor=0.2, min_lr=0.001),
tf.keras.callbacks.ModelCheckpoint(
filepath=model_dir + "/" + ticker + "/model" + ".h5",
save_weights_only=True,
save_best_only=True,
monitor="val_root_mean_squared_error",
mode="min"),
]
history = model.fit_generator(train_gen,
epochs=300,
verbose=0,
shuffle=True,
validation_data=test_gen,
callbacks=my_callbacks)
##### PLOTTING LOSS ######
'''plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
plt.show()
score = model.evaluate_generator(test_gen, verbose = 1)
print()
print('Test loss:', score[0])
print('Test accuracy:', score[1])
print()'''
###### RESHAPE ACTUAL DATA #######
actual_train = reshape_actual(train_gen)
predictions_train = model.predict_generator(train_gen, verbose=0)
print(predictions_train)
##### RSME FOR TRAIN #####
rmse_train = math.sqrt(
mean_squared_error(actual_train[:], predictions_train[:]))
print(rmse_train)
###### TEST DATA ######
actual_test = reshape_actual(test_gen)
predictions_test = model.predict_generator(test_gen, verbose=0)
rmse_test = math.sqrt(
mean_squared_error(actual_test[:], predictions_test[:]))
print(rmse_test)
output["Accuracy"] = {
"Train": round(rmse_train * 100, 2),
"Test": round(rmse_test * 100, 2)
}
###### PLOT TEST ######
output["Train"] = plot_them_graphs(actual_train, predictions_train,
"train", ticker, scaler)
output["Test"] = plot_them_graphs(actual_test, predictions_test, "test",
ticker, scaler)
##### SAVE IT!!!!!! #####
model_json = model.to_json()
with open(model_dir + "/" + ticker + "/model" + ".json", "w") as json_file:
json_file.write(model_json)
#model.save_weights(model_dir + "/" + ticker + "/model" + ".h5")
print("Saved model to disk")
data = {"name": ticker, "date": present_date.strftime("%d-%b-%Y")}
with open(model_dir + "/" + ticker + '/data.json', 'w') as outfile:
json.dump(data, outfile)
return output
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
model.summary()
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
#Model Fitting
history = model.fit_generator(generator=trainData,
steps_per_epoch=100,
epochs=10,
validation_data=testData,
validation_steps=40)
#plot for Loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epochs')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
#test Image
test = r'D:\Bhushan\casting_512x512\def_front\cast_def_0_180.jpeg'
img = image.load_img(test, target_size=(128, 128))
MaxPool2D(pool_size=2),
Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation='relu'),
BatchNormalization(),
MaxPool2D(pool_size=2),
Flatten(),
Dense(units=num_classes, activation='softmax'),
])
loss = keras.losses.CategoricalCrossentropy()
opt = keras.optimizers.Adam(lr=0.000001)
best_model = ModelCheckpoint(
'dogs-iter1model.h5', save_best_only=True, verbose=1)
model.compile(optimizer='adam', loss=loss, metrics=['accuracy'])
H = model.fit_generator(aug_generator.flow(train_X, train_Y, batch_size=batch_size),
epochs=epochs, validation_data=(test_X, test_Y), callbacks=[best_model])
# testing
test_loss, test_acc = model.evaluate(test_X, test_Y)
print('test_acc:', test_acc)
# plot
epochs = range(1, len(H.history['acc']) + 1)
plt.figure(1, figsize=(8, 5))
plt.title("Training and test accuracy")
plt.ylabel('accuracy')
plt.xlabel('epochs')
plt.plot(epochs, H.history['acc'], 'r', label='train')
plt.plot(epochs, H.history['val_acc'], 'b', label='test')
plt.legend()
model.compile(optimizer='Adam',
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError()])
datagen = ImageDataGenerator(featurewise_center=True,
featurewise_std_normalization=True,
rotation_range=20,
width_shift_range=0.2,
zoom_range=0.4,
height_shift_range=0.2,
horizontal_flip=True)
# compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied)
datagen.fit(Images)
# fits the model on batches with real-time data augmentation:
model.fit_generator(datagen.flow(Images, Labels, batch_size=32), epochs=30)
#history = model.fit(Images, Labels, epochs=25, shuffle=True, validation_split=0.15)
#PRE-PROCESSING TEST IMAGES
directory = '/content/drive/My Drive/giara/jukil/test/'
test_images = []
for image_file in os.listdir(
directory
): #Extracting the file name of the image from Class Label folder
image = cv2.imread(directory + '/' +
image_file) #Reading the image (OpenCV)
image = cv2.resize(
classifier.add(Dense(units = 1, activation = 'sigmoid'))
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
train_datagen = ImageDataGenerator(
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1./255)
train_set = train_datagen.flow_from_directory(
'dataset/training_set',
target_size=(64, 64),
batch_size=32,
class_mode='binary')
test_set = test_datagen.flow_from_directory(
'dataset/test_set',
target_size=(64, 64),
batch_size=32,
class_mode='binary')
classifier.fit_generator(
train_set,
steps_per_epoch=8000,
epochs=25,
validation_data=test_set,
validation_steps=2000)
def create_model(x_valid, y_valid, datagen, val_datagen, x_train, y_train):
# construct the search space
conv1_numfilters = {{choice([32, 64, 128, 256])}}
conv1_size = {{choice([(2, 2), (3, 3), (5, 5)])}}
conv1_activation = {{choice([relu, tanh, elu])}}
conv2_numfilters = {{choice([32, 64, 128, 256])}}
conv2_size = {{choice([(2, 2), (3, 3), (5, 5)])}}
conv2_activation = {{choice([relu, tanh, elu])}}
conv3_numfilters = {{choice([32, 64, 128, 256])}}
conv3_size = {{choice([(2, 2), (3, 3), (5, 5)])}}
conv3_activation = {{choice([relu, tanh, elu])}}
conv4_numfilters = {{choice([32, 64, 128, 256])}}
conv4_size = {{choice([(2, 2), (3, 3), (5, 5)])}}
conv4_activation = {{choice([relu, tanh, elu])}}
maxpool1_size = {{choice([2, 4, 8])}}
maxpool2_size = {{choice([2, 4, 8])}}
dense_activation = {{choice([relu, tanh, elu])}}
num_neurons = {{choice([64, 128, 256, 512])}}
dropout = {{uniform(0, 1)}}
learn_rate = {{uniform(0.00001, 0.01)}}
batch_size = {{choice([16, 32, 64])}}
# build model
model = Sequential()
model.add(
Conv2D(conv1_numfilters,
conv1_size,
input_shape=(64, 64, 1),
padding="same",
activation=conv1_activation))
model.add(
Conv2D(conv2_numfilters,
conv2_size,
padding="same",
activation=conv2_activation))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=maxpool1_size))
model.add(
Conv2D(conv3_numfilters,
conv3_size,
padding="same",
activation=conv3_activation))
model.add(
Conv2D(conv4_numfilters,
conv4_size,
padding="same",
activation=conv4_activation))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=maxpool2_size))
model.add(Flatten())
model.add(Dense(units=num_neurons, activation=dense_activation))
model.add(Dropout(dropout))
model.add(Dense(units=6, activation=softmax))
model.compile(loss=sparse_categorical_crossentropy,
optimizer=Adam(lr=learn_rate, decay=0.001),
metrics=["accuracy"])
model.summary()
train_steps = x_train.shape[0] // batch_size
valid_steps = x_valid.shape[0] // batch_size
result = model.fit_generator(datagen.flow(x_train,
y_train,
batch_size=batch_size),
epochs=80,
verbose=2,
validation_data=val_datagen.flow(
x_valid, y_valid, batch_size=batch_size),
steps_per_epoch=train_steps,
validation_steps=valid_steps)
# take max validation accuracy as metric
validation_acc = np.amax(result.history['val_acc'])
return {
'loss': -validation_acc,
'status': STATUS_OK,
'model': model,
'history.val_loss': result.history['val_loss'],
'history.val_acc': result.history['val_acc']
}
model.summary()
model = model
model.compile(optimizer='sgd',
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError()])
checkpointer = ModelCheckpoint(
filepath='/content/drive/My Drive/giara/best_model_7class.hdf5',
verbose=1,
save_best_only=True)
csv_logger = CSVLogger('/content/drive/My Drive/giara/history_7class.log')
history = model.fit_generator(train_generator,
steps_per_epoch=nb_train_samples // batch_size,
validation_data=validation_generator,
validation_steps=nb_validation_samples //
batch_size,
epochs=6,
verbose=1,
callbacks=[csv_logger, checkpointer])
model.save('model_trained_7class.hdf5')
class_map_3 = train_generator.class_indices
class_map_3
def plot_rmse(history, title):
plt.title(title)
plt.plot(history.history['root_mean_squared_error'])
plt.plot(history.history['val_root_mean_squared_error'])
plt.ylabel('root_mean_squared_error')
from tensorflow.keras.preprocessing.image import ImageDataGenerator train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,zoom_range = 0.2,horizontal_flip = True) test_datagen = ImageDataGenerator(rescale = 1) x_train = train_datagen.flow_from_directory(r'C:\Users\Washifa\Desktop\D\trainset',target_size=(64,64),batch_size=32,class_mode='binary') x_test = test_datagen.flow_from_directory(r'C:\Users\Washifa\Desktop\D\testset',target_size=(64,64),batch_size=32,class_mode='binary') print(x_train.class_indices) import tensorflow as tf from tensorflow.python.keras.layers import Dense from tensorflow.keras import Sequential from tensorflow.keras.layers import Convolution2D from tensorflow.keras.layers import MaxPooling2D from tensorflow.keras.layers import Flatten model = Sequential() model.add(Convolution2D(32,(3,3),input_shape = (64,64,3))) model.add(MaxPooling2D(pool_size = (2,2))) model.add(Flatten()) model.add(Dense(units = 128,kernel_initializer = 'uniform')) model.add(Dense(units = 1,kernel_initializer = 'uniform')) model.compile(loss='binary_crossentropy',optimizer = "adam",metrics = ["accuracy"]) model.fit_generator(x_train,validation_data=x_test, steps_per_epoch=10) model.save(r'C:\Users\Washifa\Desktop\test\test.h5')
def main():
###predeclared parameters for the learning
batch_size = 64
epochs = 250
IMG_HEIGHT = 200
IMG_WIDTH = 200
###all data sets will use as train set, validation set and test set
train_image_generator = ImageDataGenerator(
rescale=1. / 255,
rotation_range=45,
width_shift_range=.15,
height_shift_range=.15,
horizontal_flip=True,
zoom_range=0.5) # Generator for our training data
validation_image_generator = ImageDataGenerator(
rescale=1. / 255) # Generator for our validation data
test_image_generator = ImageDataGenerator(rescale=1. / 255)
train_data_gen = train_image_generator.flow_from_directory(
batch_size=batch_size,
directory=
r"C:\Users\evgen\Desktop\DL_Git_forAllProj\CNN\dataset\train_set",
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='binary')
val_data_gen = validation_image_generator.flow_from_directory(
batch_size=batch_size,
directory=
r"C:\Users\evgen\Desktop\DL_Git_forAllProj\CNN\dataset\val_set",
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='binary')
test_data_gen = test_image_generator.flow_from_directory(
batch_size=batch_size,
directory=
r"C:\Users\evgen\Desktop\DL_Git_forAllProj\CNN\dataset\train_set",
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='binary')
###building the model
model = Sequential([
Conv2D(16,
3,
padding='same',
activation='relu',
input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
MaxPooling2D(),
Dropout(0.2),
Conv2D(32, 3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(64, 3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(128, 3, padding='same', activation='relu'),
MaxPooling2D(),
Dropout(0.2),
Flatten(),
Dense(512, activation='relu'),
Dense(1, activation='sigmoid')
])
###complinig the model
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit_generator(train_data_gen,
steps_per_epoch=6003 // batch_size,
epochs=epochs,
validation_data=val_data_gen,
validation_steps=2001 // batch_size)
###summary of the model after traning
print('\nhistory dict:', history.history)
###saving the model and weights as a json and h5 files
json_str = model.to_json()
with open(
r'C:\Users\evgen\Desktop\n_models\saved_model_250ep_w_dropout_data_rich.json',
'w') as outfile:
json.dump(json.loads(json_str), outfile,
indent=4) # Save the json on a file
model.save_weights(
r"C:\Users\evgen\Desktop\n_models\weights_250ep_w_dropout_data_rich.h5",
save_format="h5")
print("Saved model to disk")
###evaluating the model on the test data
print('\n# Evaluate on test data')
results_test = model.evaluate_generator(test_data_gen)
print('test loss, test acc:', results_test)
####printing the model as a graph
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(epochs)
plt.figure(figsize=(6, 6))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
RNN(HIDDEN_SIZE),
layers.RepeatVector(3),
RNN(128, return_sequences=True),
layers.TimeDistributed(layers.Dense(len(CHARS), activation='softmax'))
])
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
train_generator = encode_generator(training_generator, BATCH_SIZE)
hist = model.fit_generator(train_generator,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=EPOCHS,
verbose=1,
use_multiprocessing=True,
workers=-2,
callbacks=callbacks,
validation_data=train_generator, validation_steps=30)
score = model.evaluate_generator(encode_generator(
test_generator, BATCH_SIZE), steps=STEPS_PER_EPOCH)
print(score)
config = build_config(MODEL_NAME, LEARNING_RATE, BATCH_SIZE,
EPOCHS, STEPS_PER_EPOCH, score[0], score[1])
wrapper = ModelWrapper(model, config=config)
wrapper.save_model()
train_datagen = ImageDataGenerator(rescale=1.0 / 255.0,
validation_split=0.2,
rotation_range=10)
train_generator = train_datagen.flow(x=x_shuffled,
y=y_shuffled,
batch_size=batch_size,
subset='training') # set as training data
validation_generator = train_datagen.flow(
x=x_shuffled, y=y_shuffled, batch_size=batch_size,
subset='validation') # set as validation data
#training
nb_epochs = 5
model.fit_generator(train_generator,
validation_data=validation_generator,
epochs=nb_epochs)
#testing
import os
x_test = []
for filename in os.listdir('D:/desktop/med_hw2/test_image/'):
img = cv2.imread(os.path.join('D:/desktop/med_hw2/test_image/', filename))
if img is not None:
img = cv2.resize(img, (224, 224), interpolation=cv2.INTER_AREA)
x_test.append(img)
x_test_np = np.array(x_test)
y_predict = model.predict(x_test_np)
import csv
fn = sorted(os.listdir('D:/desktop/med_hw2/test_image/'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPool2D(2, 2))
model.add(Conv2D(128, (3, 3), activation='relu'))
#model.add(MaxPool2D(2, 2))
model.add(Flatten())
#model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
print(model.summary())
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit_generator(generator=train_data_generator,
steps_per_epoch=len(train_data_generator),
epochs=20,
validation_data=validation_data_generator,
validation_steps=len(validation_data_generator))
model.add(MaxPooling2D((2, 2), padding='same'))
# model.add(Dropout(0.2))
model.add(Conv2D(32, (6, 6), padding='same', activation='relu'))
model.add(MaxPooling2D((2, 2), padding='same'))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4, activation='softmax'))
model.compile(loss="categorical_crossentropy",
optimizer='adam',
metrics=['accuracy'])
history = model.fit_generator(
train_generator,
workers=100,
steps_per_epoch=63, # 2000 images over 32 batch size
validation_data=valid_generator,
epochs=20)
scores = model.evaluate_generator(valid_generator)
print("\n\n1 - Accuracy 1st test: " + str(scores[1]))
"""scores = model.evaluate_generator(valid_generator2)
print("\n\n1 - Accuracy 2nd test: "+str(scores[1]))
scores = model.evaluate_generator(valid_generator3)
print("\n\n1 - Accuracy 3rd test: "+str(scores[1])) """
loss1 = history.history['loss']
val_loss1 = history.history['val_loss']
plt.plot(loss1, color="red")
plt.plot(val_loss1, color="blue")
def train_binary_model(path,
epochs=100,
ft_epochs=100,
learning_rate=0.01,
classes_to_match: Union[int, List[int]] = 0,
classes_to_drop: Union[int, List[int]] = None):
"""
Train a smaller binary model for empty/not empty classification and save it under the given path. The method first
loads the models using :py:doc:`generate_datasets.py <training.generate_datasets.py>` methods. Then the model is
trained, saved and finally evaluated.
Training is run in two steps: It is first trained with synthetic data and then finetuned with real data. Early
stopping is used to prevent overfitting.
Args:
path(str): The directory to save the trained model to.
epochs(int): The number of epochs. (Default value = 100)
ft_epochs: The number of finetuning epochs. (Default value = 100)
learning_rate: The learning rate for the Adadelta optimizer. (Default value = 0.01)
classes_to_match(Union[int, list[int]]): The classes to match as class 1. (Default value = 0)
classes_to_drop(Union[int, list[int]]): The classes to drop from the dataset. (Default value = None)
Returns:
None
"""
os.makedirs(path, exist_ok=True)
concat_machine, concat_hand, concat_out, real_training, real_validation = load_datasets(
TRANSFORMED_DATASET_NAMES)
batch_size = 192
train_generator = ToBinaryGenerator(concat_machine.train,
concat_hand.train,
concat_out.train,
classes_to_match=classes_to_match,
classes_to_drop=classes_to_drop,
batch_size=batch_size,
shuffle=True,
truncate=True)
dev_generator = ToBinaryGenerator(concat_machine.test,
concat_hand.test,
concat_out.test,
classes_to_match=classes_to_match,
classes_to_drop=classes_to_drop,
batch_size=batch_size,
shuffle=True,
truncate=True)
ft_train_generator = ToBinaryGenerator(real_training.train,
classes_to_match=classes_to_match,
classes_to_drop=classes_to_drop,
batch_size=batch_size,
shuffle=True,
truncate=True)
ft_dev_generator = ToBinaryGenerator(real_training.test,
classes_to_match=classes_to_match,
classes_to_drop=classes_to_drop,
batch_size=batch_size,
shuffle=True,
truncate=True)
test_generator = ToBinaryGenerator(real_validation.test,
classes_to_match=classes_to_match,
classes_to_drop=classes_to_drop,
batch_size=batch_size,
shuffle=False)
# Run training on the GPU
with tf.device('/GPU:0'):
# Keras Model
print("Creating model..")
model = Sequential()
model.add(Conv2D(16, (5, 5), strides=2, input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(4, 4)))
model.add(Conv2D(32, (2, 2)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten()) # 32
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(64, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# def mean_pred(_, y):
# return keras.backend.mean(y)
print("Compiling model..")
model.compile(
loss=keras.losses.BinaryCrossentropy(from_logits=True),
optimizer=keras.optimizers.Adadelta(learning_rate),
metrics=[keras.metrics.binary_accuracy, 'mse'],
)
print(model.summary())
print("Training model")
model.fit_generator(train_generator,
validation_data=dev_generator,
epochs=epochs,
callbacks=[
EarlyStopping(monitor='val_accuracy',
restore_best_weights=True,
patience=3,
min_delta=0.0001),
])
print("Finetuning model")
model.fit_generator(ft_train_generator,
validation_data=ft_train_generator,
epochs=ft_epochs,
callbacks=[
EarlyStopping(monitor='val_accuracy',
restore_best_weights=True,
patience=3,
min_delta=0.0001),
])
models.save_model(model, path + "model.h5", save_format='h5')
print("Evaluating")
print(
"Training dev",
list(
zip(model.metrics_names,
model.evaluate_generator(dev_generator))))
print(
"Finetuning dev",
list(
zip(model.metrics_names,
model.evaluate_generator(ft_dev_generator))))
print(
"Test",
list(
zip(model.metrics_names,
model.evaluate_generator(test_generator))))
evaluate(model, test_generator, binary=True)
model.add(MaxPool2D(pool_size=3, strides=2))
model.add(
Conv2D(256, kernel_size=3, strides=2, padding='SAME', activation='relu'))
model.add(
Conv2D(256, kernel_size=3, strides=1, padding='SAME', activation='relu'))
model.add(
Conv2D(256, kernel_size=3, strides=1, padding='SAME', activation='relu'))
model.add(MaxPool2D(pool_size=3, strides=2))
model.add(Dropout(rate=0.3))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dense(1, 'sigmoid'))
print(model.summary())
opt = tf.keras.optimizers.Adam()
ES = EarlyStopping(monitor='val_loss',
patience=3,
verbose=1,
restore_best_weights=True)
LRR = ReduceLROnPlateau(monitor='val_loss', factor=0.2, verbose=1)
model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy'])
history = model.fit_generator(train_gen,
steps_per_epoch=steps,
epochs=15,
callbacks=[ES, LRR],
validation_data=val_gen)
score = model.evaluate_generator(test_gen)
print(score)
zca_whitening=False, # apply ZCA whitening
rotation_range=10, # randomly rotate images in the range (degrees, 0 to 180)
zoom_range=0.1, # Randomly zoom image
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=False, # randomly flip images
vertical_flip=False) # randomly flip images
datagen.fit(x_train)
history = model.fit_generator(datagen.flow(x_train,
y_train,
batch_size=batch_size),
epochs=epochs,
validation_data=(x_val, y_val),
verbose=2,
steps_per_epoch=x_train.shape[0] // batch_size,
callbacks=[learning_rate_reduction])
df_test = pd.read_csv(os.path.join(raw_data_dir, project, test_file))
df_test /= 255
df_test = df_test.values.reshape(-1, 28, 28, 1)
results = model.predict(df_test)
# select the indix with the maximum probability
results = np.argmax(results, axis=1)
results = pd.Series(results, name="Label")
submission = pd.concat([pd.Series(range(1, 28001), name="ImageId"), results],
axis=1)
