def save_model(self, model: Sequential):
if not self.is_neural_network_ready_to_save:
raise Exception('Could not save Neural Network, train model before save')
print('\033[1;36m*' * 50)
print('*', '\t' * 4, 'Saving the Model', '\t' * 4, '*')
print('\033[1;36m*\033[m' * 50)
json = model.to_json()
with open(self.ESTRUTURA_JSON_FILE_PATH, 'w') as arquivo_json:
arquivo_json.write(json)
arquivo_json.close()
model.save_weights(self.WEIGHTS_FILE_PATH)
def train_regressor(filename, epochs, neuron_num):
dataset = []
with open(filename, 'r') as f:
for line in f:
jsonfile = json.loads(line[:-2])
dataset.append(jsonfile)
f.close()
cars = pd.DataFrame(dataset)
cars = cars.drop(cars[(cars['price'] > 30000)
& (cars['price'] < 300000)].index)
cars_prices = cars["price"].copy()
cars = cars.drop("price", axis=1)
cars_prepared = full_pipeline.fit_transform(cars)
model = Sequential()
model.add(
Dense(8, input_dim=10, kernel_initializer='normal', activation='relu'))
model.add(Dense(neuron_num, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mse', optimizer='adam', metrics=['mae'])
history = model.fit(cars_prepared,
cars_prices,
epochs=epochs,
batch_size=50,
verbose=1,
validation_split=0.2)
model_json = model.to_json()
plt.plot(history.history['mean_absolute_error'])
plt.plot(history.history['val_mean_absolute_error'])
plt.title('model mean_absolute_error')
plt.ylabel('mean_absolute_error')
plt.xlabel('epok')
plt.legend(['train', 'validation'], loc='upper left')
plt.savefig('app/web/static/history.png')
with open('neuralnetregressor.json', 'w') as json_file:
json_file.write(model_json)
model.save_weights('neuralnetregressor.h5')
def train(x_train, y_train, x_test, y_test, epochs):
# calculate classes
if np.unique(y_train).shape[0] == np.unique(y_test).shape[0]:
#
num_classes = np.unique(y_train).shape[0]
else:
print('Error in class data...')
return -2
# set validation data
'''val_size = int(0.1 * x_train.shape[0])
r = np.random.randint(0, x_train.shape[0], size=val_size)
x_val = x_train[r, :, :]
y_val = y_train[r]
x_train = np.delete(x_train, r, axis=0)
y_train = np.delete(y_train, r, axis=0)'''
step = int(x_train.shape[0] * 0.005)
length = int(x_train.shape[0] * 0.1 * 0.005)
r = []
for i in range(0, x_train.shape[0] - length, step):
r.extend(range(i, i + length))
x_val = x_train[r, :, :]
y_val = y_train[r]
x_train = np.delete(x_train, r, axis=0)
y_train = np.delete(y_train, r, axis=0)
print('\nInitializing CNN2D...')
print('\nclasses:', num_classes)
print('x train shape:',
x_train.shape), print('x val shape:',
x_val.shape), print('x test shape:',
x_test.shape)
print('y train shape:',
y_train.shape), print('y val shape:',
y_val.shape), print('y test shape:',
y_test.shape)
print("\nTrain split with mean|std {:.2f}|{:.2f}".format(
np.mean(x_train), np.std(x_train)))
print("Test split with mean|std {:.2f}|{:.2f}".format(
np.mean(x_test), np.std(x_test)))
# shape data
x_train = x_train.reshape(x_train.shape[0], x_train.shape[1],
x_train.shape[2], 1)
x_val = x_val.reshape(x_val.shape[0], x_val.shape[1], x_val.shape[2], 1)
x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], x_test.shape[2],
1)
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_val = tf.keras.utils.to_categorical(y_val, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
# define the model
activation = 'elu'
regularizer = 0.0000
dropout = 0.25
# preprocessing
'''
offset = 1.0 * np.std(x_train)
dc0 = (x)
dc1 = GaussianNoise(offset*0.1)(x)
dc2 = GaussianDropout(dropout)(x)
dc3 = Lambda(lambda r: r + __import__('keras').backend.random_uniform((1,), -offset, offset))(x)
dc4 = Lambda(lambda r: r + __import__('keras').backend.random_uniform((1,), -offset, offset))(x)
m = Concatenate()([dc0, dc1, dc2, dc3, dc4])
m = Lambda(lambda r: r - __import__('keras').backend.mean(r))(x)
'''
# sequential
model = Sequential()
model.add(
Conv2D(16,
kernel_size=(3, 3),
strides=(2, 1),
activation='elu',
kernel_regularizer=regularizers.l2(regularizer),
input_shape=(x_train.shape[1], x_train.shape[2], 1)))
model.add(EntropyPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(
Conv2D(32,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
kernel_regularizer=regularizers.l2(regularizer)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(
Conv2D(64,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
kernel_regularizer=regularizers.l2(regularizer)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
# model.add(Conv2D(128, kernel_size=(3, 3), strides=(1, 1), activation='elu', kernel_regularizer=regularizers.l2(regularizer)))
# model.add(MaxPooling2D(pool_size=(1, 2)))
# model.add(Dropout(dropout))
model.add(Flatten())
model.add(
Dense(64,
activation='elu',
kernel_regularizer=regularizers.l2(regularizer)))
model.add(Dropout(dropout))
model.add(Dense(num_classes, activation='softmax'))
# functional
'''
x = Input((x_train.shape[1], x_train.shape[2], x_train.shape[3]))
m = Conv2D(16, 3, activation=activation , kernel_regularizer=regularizers.l2(regularizer))(x)
m = EntropyPooling2D((2, 2))(m)
m = Dropout(dropout)(m)
m = Conv2D(32, 3, activation=activation, kernel_regularizer=regularizers.l2(regularizer))(m)
m = EntropyPooling2D((2, 2))(m)
m = Dropout(dropout)(m)
m = Conv2D(64, 3, activation=activation, kernel_regularizer=regularizers.l2(regularizer))(m)
m = EntropyPooling2D((2, 2))(m)
m = Dropout(dropout)(m)
if x_train.shape[1] < 50:
#
m = Flatten()(m)
else:
m = Conv2D(128, 3, activation=activation, kernel_regularizer=regularizers.l2(regularizer))(m)
m = GlobalAveragePooling2D()(m)
m = Dropout(dropout)(m)
m = (Dense(64, activation=activation, kernel_regularizer=regularizers.l2(regularizer)))(m)
m = Dropout(dropout)(m)
y = Dense(num_classes, activation='softmax')(m)
model = Model(inputs=[x], outputs=[y])
'''
# summarize model
for i in range(0, len(model.layers)):
if i == 0:
plot_model(model, to_file='Models\\model_cnn2d.png')
# f = open('Models\\model_cnn2d.txt', 'w')
# print(' ')
# print('{}. Layer {} with input / output shapes: {} / {}'.format(i, model.layers[i].name, model.layers[i].input_shape, model.layers[i].output_shape))
# f.write('{}. Layer {} with input / output shapes: {} / {} \n'.format(i, model.layers[i].name, model.layers[i].input_shape, model.layers[i].output_shape))
if i == len(model.layers) - 1:
# f.close()
print(' ')
model.summary()
# compile, fit evaluate
callback = [
callbacks.EarlyStopping(monitor='val_acc',
min_delta=0.01,
patience=10,
restore_best_weights=True)
]
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=256,
epochs=epochs,
verbose=2,
validation_data=(x_val, y_val),
callbacks=callback)
score = model.evaluate(x_test, y_test, verbose=2)
# evaluate on larger frames
aggr_size = 5
for i in range(0, y_test.shape[0] - aggr_size, aggr_size):
if i == 0:
y_pred = model.predict(x_test)
y_pred = np.argmax(y_pred, axis=1)
y_test = np.argmax(y_test, axis=1)
y_aggr_test = []
y_aggr_pred = []
if np.unique(y_test[i:i + aggr_size]).shape[0] == 1:
y_aggr_test.append(stats.mode(y_test[i:i + aggr_size])[0][0])
y_aggr_pred.append(stats.mode(y_pred[i:i + aggr_size])[0][0])
# print(confusion_matrix(np.argmax(y_test, axis=1), np.argmax(y_pred, axis=1)))
scipy_score = classification_report(y_aggr_test,
y_aggr_pred,
output_dict=True)['accuracy']
print('short {:.2f} and aggr {:.2f}'.format(score[1], scipy_score))
# save model
open("Models\\model_cnn2d.json", "w").write(model.to_json())
pickle.dump(model.get_config(), open("Models\\model_cnn2d.pickle", "wb"))
model.save_weights("Models\\model_cnn2d.h5")
# results
return score[1]
def example_1():
simutation_parameters = {
"PWM_file":
"/home/qan/Desktop/DeepEpitif/DeepMetif/JASPAR2018_CORE_vertebrates_non-redundant_pfms_jaspar/MA0835.1.jaspar",
"seq_length": 100,
"center_pos": 20,
"motif_width": 14,
"metif_level": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
}
[train_X, train_Y, valid_X, valid_Y, test_X,
test_Y] = get_simulated_dataset(parameters=simutation_parameters,
train_size=16000,
valid_size=2000,
test_size=20)
#print(train_X.dtype)
#print(train_Y.dtype)
#print(train_X[2,:,:,:])
#print(train_Y)
#print(train_X.shape[1::])
#exit()
one_filter_keras_model = Sequential()
one_filter_keras_model.add(
Conv2D(filters=5,
kernel_size=(1, 15),
padding="same",
input_shape=train_X.shape[1::]))
one_filter_keras_model.add(BatchNormalization(axis=-1))
one_filter_keras_model.add(Activation('relu'))
one_filter_keras_model.add(MaxPooling2D(pool_size=(1, 35)))
one_filter_keras_model.add(Flatten())
one_filter_keras_model.add(Dense(1))
one_filter_keras_model.add(Activation("sigmoid"))
one_filter_keras_model.summary()
one_filter_keras_model.compile(optimizer='adam',
loss='binary_crossentropy')
metrics_callback = MetricsCallback(train_data=(train_X, train_Y),
validation_data=(valid_X, valid_Y))
print(one_filter_keras_model.get_weights())
history_one_filter = one_filter_keras_model.fit(
x=train_X,
y=train_Y,
batch_size=10,
epochs=50,
verbose=1,
callbacks=[History(), metrics_callback],
validation_data=(valid_X, valid_Y))
#print(one_filter_keras_model.get_weights())
one_filter_keras_model_json = one_filter_keras_model.to_json()
with open("one_filter_keras_model.json", "w") as json_file:
json_file.write(one_filter_keras_model_json)
one_filter_keras_model.save_weights("one_filter_keras_model.h5")
print("Saved model to disk")
try:
model.fit(x=train_generator,
validation_data=test_generator,
steps_per_epoch=training_len//batch_size,
validation_steps=testing_len//batch_size,
workers=2,
use_multiprocessing=True,
epochs=num_epochs)
#save model upon successful completion of running model.fit
model.save('deepfake_model_compare_frames.h5')
except Exception as e:
print(e)
#if there is an exception, want to automatically save the model
model.save('compare_frames_model_train_exception.h5') #uncomment in production
#consider updating this to save to a json file
print(model.to_json())
# In[ ]:
model.metrics_names
# In[ ]:
# x, _ = get_video('xpzfhhwkwb.mp4') # fake video
prediction += "\n dog-" + str(result[0][2])
prediction += "\n kitchen-" + str(result[0][3])
prediction += "\n knife-" + str(result[0][4])
print("Prediction - \n", prediction)
# Input image
plt.figure(1)
plt.title('Knife')
plt.axis('off')
plt.imshow(
image.load_img(
'Dataset_Multy/single_prediction/knife-darkfinal2Color.jpeg'))
#knife-dark.jpeg
#knife-darkfinal2Color.jpeg
#chair2.jpeg
#chair2final2Color.jpeg
# ---*-----*---Part 4 - Saving the trained model and weights---*------*----
# serialize model to JSON
model_json = classifier.to_json()
with open("model_cnn_multy.json", "w") as json_file:
json_file.write(model_json)
# serialize weights to hdf5
classifier.save_weights("weights_cnn_multy.h5")
# ---*-----*---Part 5 - Loading the trained model weights---*------*----
classifier.load_weights("weights_cnn_multy.h5")
class Model():
def __init__(self, train_x, train_y,
validation_x , validation_y, seq_info:str,
*,
max_epochs = 100, batch_size = 1024, hidden_layers = 2,
neurons_per_layer = 64, architecture = Architecture.LSTM.value,
dropout = 0.1, is_bidirectional = False, initial_learn_rate = 0.001,
early_stop_patience = 6, is_classification=False):
"""
INFO GOES HERE
"""
## Param member vars
self.max_epochs = max_epochs
self.batch_size = batch_size
self.hidden_layers = hidden_layers
self.neurons_per_layer = neurons_per_layer
self.architecture = architecture
self.dropout = dropout
self.is_bidirectional = is_bidirectional
self.initial_learn_rate = initial_learn_rate
self.seq_info = seq_info
self.is_classification = is_classification
self.early_stop_patience = early_stop_patience
self.train_time = 0
self.train_x = train_x
self.train_y = train_y
self.validation_x = validation_x
self.validation_y = validation_y
## Other member vars
self.model = Sequential()
self.training_history = None
self.score: dict = {}
self._create_model()
### PUBLIC FUNCTIONS
def get_model(self):
return self.model
def train(self):
start = time.time()
early_stop = EarlyStopping(monitor='val_loss', patience=self.early_stop_patience, restore_best_weights=True)
tensorboard = TensorBoard(log_dir=f"{os.environ['WORKSPACE']}/logs/{self.seq_info}__{self.get_model_info_str()}__{datetime.now().timestamp()}")
# Train model
self.training_history = self.model.fit(
self.train_x, self.train_y,
batch_size=self.batch_size,
epochs=self.max_epochs,
validation_data=(self.validation_x, self.validation_y),
callbacks=[tensorboard, early_stop],
shuffle=True
)
# Score model
self.score = self.model.evaluate(self.validation_x, self.validation_y, verbose=0)
self.score = {out: self.score[i] for i, out in enumerate(self.model.metrics_names)}
print('Scores:', self.score)
end = time.time()
self.train_time = end - start
def save_model(self):
self._save_model_config()
self._save_model_weights()
def get_model_info_str(self):
return f"{'Bi' if self.is_bidirectional else ''}{self.architecture.__name__}-HidLayers{self.hidden_layers}-Neurons{self.neurons_per_layer}-Bat{self.batch_size}-Drop{self.dropout}"
### PRIVATE FUNCTIONS
def _create_model(self):
"""
Creates and compiles the model
"""
self._use_gpu_if_available()
##### Create the model ####
self.model = Sequential()
if self.is_bidirectional:
self.model.add(Bidirectional(self.architecture(self.neurons_per_layer, input_shape=(self.train_x.shape[1:]), return_sequences=True)))
else:
self.model.add(self.architecture(self.neurons_per_layer, input_shape=(self.train_x.shape[1:]), return_sequences=True))
self.model.add(Dropout(self.dropout))
self.model.add(BatchNormalization())
for i in range(self.hidden_layers):
return_sequences = i != self.hidden_layers - 1 # False on last iter
if self.is_bidirectional:
self.model.add(Bidirectional(self.architecture(self.neurons_per_layer, return_sequences=return_sequences)))
else:
self.model.add(self.architecture(self.neurons_per_layer, return_sequences=return_sequences))
self.model.add(Dropout(self.dropout))
self.model.add(BatchNormalization())
if self.is_classification:
self.model.add(Dense(2, activation="sigmoid"))
else:
self.model.add(Dense(1))
adam = adam_v2.Adam(learning_rate=self.initial_learn_rate)
if self.is_classification:
self.model.compile(
loss="sparse_categorical_crossentropy",
optimizer=adam,
metrics=["sparse_categorical_crossentropy", "accuracy"]
)
else:
self.model.compile(
loss=RSquaredMetricNeg,
optimizer=adam,
metrics=["mae", RSquaredMetric]
)
def _use_gpu_if_available(self):
## Utilise GPU if GPU is available
local_devices = device_lib.list_local_devices()
gpus = [x.name for x in local_devices if x.device_type == 'GPU']
if len(gpus) != 0:
if self.architecture == GRU:
self.architecture = CuDNNGRU
elif self.architecture == LSTM:
self.architecture = CuDNNLSTM
def _save_model_weights(self):
file_path = ""
if self.is_classification:
file_path = f"{os.environ['WORKSPACE']}/models/final/{self.seq_info}__{self.get_model_info_str()}__{self.max_epochs}-{self.score['sparse_categorical_crossentropy']:.3f}.h5"
else:
file_path = f"{os.environ['WORKSPACE']}/models/final/{self.seq_info}__{self.get_model_info_str()}__{self.max_epochs}-{self.score['RSquaredMetric']:.3f}.h5"
self.model.save_weights(file_path)
print(f"Saved model weights to: {file_path}")
def _save_model_config(self):
json_config = self.model.to_json()
file_path = f'{os.environ["WORKSPACE"]}/model_config/{self.get_model_info_str()}.json'
with open(file_path, "w+") as file:
file.write(json_config)
print(f"Saved model config to: {file_path}")
def train():
start_time = time.time()
print("Starting The Training Process")
print("Loading The Preprocessed Images Data set")
datasets = np.load('preprocessed_train_data.npy',
allow_pickle=True) #Preprocessed Train Data
print("Preprocessed Data ser Loaded Successfully.")
print("Shuffling The Data set")
np.random.shuffle(datasets)
print(datasets.shape)
pixels = []
labels = []
for pixel, label in datasets:
pixels.append(pixel)
labels.append(label)
pixels = np.array(pixels).reshape(-1, 32, 32, 1)
# print('number of inputs:')
# Building The Model:
print("creating The Sequential Model.")
model = Sequential()
print("Adding First Convolution Layer To The Model.")
model.add(
Conv2D(16, (5, 5),
padding="same",
input_shape=(32, 32, 1),
activation="relu"))
print("Adding Pooling Layer To The First Convolution Layer.")
model.add(MaxPooling2D(pool_size=(2, 2)))
print("Adding The Second Convolution Layer To The Model.")
model.add(Conv2D(64, (5, 5), padding="same", activation="relu"))
print("Adding Pooling Layer To The Second Convolution Layer.")
model.add(MaxPooling2D(pool_size=(2, 2)))
print("Flattening The Output From Second Convolution Layer.")
model.add(Flatten())
print("Adding The Hidden Dense Layer With 1000 Neurons.")
model.add(Dense(1000))
print("Adding The Output Layer With 36 Neurons For 36 Classes.")
model.add(Dense(36))
print("Adding The Softmax Activation At The Output Layer.")
model.add(Activation("softmax"))
print("Using The Cross Entropy As The Loss Function With Adam Optimizer")
model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print("Fitting The Model.")
print("Training Begins...........")
history = model.fit(pixels,
labels,
batch_size=256,
validation_split=0.15,
epochs=30)
end_time = time.time()
total_time = round(end_time - start_time)
time_msg = "Training Completed Successfully in {Time}".format(
Time=str(datetime.timedelta(seconds=total_time)))
print(time_msg)
print("Saving the Model in Hard Drive For Later Use")
# serialize model to JSON
model_json = model.to_json()
with open("Trained_model.json", "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("Weights_model.h5")
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
plt.show()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
plt.show()
optimizer=sgd,
metrics=[metrics.mae])
addition_model.fit(input_data,
output_data,
batch_size=1,
epochs=100,
verbose=1)
# Modell wird gespeichert
addition_model.save("addition_model.h5")
# Und auch für TensorFlow.js!
# tfjs.converters.save_keras_model(addition_model, "./addition_model")
print("== Modell als JSON-Struktur ==")
pprint(addition_model.to_json())
pprint("== Modell als YAML-Struktur ==")
pprint(addition_model.to_yaml())
# Weights werden gespeichert
addition_model.save_weights("addition_weights.h5")
# Struktur des Modells wird als JSON gespeichert
json_str = addition_model.to_json()
with open("addition_model.json", "w") as json_file:
json_file.write(json_str)
# Modell wird neu geladen (vom .h5 Datei)
model = load_model('addition_model.h5')
result = model.predict([[[5,
img_height),
batch_size=batch_size,
class_mode='binary')
# In[9]:
model.fit_generator(train_generator,
steps_per_epoch=nb_train_samples // batch_size,
epochs=epochs,
validation_data=val_generator,
validation_steps=nb_validation_samples // batch_size)
# In[10]:
scores = model.evaluate_generator(test_generator,
nb_test_samples // batch_size)
# In[11]:
print("Accuracy: %.2f%%" % (scores[1] * 100))
# In[12]:
import pandas as pd
# In[13]:
model.to_json()
# In[ ]:
def main():
parser = argparse.ArgumentParser(description='Tensorflow MNIST Example')
parser.add_argument('--batch-size',
type=int,
default=128,
metavar='N',
help='input batch size for training (default: 128)')
parser.add_argument('--epochs',
type=int,
default=10,
metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr',
type=float,
default=0.01,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
args = parser.parse_args()
print(args)
use_cuda = not args.no_cuda
num_classes = 10
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data(
path=str(PurePath(data_dir, "mnist.npz")))
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
cp_callback = MyCallback.get_cp_callback(checkpoint_dir)
mq_callback = MyCallback.get_mq_callback()
if use_cuda:
# support multiple gpu
available_devices = _get_available_devices()
available_devices = [
_normalize_device_name(name) for name in available_devices
]
gpu_names = [x for x in available_devices if '/gpu:' in x]
num_gpus = len(gpu_names)
if num_gpus <= 0:
raise ValueError('Unable to find any gpu device ')
print("Let's use gpus: " + str(gpu_names))
if num_gpus > 1:
model = tf.keras.utils.multi_gpu_model(model, gpus=num_gpus)
else:
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = ""
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=tf.keras.optimizers.Adadelta(lr=args.lr),
metrics=['accuracy'])
start_time = time.time()
model.fit(x_train,
y_train,
batch_size=args.batch_size,
epochs=args.epochs,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[cp_callback, mq_callback])
duration = (time.time() - start_time) / 60
print("Train finished. Time cost: %.2f minutes" % (duration))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
# save model
model_json = model.to_json()
open(str(PurePath(model_path, 'mnist_arch.json')), 'w').write(model_json)
output_weight = str(PurePath(model_path, 'mnist_weights.h5'))
model.save_weights(output_weight, overwrite=True)
print("Weight saved in path: %s" % output_weight)
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(NUM_CLASSES))
model.add(Activation('softmax'))
sgd = optimizers.SGD(lr=LEARNING_RATE)
model.compile(loss='categorical_crossentropy',
optimizer='SGD',
metrics=['accuracy'])
model.summary()
# モデルの保存
model_json_str = model.to_json()
with open(backup_dir + '/mnist_deep_model.json', 'w') as f:
f.write(model_json_str)
# 重みデータのバックアップ
cb_cp = tf.keras.callbacks.ModelCheckpoint(backup_dir + '/weights.{epoch:02d}.hdf5', verbose=1, save_weights_only=True)
# TensorBoard用のデータ
cb_tf = tf.keras.callbacks.TensorBoard(log_dir=backup_dir + '/tensorBoard', histogram_freq=0)
start = time.time()
history = model.fit(X_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS,
validation_data = (X_test, y_test), verbose = 1, callbacks=[cb_cp, cb_tf])
elapsed_time = time.time() - start
print ("elapsed_time:{0}".format(elapsed_time) + "[sec]")
plt.plot(history.history['acc'])
class RNN:
def __init__(self, cash_available, csv_train, csv_test, stock):
self.cash_available = cash_available
self.csv_train = csv_train
self.csv_test = csv_test
self.stock = stock
self.model_json = "rnn.json"
self.date = "2017-00-00T00:00:00.000Z" # date specified here only for testing purposes
self.sc = MinMaxScaler(feature_range=(0, 1))
self.api = tradeapi.REST(key_id='PKXVRTVRHQWTL50AYFKA',
secret_key='',
base_url='https://paper-api.alpaca.markets')
self.dataset, self.training_set, self.X_train, self.y_train, \
self.regressor, self.dataset_test, self.test_set, self.real_stock_price, \
self.inputs, self.dataset_total, self.X_test, self.predicted_stock_price, \
self.data = [], [], [], [], [], [], [], [], [], [], [], [], []
def loadTrainData(self):
""" Loads data for training. """
self.dataset = pd.read_csv(self.csv_train, index_col="Date", parse_dates=True)
training_set = self.dataset["Open"]
self.training_set = pd.DataFrame(training_set)
def loadTestData(self):
""" Loads the data for testing. """
self.dataset_test = pd.read_csv(self.csv_test, index_col="Date", parse_dates=True)
self.real_stock_price = self.dataset_test.iloc[:, 1:2].values
self.test_set = self.dataset_test['Open']
self.test_set = pd.DataFrame(self.test_set)
def updateData(self):
self.stock_dataset = self.api.get_barset(self.stock, "1D", start=self.date)
self.stock_data = self.stock_dataset[self.stock]
for data_row in self.stock_data:
date = data_row.t
open = data_row.o
high = data_row.h
low = data_row.l
close = data_row.c
volume = data_row.v
df_row = pd.DataFrame(np.array([[date, open, high, low, close, volume]]), columns=['Date', 'Open', 'High', 'Low', 'Close', 'Volume'])
df_row = df_row.set_index('Date')
self.dataset = self.dataset.append(df_row)
def scaleTrainData(self):
""" Scales the training data using sklearn MinMaxScaler. """
self.loadTrainData()
# Feature Scaling
self.training_set_scaled = self.sc.fit_transform(self.training_set)
# Creating a data structure with 60 timesteps and 1 output
self.X_train = []
self.y_train = []
for i in range(60, 1258):
self.X_train.append(self.training_set_scaled[i-60:i, 0])
self.y_train.append(self.training_set_scaled[i, 0])
self.X_train, self.y_train = np.array(self.X_train), np.array(self.y_train)
# Reshaping
self.X_train = np.reshape(self.X_train, (self.X_train.shape[0], self.X_train.shape[1], 1))
def buildRNN(self):
""" Builds the RNN. """
self.scaleTrainData()
# Initialising the RNN
self.regressor = Sequential()
# Adding the first LSTM layer and some Dropout regularisation
self.regressor.add(LSTM(units=50, return_sequences=True,
input_shape=(self.X_train.shape[1], 1)))
self.regressor.add(Dropout(0.2))
# Adding a second LSTM layer and some Dropout regularisation
self.regressor.add(LSTM(units=50, return_sequences=True))
self.regressor.add(Dropout(0.2))
# Adding a third LSTM layer and some Dropout regularisation
self.regressor.add(LSTM(units=50, return_sequences=True))
self.regressor.add(Dropout(0.2))
# Adding a fourth LSTM layer and some Dropout regularisation
self.regressor.add(LSTM(units=50))
self.regressor.add(Dropout(0.2))
# Adding the output layer
self.regressor.add(Dense(units=1))
def fitRNN(self):
""" Fits the RNN to the data. """
self.buildRNN()
# Compiling the RNN
self.regressor.compile(optimizer='adam', loss='mean_squared_error')
# Fitting the RNN to the Training set
self.regressor.fit(self.X_train, self.y_train, epochs=100, batch_size=32)
def getPredictions_TestDataset(self):
""" Gets predictions for the test dataset. """
self.loadTestData()
self.fitRNN()
# Getting the predicted stock price
self.dataset_total = pd.concat((self.dataset['Open'], self.dataset_test['Open']), axis=0)
self.inputs = self.dataset_total[len(self.dataset_total) - len(self.dataset_test) - 60:].values
self.inputs = self.inputs.reshape(-1, 1)
self.inputs = self.sc.transform(self.inputs)
for i in range(60, len(self.dataset_test) + 60):
self.X_test.append(self.inputs[i-60:i, 0])
self.X_test = np.array(self.X_test)
self.X_test = np.reshape(self.X_test, (self.X_test.shape[0], self.X_test.shape[1], 1))
self.predicted_stock_price = self.regressor.predict(self.X_test)
self.predicted_stock_price = self.sc.inverse_transform(self.predicted_stock_price)
def visualize(self):
""" Visualize the results of the real stock price versus the predicted stock price. """
plt.plot(self.real_stock_price, color='red', label='Real Google Stock Price')
plt.plot(self.predicted_stock_price, color='blue',
label='Predicted Google Stock Price')
plt.title('Google Stock Price Prediction')
plt.xlabel('Time')
plt.ylabel('Google Stock Price')
plt.legend()
plt.xlim(0, 360)
plt.ylim(750, 875)
plt.show()
def predictTomorrow(self):
""" Predicts the stock price for tomorrow. """
self.loadTrainData()
self.updateData()
self.fitRNN()
self.inputs = self.dataset[:].values
self.inputs = self.inputs.reshape(-1, 1)
self.inputs = self.sc.transform(self.inputs)
self.inputs = np.array(self.inputs)
self.inputs = np.reshape(self.inputs, (self.inputs.shape[0], self.inputs.shape[1], 1))
self.predicted_stock_price = self.regressor.predict(self.inputs)
self.predicted_stock_price = self.sc.inverse_transform(self.predicted_stock_price)
print("previous 2 days", self.api.get_barset(self.stock, 'day', limit=2))
print("prediction for tomorrow:", self.predicted_stock_price)
def saveModel(self):
""" Saves RNN to JSON file """
self.model_json = self.regressor.to_json() # serialize model to JSON
with open("model.json", "w") as json_file:
json_file.write(self.model_json)
self.regressor.save_weights("model.h5") # serialize weights to HDF5
def loadModel(self):
self.json_file = open('model.json', 'r') # load json and create model
self.loaded_model_json = self.json_file.read()
self.json_file.close()
self.regressor = model_from_json(self.loaded_model_json)
self.regressor.load_weights("model.h5") # load weights into new model
def buy(self):
# Submit a market order to buy 1 share of stock at market price
self.api.submit_order(
symbol=self.stock,
qty=1,
side='buy',
type='market',
time_in_force='gtc'
)
def sell(self):
# Submit a market order to sell 1 share of stock at market price
self.api.submit_order(
symbol=self.stock,
qty=1,
side='sell',
type='market',
time_in_force='gtc'
)
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_labels, activation='softmax'))
model.summary()
callbacks = TensorBoard(log_dir='./graph')
# Compiling the model
model.compile(loss=categorical_crossentropy,
optimizer=Adam(),
metrics=['accuracy'])
# Training the model
model.fit(train_x, train_y,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(test_x, test_y),
shuffle=True,
callbacks=[callbacks])
# Saving the model to use it later on
fer_json = model.to_json()
with open("emotion_classification_cnn_5_emotions.json", "w") as json_file:
json_file.write(fer_json)
model.save_weights("emotion_classification_cnn_5_emotions.h5")
def main():
counting_dataset_path = 'counting_data_UCF'
counting_dataset = list()
train_labels = {}
val_labels = {}
for im_path in glob.glob(os.path.join(counting_dataset_path, '*.jpg')):
counting_dataset.append(im_path)
img = image.load_img(im_path)
gt_file = im_path.replace('.jpg', '_ann.mat')
h, w = img.size
dmap, crowd_number = load_gt_from_mat(gt_file, (w, h))
train_labels[im_path] = dmap
val_labels[im_path] = crowd_number
mae_sum = 0.0
mse_sum = 0.0
# create folder to save results
date = str(datetime.datetime.now())
d = date.split()
d1 = d[0]
d2 = d[1].split(':')
results_folder = 'Results-' + d1 + '-' + d2[0] + '.' + d2[1]
if not os.path.exists(results_folder):
os.makedirs(results_folder)
# 5-fold cross validation
epochs = int(round(iterations / iterations_per_epoch))
n_fold = 5
for f in range(0, n_fold):
print('\nFold ' + str(f))
vgg = VGG16(include_top=False,
weights=None,
input_shape=(None, None, 3))
transfer_layer = vgg.get_layer('block5_conv3')
vgg_partial = Model(inputs=vgg.input,
outputs=transfer_layer.output,
name='vgg_partial')
# Start a new Keras Sequential model.
train_model = Sequential()
# Add the convolutional part of the VGG16 model from above.
train_model.add(vgg_partial)
train_model.add(
Conv2D(1, (3, 3),
strides=(1, 1),
padding='same',
data_format=None,
dilation_rate=(1, 1),
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
name='counting_output'))
train_model.summary()
# l2 weight decay
for layer in train_model.layers:
if hasattr(layer, 'kernel_regularizer'):
layer.kernel_regularizer = regularizers.l2(5e-4)
elif layer.name == 'vgg_partial':
for l in layer.layers:
if hasattr(l, 'kernel_regularizer'):
l.kernel_regularizer = regularizers.l2(5e-4)
optimizer = SGD(lr=0.0, decay=0.0, momentum=0.9, nesterov=False)
loss = {'counting_output': euclideanDistanceCountingLoss}
train_model.compile(optimizer=optimizer, loss=loss)
if f == 0:
split_train = [
'counting_data_UCF/25.jpg', 'counting_data_UCF/49.jpg',
'counting_data_UCF/18.jpg', 'counting_data_UCF/13.jpg',
'counting_data_UCF/28.jpg', 'counting_data_UCF/34.jpg',
'counting_data_UCF/17.jpg', 'counting_data_UCF/3.jpg',
'counting_data_UCF/26.jpg', 'counting_data_UCF/15.jpg',
'counting_data_UCF/31.jpg', 'counting_data_UCF/6.jpg',
'counting_data_UCF/33.jpg', 'counting_data_UCF/2.jpg',
'counting_data_UCF/30.jpg', 'counting_data_UCF/36.jpg',
'counting_data_UCF/42.jpg', 'counting_data_UCF/20.jpg',
'counting_data_UCF/38.jpg', 'counting_data_UCF/11.jpg',
'counting_data_UCF/5.jpg', 'counting_data_UCF/7.jpg',
'counting_data_UCF/4.jpg', 'counting_data_UCF/21.jpg',
'counting_data_UCF/27.jpg', 'counting_data_UCF/39.jpg',
'counting_data_UCF/22.jpg', 'counting_data_UCF/43.jpg',
'counting_data_UCF/32.jpg', 'counting_data_UCF/35.jpg',
'counting_data_UCF/8.jpg', 'counting_data_UCF/50.jpg',
'counting_data_UCF/12.jpg', 'counting_data_UCF/19.jpg',
'counting_data_UCF/44.jpg', 'counting_data_UCF/23.jpg',
'counting_data_UCF/9.jpg', 'counting_data_UCF/46.jpg',
'counting_data_UCF/16.jpg', 'counting_data_UCF/41.jpg'
]
split_val = [
'counting_data_UCF/37.jpg', 'counting_data_UCF/48.jpg',
'counting_data_UCF/29.jpg', 'counting_data_UCF/10.jpg',
'counting_data_UCF/14.jpg', 'counting_data_UCF/1.jpg',
'counting_data_UCF/45.jpg', 'counting_data_UCF/47.jpg',
'counting_data_UCF/40.jpg', 'counting_data_UCF/24.jpg'
]
split_val_labels = {
k: val_labels[k]
for k in split_val
} #dizionario con 10 corrispondenze image_path-->crowd_number
split_train_labels = {
k: train_labels[k]
for k in split_train
} #dizionario con 40 corrispondenze image_path-->dmap
elif f == 1:
split_train = [
'counting_data_UCF/37.jpg', 'counting_data_UCF/48.jpg',
'counting_data_UCF/29.jpg', 'counting_data_UCF/10.jpg',
'counting_data_UCF/14.jpg', 'counting_data_UCF/1.jpg',
'counting_data_UCF/45.jpg', 'counting_data_UCF/47.jpg',
'counting_data_UCF/40.jpg', 'counting_data_UCF/24.jpg',
'counting_data_UCF/31.jpg', 'counting_data_UCF/6.jpg',
'counting_data_UCF/33.jpg', 'counting_data_UCF/2.jpg',
'counting_data_UCF/30.jpg', 'counting_data_UCF/36.jpg',
'counting_data_UCF/42.jpg', 'counting_data_UCF/20.jpg',
'counting_data_UCF/38.jpg', 'counting_data_UCF/11.jpg',
'counting_data_UCF/5.jpg', 'counting_data_UCF/7.jpg',
'counting_data_UCF/4.jpg', 'counting_data_UCF/21.jpg',
'counting_data_UCF/27.jpg', 'counting_data_UCF/39.jpg',
'counting_data_UCF/22.jpg', 'counting_data_UCF/43.jpg',
'counting_data_UCF/32.jpg', 'counting_data_UCF/35.jpg',
'counting_data_UCF/8.jpg', 'counting_data_UCF/50.jpg',
'counting_data_UCF/12.jpg', 'counting_data_UCF/19.jpg',
'counting_data_UCF/44.jpg', 'counting_data_UCF/23.jpg',
'counting_data_UCF/9.jpg', 'counting_data_UCF/46.jpg',
'counting_data_UCF/16.jpg', 'counting_data_UCF/41.jpg'
]
split_val = [
'counting_data_UCF/25.jpg', 'counting_data_UCF/49.jpg',
'counting_data_UCF/18.jpg', 'counting_data_UCF/13.jpg',
'counting_data_UCF/28.jpg', 'counting_data_UCF/34.jpg',
'counting_data_UCF/17.jpg', 'counting_data_UCF/3.jpg',
'counting_data_UCF/26.jpg', 'counting_data_UCF/15.jpg'
]
split_val_labels = {
k: val_labels[k]
for k in split_val
} #dizionario con 10 corrispondenze image_path-->crowd_number
split_train_labels = {
k: train_labels[k]
for k in split_train
} #dizionario con 40 corrispondenze image_path-->dmap
elif f == 2:
split_train = [
'counting_data_UCF/37.jpg', 'counting_data_UCF/48.jpg',
'counting_data_UCF/29.jpg', 'counting_data_UCF/10.jpg',
'counting_data_UCF/14.jpg', 'counting_data_UCF/1.jpg',
'counting_data_UCF/45.jpg', 'counting_data_UCF/47.jpg',
'counting_data_UCF/40.jpg', 'counting_data_UCF/24.jpg',
'counting_data_UCF/25.jpg', 'counting_data_UCF/49.jpg',
'counting_data_UCF/18.jpg', 'counting_data_UCF/13.jpg',
'counting_data_UCF/28.jpg', 'counting_data_UCF/34.jpg',
'counting_data_UCF/17.jpg', 'counting_data_UCF/3.jpg',
'counting_data_UCF/26.jpg', 'counting_data_UCF/15.jpg',
'counting_data_UCF/5.jpg', 'counting_data_UCF/7.jpg',
'counting_data_UCF/4.jpg', 'counting_data_UCF/21.jpg',
'counting_data_UCF/27.jpg', 'counting_data_UCF/39.jpg',
'counting_data_UCF/22.jpg', 'counting_data_UCF/43.jpg',
'counting_data_UCF/32.jpg', 'counting_data_UCF/35.jpg',
'counting_data_UCF/8.jpg', 'counting_data_UCF/50.jpg',
'counting_data_UCF/12.jpg', 'counting_data_UCF/19.jpg',
'counting_data_UCF/44.jpg', 'counting_data_UCF/23.jpg',
'counting_data_UCF/9.jpg', 'counting_data_UCF/46.jpg',
'counting_data_UCF/16.jpg', 'counting_data_UCF/41.jpg'
]
split_val = [
'counting_data_UCF/31.jpg', 'counting_data_UCF/6.jpg',
'counting_data_UCF/33.jpg', 'counting_data_UCF/2.jpg',
'counting_data_UCF/30.jpg', 'counting_data_UCF/36.jpg',
'counting_data_UCF/42.jpg', 'counting_data_UCF/20.jpg',
'counting_data_UCF/38.jpg', 'counting_data_UCF/11.jpg'
]
split_val_labels = {
k: val_labels[k]
for k in split_val
} #dizionario con 10 corrispondenze image_path-->crowd_number
split_train_labels = {
k: train_labels[k]
for k in split_train
} #dizionario con 40 corrispondenze image_path-->dmap
elif f == 3:
split_train = [
'counting_data_UCF/37.jpg', 'counting_data_UCF/48.jpg',
'counting_data_UCF/29.jpg', 'counting_data_UCF/10.jpg',
'counting_data_UCF/14.jpg', 'counting_data_UCF/1.jpg',
'counting_data_UCF/45.jpg', 'counting_data_UCF/47.jpg',
'counting_data_UCF/40.jpg', 'counting_data_UCF/24.jpg',
'counting_data_UCF/25.jpg', 'counting_data_UCF/49.jpg',
'counting_data_UCF/18.jpg', 'counting_data_UCF/13.jpg',
'counting_data_UCF/28.jpg', 'counting_data_UCF/34.jpg',
'counting_data_UCF/17.jpg', 'counting_data_UCF/3.jpg',
'counting_data_UCF/26.jpg', 'counting_data_UCF/15.jpg',
'counting_data_UCF/31.jpg', 'counting_data_UCF/6.jpg',
'counting_data_UCF/33.jpg', 'counting_data_UCF/2.jpg',
'counting_data_UCF/30.jpg', 'counting_data_UCF/36.jpg',
'counting_data_UCF/42.jpg', 'counting_data_UCF/20.jpg',
'counting_data_UCF/38.jpg', 'counting_data_UCF/11.jpg',
'counting_data_UCF/8.jpg', 'counting_data_UCF/50.jpg',
'counting_data_UCF/12.jpg', 'counting_data_UCF/19.jpg',
'counting_data_UCF/44.jpg', 'counting_data_UCF/23.jpg',
'counting_data_UCF/9.jpg', 'counting_data_UCF/46.jpg',
'counting_data_UCF/16.jpg', 'counting_data_UCF/41.jpg'
]
split_val = [
'counting_data_UCF/5.jpg', 'counting_data_UCF/7.jpg',
'counting_data_UCF/4.jpg', 'counting_data_UCF/21.jpg',
'counting_data_UCF/27.jpg', 'counting_data_UCF/39.jpg',
'counting_data_UCF/22.jpg', 'counting_data_UCF/43.jpg',
'counting_data_UCF/32.jpg', 'counting_data_UCF/35.jpg'
]
split_val_labels = {
k: val_labels[k]
for k in split_val
} #dizionario con 10 corrispondenze image_path-->crowd_number
split_train_labels = {
k: train_labels[k]
for k in split_train
} #dizionario con 40 corrispondenze image_path-->dmap
elif f == 4:
split_train = [
'counting_data_UCF/37.jpg', 'counting_data_UCF/48.jpg',
'counting_data_UCF/29.jpg', 'counting_data_UCF/10.jpg',
'counting_data_UCF/14.jpg', 'counting_data_UCF/1.jpg',
'counting_data_UCF/45.jpg', 'counting_data_UCF/47.jpg',
'counting_data_UCF/40.jpg', 'counting_data_UCF/24.jpg',
'counting_data_UCF/25.jpg', 'counting_data_UCF/49.jpg',
'counting_data_UCF/18.jpg', 'counting_data_UCF/13.jpg',
'counting_data_UCF/28.jpg', 'counting_data_UCF/34.jpg',
'counting_data_UCF/17.jpg', 'counting_data_UCF/3.jpg',
'counting_data_UCF/26.jpg', 'counting_data_UCF/15.jpg',
'counting_data_UCF/31.jpg', 'counting_data_UCF/6.jpg',
'counting_data_UCF/33.jpg', 'counting_data_UCF/2.jpg',
'counting_data_UCF/30.jpg', 'counting_data_UCF/36.jpg',
'counting_data_UCF/42.jpg', 'counting_data_UCF/20.jpg',
'counting_data_UCF/38.jpg', 'counting_data_UCF/11.jpg',
'counting_data_UCF/5.jpg', 'counting_data_UCF/7.jpg',
'counting_data_UCF/4.jpg', 'counting_data_UCF/21.jpg',
'counting_data_UCF/27.jpg', 'counting_data_UCF/39.jpg',
'counting_data_UCF/22.jpg', 'counting_data_UCF/43.jpg',
'counting_data_UCF/32.jpg', 'counting_data_UCF/35.jpg'
]
split_val = [
'counting_data_UCF/8.jpg', 'counting_data_UCF/50.jpg',
'counting_data_UCF/12.jpg', 'counting_data_UCF/19.jpg',
'counting_data_UCF/44.jpg', 'counting_data_UCF/23.jpg',
'counting_data_UCF/9.jpg', 'counting_data_UCF/46.jpg',
'counting_data_UCF/16.jpg', 'counting_data_UCF/41.jpg'
]
split_val_labels = {
k: val_labels[k]
for k in split_val
} #dizionario con 10 corrispondenze image_path-->crowd_number
split_train_labels = {
k: train_labels[k]
for k in split_train
} #dizionario con 40 corrispondenze image_path-->dmap
X_counting = np.empty((len(split_train), 224, 224, 3))
y_counting = np.empty((len(split_train), 14, 14, 1))
y_tmp = np.empty(
(len(split_train), 14,
14)) # to temporarily save the resized counting target
for i, imgpath in enumerate(split_train):
counting_img = image.load_img(imgpath)
crop_resized_img = counting_img.resize((224, 224),
PIL.Image.BILINEAR)
crop_resized_array_img = image.img_to_array(crop_resized_img)
X_counting[i, ] = crop_resized_array_img
dmap = split_train_labels[imgpath]
y_tmp[i] = downsample(dmap, (14, 14))
y_counting[i] = np.resize(y_tmp[i], (14, 14, 1))
lrate = LearningRateScheduler(step_decay)
callbacks_list = [lrate]
train_model.fit(x=X_counting,
y=y_counting,
batch_size=batch_size,
epochs=epochs,
callbacks=callbacks_list)
predictions = np.empty((len(split_val), 1))
y_validation = np.empty((len(split_val), 1))
for i in range(len(split_val)):
img = image.load_img(split_val[i]) # test image original size
# img = image.load_img(split_val[i], target_size=(224, 224)) # test image 224x224
img_to_array = image.img_to_array(img)
img_to_array = np.expand_dims(img_to_array, axis=0)
pred_test = train_model.predict(img_to_array)
predictions[i] = np.sum(pred_test)
y_validation[i] = split_val_labels[split_val[i]]
mean_abs_err = mae(predictions, y_validation)
mean_sqr_err = mse(predictions, y_validation)
# serialize model to JSON
model_json = train_model.to_json()
model_json_name = "test_model_" + str(f) + ".json"
with open(model_json_name, "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model_h5_name = "test_model_" + str(f) + ".h5"
train_model.save_weights(model_h5_name)
print("Saved model to disk")
print('\n######################')
print('Results on TEST SPLIT:')
print(' MAE: {}'.format(mean_abs_err))
print(' MSE: {}'.format(mean_sqr_err))
print("Took %f seconds" % (time.time() - s))
path1 = results_folder + '/test_split_results_fold-' + str(f) + '.txt'
with open(path1, 'w') as f:
f.write('mae: %f,\nmse: %f, \nTook %f seconds' %
(mean_abs_err, mean_sqr_err, time.time() - s))
mae_sum = mae_sum + mean_abs_err
mse_sum = mse_sum + mean_sqr_err
print('\n################################')
print('Average Results on TEST SPLIT:')
print(' AVE MAE: {}'.format(mae_sum / n_fold))
print(' AVE MSE: {}'.format(mse_sum / n_fold))
print("Took %f seconds" % (time.time() - s))
path2 = results_folder + '/test_split_results_avg.txt'
with open(path2, 'w') as f:
f.write('avg_mae: %f, \navg_mse: %f, \nTook %f seconds' %
(mae_sum / n_fold, mse_sum / n_fold, time.time() - s))
# In[25]:
categories = {0: 'with_mask', 1: 'without_mask'}
def mapping(value):
return categories[value]
# In[26]:
prediction = model.predict(prediction_image)
value = np.argmax(prediction)
predicted = mapping(value)
print("PREDICTION IS {}".format(predicted))
# In[27]:
# model.save("mask_detection.h5")
from tensorflow.keras.models import model_from_json
# In[28]:
# prediction_image.shape
json_file = model.to_json()
with open("mask_detection.json", "w") as file:
file.write(json_file)
model.save_weights("mask_detection.h5")
# In[ ]:
class GRUTheano:
def __init__(self,
input_x,
hidden_layer,
epoch=20,
lr=1e-3,
optimasi='SGD'):
self.input = input_x
self.hidden_layer = hidden_layer
self.epoch = epoch
self.lr = lr
self.feat_max = 50
self.optim = optimasi
self.__build_model__()
def __build_model__(self):
self.model = Sequential()
self.model.add(
GRU(units=self.hidden_layer,
return_sequences=True,
input_shape=(self.input, self.feat_max)))
self.model.add(Flatten())
self.model.add(Dense(1, activation='sigmoid'))
if self.optim == 'Adam':
optimasi = Adam(lr=self.lr)
else:
optimasi = SGD(lr=self.lr)
self.model.compile(loss='binary_crossentropy',
optimizer=optimasi,
metrics=['accuracy'])
def feedpassward(self, data_train, label_train, batc=100):
history = self.model.fit(data_train,
label_train,
validation_split=0.05,
epochs=self.epoch,
batch_size=batc)
return history
def evaluasimodel(self, data_test, label_test):
result = self.model.evaluate(data_test, label_test)
# print(result)
print("Accuracy: {0:.2%}".format(result[1]))
if result[1] > 0.90:
self.simpan_model()
def prediksi(self, data_prediksi, label_prediksi):
y_predik = self.model.predict(x=data_prediksi)
y_predik = y_predik.T[0]
cls_pred = np.array([1. if p > 0.5 else 0. for p in y_predik])
cls_true = np.array(label_prediksi)
incorect = np.where(cls_pred != cls_true)
print(incorect)
incorect = incorect[0]
print("incorect : ", incorect)
print(len(incorect))
def simpan_model(self):
# serialize model to json
model_json = self.model.to_json()
with open('berat/model.json', "w") as json_file:
json_file.write(model_json)
# serialize bobot to HDFS
self.model.save_weights("berat/model.h5")
print("model disimpan di disk")
LSTM(hidden_neurons,
batch_input_shape=(None, length_of_sequences, in_out_neurons),
return_sequences=False))
model.add(Dense(in_out_neurons))
model.add(Activation("linear"))
model.compile(
loss="mean_squared_error",
optimizer="adam",
)
#学習の実施
early_stopping = EarlyStopping(monitor='val_loss', mode='auto', patience=0)
history = model.fit(X_train,
y_train,
batch_size=600,
epochs=10,
validation_split=0.1,
callbacks=[early_stopping])
json_string = model.to_json()
open('keras_lstm_model.json', 'w').write(json_string)
model.save_weights('keras_lstm_weihgts.h5')
#グラフ描画
pred_data = model.predict(X_train)
plt.plot(y_train, label='train')
plt.plot(pred_data, label='pred')
plt.legend(loc='upper left')
plt.show()
def trainModel(modelName, train_X, train_Y, test_X, test_Y, layers, inputDime,
outputDim, transfnc, optimizer, epochs, batch):
# create tesnsorboard callback
tb = TensorBoard(log_dir='./logs',
histogram_freq=0,
write_graph=True,
write_images=True)
# create a csv logger callback
csv_logger = CSVLogger("logs/" + modelName + 'training.log')
## create model
model = Sequential()
model.add(Dense(layers[0], input_dim=inputDime, activation=transfnc))
# setup model's architecure
for i in range(1, len(layers)):
model.add(Dense(layers[i], activation=transfnc))
model.add(Dense(outputDim, activation='softmax'))
# Compile model
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy', 'mse'])
start_time = time.time()
# Fit the model
model.fit(
train_X,
train_Y,
epochs=epochs,
shuffle=True,
batch_size=batch,
callbacks=[tb, csv_logger],
verbose=1,
validation_split=0.15,
)
# evaluate the model
scores = evaluateModel(model, test_X, test_Y, batch)
elapsed_time = time.time() - start_time
# Saving the model
architecture = ""
for layer in layers:
architecture = architecture + str(layer) + "-"
architecture = architecture[0:len(architecture) - 1]
stats = open(statsFile, 'a')
stats.write(architecture + "," + transfnc + "," + optimizer + "," +
str(epochs) + "," + str(batch) + "," + str(scores[1] * 100) +
"," + str(scores[2]) + "," +
(time.strftime("%H:%M:%S.", time.gmtime(elapsed_time))) + "\n")
stats.close()
# serialize model to JSON
model_json = model.to_json()
with open("Models/JSON/" + modelName + "_Architecure.json",
"w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save("Models/Weights/" + modelName + ".hd5")
print("SAVING " + modelName + " TO DISK")
print("FINISHED TRAINING MODEL : " + modelName)
# sleep(30)
return model
callbacks=callbacks_list,
verbose=1,
shuffle=True)
model.save(current_output_local + '/my_checkpoint_test',
overwrite=True) # creates a HDF5 file 'my_model.h5'
#del model # deletes the existing model
#model = load_model('output/my_model.h5')
######## save method two https://jovianlin.io/saving-loading-keras-models/
# Save the weights
model.save_weights(current_output_local + 'model_weights.h5', overwrite=True)
# Save the model architecture
with open(current_output_local + 'model_architecture.json', 'w') as f:
f.write(model.to_json())
#######
############save method three#################
saver = tf.train.Saver()
sess = backend.get_session()
saver.save(sess, current_output_local)
model.save(current_output_local + 'my_model.h5')
#print(model.get_weights())
###########################perdiction####################################
print(X.shape)
#temp=temp
data = X[0:100, :, :, :]
del X
data = np.array(data).reshape(-1, IMG_SIZE_UP, IMG_SIZE_UP, 3)
print('done')
from tensorflow.python.keras.applications.resnet50 import preprocess_input
from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
image_size = 224
data_generator = ImageDataGenerator(preprocessing_function=preprocess_input)
train_generator = data_generator.flow_from_directory('Images/train',
target_size=(image_size,
image_size),
batch_size=10,
class_mode='categorical')
validation_generator = data_generator.flow_from_directory(
'Images/val',
target_size=(image_size, image_size),
batch_size=10,
class_mode='categorical')
my_new_model.compile(optimizer='sgd',
loss='categorical_crossentropy',
metrics=['accuracy'])
my_new_model.fit_generator(train_generator,
steps_per_epoch=900,
epochs=2,
validation_data=validation_generator,
validation_steps=400)
model_json = my_new_model.to_json()
with open("model_arch.json", "w") as json_file:
json_file.write(model_json)
my_new_model.save_weights("my_model_weights.h5")
ytrain = np.zeros(shape=((NB_CLASSES + 1) * NB_VIDEOS_BY_CLASS_TRAIN,
NB_CLASSES + 1))
print("Session " + str(serie))
xtrain, ytrain = data_generation(xtrain, ytrain)
if (MIXED_DATA == True):
# manage several data files
for i in range(len(REAL_VIDEO_DATASET)):
data = np.load(str(REAL_VIDEO_DATASET[i]))
xtrain = np.concatenate((xtrain, data['a']), axis=0)
ytrain = np.concatenate((ytrain, data['b']), axis=0)
indices = np.arange(xtrain.shape[0])
np.random.shuffle(indices)
xtrain = xtrain[indices]
ytrain = ytrain[indices]
#start training
model.fit(xtrain,
ytrain,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
verbose=VERBOSE)
#save data
model_json = model.to_json()
open(f'{RESULTS_PATH}/model_conv3D.json', 'w').write(model_json)
model.save_weights(f'{RESULTS_PATH}/weights_conv3D.h5', overwrite=True)
print('A new model has been saved!\n')
class FaceRecogPredictor:
def __init__(self, labels, from_json=False):
self.from_json = from_json
self.labels = labels
if from_json:
self.load()
else:
self.amt_labels = len(self.labels)
self.dirs = [PHOTO_DIR + label + "/" for label in self.labels]
self.model = Sequential()
self.model.add(
Conv2D(64,
kernel_size=1,
activation="relu",
input_shape=(1, PHOTO_ROWS, PHOTO_COLS)))
self.model.add(Conv2D(32, kernel_size=1, activation="relu"))
self.model.add(Flatten())
self.model.add(Dense(16, activation="relu"))
self.model.add(Dense(self.amt_labels, activation="softmax"))
self.model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
def fetch_data(self):
xs = []
ys = []
for ix, direc in enumerate(self.dirs):
y = np.array([0 for i in range(self.amt_labels)])
y[ix] = 1
photos = [direc + fname for fname in os.listdir(direc)]
for p in photos:
photo = Image.open(p)
resized = photo.resize((PHOTO_ROWS, PHOTO_COLS))
gray = resized.convert("L")
xs.append(np.array([np.array(gray)]))
ys.append(y)
return (xs, ys)
def get_train_test(self, xs, ys, split=0.7):
sh_xs, sh_ys = shuffle(xs, ys)
len_xs = len(xs)
train_size = int(len_xs * split)
x_train, y_train = sh_xs[:train_size], sh_ys[:train_size]
x_test, y_test = sh_xs[train_size + 1:len_xs], sh_ys[train_size +
1:len_xs]
return (x_train, x_test, y_train, y_test)
def train(self):
xs, ys = self.fetch_data()
x_train, x_test, y_train, y_test = self.get_train_test(xs, ys)
self.model.fit(np.array(x_train),
np.array(y_train),
validation_data=(np.array(x_test), np.array(y_test)),
epochs=100)
def predict(self, x):
prediction = self.model.predict(x)
ix = np.argmax(prediction)
return self.labels[ix]
def save(self):
with open(MODEL_DIR + "model.json", "w") as json_file:
json_file.write(self.model.to_json())
self.model.save_weights("model.h5")
def load(self):
inside = os.listdir(MODEL_DIR)
if "model.json" not in inside or "model.h5" not in inside:
raise ValueError(
"Make sure both model.json and model.h5 are inside \'models/\'"
)
with open(MODEL_DIR + "model.json", "w") as json_file:
self.model = model_from_json(json_file.read())
self.model.load_weights(MODEL_DIR + "model.h5")
