def train_model():
use_gpu = True
if use_gpu and torch.cuda.is_available():
device = torch.device("cuda")
else:
device = torch.device("cpu")
print("Loading datasets")
train_df = utils.import_file("train")
dev_df = utils.import_file("dev")
test_df = utils.import_file("test")
print("Building tokenizer")
tokenizer = Tokenizer()
batch_size = 32
hidden_size = 128
max_length = 200
epochs = 10
dropout_p = 0.1
print("Creating training dataloader")
dataloader_train = get_data_loader_bilstm(train_df,
tokenizer,
batch_size=batch_size)
print("Creating dev dataloader")
dataloader_dev = get_data_loader_bilstm(dev_df,
tokenizer,
batch_size=batch_size)
print("Creating test dataloader")
dataloader_test = get_data_loader_bilstm(test_df,
tokenizer,
batch_size=batch_size,
test=True)
print("Building encoder")
encoder = comparer_model.EncoderRNN(tokenizer.vocab_size, hidden_size)
print("Building decoder")
decoder = comparer_model.AttnDecoderRNN(tokenizer.vocab_size,
hidden_size,
max_length,
dropout_p=dropout_p)
print("Creating Trainer")
trainer = TrainerBiLSTM(encoder, decoder, batch_size, device, max_length)
print("Starting training")
trainer.train(dataloader_train, epochs)
def main(args):
# Get the configuration file
config = utils.import_file(os.path.join(args.model_dir, 'config.py'), 'config')
# Get the paths of the aligned images
with open(args.image_list) as f:
paths = [line.strip() for line in f]
print('%d images to load.' % len(paths))
assert(len(paths)>0)
# Pre-process the images
images = utils.preprocess(paths, config, False)
switch = np.array([utils.is_typeB(p) for p in paths])
# Load model files and config file
if config.use_sibling:
network = SiblingNetwork()
else:
network = BaseNetwork()
network.load_model(args.model_dir)
# Run forward pass to calculate embeddings
if config.use_sibling:
embeddings = network.extract_feature(images, switch, args.batch_size, verbose=True)
else:
embeddings = network.extract_feature(images, args.batch_size, verbose=True)
# Output the extracted features
np.save(args.output, embeddings)
def load(script_name, file_extension=config.g_ratt_file_extension):
""" Dynamically loads the specifies script. 'script_name' is a string of
script's file name WITHOUT a file extension. 'file_extension' appended
to 'script_name' to complete the script's file name.
The method returns the 'module object' for the loaded script.
"""
m, e = utils.import_file(script_name + file_extension,
config.g_script_paths)
if (m == None):
output.writeline("Error loading script: (). [{}]".format(e))
return None
return m
def load_dataset(self):
train_df = import_file("train", path=self.dataset_path)
dev_df = import_file("dev", path=self.dataset_path)
test_df = import_file("test", path=self.dataset_path)
train_df_aug = augment_dataset(
train_df,
lambda score: score < -1,
lambda score: score < -0.3,
lambda score: score > 0.55,
lambda score: score > 1,
lambda score: score > 1.3,
)
self.dataLoader_train = get_data_loader(train_df, batch_size=32)
self.dataLoader_train_aug = get_data_loader(train_df_aug, batch_size=32)
self.dataLoader_dev = get_data_loader(dev_df, batch_size=32)
self.dataLoader_test = get_data_loader(test_df, batch_size=32, test=True)
# Masked versions of the dataset (load both into memory to avoid recalculation)
self.dataLoader_train_masked = get_data_loader_masked(train_df, batch_size=32)
self.dataLoader_train_aug_masked = get_data_loader_masked(
train_df_aug, batch_size=32
)
self.dataLoader_dev_masked = get_data_loader_masked(dev_df, batch_size=32)
def main(args):
# I/O
config_file = args.config_file
config = utils.import_file(config_file, 'config')
#trainset = utils.Dataset(config.train_dataset_path)
testset = utils.Dataset(config.test_dataset_path)
network = BaseNetwork()
network.initialize(config, 0 ) #trainset.num_classes
# Initalization for running
log_dir = utils.create_log_dir(config, config_file)
summary_writer = tf.summary.FileWriter(log_dir, network.graph)
if config.restore_model is not None:
network.restore_model(config.restore_model, config.restore_scopes)
# Set up LFW test protocol and load images
print('Loading images...')
lfwtest = LFWTest(testset.images)
lfwtest.init_standard_proto(config.lfw_pairs_file)
lfwtest.images = utils.preprocess(lfwtest.image_paths, config, is_training=False)
#trainset.start_batch_queue(config, True)
#
# Main Loop
#
print('\nStart Training\nname: %s\n# epochs: %d\nepoch_size: %d\nbatch_size: %d\n'\
% (config.name, config.num_epochs, config.epoch_size, config.batch_size))
global_step = 0
# Testing on LFW
print('Testing on Neetis LFW protocol...')
embeddings = network.extract_feature(lfwtest.images, config.batch_size)
print(type(embeddings))
accuracy_embeddings, threshold_embeddings = lfwtest.test_standard_proto(embeddings)
print('Embeddings Accuracy: %2.4f Threshold %2.3f' % (accuracy_embeddings, threshold_embeddings))
with open(os.path.join(log_dir,'lfw_result.txt'),'at') as f:
f.write('%d\t%.5f\n' % (global_step,accuracy_embeddings))
summary = tf.Summary()
summary.value.add(tag='lfw/accuracy', simple_value=accuracy_embeddings)
summary_writer.add_summary(summary, global_step)
def test_export_equals_import(self):
sixteenth_per_beat = 13
beats_per_bar = 52
num_bars = 36
sixteenth_duration = 24
swing = False
swing_amount = 0.3
beat_pattern = []
is_active = [1,1,1,1,1,1]
file_name = 'temp.drum'
utils.export_file(sixteenth_per_beat, beats_per_bar, num_bars, sixteenth_duration, swing, beat_pattern, is_active, swing_amount, file_name)
s_p_b, b_p_b, n_b, s_d, s, b_p, is_a, s_a = utils.import_file(file_name)
self.assertEquals(sixteenth_per_beat, s_p_b)
self.assertEquals(beats_per_bar, b_p_b)
self.assertEquals(num_bars, n_b)
self.assertEquals(sixteenth_duration, s_d)
self.assertEquals(swing, s)
self.assertEquals(beat_pattern, b_p)
os.remove(file_name)
def main(args):
# Get the configuration file
config = utils.import_file(os.path.join(args.model_dir, 'config.py'),
'config')
# Get the paths of the aligned images
with open(args.image_list) as f:
paths = [line.strip() for line in f]
print('%d images to load.' % len(paths))
# Pre-process the images
images = utils.preprocess(paths, config, False)
assert (len(paths) > 0)
# Load model files and config file
if config.use_sibling:
network = SiblingNetwork()
else:
network = BaseNetwork()
network.load_model(args.model_dir)
# Run forward pass to calculate embeddings
if config.use_sibling:
print(
"\033[93mWARNING:\033[0m When using sibling network: we assume the images are in the order template, probe, template, probe, ...!"
)
assert len(
images
) % 2 == 0, "The number of images are assumed to be even for using sibling network!"
switch = utils.zero_one_switch(len(images))
embeddings = network.extract_feature(images,
switch,
args.batch_size,
verbose=True)
else:
embeddings = network.extract_feature(images,
args.batch_size,
verbose=True)
# Output the extracted features
np.save(args.output, embeddings)
def man(script_name, file_extension=config.g_ratt_file_extension):
""" Displays help for the specified script name and its 'run()' method
(which is assumed to be the script's primary/entry function).
"""
# Look-up/load the script
filename = script_name + file_extension
m, e = utils.import_file(filename, config.g_script_paths)
if (m == None):
output.writeline("ERROR: {} was not found. [{}]".format(
script_name + file_extension, e))
return
# get the module's location
modname = os.path.splitext(os.path.split(filename)[1])[0]
modpath = config.g_utils_import_paths[modname]
# get module help
indent = " "
modhelp = indent + pydoc.getdoc(m).replace("\n", "\n" + indent)
try:
runhelp = indent + pydoc.getdoc(m.run).replace("\n", "\n" + indent)
except:
runhelp = None
# Display the help text
output.writeline("")
output.writeline("MODULE NAME:")
output.writeline(indent + modname)
output.writeline("")
output.writeline("LOCATION:")
output.writeline(indent + modpath)
output.writeline("")
output.writeline("DESCRIPTION:")
output.writeline(modhelp)
output.writeline("")
if (runhelp != None):
output.writeline("RUN() FUNCTION:")
output.writeline(runhelp)
output.writeline("")
def validate_lfw(args):
config = utils.import_file(args.config_file, 'config')
testset = utils.Dataset(args.test_dataset_path)
# Carregando modelo
print('Loading network model...')
network = BaseNetwork()
network.load_model(args.model_dir)
# Set up LFW test protocol and load images
print('Loading images...')
lfwtest = LFWTest(testset.images)
lfwtest.init_standard_proto(args.lfw_pairs_file)
lfwtest.images = utils.preprocess(lfwtest.image_paths,
config,
is_training=False)
# Testing on LFW
print('Testing on standard LFW protocol...')
embeddings = network.extract_feature(lfwtest.images, config.batch_size)
accuracy_embeddings, threshold_embeddings = lfwtest.test_standard_proto(
embeddings)
print('Embeddings Accuracy: %2.4f Threshold %2.3f' %
(accuracy_embeddings, threshold_embeddings))
def main(args):
# I/O
config_file = args.config_file
config = utils.import_file(config_file, 'config')
trainset = utils.Dataset(config.train_dataset_path)
testset = utils.Dataset(config.test_dataset_path)
network = SiblingNetwork()
network.initialize(config, trainset.num_classes)
# Initalization for running
log_dir = utils.create_log_dir(config, config_file)
summary_writer = tf.summary.FileWriter(log_dir, network.graph)
if config.restore_model:
network.restore_model(config.restore_model, config.restore_scopes)
# Set up test protocol and load images
print('Loading images...')
testset.separate_template_and_probes()
testset.images = utils.preprocess(testset.images, config, is_training=False)
trainset.start_batch_queue(config, True)
#
# Main Loop
#
print('\nStart Training\nname: %s\n# epochs: %d\nepoch_size: %d\nbatch_size: %d\n'\
% (config.name, config.num_epochs, config.epoch_size, config.batch_size))
global_step = 0
start_time = time.time()
for epoch in range(config.num_epochs):
# Training
for step in range(config.epoch_size):
# Prepare input
learning_rate = utils.get_updated_learning_rate(global_step, config)
image_batch, label_batch = trainset.pop_batch_queue()
switch_batch = utils.zero_one_switch(len(image_batch))
wl, sm, global_step = network.train(image_batch, label_batch, switch_batch, learning_rate, config.keep_prob)
# Display
if step % config.summary_interval == 0:
duration = time.time() - start_time
start_time = time.time()
utils.display_info(epoch, step, duration, wl)
summary_writer.add_summary(sm, global_step=global_step)
# Testing
print('Testing...')
switch = utils.zero_one_switch(len(testset.images))
embeddings = network.extract_feature(testset.images, switch, config.batch_size)
tars, fars, _ = utils.test_roc(embeddings, FARs=[1e-4, 1e-3, 1e-2])
with open(os.path.join(log_dir,'result.txt'),'at') as f:
for i in range(len(tars)):
print('[%d] TAR: %2.4f FAR %2.3f' % (epoch+1, tars[i], fars[i]))
f.write('[%d] TAR: %2.4f FAR %2.3f\n' % (epoch+1, tars[i], fars[i]))
summary = tf.Summary()
summary.value.add(tag='test/tar_%d'%i, simple_value=tars[i])
summary_writer.add_summary(summary, global_step)
# Save the model
network.save_model(log_dir, global_step)
print("P {} using {}".format(self.number,
self.message_queue[0]))
self.registers[self.X] = self.message_queue.pop(0)
elif command == 'set':
self.registers[self.X] = self.Y
elif command == 'add':
self.registers[self.X] += self.Y
elif command == 'mul':
self.registers[self.X] *= self.Y
elif command == 'mod':
self.registers[self.X] %= self.Y
#increment
self.i += 1
instructions = utils.import_file("Inputs/input18.txt", split=True)
i1 = instructions[:]
i2 = instructions[:]
p1 = Program(0, i1)
p2 = Program(1, i2, target=p1)
p1.set_target(p2)
thread1 = ProgramThread(p1)
thread2 = ProgramThread(p2)
thread1.start()
thread2.start()
threads = []
threads.append(thread1)
threads.append(thread2)
for t in threads:
def main():
# Parse command line
args = docopt(__doc__, version=VERSION, options_first=True)
# Add the ratt directory to the system path (so module can access the
# 'utils' package
sys.path.append(__file__)
# Enumrate Windoze COM Ports
if (args['--serialports'] == True):
ports = utils.get_available_serial_ports(platform="Windows")
for p in ports:
print(p)
sys.exit()
# Get Newline option
config.newline = '\r\n' if args['--crlf'] else '\n'
# Open log file (when not disabled)
logfile = None
if (args['--log'] == True or args['--vlog'] or args['--dlog']):
if (args['--vlog']):
config.g_verbose_logs = True
if (args['--dlog']):
config.g_debug_logs = True
logfile = open(utils.append_current_time(args['--logfile']), "wb")
## Created 'Expected' object for a: Windoze executable UUT
if (args['--win']):
config.g_uut = rexpect.ExpectWindowsConsole(
" ".join(args['<executable>']), logfile)
# Created 'Expected' object for a: Linux/Wsl executable UUT
elif (args['--linux']):
config.g_uut = rexpect.ExpectLinuxConsole(
" ".join(args['<executable>']), logfile)
# Created 'Expected' object for a: UUT via a Windoze COM Port
elif (args['--comport']):
serial = utils.open_serial_port('com' + args['<comnum>'],
timeout=0,
baudrate=int(args['--baud']),
parity=args['--parity'],
stopbits=int(args['--stopbits']),
bytesize=int(args['--databits']))
config.g_uut = rexpect.ExpectSerial(serial, logfile)
# Create 'Expected' object for a: NO UUT
elif (args['--nouut']):
config.g_uut = rexpect.ExpectNullConsole(logfile)
# Enable output
output.set_verbose_mode(args['-v'])
output.set_debug_mode(args['--debug'])
output.set_output_fd(sys.stdout, logfile)
# Get script paths
config.g_script_paths.append('.')
if (args['--path1'] != None):
config.g_script_paths.append(args['--path1'])
if (args['--path2'] != None):
config.g_script_paths.append(args['--path2'])
if (args['--path3'] != None):
config.g_script_paths.append(args['--path3'])
# Check for batch mode
if (args['--input'] != None):
input, result = utils.import_file(args['--input'],
config.g_script_paths)
if (input == None):
sys.exit(result)
start_time = time()
output.writeline(
"------------ START: Ratt, ver={}. Start time={}".format(
VERSION, strftime("%Y-%m-%d_%H.%M.%S", localtime(start_time))))
output.writeline("------------ RUNNING SUITE CASE: {}".format(result))
passcode = input.main()
end_time = time()
if (passcode != 0):
output.writeline(
"------------ TEST SUITE FAILED ({}).".format(passcode))
else:
output.writeline("------------ TEST SUITE PASSED.")
output.writeline(
"------------ END: End time={}, delta={:.2f} mins".format(
strftime("%Y-%m-%d_%H.%M.%S", localtime(end_time)),
(end_time - start_time) / 60.0))
sys.exit(passcode)
# interactive mode
else:
output.writeline("")
output.writeline(
"------------ Welcome to Ratt, this is my Kung-Fu and it is strong! ------------"
)
output.writeline(" ver={}. Start time={}".format(
VERSION, utils.append_current_time("", "")))
output.writeline("")
exec('from rattlib import *')
exec('import config')
while (True):
output.write(">")
line = sys.stdin.readline().rstrip("\r\n")
output.writeline(line, log_only=True)
try:
exec(line)
except Exception as e:
output.writeline(str(e))
self.velocity[i] + self.acceleration[i]
for i in range(len(self.velocity))
]
self.position = [
self.position[i] + self.velocity[i]
for i in range(len(self.position))
]
def distance(self):
return sum([abs(i) for i in self.position])
def get_position(self):
return self.position
inputs = utils.import_file("Inputs/input20.txt", split=True)
particles = []
for line in inputs:
values = [s.split(',') for s in re.findall(r'<(.*?)>', line)]
pos, vel, acc = [list(map(int, v)) for v in values]
particles.append(Particle(pos, vel, acc))
for i in range(1000):
[p.step() for p in particles]
by_position = lambda x: x.get_position()
particles = sorted(particles, key=by_position)
for key, group in itertools.groupby(particles, key=by_position):
if len(list(group)) > 1:
particles = list(
filter(lambda x: x.get_position() != key, particles))
def initialize(self, config, num_classes):
'''
Initialize the graph from scratch according config.
'''
with self.graph.as_default():
with self.sess.as_default():
# Set up placeholders
w, h = config.image_size
channels = config.channels
image_batch_placeholder = tf.placeholder(
tf.float32,
shape=[None, h, w, channels],
name='image_batch')
label_batch_placeholder = tf.placeholder(tf.int32,
shape=[None],
name='label_batch')
learning_rate_placeholder = tf.placeholder(
tf.float32, name='learning_rate')
keep_prob_placeholder = tf.placeholder(tf.float32,
name='keep_prob')
phase_train_placeholder = tf.placeholder(tf.bool,
name='phase_train')
global_step = tf.Variable(0,
trainable=False,
dtype=tf.int32,
name='global_step')
image_splits = tf.split(image_batch_placeholder,
config.num_gpus)
label_splits = tf.split(label_batch_placeholder,
config.num_gpus)
grads_splits = []
split_dict = {}
def insert_dict(k, v):
if k in split_dict: split_dict[k].append(v)
else: split_dict[k] = [v]
for i in range(config.num_gpus):
scope_name = '' if i == 0 else 'gpu_%d' % i
with tf.name_scope(scope_name):
with tf.variable_scope('', reuse=i > 0):
with tf.device('/gpu:%d' % i):
images = tf.identity(image_splits[i],
name='inputs')
labels = tf.identity(label_splits[i],
name='labels')
# Save the first channel for testing
if i == 0:
self.inputs = images
# Build networks
if config.localization_net is not None:
localization_net = utils.import_file(
config.localization_net, 'network')
imsize = (112, 112)
images, theta = localization_net.inference(
images,
imsize,
phase_train_placeholder,
weight_decay=0.0)
images = tf.identity(
images, name='transformed_image')
if i == 0:
tf.summary.image(
'transformed_image', images)
else:
images = images
network = utils.import_file(
config.network, 'network')
prelogits = network.inference(
images,
keep_prob_placeholder,
phase_train_placeholder,
bottleneck_layer_size=config.
embedding_size,
weight_decay=config.weight_decay,
model_version=config.model_version)
prelogits = tf.identity(prelogits,
name='prelogits')
embeddings = tf.nn.l2_normalize(
prelogits, dim=1, name='embeddings')
if i == 0:
self.outputs = tf.identity(embeddings,
name='outputs')
# Build all losses
losses = []
# Orignal Softmax
if 'softmax' in config.losses.keys():
logits = slim.fully_connected(
prelogits,
num_classes,
weights_regularizer=slim.
l2_regularizer(config.weight_decay),
# weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
weights_initializer=slim.
xavier_initializer(),
biases_initializer=tf.
constant_initializer(0.0),
activation_fn=None,
scope='Logits')
cross_entropy = tf.reduce_mean(
tf.nn.
sparse_softmax_cross_entropy_with_logits(
labels=labels, logits=logits),
name='cross_entropy')
losses.append(cross_entropy)
insert_dict('sloss', cross_entropy)
# L2-Softmax
if 'cosine' in config.losses.keys():
logits, cosine_loss = tflib.cosine_softmax(
prelogits,
labels,
num_classes,
gamma=config.losses['cosine']['gamma'],
weight_decay=config.weight_decay)
losses.append(cosine_loss)
insert_dict('closs', cosine_loss)
# A-Softmax
if 'angular' in config.losses.keys():
a_cfg = config.losses['angular']
angular_loss = tflib.angular_softmax(
prelogits,
labels,
num_classes,
global_step,
a_cfg['m'],
a_cfg['lamb_min'],
a_cfg['lamb_max'],
weight_decay=config.weight_decay)
losses.append(angular_loss)
insert_dict('aloss', angular_loss)
# Split Loss
if 'split' in config.losses.keys():
split_losses = tflib.split_softmax(
prelogits,
labels,
num_classes,
global_step,
gamma=config.losses['split']['gamma'],
weight_decay=config.weight_decay)
losses.extend(split_losses)
insert_dict('loss', split_losses[0])
# Collect all losses
reg_loss = tf.reduce_sum(tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES),
name='reg_loss')
losses.append(reg_loss)
insert_dict('reg_loss', reg_loss)
total_loss = tf.add_n(losses,
name='total_loss')
grads_split = tf.gradients(
total_loss, tf.trainable_variables())
grads_splits.append(grads_split)
# Merge the splits
grads = tflib.average_grads(grads_splits)
for k, v in split_dict.items():
v = tflib.average_tensors(v)
split_dict[k] = v
if 'loss' in k:
tf.summary.scalar('losses/' + k, v)
else:
tf.summary.scalar(k, v)
# Training Operaters
apply_gradient_op = tflib.apply_gradient(
tf.trainable_variables(), grads, config.optimizer,
learning_rate_placeholder,
config.learning_rate_multipliers)
update_global_step_op = tf.assign_add(global_step, 1)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
train_ops = [apply_gradient_op, update_global_step_op
] + update_ops
train_op = tf.group(*train_ops)
tf.summary.scalar('learning_rate', learning_rate_placeholder)
summary_op = tf.summary.merge_all()
# Initialize variables
self.sess.run(tf.local_variables_initializer())
self.sess.run(tf.global_variables_initializer())
self.saver = tf.train.Saver(tf.trainable_variables(),
max_to_keep=None)
# Keep useful tensors
self.image_batch_placeholder = image_batch_placeholder
self.label_batch_placeholder = label_batch_placeholder
self.learning_rate_placeholder = learning_rate_placeholder
self.keep_prob_placeholder = keep_prob_placeholder
self.phase_train_placeholder = phase_train_placeholder
self.global_step = global_step
self.watch_list = split_dict
self.train_op = train_op
self.summary_op = summary_op
#!/usr/bin/env python3
import strcon
import xor
import utils
hex_strings = utils.import_file("Inputs/4.txt", split=True)
byte_strings = [strcon.hexToBytes(s) for s in hex_strings]
for b in byte_strings:
(result, score, key) = xor.singleByteDecrypt(b)
if score > 200:
print('Score: {score}\nPlaintext: {s}\nKey: {key}'.format(score=score,
s=result,
key=key))
import utils
utils.import_file('c:\\level.hom')
Args:
memory: A list of ints representing memory addresses and their contents.
Returns:
A tuple of how many cycles were performed and the cycle length.
"""
memory = memory[:]
states = {}
num_cycles = 0
while tuple(memory) not in states:
#keep track of when each state was seen
states[tuple(memory)] = num_cycles
cycle(memory)
num_cycles += 1
cycle_length = num_cycles - states[tuple(memory)]
return (num_cycles, cycle_length)
M = [0, 2, 7, 0]
#Part 1
assert reallocate(M)[0] == 5
cycle(M)
assert M == [2, 4, 1, 2]
#Part 2
assert reallocate(M)[1] == 4
memory = [int(i) for i in utils.import_file("Inputs/input6.txt").split()]
num_cycles, cycle_length = reallocate(memory)
print("Part 1: {}".format(num_cycles))
print("Part 2: {}".format(cycle_length))
import os
import sys
import importlib
from utils import path_to_module, remove_suffix, import_file
dict_ = {'width': width, 'height': height, 'arena_dicts': []}
arena_files = {'./dict_arena_rec_max.py'}
Arena_Params = []
for arena_file in arena_files:
Arena_Param = import_file(arena_file,
start_path=__file__,
main_path=sys.path[0])
Arena_Params.append(Arena_Param)
arena_dict = Arena_Param.dict_
'''
for key, value in arena_dict.items():
print('%s:%s'%(key, value))
#arena_type = arena_dict['type']
'''
dict_['arena_dicts'].append(arena_dict)
'''
if arena_type in ['rec', 'rec_max', 'square']:
dict_arenas['arena_dicts'].append({ # arena 0
'type':'rec_max',
'width': arena_width,
'height': arena_height,
import stream
import utils
import strcon
import block
import xor
key_size = 16
nonce_size = key_size // 2
key = block.generateRandomBytes(key_size)
nonce = bytes([0] * nonce_size)
base64texts = utils.import_file("Inputs/19.txt", split=True)
plaintexts = map(strcon.base64ToBytes, base64texts)
ciphertexts = [stream.CTR_mode(p, key, nonce) for p in plaintexts]
min_len = len(min(ciphertexts, key=len))
transposed_result = []
for i in range(min_len):
letters = bytes([c[i] for c in ciphertexts])
transposed_result.append(xor.singleByteDecrypt(letters)[0].decode())
result = [''.join(s) for s in zip(*transposed_result)]
for r in result:
print(r)
evenly divides the other
"""
for combo in itertools.combinations(l, 2):
low, high = sorted(combo)
q, r = divmod(high, low)
if r == 0: return q
raise InvalidInputError("The list did not contain two numbers where one"
" evenly divides the other")
def divsum(matrix):
return sum([even_divisor(row) for row in matrix])
#part 1
assert checksum([[5, 1, 9, 5],
[7, 5, 3],
[2, 4, 6, 8]]) == 18
#part 2
assert divsum([[5, 9, 2, 8],
[9, 4, 7, 3],
[3, 8, 6, 5]]) == 9
input_file = utils.import_file("Inputs/input2.txt")
matrix = []
for row in input_file.split('\n'):
matrix.append([int(entry) for entry in row.split('\t')])
print("Part 1: {}".format(checksum(matrix)))
print("Part 2: {}".format(divsum(matrix)))
import numpy as np
import argparse
import utils
import tflib
from network import Network
from tensorflow.contrib.tensorboard.plugins import projector
import evaluate
# Config File
parser = argparse.ArgumentParser()
parser.add_argument('--config_file',
help='Path to training configuration file',
type=str)
config_file = parser.parse_args().config_file
# I/O
config = utils.import_file(config_file, 'config')
trainset = utils.Dataset(config.splits_path + '/train_' +
str(config.fold_number) + '.txt')
trainset.images = utils.preprocess(trainset.images, config, True)
network = Network()
network.initialize(config, trainset.num_classes)
# Initalization for running
log_dir = utils.create_log_dir(config, config_file)
summary_writer = tf.summary.FileWriter(log_dir, network.graph)
if config.restore_model:
network.restore_model(config.restore_model, config.restore_scopes)
# Load gallery and probe file_list
def import_file(file_name):
"""Take the json in the given file and import all global constants."""
global sixteenth_per_beat
global beats_per_bar
global num_bars
global sixteenth_duration
global swing
global beat_pattern
global is_active
global swing_amount
if not utils.is_valid_file('saved_beats/' + file_name + '.drum'):
message.set_message("Error")
return False
reset_global_timer()
sixteenth_per_beat, beats_per_bar, num_bars, sixteenth_duration, swing, beat_pattern, is_active, swing_amount = utils.import_file(
'saved_beats/' + file_name + '.drum')
set_graphics()
message.set_message("Imported")
resize_window()
return True
import utils
import strcon
import itertools
import block
block_length = 16
texts = [
strcon.hexToBytes(t) for t in utils.import_file("Inputs/8.txt", split=True)
]
for text in texts:
blocks = block.blockSplit(text, block_length)
for combo in itertools.combinations(blocks, 2):
if combo[0] == combo[1]:
print('Detected duplicate! Text was {0}, block was {1}'.format(
strcon.bytesToHex(text), strcon.bytesToHex(combo[0])))
break
arena_files = ['./dict_arena/dict_arena_rec_max.py']
import os
import sys
import importlib
from utils import path_to_module, remove_suffix, import_file
Arena_Params = []
dict_ = {'width': width, 'height': height, 'arena_dicts': []}
for arena_file in arena_files:
Arena_Param = import_file(path_rel=arena_file,
path_start=__file__,
path_main=sys.path[0])
Arena_Params.append(Arena_Param)
arena_dict = Arena_Param.dict_
'''
for key, value in arena_dict.items():
print('%s:%s'%(key, value))
#arena_type = arena_dict['type']
'''
dict_['arena_dicts'].append(arena_dict)
'''
if arena_type in ['rec', 'rec_max', 'square']:
dict_arenas['arena_dicts'].append({ # arena 0
'type':'rec_max',
'width': arena_width,
'height': arena_height,
def validate_tflite(args):
# open config files
config = utils.import_file(args.config_file, 'config')
testset = utils.Dataset(args.test_dataset_path)
# Set up LFW test protocol and load images
print('Loading images...')
lfwtest = LFWTest(testset.images)
lfwtest.init_standard_proto(args.lfw_pairs_file)
lfwtest.images = utils.preprocess(lfwtest.image_paths,
config,
is_training=False)
# Load TFLite model and allocate tensors
print('Loading network tflite model...')
interpreter = tf.contrib.lite.Interpreter(args.model_dir)
interpreter.allocate_tensors()
# Get Input and output tensors
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# ---------------------------------
# Testing on LFW
num_images = lfwtest.images.shape[0] if type(
lfwtest.images) == np.ndarray else len(lfwtest.images)
num_features = output_details[0]['shape'][1]
result = np.ndarray((num_images, num_features), dtype=np.float32)
total_time = 0.0
print("Extracting Embeddings from LFW...")
#for start_idx in range(0, num_images, config.batch_size):
for start_idx in range(num_images):
# get batch images
#end_idx = min(num_images, start_idx + config.batch_size)
#inputs = lfwtest.images[start_idx:end_idx]
inputs = np.expand_dims(lfwtest.images[start_idx], axis=0)
#print("input should be: ", str(input_details[0]['shape']))
#print("input: ", str(inputs.shape))
# run net
start_time = time.time()
interpreter.set_tensor(input_details[0]['index'], inputs)
interpreter.invoke()
# get batches result
#result[start_idx:end_idx] = interpreter.get_tensor(output_details[0]['index'])
result[start_idx] = interpreter.get_tensor(output_details[0]['index'])
elapsed_time = time.time() - start_time
total_time += elapsed_time
if (start_idx % 100 == 0):
print("Extract " + str(start_idx) + "/" + str(num_images))
if (start_idx % 1000 == 0):
print("Tempo de inferência total: " + str(total_time / 1000))
total_time = 0.0
# calculating accuracy and threshold
print("Calculating accuracy...")
accuracy_embeddings, threshold_embeddings = lfwtest.test_standard_proto(
result)
print('Embeddings Accuracy: %2.4f Threshold %2.3f' %
(accuracy_embeddings, threshold_embeddings))
thickness = 2
color = (0, 0, 255)
font = cv2.FONT_HERSHEY_SIMPLEX
fontScale = 1
time_out = 2
max_fps = 15
count_fps = 0
last_fps_time = time.time()
no_viewer = False
cam = cv2.VideoCapture(0)
font = cv2.FONT_HERSHEY_SIMPLEX
lines = import_file(constants['samples_map_file'])
mapper = {'0': 'No one'}
for line in lines:
identifier, name = line[1].split(',')
mapper[identifier] = name.replace('\n', '')
last_rec = 0
last_rec_time = time.time()
while True:
time.sleep(1 / max_fps)
count_fps += 1
if time.time() - last_fps_time >= 1:
last_fps_time = time.time()
import utils
utils.import_file('c:\\level.cform')
import utils
import strcon
import block
key = b'YELLOW SUBMARINE'
text = ''.join(utils.import_file("Inputs/7.txt", split=True))
text = strcon.base64ToBytes(text)
print(block.decryptAES_ECB(text, key).decode())
def main(args):
# I/O
config_file = args.config_file
config = utils.import_file(config_file, 'config')
trainset = utils.Dataset(config.train_dataset_path)
testset = utils.Dataset(config.test_dataset_path)
network = BaseNetwork()
network.initialize(config, trainset.num_classes)
# Initalization for running
log_dir = utils.create_log_dir(config, config_file)
summary_writer = tf.summary.FileWriter(log_dir, network.graph)
if config.restore_model is not None:
network.restore_model(config.restore_model, config.restore_scopes)
# Set up LFW test protocol and load images
print('Loading images...')
lfwtest = LFWTest(testset.images)
lfwtest.init_standard_proto(config.lfw_pairs_file)
lfwtest.images = utils.preprocess(lfwtest.image_paths,
config,
is_training=False)
trainset.start_batch_queue(config, True)
#
# Main Loop
#
print('\nStart Training\nname: %s\n# epochs: %d\nepoch_size: %d\nbatch_size: %d\n'\
% (config.name, config.num_epochs, config.epoch_size, config.batch_size))
global_step = 0
start_time = time.time()
for epoch in range(config.num_epochs):
# Training
for step in range(config.epoch_size):
# Prepare input
learning_rate = utils.get_updated_learning_rate(
global_step, config)
batch = trainset.pop_batch_queue()
wl, sm, global_step = network.train(batch['images'],
batch['labels'], learning_rate,
config.keep_prob)
# Display
if step % config.summary_interval == 0:
duration = time.time() - start_time
start_time = time.time()
utils.display_info(epoch, step, duration, wl)
summary_writer.add_summary(sm, global_step=global_step)
# Testing on LFW
print('Testing on standard LFW protocol...')
embeddings = network.extract_feature(lfwtest.images, config.batch_size)
accuracy_embeddings, threshold_embeddings = lfwtest.test_standard_proto(
embeddings)
print('Embeddings Accuracy: %2.4f Threshold %2.3f' %
(accuracy_embeddings, threshold_embeddings))
with open(os.path.join(log_dir, 'lfw_result.txt'), 'at') as f:
f.write('%d\t%.5f\n' % (global_step, accuracy_embeddings))
summary = tf.Summary()
summary.value.add(tag='lfw/accuracy', simple_value=accuracy_embeddings)
summary_writer.add_summary(summary, global_step)
# Save the model
network.save_model(log_dir, global_step)
after the last digit is the first digit in the list.
Args:
s: A string of the captcha digits of length at least 2.
shift: An integer number of digits ahead to look for a match.
Returns:
An integer solution to the captcha.
"""
shifted = s[shift:] + s[0:shift]
return sum([int(s[i]) for i in range(len(s)) if s[i] == shifted[i]])
#part 1
assert (solve_captcha("1122") == 3)
assert (solve_captcha("1111") == 4)
assert (solve_captcha("1234") == 0)
assert (solve_captcha("91212129") == 9)
#part 2
assert (solve_captcha("1212", shift=2) == 6)
assert (solve_captcha("1221", shift=2) == 0)
assert (solve_captcha("123425", shift=3) == 4)
assert (solve_captcha("123123", shift=3) == 12)
assert (solve_captcha("12131415", shift=4) == 4)
s = utils.import_file("Inputs/input-1-1.txt")
print("Part 1: {}".format(solve_captcha(s)))
print("Part 2: {}".format(solve_captcha(s, shift=len(s) // 2)))
