def create_and_train_model(self, trainX, trainY, testX, testY, main_directory):
start = datetime.datetime.now()
# Update indiv_id pour avoir un vrai ID unique
self.indiv_id = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
# Choix d'un emplacement pour les logs
log_dir=main_directory+"\\logs_"+self.indiv_id+"\\tensorboard_data\\"
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
print("log dir = ",log_dir)
#ON VA GERER L1 ET L2, A L AVENIR IL FAUDRAIT MIEUX LES GERER DANS UNE FONCTION ?
if self.l1 > 0:
self.my_regularizer = regularizers.l1(self.l1 / self.nb_layers)
elif self.l2 > 0:
self.my_regularizer = regularizers.l2(self.l2 / self.nb_layers)
else:
self.my_reguralizer = 'he_uniform'
# Definir notre modèle basique, 2 couches de conv et 1 pool avant tout
model = Sequential()
model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding, input_shape=(32, 32, 3)))
model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding))
model.add(MaxPooling2D((2, 2)))
# Faire toutes les convs nécessaires
if self.nb_layers > 2:
for i in range(2, self.nb_layers):
if self.nb_layers - i != 1:
print("i = ", i)
# 2 conv + pool
model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding))
model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding))
model.add(MaxPooling2D((2, 2)))
else:
# 1 conv + pool si nombre impair de couches (nb_layers)
model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding))
model.add(MaxPooling2D((2, 2)))
# Fin des convs -> neural network classique (je n'utilise pas self.activation car ce n'est pas relié a ce neural net)
model.add(Flatten())
model.add(Dense(128, activation='relu', kernel_initializer=self.my_reguralizer))
model.add(Dense(10, activation='softmax'))
# Compiler le modele
opt = SGD(lr=0.001, momentum=0.9)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])
#save model png
plot_model(model, "model.png")
# Entrainer le modele
history = model.fit(trainX, trainY, epochs=self.epochs, batch_size=64, validation_data=(testX, testY), verbose=0, callbacks=[tensorboard_callback])
end = datetime.datetime.now()
self.time_fit = end - start # J'arrive pas trop à le round, ça pourrait servir !
print("Time for fit = ", self.time_fit)
# Deplacement modele au bon endroit
shutil.move("C:\\Users\\arnau\\Desktop\\quatrième_année\\Deep_Learning\\Projet_cifar-10\\model.png", main_directory+"\\logs_"+self.indiv_id+"\\model.png")
return history
outName = videoName[:-4] + '_' + str(qsize) + '.avi'
modelname = 'phone_usage_DNN'
modelpath = os.path.join('model', modelname + ".hdf5")
pickpath = os.path.join('model', modelname + ".pickle")
videopath = os.path.join('example_clips', videoName)
outpath = os.path.join('output', outName)
imgMean = np.array([123.68, 116.779, 103.939], dtype="float32")
Q = deque(maxlen=qsize)
# ...........................................................................
print("Loading model and pickle files ...")
lb = pickle.loads(open(pickpath, "rb").read())
optmz = SGD(lr=1e-4, momentum=0.9, decay=1e-4 / 25)
#base = ResNet50(weights="imagenet",
# include_top=False,
# input_tensor=Input(shape=(224, 224, 3)))
base = ResNet50(weights=None,
include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
def createModel():
h = base.output
h = AveragePooling2D(pool_size=(7, 7))(h)
h = Flatten(name="flatten")(h)
h = Dense(512, activation="relu")(h)
activation='relu',
strides=(2, 2),
padding='same'),
tf.keras.layers.BatchNormalization(axis=3),
tf.keras.layers.Conv2D(48, (3, 3),
activation='relu',
strides=(2, 2),
padding='same'),
tf.keras.layers.BatchNormalization(axis=3),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy',
optimizer=SGD(lr=0.001, decay=1e-6, momentum=0.9),
metrics=['acc'])
train_datagen = ImageDataGenerator(rescale=1 / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
validation_datagen = ImageDataGenerator(rescale=1 / 255)
train_generator = train_datagen.flow_from_directory(
r"D://Learning//tensorflow_2.0//data//train", # 训练集的根目录
target_size=(48, 48), # 所有图像的分辨率将被调整为48x48
batch_size=32, # 每次输入32个图像
# 类别模式设为二分类
class_mode='binary')
# 对验证集做同样的操作
print('data.len=', len(data), 'labels.len=', len(labels))
# perform one-hot encoding on the labels and account for skew in the labeled data
labels = to_categorical(labels, num_classes=config.CLASS_NUM)
classTotals = labels.sum(axis=0)
classWeight = classTotals.max() / classTotals
# construct the training and testing split
trainX, testX, trainY, testY = train_test_split(data, labels, test_size=config.TEST_SPLIT, random_state=42)
print('trainX.len=', len(trainX), 'trainY.len=', len(trainY), 'testX.len=', len(testX), 'testY.len=', len(testY))
# initialize the training data augmentation object
aug = ImageDataGenerator(rotation_range=30, zoom_range=0.15, width_shift_range=0.2, height_shift_range=0.2,
shear_range=0.15, horizontal_flip=True, fill_mode="nearest")
print("[INFO] compiling model...")
opt = SGD(lr=config.INIT_LR, momentum=0.9, decay=config.INIT_LR / config.NUM_EPOCHS)
if os.path.exists(config.MODEL_PATH):
print("[INFO] loading from ", config.MODEL_PATH)
model = load_model(config.MODEL_PATH)
else:
model = DetectionNet.build(width=config.RESIZE_WH, height=config.RESIZE_WH, depth=3, classes=config.CLASS_NUM)
model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"])
# check to see if we are attempting to find an optimal learning rate
# before training for the full number of epochs
if args["lr_find"] > 0:
# initialize the learning rate finder and then train with learning rates ranging from 1e-10 to 1e+1
print("[INFO] finding learning rate...")
lrf = LearningRateFinder(model)
lrf.find(aug.flow(trainX, trainY, batch_size=config.BATCH_SIZE), 1e-10, 1e+1,
stepsPerEpoch=np.ceil((trainX.shape[0] / float(config.BATCH_SIZE))),
# start to become initialized with actual "learned" values
# versus pure random
print("[INFO] training head...")
model.fit_generator(aug.flow(trainX, trainY, batch_size=32),
validation_data=(testX, testY), epochs=20,
steps_per_epoch=len(trainX) // 32, verbose=200)
# evaluate the network after initialization
print("[INFO] evaluating after initialization...")
predictions = model.predict(testX, batch_size=32)
print(classification_report(testY.argmax(axis=1),
predictions.argmax(axis=1), target_names=classNames))
print("[INFO] re-compiling model...")
opt = SGD(lr=0.0001)
model.compile(loss="categorical_crossentropy", optimizer=opt,
metrics=["accuracy"])
# train the model again, this time fine-tuning *both* the final set
# of CONV layers along with our set of FC layers
print("[INFO] fine-tuning model...")
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=32),
validation_data=(testX, testY), epochs=15,
steps_per_epoch=len(trainX) // 32, verbose=1)
for key in H.history.keys():
print(key)
# evaluate the network on the fine-tuned model
print("[INFO] evaluating after fine-tuning...")
from tensorflow.keras.optimizers import SGD # ----- network constants ----- # CIFAR_INPUT_SHAPE = (32, 32, 3) IMAGENET_INPUT_SHAPE = (224, 224, 3) BATCH_SIZE = 256 IMAGENET_EPOCH_SIZE = 1280000 IMAGENET_VALIDATION_SIZE = 50000 CIFAR_NUM_OF_CLASSES = 10 IMAGENET_NUM_OF_CLASSES = 1000 NUM_OF_CONV_LAYERS = 7 NUM_OF_CHANNELS = 128 KERNEL_SIZE = 5 NUM_OF_FC_LAYERS = 2 FC_SIZE = 256 CONV_ACTIVATION = 'relu' FC_ACTIVATION = 'relu' LAST_ACTIVATION = 'softmax' LEARNING_RATE = 0.001 OPTIMIZER = SGD(lr=LEARNING_RATE, momentum=0.9, nesterov=False) LOSS = 'categorical_crossentropy'
# x = AveragePooling2D(pool_size=(1,4))(x)
x = Dense(1024, activation='relu')(x)
x = Dense(1251, activation='softmax')(x)
x = Reshape(target_shape=(1251,))(x)
model = Model(inputs=input, outputs=x)
"""
model = saved_model.load_keras_model(save_dir + checkpoints[-1])
model = multi_gpu_model(model, gpus=G)
# we need to recompile the model for these modifications to take effect
# we use SGD with a low learning rate
print("[INFO] Compiling Model ... ")
from tensorflow.keras.optimizers import SGD
rms = RMSprop()
model.compile(optimizer=SGD(INIT_LR,0.99), loss=contrastive_loss, metrics=[accuracy])
# model.compile(optimizer=RMSprop(lr=INIT_LR), loss='categorical_crossentropy',metrics=['accuracy'])
print("[INFO] Loading Data... ")
filename = "data4/data1.txt"
filename2 = "data4/labels1.txt"
counter = 1
le = preprocessing.LabelEncoder()
start = time.time()
filename2 = filename2[:-4 - len(str(counter - 1))] + str(counter) + filename2[-4:]
data = np.memmap('pairs_data.array', dtype=np.float64, mode='r+', shape=(294343, 2, 100, 40, 3))
labels = np.memmap('pairs_labels.array', dtype= np.float64, mode= 'r+', shape= (294343, ))
def buildGraph(self):
optimizer = SGD(lr=self.config['lr'], decay=self.config['decay'], momentum=0.9)
self.model.compile(loss=self.config['loss'], #'binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
precision = true_positives / (predicted_positives + K.epsilon())
return precision
pipe = make_pipeline(
RandomUnderSampler(sampling_strategy=0.2, random_state=42),
SVMSMOTE(sampling_strategy=0.7, n_jobs=12, random_state=42))
start = datetime.datetime.now()
print(f"{start} : over sampling......")
print(f"1 : {np.sum(y_train)}, 0 :{len(y_train)- np.sum(y_train)}")
x_tmp, y_tmp = pipe.fit_resample(x_train, y_train)
print(f"sampling : {datetime.datetime.now() - start}")
print(f"1 : {np.sum(y_tmp)}, 0 :{len(y_tmp)- np.sum(y_tmp)}")
sgd = SGD(lr=0.0002, momentum=0.9, decay=10e-6, nesterov=True)
adam = Adam(lr=1e-4, decay=1e-6)
rmsprop = RMSprop(lr=1e-5, epsilon=1.0)
amsgrad = Adam(lr=1e-5, decay=1e-6, amsgrad=True)
adagrad = Adagrad(lr=1e-5, decay=1e-6)
nadam = Nadam(lr=0.002,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
schedule_decay=0.004)
adadelta = Adadelta(lr=1., rho=0.95, epsilon=None, decay=0.0)
model = dnn_model(x_train.shape[1], FEATURE_SIZE)
# model = chunje_1(x_train.shape[1])
model.compile(optimizer=adadelta,
loss='binary_crossentropy',
equal = tf.cast(predicted == truth, tf.int32)
return tf.math.reduce_sum(equal).numpy() / equal.shape[0]
def accuracy_metrics(truth, logits):
acc = accuracy(truth, logits)
return {'accuracy': acc}
if __name__ == '__main__':
cifar10 = tf.keras.datasets.cifar10
(x_train, y_train), (x_valid, y_valid) = cifar10.load_data()
x_train, x_valid = x_train / 255.0, x_valid / 255.0
train_set = (x_train, y_train)
valid_set = (x_valid, y_valid)
net = Net()
trainer = EnasTrainer(
net,
loss=SparseCategoricalCrossentropy(from_logits=True, reduction=Reduction.NONE),
metrics=accuracy_metrics,
reward_function=accuracy,
optimizer=SGD(learning_rate=0.001, momentum=0.9),
batch_size=64,
num_epochs=2,
dataset_train=train_set,
dataset_valid=valid_set
)
trainer.train()
#logging.info("1111111111111111111111111")
strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(
tf.distribute.experimental.CollectiveCommunication.AUTO, )
#logging.info("222222222222222222222222222")
with strategy.scope():
model = Sequential()
model.add(Dense(8, input_dim=2))
model.add(Activation('tanh'))
model.add(Dense(1))
model.add(Activation('sigmoid'))
sgd = SGD(lr=0.1)
model.compile(loss='binary_crossentropy', optimizer=sgd)
#logging.info("333333333333333333333333333")
def fit(events):
logging.info("4444444444444444444444")
input_tensors = np.array([[
int(e["i1"]),
int(e["i2"]),
] for e in events])
output_tensors = np.array([[
int(e["o"]),
] for e in events])
def fit_model(x_train, y_train, epochs = 100, batch_size = 1024):
# convolutional layers for time-series
ts = Sequential([
Input(shape = (130,1)),
# 1st set of convolution layer (96 -> MaxPool -> Dropout)
Conv1D(filters = 96, kernel_size = 6, strides = 4, padding = "valid",
kernel_initializer = GlorotNormal()),
Activation(tf.keras.activations.relu),
MaxPooling1D(pool_size = 2, strides = 2, padding = "valid"),
# 2nd set of convolutional layer (256 -> MaxPool)
Conv1D(filters = 256, kernel_size = 5, strides = 1, padding = "same",
kernel_initializer = GlorotNormal()),
Activation(tf.keras.activations.relu),
MaxPooling1D(pool_size = 2, strides = 2, padding = "valid"),
# 3rd set of convolutional layer (384 -> 384 -> 256 -> MaxPool)
Conv1D(filters = 384, kernel_size = 3, strides = 1, padding = "same",
kernel_initializer = GlorotNormal()),
Activation(tf.keras.activations.relu),
Conv1D(filters = 384, kernel_size = 3, strides = 1, padding = "same",
kernel_initializer = GlorotNormal()),
Activation(tf.keras.activations.relu),
Conv1D(filters = 256, kernel_size = 3, strides = 1, padding = "same",
kernel_initializer = GlorotNormal()),
Activation(tf.keras.activations.relu),
MaxPooling1D(pool_size = 3, strides = 2, padding = "valid"),
# Flatten layer
Flatten()
])
# regular layer for weight
w = Sequential([
Input(shape = (1,)),
Dense(units = 4, kernel_initializer = GlorotNormal())
])
# concatenate ts and w
model_concat = Concatenate(axis = -1)([ts.output, w.output])
# 1st set of layers (256 -> Dropout -> 256 -> Dropout )
model_concat = Dense(units = 256, kernel_initializer = GlorotNormal())(model_concat)
model_concat = BatchNormalization()(model_concat)
model_concat = Activation(tf.keras.activations.relu)(model_concat)
model_concat = Dropout(0.2)(model_concat)
model_concat = Dense(units = 256, kernel_initializer = GlorotNormal())(model_concat)
model_concat = BatchNormalization()(model_concat)
model_concat = Activation(tf.keras.activations.relu)(model_concat)
model_concat = Dropout(0.2)(model_concat)
# output layer
model_concat = Dense(units = 1, activation = "sigmoid")(model_concat)
# define full model
model = Model(inputs = [ts.input, w.input], outputs = model_concat)
# fit model
opt = SGD(learning_rate = 0.05, momentum = 0.9, decay = 0.0005)
model.compile(
loss = "binary_crossentropy",
optimizer = opt,
metrics = [tf.keras.metrics.AUC(name="AUC"), "accuracy"]
)
history = model.fit(
x = x_train,
y = y_train,
epochs = epochs,
batch_size = batch_size,
validation_split = 0.2,
callbacks = [EarlyStopping('accuracy', patience=10, restore_best_weights = True)],
verbose = 2
)
return model, history
def model_CrossingDetection_OrderPrediction_SIAMESE_NTL(
the_input_shape, units_dense_layer_1, units_dense_layer_2,
dropout_rate_1, dropout_rate_2, learning_rate, momentum):
# Se definen las 4 entradas del modelo
input_1 = Input(shape=the_input_shape)
input_2 = Input(shape=the_input_shape)
input_3 = Input(shape=the_input_shape)
input_4 = Input(shape=the_input_shape)
#CaffeNet
base_model = Sequential()
base_model.add(
Conv2D(filters=96,
kernel_size=(11, 11),
strides=(4, 4),
padding='valid',
data_format='channels_last',
activation='relu',
input_shape=the_input_shape,
name='Conv2D_1_CaffeNet'))
base_model.add(
MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='valid',
data_format='channels_last',
name='MaxPooling2D_1_CaffeNet'))
base_model.add(BatchNormalization())
base_model.add(
Conv2D(filters=256,
kernel_size=(5, 5),
strides=(1, 1),
padding='same',
data_format='channels_last',
activation='relu',
name='Conv2D_2_CaffeNet'))
base_model.add(
MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='valid',
data_format='channels_last',
name='MaxPooling2D_2_CaffeNet'))
base_model.add(BatchNormalization())
base_model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format='channels_last',
activation='relu',
name='Conv2D_3_CaffeNet'))
base_model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format='channels_last',
activation='relu',
name='Conv2D_4_CaffeNet'))
base_model.add(
Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format='channels_last',
activation='relu',
name='Conv2D_5_CaffeNet'))
base_model.add(
MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='valid',
data_format='channels_last',
name='MaxPooling2D_3_CaffeNet'))
# Las 4 entradas son pasadas a través del modelo base (calculo de las distintas convoluciones)
output_1 = base_model(input_1)
output_2 = base_model(input_2)
output_3 = base_model(input_3)
output_4 = base_model(input_4)
flatten_1 = Flatten(name='Flatten_1_FINAL')
# Se obtienen los vectores de características de las 4 entradas
features_1 = flatten_1(output_1)
features_2 = flatten_1(output_2)
features_3 = flatten_1(output_3)
features_4 = flatten_1(output_4)
# Capa densa utilizada para resumir las caracteristicas extraidas de las capas convolucionales para cada frame
dense_1 = Dense(units=units_dense_layer_1,
activation='relu',
name='FC_1_FINAL')
features_1 = dense_1(features_1)
features_2 = dense_1(features_2)
features_3 = dense_1(features_3)
features_4 = dense_1(features_4)
dropout_1 = Dropout(rate=dropout_rate_1, name='Dropout_1_FINAL')
features_1 = dropout_1(features_1)
features_2 = dropout_1(features_2)
features_3 = dropout_1(features_3)
features_4 = dropout_1(features_4)
Features_12 = concatenate([features_1, features_2])
Features_13 = concatenate([features_1, features_3])
Features_14 = concatenate([features_1, features_4])
Features_23 = concatenate([features_2, features_3])
Features_24 = concatenate([features_2, features_4])
Features_34 = concatenate([features_3, features_4])
# Capa densa que aprende la relación entre las características de los distintos fotogramas
dense_2 = Dense(units=units_dense_layer_2,
activation='relu',
name='FC_2_FINAL')
RelationShip_1_2 = dense_2(Features_12)
RelationShip_1_3 = dense_2(Features_13)
RelationShip_1_4 = dense_2(Features_14)
RelationShip_2_3 = dense_2(Features_23)
RelationShip_2_4 = dense_2(Features_24)
RelationShip_3_4 = dense_2(Features_34)
dropout_2 = Dropout(rate=dropout_rate_2, name='Dropout_2_FINAL')
RelationShip_1_2 = dropout_2(RelationShip_1_2)
RelationShip_1_3 = dropout_2(RelationShip_1_3)
RelationShip_1_4 = dropout_2(RelationShip_1_4)
RelationShip_2_3 = dropout_2(RelationShip_2_3)
RelationShip_2_4 = dropout_2(RelationShip_2_4)
RelationShip_3_4 = dropout_2(RelationShip_3_4)
# Concatenación de todas las relaciones
Features_Final = concatenate([
RelationShip_1_2, RelationShip_1_3, RelationShip_1_4, RelationShip_2_3,
RelationShip_2_4, RelationShip_3_4
])
prediction = Dense(units=2, activation='softmax',
name='FC_Final_FINAL')(Features_Final)
siamese_model = Model(inputs=[input_1, input_2, input_3, input_4],
outputs=prediction)
siamese_model.summary()
optimizer = SGD(learning_rate=learning_rate, momentum=momentum)
siamese_model.compile(optimizer=optimizer,
loss='binary_crossentropy',
metrics=[
'accuracy',
tf.keras.metrics.AUC(),
tf.keras.metrics.Precision(),
tf.keras.metrics.Recall()
])
return siamese_model
##--------------------------- SETTING AREA ------------------------------##
loading = instant_data()
df, mode = loading.hourly_instant(), 'hour'
# df,mode = loading.daily_instant(),'day'
if mode == 'hour': n_past, n_future = 24 * 7, 72
elif mode == 'day': n_past, n_future = 60, 30
st = 'CPY012'
target, start_p, stop_p, host_path = station_sel(st, mode)
#------------ DL PARAMETER ---------------------#
callback_early_stopping = EarlyStopping(monitor='val_loss',
patience=5,
verbose=2)
reduce_lr = tf.keras.callbacks.LearningRateScheduler(lambda x: 1e-5 * 0.90**x)
callbacks = [callback_early_stopping, reduce_lr]
my_optimizer = SGD(lr=0.01, decay=0, momentum=0.9, nesterov=True)
#--------------------------- 2 Yr Edit -----------------------------------#
host_path = './CPY012/2Yr_flood/'
start_p = '2016-01-01'
split_date = '2017-05-10'
stop_p = '2018-01-01'
n_pca = 7
#-----------------------Baseline / Hybrid -----------------------------------#
save_path = host_path + 'Wavelet_exp2'
import os
if not os.path.exists(save_path):
os.makedirs(save_path)
#----------------------------------------------------------#
#Split XY
def main():
"""
A function for running text classification of GoT texts from the terminal
"""
# loading data
data = pd.read_csv(os.path.join("..", "data", "raw","Game_of_Thrones_Script.csv"))
# gathering all lines from a given character by a seson an episode to context and model's accuracy
data = data.groupby(["Season", "Episode", "Name"])
data = data["Sentence"].agg(lambda x: " ".join(x)).to_frame()
data = data.reset_index().rename(columns ={"Sentence": "Text"}) #resetting index
# train and test split using sklearn
X_train, X_test, y_train, y_test = train_test_split(data.Text,
data["Season"],
test_size=0.1,
random_state=random_state)
print("Data loaded and split")
### a baseline model of a logistic regresssion ###
print("fitting baseline LogReg model")
pipe = Pipeline(steps=[
('tfidf', TfidfVectorizer()),
('clf', LogisticRegression(solver = "liblinear",random_state = random_state))
])
# report model metrict
classifier = pipe.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
classifier_metrics_lr = metrics.classification_report(y_test, y_pred)
print(classifier_metrics_lr)
# save the classification report
filepath = os.path.join("..","models","LG_metrics.txt")
text_file = open(filepath, "w")
text_file.write(classifier_metrics_lr)
text_file.close()
### Building network ###
# integers to one-hot vectors
lb = LabelBinarizer()
y_train_bin = lb.fit_transform(y_train)
y_test_bin = lb.fit_transform(y_test)
# the nn will have a vocabulary size of 15000
maxlen = 15000
vectorizer = TfidfVectorizer(ngram_range=(1,2), max_features = maxlen)
X_train_feats = vectorizer.fit_transform(X_train).toarray()
X_test_feats = vectorizer.transform(X_test).toarray()
# l2 regularization
l2 = L2(0.00001)
# a new neural network
model = Sequential()
model.add(Dense(64, activation='relu', kernel_regularizer=l2,input_shape=(maxlen,)))
model.add(BatchNormalization())
model.add(Dropout(0.3))
model.add(Dense(8, activation='softmax'))
# compiler
model.compile(loss='categorical_crossentropy',
optimizer= SGD(learning_rate= .01),
metrics=['accuracy'])
epochs = 10
print(model.summary())
achitecture_path = os.path.join("..","models","nn_model_architecture.png")
#plot model
plot_model(model, to_file = achitecture_path, show_shapes=True, show_layer_names=True)
print(f"Image of model architecture saved in {achitecture_path}")
print("fitting nn-model")
# a fit history of the network
history = model.fit(X_train_feats, y_train_bin,
epochs=epochs,
verbose=True,
validation_data=(X_test_feats, y_test_bin))
# plot history
plot_history(history, epochs = epochs)
predictions=model.predict(X_test_feats, verbose=True)
# get the class with highest probability for each sample
y_pred = np.argmax(predictions, axis=1)
le = LabelEncoder()
y_test_int = le.fit_transform(y_test) #encode labels for the classification report
# get the classification report
metrics_nn = metrics.classification_report(y_test_int, y_pred, target_names = y_test.sort_values().unique())
print(metrics_nn)
# save metrics
filepath = os.path.join("..","models","NN_metrics.txt")
text_file = open(filepath, "w")
text_file.write(metrics_nn)
text_file.close()
print("We will now use grid search and crossvalidation to find a better model using an SGD-classifier")
# Grid Search for SGD Classifier (stochastic gradient classifier)
## making a pipeline where we use two embedding methods to find out the best one
pipe = Pipeline(steps=[
('tfidf', TfidfVectorizer()),
('clf', SGDClassifier(random_state = random_state))
])
## specifying
parameters = {
'tfidf__ngram_range': [(1, 1), (1, 2),(1,3)],
'tfidf__max_df': [1.0, 0.95,0.9,0.85],
'tfidf__min_df': [0.0, 0.05],
'clf__alpha': [1e-3, 1e-2, 1e-1], # learning rate
'clf__penalty': ['l2'],
}
search = GridSearchCV(pipe, parameters, n_jobs = -1, verbose = 1, refit = True)
gs_clf = search.fit(X_train, y_train)
print(f"The best{gs_clf.best_score_}")
print(f"The best model hyper parameters: {gs_clf.best_params_}")
y_pred = gs_clf.predict(X_test)
classifier_metrics_sgd = metrics.classification_report(y_test, y_pred)
print(classifier_metrics_sgd)
# get the classification report
filepath = os.path.join("..","models", "SGD_metrics.txt")
text_file = open(filepath, "w")
text_file.write(classifier_metrics_sgd)
text_file.close()
elif K.image_data_format() == "channels_last":
X_train = X_train.reshape((X_train.shape[0], 32, 32, 1))
X_test = X_test.reshape((X_test.shape[0], 32, 32, 1))
X_train = X_train.astype("float32") / 255.0
X_test = X_test.astype("float32") / 255.0
lb = LabelBinarizer()
y_train = lb.fit_transform(y_train)
y_train = to_categorical(y_train)
y_test = lb.transform(y_test)
y_test = to_categorical(y_test)
opt = SGD(lr=0.01)
model = LeNet.build(width=32, height=32, depth=1, classes=2)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
H = model.fit(X_train,
y_train,
validation_data=(X_test, y_test),
batch_size=32,
epochs=20,
verbose=1)
predictions = model.predict(X_test, batch_size=32)
print(
classification_report(y_test.argmax(axis=1),
def train_semantic_segmentation(normalize, img_list, label_list, x_scale, y_scale,
z_scale, crop_data, path_to_model, z_patch, y_patch, x_patch, epochs,
batch_size, channels, validation_split, stride_size, balance,
flip_x, flip_y, flip_z, rotate, image, early_stopping, val_tf,
validation_freq, cropping_weights, cropping_config):
# training data
img, label, position, allLabels, configuration_data, header, extension, number_of_images, counts = load_training_data(normalize,
img_list, label_list, channels, x_scale, y_scale, z_scale, crop_data)
# force validation_split for large number of training images
if number_of_images > 20:
if validation_split == 0:
validation_split = 0.8
early_stopping = True
# img shape
zsh, ysh, xsh = img.shape
# validation data
if validation_split:
number_of_images = zsh // z_scale
split = round(number_of_images * validation_split)
img_val = np.copy(img[split*z_scale:])
label_val = np.copy(label[split*z_scale:])
img = np.copy(img[:split*z_scale])
label = np.copy(label[:split*z_scale])
zsh, ysh, xsh = img.shape
if channels == 2:
position_val = np.copy(position[split*z_scale:])
position = np.copy(position[:split*z_scale])
# img_val shape
zsh_val, ysh_val, xsh_val = img_val.shape
# list of validation IDs
list_IDs_val = []
# get validation IDs of patches
for k in range(0, zsh_val-z_patch+1, stride_size):
for l in range(0, ysh_val-y_patch+1, stride_size):
for m in range(0, xsh_val-x_patch+1, stride_size):
list_IDs_val.append(k*ysh_val*xsh_val+l*xsh_val+m)
# make length of list divisible by batch size
rest = batch_size - (len(list_IDs_val) % batch_size)
list_IDs_val = list_IDs_val + list_IDs_val[:rest]
# list of IDs
list_IDs = []
# get IDs of patches
for k in range(0, zsh-z_patch+1, stride_size):
for l in range(0, ysh-y_patch+1, stride_size):
for m in range(0, xsh-x_patch+1, stride_size):
list_IDs.append(k*ysh*xsh+l*xsh+m)
# number of labels
nb_labels = len(allLabels)
# input shape
input_shape = (z_patch, y_patch, x_patch, channels)
# parameters
params = {'batch_size': batch_size,
'dim': (z_patch, y_patch, x_patch),
'dim_img': (zsh, ysh, xsh),
'n_classes': nb_labels,
'n_channels': channels,
'class_weights': False,
'augment': (flip_x, flip_y, flip_z, rotate)}
# data generator
validation_generator = None
training_generator = DataGenerator(img, label, position, list_IDs, counts, True, **params)
if validation_split:
if val_tf:
params['dim_img'] = (zsh_val, ysh_val, xsh_val)
params['augment'] = (False, False, False, 0)
validation_generator = DataGenerator(img_val, label_val, position_val, list_IDs_val, counts, False, **params)
else:
metrics = Metrics(img_val, label_val, list_IDs_val, (z_patch, y_patch, x_patch), (zsh_val, ysh_val, xsh_val), batch_size,
path_to_model, early_stopping, validation_freq, nb_labels)
# optimizer
sgd = SGD(learning_rate=0.01, decay=1e-6, momentum=0.9, nesterov=True)
# create a MirroredStrategy
if os.name == 'nt':
cdo = tf.distribute.HierarchicalCopyAllReduce()
else:
cdo = tf.distribute.NcclAllReduce()
strategy = tf.distribute.MirroredStrategy(cross_device_ops=cdo)
print('Number of devices: {}'.format(strategy.num_replicas_in_sync))
# compile model
with strategy.scope():
model = make_unet(input_shape, nb_labels)
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
# save meta data
meta_data = MetaData(path_to_model, configuration_data, allLabels, extension, header, crop_data, cropping_weights, cropping_config)
# model checkpoint
if validation_split:
if val_tf:
model_checkpoint_callback = ModelCheckpoint(
filepath=str(path_to_model),
save_weights_only=False,
monitor='val_accuracy',
mode='max',
save_best_only=True)
callbacks = [model_checkpoint_callback, CustomCallback(image.id,epochs), meta_data]
if early_stopping:
callbacks.insert(0, EarlyStopping(monitor='val_accuracy', mode='max', patience=10))
else:
callbacks = [metrics, CustomCallback(image.id,epochs), meta_data]
else:
callbacks = [ModelCheckpoint(filepath=str(path_to_model)),
CustomCallback(image.id,epochs), meta_data]
# train model
model.fit(training_generator,
epochs=epochs,
validation_data=validation_generator,
callbacks=callbacks)
cv2.destroyAllWindows()
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='Facial expression recognition for demo')
parser.add_argument('--one-image',
dest='method',
default='realtime',
help='predict from one image in local storage')
args = parser.parse_args()
print("Loading Residual Masking Network model...")
model = ResMaskingNet(input_shape=(48, 48, 3), classes=7)
model.compile(optimizer=SGD(lr=1e-2,
decay=1e-6,
momentum=0.9,
nesterov=True),
loss='categorical_crossentropy',
metrics=['accuracy'])
model.load_weights("residual_masking_71_best.h5")
print("========Completed load model========")
face_decade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
if args.method == 'realtime' or args.method == '':
print("Recognizing real-time...")
predict_real_time(model, face_decade)
else:
print("Recognizing one image...")
predict_one_pic(args.method, model, face_decade)
def one_hot_cnn(dense_out, max_len=300, frame='small'):
"""
Temporal CNN Model
As defined in "Text Understanding from Scratch" by Zhang, LeCun 2015
https://arxiv.org/pdf/1502.01710v4.pdf
This model is a series of 1D CNNs, with a maxpooling and fully connected layers.
The frame sizes may either be large or small.
Args:
dense_out (int): size out the output dense layer, this is the number of classes
max_len (int): length of the input text
frame (str): frame size, either large or small
Returns:
model (model): temporal CNN model
"""
if frame == 'large':
cnn_size = 1024
fully_connected = [2048, 2048, dense_out]
else:
cnn_size = 256
fully_connected = [1024, 1024, dense_out]
model = Sequential()
model.add(Conv1D(cnn_size, 7, padding='same', input_shape=(68, max_len)))
model.add(MaxPooling1D(pool_size=3))
print(model.output_shape)
# Input = 22 x 256
model.add(Conv1D(cnn_size, 7, padding='same'))
model.add(MaxPooling1D(pool_size=3))
print(model.output_shape)
# Input = 7 x 256
model.add(Conv1D(cnn_size, 3, padding='same'))
# Input = 7 x 256
model.add(Conv1D(cnn_size, 3, padding='same'))
model.add(Conv1D(cnn_size, 3, padding='same'))
# Input = 7 x 256
model.add(Conv1D(cnn_size, 3, padding='same'))
model.add(MaxPooling1D(pool_size=3))
model.add(Flatten())
# Fully Connected Layers
# Input is 512 Output is 1024/2048
model.add(Dense(fully_connected[0]))
model.add(Dropout(0.75))
model.add(Activation('relu'))
# Input is 1024/2048 Output is 1024/2048
model.add(Dense(fully_connected[1]))
model.add(Dropout(0.75))
model.add(Activation('relu'))
# Input is 1024/2048 Output is dense_out size (number of classes)
model.add(Dense(fully_connected[2]))
model.add(Activation('softmax'))
# Stochastic gradient parameters as set by paper
sgd = SGD(lr=0.01, decay=1e-5, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
return model
def __init__(self, nrows, ncols):
self.nrows = nrows
self.ncols = ncols
wr = 0.00001 # l1 regularizer value
dp = 0.125 # dropout rate
model = models.Sequential()
# speed, accel, distance, angle
#real_in = Input(shape=(2,), name='real_input')
#video fram
frame_in = Input(shape=(3, nrows, ncols), name='img_input')
print("adding first convolutional layer")
#5x5 convolutional layer with a stride of 2
model.add(
Conv2D(24, (5, 5),
input_shape=(nrows, ncols, 3),
strides=(2, 2),
activation='elu',
padding='same',
kernel_initializer='lecun_uniform'))
model.add(Dropout(dp))
print("adding second convolutional layer")
#5x5 convolutional layer with a stride of 2
model.add(
Conv2D(32, (5, 5),
strides=(2, 2),
activation='elu',
padding='same',
kernel_initializer='lecun_uniform'))
model.add(Dropout(dp))
print("adding third convolutional layer")
#5x5 convolutional layer with a stride of 2
model.add(
Conv2D(40, (5, 5),
strides=(2, 2),
activation='elu',
padding='same',
kernel_initializer='lecun_uniform'))
model.add(Dropout(dp))
print("adding fourth convolutional layer")
#3x3 convolutional layer with no stride
model.add(
Conv2D(48, (3, 3),
strides=(2, 2),
activation='elu',
padding='same',
kernel_initializer='lecun_uniform'))
model.add(Dropout(dp))
print("adding fifth convolutional layer")
#3x3 convolutional layer with no stride
model.add(
Conv2D(48, (3, 3),
strides=(2, 2),
activation='elu',
padding='same',
kernel_initializer='lecun_uniform'))
model.add(Dropout(dp))
model.add(Flatten())
print("adding fully connected layer")
#fully connected layer
model.add(
Dense(100, activation='elu', kernel_initializer='lecun_uniform'))
model.add(Dropout(dp))
#M = merge([flat,real_in], mode='concat', concat_axis=1)
print("adding output layer")
#fully connected layer to output node
model.add(
Dense(1, activation='linear', kernel_initializer='lecun_uniform'))
model.compile(loss=['mse'],
optimizer=SGD(lr=0.001,
decay=1e-6,
momentum=0.9,
nesterov=True),
metrics=['mse'])
print(model.summary())
def _test_async_correctness(
self,
grads_and_vars_batches,
embed_values,
expected_non_embed_values,
expected_embed_values=None,
):
"""Checks the correctness of async OptimizerWrapper. This function
creates many threads and these threads call
`OptimizerWrapper.apply_gradients` simultaneously.
Args:
grads_and_vars_batches: A python list of `grads_and_vars`. Every
thread takes a `grads_and_vars` and calls `apply_gradients`.
embed_values: A python dictionary of
`(layer_name, embedding table)`.
expected_non_embed_values: A python list of expected non-embdding
values after applying gradients.
expected_embed_values: A python dictionary of expected embedding
values after applying gradients. None means no need to check
embedding values.
"""
thread_num = len(grads_and_vars_batches)
input_dims = {}
embed_var_n = len(embed_values)
params = Parameters()
for layer, values in embed_values.items():
embed_dim = values.shape[1]
input_dims[layer] = values.shape[0]
embed_table = EmbeddingTable(layer, embed_dim)
embed_table.set(range(input_dims[layer]), values)
params.embedding_params[layer] = embed_table
opt = SGD(0.1)
opt_wrapper = OptimizerWrapper(
opt,
True,
lookup_embedding_func=params.get_embedding_param,
update_embedding_func=params.set_embedding_param,
)
# call optimizer_wrapper.apply_gradients asynchronously
def _apply_gradients(opt_wrapper, grads_and_vars):
# sleep 1s to wait that all threads are in this method call
time.sleep(1)
opt_wrapper.apply_gradients(grads_and_vars)
executor = ThreadPoolExecutor(max_workers=thread_num)
tasks = [
executor.submit(_apply_gradients, opt_wrapper, grads_and_vars)
for grads_and_vars in grads_and_vars_batches
]
_ = [task.result() for task in tasks]
# check updated results of non-embedding variables
non_embed_vars = [
var for grad, var in grads_and_vars_batches[0][:-embed_var_n]
]
for var, expected_value in zip(non_embed_vars,
expected_non_embed_values):
self.assertTrue(np.isclose(var.numpy(), expected_value).all())
# `expected_embed_values=None` means that no need to check
# embedding table
if not expected_embed_values:
return
# check updated results of embedding table
for layer, expected_values in expected_embed_values.items():
value = params.get_embedding_param(layer, range(input_dims[layer]))
self.assertTrue(
any([
np.isclose(value, expected).all()
for expected in expected_values
]))
# example of a 3-block vgg style architecture
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=(32, 32, 3)))
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(10, activation='softmax'))
# compile model
opt = SGD(lr=0.001, momentum=0.9)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])
history = model.fit(train_images, train_labels, epochs=50, batch_size=64, validation_data=(test_images, test_labels), verbose=0)
model.save("cifar.h5")
plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0.5, 1])
plt.legend(loc='lower right')
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import SGD, Adam
import numpy as np
print(tf.__version__)
x_data = np.array([[1, 2, 0], [5, 4, 3], [1, 2, -1], [3, 1, 0], [2, 4, 2],
[4, 1, 2], [-1, 3, 2], [4, 3, 3], [0, 2, 6], [2, 2, 1],
[1, -2, -2], [0, 1, 3], [1, 2, 3], [0, 2, 4], [2, 3, 3]])
t_data = np.array([-4, 4, -6, 3, -4, 9, -7, 5, 6, 0, 4, 3, 5, 5, 1])
print('x_data_dhape=', x_data.shape, ',t_data_shape=', t_data.shape)
model = Sequential()
model.add(Dense(1, input_shape=(3, ), activation='linear'))
model.compile(optimizer=SGD(learning_rate=1e-2), loss='mse')
model.summary()
model.fit(x_data, t_data, epochs=1000)
test_data = [[5, 5, 0], [2, 3, 1], [-1, 0, -1], [10, 5, 2], [4, -1, -2]]
ret_val = [2 * data[0] - 3 * data[1] + 2 * data[2] for data in test_data]
predict_val = model.predict(np.array(test_data))
print(predict_val)
print('--------------------')
print(ret_val)
ap.add_argument("-o", "--output", required=True, help="path to output")
args = vars(ap.parse_args())
print("[INFO] loading CIFAR-10 data...")
((trainX, trainY), (testX, testY)) = cifar10.load_data()
trainX = trainX.astype("float") / 255.0
testX = testX.astype("float") / 255.0
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)
labelNames = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
print("[INFO] compiling model...")
opt = SGD(lr=0.01, decay=0.01/40, momentum=0.9, nesterov=True)
model = MiniVGGNet.build(width=32, height=32, depth=3, classes=10)
model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"])
print("[INFO] training network...")
H = model.fit(trainX, trainY, validation_data=(testX, testY), batch_size=24, epochs=40, verbose=1)
print("[INFO] evaluating network...")
predictions = model.predict(testX, batch_size=64)
print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=labelNames))
plt.style.use("ggplot")
plt.figure()
plt.plot(np.arange(0, 40), H.history["loss"], label="train_loss")
plt.plot(np.arange(0, 40), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, 40), H.history["accuracy"], label="train_acc")
def train_wrn(data_generator, file_name, num_epochs=200, debug=True, gpus=None,
initial_epoch=0, initial_model=None, data_format=None, rand_spike=0, dropout=0.0, train_temp=1):
# For WRN-16-8 put N = 2, k = 8
# For WRN-28-10 put N = 4, k = 10
# For WRN-40-4 put N = 6, k = 4
def _create_model():
return wrn.create_wide_residual_network(data.train_data.shape[1:],
nb_classes=10, N=4, k=10, dropout=dropout, weight_decay=0.0005,
output_logits=True, input_data_format=data_format,
data_format=data_format, rand_spike=rand_spike)
devices = get_available_gpus()
devices_len = len(devices)
if gpus is None:
gpus = []
elif isinstance(gpus, list):
pass
elif isinstance(gpus, int):
gpus = list(range(gpus))
else:
raise ValueError('number of gpus is either list or int')
if devices_len >= 2 and len(gpus) >= 2:
with tf.device('/cpu:0'):
_model = _create_model()
_model_multi = multi_gpu_model(_model, gpus)
else:
_model = _create_model()
_model_multi = _model
# learning rate schedule
lr_schedule = [60, 120, 160, 180] # epoch_step
def schedule(epoch_idx):
if (epoch_idx + 1) < lr_schedule[0]:
return 0.1
elif (epoch_idx + 1) < lr_schedule[1]:
return 0.02 # lr_decay_ratio = 0.2
elif (epoch_idx + 1) < lr_schedule[2]:
return 0.004
elif (epoch_idx + 1) < lr_schedule[3]:
return 0.0008
return 0.0008
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct,
logits=predicted/train_temp)
sgd = SGD(lr=0.1, decay=0, momentum=0.9, nesterov=True)
if initial_epoch > 0:
_model_multi.load_weights(initial_model)
_model_multi.compile(loss=fn,
optimizer=sgd,
metrics=['accuracy'])
_model.summary()
log_path = file_name + "_log"
checkpoint_path = os.path.join(log_path, "checkpoint")
if not os.path.exists(checkpoint_path):
os.makedirs(checkpoint_path)
_model_multi.fit_generator(data_generator,
steps_per_epoch=len(data_generator),
validation_data=(data.validation_data, data.validation_labels),
epochs=num_epochs,
initial_epoch=initial_epoch,
callbacks=[
LearningRateScheduler(schedule=schedule),
SGDLearningRateTracker(),
ModelCheckpoint(os.path.join(
checkpoint_path, 'weights.{epoch:02d}-{val_acc:.2f}-{val_loss:.2f}.hdf5'),
monitor='val_acc',
verbose=1,
save_best_only=True,
save_weights_only=True,
mode='auto')
],
shuffle=True)
if debug:
plot_model(_model, os.path.join(log_path, "WRN-{0}-{1}.png".format(28, 10)), show_shapes=True,
show_layer_names=True)
with open(os.path.join(log_path, 'WRN-{0}-{1}.json'.format(28, 10)), 'w') as f:
f.write(_model.to_json())
f.close()
if file_name is not None:
_model.save(file_name)
# save idx
utils.save_model_idx(file_name, data)
return _model
def create_model(ac_weights, train_vec, parms):
# =============================================================================
# Input layer
# =============================================================================
ac_input = Input(shape=(train_vec['pref']['ac_index'].shape[1], ),
name='ac_input')
features = Input(shape=(train_vec['pref']['features'].shape[1],
train_vec['pref']['features'].shape[2]),
name='features')
# =============================================================================
# Embedding layer for categorical attributes
# =============================================================================
ac_embedding = Embedding(
ac_weights.shape[0],
ac_weights.shape[1],
weights=[ac_weights],
input_length=train_vec['pref']['ac_index'].shape[1],
trainable=False,
name='ac_embedding')(ac_input)
# =============================================================================
# Layer 1
# =============================================================================
merged = Concatenate(name='concatenated', axis=2)([ac_embedding, features])
l1_c1 = LSTM(parms['l_size'],
kernel_initializer='glorot_uniform',
return_sequences=True,
dropout=0.2,
implementation=parms['imp'])(merged)
# =============================================================================
# Batch Normalization Layer
# =============================================================================
batch1 = BatchNormalization()(l1_c1)
# =============================================================================
# The layer specialized in prediction
# =============================================================================
l2_c1 = LSTM(parms['l_size'],
activation=parms['lstm_act'],
kernel_initializer='glorot_uniform',
return_sequences=False,
dropout=0.2,
implementation=parms['imp'])(batch1)
# =============================================================================
# Output Layer
# =============================================================================
times_output = Dense(train_vec['next'].shape[1],
activation=parms['dense_act'],
kernel_initializer='glorot_uniform',
name='time_output')(l2_c1)
model = Model(inputs=[ac_input, features], outputs=[times_output])
if parms['optim'] == 'Nadam':
opt = Nadam(learning_rate=0.002, beta_1=0.9, beta_2=0.999)
elif parms['optim'] == 'Adam':
opt = Adam(learning_rate=0.001,
beta_1=0.9,
beta_2=0.999,
amsgrad=False)
elif parms['optim'] == 'SGD':
opt = SGD(learning_rate=0.01, momentum=0.0, nesterov=False)
elif parms['optim'] == 'Adagrad':
opt = Adagrad(learning_rate=0.01)
model.compile(loss={'time_output': 'mae'}, optimizer=opt)
model.summary()
return model
# we should freeze: # for i, layer in enumerate(base_model.layers): # print(i, layer.name) # we chose to train the top 1 inception blocks, i.e. we will freeze # the first 250 layers and unfreeze the rest: for layer in model.layers[:250]: layer.trainable = False for layer in model.layers[250:]: layer.trainable = True # we need to recompile the model for these modifications to take effect # we use SGD with a low learning rate # if required remove one metric from tensorflow.keras.optimizers import SGD model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy', 'categorical_accuracy']) # we train our model again (this time fine-tuning the top 1 inception blocks) # alongside the top Dense layers model.fit(X_train, y_train, epochs=50, batch_size=64, verbose=0) # Use the following code for training in a mini-batch basis. # When limited resources are available. # 287 -> number of COVID 19 photos # 1595 -> number of Normal photos # 4371 -> number of Pneumonia photos # Used a mini-batch of maximum 200 photos in one go from each class for i in range(23): # 23 would be sufficient to cover all the images in the largest category here (pneumonia) overall = [] c = listdir(fp + 'corona')
import numpy as np
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation
from tensorflow.keras.optimizers import SGD
x_train = np.random.random((1000, 20))
y_train = keras.utils.to_categorical(np.random.randint(10, size=(1000, 1)),
num_classes=10)
x_test = np.random.random((100, 20))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)),
num_classes=10)
model = Sequential()
model.add(Dense(64, activation='relu', input_dim=20))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=20, batch_size=128)
score = model.evaluate(x_test, y_test, batch_size=128)
#convert labels from integers to Vectors
trainY = LabelBinarizer().fit_transform(trainY)
testY = LabelBinarizer().fit_transform(testY)
#constructing image generator for Data augumentation
aug = ImageDataGenerator(rotation_range=30,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
#initializing the optimizer and model
print('[INFO] compiling model ...')
opt = SGD(lr=0.05)
model = MiniVGGNet.build(width=64, height=64, depth=3, classes=len(classNames))
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
#train network
print('[INFO] training network ...')
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=32),
validation_data=(testX, testY),
steps_per_epoch=len(trainX) // 32,
epochs=100,
verbose=1)
#evaluate the model
print('[INFO] evaluating the network ...')
MaxPooling2D(pool_size=(2, 2)),
BatchNormalization(),
Conv2D(128, kernel_size=(3, 3), activation='relu'),
MaxPooling2D(pool_size=(2, 2)),
BatchNormalization(),
Conv2D(128, kernel_size=(3, 3), activation='relu'),
MaxPooling2D(pool_size=(2, 2)),
BatchNormalization(),
Conv2D(64, kernel_size=(3, 3), activation='relu'),
MaxPooling2D(pool_size=(2, 2)),
Flatten(),
Dropout(0.2),
Dense(256, activation='relu'),
Dropout(0.2),
Dense(64, activation='relu'),
Dense(1, activation='sigmoid')
])
model.compile(optimizer=SGD(),
loss='binary_crossentropy',
metrics=['accuracy'])
model.summary()
history = model.fit(train_generator,
steps_per_epoch=total_train // batch_size,
epochs=epochs,
validation_data=validation_generator,
validation_steps=validation_generator.samples //
batch_size)
print("Evaluate on test data")
results = model.evaluate(test_generator, batch_size=1)
print("test loss, test acc:", results)
model.save('model')
