def predict_main(aoi_path):
"""this functions trakes as input the json file fr4om frontend and returns the subpolygones with co2 metrcis
aoi: json file with area of intreste from frontend
"""
# download images from gee
data_parent_path = os.path.join("..", "data", "raw")
dataset_name = data.download_dataset(aoi_path,
data_parent_path=data_parent_path,
get_sent2=True,
get_glc=False,
get_ndvi=False)
# preprocess data (creates dataset folder structure in data/preprocessed
# from data import make_dataset
data.make_dataset(dataset_name)
# predict land cover
prediction = predict_model(dataset_name)
# prediction is a json with subpolygones
# get co2 estimations
prediction = calc_vegetation_co_metric(
prediction) # adds attribute "veg_co2_metric" to predictions
prediction = calc_soil_co_metric(
prediction) # adds attribute "soil_co2_metric" to predictions
#return prediction
pass
def main(argv):
"""Builds, trains, and evaluates the model."""
args = parser.parse_args(argv[1:])
(train_x, train_y), (test_x, test_y) = data.load_data()
# Provide the training input dataset.
train_input_fn = data.make_dataset(args.batch_size, train_x, train_y, True,
1000)
# Provide the validation input dataset.
test_input_fn = data.make_dataset(args.batch_size, test_x, test_y)
# Use the same categorical columns as in `linear_regression_categorical`
body_style_vocab = ["47980dda", "79ceee49"]
body_style_column = tf.feature_column.categorical_column_with_vocabulary_list(
key="auction_boolean_0", vocabulary_list=body_style_vocab)
#make_column = tf.feature_column.categorical_column_with_hash_bucket(
#key="make", hash_bucket_size=50)
feature_columns = [
tf.feature_column.numeric_column(key="creative_height"),
tf.feature_column.numeric_column(key="creative_width"),
# Since this is a DNN model, categorical columns must be converted from
# sparse to dense.
# Wrap them in an `indicator_column` to create a
# one-hot vector from the input.
tf.feature_column.indicator_column(body_style_column)
# Or use an `embedding_column` to create a trainable vector for each
# index.
#tf.feature_column.embedding_column(make_column, dimension=3),
]
# Build a DNNRegressor, with 2x20-unit hidden layers, with the feature columns
# defined above as input.
model = tf.estimator.LinearClassifier(feature_columns=feature_columns,
n_classes=2)
# Train the model.
# By default, the Estimators log output every 100 steps.
model.train(input_fn=train_input_fn, steps=args.train_steps)
# Evaluate how the model performs on data it has not yet seen.
eval_result = model.evaluate(input_fn=test_input_fn)
# The evaluation returns a Python dictionary. The "average_loss" key holds the
# Mean Squared Error (MSE).
average_loss = eval_result["average_loss"]
# Convert MSE to Root Mean Square Error (RMSE).
print("\n" + 80 * "*")
print("\nRMS error for the test set: ${:.0f}".format(average_loss))
print()
def train_input_fn():
return data.make_dataset(config['train_images'],
config['img_feature_name'],
config['img_size'],
config['num_channels'],
batch_size=config['batch_size'],
num_epochs=config['epochs_per_eval'],
shuffle=True)
def test_input_fn():
return data.make_dataset(config['test_images'],
config['img_feature_name'],
config['img_size'],
config['num_channels'],
batch_size=config['batch_size'],
grayscale=config['grayscale'],
shuffle=False)
def make_model(in_path, out_path, n_epochs=500, gen_type="balanced"):
(X_train, y_train), test = data.make_dataset(in_path, False)
gen = sim.gen.get_data_generator(gen_type)
X, y = gen(X_train, y_train)
X, n_cats, n_channels = prepare_data(X, y)
# raise Exception(n_cats)
sim_metric, model = make_five(n_cats, n_channels, params=None)
sim_metric.fit(X, y, epochs=n_epochs, batch_size=128)
if (out_path):
model.save(out_path)
def show_frames(in_path, out_path):
(X_train, y_train), test = data.make_dataset(in_path, False)
X, y = sim.gen.OneCat(14)(X_train,
y_train) #balanced_data(X_train,y_train)
files.make_dir(out_path)
for i, y_i in enumerate(y):
x0, x1 = X[0][i], X[1][i]
cat_i = np.argmax(y_i)
img_i = np.concatenate([x0, x1])
out_i = '%s/%d_%d.png' % (out_path, i, cat_i)
print(out_i)
cv2.imwrite(out_i, img_i)
def simple_exp(in_path, out_path=None, n_epochs=500, model_type="old"):
(X_train, y_train), (X_test, y_test) = data.make_dataset(in_path)
n_cats, n_channels = data.get_params(X_train, y_train)
X_train, y_train = prepare_data(X_train, y_train, n_channels)
X_test, y_test = prepare_data(X_test, y_test, n_channels)
model_factory, params = models.get_model_factory(model_type)
model = model_factory(n_cats, n_channels, params)
model.summary()
model.fit(X_train, y_train, epochs=n_epochs, batch_size=256)
test_model(X_test, y_test, model)
if (out_path):
model.save(out_path)
def train_binary_model(in_path,out_path,n_epochs=150,model_type='exp'):
(X_train,y_train),(X_test,y_test)=data.make_dataset(in_path)
n_cats,n_channels=data.get_params(X_train,y_train)
X_train,y_train=basic.prepare_data(X_train,y_train,n_channels)
X_test,y_test=basic.prepare_data(X_test,y_test,n_channels)
model_factory,params=models.get_model_factory(model_type)
files.make_dir(out_path)
for cat_i in range(n_cats):
y_i=binarize(y_train,cat_i)
model=model_factory(2,n_channels,params)
model.summary()
model.fit(X_train,y_i,epochs=n_epochs,batch_size=256)
out_i=out_path+'/nn'+str(cat_i)
model.save(out_i)
def main():
parser = ArgumentParser()
parser.add_argument('--data-dir', help='Location where TFRecord files are')
parser.add_argument('--model-dir',
help='Location where model will be saved')
parser.add_argument('--max-steps', default=10000)
args, _ = parser.parse_known_args()
# Ensure our model directory exists
tf.gfile.MakeDirs(args.model_dir)
config = tf.estimator.RunConfig(
train_distribute=tf.contrib.distribute.MirroredStrategy())
estimator = tf.estimator.Estimator(model_fn=model.unet_model,
model_dir=args.model_dir,
config=config,
params={'learning_rate': 1e-4})
tf.logging.set_verbosity(tf.logging.INFO)
train_input_fn = lambda: data.make_dataset(os.path.join(
args.data_dir, 'train-*.tfrecord'),
batch_size=2,
shuffle=True)
train_spec = tf.estimator.TrainSpec(
train_input_fn, max_steps=args.max_steps) #, hooks=[debug_hook])
val_input_fn = lambda: data.make_dataset(os.path.join(
args.data_dir, 'validation-0.tfrecord'),
batch_size=2,
shuffle=False)
eval_spec = tf.estimator.EvalSpec(val_input_fn, steps=20)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
def train(in_path, out_path=None, n_epochs=1000, recon=True):
(X_train, y_train), (X_test, y_test) = data.make_dataset(in_path)
n_cats, n_channels = data.get_params(X_train, y_train)
X = data.format_frames(X_train, n_channels)
noise_X = add_noise(X)
make_model, params = models.auto.get_model_factory("basic")
model, recon = make_model(n_channels, params)
recon.summary()
gc.collect()
recon.fit(noise_X, X, epochs=n_epochs, batch_size=256) #,
# shuffle=True,validation_data=(X, X))
if (not out_path):
dest_dir = os.path.split(in_path)[0]
out_path = dest_dir + '/ae'
model.save(out_path)
if (recon):
recon.save(out_path + "_recon")
def train(args):
tf.enable_eager_execution()
tf.executing_eagerly()
tfe = tf.contrib.eager
writer = tf.contrib.summary.create_file_writer("./log")
global_step = tf.train.get_or_create_global_step()
writer.set_as_default()
dataset = make_dataset("./train.csv", args.batch_size, args.n_class)
model = MultiSegCaps(n_class=args.n_class)
#optimizer = tf.train.AdamOptimizer(learning_rate=args.lr)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=args.lr)
checkpoint_dir = './models'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
root = tfe.Checkpoint(optimizer=optimizer,
model=model,
optimizer_step=tf.train.get_or_create_global_step())
with tf.contrib.summary.record_summaries_every_n_global_steps(50):
for epoch in range(args.epoch):
for imgs, lbls in dataset:
global_step.assign_add(1)
with tf.GradientTape() as tape:
out_seg, reconstruct = model(imgs, lbls)
segmentation_loss = tf.losses.softmax_cross_entropy(
lbls, out_seg)
tf.contrib.summary.scalar('segmentation_loss',
segmentation_loss)
#segmetation_loss = weighted_margin_loss(out_seg, lbls, class_weighting=[0,1,1,1,1])
reconstruct_loss = reconstruction_loss(reconstruct,
imgs,
rs=args.rs)
tf.contrib.summary.scalar('reconstruction_loss',
reconstruct_loss)
total_loss = segmentation_loss + reconstruct_loss
tf.contrib.summary.scalar('total_loss', total_loss)
print(total_loss)
grad = tape.gradient(total_loss, model.variables)
optimizer.apply_gradients(
zip(grad, model.variables),
global_step=tf.train.get_or_create_global_step())
if epoch % 10 == 0:
root.save(file_prefix=checkpoint_prefix)
def main(args):
os.environ['CUDA_VISIBLE_DEVICES'] = args.device
sess = tf.Session()
model = VGG19(nb_classes=2, is_training=False)
img_height, img_width, _ = model.SHAPE
saver = tf.train.Saver()
saver.restore(sess, args.checkpoint)
columns = ['filename', 'attack', 'iteration', 'label',
'class_0_pred', 'class_1_pred', 'l2_norm']
data = []
def preprocess_func(x, y):
x = read_image(x)
x = decode_png(x)
x = resize(x, img_height, img_width)
return x, y
allowed_attacks = set([a.strip() for a in args.attacks.split(',')
if len(a.strip()) > 0])
for attack_dir in os.listdir(args.data):
if not attack_dir in allowed_attacks:
continue
logger.debug("Start processing attack {}".format(attack_dir))
for iter_dir in os.listdir(join(args.data, attack_dir)):
logger.debug("Start processing iteration #{}".format(int(iter_dir)))
source_dir = join(args.data, attack_dir, iter_dir)
dataset = make_dataset(source_dir, 128, preprocess_func, shuffle=False, repeat=False)
iter_data = fetch_data(sess, model, dataset, attack_dir, iter_dir)
data.extend(iter_data)
dataframe = pd.DataFrame(data=data, columns=columns)
dataframe.to_csv(args.csv, index=False)
shutil.copy2(args.config, output_dir)
# logger
logger = make_logger("project", opt.output_dir, 'log')
# device
if opt.device == 'cuda':
os.environ['CUDA_VISIBLE_DEVICES'] = opt.device_id
num_gpus = len(opt.device_id.split(','))
logger.info("Using {} GPUs.".format(num_gpus))
logger.info("Training on {}.\n".format(torch.cuda.get_device_name(0)))
cudnn.benchmark = True
device = torch.device(opt.device)
# create the dataset for training
dataset = make_dataset(opt.dataset)
# init the network
style_gan = StyleGAN(structure=opt.structure,
resolution=opt.dataset.resolution,
num_channels=opt.dataset.channels,
latent_size=opt.model.gen.latent_size,
g_args=opt.model.gen,
d_args=opt.model.dis,
g_opt_args=opt.model.g_optim,
d_opt_args=opt.model.d_optim,
loss=opt.loss,
drift=opt.drift,
d_repeats=opt.d_repeats,
use_ema=opt.use_ema,
ema_decay=opt.ema_decay,
import tensorflow as tf
from data import make_dataset
import time
import matplotlib.pyplot as plt
'''
Implementation of k-means ++
'''
tf.config.threading.set_inter_op_parallelism_threads(8)
tf.config.threading.set_intra_op_parallelism_threads(8)
NUM_CLUSTER = 9
NUM_ITERS = 30
NEW_CENTRIOD_THRESHOLD = 0.98
ds_1 = make_dataset(BATCH_SIZE=1, file_name='train_tf_record', split=False)
ds_2 = make_dataset(BATCH_SIZE=1, file_name='test_tf_record', split=False)
ds = ds_1.concatenate(ds_2)
NUM_SAMPLES = len(list(ds))
frame = []
for sample in ds:
for num, x_min in enumerate(sample[1]):
y_min = sample[2][num]
x_max = sample[3][num]
y_max = sample[4][num]
width = tf.cast((x_max - x_min), tf.float32).numpy()
height = tf.cast((y_max - y_min), tf.float32).numpy()
frame.append((width, height))
# Calculate initial centroids (K-Means++)
def train(config, anchors):
num_epoch = int(config.epoch)
log_dir = './results/'
# Load dataset
path = os.getcwd()
train_file = path + '/train_tf_record'
test_file = path + '/test_tf_record'
train_dataset, val_dataset = make_dataset(
BATCH_SIZE=config.training_batch_size,
file_name=train_file,
split=True)
test_dataset = make_dataset(BATCH_SIZE=config.test_batch_size,
file_name=test_file,
split=False)
# Model
model = load_model(1,
anchors,
config.model_size,
load_full_weights=config.load_full_weights)
# set optimizer
optimizer = tf.keras.optimizers.Adam(learning_rate=config.lr)
# set Metrics
tr_sum_loss = tf.keras.metrics.Mean()
tr_iou = tf.keras.metrics.Mean()
val_xy_loss = tf.keras.metrics.Mean()
val_wh_loss = tf.keras.metrics.Mean()
val_obj_loss = tf.keras.metrics.Mean()
val_prob_loss = tf.keras.metrics.Mean()
val_sum_loss = tf.keras.metrics.Mean()
val_iou = tf.keras.metrics.Mean()
test_iou = tf.keras.metrics.Mean()
# Save Checkpoint
ckpt = tf.train.Checkpoint(step=tf.Variable(1),
optimizer=optimizer,
net=model)
manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=5)
# Set up summary writers
current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tb_log_dir = log_dir + current_time
summary_writer = tf.summary.create_file_writer(tb_log_dir)
# Restore Checkpoint
ckpt.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
logging.info('Restored from {}'.format(manager.latest_checkpoint))
else:
logging.info('Initializing from scratch.')
# calculate losses, update network and metrics.
@tf.function
def train_step(images, y_true):
# Optimize the model
with tf.GradientTape() as tape:
detect0, detect1, detect2 = model(images,
training=True,
finetuning=config.finetuning)
de_de0 = decode(detect0, anchors[2], 1, config.model_size)
de_de1 = decode(detect1, anchors[1], 1, config.model_size)
de_de2 = decode(detect2, anchors[0], 1, config.model_size)
loss_de0 = yolo_loss(detect0, y_true, de_de0, anchors[2],
config.model_size)
loss_de1 = yolo_loss(detect1, y_true, de_de1, anchors[1],
config.model_size)
loss_de2 = yolo_loss(detect2, y_true, de_de2, anchors[0],
config.model_size)
total_loss = loss_de0 + loss_de1 + loss_de2
sum_loss = tf.reduce_sum(total_loss)
grads = tape.gradient(sum_loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
x = tf.concat([de_de0, de_de1, de_de2], axis=1)
x = build_boxes(x)
boxes_dicts = non_max_suppression(x, model.n_classes,
config.max_out_size,
config.iou_threshold,
config.confid_threshold)
return sum_loss, boxes_dicts
@tf.function
def val_step(images, y_true):
detect0, detect1, detect2 = model(images, training=False)
de_de0 = decode(detect0, anchors[2], 1, config.model_size)
de_de1 = decode(detect1, anchors[1], 1, config.model_size)
de_de2 = decode(detect2, anchors[0], 1, config.model_size)
loss_de0 = yolo_loss(detect0, y_true, de_de0, anchors[2],
config.model_size)
loss_de1 = yolo_loss(detect1, y_true, de_de1, anchors[1],
config.model_size)
loss_de2 = yolo_loss(detect2, y_true, de_de2, anchors[0],
config.model_size)
total_loss = loss_de0 + loss_de1 + loss_de2
x = tf.concat([de_de0, de_de1, de_de2], axis=1)
x = build_boxes(x)
boxes_dicts = non_max_suppression(x, model.n_classes,
config.max_out_size,
config.iou_threshold,
config.confid_threshold)
return total_loss, boxes_dicts
@tf.function
def test_step(images):
detect0, detect1, detect2 = model(images, training=False)
de_de0 = decode(detect0, anchors[2], 1, config.model_size)
de_de1 = decode(detect0, anchors[1], 1, config.model_size)
de_de2 = decode(detect0, anchors[0], 1, config.model_size)
x = tf.concat([de_de0, de_de1, de_de2], axis=1)
x = build_boxes(x)
boxes_dicts = non_max_suppression(x, model.n_classes,
config.max_out_size,
config.iou_threshold,
config.confid_threshold)
return boxes_dicts
for epoch in range(num_epoch):
begin = time.time()
# Training loop
for i in train_dataset:
images = data_augmentation(i[0], config.probability,
config.brightness_delta,
config.contrast_range, config.hue_delta)
y_true = i[1:]
sum_loss, boxes_dicts = train_step(images, y_true)
tr_sum_loss.update_state(sum_loss)
pred_points = list(map(lambda x: x[0][..., 0:4], boxes_dicts))
pred_points = tf.concat(pred_points, axis=0)
for _ in range(config.training_batch_size -
tf.shape(pred_points)[0]):
pred_points = tf.concat(
values=[pred_points,
tf.constant([[0., 0., 0., 0.]])],
axis=0)
training_iou_batch = tf.reduce_mean(
iou(pred_points,
tf.cast(tf.stack(y_true[0:4], axis=-1), dtype=tf.float32)))
tr_iou.update_state(training_iou_batch)
for j in val_dataset:
images = j[0]
y_true = j[1:]
total_loss, boxes_dicts = val_step(images, y_true)
val_xy_loss.update_state(total_loss[0])
val_wh_loss.update_state(total_loss[1])
val_obj_loss.update_state(total_loss[2])
val_prob_loss.update_state(total_loss[3])
val_sum_loss.update_state(tf.reduce_sum(total_loss))
pred_points = list(map(lambda x: x[0][..., 0:4], boxes_dicts))
pred_points = tf.concat(pred_points, axis=0)
for _ in range(config.training_batch_size -
tf.shape(pred_points)[0]):
pred_points = tf.concat(
values=[pred_points,
tf.constant([[0., 0., 0., 0.]])],
axis=0)
val_iou_batch = tf.reduce_mean(
iou(pred_points,
tf.cast(tf.stack(y_true[0:4], axis=-1), dtype=tf.float32)))
val_iou.update_state(val_iou_batch)
with summary_writer.as_default():
tf.summary.scalar('Train Sum loss',
tr_sum_loss.result(),
step=epoch)
tf.summary.scalar('Train IOU', tr_iou.result(), step=epoch)
tf.summary.scalar('Validation XY loss',
val_xy_loss.result(),
step=epoch)
tf.summary.scalar('Validation WH loss',
val_wh_loss.result(),
step=epoch)
tf.summary.scalar('Validation OBJ loss',
val_obj_loss.result(),
step=epoch)
tf.summary.scalar('Validation PROB loss',
val_prob_loss.result(),
step=epoch)
tf.summary.scalar('Validation Sum loss',
val_sum_loss.result(),
step=epoch)
tf.summary.scalar('Validation IOU', val_iou.result(), step=epoch)
end = time.time()
logging.info(
"Epoch {:d} Training Sum loss: {:.3}, Training IOU: {:.3%} \n Validation Sum loss: {:.3}, "
"Validation IOU: {:.3%}, Time:{:.5}s".format(
epoch + 1, tr_sum_loss.result(), tr_iou.result(),
val_sum_loss.result(), val_iou.result(), (end - begin)))
tr_sum_loss.reset_states()
tr_iou.reset_states()
val_xy_loss.reset_states()
val_wh_loss.reset_states()
val_obj_loss.reset_states()
val_prob_loss.reset_states()
val_sum_loss.reset_states()
val_iou.reset_states()
if int(ckpt.step) % 5 == 0:
save_path = manager.save()
logging.info('Saved checkpoint for epoch {}: {}'.format(
int(ckpt.step), save_path))
ckpt.step.assign_add(1)
if epoch % 1 == 0:
for j in test_dataset:
images = j[0]
y_true = j[1:]
boxes_dicts = test_step(images)
pred_points = list(map(lambda x: x[0][..., 0:4], boxes_dicts))
pred_points = tf.concat(pred_points, axis=0)
for _ in range(config.test_batch_size -
tf.shape(pred_points)[0]):
pred_points = tf.concat(
values=[pred_points,
tf.constant([[0., 0., 0., 0.]])],
axis=0)
test_iou_batch = tf.reduce_mean(
iou(
pred_points,
tf.cast(tf.stack(y_true[0:4], axis=-1),
dtype=tf.float32)))
test_iou.update_state(test_iou_batch)
# test image visualization
time_begin = time.time()
test_sample = next(iter(test_dataset))
images = test_sample[0][0]
y_true = list(map(lambda x: x[0], test_sample[1:]))
# numpy array is necessary for openCV
images_tf = tf.expand_dims(images, axis=0)
images = tf.cast(images * 255, tf.uint8).numpy()
images = cv.cvtColor(images, cv.COLOR_BGR2RGB)
box_dicts = test_step(images_tf)
draw_boxes_cv2(images, box_dicts,
[y_true[4].numpy().decode('utf-8')],
config.model_size, time_begin)
cv.rectangle(images, (y_true[0], y_true[1]),
(y_true[2], y_true[3]), (0, 0, 255), 2)
images = cv.cvtColor(images, cv.COLOR_RGB2BGR)
images = tf.expand_dims(images, axis=0)
with summary_writer.as_default():
tf.summary.image('Test Object detection', images, step=epoch)
tf.summary.scalar('Test IOU', test_iou.result(), step=epoch)
logging.info("Test IOU: {:.3%}".format(test_iou.result()))
test_iou.reset_states()
os.mkdir(save_dir)
ckpt_dir = './info_output/%s/checkpoints/' % experiment_name
if not os.path.exists(ckpt_dir):
os.mkdir(ckpt_dir)
train_hist = {}
train_hist['D_loss'] = []
train_hist['G_loss'] = []
train_hist['info_loss'] = []
train_hist['per_epoch_time'] = []
train_hist['total_time'] = []
#dataSets
data_loader, shape = data.make_dataset(dataset_name='celebaHQ',
batch_size=batch_size,
img_size=img_size,
pin_memory=True)
#---------------- Pre-Model ------------
#-----DCGAN celebaA---------## input_dim=256, Gscale=8, Dscale=4
import network.network_1 as net1
import network.network_1_SSencoder as net2
def toggle_grad(model, requires_grad):
for p in model.parameters():
p.requires_grad_(requires_grad)
netG1 = net1.Generator(
print("knn_cls result : ", knn_cls)
ret_dict['knn_cls'] = knn_cls
X_sub, Y_sub = sub_select_knn_anneal(X, Y, n_sub)
knn_anneal = get_acc(clf, X_sub, Y_sub, X_t, Y_t)
print("knn_anneal result : ", knn_anneal)
ret_dict['knn_anneal'] = knn_anneal
return ret_dict
if __name__ == "__main__":
n = 2000
n_tr = n // 2
X, Y = make_dataset(n)
X_tr, Y_tr = X[:n_tr], Y[:n_tr]
X_t, Y_t = X[n_tr:], Y[n_tr:]
# some TSNE print for all features and only class relevant features
tsne(X_tr, Y_tr, "all_feature")
X_emb = [get_class(x) for x in X]
tsne(X_emb, Y, "class_feature")
X_style = [get_style(x) for x in X]
tsne(X_style, Y, "style_feature")
X_common = [get_common(x) for x in X]
tsne(X_common, Y, "common_feature")
clf_name = 'knn'
sub_sizes = [10 * i for i in range(1, 21)]
def eval_input_fn():
return data.make_dataset(config['val_images'],
config['img_feature_name'],
config['img_size'],
config['num_channels'],
shuffle=False)
test_dataset = test_dataset.padded_batch(config.batch_size,
padded_shapes=([None], []))
model = tf.keras.Sequential([
tf.keras.layers.Embedding(config.vocab_size, config.embedding_dim),
tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(config.rnn_units)),
tf.keras.layers.Dense(config.rnn_units, activation='relu'),
tf.keras.layers.Dense(1)
])
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(1e-4),
metrics=['accuracy'])
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt_{epoch}")
checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_prefix, save_weights_only=True)
history = model.fit(train_dataset,
epochs=config.epochs,
validation_data=test_dataset,
validation_steps=config.validation_steps,
callbacks=[checkpoint_callback])
if __name__ == "__main__":
config = TrainConfig
dataset, encoder = make_dataset('train.txt', ['name', 'gender'], 'gender')
config.vocab_size = encoder.vocab_size
train(dataset, './training_checkpoints', config)
def train(hparams, num_epoch, tuning):
log_dir = './results/'
test_batch_size = 8
# Load dataset
training_set, valid_set = make_dataset(BATCH_SIZE=hparams['HP_BS'],
file_name='train_tf_record',
split=True)
test_set = make_dataset(BATCH_SIZE=test_batch_size,
file_name='test_tf_record',
split=False)
class_names = ['NRDR', 'RDR']
# Model
model = ResNet()
# set optimizer
optimizer = tf.keras.optimizers.Adam(learning_rate=hparams['HP_LR'])
# set metrics
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
valid_accuracy = tf.keras.metrics.Accuracy()
valid_con_mat = ConfusionMatrix(num_class=2)
test_accuracy = tf.keras.metrics.Accuracy()
test_con_mat = ConfusionMatrix(num_class=2)
# Save Checkpoint
if not tuning:
ckpt = tf.train.Checkpoint(step=tf.Variable(1),
optimizer=optimizer,
net=model)
manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=5)
# Set up summary writers
current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tb_log_dir = log_dir + current_time + '/train'
summary_writer = tf.summary.create_file_writer(tb_log_dir)
# Restore Checkpoint
if not tuning:
ckpt.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
logging.info('Restored from {}'.format(manager.latest_checkpoint))
else:
logging.info('Initializing from scratch.')
@tf.function
def train_step(train_img, train_label):
# Optimize the model
loss_value, grads = grad(model, train_img, train_label)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
train_pred, _ = model(train_img)
train_label = tf.expand_dims(train_label, axis=1)
train_accuracy.update_state(train_label, train_pred)
for epoch in range(num_epoch):
begin = time()
# Training loop
for train_img, train_label, train_name in training_set:
train_img = data_augmentation(train_img)
train_step(train_img, train_label)
with summary_writer.as_default():
tf.summary.scalar('Train Accuracy',
train_accuracy.result(),
step=epoch)
for valid_img, valid_label, _ in valid_set:
valid_img = tf.cast(valid_img, tf.float32)
valid_img = valid_img / 255.0
valid_pred, _ = model(valid_img, training=False)
valid_pred = tf.cast(tf.argmax(valid_pred, axis=1), dtype=tf.int64)
valid_con_mat.update_state(valid_label, valid_pred)
valid_accuracy.update_state(valid_label, valid_pred)
# Log the confusion matrix as an image summary
cm_valid = valid_con_mat.result()
figure = plot_confusion_matrix(cm_valid, class_names=class_names)
cm_valid_image = plot_to_image(figure)
with summary_writer.as_default():
tf.summary.scalar('Valid Accuracy',
valid_accuracy.result(),
step=epoch)
tf.summary.image('Valid ConfusionMatrix',
cm_valid_image,
step=epoch)
end = time()
logging.info(
"Epoch {:d} Training Accuracy: {:.3%} Validation Accuracy: {:.3%} Time:{:.5}s"
.format(epoch + 1, train_accuracy.result(),
valid_accuracy.result(), (end - begin)))
train_accuracy.reset_states()
valid_accuracy.reset_states()
valid_con_mat.reset_states()
if not tuning:
if int(ckpt.step) % 5 == 0:
save_path = manager.save()
logging.info('Saved checkpoint for epoch {}: {}'.format(
int(ckpt.step), save_path))
ckpt.step.assign_add(1)
for test_img, test_label, _ in test_set:
test_img = tf.cast(test_img, tf.float32)
test_img = test_img / 255.0
test_pred, _ = model(test_img, training=False)
test_pred = tf.cast(tf.argmax(test_pred, axis=1), dtype=tf.int64)
test_accuracy.update_state(test_label, test_pred)
test_con_mat.update_state(test_label, test_pred)
cm_test = test_con_mat.result()
# Log the confusion matrix as an image summary
figure = plot_confusion_matrix(cm_test, class_names=class_names)
cm_test_image = plot_to_image(figure)
with summary_writer.as_default():
tf.summary.scalar('Test Accuracy', test_accuracy.result(), step=epoch)
tf.summary.image('Test ConfusionMatrix', cm_test_image, step=epoch)
logging.info("Trained finished. Final Accuracy in test set: {:.3%}".format(
test_accuracy.result()))
# Visualization
if not tuning:
for vis_img, vis_label, vis_name in test_set:
vis_label = vis_label[0]
vis_name = vis_name[0]
vis_img = tf.cast(vis_img[0], tf.float32)
vis_img = tf.expand_dims(vis_img, axis=0)
vis_img = vis_img / 255.0
with tf.GradientTape() as tape:
vis_pred, conv_output = model(vis_img, training=False)
pred_label = tf.argmax(vis_pred, axis=-1)
vis_pred = tf.reduce_max(vis_pred, axis=-1)
grad_1 = tape.gradient(vis_pred, conv_output)
weight = tf.reduce_mean(grad_1, axis=[1, 2]) / grad_1.shape[1]
act_map0 = tf.nn.relu(
tf.reduce_sum(weight * conv_output, axis=-1))
act_map0 = tf.squeeze(tf.image.resize(tf.expand_dims(act_map0,
axis=-1),
(256, 256),
antialias=True),
axis=-1)
plot_map(vis_img, act_map0, vis_pred, pred_label, vis_label,
vis_name)
break
return test_accuracy.result()
def main():
device = '/gpu:0' if not FLAGS.no_gpu else '/cpu:0'
full_dataset, tokenizer, size = data.make_dataset(FLAGS.dataset_name,
FLAGS.dataset_type,
FLAGS.data_dir,
FLAGS.seq_length)
# Dataset processing
train_dataset, valid_dataset, test_dataset = _split(
full_dataset, FLAGS.train_frac, FLAGS.valid_frac, FLAGS.test_frac,
size)
train_dataset = (train_dataset.batch(
FLAGS.batch_size, drop_remainder=True).prefetch(2 * FLAGS.batch_size))
valid_dataset = (valid_dataset.batch(
FLAGS.batch_size, drop_remainder=True).prefetch(2 * FLAGS.batch_size))
test_dataset = (test_dataset.batch(
FLAGS.batch_size, drop_remainder=True).prefetch(2 * FLAGS.batch_size))
logging.info('Loaded dataset {}_{} with shape {}'.format(
FLAGS.dataset_name, FLAGS.dataset_type, train_dataset.output_shapes))
logging.info('Dataset size {}'.format(size))
for x, y in train_dataset.take(1):
logging.info('x:{} ; y:{}'.format(x.numpy(), y.numpy()))
if FLAGS.pretrain:
lm = LanguageModelRNN(tokenizer.vocab_size, FLAGS.embed_dim,
FLAGS.RNN_sizes[0], (not FLAGS.no_mask), False)
latest_ckpt = tf.train.latest_checkpoint(FLAGS.pretrain_lm_dir)
lm_ckpt = tf.train.Checkpoint(model=lm)
lm_ckpt.restore(latest_ckpt)
if FLAGS.model == 'LanguageModelRNN':
model = LanguageModelRNN(tokenizer.vocab_size, FLAGS.embed_dim,
FLAGS.RNN_sizes[0], (not FLAGS.no_mask),
False)
elif FLAGS.model == 'UniRNN':
model = UniRNN(tokenizer.vocab_size, FLAGS.embed_dim,
FLAGS.RNN_sizes[0], 2, (not FLAGS.no_mask), False)
else:
raise NotImplementedError
# Create optimizer
optimizer = tf.train.AdamOptimizer(FLAGS.lr)
# Initialize summaries and checkpointing
summary_writer = tf.contrib.summary.create_file_writer(FLAGS.log_dir,
flush_millis=1000)
checkpoint_prefix = os.path.join(FLAGS.checkpoint_dir, 'ckpt')
latest_ckpt = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
if latest_ckpt:
print('Using latest checkpoint at ' + latest_ckpt)
checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)
checkpoint.restore(latest_ckpt)
# Create global TF ops
global_step = tf.train.get_or_create_global_step()
# Train loop
if FLAGS.mode == 'train':
with tf.device(device):
for epoch in range(FLAGS.epochs):
start = time.time()
with summary_writer.as_default():
model.train(train_dataset, optimizer, global_step)
val_loss = model.evaluate(valid_dataset)
print(val_loss)
end = time.time()
checkpoint.save(checkpoint_prefix)
logging.info(
'\nTrain time for epoch #%d (step %d): %f seconds' %
(checkpoint.save_counter.numpy(), global_step.numpy(),
end - start))
elif FLAGS.mode == 'sample':
seed_tokens = tokenizer.tokenize(FLAGS.sample_seed_text)
seed = tf.constant(np.array(seed_tokens, dtype=np.int16))
seed = tf.expand_dims(seed, 0)
print(seed.shape)
inp = seed
tokens = seed_tokens
for i in range(FLAGS.sample_length):
logits = model(inp)
logits = tf.squeeze(logits, 0)
logits = logits / FLAGS.temperature
sample_tok = tf.multinomial(logits, num_samples=1)[-1, 0].numpy()
tokens.append(sample_tok)
inp = tf.expand_dims([sample_tok], 0)
print(tokenizer.untokenize(tokens))
def main():
# Parse
parser = model_utils.get_parser()
FLAGS, unparsed = parser.parse_known_args()
# Setup model_dir
if FLAGS.model_name is None:
model_name = "LanguageModel"
else:
model_name = FLAGS.model_name
model_dir = os.path.abspath(FLAGS.base_dir) + '/{}/'.format(model_name)
if not os.path.exists(model_dir):
model_utils.setup_model_dir(model_dir, create_base=True)
if FLAGS.no_restore:
model_utils.remove_history(model_dir)
model_utils.setup_model_dir(model_dir, create_base=False)
# Start logging
logger = model_utils.get_logger(model_name, model_dir)
logger.info("Started constructing {}".format(model_name))
logger.info("Parsed args {}".format(FLAGS))
if FLAGS.no_restore:
logger.info('Not restoring, deleted history.')
# Get Dataset
logger.info("Getting dataset {}".format(FLAGS.dataset_name))
full_dataset, tokenizer, size = data.make_dataset(FLAGS.dataset_name,
FLAGS.dataset_type,
FLAGS.data_dir,
FLAGS.seq_length)
# Create model
hparams = create_hparams(FLAGS.hparams)
lm = LanguageModel(tokenizer.vocab_size, hparams.embedding_dim,
hparams.rnn_size, hparams.use_cudnn)
optimizer = tf.train.AdamOptimizer(hparams.lr, hparams.beta1,
hparams.beta2, hparams.epsilon)
epoch_count = tf.Variable(1, 'epoch_count')
global_step = tf.train.get_or_create_global_step()
logger.info("Model created")
# Create checkpointing
checkpoint_dir = os.path.abspath(model_dir + 'ckpts/' + FLAGS.run_name)
logger.info("Checkpoints at {}".format(checkpoint_dir))
checkpoint_prefix = checkpoint_dir + '/ckpt'
checkpoint = tf.train.Checkpoint(optimizer=optimizer,
lm=lm,
epoch_count=epoch_count,
global_step=global_step)
if not FLAGS.no_restore:
if not FLAGS.load_checkpoint is None:
load_checkpoint = FLAGS.load_checkpoint
else:
load_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
logger.info("Loading latest checkpoint...")
logger.info("Loading checkpoint {}".format(load_checkpoint))
checkpoint.restore(load_checkpoint)
# Create summary writer
summary_dir = model_dir + 'log/' + FLAGS.run_name + '/'
summary_writer = tf.contrib.summary.create_file_writer(summary_dir,
flush_millis=1000)
# Training
if FLAGS.mode == "train":
logger.info("Beginning training...")
device = '/gpu:0' if not FLAGS.no_gpu else '/cpu:0'
# Get training Dataset
logger.info("Full dataset size: {}".format(int(size)))
logger.info("Train dataset size: {}".format(
int(size * FLAGS.use_frac * FLAGS.train_frac)))
train_dataset, valid_dataset = model_utils.split(
full_dataset, size, FLAGS.use_frac, FLAGS.train_frac)
train_dataset = train_dataset.batch(FLAGS.batch_size,
drop_remainder=True)
valid_dataset = valid_dataset.batch(FLAGS.batch_size,
drop_remainder=True)
train_dataset = (
tf.data.experimental.prefetch_to_device(device)(train_dataset))
valid_dataset = (
tf.data.experimental.prefetch_to_device(device)(valid_dataset))
# Train loop
train_losses = []
val_losses = []
patience_count = 0
for epoch in range(FLAGS.epochs):
cur_epoch = epoch_count.numpy() + epoch
logger.info("Starting epoch {}...".format(cur_epoch))
start = time.time()
with summary_writer.as_default():
train_loss = lm.train(train_dataset, optimizer, global_step,
FLAGS.log_interval)
logger.info("Epoch {} complete: train loss = {:0.03f}".format(
cur_epoch, train_loss))
logger.info("Validating...")
val_loss = lm.evaluate(valid_dataset)
logger.info("Validation loss = {:0.03f}".format(val_loss))
time_elapsed = time.time() - start
logger.info("Took {:0.01f} seconds".format(time_elapsed))
# Checkpoint
if FLAGS.early_stopping:
if not val_losses or val_loss < min(
val_losses) - FLAGS.es_delta:
logger.info("Checkpointing...")
checkpoint.save(checkpoint_prefix)
elif patience_count + 1 > FLAGS.patience:
logger.info("Early stopping reached")
break
else:
patience_count += 1
else:
logger.info("Checkpointing...")
checkpoint.save(checkpoint_prefix)
elif FLAGS.mode == "eval":
logger.info("Beginning evaluation...")
device = '/gpu:0' if not FLAGS.no_gpu else '/cpu:0'
with summary_writer.as_default():
val_loss = lm.evaluate(full_dataset)
logger.info("Validation loss: {:0.02f}".format(val_loss))
elif FLAGS.mode == "generate":
# Generate samples
logger.info("Generating samples...")
for _ in range(FLAGS.num_samples):
tokens = tokenizer.tokenize(FLAGS.seed_text)
inp = tf.constant(np.array(tokens, dtype=np.int16))
inp = tf.expand_dims(inp, 0)
_, state = lm.call_with_state(inp[:, 0:-1]) # Setup state
cur_token = tokens[-1]
done = False
while not done:
inp = tf.constant(np.array([cur_token], dtype=np.int16))
inp = tf.expand_dims(inp, 0)
logits, state = lm.call_with_state(inp, state)
logits = tf.squeeze(logits, 0)
logits = logits / FLAGS.temperature
cur_token = tf.multinomial(logits, num_samples=1)[-1,
0].numpy()
tokens.append(cur_token)
if len(tokens) > FLAGS.sample_length:
done = True
logger.info("{}".format(tokenizer.untokenize(tokens)))
lm.recurrent.reset_states()
def create_graph(bound, state_size, num_timesteps, batch_size,
num_samples, num_eval_samples, resampling_schedule,
use_resampling_grads, learning_rate, lr_decay_steps,
train_p, dtype='float64'):
if FLAGS.use_bs:
true_bs = None
else:
true_bs = [np.zeros([state_size]).astype(dtype) for _ in xrange(num_timesteps)]
# Make the dataset.
true_bs, dataset = data.make_dataset(
bs=true_bs,
state_size=state_size,
num_timesteps=num_timesteps,
batch_size=batch_size,
num_samples=num_samples,
variance=FLAGS.variance,
prior_type=FLAGS.p_type,
bimodal_prior_weight=FLAGS.bimodal_prior_weight,
bimodal_prior_mean=FLAGS.bimodal_prior_mean,
transition_type=FLAGS.transition_type,
fixed_observation=FLAGS.fixed_observation,
dtype=dtype)
itr = dataset.make_one_shot_iterator()
_, observations = itr.get_next()
# Make the dataset for eval
_, eval_dataset = data.make_dataset(
bs=true_bs,
state_size=state_size,
num_timesteps=num_timesteps,
batch_size=num_eval_samples,
num_samples=num_eval_samples,
variance=FLAGS.variance,
prior_type=FLAGS.p_type,
bimodal_prior_weight=FLAGS.bimodal_prior_weight,
bimodal_prior_mean=FLAGS.bimodal_prior_mean,
transition_type=FLAGS.transition_type,
fixed_observation=FLAGS.fixed_observation,
dtype=dtype)
eval_itr = eval_dataset.make_one_shot_iterator()
_, eval_observations = eval_itr.get_next()
# Make the model.
if bound == "fivo-aux-td":
model = models.TDModel.create(
state_size,
num_timesteps,
variance=FLAGS.variance,
train_p=train_p,
p_type=FLAGS.p_type,
q_type=FLAGS.q_type,
mixing_coeff=FLAGS.bimodal_prior_weight,
prior_mode_mean=FLAGS.bimodal_prior_mean,
observation_variance=FLAGS.observation_variance,
transition_type=FLAGS.transition_type,
use_bs=FLAGS.use_bs,
dtype=tf.as_dtype(dtype),
random_seed=FLAGS.random_seed)
else:
model = models.Model.create(
state_size,
num_timesteps,
variance=FLAGS.variance,
train_p=train_p,
p_type=FLAGS.p_type,
q_type=FLAGS.q_type,
mixing_coeff=FLAGS.bimodal_prior_weight,
prior_mode_mean=FLAGS.bimodal_prior_mean,
observation_variance=FLAGS.observation_variance,
transition_type=FLAGS.transition_type,
use_bs=FLAGS.use_bs,
r_sigma_init=FLAGS.r_sigma_init,
dtype=tf.as_dtype(dtype),
random_seed=FLAGS.random_seed)
# Compute the bound and loss
if bound == "iwae":
(_, losses, ema_op, _, _) = bounds.iwae(
model,
observations,
num_timesteps,
num_samples=num_samples)
(eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.iwae(
model,
eval_observations,
num_timesteps,
num_samples=num_eval_samples,
summarize=True)
eval_log_p_hat = tf.reduce_mean(eval_log_p_hat)
elif "fivo" in bound:
if bound == "fivo-aux-td":
(_, losses, ema_op, _, _) = bounds.fivo_aux_td(
model,
observations,
num_timesteps,
resampling_schedule=resampling_schedule,
num_samples=num_samples)
(eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.fivo_aux_td(
model,
eval_observations,
num_timesteps,
resampling_schedule=resampling_schedule,
num_samples=num_eval_samples,
summarize=True)
else:
(_, losses, ema_op, _, _) = bounds.fivo(
model,
observations,
num_timesteps,
resampling_schedule=resampling_schedule,
use_resampling_grads=use_resampling_grads,
resampling_type=FLAGS.resampling_method,
aux=("aux" in bound),
num_samples=num_samples)
(eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.fivo(
model,
eval_observations,
num_timesteps,
resampling_schedule=resampling_schedule,
use_resampling_grads=False,
resampling_type="multinomial",
aux=("aux" in bound),
num_samples=num_eval_samples,
summarize=True)
eval_log_p_hat = tf.reduce_mean(eval_log_p_hat)
summ.summarize_ess(eval_log_weights, only_last_timestep=True)
# if FLAGS.p_type == "bimodal":
# # create the observations that showcase the model.
# mode_odds_ratio = tf.convert_to_tensor([1., 3., 1./3., 512., 1./512.],
# dtype=tf.float64)
# mode_odds_ratio = tf.expand_dims(mode_odds_ratio, 1)
# k = ((num_timesteps+1) * FLAGS.variance) / (2*FLAGS.bimodal_prior_mean)
# explain_obs = tf.reduce_sum(model.p.bs) + tf.log(mode_odds_ratio) * k
# explain_obs = tf.tile(explain_obs, [num_eval_samples, 1])
# # run the model on the explainable observations
# if bound == "iwae":
# (_, _, _, explain_states, explain_log_weights) = bounds.iwae(
# model,
# explain_obs,
# num_timesteps,
# num_samples=num_eval_samples)
# elif bound == "fivo" or "fivo-aux":
# (_, _, _, explain_states, explain_log_weights) = bounds.fivo(
# model,
# explain_obs,
# num_timesteps,
# resampling_schedule=resampling_schedule,
# use_resampling_grads=False,
# resampling_type="multinomial",
# aux=("aux" in bound),
# num_samples=num_eval_samples)
# summ.summarize_particles(explain_states,
# explain_log_weights,
# explain_obs,
# model)
# Calculate the true likelihood.
if hasattr(model.p, 'likelihood') and callable(getattr(model.p, 'likelihood')):
eval_likelihood = model.p.likelihood(eval_observations)/ FLAGS.num_timesteps
else:
eval_likelihood = tf.zeros_like(eval_log_p_hat)
tf.summary.scalar("log_p_hat", eval_log_p_hat)
tf.summary.scalar("likelihood", eval_likelihood)
tf.summary.scalar("bound_gap", eval_likelihood - eval_log_p_hat)
summ.summarize_model(model, true_bs, eval_observations, eval_states, bound,
summarize_r=not bound == "fivo-aux-td")
# Compute and apply grads.
global_step = tf.train.get_or_create_global_step()
apply_grads = make_apply_grads_op(losses,
global_step,
learning_rate,
lr_decay_steps)
# Update the emas after applying the grads.
with tf.control_dependencies([apply_grads]):
train_op = tf.group(ema_op)
#train_op = tf.group(ema_op, add_check_numerics_ops())
return global_step, train_op, eval_log_p_hat, eval_likelihood
args = py.args_from_yaml(py.join(test_args.experiment_dir, 'settings.yml'))
args.__dict__.update(test_args.__dict__)
# ==============================================================================
# = test =
# ==============================================================================
# data
A_img_paths_test = py.glob(py.join(args.datasets_dir, args.dataset, 'testA'),
'*.jpg')
B_img_paths_test = py.glob(py.join(args.datasets_dir, args.dataset, 'testB'),
'*.jpg')
A_dataset_test = data.make_dataset(A_img_paths_test,
args.batch_size,
args.load_size,
args.crop_size,
training=False,
drop_remainder=False,
shuffle=False,
repeat=1)
B_dataset_test = data.make_dataset(B_img_paths_test,
args.batch_size,
args.load_size,
args.crop_size,
training=False,
drop_remainder=False,
shuffle=False,
repeat=1)
# model
G_A2B = module.ResnetGenerator(input_shape=(args.crop_size, args.crop_size, 3),
dim=args.dim,
# data
div = 900
batch_size = 1
num_workers = 0
data_path = 'data/class1_data.pkl'
# model
hidden_dim = 32 # make it a number smaller than feature_dim
model_check = 'model/checkpoint.pth.tar'
model_best = 'model/bestmodel.pth.tar'
# result
save_path = 'data/pred_data.pkl'
# --------------------------------------------------------------------------
# prepare dataset
data, (len_seq, num_frame, num_joint, num_coor) = make_dataset(data_path)
test_set = data[div :]
# test_set = data[0: 30]
# train_loader shuffle
test_loader = DataLoader(dataset=test_set, batch_size=batch_size,
shuffle=False, num_workers=num_workers)
# --------------------------------------------------------------------------
# model settings
feature_dim = num_joint * num_coor # 16 * 3 = 48
model = LSTMpred(feature_dim, hidden_dim)
model.eval()
# loading trained model
if os.path.isfile(model_best):
print(("=> loading checkpoint '{}'".format(model_best)))
checkpoint = torch.load(model_best)
s = l[k].split('\\')[-1]
s2 = 'data\\tests\\0.1_color\\' + s
lis.append(s2)
return lis
# ==============================================================================
# = data =
# ==============================================================================
B_imgs = py.glob(py.join('data\\tests', 'trainsmall'), '*.jpg')
B_color = createdata(B_imgs)
B_set = data.make_dataset(B_imgs,
B_color,
abatch_size,
aload_size,
acrop_size,
training=False,
work=0)
B_lis = list(tfds.as_numpy(B_set))
B_list = []
for b in B_lis:
m, = b
B_list.append(tf.convert_to_tensor(m))
B_length = len(B_list)
len_dataset = B_length
#print('b list\n',B_list[0][0].squeeze().shape)
A2B_pool = data.ItemPool(apool_size)
def main():
# data
div1, div2 = 800, 900
batch_size = 20
num_workers = 0
data_path = 'data/class1_data.pkl'
# train
num_epoch = 100
lr = 1e-3
lr_step = 50 #
momentum = 0.9
weight_decay = 1e-3
# model
hidden_dim = 32 # make it a number smaller than feature_dim
model_check = 'model/checkpoint.pth.tar'
model_best = 'model/bestmodel.pth.tar'
# result
print_freq = 20
loss_best = 1e5
# --------------------------------------------------------------------------
# prepare dataset
data, (len_seq, num_frame, num_joint, num_coor) = make_dataset(data_path)
# data[:div] for trainning, data[800:900] for validation
# and the rest for testing
train_set = data[:div1]
val_set = data[div1:div2]
# train_loader shuffle
train_loader = DataLoader(dataset=train_set,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
val_loader = DataLoader(dataset=val_set,
batch_size=1,
shuffle=False,
num_workers=num_workers)
# --------------------------------------------------------------------------
# model settings
feature_dim = num_joint * num_coor # 16 * 3 = 48
model = LSTMpred(feature_dim, hidden_dim)
print(model)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(),
lr=lr,
momentum=momentum,
weight_decay=weight_decay)
# --------------------------------------------------------------------------
# run
for epoch in range(num_epoch):
adjust_lr(lr, optimizer, epoch, lr_step)
print('Epoch: {0}/{1} [training stage]'.format(epoch, num_epoch))
train(train_loader, model, criterion, optimizer, print_freq)
print('Epoch: {0}/{1} [validation stage]'.format(epoch, num_epoch))
loss = val(val_loader, model, criterion, print_freq)
is_best = loss < loss_best
loss_best = min(loss_best, loss)
save_checkpoint(
{
'epoch': epoch,
'arch': 'LSTMpred',
'state_dict': model.state_dict(),
'loss_best': loss_best,
'optimizer': optimizer.state_dict(),
}, is_best, model_check, model_best)
def create_graph(bound,
state_size,
num_timesteps,
batch_size,
num_samples,
num_eval_samples,
resampling_schedule,
use_resampling_grads,
learning_rate,
lr_decay_steps,
train_p,
dtype='float64'):
if FLAGS.use_bs:
true_bs = None
else:
true_bs = [
np.zeros([state_size]).astype(dtype) for _ in xrange(num_timesteps)
]
# Make the dataset.
true_bs, dataset = data.make_dataset(
bs=true_bs,
state_size=state_size,
num_timesteps=num_timesteps,
batch_size=batch_size,
num_samples=num_samples,
variance=FLAGS.variance,
prior_type=FLAGS.p_type,
bimodal_prior_weight=FLAGS.bimodal_prior_weight,
bimodal_prior_mean=FLAGS.bimodal_prior_mean,
transition_type=FLAGS.transition_type,
fixed_observation=FLAGS.fixed_observation,
dtype=dtype)
itr = dataset.make_one_shot_iterator()
_, observations = itr.get_next()
# Make the dataset for eval
_, eval_dataset = data.make_dataset(
bs=true_bs,
state_size=state_size,
num_timesteps=num_timesteps,
batch_size=num_eval_samples,
num_samples=num_eval_samples,
variance=FLAGS.variance,
prior_type=FLAGS.p_type,
bimodal_prior_weight=FLAGS.bimodal_prior_weight,
bimodal_prior_mean=FLAGS.bimodal_prior_mean,
transition_type=FLAGS.transition_type,
fixed_observation=FLAGS.fixed_observation,
dtype=dtype)
eval_itr = eval_dataset.make_one_shot_iterator()
_, eval_observations = eval_itr.get_next()
# Make the model.
if bound == "fivo-aux-td":
model = models.TDModel.create(
state_size,
num_timesteps,
variance=FLAGS.variance,
train_p=train_p,
p_type=FLAGS.p_type,
q_type=FLAGS.q_type,
mixing_coeff=FLAGS.bimodal_prior_weight,
prior_mode_mean=FLAGS.bimodal_prior_mean,
observation_variance=FLAGS.observation_variance,
transition_type=FLAGS.transition_type,
use_bs=FLAGS.use_bs,
dtype=tf.as_dtype(dtype),
random_seed=FLAGS.random_seed)
else:
model = models.Model.create(
state_size,
num_timesteps,
variance=FLAGS.variance,
train_p=train_p,
p_type=FLAGS.p_type,
q_type=FLAGS.q_type,
mixing_coeff=FLAGS.bimodal_prior_weight,
prior_mode_mean=FLAGS.bimodal_prior_mean,
observation_variance=FLAGS.observation_variance,
transition_type=FLAGS.transition_type,
use_bs=FLAGS.use_bs,
r_sigma_init=FLAGS.r_sigma_init,
dtype=tf.as_dtype(dtype),
random_seed=FLAGS.random_seed)
# Compute the bound and loss
if bound == "iwae":
(_, losses, ema_op, _, _) = bounds.iwae(model,
observations,
num_timesteps,
num_samples=num_samples)
(eval_log_p_hat, _, _, eval_states,
eval_log_weights) = bounds.iwae(model,
eval_observations,
num_timesteps,
num_samples=num_eval_samples,
summarize=True)
eval_log_p_hat = tf.reduce_mean(eval_log_p_hat)
elif "fivo" in bound:
if bound == "fivo-aux-td":
(_, losses, ema_op, _,
_) = bounds.fivo_aux_td(model,
observations,
num_timesteps,
resampling_schedule=resampling_schedule,
num_samples=num_samples)
(eval_log_p_hat, _, _, eval_states,
eval_log_weights) = bounds.fivo_aux_td(
model,
eval_observations,
num_timesteps,
resampling_schedule=resampling_schedule,
num_samples=num_eval_samples,
summarize=True)
else:
(_, losses, ema_op, _,
_) = bounds.fivo(model,
observations,
num_timesteps,
resampling_schedule=resampling_schedule,
use_resampling_grads=use_resampling_grads,
resampling_type=FLAGS.resampling_method,
aux=("aux" in bound),
num_samples=num_samples)
(eval_log_p_hat, _, _, eval_states,
eval_log_weights) = bounds.fivo(
model,
eval_observations,
num_timesteps,
resampling_schedule=resampling_schedule,
use_resampling_grads=False,
resampling_type="multinomial",
aux=("aux" in bound),
num_samples=num_eval_samples,
summarize=True)
eval_log_p_hat = tf.reduce_mean(eval_log_p_hat)
summ.summarize_ess(eval_log_weights, only_last_timestep=True)
# if FLAGS.p_type == "bimodal":
# # create the observations that showcase the model.
# mode_odds_ratio = tf.convert_to_tensor([1., 3., 1./3., 512., 1./512.],
# dtype=tf.float64)
# mode_odds_ratio = tf.expand_dims(mode_odds_ratio, 1)
# k = ((num_timesteps+1) * FLAGS.variance) / (2*FLAGS.bimodal_prior_mean)
# explain_obs = tf.reduce_sum(model.p.bs) + tf.log(mode_odds_ratio) * k
# explain_obs = tf.tile(explain_obs, [num_eval_samples, 1])
# # run the model on the explainable observations
# if bound == "iwae":
# (_, _, _, explain_states, explain_log_weights) = bounds.iwae(
# model,
# explain_obs,
# num_timesteps,
# num_samples=num_eval_samples)
# elif bound == "fivo" or "fivo-aux":
# (_, _, _, explain_states, explain_log_weights) = bounds.fivo(
# model,
# explain_obs,
# num_timesteps,
# resampling_schedule=resampling_schedule,
# use_resampling_grads=False,
# resampling_type="multinomial",
# aux=("aux" in bound),
# num_samples=num_eval_samples)
# summ.summarize_particles(explain_states,
# explain_log_weights,
# explain_obs,
# model)
# Calculate the true likelihood.
if hasattr(model.p, 'likelihood') and callable(
getattr(model.p, 'likelihood')):
eval_likelihood = model.p.likelihood(
eval_observations) / FLAGS.num_timesteps
else:
eval_likelihood = tf.zeros_like(eval_log_p_hat)
tf.summary.scalar("log_p_hat", eval_log_p_hat)
tf.summary.scalar("likelihood", eval_likelihood)
tf.summary.scalar("bound_gap", eval_likelihood - eval_log_p_hat)
summ.summarize_model(model,
true_bs,
eval_observations,
eval_states,
bound,
summarize_r=not bound == "fivo-aux-td")
# Compute and apply grads.
global_step = tf.train.get_or_create_global_step()
apply_grads = make_apply_grads_op(losses, global_step, learning_rate,
lr_decay_steps)
# Update the emas after applying the grads.
with tf.control_dependencies([apply_grads]):
train_op = tf.group(ema_op)
#train_op = tf.group(ema_op, add_check_numerics_ops())
return global_step, train_op, eval_log_p_hat, eval_likelihood
def main(args):
logger = init_logger(args.run_name)
# Datasets
img_height, img_width, _ = InceptionV3.SHAPE
def prep_func(f, x, y):
x = read_image(x)
x = decode_png(x)
x = resize(x, img_height, img_width)
return f, x, y
trn_ds = make_dataset(args.train_dir, args.batch_size, prep_func,
shuffle=True, repeat=True, add_filenames=True)
val_ds = make_dataset(args.train_dir, args.batch_size, prep_func,
shuffle=False, repeat=False, add_filenames=True)
tst_ds = make_dataset(args.train_dir, args.batch_size, prep_func,
shuffle=False, repeat=False, add_filenames=True)
num_classes = len(trn_ds.labels_map)
it = tf.data.Iterator.from_structure(
trn_ds.dataset.output_types, trn_ds.dataset.output_shapes)
num_trn_batches = int(math.ceil(float(trn_ds.size) / args.batch_size))
num_val_batches = int(math.ceil(float(val_ds.size) / args.batch_size))
num_tst_batches = int(math.ceil(float(tst_ds.size) / args.batch_size))
trn_init_op = it.make_initializer(trn_ds.dataset)
val_init_op = it.make_initializer(val_ds.dataset)
tst_init_op = it.make_initializer(tst_ds.dataset)
# Filename, input image and corrsponding one hot encoded label
f, x, y = it.get_next()
sess = tf.Session()
# Model and logits
is_training = tf.placeholder(dtype=tf.bool)
model = InceptionV3(nb_classes=num_classes, is_training=is_training)
logits = model.get_logits(x)
attacks_ord = {
'inf': np.inf,
'1': 1,
'2': 2
}
# FGM attack
attack_params = {
'eps': args.eps,
'clip_min': 0.0,
'clip_max': 1.0,
'ord': attacks_ord[args.ord],
}
attack = FastGradientMethod(model, sess)
# Learning rate with exponential decay
global_step = tf.Variable(0, trainable=False)
global_step_update_op = tf.assign(global_step, tf.add(global_step, 1))
lr = tf.train.exponential_decay(
args.initial_lr, global_step, args.lr_decay_steps,
args.lr_decay_factor, staircase=True)
cross_entropy = CrossEntropy(model, attack=attack,
smoothing=args.label_smth,
attack_params=attack_params,
adv_coeff=args.adv_coeff)
loss = cross_entropy.fprop(x, y)
# Gradients clipping
opt = tf.train.RMSPropOptimizer(learning_rate=lr, decay=args.opt_decay,
epsilon=1.0)
gvs = opt.compute_gradients(loss)
clip_min, clip_max = -args.grad_clip, args.grad_clip
capped_gvs = []
for g, v in gvs:
capped_g = tf.clip_by_value(g, clip_min, clip_max) \
if g is not None else tf.zeros_like(v)
capped_gvs.append((capped_g, v))
train_op = opt.apply_gradients(capped_gvs)
saver = tf.train.Saver()
global_init_op = tf.global_variables_initializer()
if args.load_model and args.restore_path:
saver.restore(sess, args.restore_path)
logger.info("Model restored from: ".format(args.restore_path))
with sess.as_default():
sess.run(global_init_op)
best_val_acc = -1
for epoch in range(args.num_epochs):
logger.info("Epoch: {:04d}/{:04d}".format(epoch + 1, args.num_epochs))
sess.run(trn_init_op)
for batch in range(num_trn_batches):
loss_np, lr_np, _ = sess.run([loss, lr, train_op],
feed_dict={is_training: True})
logger.info("Batch: {:04d}/{:04d}, loss: {:.05f}, lr: {:.05f}"
.format(batch + 1, num_trn_batches, loss_np, lr_np))
logger.info("Epoch completed...")
sess.run(global_step_update_op)
val_acc = eval_acc(sess, logits, y, num_val_batches,
is_training, val_init_op)
logger.info("Validation set accuracy: {:.05f}".format(val_acc))
if best_val_acc < val_acc:
output_path = saver.save(sess, args.model_path)
logger.info("Model was successfully saved: {}".format(output_path))
best_val_acc = val_acc
pass
tst_acc = eval_acc(sess, logits, y, num_tst_batches,
is_training, tst_init_op)
logger.info("Test set accuracy: {:.05f}".format(tst_acc))
os.mkdir('output')
if not os.path.exists(output_dir):
os.mkdir(output_dir)
# save settings
with open(os.path.join(output_dir, 'settings.yml'), "w", encoding="utf-8") as f:
yaml.dump(args, f)
# others
use_gpu = torch.cuda.is_available()
device = torch.device("cuda" if use_gpu else "cpu")
# dataset
data_loader, shape = data.make_dataset(args.dataset, args.batch_size, args.img_size,pin_memory=use_gpu)
#n_G_upsamplings = n_D_downsamplings = 5 # 3: 32x32 4:64:64 5:128 6:256
print('data-size: '+str(shape))
# ==============================================================================
# = model =
# ==============================================================================
# networks
G = net.Generator(input_dim=args.z_dim, output_channels = args.img_channels, image_size=args.img_size, scale=args.Gscale).to(device)
D = net.Discriminator_SpectrualNorm(args.z_dim, input_channels = args.img_channels, image_size=args.img_size, scale=args.Dscale).to(device)
with open(output_dir+'/net.txt','w+') as f:
#if os.path.getsize(output_dir+'/net.txt') == 0: #判断文件是否为空
print(G,file=f)
os.mkdir(params.checkpoint_dir)
os.mkdir(params.log_dir)
except FileExistsError:
pass
configure(params.log_dir)
input_dim = 300
output_dim = 512
print('Starting with params:', params)
# Pre-process data and create dataloaders =====================================
# %%
print('Pre-processing data')
(train, valid, test) = data.make_dataset(params)
train_loader = dd.DataLoader(dataset=train,
batch_size=params.batch_size,
shuffle=True)
valid_loader = dd.DataLoader(dataset=valid,
batch_size=params.batch_size,
shuffle=True)
test_loader = dd.DataLoader(dataset=test,
batch_size=params.batch_size,
shuffle=True)
# Create model, optimizer, and criterion ======================================
print('Creating model')
model = models.LinearDifference(input_dim, output_dim)
if params.model_path != '':
