for layer in base_model.layers:
layer.trainable = False
# compile the model (should be done *after* setting layers to non-trainable)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['acc', 'top_k_categorical_accuracy'])
train_steps = int(math.ceil(nb_train_samples / batch_size))
validation_steps = int(math.ceil(nb_validation_samples / batch_size))
# train_steps = nb_train_samples // batch_size
# validation_steps = nb_validation_samples // batch_size
bn_start_time = datetime.now()
print("[Info] Model Bottlenecking started at: {}".format(bn_start_time))
filepath = training_checkpoint_dir + "/model-{epoch:02d}-{val_acc:.2f}-{val_loss:.2f}.h5"
checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='min')
early_stop = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=5, restore_best_weights=True)
reduce_lr = ReduceLROnPlateau(patience=3)
figPath = os.path.join(model_dir, 'checkpoints', 'progress', 'train.png')
jsonPath = os.path.join(model_dir, 'checkpoints', 'progress', 'train.json')
train_monitor = TrainingMonitor(figPath, jsonPath=jsonPath, startAt=init_epoch_train)
# TypeError: Object of type float32 is not JSON serializable
# train_monitor = TrainingMonitor(figPath)
callbacks_list = [early_stop, reduce_lr, checkpoint, train_monitor]
history = model.fit_generator(
train_generator,
def train(args):
src_root = args.src_root
sr = args.sample_rate
dt = args.delta_time
batch_size = args.batch_size
model_type = args.model_type
params = {'N_CLASSES': len(os.listdir(args.src_root)), 'SR': sr, 'DT': dt}
models = {
'conv1d': Conv1D(**params),
'conv2d': Conv2D(**params),
'lstm': LSTM(**params)
}
assert model_type in models.keys(), '{} not an available model'.format(
model_type)
csv_path = os.path.join('logs', '{}_history.csv'.format(model_type))
wav_paths = glob('{}/**'.format(src_root), recursive=True)
wav_paths = [x.replace(os.sep, '/') for x in wav_paths if '.wav' in x]
classes = sorted(os.listdir(args.src_root))
le = LabelEncoder()
le.fit(classes)
labels = [os.path.split(x)[0].split('/')[-1] for x in wav_paths]
labels = le.transform(labels)
wav_train, wav_val, label_train, label_val = train_test_split(
wav_paths, labels, test_size=0.1, random_state=0)
assert len(
label_train
) >= args.batch_size, 'Number of train samples must be >= batch_size'
if len(set(label_train)) != params['N_CLASSES']:
warnings.warn(
'Found {}/{} classes in training data. Increase data size or change random_state.'
.format(len(set(label_train)), params['N_CLASSES']))
if len(set(label_val)) != params['N_CLASSES']:
warnings.warn(
'Found {}/{} classes in validation data. Increase data size or change random_state.'
.format(len(set(label_val)), params['N_CLASSES']))
tg = DataGenerator(wav_train,
label_train,
sr,
dt,
params['N_CLASSES'],
batch_size=batch_size)
vg = DataGenerator(wav_val,
label_val,
sr,
dt,
params['N_CLASSES'],
batch_size=batch_size)
model = models[model_type]
cp = ModelCheckpoint('models/{}.h5'.format(model_type),
monitor='val_loss',
save_best_only=True,
save_weights_only=False,
mode='auto',
save_freq='epoch',
verbose=1)
csv_logger = CSVLogger(csv_path, append=False)
model.fit(tg,
validation_data=vg,
epochs=30,
verbose=1,
callbacks=[csv_logger, cp])
# model.add(Conv2D(9,(2,3)))
# model.add(Conv2D(8,2))
model.add(Flatten())
model.add(Dense(1))
model.add(Dense(1, activation='sigmoid')) #이진분류일 때 activation을 sigmoid로 사용
# linear -무한 ~ 무한 / relu 0 ~ 무한 / sigmoid 0 ~ 1
# 3. 컴파일, 훈련
# mean_squared_error #accuracy, mae
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])
# 이진분류일 때 loss를 binary_crossentropy로 사용 # metrics에 가급적 acc로 사용
# mse는 회귀모델
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
modelpath = '../data/modelcheckpoint/k46_6_cancer_{epoch:02d}-{val_loss:.4f}.hdf5'
cp = ModelCheckpoint(filepath=modelpath,
monitor='val_loss',
save_best_only=True,
mode='auto')
early_stopping = EarlyStopping(monitor='loss', patience=20, mode='auto')
hist = model.fit(x_train,
y_train,
epochs=500,
batch_size=10,
validation_data=(x_val, y_val),
callbacks=[early_stopping, cp])
loss = model.evaluate(x_test, y_test)
print(loss)
# sigmoid 0~1 이므로 0.5 이상 = 1 미만 = 0 으로 설정
sent1 = Embedding(vocab_size, EMBEDDING_DIM,
input_length=MAX_LEN)(text_input)
sent3 = Bidirectional(LSTM(128, return_sequences=False))(sent1)
decoder1 = Add()([im2, sent3])
pred = Dense(vocab_size, activation='softmax')(decoder1)
model = Model(inputs=[image_input, text_input], outputs=pred)
model.compile(loss='categorical_crossentropy',
optimizer="Adam",
metrics=['accuracy'])
model.summary()
callbacks = [
EarlyStopping(patience=10, verbose=1),
ReduceLROnPlateau(factor=0.1, patience=3, min_lr=0.00001, verbose=1),
ModelCheckpoint(os.path.join(
os.path.join(model_workspace_dir, 'weights_best.hdf5')),
verbose=1,
save_best_only=False),
CSVLogger(os.path.join(model_workspace_dir, 'training.csv')),
PerformanceMetrics(os.path.join(model_workspace_dir,
'performance.csv')),
]
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
epochs=100,
callbacks=callbacks)
def main(cfg):
if cfg.wandb.project:
import wandb
from wandb.keras import WandbCallback
wandb.init(project=cfg.wandb.project)
callbacks = [WandbCallback()]
else:
callbacks = []
data_path = Path("/pfs/faces/data/imdb_crop")
#data_path = Path("/home/raoulfasel/Documents/pachyderm/age_gender_estimation/data/imdb_crop")
csv_path = Path(to_absolute_path("./")).joinpath("meta", f"{cfg.data.db}.csv")
#csv_path = Path(to_absolute_path("/pfs/faces")).joinpath("meta", f"{cfg.data.db}.csv")
print(csv_path)
df = pd.read_csv(str(csv_path))
train, val = train_test_split(df, random_state=42, test_size=0.1)
train_gen = ImageSequence(cfg, train, "train", data_path)
val_gen = ImageSequence(cfg, val, "val", data_path)
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
model = get_model(cfg)
opt = get_optimizer(cfg)
scheduler = get_scheduler(cfg)
model.compile(optimizer=opt,
loss=["sparse_categorical_crossentropy", "sparse_categorical_crossentropy"],
metrics=['accuracy'])
#checkpoint_dir = Path(to_absolute_path("age_gender_estimation")).joinpath("checkpoint")
checkpoint_dir = Path(to_absolute_path("/pfs/build")).joinpath("checkpoint")
print(checkpoint_dir)
checkpoint_dir.mkdir(exist_ok=True)
filename = "_".join([cfg.model.model_name,
str(cfg.model.img_size),
"weights.{epoch:02d}-{val_loss:.2f}.hdf5"])
callbacks.extend([
LearningRateScheduler(schedule=scheduler),
ModelCheckpoint(str(checkpoint_dir) + "/" + filename,
monitor="val_loss",
verbose=1,
save_best_only=True,
mode="auto")
])
model.fit(train_gen, epochs=cfg.train.epochs, callbacks=callbacks, validation_data=val_gen,
workers=multiprocessing.cpu_count())
model.save("tensorflow_deployment_package/tensorflow_model.h5")
with open('/opt/ubiops/token', 'r') as reader:
API_TOKEN = reader.read()
client = ubiops.ApiClient(ubiops.Configuration(api_key={'Authorization': API_TOKEN},
host='https://api.ubiops.com/v2.1'))
api = ubiops.CoreApi(client)
# Create the deployment
deployment_template = ubiops.DeploymentCreate(
name=DEPLOYMENT_NAME,
description='Tensorflow deployment',
input_type='structured',
output_type='structured',
input_fields=[
ubiops.DeploymentInputFieldCreate(
name='input_image',
data_type='blob',
),
],
output_fields=[
ubiops.DeploymentOutputFieldCreate(
name='output_image',
data_type='blob'
),
],
labels={"demo": "tensorflow"}
)
api.deployments_create(
project_name=PROJECT_NAME,
data=deployment_template
)
# Create the version
version_template = ubiops.DeploymentVersionCreate(
version=DEPLOYMENT_VERSION,
language='python3.8',
instance_type="2048mb",
minimum_instances=0,
maximum_instances=1,
maximum_idle_time=1800 # = 30 minutes
)
api.deployment_versions_create(
project_name=PROJECT_NAME,
deployment_name=DEPLOYMENT_NAME,
data=version_template
)
# Zip the deployment package
shutil.make_archive('tensorflow_deployment_package', 'zip', '.', 'tensorflow_deployment_package')
# Upload the zipped deployment package
file_upload_result =api.revisions_file_upload(
project_name=PROJECT_NAME,
deployment_name=DEPLOYMENT_NAME,
version=DEPLOYMENT_VERSION,
file='tensorflow_deployment_package.zip'
)
def train(self, dataloader, mode='eager'):
print("-" * 35)
print(f"Starting training {self.use_model} in {mode} mode")
print("-" * 35)
self.build_model(training=True)
dataset = dataloader.get_samples()
dataset.pop('scalers')
if self.custom_model_params['netdesign'] == 'oneshot':
inputs, targets = tuple(dataset['inputs'][0:2]), dataset['targets']
else:
inputs, targets = tuple(dataset['inputs']), dataset['targets']
if mode == 'fit':
self.tsmodel.compile(loss=self.loss_fn,
optimizer=self.optimizer_fn)
callbacks = [
TensorBoard(log_dir=f"{self.paths['logs']}/{self.use_model}"),
ModelCheckpoint(
f"{self.paths['ckpts']}/{self.use_model}_weights.h5",
verbose=1,
save_weights_only=True)
]
self.tsmodel.fit(x=inputs,
y=targets,
batch_size=self.params['batchsize'],
epochs=self.params['epochs'],
validation_split=0.2,
shuffle=True,
callbacks=callbacks)
elif mode == 'eager':
self.summarywriter = tf.summary.create_file_writer(
f"{self.paths['logs']}/{self.use_model}")
self.trnsteps = tf.Variable(1, trainable=False, dtype=tf.int64)
self.valsteps = tf.Variable(1, trainable=False, dtype=tf.int64)
trnloss = avgmeter()
valloss = avgmeter()
nbatches = len(dataset['targets']) // self.params['batchsize']
dataset = tf.data.Dataset.from_tensor_slices({
'inputs': inputs,
'targets': targets
}).shuffle(nbatches, reshuffle_each_iteration=False).batch(
self.params['batchsize'])
comparisonmetric = 1e9
for epoch in range(1, self.params['epochs'] + 1):
trnloss.reset()
valloss.reset()
with tqdm(total=nbatches) as bar:
bar.set_description(f'Epoch:{epoch}')
for index, batchdata in dataset.enumerate():
if (index + 1) / nbatches < 0.8:
batchloss = self.trnstep(batchdata)
trnloss.update(batchloss.numpy(),
self.params['batchsize'])
bar.update(1)
bar.set_postfix(trainloss=trnloss.avg,
validloss=valloss.avg)
with self.summarywriter.as_default():
tf.summary.scalar('trainloss-iterations',
batchloss,
step=self.trnsteps)
else:
batchloss = self.valstep(batchdata)
valloss.update(batchloss.numpy(),
self.params['batchsize'])
bar.update(1)
bar.set_postfix(trainloss=trnloss.avg,
validloss=valloss.avg)
with self.summarywriter.as_default():
tf.summary.scalar('validationloss-iterations',
batchloss,
step=self.valsteps)
with self.summarywriter.as_default():
tf.summary.scalar('Lossfunction/trn',
trnloss.avg,
step=epoch)
tf.summary.scalar('Lossfunction/val',
valloss.avg,
step=epoch)
if valloss.avg < comparisonmetric:
self.tsmodel.save_weights(
f"{self.paths['ckpts']}/{self.use_model}_weights.h5")
comparisonmetric = valloss.avg
else:
print('Validation loss increased!')
else:
raise ValueError(
f"Unsupported training mode: {mode}, choose 'eager' or 'fit'")
self.exportmodel()
def quant_ft(build_dir, batchsize, learnrate, epochs, max_classes):
'''
Quantize & fine-tune the floating-point model
Save to HDF5 file
'''
def step_decay(epoch):
'''
Learning rate scheduler used by callback
Reduces learning rate depending on number of epochs
'''
lr = learnrate
if epoch > 65:
lr /= 10
return lr
float_dir = build_dir + '/float_model'
quant_ft_dir = build_dir + '/quant_ft_model'
tfrec_train = build_dir + '/tfrec_train'
tfrec_val = build_dir + '/tfrec_val'
print('\n' + DIVIDER)
print('Quantization & Fine-tune')
print(DIVIDER + '\n')
# load the floating point trained model
print(' Loading floating-point model from', float_dir + '/float_model.h5')
float_model = load_model(float_dir + '/float_model.h5', compile=False)
# get input dimensions of the floating-point model
height = float_model.input_shape[1]
width = float_model.input_shape[2]
chans = float_model.input_shape[3]
print(' Input dimensions: height:', height, ' width:', width, 'channels:',
chans)
# Quantization-aware training model
quantizer = vitis_quantize.VitisQuantizer(float_model)
ft_model = quantizer.get_qat_model()
'''
tf.data pipelines
'''
train_dataset = input_fn(tfrec_train, batchsize, True)
test_dataset = input_fn(tfrec_val, batchsize, False)
'''
Call backs
'''
chkpt_call = ModelCheckpoint(filepath=os.path.join(quant_ft_dir,
'quant_ft.h5'),
monitor='val_accuracy',
verbose=1,
save_best_only=True)
lr_scheduler_call = LearningRateScheduler(schedule=step_decay, verbose=1)
callbacks_list = [chkpt_call, lr_scheduler_call]
'''
Compile model
Adam optimizer to change weights & biases
Loss function is sparse categorical crossentropy
'''
ft_model.compile(optimizer=Adam(learning_rate=learnrate),
loss=SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
'''
Training
'''
print('\n' + DIVIDER)
print(' Training model with training set..')
print(DIVIDER)
# make folder for saving trained model checkpoint
os.makedirs(quant_ft_dir, exist_ok=True)
# run training
train_hist = ft_model.fit(train_dataset,
epochs=epochs,
steps_per_epoch=(1300 * max_classes) //
batchsize,
validation_data=test_dataset,
validation_steps=None,
callbacks=callbacks_list,
verbose=1)
'''
Evaluate quantized model
'''
print('\n' + DIVIDER)
print('Evaluating quantized model..')
print(DIVIDER + '\n')
# reload the best checkpoint and evaluate it
with vitis_quantize.quantize_scope():
eval_model = load_model(quant_ft_dir + '/quant_ft.h5', compile=False)
eval_model.compile(loss=SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
scores = eval_model.evaluate(test_dataset, steps=None, verbose=0)
print(' Quantized model accuracy: {0:.4f}'.format(scores[1] * 100), '%')
print('\n' + DIVIDER)
return
def train_model(x,
y,
model,
name="noname",
tboard=False,
ckpt=False,
epochs=10,
batch=3,
val_split=0.3,
estop=False,
estop_patience=10,
estop_min_delta=0.0001,
estop_monitor='val_acc'):
from datetime import datetime
import os
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras.callbacks import TensorBoard
from tensorflow.keras.callbacks import EarlyStopping
callbacks = []
if estop is True:
earlystop_callback = EarlyStopping(monitor=estop_monitor,
min_delta=estop_min_delta,
patience=estop_patience)
callbacks.append(earlystop_callback)
pass
if tboard is True:
logdir = 'logs/' + datetime.now().strftime("%Y%m%d-%H%M%S-") + name
if not os.path.exists('logs'):
os.makedirs('logs')
os.mkdir(logdir)
logdir = os.path.join(logdir)
tensorboard_callback = TensorBoard(log_dir=logdir,
histogram_freq=1,
profile_batch=100000000)
callbacks.append(tensorboard_callback)
pass
if ckpt is True:
if not os.path.exists('checkpoints'):
os.makedirs('checkpoints')
ckpf_dir = os.path.join(
'checkpoints',
datetime.now().strftime("%Y%m%d-%H%M%S-") + name,
)
os.makedirs(ckpf_dir)
ckpf = os.path.join('checkpoints',
datetime.now().strftime("%Y%m%d-%H%M%S-") + name,
name + '.hdf5')
checkpointer = ModelCheckpoint(filepath=ckpf,
verbose=1,
save_best_only=True)
callbacks.append(checkpointer)
pass
hist = model.fit(
x,
y,
batch_size=batch,
epochs=epochs,
validation_split=val_split,
# validation_data=(x_test, y_test_one_hot),
callbacks=callbacks,
)
return hist
# initialize the optimizer and model
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"])
# construct the callback to save only the *best* model to disk based on the validation loss
fname = os.path.sep.join(
[args["weights"], "weights-{epoch:03d}-{val_loss:.4f}.hdf5"])
# The mode parameter controls whether the ModelCheckpoint should be looking for values that minimize our metric or maximize it
checkpoint = ModelCheckpoint(fname,
monitor="val_loss",
mode="min",
save_best_only=True,
verbose=1)
callbacks = [checkpoint]
# train the network
print("[INFO] training network ...")
H = model.fit(trainX,
trainY,
validation_data=(testX, testY),
batch_size=64,
epochs=40,
callbacks=callbacks,
verbose=2)
model.add(Activation('tanh'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('elu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))
model.compile(Adam(lr=0.001, decay=1e-6),
loss="categorical_crossentropy",
metrics=["accuracy"])
# checkpoints
checkpoint = ModelCheckpoint(model_filename_just_faces,
monitor='val_accuracy',
save_best_only=True,
mode='max',
verbose=1)
#checkpoint = ModelCheckpoint(model_filename, monitor='val_loss', save_best_only=True, mode='min', verbose=1)
callbacks_list = [checkpoint]
STEP_SIZE_TRAIN = train_generator.n // train_generator.batch_size
STEP_SIZE_VALID = valid_generator.n // valid_generator.batch_size
model.fit_generator(generator=train_generator,
steps_per_epoch=STEP_SIZE_TRAIN,
validation_data=valid_generator,
validation_steps=STEP_SIZE_VALID,
callbacks=callbacks_list,
epochs=30)
def main():
args = parser.parse_args()
image_names = os.listdir(args.data_root) #the best way is to use sorted list,i.e., sorted()
image_names = sorted(image_names)[:-1]
img_path = [os.path.join(args.data_root,x) for x in image_names]
person_id_original_list = [x[:4] for x in image_names]
num_person_ids = len(set(person_id_original_list))
print('Number of Person IDs is {}'.format(num_person_ids))
id_encoder = LabelEncoder()
id_encoder.fit(person_id_original_list)
person_id_encoded = id_encoder.transform(person_id_original_list)
train_img_path, val_img_path, train_person_ids, val_person_ids = train_test_split(
img_path, person_id_encoded, test_size=0.2, random_state=42)
# model
cnn_model = MobileNetV2(include_top=False, alpha=0.5, weights='imagenet',
input_shape=(args.img_height,args.img_width,3), pooling='max')
global_pool = cnn_model.layers[-1].output
normalized_global_pool = Lambda(lambda x: K.l2_normalize(x, axis=1), name='triplet')(global_pool)
if args.USE_BNNeck:
global_pool_bn = BatchNormalization(name= 'feature_bn')(global_pool)
pred = Dense(num_person_ids, activation='softmax')(global_pool_bn)
else:
pred = Dense(num_person_ids, activation='softmax')(global_pool)
triplet_model = Model(inputs=cnn_model.input, outputs=[pred, normalized_global_pool])
# model compile
if args.USE_Semihard:
triplet_loss = tripletSemihardloss
else:
triplet_loss = triplet_hard_loss
optimizer = opt_ways[args.optimizer](learning_rate=args.learning_rate)
if args.USE_Label_Smoothing:
triplet_model.compile(loss=[cross_entropy_label_smoothing, triplet_loss], optimizer=optimizer,
loss_weights=[1, 1],
metrics=['accuracy'])
else:
triplet_model.compile(loss=['categorical_crossentropy', triplet_loss], optimizer=optimizer,
loss_weights=[1, 1],
metrics=['accuracy'])
#triplet_model.load_weights('triplet_hard_weights.h5')
triplet_model.summary()
# save model
model_path = os.path.join(args.log_dir, 'triplet_semihard_weights.h5')
checkpoint = ModelCheckpoint(model_path, monitor='val_dense_accuracy',
verbose=1, save_best_only=True, mode='auto')
reduce_lr = LearningRateScheduler(lr_decay_warmup, verbose=1)
# data loader
train_generator = generator_batch_triplet_hard(train_img_path, train_person_ids,
num_person_ids, args.img_width, args.img_height, args.batch_size, args.num_instances,
shuffle=True, aug=True)
val_generator = generator_batch_triplet_hard(val_img_path, val_person_ids,
num_person_ids, args.img_width, args.img_height, args.batch_size, args.num_instances,
shuffle=False, aug=False)
# fit data to model
history = triplet_model.fit(
train_generator,
steps_per_epoch=len(train_img_path)//args.batch_size,
validation_data=val_generator,
validation_steps=len(val_img_path)//args.batch_size,
verbose=2,
shuffle=True,
epochs=args.num_epochs,
callbacks=[checkpoint, reduce_lr])
#print(history.history)
# Plot training & validation accuracy and loss values
fig, ax = plt.subplots(2,1)
ax[0].plot(history.history['dense_loss'], color='b', label='cross-entropy loss')
ax[0].plot(history.history['triplet_loss'], color='r', label='triplet loss')
ax[0].plot(history.history['val_dense_loss'], color='g', label='val cross-entropy loss')
ax[0].plot(history.history['val_triplet_loss'], color='y', label='val triplet loss')
legend = ax[0].legend(loc='best', shadow=True)
ax[1].plot(history.history['dense_accuracy'], color='b', label='Training accuracy')
ax[1].plot(history.history['val_dense_accuracy'], color='r', label='Validation accuracy')
legend = ax[1].legend(loc='best', shadow=True)
plt.savefig(os.path.join(args.log_dir, 'loss_acc_triplet_semihard.jpg'))
#evaluation
print("Evaluating model...")
Evaluate(args, model_path=model_path, batch_size=32)
mask = tf.math.logical_not(tf.math.equal(real, 0))
mask = tf.expand_dims(tf.cast(mask, dtype=pred.dtype), axis=-1)
pred *= mask
acc = train_accuracy(real, pred)
return tf.reduce_mean(acc)
model = Transformer(**kargs) # dictionary로 다룸
model.compile(optimizer=tf.keras.optimizers.Adam(1e-4),
loss=loss,
metrics=[accuracy])
# Callback 선언
# overfitting을 막기 위한 ealrystop 추가
earlystop_callback = EarlyStopping(monitor='val_accuracy', min_delta=0.0001, patience=10)
# min_delta: the threshold that triggers the termination (acc should at least improve 0.0001)
# patience: no improvment epochs (patience = 1, 1번 이상 상승이 없으면 종료)
checkpoint_path = DATA_OUT_PATH + model_name + '/weights.h5'
checkpoint_dir = os.path.dirname(checkpoint_path)
# Create path if exists
if os.path.exists(checkpoint_dir):
print("{} -- Folder already exists \n".format(checkpoint_dir))
else:
os.makedirs(checkpoint_dir, exist_ok=True)
print("{} -- Folder create complete \n".format(checkpoint_dir))
cp_callback = ModelCheckpoint(
checkpoint_path, monitor='val_accuracy', verbose=1, save_best_only=True, save_weights_only=True)
train_label = to_categorical(train_label, len(constants.CATE_LIST))
print('train_shape: ', train_data.shape)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=[
tf.keras.metrics.categorical_accuracy,
tf.keras.metrics.Recall()
])
cur_time = int(time.strftime('%Y%m%d%H%M', time.localtime(time.time())))
model_path = '../../model/CNN_model/{}.h5'.format(cur_time)
log_name = '{}'.format(cur_time)
model_saver = ModelCheckpoint(filepath=model_path,
verbose=2,
save_best_only=True)
early_stopper = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=100,
verbose=2,
mode='min',
baseline=None,
restore_best_weights=True)
tensor_board = TensorBoard(log_dir=r'..\..\log\{}'.format(log_name))
result = model.fit(train_data,
train_label,
batch_size=128,
def _main(path_dataset,
path_anchors,
path_weights=None,
path_output='.',
path_config=None,
path_classes=None,
nb_gpu=1,
**kwargs):
config = load_config(path_config, DEFAULT_CONFIG)
anchors = get_anchors(path_anchors)
nb_classes = get_nb_classes(path_dataset)
logging.info('Using %i classes', nb_classes)
_export_classes(get_dataset_class_names(path_dataset, path_classes),
path_output)
# make sure you know what you freeze
model, bottleneck_model, last_layer_model = create_model_bottleneck(
config['image-size'],
anchors,
nb_classes,
freeze_body=2,
weights_path=path_weights,
nb_gpu=nb_gpu)
# if create blank use image-size, else take loaded from model file
config['image-size'] = model._input_layers[0].input_shape[1:3]
log_tb = TensorBoard(log_dir=path_output)
checkpoint = ModelCheckpoint(os.path.join(path_output, NAME_CHECKPOINT),
monitor='val_loss',
save_weights_only=True,
save_best_only=True,
period=3)
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=3,
verbose=1)
early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=10,
verbose=1)
lines_train, lines_valid, num_val, num_train = load_training_lines(
path_dataset, config['valid-split'])
# Train with frozen layers first, to get a stable loss.
# Adjust num epochs to your dataset. This step is enough to obtain a not bad model.
_yolo_loss = lambda y_true, y_pred: y_pred # use custom yolo_loss Lambda layer.
_data_gene_bottleneck = partial(
generator_bottleneck,
batch_size=config['batch-size']['bottlenecks'],
input_shape=config['image-size'],
anchors=anchors,
nb_classes=nb_classes,
**config['generator'])
_data_generator = partial(data_generator,
input_shape=config['image-size'],
anchors=anchors,
nb_classes=nb_classes,
**config['generator'])
epochs_head = config['epochs'].get('head', 0)
epochs_btnc = config['epochs'].get('bottlenecks', 0)
if epochs_btnc > 0 or epochs_head > 0:
# perform bottleneck training
path_bottlenecks = os.path.join(path_output, NAME_BOTTLENECKS)
if not os.path.isfile(
path_bottlenecks) or config['recompute-bottlenecks']:
logging.info('calculating bottlenecks')
bottlenecks = bottleneck_model.predict_generator(
_data_generator(
lines_train + lines_valid,
randomize=False,
batch_size=config['batch-size']['bottlenecks']),
steps=(len(lines_train + lines_valid) //
config['batch-size']['bottlenecks']) + 1,
max_queue_size=1)
np.savez(path_bottlenecks,
bot0=bottlenecks[0],
bot1=bottlenecks[1],
bot2=bottlenecks[2])
# load bottleneck features from file
dict_bot = np.load(path_bottlenecks)
bottlenecks_train = [
dict_bot[bot_][:num_train] for bot_ in ("bot0", "bot1", "bot2")
]
bottlenecks_val = [
dict_bot[bot_][num_train:] for bot_ in ("bot0", "bot1", "bot2")
]
# train last layers with fixed bottleneck features
logging.info(
'Training last layers with bottleneck features '
'with %i samples, val on %i samples and batch size %i.', num_train,
num_val, config['batch-size']['bottlenecks'])
last_layer_model.compile(optimizer='adam',
loss={'yolo_loss': _yolo_loss})
t_start = time.time()
last_layer_model.fit_generator(
_data_gene_bottleneck(lines_train, bottlenecks=bottlenecks_train),
steps_per_epoch=max(
1, num_train // config['batch-size']['bottlenecks']),
validation_data=_data_gene_bottleneck(lines_valid,
bottlenecks=bottlenecks_val),
validation_steps=max(
1, num_val // config['batch-size']['bottlenecks']),
epochs=epochs_btnc,
initial_epoch=0,
max_queue_size=1)
_export_model(model, path_output, '', '_bottleneck')
# train last layers with random augmented data
model.compile(optimizer=Adam(lr=1e-3),
loss={'yolo_loss':
_yolo_loss}) # use custom yolo_loss Lambda layer.
logging.info(
'Train on %i samples, val on %i samples, with batch size %i.',
num_train, num_val, config['batch-size']['head'])
t_start = time.time()
model.fit_generator(
_data_generator(lines_train,
batch_size=config['batch-size']['head']),
steps_per_epoch=max(1, num_train // config['batch-size']['head']),
validation_data=_data_generator(
lines_valid, batch_size=config['batch-size']['head']),
validation_steps=max(1, num_val // config['batch-size']['head']),
epochs=epochs_btnc + epochs_head,
initial_epoch=epochs_btnc,
callbacks=[log_tb, checkpoint])
logging.info('Training took %f minutes', (time.time() - t_start) / 60.)
_export_model(model, path_output, '', '_head')
# Unfreeze and continue training, to fine-tune.
# Train longer if the result is not good.
if config['epochs'].get('full', 0) > 0:
for i in range(len(model.layers)):
model.layers[i].trainable = True
model.compile(optimizer=Adam(lr=1e-4),
loss={
'yolo_loss': lambda y_true, y_pred: y_pred
}) # recompile to apply the change
logging.info('Unfreeze all of the layers.')
# note that more GPU memory is required after unfreezing the body
logging.info(
'Train on %i samples, val on %i samples, with batch size %i.',
num_train, num_val, config['batch-size']['full'])
t_start = time.time()
model.fit_generator(
_data_generator(lines_train,
batch_size=config['batch-size']['full']),
steps_per_epoch=max(1, num_train // config['batch-size']['full']),
validation_data=_data_generator(
lines_valid, batch_size=config['batch-size']['full']),
validation_steps=max(1, num_val // config['batch-size']['full']),
epochs=epochs_btnc + epochs_head + config['epochs']['full'],
initial_epoch=epochs_btnc + epochs_head,
callbacks=[log_tb, checkpoint, reduce_lr, early_stopping])
logging.info('Training took %f minutes', (time.time() - t_start) / 60.)
_export_model(model, path_output, '', '_full')
model = Model(inputs=[y_in, y_err], outputs=h_dec)
model.compile(optimizer=Adam(clipvalue=0.5), loss=chi2(y_err))
# model.load_weights("../../model_weights/model_2020-03-11_20-34-12.h5")
training_time_stamp = datetime.datetime.now(
tz=pytz.timezone('Europe/London')).strftime("%Y-%m-%d_%H-%M-%S")
CB = EarlyStopping(monitor='val_loss',
min_delta=5e-5,
patience=100,
verbose=1,
mode='auto')
MC = ModelCheckpoint(
'../../model_weights/model_{}.h5'.format(training_time_stamp),
monitor='val_loss',
mode="auto",
save_best_only=True,
verbose=1)
history = model.fit_generator(training_generator,
epochs=8000,
verbose=2,
callbacks=[MC, CB],
validation_data=validation_generator)
np.savetxt("training_history/loss_history-{}.txt".format(training_time_stamp),
[
np.asarray(history.history["loss"]),
np.asarray(history.history["val_loss"])
],
delimiter=",")
def learn(self, symbol_list):
if self.args.image == "generate":
for symbol in symbol_list:
start_time = time.time()
print("Starting to generate images for: ", symbol)
GenerateImagesNoHold.generate_buy_sell_images(
symbol, str(self.from_date), str(self.to_date))
end_time = time.time()
print("Generated images for stocks: ", symbol, " in: ",
(end_time - start_time), " seconds")
training_data = []
for symbol in symbol_list:
for category in self.categories:
path = os.path.join(Constants.IMAGE_DIR,
category.value + "/" + symbol)
class_num = self.categories.index(category)
for img in os.listdir(path):
try:
img_arr = cv2.imread(os.path.join(path, img),
cv2.IMREAD_GRAYSCALE)
resized_arr = cv2.resize(
img_arr, (self.IMG_SIZE, self.IMG_SIZE))
training_data.append([resized_arr, class_num])
except Exception as e:
print(e)
random.shuffle(training_data)
X = []
y = []
for features, labels in training_data:
X.append(features)
y.append(labels)
X = np.array(X).reshape(-1, self.IMG_SIZE, self.IMG_SIZE, 1)
y = np.array(y)
self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(
X, y, test_size=.3)
self.X_train = self.X_train / 255.0
model = Sequential()
model.add(Conv2D(128, (3, 3), input_shape=X.shape[1:]))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(32))
model.add(Activation("relu"))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(
loss="binary_crossentropy",
optimizer="rmsprop",
metrics=['accuracy'],
)
model_save_path = Constants.MODEL_DIR + symbol + Constants.MODEL_EXTENSION
model_cp = ModelCheckpoint(model_save_path,
monitor='val_loss',
verbose=0,
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
lr_callback = LearningRateScheduler(self.lr_schedule)
model.fit(
self.X_train,
self.y_train,
batch_size=16,
epochs=self.EPOCHS,
validation_split=0.2,
callbacks=[self.tensorboard, model_cp, self.early_stopping])
val_loss, val_acc = model.evaluate(self.X_test, self.y_test)
print('Accuracy for ', symbol, ": ", val_loss, val_acc)
model.save(model_save_path)
accuracy = False
if accuracy:
# TENSORBOARD CODE
train_dataset = tf.data.Dataset.from_tensor_slices(
(self.X_train, self.y_train / 1.0))
test_dataset = tf.data.Dataset.from_tensor_slices(
(self.X_test / 255.0, self.y_test / 1.0))
train_dataset = train_dataset.shuffle(60000).batch(64)
test_dataset = test_dataset.batch(64)
current_time = datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
train_summary_writer = tf.summary.create_file_writer(
'logs/{}'.format(self.NAME) + '/train')
test_summary_writer = tf.summary.create_file_writer(
'logs/{}'.format(self.NAME) + '/test')
for epoch in range(self.EPOCHS):
for (x_train, y_train) in train_dataset:
self.train_step(model, self.optimizer, x_train,
y_train)
with train_summary_writer.as_default():
tf.summary.scalar('loss',
self.train_loss.result(),
step=epoch)
tf.summary.scalar('accuracy',
self.train_accuracy.result(),
step=epoch)
for (x_test, y_test) in test_dataset:
self.test_step(model, x_test, y_test)
with test_summary_writer.as_default():
tf.summary.scalar('loss',
self.test_loss.result(),
step=epoch)
tf.summary.scalar('accuracy',
self.test_accuracy.result(),
step=epoch)
template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
print(
template.format(epoch + 1, self.train_loss.result(),
self.train_accuracy.result() * 100,
self.test_loss.result(),
self.test_accuracy.result() * 100))
# Reset metrics every epoch
self.train_loss.reset_states()
self.test_loss.reset_states()
self.train_accuracy.reset_states()
self.test_accuracy.reset_states()
tuning = False
if tuning:
with tf.summary.create_file_writer(
'logs/hparam_tuning').as_default():
hp.hparams_config(
hparams=[
self.HP_NUM_UNITS, self.HP_DROPOUT,
self.HP_OPTIMIZER, self.HP_ACTIVATION
],
metrics=[
hp.Metric(self.METRIC_ACCURACY,
display_name='Accuracy')
],
)
session_num = 0
for num_units in self.HP_NUM_UNITS.domain.values:
for dropout_rate in (self.HP_DROPOUT.domain.min_value,
self.HP_DROPOUT.domain.max_value):
for optimizer in self.HP_OPTIMIZER.domain.values:
for activation in self.HP_ACTIVATION.domain.values:
hparams = {
self.HP_NUM_UNITS: num_units,
self.HP_DROPOUT: dropout_rate,
self.HP_OPTIMIZER: optimizer,
self.HP_ACTIVATION: activation
}
run_name = "run-%d" % session_num
print('--- Starting trial: %s' % run_name)
print({h.name: hparams[h] for h in hparams})
self.run('logs/hparam_tuning/' + run_name,
hparams)
session_num += 1
def run_model(data):
#final_mse = np.empty((len(split)))
final_rmse = []
for temp_split in split:
x_data = data.values
y_data = df_targets.values.reshape(-1,1)
num_data = len(x_data)
train_split = temp_split
num_train = int(train_split * num_data)
num_test = num_data - num_train
x_train = x_data[0:num_train]
x_test = x_data[num_train:]
y_train = y_data[0:num_train]
y_test = y_data[num_train:]
num_x_signals = x_data.shape[1]
num_y_signals = y_data.shape[1]
x_scaler = MinMaxScaler()
x_train_scaled = x_scaler.fit_transform(x_train)
x_test_scaled = x_scaler.transform(x_test)
y_scaler = MinMaxScaler()
y_train_scaled = y_scaler.fit_transform(y_train)
y_test_scaled = y_scaler.transform(y_test)
batch_size = 256
sequence_length = 100
generator = batch_generator(batch_size, sequence_length, num_x_signals, num_y_signals, num_train, x_train_scaled, y_train_scaled)
validation_data = (np.expand_dims(x_test_scaled, axis=0), np.expand_dims(y_test_scaled, axis=0))
model = Sequential()
model.add(GRU(units=512,
return_sequences=True,
input_shape=(None, num_x_signals,)))
model.add(Dense(num_y_signals, activation='sigmoid'))
if False:
from tensorflow.python.keras.initializers import RandomUniform
# Maybe use lower init-ranges.
init = RandomUniform(minval=-0.05, maxval=0.05)
model.add(Dense(num_y_signals,
activation='linear',
kernel_initializer=init))
optimizer = RMSprop(lr=1e-3)
model.compile(loss=loss_mse_warmup, optimizer=optimizer, metrics = ['mse'])
path_checkpoint = 'best_model'
callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint, monitor='val_loss', verbose=1, save_weights_only=True, save_best_only=True)
callback_early_stopping = EarlyStopping(monitor='val_loss', patience=3, verbose=1)
callbacks = [callback_checkpoint, callback_early_stopping]
model.fit(x=generator,
epochs=1,
steps_per_epoch=100,
validation_data=validation_data,
callbacks = callbacks)
try:
model.load_weights(path_checkpoint)
print('Success')
except Exception as error:
print("Error trying to load checkpoint.")
print(error)
# Input-signals for the model.
x = np.expand_dims(x_test_scaled, axis=0)
# Use the model to predict the output-signals.
y_pred = model.predict(x)
y_pred_rescaled = y_scaler.inverse_transform(y_pred[0])
out_rmse = np.sqrt(mean_squared_error(y_test,y_pred_rescaled))
print(out_rmse)
#final_mse = np.append(final_mse, out_mse)
final_rmse.append(out_rmse)
return_final_rmse = np.array(final_rmse)
return return_final_rmse
def start(self):
""" Loading training data """
print("\n-------------- Available training data --------------")
trainCaptions, trainFeatures = self.utils.dataLoader(
configuration['trainImagePath'])
""" Loading validation data """
print("------------- Available validation data -------------")
valCaptions, valFeatures = self.utils.dataLoader(
configuration['validationImagePath'])
""" Generating tokens for training data and largest caption length"""
print("\n----------------------------------------------------")
maxCaption = self.utils.maxLengthOfCaption(trainCaptions)
print("Length of largest caption of training: ", maxCaption)
if not os.path.exists(configuration['featuresPath'] + 'tokenizer.pkl'):
self.utils.createTokenizer(trainCaptions)
print("Tokenizer file generated")
else:
print('Tokenizer file already present at %s' %
(configuration['featuresPath'] + 'tokenizer.pkl'))
tokenizer = load(
open(configuration['featuresPath'] + 'tokenizer.pkl', 'rb'))
vocabSize = len(tokenizer.word_index) + 1
print('Training vocabulary Size: %d' % vocabSize)
print("\n----------------------------------------------------")
stepsToTrain = round(len(trainFeatures) / configuration['batchSize'])
stepsToVal = round(len(valFeatures) / configuration['batchSize'])
print("Batch size: %d" % configuration['batchSize'])
print("epochs: %d" % configuration['epochs'])
print("Steps per epoch for training: %d" % stepsToTrain)
print("Steps per epoch for validation: %d\n" % stepsToVal)
model = self.utils.captionModel(vocabSize, maxCaption,
configuration['CNNmodelType'],
configuration['RNNmodelType'])
print(model.summary())
"To plot a model Image"
# plot_model(model, "caption_model.png", show_shapes=True) # works on colab only
"The modified caption model"
# model = self.utils.updatedCaptionModel(vocabSize, maxCaption, configuration['CNNmodelType'], configuration['RNNmodelType'])
# print('\nRNN Model Summary : ')
modelSavePath = configuration['modelsPath'] + "model_" + str(
configuration['CNNmodelType']
) + "_" + str(
configuration['RNNmodelType']
) + "_epoch-{epoch:02d}_train_loss-{loss:.4f}_val_loss-{val_loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(modelSavePath,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
# logdir = "logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
# tensorboardCallback = TensorBoard(log_dir=logdir, histogram_freq=1)
# callbacks = [checkpoint, tensorboardCallback]
callbacks = [checkpoint]
if configuration['batchSize'] <= len(trainCaptions.keys()):
trainingDataGen = self.utils.dataGenerator(
trainFeatures, trainCaptions, tokenizer, maxCaption,
configuration['batchSize'])
validationDataGen = self.utils.dataGenerator(
valFeatures, valCaptions, tokenizer, maxCaption,
configuration['batchSize'])
""" Use to train the saved model """
# model_path(configuration['CNNmodelType'])
# print(configuration['loadModelPath'])
# model = load_model(configuration['loadModelPath'])
""" Training the model """
history = model.fit(trainingDataGen,
epochs=configuration['epochs'],
steps_per_epoch=stepsToTrain,
validation_data=validationDataGen,
validation_steps=stepsToVal,
callbacks=callbacks,
verbose=1)
print("Model trained successfully.")
# list all data in history
print(history.history)
fName = configuration['modelsPath'] + "history/" + configuration[
'CNNmodelType'] + "_" + configuration[
'RNNmodelType'] + "_" + 'model_history.txt'
file = open(fName, 'w')
file.write(str(history.history) + '\n')
file.close()
# summarize history for loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.show()
# summarize history for accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.show()
else:
print("Batch size must be less than or equal to " +
list(trainCaptions.keys()))
"""### GRU 모델로 학습하기"""
from tensorflow.keras.layers import Embedding, Dense, GRU
from tensorflow.keras.models import Sequential
from tensorflow.keras.models import load_model
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
model = Sequential()
model.add(Embedding(vocab_size, 100))
model.add(GRU(128))
model.add(Dense(1, activation='sigmoid')) # 다중분류가 아니니 softmax X
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4)
mc = ModelCheckpoint('best_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True)
# compile
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
history = model.fit(x_train, y_train, epochs= 30, callbacks=[es, mc], batch_size = 60, validation_split=0.2)
loaded_model = load_model('best_model.h5')
print('\n 테스트 정확도 : %.4f'% (loaded_model.evaluate(x_test, y_test)[1]))
"""## 리뷰 예측하기"""
def sentiment_predict(new_sentence):
new_sentence = mecab.morphs(new_sentence) #토큰화
new_sentence = [word for word in new_sentence if not word in stopwords] #불용어 제거
encoded = tokenizer.texts_to_sequences([new_sentence])
pad_new = pad_sequences(encoded, maxlen=max_len) # 패딩
r_layer = Concatenate()(conv_feature_maps)
r_layer = Dropout(rate=0.5)(r_layer)
y_output = Dense(250, activation='relu')(r_layer)
y_output = Dense(1, activation='sigmoid')(r_layer)
model = Model(x_input, y_output)
model.compile(loss='binary_crossentropy',
optimizer=Adam(learning_rate=0.0005),
metrics=['accuracy'])
model.summary()
# 학습
es = EarlyStopping(monitor='val_accuracy', min_delta=0.0001, patience=2)
cp = ModelCheckpoint(filepath='./',
monitor='val_accuracy',
verbose=1,
save_best_only=True,
save_weights_only=True)
hist = model.fit(x_train,
y_train,
validation_data=(x_val, y_val),
batch_size=512,
epochs=30,
callbacks=[es, cp])
# Loss history를 그린다
plt.plot(hist.history['loss'], label='Train loss')
plt.plot(hist.history['val_loss'], label='Test loss')
plt.legend()
plt.title("Loss history")
plt.xlabel("epoch")
def training(path_save_spectrogram, weights_path, name_model,
training_from_scratch, epochs, batch_size):
""" This function will read noisy voice and clean voice spectrograms created by data_creation mode,
and train a Unet model on this dataset for epochs and batch_size specified. It saves best models to disk regularly
If training_from_scratch is set to True it will train from scratch, if set to False, it will train
from weights (name_model) provided in weights_path
"""
#load noisy voice & clean voice spectrograms created by data_creation mode
X_in = np.load(path_save_spectrogram + 'noisy_voice_amp_db' + ".npy")
X_ou = np.load(path_save_spectrogram + 'voice_amp_db' + ".npy")
#Model of noise to predict
X_ou = X_in - X_ou
#Check distribution
print(stats.describe(X_in.reshape(-1, 1)))
print(stats.describe(X_ou.reshape(-1, 1)))
#to scale between -1 and 1
X_in = scaled_in(X_in)
X_ou = scaled_ou(X_ou)
#Check shape of spectrograms
print(X_in.shape)
print(X_ou.shape)
#Check new distribution
print(stats.describe(X_in.reshape(-1, 1)))
print(stats.describe(X_ou.reshape(-1, 1)))
#Reshape for training
X_in = X_in[:, :, :]
X_in = X_in.reshape(X_in.shape[0], X_in.shape[1], X_in.shape[2], 1)
X_ou = X_ou[:, :, :]
X_ou = X_ou.reshape(X_ou.shape[0], X_ou.shape[1], X_ou.shape[2], 1)
X_train, X_test, y_train, y_test = train_test_split(X_in,
X_ou,
test_size=0.10,
random_state=42)
#If training from scratch
if training_from_scratch:
generator_nn = unet()
#If training from pre-trained weights
else:
generator_nn = unet(pretrained_weights=weights_path + name_model +
'.h5')
#Save best models to disk during training
checkpoint = ModelCheckpoint(weights_path + '/model_best.h5',
verbose=1,
monitor='val_loss',
save_best_only=True,
mode='auto')
generator_nn.summary()
#Training
history = generator_nn.fit(X_train,
y_train,
epochs=epochs,
batch_size=batch_size,
shuffle=True,
callbacks=[checkpoint],
verbose=1,
validation_data=(X_test, y_test))
#Plot training and validation loss (log scale)
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, label='Training loss')
plt.plot(epochs, val_loss, label='Validation loss')
plt.yscale('log')
plt.title('Training and validation loss')
plt.legend()
plt.show()
model.add(Dense(1))
model.summary()
model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate,
beta_1=beta1,
beta_2=beta2,
epsilon=epsilon,
decay=weight_decay),
loss=brLoss(batch_size),
metrics=[evalLoss, Pearson, Spearman, Kendall])
csv_logger = CSVLogger("model_history_log.csv", append=True)
checkpoint = ModelCheckpoint("model.hdf5",
monitor='val_loss',
verbose=1,
save_best_only=False,
mode='min')
model.fit(x_train,
y_train,
epochs=epochs,
batch_size=batch_size,
validation_data=(x_val, y_val),
callbacks=[csv_logger, checkpoint])
test = np.random.random((1, 20, 20, 20, 12))
prediction = model.predict(test)
print(prediction)
'''
ORIGINAL UNCAHNGED MODEL. DON'T DELETE
model.compile(loss='sparse_categorical_crossentropy',
optimizer=hp.Choice('optimizer', ['adam', 'sgd', 'rmsprop']),
metrics=['accuracy'])
return model
#%%
### Callback functions
ckpt_dir = 'logs/ktuner/checkpoints/' + datetime.now().strftime(
'%Y%m%d-%H%M%S')
os.mkdir(ckpt_dir)
path_checkpoint = ckpt_dir + datetime.now().strftime('%Y%m%d-%H%M%S') + '.ckpt'
callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint,
monitor='val_loss',
verbose=1,
save_weights_only=True,
save_best_only=True)
callback_early_stopping = EarlyStopping(monitor='val_loss',
patience=15,
verbose=1)
log_dir = 'logs/ktuner/fit/' + datetime.now().strftime('%Y%m%d-%H%M%S')
callback_tensorboard = TensorBoard(log_dir=log_dir,
histogram_freq=1,
write_graph=False)
callback_reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
model.summary()
model.save('C:/nmb/nmb_data/h5/5s/0601/DNN_lstm_2.h5')
# 컴파일, 훈련
op = Adadelta(lr=1e-2)
batch_size = 32
es = EarlyStopping(monitor='val_loss',
patience=20,
restore_best_weights=True,
verbose=1)
lr = ReduceLROnPlateau(monitor='val_loss', vactor=0.5, patience=10, verbose=1)
path = 'C:/nmb/nmb_data/h5/5s/0601/DNN_lstm_2.h5'
mc = ModelCheckpoint(path, monitor='val_loss', verbose=1, save_best_only=True)
model.compile(optimizer=op,
loss="sparse_categorical_crossentropy",
metrics=['acc'])
history = model.fit(x_train,
y_train,
epochs=5000,
batch_size=batch_size,
validation_split=0.2,
callbacks=[es, lr, mc])
# 평가, 예측
# model = load_model('C:/nmb/nmb_data/h5/5s/0601/DNN_lstm_2.h5')
model.load_weights('C:/nmb/nmb_data/h5/5s/0601/DNN_lstm_2.h5')
result = model.evaluate(x_test, y_test, batch_size=32)
def train_data(iq, symbol, symbols, timeframe):
df = iq_get_data(iq, symbol, symbols, timeframe)
# df.to_csv(r'EURUSD.csv')
df = Indicators(df)
df.isnull().sum().sum() # there are no nans
df.fillna(method="ffill", inplace=True)
df = df.loc[~df.index.duplicated(keep='first')]
df['future'] = df["GOAL"].shift(-predict_period)
#df = df.drop(columns = {'open','min','max'})
df = df.dropna()
dataset = df.fillna(method="ffill")
dataset = dataset.dropna()
dataset.sort_index(inplace=True)
main_df = dataset
main_df.fillna(method="ffill", inplace=True)
main_df.dropna(inplace=True)
main_df['target'] = list(map(classify, main_df['GOAL'], main_df['future']))
main_df.dropna(inplace=True)
main_df['target'].value_counts()
main_df.dropna(inplace=True)
main_df = main_df.astype('float32')
if VALIDATION_TRAIN:
times = sorted(main_df.index.values)
last_5pct = sorted(main_df.index.values)[-int(0.1 * len(times))]
validation_main_df = main_df[(main_df.index >= last_5pct)]
main_df = main_df[(main_df.index < last_5pct)]
train_x, train_y = preprocess_df(main_df)
validation_x, validation_y = preprocess_df(validation_main_df)
print(f"train data: {len(train_x)} validation: {len(validation_x)}")
print(f"sells: {train_y.count(0)}, buys: {train_y.count(1)}")
print(
f"VALIDATION sells: {validation_y.count(0)}, buys : {validation_y.count(1)}"
)
train_y = np.asarray(train_y)
validation_y = np.asarray(validation_y)
else:
train_x, train_y = preprocess_df(main_df)
print(f"train data: {len(train_x)}")
print(f"sells: {train_y.count(0)}, buys: {train_y.count(1)}")
train_y = np.asarray(train_y)
NAME = f"{LEARNING_RATE}-{seq_len}-SEQ-{predict_period}-{EPOCHS}-{BATCH_SIZE}-PRED-{int(time.time())}"
earlyStoppingCallback = tf.keras.callbacks.EarlyStopping(
monitor='loss', patience=EARLYSTOP)
model = Sequential()
model.add(
LSTM(NEURONS, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.1))
model.add(BatchNormalization())
model.add(LSTM(NEURONS, return_sequences=True))
model.add(Dropout(0.1))
model.add(BatchNormalization())
model.add(LSTM(NEURONS))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(NEURONS, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(2, activation='softmax'))
opt = tf.keras.optimizers.Adam(lr=LEARNING_RATE)
# Compile model
model.compile(loss='sparse_categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))
filepath = "ThesisBrain"
if VALIDATION_TRAIN:
checkpoint = ModelCheckpoint("models/{}.h5".format(filepath),
monitor='val_accuracy',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='max')
# Train model
model.fit(
train_x,
train_y,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
validation_data=(validation_x, validation_y),
callbacks=[tensorboard, checkpoint, earlyStoppingCallback],
)
else:
checkpoint = ModelCheckpoint("models/{}.h5".format(filepath),
monitor='accuracy',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='max')
# Train model
model.fit(
train_x,
train_y,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks=[tensorboard, checkpoint, earlyStoppingCallback],
)
return filepath
