def test(train_data_dir):
# Prepare data augmentation configuration
train_generator = DataGenerator(train_data_dir, TRAIN, **params)
val_generator = DataGenerator(train_data_dir, VAL, **params)
test_dataset(train_generator)
test_dataset(val_generator)
def evaluate(lang='pt'):
X, Y = util.get_X_Y(data_type='keras_tokenized_tri', lang=lang, file_type="dump")
X = np.asarray(X)
data_generator = DataGenerator(X,Y, lang=lang, process_x=process_x, batch_size=PARAMS['batch_size'])
model, epoch = load_lastest(lang=lang)
x_val, y_val = data_generator.get_validation_data()
y_pred = model.predict(x_val)
y_pred = y_pred.argmax(axis=-1)
print('Model '+NAME+' val score on '+lang+': ', util.evaluate(y_val, y_pred))
def train(lang='pt'):
params = PARAMS.copy()
initial_epoch = 0
X, Y = util.get_X_Y(data_type='keras_tokenized_tri', lang=lang, file_type="dump")
X = np.asarray(X)
params['embedding_matrix'] = load_embedding_matrix(name="fasttext_sg_tri_8", tokenizer='keras_tokenized_tri',lang=lang, model_type="dump")
params["vocab_size"] = params['embedding_matrix'].shape[0]
params["embedding_dim"] = params['embedding_matrix'].shape[1]
if not os.path.exists(PATH):
os.makedirs(PATH)
if not os.path.exists(PATH+'log_dir'):
os.makedirs(PATH+'log_dir')
#params["loss"] = util.focal_loss(gamma=5.,alpha=1588)
lastest_model = load_lastest(lang=lang)
if(lastest_model == None):
model, params = generate_model(params)
else:
model = lastest_model[0]
initial_epoch = lastest_model[1]
print(model.metrics_names)
params['sampler'] = FunctionSampler(func=balance_dataset,
kw_args={'cut_off': 0.5,
'random_state': 42})
data_generator = DataGenerator(X,Y, lang=lang, process_x=process_x, process_y=process_y, batch_size=PARAMS['batch_size'], sampler=params['sampler'])
#data_generator.remove_reliable_0(pct=1.0)
validation_data = data_generator.get_validation_data()
print('data_generator.x: ', data_generator.__getitem__(0)[0][0:5])
print('data_generator.y: ', data_generator.__getitem__(0)[1][0:5])
#params["class_weights"]= data_generator.get_classes_weights()
reduce_lr = ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.2, patience=3, verbose=1)
early_stopping = EarlyStopping(monitor='val_categorical_accuracy', min_delta=0.02, patience=10, verbose=1)
csv_logger = CSVLogger(PATH+'traning.log', append=True)
tensorboard_callback = TensorBoard(log_dir=PATH+'log_dir', batch_size=params["batch_size"])
model_checkpoint = ModelCheckpoint(filepath=PATH+'weights-{epoch:03d}-{val_categorical_accuracy:.4f}-'+lang+'.hdf5',
monitor='val_categorical_accuracy',
verbose=1,
mode='max')
params["callbacks"] = [model_checkpoint, early_stopping, tensorboard_callback, csv_logger, reduce_lr]
model.fit_generator(data_generator,
epochs=params["epochs"],
verbose=1,
callbacks=params["callbacks"],
validation_data=validation_data,
#workers=7,
#use_multiprocessing=True,
class_weight=params["class_weights"],
initial_epoch=initial_epoch)
def get_eval_op():
dataset = DataGenerator(
sample_range=config.eval_samples,
shuffle_samples=True,
max_patches_per_sample=config.max_patches_per_sample
).make_dataset(
split_lhs_rhs=False
)
X, Y = dataset.make_one_shot_iterator().get_next()
ops = model_eval(X, Y, params={'n_candidates': tf.constant(config.n_candidates)})
return ops
def get_train_op_old():
dataset = DataGenerator(
sample_range=config.train_samples, # we have 236 samples
shuffle_samples=True,
max_patches_per_sample=config.max_patches_per_sample
).make_dataset(
split_lhs_rhs=True
)
lhs, lhs_label, rhs, rhs_label = dataset.make_one_shot_iterator().get_next()
ops = model_train(lhs, lhs_label, rhs, rhs_label, params={'n_candidates': tf.constant(config.n_candidates)})
return ops
def get_object_confusion(class1, class2, similarity_model, config):
model_config = config['model']
benchmark_config = config['benchmark']
model_path = model_config['model_filename']
dataset_path = benchmark_config['dataset_path']
params = {
'dim': model_config['input_shape'],
'batch_size': benchmark_config['batch_size'],
'shuffle': False
}
test_dataset = ImageDataset(dataset_path, 'validation')
test_dataset.prepare_specific(benchmark_config['test_cases'] // 2, class1,
class2)
test_generator = DataGenerator(test_dataset, **params)
preds = np.array([])
gts = np.array([])
for i in tqdm(range(len(test_generator))):
batch = test_generator[i]
pred = similarity_model.predict_on_batch(batch[0])
preds = np.append(preds, pred.flatten())
gts = np.append(gts, batch[1])
if benchmark_config['vis_output'] and not i % benchmark_config[
'test_cases'] // (5 * benchmark_config['batch_size']):
show_output(batch[0][0], batch[0][1], pred, batch[1])
te_acc = compute_accuracy(preds, gts)
print("Class 1: " + class1 + ", Class2: " + class2 +
", Distinguishability Score: " + str(te_acc))
return te_acc
def _main_():
args = argparser.parse_args()
config_path = args.config
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
weights_path = args.weights_path
sm_model = SMModel(config['model'])
sm_model.model.summary()
sm_model.model.load_weights(weights_path)
test_generator = DataGenerator(config=config['test'],
preprocessing=sm_model.preprocessing,
n_class=sm_model.n_class,
split='test')
encoded_pixels = []
image_id_class_id = []
for X, filenames in tqdm(list(test_generator)):
preds = sm_model.model.predict_on_batch(X)
if config['test']['tta']:
for flip_type in ['ud', 'lr', 'udlr']:
X_temp = flip(X.copy(), flip_type)
pred_temp = sm_model.model.predict_on_batch(X_temp)
preds += flip(pred_temp, flip_type)
preds /= 4
preds = postprocess(preds, config['postprocess'], True)
for i in range(len(preds)):
for j in range(4):
encoded_pixels.append(run_length_encode(preds[i, :, :, j]))
image_id_class_id.append(filenames[i] + '_{}'.format(j + 1))
df = pd.DataFrame(data=encoded_pixels,
index=image_id_class_id,
columns=['EncodedPixels'])
df.index.name = 'ImageId_ClassId'
df.to_csv('submission.csv')
def _main_():
args = argparser.parse_args()
config_path = args.config
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
sm_model = SMModel(config['model'])
oof_preds = []
oof_true_masks = []
for i in range(5):
config['train']['fold'] = i
generator = DataGenerator(config=config['train'],
preprocessing=sm_model.preprocessing,
n_class=sm_model.n_class,
split='val',
full_size_mask=True)
weithts_path = os.path.join(config['train']['save_model_folder'],
'val_best_fold_{}_weights.h5'.format(i))
sm_model.model.load_weights(weithts_path)
print('Fold {} eval begin.'.format(i))
for X, y in tqdm(list(generator)):
y_preds = sm_model.model.predict(X)
y_preds = postprocess(y_preds, config['postprocess'], True)
oof_preds.append(y_preds)
y = y[:, :, :, :4]
oof_true_masks.append(y)
oof_preds = np.concatenate(oof_preds)
oof_true_masks = np.concatenate(oof_true_masks)
cv_dice_coef = dice_coef_score(oof_true_masks, oof_preds)
print('CV Dice Coef Score: {}'.format(cv_dice_coef))
def get_generators(self, ids_train, ids_valid):
trainA_generator = DataGenerator(df=ids_train,
channel="channel_first",
apply_noise=True,
phase="train",
apply_online_aug=False,
batch_size=self.BATCH_SIZE,
n_samples=self.n_samples)
validA_generator = DataGenerator(df=ids_valid,
channel="channel_first",
apply_noise=False,
phase="valid",
apply_online_aug=False,
batch_size=self.BATCH_SIZE,
n_samples=-1)
return iter(trainA_generator), iter(validA_generator)
def load_imgs(path, size):
files = glob.glob(os.path.join(path, "*"))
imgs = []
for file in files:
img = cv2.imread(file)
img = DataGenerator.pre_process(img, size)
imgs.append(img)
return files, imgs
def get_train_op():
dg = DataGenerator(
sample_range=config.train_samples,
shuffle_samples=True,
max_patches_per_sample=config.max_patches_per_sample
)
ds = dg.make_dataset(split_lhs_rhs=False)
label_weights = dg.get_label_weights_from_dumped()
print("Label weights used: ", label_weights)
label_weights = tf.constant(label_weights, dtype=tf.float32)
X, Y = ds.make_one_shot_iterator().get_next()
ops = model_train(X, Y, params={
'n_candidates': tf.constant(config.n_candidates),
'label_weights': label_weights
})
return ops
def build_generator(self):
self.train_generator = DataGenerator(
args=self.args,
dictionary=self.dictionary,
n_classes=self.n_classes,
feature_shapes=self.feature_shapes,
n_anchors=self.n_anchors,
shuffle=True)
def split_path(list_imgs, size):
path_imgs = []
imgs = []
for file in list_imgs:
img = cv2.imread(file['path'])
img = DataGenerator.pre_process(img, size)
imgs.append(img)
path_imgs.append(file['path'])
return path_imgs, imgs
def __createDatasets(self):
if self.parameters.pretrained is None:
logging.info(
"Loading dataset with target same source and target files")
target_label = 'source'
else:
logging.info("Loading dataset with target source and target files")
target_label = 'target'
self.trainGenerator = DataGenerator(
self.parameters.train_lst,
batch_size=self.parameters.batch_size,
frame_length=self.parameters.frame_length,
target_label=target_label)
self.testGenerator = DataGenerator(
self.parameters.test_lst,
batch_size=self.parameters.batch_size,
frame_length=self.parameters.frame_length,
target_label=target_label)
def train(opt, data_type=None):
callbacks = MyCallback(opt)
if data_type == 'All_data': # data from TextDataGenerator and AI Hub
opt.num_class = len(opt.character)
df = pd.read_csv(opt.data)
xs = np.array(df['ids'])
ys = np.array(df['labels'])
# train/valid split and shuffle
train_x, valid_x, train_y, valid_y = train_test_split(xs, ys, test_size=0.01)
train_datagen = DataGeneratorByPath(train_x, train_y, opt)
valid_datagen = DataGeneratorByPath(valid_x, valid_y, opt)
else: # only data from TextDataGenerator
opt.num_class = len(opt.character)
train_datagen = DataGenerator(opt.train_data, opt)
valid_datagen = DataGenerator(opt.valid_data, opt, shuffle=False)
print(f'num class : {opt.num_class}')
model = VGG_FeatureExtractor(opt.num_class)
model.summary()
start_epoch = 0
if opt.saved_model != '':
model.load_weights(opt.saved_model)
start_epoch = int(opt.saved_model.split('/')[-1].split('_')[0])+1
print(f'load weight of {start_epoch} epoch')
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss='sparse_categorical_crossentropy',
metrics=['acc'])
model.fit(train_datagen,
initial_epoch=start_epoch,
epochs=opt.num_epochs,
validation_data=valid_datagen,
callbacks=[callbacks])
def get_test_imgs(path, size):
path_imgs = []
for root, dir, files in os.walk(path):
for file in files:
file_path = os.path.join(root, file)
path_imgs.append(file_path)
imgs = []
for file in path_imgs:
img = cv2.imread(file)
img = DataGenerator.pre_process(img, size)
imgs.append(img)
return path_imgs, imgs
def train(model, batch_size, num_epochs, model_dir=MODEL_DIR):
train_data_dirs = ['data/G_data', 'data/H_data']
train_label_files = [
'data/labels/image_boxes_G.txt', 'data/labels/image_boxes_H.txt'
]
val_data_dirs = ['data/I_data']
val_label_files = ['data/labels/image_boxes_I.txt']
train_generator = DataGenerator(train_data_dirs,
train_label_files,
batch_size,
enable_data_aug=True)
val_generator = DataGenerator(val_data_dirs,
val_label_files,
batch_size,
enable_data_aug=False)
# Check if data looks correct
# verify_data_generator(train_generator)
callbacks = [
tf.keras.callbacks.ModelCheckpoint(model_dir,
monitor='loss',
save_best_only=True,
save_weights_only=True),
# tf.keras.callbacks.EarlyStopping(monitor='loss', patience=20, verbose=1),
tf.keras.callbacks.ReduceLROnPlateau(monitor='loss',
factor=0.8,
patience=10,
min_lr=1e-6,
verbose=1),
tf.keras.callbacks.TensorBoard(log_dir=LOG_DIR, histogram_freq=0)
]
return model.fit_generator(generator=train_generator,
epochs=num_epochs,
callbacks=callbacks,
validation_data=val_generator)
def evaluate_age_mobilenet_v1_imdb_wiki():
validation_size = 1000
data = get_imdb_wiki_dataset()
addrs = data["addrs"][:validation_size]
age_labels = data["age_labels"][:validation_size]
gender_labels = data["gender_labels"][:validation_size]
num_classes = 101
batch_size = 64
imp = task_importance_weights(age_labels, num_classes)
plt.figure("Weight importance")
plt.plot(imp)
plt.show()
checkpoint_path = os.path.join(ROOT_DIR, "outputs", "checkpoints",
"age_mobilenet_v1_imdb_wiki", "ckpt.h5")
# Building Mobilenet
val_generator = DataGenerator(addrs[:validation_size],
age_labels[:validation_size], batch_size,
num_classes)
# steps_per_epoch = val_generator.n // val_generator.batch_size
loss = coral_loss(imp)
model = keras.models.load_model(
checkpoint_path,
custom_objects={
"loss": loss,
"mae_pred": mae_pred,
"Linear_1_bias": Linear_1_bias
},
)
pred = model.predict_generator(generator=val_generator)
pred = pred > 0.5
y_pred = np.sum(pred, axis=1)
mae = np.mean(np.abs(age_labels - y_pred))
print("mae: {}".format(mae))
# print(list(zip(model.metrics_names, score)))
plot(validation_size, batch_size, addrs, gender_labels, age_labels, y_pred)
def evaluate(opt):
test_datagen = DataGenerator(opt.test_data, opt, False)
opt.num_class = len(opt.character)
model = VGG_FeatureExtractor(opt.num_class)
model.summary()
if opt.saved_model == '':
print('set path of save model!')
exit()
model.load_weights(opt.saved_model)
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss='sparse_categorical_crossentropy',
metrics=['acc'])
history = model.evaluate(test_datagen)
return history
def evaluate_tut_model():
num_classes = 7
batch_size = 64
validation_size = 2500
data = get_affectnet_dataset()
train_addrs = data["training"]["addrs"][:validation_size]
train_expression_labels = data["training"][
"expression_labels"][:validation_size]
train_expression_labels[train_expression_labels > 6] = 0
val_addrs = data["validation"]["addrs"]
val_expression_labels = data["validation"]["expression_labels"]
val_expression_labels[val_expression_labels > 6] = 0
val_generator = DataGenerator(train_addrs, train_expression_labels,
batch_size, num_classes)
model = keras.models.load_model("./model.h5")
evaluation = model.evaluate_generator(val_generator, batch_size=batch_size)
print(evaluation)
def evaluate_tut_model():
data = get_audience_dataset()
addrs = data["addrs"]
age_labels = data["gender_labels"]
num_classes = 2
batch_size = 64
validation_size = 1000
# Building Mobilenet
val_generator = DataGenerator(
addrs[:validation_size], age_labels[:validation_size], batch_size, num_classes
)
# steps_per_epoch = val_generator.n // val_generator.batch_size
model = keras.models.load_model(os.path.join(ROOT_DIR, "outputs/tut/gender/model.h5"))
# evaluation = model.evaluate(X, keras.utils.to_categorical(Y), batch_size=128)
score = model.evaluate_generator(generator=val_generator)
print(list(zip(model.metrics_names, score)))
def predict(opt):
test_datagen = DataGenerator(opt.test_data, opt, False, False)
opt.num_class = len(opt.character)
model = VGG_FeatureExtractor(opt.num_class)
model.summary()
if opt.saved_model == '':
print('set path of save model!')
exit()
model.load_weights(opt.saved_model)
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss='sparse_categorical_crossentropy',
metrics=['acc'])
pred = model.predict(test_datagen)
y_pred = tf.argmax(pred, axis=1).numpy()
#print(y_pred)
print([test_datagen.idx_to_char[idx] for idx in y_pred])
return y_pred
def oof_predict(sm_model, config):
oof_preds = []
oof_true_masks = []
for i in range(5):
config['train']['fold'] = i
generator = DataGenerator(config=config['train'],
preprocessing=sm_model.preprocessing,
n_class=sm_model.n_class,
split='val',
full_size_mask=True)
weithts_path = os.path.join(config['train']['save_model_folder'],
'val_best_fold_{}_weights.h5'.format(i))
sm_model.model.load_weights(weithts_path)
print('Fold {} eval begin.'.format(i))
for X, y in tqdm(list(generator)):
y_preds = sm_model.model.predict(X)
oof_preds.append(y_preds)
y = y[:, :, :, :4]
oof_true_masks.append(y)
oof_preds = np.concatenate(oof_preds)
oof_true_masks = np.concatenate(oof_true_masks)
return oof_preds, oof_true_masks
def evaluate_7expr_mobilenet_v1_train_affectnet_model():
num_classes = 7
batch_size = 64
validation_size = 2500
data = get_affectnet_dataset()
train_addrs = data["training"]["addrs"][:validation_size]
train_expression_labels = data["training"][
"expression_labels"][:validation_size]
train_expression_labels[train_expression_labels > 6] = 0
val_addrs = data["validation"]["addrs"]
val_expression_labels = data["validation"]["expression_labels"]
val_expression_labels[val_expression_labels > 6] = 0
val_generator = DataGenerator(train_addrs, train_expression_labels,
batch_size, num_classes)
checkpoint_path = os.path.join(ROOT_DIR, "outputs", "checkpoints",
"7expr_mobilenet_v1_affectnet", "ckpt.h5")
model = keras.models.load_model(checkpoint_path)
evaluation = model.evaluate_generator(generator=val_generator)
print(list(zip(model.metrics_names, evaluation)))
def evaluate_imdb_wiki_model():
data = get_imdb_wiki_dataset()
addrs = data["addrs"]
age_labels = data["gender_labels"]
num_classes = 2
batch_size = 64
validation_size = 2500
checkpoint_path = os.path.join(
ROOT_DIR, "outputs", "checkpoints", "gender_mobilenet_v1_imdb_wiki", "ckpt-08-0.48.hdf5"
)
# Building Mobilenet
val_generator = DataGenerator(
addrs[:validation_size], age_labels[:validation_size], batch_size, num_classes
)
# steps_per_epoch = val_generator.n // val_generator.batch_size
model = keras.models.load_model(checkpoint_path)
# evaluation = model.evaluate(X, keras.utils.to_categorical(Y), batch_size=128)
score = model.evaluate_generator(generator=val_generator)
print(list(zip(model.metrics_names, score)))
def evaluate_fine_tuned_audience_model():
data = get_audience_dataset()
addrs = data["addrs"]
age_labels = data["gender_labels"]
num_classes = 2
batch_size = 64
validation_size = 1000
checkpoint_path = os.path.join(
ROOT_DIR, "outputs", "checkpoints", "gender_mobilenet_v1_audience", "ckpt-04-0.22.hdf5"
)
# Building Mobilenet
val_generator = DataGenerator(
addrs[:validation_size], age_labels[:validation_size], batch_size, num_classes
)
# steps_per_epoch = val_generator.n // val_generator.batch_size
model = keras.models.load_model(checkpoint_path)
# evaluation = model.evaluate(X, keras.utils.to_categorical(Y), batch_size=128)
score = model.predict_generator(generator=val_generator)
print(np.argmax(score, axis=1))
if __name__ == "__main__":
# get config
config, _ = get_config()
# Build Model and Reward from config
actor = Actor(config)
print("Starting training...")
with tf.Session() as sess:
tf.global_variables_initializer().run()
print_config()
solver = [] #Solver(actor.max_length)
training_set = DataGenerator(solver)
nb_epoch=2
for i in tqdm(range(nb_epoch)): # epoch i
# Get feed_dict
input_batch = training_set.train_batch(actor.batch_size, actor.max_length, actor.input_dimension)
feed = {actor.input_: input_batch}
#print(' Input \n', input_batch)
permutation, distances = sess.run([actor.positions, actor.distances], feed_dict=feed)
print(' Permutation \n',permutation)
print(' Tour length \n',distances)
variables_names = [v.name for v in tf.global_variables() if 'Adam' not in v.name]
batch_size = 64
validation_size = 1000
input_shape = (224, 224, 3)
app_id = "age_mobilenet_v1_audience"
################################################################################
# Create dataset generator
################################################################################
data = get_audience_dataset()
addrs = data["addrs"]
age_labels = data["age_labels"]
imp = task_importance_weights(age_labels, num_classes)
train_generator = DataGenerator(addrs[validation_size:],
age_labels[validation_size:], batch_size,
num_classes)
val_generator = DataGenerator(addrs[:validation_size],
age_labels[:validation_size], batch_size,
num_classes)
steps_per_epoch = train_generator.n // train_generator.batch_size
################################################################################
# Create and load mobilenet
################################################################################
model = keras.applications.mobilenet.MobileNet(input_shape=input_shape,
weights=None,
include_top=False)
x = model.output
x = keras.layers.GlobalAveragePooling2D()(x)
x = keras.layers.Dropout(0.001)(x)
def preprocess_input(x):
"""Preprocesses a numpy array encoding a batch of images.
# Arguments
x: a 4D numpy array consists of RGB values within [0, 255].
# Returns
Input array scaled to [-1.,1.]
"""
return imagenet_utils.preprocess_input(x, mode='tf')
def create_model():
return Deeplabv3(weights=None, backbone='mobilenetv2', OS=8, classes=2, input_shape=(480, 854, 4))
if __name__ == '__main__':
import keras
from keras import optimizers
# from keras.utils import plot_model
from dataset import DataGenerator
# plot_model(create_model(), show_shapes=True, to_file='mobile_net_v2.png', )
model = create_model()
# datagen = ImageDataGenerator(horizontal_flip=True, width_shift_range=0.125, height_shift_range=0.125,
# fill_mode='constant', cval=0.)
sgd = optimizers.SGD(lr=.001, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss=keras.losses.binary_crossentropy, metrics=['accuracy'])
train_datagen = DataGenerator('../MT_split/train.txt', 2)
model.fit_generator(train_datagen, epochs=10, workers=2, use_multiprocessing=True)
def main():
# Get running configuration
config, _ = get_config()
print_config()
# Build tensorflow graph from config
print("Building graph...")
actor = Actor(config)
# Saver to save & restore all the variables.
variables_to_save = [
v for v in tf.global_variables() if 'Adam' not in v.name
]
saver = tf.train.Saver(var_list=variables_to_save,
keep_checkpoint_every_n_hours=1.0)
print("Starting session...")
with tf.Session() as sess:
# Run initialize op
sess.run(tf.global_variables_initializer())
# Restore variables from disk.
if config.restore_model == True:
saver.restore(sess, "save/" + config.restore_from + "/actor.ckpt")
print("Model restored.")
# Initialize data generator
solver = Solver(actor.max_length) ###### ######
training_set = DataGenerator(solver)
# Training mode
if not config.inference_mode:
# Summary writer
writer = tf.summary.FileWriter(config.log_dir, sess.graph)
print("Starting training...")
for i in tqdm(range(config.nb_epoch)):
# Get feed dict
input_batch = training_set.train_batch(actor.batch_size,
actor.max_length,
actor.input_dimension)
feed = {actor.input_: input_batch}
if i % 5 == 0:
sess.run(actor.assign_op, feed_dict=feed)
# Forward pass & train step
summary, base_op, train_step1, train_step2 = sess.run(
[
actor.merged, actor.base_op, actor.train_step1,
actor.train_step2
],
feed_dict=feed)
if i % 100 == 0:
writer.add_summary(summary, i)
# Save the variables to disk
if i % max(1, int(config.nb_epoch / 5)) == 0 and i != 0:
save_path = saver.save(sess,
"save/" + config.save_to +
"/tmp.ckpt",
global_step=i)
print("\n Model saved in file: %s" % save_path)
print("Training COMPLETED !")
saver.save(sess, "save/" + config.save_to + "/actor.ckpt")
# Inference mode
else:
targets = []
predictions = []
for __ in tqdm(range(1000)): # num of examples
# Get feed_dict (single input)
seed_ = 1 + __
input_batch, or_sequence = training_set.test_batch(
actor.batch_size,
actor.max_length,
actor.input_dimension,
seed=seed_) # seed=0 means None
feed = {actor.input_: input_batch}
# Solve instance (OR tools)
opt_trip, opt_length = training_set.solve_instance(or_sequence)
targets.append(opt_length / 100)
#print('\n Optimal length:',opt_length/100)
################################### UMPA LOOOOP HERE ################################### nb_loop / temperature
# Sample solutions
permutations, circuit_length = sess.run(
[actor.positions, actor.distances], feed_dict=feed)
#training_set.visualize_sampling(permutations)
# Find best solution
#print(circuit_length)
j = np.argmin(circuit_length)
best_permutation = permutations[j][:-1]
predictions.append(circuit_length[j])
################################### UMPA LOOOOP HERE ###################################
#print('\n Best tour length:',circuit_length[j])
#print(' * permutation:', best_permutation)
# plot corresponding tour
#training_set.visualize_2D_trip(opt_trip)
#training_set.visualize_2D_trip(or_sequence[best_permutation])
predictions = np.asarray(predictions)
targets = np.asarray(targets)
print(' Mean length:', np.mean(predictions))
ratio = np.asarray(predictions) / np.asarray(targets)
print('\n Average deviation: \n', np.mean(ratio))
n, bins, patches = plt.hist(ratio, 50, facecolor='r', alpha=0.75)
plt.xlabel('Prediction/target')
plt.ylabel('Counts')
plt.title('Comparison to Google OR tools')
plt.axis([0.9, 1.4, 0, 500])
plt.grid(True)
plt.show()
