def pre(self):
"""Get PRE for release"""
from pre import Pre
pre = Pre(self.release_name)
pre.get_pre()
self.pre_fetched = True
return pre
def __init__(self):
self.state = 'pre'
# init pygame
pygame.init()
pygame.mixer.init(44100, 16, 2, 1024*4)
pygame.display.set_caption("MR. TRAPEZIUS ")
try:
self.screen = pygame.display.set_mode((640, 480),
HWSURFACE | SRCALPHA, 32)
except:
self.screen = pygame.display.set_mode((640, 480),
SRCALPHA, 32)
try:
pygame.display.set_icon(pygame.image.load(
util.file_path("Inky.png")).convert_alpha())
except:
# some platfom do not allow change icon after shown
pass
# init fonts and music lists
util.init()
# init sub states objects
self.pre = Pre(self.screen)
self.go = MainGame(self.screen)
self.level_info = Level(self.screen)
self.re = Retry(self.screen)
self.next = NextLevel(self.screen)
sound.load()
def load_local_data(index, cl_b1, cl_a2):
kdat = KDat(index)
pro = Pro(index, kdat.k, cl_b1, cl_a2)
pre = Pre(index, kdat.k, cl_b1, cl_a2)
pdat = PDat(index, kdat.k, cl_b1, cl_a2)
return kdat.loaded and pro.generated and pre.generated, \
kdat.k, pro.pro, pre.pre, pdat.p
def generate_p(k, cl, force_calc):
success = True
pro = Pro(k.index, k.k, cl.b1, cl.a2, force_calc)
pre = Pre(k.index, k.k, cl.b1, cl.a2, force_calc)
p = None
if pro.generated:
if pre.generated:
p = PDat(k.index, k.k, pro.pro, pre.pre, cl.b1, cl.a2, force_calc)
else:
print "ERROR: pre not generated."
success = False
else:
print "ERROR: pro not generated."
success = False
return success, pro, pre, p
def calc_pre_data(r, cl_data, res_data):
lo_data, lo_target_data = Pre.get_data_for_pre(r[R_NAME_1_COL], cl_data,
res_data, True)
lo_mdl = Pre.get_mdl(r[R_NAME_1_COL])
lo_pre = Pre.get_pre_values(lo_data, lo_target_data, lo_mdl.lo_mdls)
vi_data, vi_target_data = Pre.get_data_for_pre(r[R_NAME_2_COL], cl_data,
res_data, False)
vi_mdl = Pre.get_mdl(r[R_NAME_2_COL])
vi_pre = Pre.get_pre_values(vi_data, vi_target_data, vi_mdl.vi_mdls)
return combine_lo_vi(lo_pre, vi_pre)
def comb_algorithm(l, m, n, dataset_original1, privileged_groups1,
unprivileged_groups1, optim_options1):
dataset_original2 = copy.deepcopy(dataset_original1)
privileged_groups2 = copy.deepcopy(privileged_groups1)
unprivileged_groups2 = copy.deepcopy(unprivileged_groups1)
optim_options2 = copy.deepcopy(optim_options1)
print(l, m, n)
dataset_orig_train, dataset_orig_vt = dataset_original2.split([0.7],
shuffle=True)
dataset_orig_valid, dataset_orig_test = dataset_orig_vt.split([0.5],
shuffle=True)
if l == 0:
dataset_transf_train, dataset_transf_valid, dataset_transf_test = dataset_orig_train, dataset_orig_valid, dataset_orig_test
else:
pre_used = preAlgorithm[l - 1]
dataset_transf_train, dataset_transf_valid, dataset_transf_test = Pre(
pre_used, dataset_orig_train, dataset_orig_valid,
dataset_orig_test, privileged_groups2, unprivileged_groups2,
optim_options2)
#assert (l,m,n)!=(2,0,0)
#assert not np.all(dataset_transf_train.labels.flatten()==1.0)
if m == 0:
dataset_transf_valid_pred, dataset_transf_test_pred = train(
dataset_transf_train, dataset_transf_valid, dataset_transf_test,
privileged_groups2, unprivileged_groups2)
else:
in_used = inAlgorithm[m - 1]
if in_used == "adversarial_debiasing":
dataset_transf_valid_pred, dataset_transf_test_pred = adversarial_debiasing(
dataset_transf_train, dataset_transf_valid,
dataset_transf_test, privileged_groups2, unprivileged_groups2)
elif in_used == "art_classifier":
dataset_transf_valid_pred, dataset_transf_test_pred = art_classifier(
dataset_transf_train, dataset_transf_valid,
dataset_transf_test, privileged_groups2, unprivileged_groups2)
elif in_used == "prejudice_remover":
for key, value in privileged_groups2[0].items():
sens_attr = key
dataset_transf_valid_pred, dataset_transf_test_pred = prejudice_remover(
dataset_transf_train, dataset_transf_valid,
dataset_transf_test, privileged_groups2, unprivileged_groups2,
sens_attr)
if n == 0:
dataset_transf_test_pred_transf = dataset_transf_test_pred
else:
post_used = postAlgorithm[n - 1]
if post_used == "calibrated_eqodds":
cpp = CalibratedEqOddsPostprocessing(
privileged_groups=privileged_groups2,
unprivileged_groups=unprivileged_groups2,
cost_constraint=cost_constraint,
seed=1)
cpp = cpp.fit(dataset_transf_valid, dataset_transf_valid_pred)
dataset_transf_test_pred_transf = cpp.predict(
dataset_transf_test_pred)
elif post_used == "eqodds":
EO = EqOddsPostprocessing(unprivileged_groups=unprivileged_groups2,
privileged_groups=privileged_groups2,
seed=1)
EO = EO.fit(dataset_transf_valid, dataset_transf_valid_pred)
dataset_transf_test_pred_transf = EO.predict(
dataset_transf_test_pred)
elif post_used == "reject_option":
ROC = RejectOptionClassification(
unprivileged_groups=unprivileged_groups2,
privileged_groups=privileged_groups2,
low_class_thresh=0.01,
high_class_thresh=0.99,
num_class_thresh=100,
num_ROC_margin=50,
metric_name=allowed_metrics[0],
metric_ub=metric_ub,
metric_lb=metric_lb)
ROC = ROC.fit(dataset_transf_valid, dataset_transf_valid_pred)
dataset_transf_test_pred_transf = ROC.predict(
dataset_transf_test_pred)
metric = ClassificationMetric(dataset_transf_test,
dataset_transf_test_pred_transf,
unprivileged_groups=unprivileged_groups2,
privileged_groups=privileged_groups2)
metrics = OrderedDict()
metrics["Classification accuracy"] = metric.accuracy()
TPR = metric.true_positive_rate()
TNR = metric.true_negative_rate()
bal_acc_nodebiasing_test = 0.5 * (TPR + TNR)
metrics["Balanced classification accuracy"] = bal_acc_nodebiasing_test
metrics[
"Statistical parity difference"] = metric.statistical_parity_difference(
)
metrics["Disparate impact"] = metric.disparate_impact()
metrics[
"Equal opportunity difference"] = metric.equal_opportunity_difference(
)
metrics["Average odds difference"] = metric.average_odds_difference()
metrics["Theil index"] = metric.theil_index()
metrics["United Fairness"] = metric.generalized_entropy_index()
# print(metrics)
feature = "["
for m in metrics:
feature = feature + " " + str(round(metrics[m], 4))
feature = feature + "]"
return feature
def main(args):
# Get the list of filenames and corresponding list of labels for training et validation
if os.path.isfile(args.data_desc):
p = Pre().loadData(args.data_desc)
else:
p = Pre().createData(args.data_desc, args.data_path, data_thresh=4, verbose=True)
p.saveData(args.data_desc)
# train_filenames, train_labels = list_images(args.train_dir)
# val_filenames, val_labels = list_images(args.val_dir)
for fold in [args.data_folds]:
fold_no = 0
if args.data_augment:
data_iterator = p.get_augmented_train_and_test_data(
n_augmentations=args.n_augmentations,
n_splits=args.data_folds, balance=args.data_oversample,
augmentation_dir=args.augment_dir)
else:
data_iterator = p.get_cv_train_and_test_data(n_splits=args.data_folds, balance=args.data_oversample)
for train_filenames, train_labels, val_filenames, val_labels in data_iterator:
tf.reset_default_graph()
# Count the fold iterations
fold_no += 1
assert set(train_labels) == set(val_labels),\
"Train and val labels don't correspond:\n{}\n{}".format(set(train_labels),
set(val_labels))
num_classes = len(set(train_labels))
unique_name = args.model_name
# --------------------------------------------------------------------------
# In TensorFlow, you first want to define the computation graph with all the
# necessary operations: loss, training op, accuracy...
# Any tensor created in the `graph.as_default()` scope will be part of `graph`
graph = tf.Graph()
with graph.as_default():
# Standard preprocessing for VGG on ImageNet taken from here:
# https://github.com/tensorflow/models/blob/master/research/slim/preprocessing/vgg_preprocessing.py
# Also see the VGG paper for more details: https://arxiv.org/pdf/1409.1556.pdf
# Preprocessing (for both training and validation):
# (1) Decode the image from jpg format
# (2) Resize the image so its smaller side is 256 pixels long
def _parse_function(filename, label):
image_string = tf.read_file(filename)
image_decoded = tf.image.decode_jpeg(image_string, channels=3) # (1)
image = tf.cast(image_decoded, tf.float32)
smallest_side = 256.0
height, width = tf.shape(image)[0], tf.shape(image)[1]
height = tf.to_float(height)
width = tf.to_float(width)
scale = tf.cond(tf.greater(height, width),
lambda: smallest_side / width,
lambda: smallest_side / height)
new_height = tf.to_int32(height * scale)
new_width = tf.to_int32(width * scale)
resized_image = tf.image.resize_images(image, [new_height, new_width]) # (2)
return resized_image, label
# Preprocessing (for training)
# (3) Take a random 224x224 crop to the scaled image
# (4) Horizontally flip the image with probability 1/2
# (5) Substract the per color mean `VGG_MEAN`
# Note: we don't normalize the data here, as VGG was trained without normalization
def training_preprocess(image, label):
crop_image = tf.random_crop(image, [224, 224, 3]) # (3)
flip_image = tf.image.random_flip_left_right(crop_image) # (4)
means = tf.reshape(tf.constant(VGG_MEAN), [1, 1, 3])
centered_image = flip_image - means # (5)
return centered_image, label
# Preprocessing (for validation)
# (3) Take a central 224x224 crop to the scaled image
# (4) Substract the per color mean `VGG_MEAN`
# Note: we don't normalize the data here, as VGG was trained without normalization
def val_preprocess(image, label):
crop_image = tf.image.resize_image_with_crop_or_pad(image, 224, 224) # (3)
means = tf.reshape(tf.constant(VGG_MEAN), [1, 1, 3])
centered_image = crop_image - means # (4)
return centered_image, label
# ----------------------------------------------------------------------
# DATASET CREATION using tf.contrib.data.Dataset
# https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/data
# The tf.contrib.data.Dataset framework uses queues in the background to feed in
# data to the model.
# We initialize the dataset with a list of filenames and labels, and then apply
# the preprocessing functions described above.
# Behind the scenes, queues will load the filenames, preprocess them with multiple
# threads and apply the preprocessing in parallel, and then batch the data
# Training dataset
train_dataset = tf.contrib.data.Dataset.from_tensor_slices((train_filenames, train_labels))
train_dataset = train_dataset.map(_parse_function,
num_threads=args.num_workers, output_buffer_size=args.batch_size)
train_dataset = train_dataset.map(training_preprocess,
num_threads=args.num_workers, output_buffer_size=args.batch_size)
train_dataset = train_dataset.shuffle(buffer_size=10000) # don't forget to shuffle
batched_train_dataset = train_dataset.batch(args.batch_size)
# Validation dataset
val_dataset = tf.contrib.data.Dataset.from_tensor_slices((val_filenames, val_labels))
val_dataset = val_dataset.map(_parse_function,
num_threads=args.num_workers, output_buffer_size=args.batch_size)
val_dataset = val_dataset.map(val_preprocess,
num_threads=args.num_workers, output_buffer_size=args.batch_size)
batched_val_dataset = val_dataset.batch(args.batch_size)
# Now we define an iterator that can operator on either dataset.
# The iterator can be reinitialized by calling:
# - sess.run(train_init_op) for 1 epoch on the training set
# - sess.run(val_init_op) for 1 epoch on the valiation set
# Once this is done, we don't need to feed any value for images and labels
# as they are automatically pulled out from the iterator queues.
# A reinitializable iterator is defined by its structure. We could use the
# `output_types` and `output_shapes` properties of either `train_dataset`
# or `validation_dataset` here, because they are compatible.
iterator = tf.contrib.data.Iterator.from_structure(batched_train_dataset.output_types,
batched_train_dataset.output_shapes)
images, labels = iterator.get_next()
train_init_op = iterator.make_initializer(batched_train_dataset)
val_init_op = iterator.make_initializer(batched_val_dataset)
# Indicates whether we are in training or in test mode
is_training = tf.placeholder(tf.bool)
# ---------------------------------------------------------------------
# Now that we have set up the data, it's time to set up the model.
# For this example, we'll use VGG-16 pretrained on ImageNet. We will remove the
# last fully connected layer (fc8) and replace it with our own, with an
# output size num_classes=8
# We will first train the last layer for a few epochs.
# Then we will train the entire model on our dataset for a few epochs.
# Get the pretrained model, specifying the num_classes argument to create a new
# fully connected replacing the last one, called "vgg_16/fc8"
# Each model has a different architecture, so "vgg_16/fc8" will change in another model.
# Here, logits gives us directly the predicted scores we wanted from the images.
# We pass a scope to initialize "vgg_16/fc8" weights with he_initializer
vgg = tf.contrib.slim.nets.vgg
with slim.arg_scope(vgg.vgg_arg_scope(weight_decay=args.weight_decay)):
logits, _ = vgg.vgg_16(images, num_classes=num_classes, is_training=is_training,
dropout_keep_prob=args.dropout_keep_prob)
# Specify where the model checkpoint is (pretrained weights).
model_path = args.model_path
assert(os.path.isfile(model_path))
# Restore only the layers up to fc7 (included)
# Calling function `init_fn(sess)` will load all the pretrained weights.
variables_to_restore = tf.contrib.framework.get_variables_to_restore(exclude=['vgg_16/fc8'])
init_fn = tf.contrib.framework.assign_from_checkpoint_fn(model_path, variables_to_restore)
# Initialization operation from scratch for the new "fc8" layers
# `get_variables` will only return the variables whose name starts with the given pattern
fc8_variables = tf.contrib.framework.get_variables('vgg_16/fc8')
fc8_init = tf.variables_initializer(fc8_variables)
# ---------------------------------------------------------------------
# Using tf.losses, any loss is added to the tf.GraphKeys.LOSSES collection
# We can then call the total loss easily
with tf.name_scope('Loss'):
tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
loss = tf.losses.get_total_loss()
tf.summary.scalar("train", loss, collections=['train'])
tf.summary.scalar("valid", loss, collections=['valid'])
# First we want to train only the reinitialized last layer fc8 for a few epochs.
# We run minimize the loss only with respect to the fc8 variables (weight and bias).
fc8_optimizer = tf.train.GradientDescentOptimizer(args.learning_rate1)
fc8_train_op = fc8_optimizer.minimize(loss, var_list=fc8_variables)
# Then we want to finetune the entire model for a few epochs.
# We run minimize the loss only with respect to all the variables.
full_optimizer = tf.train.GradientDescentOptimizer(args.learning_rate2)
full_train_op = full_optimizer.minimize(loss)
# Evaluation metrics
with tf.name_scope('Accuracy'):
prediction = tf.to_int32(tf.argmax(logits, 1))
correct_prediction = tf.equal(prediction, tf.cast(labels, tf.int32))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# tf.summary.scalar("train", accuracy, collections=['train'])
# tf.summary.scalar("valid", accuracy, collections=['valid'])
merged_summary_op = tf.cond(
is_training,
lambda: tf.summary.merge_all('train'),
lambda: tf.summary.merge_all('valid'))
tf.get_default_graph().finalize()
# --------------------------------------------------------------------------
# Now that we have built the graph and finalized it, we define the session.
# The session is the interface to *run* the computational graph.
# We can call our training operations with `sess.run(train_op)` for instance
with tf.Session(graph=graph) as sess:
init_fn(sess) # load the pretrained weights
sess.run(fc8_init) # initialize the new fc8 layer
# Create a log writer, run 'tensorboard --logdir=./logs/vgg_logs'
dirs = ["./logs/vgg_logs/", str(num_classes), unique_name, str(args.data_folds), str(fold_no)]
run_log_dir = os.path.join(*dirs)
summary_writer = tf.summary.FileWriter(run_log_dir, graph=tf.get_default_graph())
summary_writer.add_graph(sess.graph)
# Update only the last layer for a few epochs.
step = 0
for epoch in range(1, args.num_epochs1 + 1):
# Run an epoch over the training data.
print('Starting epoch %d / %d' % (epoch, args.num_epochs1))
# Here we initialize the iterator with the training set.
# This means that we can go through an entire epoch until the iterator becomes empty.
sess.run(train_init_op)
while True:
try:
_, summary = sess.run(
[fc8_train_op, merged_summary_op],
feed_dict={is_training: True})
except tf.errors.OutOfRangeError:
break
step += 1
# # Initialize the correct dataset
# sess.run(val_init_op)
# while True:
# try:
# acc, summary_2 = sess.run([accuracy, merged_summary_op], {is_training: False})
# print('Validation accuracy: %f' % acc)
# except tf.errors.OutOfRangeError:
# break
# Check accuracy on the train and val sets every epoch.
train_acc = check_accuracy(sess, correct_prediction, is_training, train_init_op)
val_acc = check_accuracy(sess, correct_prediction, is_training, val_init_op)
print('Train accuracy: %f' % train_acc)
print('Val accuracy: %f\n' % val_acc)
# Create a new Summary for accuracy
summary_2 = tf.Summary()
summary_2.value.add(tag="accuracy/validation", simple_value=val_acc)
summary_2.value.add(tag="accuracy/training", simple_value=train_acc)
# Add it to the Tensorboard summary writer
summary_writer.add_summary(summary_2, epoch)
# Write logs at every epoch
summary_writer.add_summary(summary, epoch)
# summary_writer.add_summary(summary_2, epoch)
summary_writer.flush()
def comb_algorithm(l, m, n, dataset_original1, privileged_groups1,
unprivileged_groups1, optim_options1):
dataset_original2 = copy.deepcopy(dataset_original1)
privileged_groups2 = copy.deepcopy(privileged_groups1)
unprivileged_groups2 = copy.deepcopy(unprivileged_groups1)
optim_options2 = copy.deepcopy(optim_options1)
print(l, m, n)
dataset_original_train, dataset_original_vt = dataset_original2.split(
[0.7], shuffle=True)
dataset_original_valid, dataset_original_test = dataset_original_vt.split(
[0.5], shuffle=True)
dataset_original_test.labels = dataset_original_test.labels
print('=======================')
#print(dataset_original_test.labels)
dataset_orig_train = copy.deepcopy(dataset_original_train)
dataset_orig_valid = copy.deepcopy(dataset_original_valid)
dataset_orig_test = copy.deepcopy(dataset_original_test)
if l == 0:
dataset_transfer_train = copy.deepcopy(dataset_original_train)
dataset_transfer_valid = copy.deepcopy(dataset_original_valid)
dataset_transfer_test = copy.deepcopy(dataset_original_test)
#dataset_transf_train, dataset_transf_valid, dataset_transf_test = dataset_orig_train, dataset_orig_valid, dataset_orig_test
else:
pre_used = preAlgorithm[l - 1]
dataset_transfer_train, dataset_transfer_valid, dataset_transfer_test = Pre(
pre_used, dataset_orig_train, dataset_orig_valid,
dataset_orig_test, privileged_groups2, unprivileged_groups2,
optim_options2)
dataset_transf_train = copy.deepcopy(dataset_transfer_train)
dataset_transf_valid = copy.deepcopy(dataset_transfer_valid)
dataset_transf_test = copy.deepcopy(dataset_transfer_test)
if m == 0:
dataset_transfer_valid_pred, dataset_transfer_test_pred = plain_model(
dataset_transf_train, dataset_transf_valid, dataset_transf_test,
privileged_groups2, unprivileged_groups2)
else:
in_used = inAlgorithm[m - 1]
if in_used == "adversarial_debiasing":
dataset_transfer_valid_pred, dataset_transfer_test_pred = adversarial_debiasing(
dataset_transf_train, dataset_transf_valid,
dataset_transf_test, privileged_groups2, unprivileged_groups2)
elif in_used == "art_classifier":
dataset_transfer_valid_pred, dataset_transfer_test_pred = art_classifier(
dataset_transf_train, dataset_transf_valid,
dataset_transf_test, privileged_groups2, unprivileged_groups2)
elif in_used == "prejudice_remover":
for key, value in privileged_groups2[0].items():
sens_attr = key
dataset_transfer_valid_pred, dataset_transfer_test_pred = prejudice_remover(
dataset_transf_train, dataset_transf_valid,
dataset_transf_test, privileged_groups2, unprivileged_groups2,
sens_attr)
dataset_transf_valid_pred = copy.deepcopy(dataset_transfer_valid_pred)
dataset_transf_test_pred = copy.deepcopy(dataset_transfer_test_pred)
if n == 0:
dataset_transf_test_pred_transf = copy.deepcopy(
dataset_transfer_test_pred)
else:
post_used = postAlgorithm[n - 1]
if post_used == "calibrated_eqodds":
cpp = CalibratedEqOddsPostprocessing(
privileged_groups=privileged_groups2,
unprivileged_groups=unprivileged_groups2,
cost_constraint=cost_constraint)
cpp = cpp.fit(dataset_transfer_valid, dataset_transf_valid_pred)
dataset_transf_test_pred_transf = cpp.predict(
dataset_transf_test_pred)
elif post_used == "eqodds":
EO = EqOddsPostprocessing(unprivileged_groups=unprivileged_groups2,
privileged_groups=privileged_groups2)
EO = EO.fit(dataset_transfer_valid, dataset_transf_valid_pred)
dataset_transf_test_pred_transf = EO.predict(
dataset_transf_test_pred)
elif post_used == "reject_option":
#dataset_transf_test_pred_transf = reject_option(dataset_transf_valid, dataset_transf_valid_pred, dataset_transf_test, dataset_transf_test_pred, privileged_groups2, unprivileged_groups2)
ROC = RejectOptionClassification(
unprivileged_groups=unprivileged_groups2,
privileged_groups=privileged_groups2)
ROC = ROC.fit(dataset_transfer_valid, dataset_transf_valid_pred)
dataset_transf_test_pred_transf = ROC.predict(
dataset_transf_test_pred)
#print('=======================')
org_labels = dataset_orig_test.labels
print(dataset_orig_test.labels)
#print(dataset_transf_test.labels)
#print('=======================')
pred_labels = dataset_transf_test_pred.labels
print(dataset_transf_test_pred.labels)
true_pred = org_labels == pred_labels
print("acc after in: ", float(np.sum(true_pred)) / pred_labels.shape[1])
#print('=======================')
#print(dataset_transf_test_pred_transf.labels)
#print(dataset_transf_test_pred_transf.labels.shape)
metric = ClassificationMetric(dataset_transfer_test,
dataset_transf_test_pred_transf,
unprivileged_groups=unprivileged_groups2,
privileged_groups=privileged_groups2)
metrics = OrderedDict()
metrics["Classification accuracy"] = metric.accuracy()
TPR = metric.true_positive_rate()
TNR = metric.true_negative_rate()
bal_acc_nodebiasing_test = 0.5 * (TPR + TNR)
metrics["Balanced classification accuracy"] = bal_acc_nodebiasing_test
metrics[
"Statistical parity difference"] = metric.statistical_parity_difference(
)
metrics["Disparate impact"] = metric.disparate_impact()
metrics[
"Equal opportunity difference"] = metric.equal_opportunity_difference(
)
metrics["Average odds difference"] = metric.average_odds_difference()
metrics["Theil index"] = metric.theil_index()
metrics["United Fairness"] = metric.generalized_entropy_index()
feature = []
feature_str = "["
for m in metrics:
data = round(metrics[m], 4)
feature.append(data)
feature_str = feature_str + str(data) + " "
feature_str = feature_str + "]"
return feature, feature_str
def main(args):
# Initialise data paths
if os.path.isfile(args.data_desc):
p = Pre().loadData(args.data_desc)
else:
exit(1)
# p = Pre().createData(args.data_desc, args.data_path, data_thresh=4, verbose=True)
# p.saveData(args.data_desc)
# Cross-validation iterator with optional augmentation,
# number of folds and training data oversampling
if args.data_augment:
data_iterator = p.get_augmented_train_and_test_data(
n_augmentations=args.n_augmentations,
n_splits=args.data_folds, balance=args.data_oversample,
augmentation_dir=args.augment_dir)
else:
data_iterator = p.get_cv_train_and_test_data(
n_splits=args.data_folds, balance=args.data_oversample)
fold_no = 0
for train_path, train_label, test_path, test_label in data_iterator:
# Reset graph for each iteration
tf.reset_default_graph()
# Count the fold iterations
fold_no += 1
# Ensure same labels for train and validation data
assert set(train_label) == set(test_label),\
"Train and val labels don't correspond:\n{}\n{}".format(set(train_label), set(test_label))
# Get number of classes from data labels
num_classes = len(set(train_label))
# Build the training data input
X, Y = read_images(train_path, train_label, args, is_training=True)
# Build the validation data input
X_V, Y_V = read_images(test_path, test_label, args, is_training=False)
# Create a graph for training
logits_train = conv_net(X, num_classes, args, reuse=False, is_training=True)
# Create a graph for testing that reuses the same weights and has no dropout
logits_test = conv_net(X, num_classes, args, reuse=True, is_training=False)
# Create a graph for validation that reuses the same weights and has no dropout
logits_validation = conv_net(X_V, num_classes, args, reuse=True, is_training=False)
with tf.name_scope("loss"):
# Define loss and optimizer (with train logits, for dropout to take effect)
loss_op = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=logits_train, labels=Y))
tf.summary.scalar("training", loss_op)
# Define loss of validation
validation_op = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=logits_validation, labels=Y_V))
tf.summary.scalar("validation", validation_op)
optimizer = tf.train.AdamOptimizer(learning_rate=args.learning_rate)
train_op = optimizer.minimize(loss_op)
with tf.name_scope("accuracy"):
# Evaluate model (with test logits, for dropout to be disabled)
correct_pred = tf.equal(tf.argmax(logits_test, 1), tf.cast(Y, tf.int64))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
tf.summary.scalar("training", accuracy)
# Evaluate model (with validation logits, for dropout to be disabled)
correct_pred_v = tf.equal(tf.argmax(logits_validation, 1), tf.cast(Y_V, tf.int64))
accuracy_valid = tf.reduce_mean(tf.cast(correct_pred_v, tf.float32))
tf.summary.scalar("validation", accuracy_valid)
# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()
# Start training
with tf.Session() as sess:
# Create a log writer, run 'tensorboard --logdir=./logs/nn_logs'
dirs = ["./logs/nn_logs/", str(num_classes), args.model_name, str(args.data_folds), str(fold_no)]
run_log_dir = os.path.join(*dirs)
writer = tf.summary.FileWriter(run_log_dir, sess.graph)
merged = tf.summary.merge_all()
desc = ("net type: " + "Basic CNN" +
"\nname: " + str(args.model_name) +
"\nn_classes: " + str(num_classes) +
"\nimg_size: " + str(args.img_dim) +
"\nbatch_mode: " + "shuffle" +
"\nbatch_size: " + str(args.batch_size) +
"\ndata_folds: " + str(args.data_folds) +
"\nnum_epochs: " + str(args.num_epochs) +
"\nlearning_rate: " + str(args.learning_rate) +
"\ndropout_keep_prob: " + str(args.dropout_keep_prob)
)
# Run the initializer
sess.run(init)
# Add run description
with open(run_log_dir + '/run_info.txt', 'w') as f:
f.write(desc)
# Start the data queue
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
# Training cycle
samples = len(train_path)
batches_per_epoch = int(ceil(float(samples) / args.batch_size))
for step in range(1, batches_per_epoch * (args.num_epochs + 1)):
# Track values every epoch
if step % batches_per_epoch == 0:
# Run optimization and calculate batch loss and accuracy
_, loss, acc = sess.run([train_op, loss_op, accuracy])
# Run through an epoch of validation data
y_true = []
y_pred = []
valid_acc = 0
for v in range(batches_per_epoch):
valid, logits_valid, y_v = sess.run([accuracy_valid, tf.argmax(logits_validation, 1), Y_V])
y_true += map(lambda x: str(x), y_v.tolist())
y_pred += map(lambda x: str(x), logits_valid.tolist())
valid_acc += valid
# Average validation batch accuracy
valid_acc = valid_acc / batches_per_epoch
# Validation data confusion matrix summary
img_d_summary = plot_confusion_matrix(
y_true,
y_pred,
map(lambda x: str(x), range(num_classes)),
tensor_name='ConfusionMatrix')
writer.add_summary(img_d_summary, step / batches_per_epoch)
summary = sess.run(merged)
writer.add_summary(summary, step / batches_per_epoch)
print("Epoch=" + str(int(step / batches_per_epoch)) +
", Minibatch Loss= " + "{:.4f}".format(loss) +
", Validation Accuracy= " + "{:.4f}".format(valid_acc) +
", Training Accuracy= " + "{:.3f}".format(acc))
print("True batch labels= " + str(y_v) + "\n" +
"Assigned labels= " + str(logits_valid))
else:
# Only run the optimization op (backprop)
sess.run(train_op)
print("Optimization Finished!")
# Free resources from session and stop queue threads
coord.request_stop()
coord.join(threads)
sess.close()
class Game(object):
"""main loop, switching from different states"""
def __init__(self):
self.state = 'pre'
# init pygame
pygame.init()
pygame.mixer.init(44100, 16, 2, 1024*4)
pygame.display.set_caption("MR. TRAPEZIUS ")
try:
self.screen = pygame.display.set_mode((640, 480),
HWSURFACE | SRCALPHA, 32)
except:
self.screen = pygame.display.set_mode((640, 480),
SRCALPHA, 32)
try:
pygame.display.set_icon(pygame.image.load(
util.file_path("Inky.png")).convert_alpha())
except:
# some platfom do not allow change icon after shown
pass
# init fonts and music lists
util.init()
# init sub states objects
self.pre = Pre(self.screen)
self.go = MainGame(self.screen)
self.level_info = Level(self.screen)
self.re = Retry(self.screen)
self.next = NextLevel(self.screen)
sound.load()
def loop(self):
while self.state != 'quit':
print self.state
if self.state == 'pre':
self.state = self.pre.run()
elif self.state == 'pretending':
self.state = self.pre.show_pretend_loading()
elif self.state.startswith('level'):
info_mode = int(self.state[-1])
print self.state, info_mode
self.state = self.level_info.run(info_mode)
elif self.state.startswith('game'):
mode = int(self.state[-1])
self.state = self.go.run(mode)
elif self.state.startswith('next'):
nextlevel = int(self.state[-1])
self.state = self.next.run(nextlevel)
elif self.state.startswith('retry'):
retrylevel = int(self.state[-1])
self.state = self.re.run(retrylevel)
# pygame.display.update()
pygame.quit()
exit()
