def on_execute(self):
"""Executes an algorithm several times"""
while self.runs < self.maxRuns:
# continue running until algorithm is done
while self.algorithm.isDone is False:
self.algorithm.execute()
self.dataHelper.writeCSVLine(self.area)
# if algorithm completes one run, reset state
if self.algorithm.isDone is True and self.runs < self.maxRuns:
print('Run {} is complete! 🎉'.format(self.runs))
# save area to csv
self.dataHelper.writeArea(self.area)
self.dataHelper = DataHelper()
# reset area and algorithm
self.area = copy.deepcopy(self.originalArea)
self.algorithm = copy.copy(self.originalAlgorithm)
self.algorithm.area = self.area
self.runs += 1
if self.runs == self.maxRuns:
print('✨✨ I succesfully ran {}'
'times! ✨✨'.format(self.runs))
def __init__(self, logging, graph=None, file=None, start=0, ints=False):
self.logging = logging
if not os.path.isdir(logging): os.mkdir(logging)
if graph == None and file != None:
self.helper = DataHelper(file, NP=False)
self.samples = self.helper.GetSamples()
if ints == True:
samples = []
for i in self.samples:
samples.append([int(i[0]), int(i[1]), int(i[2])])
self.samples = np.array(samples)
self.G = self.readGraph(file, ints=ints)
self.uG = self.readGraph(file, ints=ints, unweight=True)
elif graph != None and file == None:
self.G = graph
self.uG = nx.Graph(self.G)
self.samples = []
for edge in self.G.edges():
for i in self.G[edge[0]][edge[1]]:
self.samples.append([
edge[0], self.G[edge[0]][edge[1]][i]['attr'], edge[1]
])
else:
raise Exception
self.start = start
self.node2id, self.id2node = self._node2id()
self.edge2id, self.id2edge = self._edge2id()
def tagger(self, filename, iteration):
print "________________________________________________________________________________________________Perceptron tagger starts"
for iter_round in range(iteration):
model_file = 'dumps\\model_' + str(iter_round + 1) + '.dump'
print 'Reading from file' + '\t' + model_file.split('\\')[1]
model = multi_class_perceptron(model_file)
c = DataHelper()
output = open('dumps\\dev-predicted.col', 'w')
for sentence in c.read_sentence(filename):
for token in sentence:
feature = token.feature_extracter(model.return_features)
score = model.weight_scores(feature)
predicted_tag = model.predict(score)
pos_tag = model.pos_constructor(token.gold_pos)
output.write(
'%s\t%s\n' %
(token.word, model.return_pos_reverse(predicted_tag)))
output.write('\n')
output.close()
Cgold = DataHelper("dataset\\test.col")
GoldWordTagList = Cgold.Tokenize(Cgold)
Cpred = DataHelper("dumps\\dev-predicted.col")
PredWordTagList = Cpred.Tokenize(Cpred)
Ctag = DataHelper("dataset\\test.col")
TagSet = Ctag.tagSet(Ctag)
eval = Evaluation()
per_tag = False
f_measure = eval.Evaluate(per_tag, GoldWordTagList,
PredWordTagList, TagSet)
print 'F-Measure Micro:' + '\t' + f_measure[0]
print 'F-Measure Macro:' + '\t' + f_measure[1]
print
final_eval = Evaluation()
f_per_tag = True
per_tag_table = final_eval.Evaluate(f_per_tag, GoldWordTagList,
PredWordTagList, TagSet)
print per_tag_table
print "________________________________________________________________________________________________Perceptron tagger ends"
def __init__(self, checkpoint_path, model_selector, cuda=False):
#cuda = True
self.dh = DataHelper() # 数据库读取
self.checkpoint_path = checkpoint_path
self.model_selector = model_selector
self.cuda = cuda
l.info("[I] Model Loading....")
self.compute_app = Application(checkpoint_path,
cuda=cuda,
model_name=model_selector)
l.info("[I] Model loaded...")
def __init__(self, area, algorithm):
"""Initiate all elements necessary to run an algorithm
without visualization
Keyword arguments:
area -- the area that should be used in the algoritm
algorithm -- the algorithm by which the given area is filled
"""
self.area = area
self.algorithm = algorithm
self.dataHelper = DataHelper()
def train(self, train_file, iteration):
print(
"________________________________________________________________________________________________tarin starts"
)
model = multi_class_perceptron()
c = DataHelper()
instances = []
sentence_count = 0
for sentence in c.read_sentence(train_file):
sentence_count += 1
for token in sentence:
feature = token.feature_extracter(model.feature_constructor)
# print feature
instances.append(
(feature, model.pos_constructor(token.gold_pos)))
weights_statistics = model.weights_constructor()
self.table_statistics.append([
str(weights_statistics[1]),
str(weights_statistics[0]),
str(len(instances)),
str(sentence_count)
])
table = AsciiTable(self.table_statistics)
print(table.table)
for iter_round in range(iteration):
start = time.time()
for (feature, pos_tag) in instances:
#print (feature, pos_tag)
score = model.weight_scores(feature)
#print score
predicted_tag = model.predict(score)
#print predicted_tag
if predicted_tag != pos_tag:
model.update(feature, pos_tag, predicted_tag)
end = time.time()
print 'Iteration' + '\t' + str(
iter_round +
1) + '\t' + 'done.', " runs at:", end - start, "seconds"
model_file = 'dumps\\model_' + str(iter_round + 1) + '.dump'
model.save(model_file)
print(
"________________________________________________________________________________________________tarin ends"
)
def __init__(self, area, algorithm, runs):
"""Initiate all elements necessary to run an algorithm consecutively
without visualizations.
Keyword arguments:
area -- the area that should be visualised
algorithm -- the algorithm by which the given area is filled
runs -- the amount of times the algorithm should run
"""
self.area = area
self.algorithm = algorithm
self.originalArea = copy.deepcopy(area)
self.originalAlgorithm = copy.copy(algorithm)
self.runs = 0
self.dataHelper = DataHelper()
self.maxRuns = runs
def __init__(self, area, algorithm, runs):
"""Initiate all elements necessary to run an algorithm consecutively
and create consecutive visualizations for them.
Keyword arguments:
area -- the area that should be visualised
algorithm -- the algorithm by which the given area is filled
runs -- the amount of times the algorithm should be run and
the amount of visualizations to be made
"""
super().__init__(area, algorithm)
self.originalArea = copy.deepcopy(area)
self.originalAlgorithm = copy.copy(algorithm)
self.runs = 0
self.allTimeHigh = 0
self.dataHelper = DataHelper()
self.maxRuns = runs
# model saver
saver = tf.train.Saver()
# train, test, and save model
with tf.Session() as sess:
sess.run(init)
if train:
# train
epoch = 1
while True: # epoch <= epochs:
epoch_start = time.time()
print 'Training Epoch {}...'.format(epoch)
# get data, test_idx = 19000 is ~83% train test split
dh = DataHelper(batch_size, test_idx=test_split)
# test data
test_data, test_labels = dh.get_test_data(test_size)
step = 1
while step * batch_size < test_split:
batch_xs, batch_ys = dh.get_next_batch()
sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
if step % display_step == 0:
acc = sess.run(rmse, feed_dict={x: batch_xs, y: batch_ys})
loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})
print "Iter " + str(step * batch_size) + \
", Minibatch Loss= " + "{:.6f}".format(loss) + \
def viterbi_tagger(self, test_file):
print "________________________________________________________________________________________________viterbi_tagger starts"
c_3 = DataHelper("dataset\\train.col")
stream_emission_matrix = gzip.open("dumps\\emission_matrix.dump", 'rb')
emission_matrix = cPickle.load(stream_emission_matrix)
stream_emission_matrix.close()
stream_transition_matrix = gzip.open("dumps\\transition_matrix.dump",
'rb')
transition_matrix = cPickle.load(stream_transition_matrix)
stream_transition_matrix.close()
for x in transition_matrix:
for p in transition_matrix[x]:
if transition_matrix[x][p] > 0.2:
print p, x, transition_matrix[x][p]
sentence_count = 0
word_count = 0
output = open('dumps\\dev-predicted-viterbi.col', 'w')
for sentence in c_3.read_sentence(test_file):
observation = sentence.word_list()
sentence_count += 1
word_count += len(observation)
#print observation
states = sentence.tag_list()
#print states
#for word in observation:
# if word in emission_matrix:
# states = states + emission_matrix[word].keys()
# else:
# states = states + ['NN']
states = list(set(states))
#states.insert(0, '<S>')
#start = time.time()
prediction = self.viterbi_smoothing(observation, states,
emission_matrix,
transition_matrix)
#end = time.time()
#print 'Sentence '+str(sentence_count)+' at', end - start
for i in range(len(prediction[0])):
output.write('%s\t%s\n' % (prediction[1][i], prediction[0][i]))
output.write('\n')
output.close()
Ctag = DataHelper("dataset\\test.col")
TagSet = Ctag.tagSet(Ctag)
self.table_statistics.append([
str(emission_matrix.__len__()),
str(len(TagSet)),
str(word_count),
str(sentence_count)
])
table = AsciiTable(self.table_statistics)
print(table.table)
print "________________________________________________________________________________________________viterbi_tagger ends"
Cgold = DataHelper("dataset\\test.col")
GoldWordTagList = Cgold.Tokenize(Cgold)
Cpred = DataHelper("dumps\\dev-predicted-viterbi.col")
PredWordTagList = Cpred.Tokenize(Cpred)
eval = Evaluation()
per_tag = False
f_measure = eval.Evaluate(per_tag, GoldWordTagList, PredWordTagList,
TagSet)
print 'F-Measure Micro:' + '\t' + f_measure[0]
print 'F-Measure Macro:' + '\t' + f_measure[1]
print
final_eval = Evaluation()
f_per_tag = True
per_tag_table = final_eval.Evaluate(f_per_tag, GoldWordTagList,
PredWordTagList, TagSet)
print per_tag_table
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from network import SimpleNet, SimpleRNN
from datahelper import DataHelper
x = SimpleNet.x
cnn = SimpleNet.build_cnn(x, reuse=None, raw_out=True)
rnn = SimpleRNN.build_graph(cnn)
infer = tf.nn.softmax(rnn)
y = SimpleRNN.y
dh = DataHelper()
saver = tf.train.Saver()
#print('Recovering')
#saver.recover_last_checkpoints('../models')
with tf.Session() as sess:
print('Restoring')
saver.restore(sess, '../models/cnn-rnn-100.ckpt')
while True:
img, lbl = dh.get_next_example(split_channels=True)
_y = sess.run(infer, feed_dict={x:img})
print(f'Label:{lbl}\nGuess:{_y}')
def _train_network(net):
global params
global x
global y
iters = tf.Variable(0, trainable=False)
learning_rate = None
if params['decay_steps']:
learning_rate = tf.train.exponential_decay(
params['start_learning_rate'], iters, params['decay_steps'],
params['decay_base'])
else:
learning_rate = tf.Variable(params['start_learning_rate'])
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(net, y))
# find a way tp paramertize the optimizer
optimizer = tf.train.MomentumOptimizer(learning_rate, params['momentum'],
params['nesterov'])
optimize = optimizer.minimize(cost, global_step=iters)
init = tf.initialize_all_variables()
saver = tf.train.Saver()
learning_rate_reduce = params['learning_rate_reduce']
start = time.time()
# this should have a more general implementation, we chose 0 because
# accuracy will grow as it improves
top_result = 0.0
with tf.Session() as sess:
sess.run(init)
for epoch in range(1, params['epoch_limit'] + 1):
if params['print']:
print epoch
dh = DataHelper(batch_size=params['batch_size'],
train_size=params['train_size'],
label_noise=params['label_noise'],
bands=params['bands'],
transform_func=eval(params['trans_func'])
if params['trans_func'] else None)
if learning_rate_reduce and epoch in learning_rate_reduce:
sess.run(learning_rate.assign(learning_rate.eval() / 10.0))
while dh.training:
batch_xs, batch_ys = dh.get_next_batch()
sess.run(optimize, feed_dict={x: batch_xs, y: batch_ys})
if iters.eval() % 20 == 0:
evaluate.evaluate(sess, net, x, y, batch_xs, batch_ys,
params['train_progress'])
#testing
batch_xs, batch_ys = dh.get_next_batch()
results = evaluate.evaluate(sess, net, x, y, batch_xs, batch_ys,
params['test_progress'])
if params['save_progress'] and results[0] > top_result:
if params['print']:
print 'Saving checkpoint'
saver.save(sess, params['model_dir'], global_step=iters)
top_result = results[0]
if params['print']:
print 'Epoch took {} seconds'.format(time.time() - start)
if params['rtrn_eval']:
print top_result
print W_out.get_shape()
print b_out.get_shape()
print out.get_shape()
# No changes to old network.py beyond this. Will be updating this soon.
cost = tf.reduce_mean(tf.squared_difference(out, y_))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
#optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
rmse = tf.sqrt(tf.reduce_mean(tf.squared_difference(out, y_)))
# Initialize
init = tf.initialize_all_variables()
dh = DataHelper(batch_size, test_idx=test_start)
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(init)
print sess.run(W_conv1), sess.run(b_conv1), sess.run(W_conv2), sess.run(
b_conv2)
test_data, test_labels = dh.get_test_data(test_size)
epoch = 1
train_start = time.time()
while epoch <= epochs:
epoch_start = time.time()
print 'Training Epoch {}...'.format(epoch)
# get data, test_idx = 19000 is ~83% train test split
dh = DataHelper(batch_size, test_idx=test_start)
# test data
def __init__(self, checkpoint_path, model_name):
self.chkpoint = checkpoint_path
self.app = Application(load_path=checkpoint_path,
model_name=model_name)
self.datahelper = DataHelper()
def p_drop(a, p):
a[a<np.percentile(a, p)] *= 1e-3
return a
scaler = MinMaxScaler()
#scaler = MinMaxScaler(feature_range=(-1, 1))
valid_img = lambda a: a.sum()>0 and np.isfinite(a).sum()==np.prod(a.shape)
scale = lambda a: scaler.fit_transform(a.reshape(-1,1)).reshape(84,84).astype(np.float32)
mean_subtraction = lambda a: a-a.mean()
drop_percentile = lambda a, p: p_drop(a,p)
identity = lambda a: a
b_trans = lambda a: scale(drop_percentile(a, 50)) if valid_img(a) else a
dh = DataHelper(batch_size=batch_size, band_transform_func=b_trans)
epoch = 1
len_epoch = len(dh._train_imgs)
print(f'Epoch length = {len_epoch}')
summaries = tf.summary.merge_all()
saver = tf.train.Saver()
with tf.Session() as sess:
if restore_file:
saver.restore(sess, restore_file)
else:
sess.run(init)
trainWriter = tf.summary.FileWriter('../report/tf-log/train', graph=sess.graph)
testWriter = tf.summary.FileWriter('../report/tf-log/test', graph=sess.graph)
import tensorflow as tf
import numpy as np
import sys
from datahelper import DataHelper
VOCAB_SIZE = 10000
EMBEDDING_SIZE = 1
LEARNING_RATE = 1e-3
MINI_BATCH_SIZE = 256
NORMALIZE_LAYER = 0
data_helper = DataHelper(_voc_size=VOCAB_SIZE)
data_helper.load_train_ins_and_process("data/train.50_51.ins")
data_helper.load_eval_ins("data/eval.52.ins")
print "data loaded"
def eval_auc(eval_res, eval_label):
sorted_res = np.argsort(eval_res, axis=0)
m = 0
n = 0
rank = 0
for k in range(sorted_res.shape[0]):
idx = sorted_res[k][0]
if eval_label[idx][0] == 1:
m += 1
def _keys(self, fn):
helper = DataHelper(fn)
if not os.path.isfile('../data/middle/entity2id.txt'):
helper.id2file()
return list(helper.node2id.keys())
parser = argparse.ArgumentParser()
parser.add_argument("--more_news_times",
type=int,
default=3,
help="Number of click the 'more news' button")
parser.add_argument("--threading_num",
type=int,
default=3,
help="Number of threading")
parser.add_argument('-o', "--output_dir", type=str, default="../output")
parser.add_argument('-i',
"--ip_list_file",
type=str,
default="../input/alive_ip_list.txt")
parser.add_argument('-v',
"--visited_url",
type=str,
default="../input/visited_url.txt")
parser.add_argument('-u',
"--unvisited_url",
type=str,
default="../input/unvisited_url.txt")
parser.add_argument('-r',
"--root_url",
type=str,
default="../input/root_url.txt")
args = parser.parse_args()
datahelper = DataHelper()
spider = Spider(datahelper=datahelper, args=args)
spider.start()
def _train_network(net, eval_net):
global params
global x
global y
iters = tf.Variable(1, trainable=False)
learning_rate = None
if params['decay_steps']:
learning_rate = tf.train.exponential_decay(
params['start_learning_rate'], iters, params['decay_steps'],
params['decay_base'])
else:
learning_rate = tf.Variable(params['start_learning_rate'],
trainable=False)
with tf.name_scope('loss'):
#loss_weights = 1.003 - tf.reduce_max(y, axis=1)
kl = lambda p, q: tf.losses.softmax_cross_entropy(
p, q, reduction=tf.losses.Reduction.MEAN)
hs_kl = lambda p, q: tf.multiply(0.5, tf.square(kl(p, q)))
loss = tf.losses.softmax_cross_entropy(
y, net, weights=1.0, reduction=tf.losses.Reduction.MEAN)
#loss = tf.nn.softmax_cross_entropy_with_logits(logits=net,
# labels=y,
# weights=loss_weights,
# reduction=tf.losses.Reduction.MEAN)
#optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=params['momentum'])
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
grads = optimizer.compute_gradients(loss)
with tf.name_scope('clipping'):
grads = [(tf.clip_by_value(grad, -1.5, 1.5), var)
for grad, var in grads]
update = optimizer.apply_gradients(grads, global_step=iters)
# with tf.name_scope('grads'):
# for grad, var in grads:
# tf.summary.histogram(f"{var.name.split(':')[0]}", grad)
# with tf.name_scope('weights'):
# for grad, var in grads:
# tf.summary.histogram(f"{var.name.split(':')[0]}", var)
learning_rate_reduce = params['learning_rate_reduce']
# this should have a more general implementation, we chose 0 because
# accuracy will grow as it improves
top_result = 0.0
dh = DataHelper(batch_size=params['batch_size'],
train_size=params['train_size'],
label_noise=params['label_noise'],
bands=params['bands'],
transform_func=eval(params['trans_func'])
if params['trans_func'] else None)
with tf.name_scope('metrics'):
evaluate.evaluate_tensorboard(eval_net, y)
summaries = tf.summary.merge_all()
init = tf.global_variables_initializer()
saver = tf.train.Saver()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
if params['restore']:
saver.restore(sess,
tf.train.latest_checkpoint(params['model_dir']))
else:
sess.run(init)
trainWriter = tf.summary.FileWriter(params['tf_train_dir'],
graph=sess.graph)
testWriter = tf.summary.FileWriter(params['tf_test_dir'],
graph=sess.graph)
# run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
# run_metadata = tf.RunMetadata()
run_options = None
run_metadata = None
top_result = 0
while iters.eval() < params['iter_limit']:
current_iter = iters.eval()
if learning_rate_reduce and current_iter in learning_rate_reduce:
sess.run(learning_rate.assign(learning_rate.eval() / 10))
if params['print']:
tf.logging.info(f"Training iter:{current_iter}")
batch_xs, batch_ys = dh.get_next_batch(iter_based=True)
batch = {x: batch_xs, y: batch_ys}
sess.run(update, feed_dict=batch)
if current_iter % 10 == 0:
if params['print']:
tf.logging.info("Evaluating")
s = sess.run(summaries, feed_dict=batch)
trainWriter.add_summary(s, current_iter)
if current_iter % 100 == 0:
if params['print']:
tf.logging.info('Testing')
batch_xs, batch_ys = dh.get_next_batch(force_test=True)
batch[x] = batch_xs
batch[y] = batch_ys
s = sess.run(summaries, feed_dict=batch)
testWriter.add_summary(s, current_iter)
evals = evaluate.evaluate(sess, eval_net, x, y, batch_xs,
batch_ys, params['test_progress'])
if params['save_progress'] and evals[0] > top_result:
if params['print']:
tf.logging.info('Saving checkpoint')
model_path = os.path.join(params['model_dir'],
'res-net.ckpt')
saver.save(sess, model_path, global_step=iters)
top_result = evals[0]
# This needs to be printed so that the async trainer can see the result
if params['rtrn_eval']:
print(top_result)
def main():
"""Present the user with choices about the algorithm to run"""
# set some values
placementOrder = None
waterAmountChoice = None
print("----------------------")
print("WELCOME TO AMSTELHAEGE \n")
# let the user choose a new or existing grid
gridChoice = int(
input('Do you want to load in a grid '
'or start from scratch?\n'
'1: Load a grid\n'
'2: Start from scratch\n'
'Your choice: '))
print("")
# let the user choose an algorithm
algorithmChoice = int(
input('What algorithm do you want to run?\n'
'1: Random \n'
'2: Greedy \n'
'3: SpeedRandom\n'
'4: HillClimbing\n'
'5: Simmulated Annealing\n'
'6: Do Nothing (show only)\n'
'Your choice: '))
if algorithmChoice == 4 or algorithmChoice == 5:
print("")
totalIterations = int(
input('How many steps should algorithm make?\n'
'Your choice: '))
if algorithmChoice == 5:
print("")
typeOfSimulatedAnnealing = int(
input('What type of Simulated'
' Annealing?\n'
'1: lineair \n'
'2: exponential\n'
'3: sigmoidal\n'
'Your choice: '))
if algorithmChoice == 5:
print("")
beginTemp = int(
input('What is the begin temperature? (Try "50")\n'
'Your choice: '))
print("")
endTemp = int(
input('What is the end temperature? (Try "0")\n'
'Your choice: '))
print("")
correctionShortening = int(
input('What correction factor for'
' shortening the would you like'
' to use? (Try "1000")\n'
' Your choice: '))
print("")
# let the user choose a type of visualization.
# Normal visualizer renders a single visualisation
# Bulk visualizer can render several maps after one another
visualizerChoice = int(
input('What visualizer do you want?\n'
'1: Normal visualizer\n'
'2: Bulk visualizer\n'
'3: No-draw normal visualizer\n'
'4: No-draw bulk visualizer\n'
'Your choice: '))
print("")
isEmpty = True
fhAmount = 0
bAmount = 0
mAmount = 0
if gridChoice == 1:
# ask the user for the file where the existing grid is stored
fileName = str(input('Please provide a file name: \n' 'Your choice: '))
area = DataHelper(fileName).getArea()
isEmpty = False
else:
# or create a new grid
area = Area()
houseAmountChoice = int(
input('How many houses do you want? \n'
'1: 20\n'
'2: 40\n'
'3: 60\n'
'Your choice: '))
print("")
# set the correct ratio of house types
# for different amounts of houses
if houseAmountChoice == 1:
fhAmount = 12
bAmount = 5
mAmount = 3
elif houseAmountChoice == 2:
fhAmount = 24
bAmount = 10
mAmount = 6
elif houseAmountChoice == 3:
fhAmount = 36
bAmount = 15
mAmount = 9
# if applicable for the algorithm chosen, provide further choices
if algorithmChoice != 2 and gridChoice != 1:
placementOrder = int(
input('In what order do you want houses '
'to be placed on the map?\n'
'1: Random \n'
'2: First Mansions, then Bungalows, '
'then Family homes \n'
'Your choice: '))
print("")
waterAmountChoice = int(
input('How many water areas'
' do you want on the map? \n'
'1: 1 Area \n'
'2: 2 Area\'s \n'
'3: 3 Area\'s \n'
'4: 4 Area\'s \n'
'5: Random amount of Area\'s \n'
'Your choice: '))
if waterAmountChoice == "5":
waterAmountChoice = "Random"
print("")
# initiate the algorithm chosen by the user
if algorithmChoice == 1:
algorithm = RandomAlgorithm(area, fhAmount, bAmount, mAmount,
placementOrder, waterAmountChoice, isEmpty)
elif algorithmChoice == 2:
algorithm = GreedyAlgorithm(area, fhAmount, bAmount, mAmount, isEmpty)
elif algorithmChoice == 3:
algorithm = SpeedRandomAlgorithm(area, fhAmount, bAmount, mAmount,
placementOrder, waterAmountChoice,
isEmpty)
elif algorithmChoice == 4:
algorithm = HillClimbingAlgorithm(area, fhAmount, bAmount, mAmount,
placementOrder, waterAmountChoice,
isEmpty, totalIterations)
elif algorithmChoice == 5:
algorithm = HillClimbingAlgorithm(area, fhAmount, bAmount, mAmount,
placementOrder, waterAmountChoice,
isEmpty, totalIterations, beginTemp,
endTemp, typeOfSimulatedAnnealing,
correctionShortening)
elif algorithmChoice == 6:
algorithm = Algorithm(area, fhAmount, bAmount, mAmount, isEmpty)
# initiate the visualization requested by the user
if visualizerChoice == 1:
# enable downward graphing
if algorithmChoice == 5:
visualizer = Visualizer(area, algorithm, True)
else:
visualizer = Visualizer(area, algorithm, False)
elif visualizerChoice == 2:
runs = int(input('How many runs do you want to do? \n'
'Your choice: '))
visualizer = BulkVisualizer(area, algorithm, runs)
elif visualizerChoice == 3:
visualizer = NoDrawVisualizer(area, algorithm)
elif visualizerChoice == 4:
runs = int(input('How many runs do you want to do? \n'
'Your choice: '))
visualizer = NoDrawBulkVisualizer(area, algorithm, runs)
# notify the user of the end of the menu
print("Starting your Algorithm...")
print("----------------------")
visualizer.on_execute()
if args.balanced_real_images:
if args.split == 'train':
image_prefix = "COCO_train2014_000000"
else:
image_prefix = "COCO_val2014_000000"
image_postfix = ".jpg"
elif args.abstract_scene_images:
if args.split == 'train':
image_prefix = "abstract_v002_train2015_0000000"
else:
raise NotImplementedError()
image_postfix = ".png"
helper = DataHelper(args.annot_file, args.ques_file)
# Write dataset to file
with open(args.output_file, "w") as output_file:
for i in range(len(helper.dataset['annotations'])):
imd_id = helper.dataset['annotations'][i]['image_id']
img_name = image_prefix + pad_with_zero(imd_id, args) + image_postfix
ques_id = helper.dataset['annotations'][i]['question_id']
question = helper.qqa[ques_id]['question']
# Convert to comma-separated token string
question = ','.join(question.strip().split())
answer = helper.dataset['annotations'][i]['multiple_choice_answer']
def setUp(self):
""" Read the data file and create model with training data """
data = DataHelper().read_data()
self.x_train, self.x_test, self.y_train, self.y_test = DataHelper(
).split_data(data)
self.model = self.mh.create_model(self.x_train, self.y_train)
