def run_til_halt(tgt, semihostagent):
with ElapsedTimer('run_til_halt',
logger=logging.getLogger('root'),
loglevel=logging.INFO) as t:
logging.info("Resuming target")
tgt.resume()
try:
while True:
if t.elapsed >= 2.0:
raise TimeoutError()
if tgt.getState() == Target.TARGET_HALTED:
logging.info("Target halted")
didHandle = semihostagent.check_and_handle_semihost_request(
)
if didHandle:
logging.info("Semihost request handled")
else:
logging.info("Non-semihost break")
return didHandle
except TimeoutError:
tgt.halt()
return False
finally:
assert tgt.getState() == Target.TARGET_HALTED
" Training Accuracy=", "{:.9f}".format(a))
c1, a1 = sess.run([self.loss, self.accuracy],
feed_dict={
self.X: X_batch_val,
self.y: y_batch_val
})
print(" Epoch=", epoch, " Validation Loss: ",
"{:.9f}".format(c1), " Validation Accuracy=",
"{:.9f}".format(a1))
results = sess.run(self.prediction_probability,
feed_dict={self.X: X_batch_val})
print(results)
if epoch % self.checkpoint_step == 0:
self.saver.save(sess,
os.path.join(self.path, 'model'),
global_step=epoch)
self.saver.save(sess, self.path + 'model_ckpt')
results = sess.run(self.prediction_probability,
feed_dict={self.X: X_batch_val})
print(results)
def process_main(self):
self._train()
if __name__ == '__main__':
with ElapsedTimer('Model train'):
fire.Fire(Review_sentiment)
print(f'Processing video {video}')
#self.dest = 'cnn_feat' + '_' + video_id
self.video_to_frames(video)
image_list = sorted(
glob.glob(os.path.join(self.temp_dest, '*.jpg')))
samples = np.round(
np.linspace(0,
len(image_list) - 1, self.frames_step))
image_list = [image_list[int(sample)] for sample in samples]
images = np.zeros(
(len(image_list), self.img_dim, self.img_dim, self.channels))
for i in range(len(image_list)):
img = self.load_image(image_list[i])
images[i] = img
images = np.array(images)
fc_feats = model.predict(images, batch_size=self.batch_cnn)
img_feats = np.array(fc_feats)
outfile = os.path.join(self.feat_dir, video_id + '.npy')
np.save(outfile, img_feats)
# cleanup
shutil.rmtree(self.temp_dest)
def process_main(self):
self.extract_feats_pretrained_cnn()
if __name__ == '__main__':
with ElapsedTimer('VideoCaptioningPreProcessing'):
fire.Fire(VideoCaptioningPreProcessing)
self.encoder_model,
self.decoder_model,
input_text_te)
out_df = pd.DataFrame()
out_df['English text'] = in_list
out_df['French text'] = out_list
out_df.to_csv(self.outdir + 'hold_out_results_validation.csv',
index=False)
self.save_models(self.outdir)
else:
self.load_models(self.outdir)
input_texts, _, _, _ = self.read_input_file(
self.path, self.num_samples)
encoder_input_data,_,_,input_texts,_ = \
self.process_input(input_texts,'',True)
in_list, out_list = self.inference(self.model,
encoder_input_data_te,
self.encoder_model,
self.decoder_model,
input_text_te)
out_df = pd.DataFrame()
out_df['English text'] = in_list
out_df['French text'] = out_list
out_df.to_csv(self.outdir + 'results_test.csv', index=False)
if __name__ == '__main__':
obj = MachineTranslation()
with ElapsedTimer(obj.mode):
obj.main()
os.mkdir(outdir)
except:
'Directory already present,writing captchas to the same'
#rint(char_num_ind)
# select one alphabet if indicator 1 else number
for i in range(num_captchas):
char_num_ind = list(np.random.randint(0, 2, 4))
text = ''
for ind in char_num_ind:
if ind == 1:
loc = np.random.randint(0, 26, 1)
text = text + alphabets[np.random.randint(0, 26, 1)[0]]
else:
text = text + str(np.random.randint(0, 10, 1)[0])
c = Claptcha(text, font)
text, image = c.image
image.save(outdir + text + '.png')
def main_process(outdir_train, num_captchas_train, outdir_val,
num_captchas_val, outdir_test, num_captchas_test, font):
generate_captcha(outdir_train, font, num_captchas_train)
generate_captcha(outdir_val, font, num_captchas_val)
generate_captcha(outdir_test, font, num_captchas_test)
if __name__ == '__main__':
with ElapsedTimer('main_process'):
fire.Fire(main_process)
for file_name in data_A]
data_B = [(self.dataset_dir + 'trainB/' + str(file_name))
for file_name in data_B]
np.random.shuffle(data_A)
np.random.shuffle(data_B)
batch_files = list(
zip(data_A[:self.batch_size], data_B[:self.batch_size]))
sample_images = [
load_train_data(batch_file, is_testing=True)
for batch_file in batch_files
]
sample_images = np.array(sample_images).astype(np.float32)
fake_A, fake_B = self.sess.run(
[self.images_fake_A_, self.images_fake_B],
feed_dict={self.images_real: sample_images})
save_images(fake_A, [self.batch_size, 1],
'./{}/A_{:02d}_{:04d}.jpg'.format(sample_dir, epoch, id_))
save_images(fake_B, [self.batch_size, 1],
'./{}/B_{:02d}_{:04d}.jpg'.format(sample_dir, epoch, id_))
def process_main(self):
self.build_network()
self.train_network()
if __name__ == '__main__':
with ElapsedTimer('DiscoGAN'):
fire.Fire(DiscoGAN)
X_ = pad_sequences(X_)
y = df['sentiment_label'].values
index = list(range(X_.shape[0]))
np.random.shuffle(index)
train_record_count = int(len(index) * 0.7)
validation_record_count = int(len(index) * 0.15)
train_indices = index[:train_record_count]
validation_indices = index[train_record_count:train_record_count +
validation_record_count]
test_indices = index[train_record_count + validation_record_count:]
X_train, y_train = X_[train_indices], y[train_indices]
X_val, y_val = X_[validation_indices], y[validation_indices]
X_test, y_test = X_[test_indices], y[test_indices]
np.save(path + 'X_train', X_train)
np.save(path + 'y_train', y_train)
np.save(path + 'X_val', X_val)
np.save(path + 'y_val', y_val)
np.save(path + 'X_test', X_test)
np.save(path + 'y_test', y_test)
# saving the tokenizer oject for inference
with open(path + 'tokenizer.pickle', 'wb') as handle:
pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
if __name__ == '__main__':
with ElapsedTimer('Process'):
fire.Fire(process_main)
output_optimized_graph_name = path + 'optimized_' + MODEL_NAME + '.pb'
clear_devices = True
freeze_graph.freeze_graph(input_graph_path, input_saver_def_path,
input_binary, checkpoint_path, output_node_names,
restore_op_name, filename_tensor_name,
output_frozen_graph_name, clear_devices, "")
input_graph_def = tf.GraphDef()
with tf.gfile.Open(output_frozen_graph_name, "rb") as f:
data = f.read()
input_graph_def.ParseFromString(data)
output_graph_def = optimize_for_inference_lib.optimize_for_inference(
input_graph_def,
["inputs/X"], #an array of the input node(s)
["positive_sentiment_probability"],
tf.int32.as_datatype_enum # an array of output nodes
)
# Save the optimized graph
f = tf.gfile.FastGFile(output_optimized_graph_name, "w")
f.write(output_graph_def.SerializeToString())
if __name__ == '__main__':
with ElapsedTimer('Model Freeze'):
fire.Fire(model_freeze)
f'Folder trainA already present, cleaning up and recreating empty folder trainB'
)
try:
os.rmdir('trainB')
except:
shutil.rmtree('trainB')
os.makedirs('trainB')
path = Path(path)
files = os.listdir(path / _dir_)
print('Images to process:', len(files))
i = 0
for f in files:
i += 1
img = imread(path / _dir_ / str(f))
w, h, d = img.shape
h_ = int(h / 2)
img_A = img[:, :h_]
img_B = img[:, h_:]
imsave(f'{path}/trainA/{str(f)}_A.jpg', img_A)
imsave(f'{path}/trainB/{str(f)}_B.jpg', img_A)
if ((i % 10000) == 0 & (i >= 10000)):
print(f'the number of input images processed : {i}')
files_A = os.listdir(path / 'trainA')
files_B = os.listdir(path / 'trainB')
print(f'No of images written to {path}/trainA is {len(files_A)}')
print(f'No of images written to {path}/trainA is {len(files_B)}')
with ElapsedTimer('process Domain A and Domain B Images'):
fire.Fire(process_data)
# Instantiate QFT Class
_qft_ = QFT(signal_length=signal_length,
basis_to_transform=basis_to_transform,
validate_inverse_fourier=validate_inverse_fourier)
# Build the QFT Circuit
_qft_.qft_circuit()
# Create the input Qubit State
if len(_qft_.input_circuit) > 0:
_qft_.circuit = _qft_.input_circuit + _qft_.circuit
if _qft_.validate_inverse_fourier:
_qft_.circuit += _qft_.inv_circuit
print("Combined Circuit")
print(_qft_.circuit)
# Simulate the circuit
output_state = _qft_.simulate_circuit()
# Print the Results
print(output_state)
if __name__ == '__main__':
with ElapsedTimer('Execute Quantum Fourier Transform'):
fire.Fire(main)
predictions.append(pred)
df = pd.DataFrame()
df['files'] = files
df['predictions'] = predictions
if fetch_target == True:
match = []
df['targets'] = targets
accuracy_count = 0
for i in range(len(files)):
if targets[i] == predictions[i]:
accuracy_count+= 1
match.append(1)
else:
match.append(0)
print(f'Accuracy: {accuracy_count/float(len(files))} ')
eval_file = outdir + 'evaluation.csv'
df['match'] = match
df.to_csv(eval_file,index=False)
print(f'Evaluation file written at: {eval_file} ')
if __name__ == '__main__':
with ElapsedTimer('captcha_solver'):
fire.Fire()
gen_word_idx = sess.run(caption_tf,
feed_dict={
video_tf: video_feat,
video_mask_tf: video_mask
})
gen_words = self.idx2word[gen_word_idx]
punct = np.argmax(np.array(gen_words) == '<eos>') + 1
gen_words = gen_words[:punct]
gen_sent = ' '.join(gen_words)
gen_sent = gen_sent.replace('<bos> ', '')
gen_sent = gen_sent.replace(' <eos>', '')
print(
f'Video path {video_feat_path} : Generated Caption {gen_sent}')
print(gen_sent, '\n')
f.write(video_feat_path + '\n')
f.write(gen_sent + '\n\n')
def process_main(self):
if self.mode == 'train':
self.train()
else:
self.inference()
if __name__ == '__main__':
with ElapsedTimer('Video Captioning'):
fire.Fire(VideoCaptioning)
import pickle
import fire
from elapsedtimer import ElapsedTimer
#path = '/home/santanu/Downloads/Mobile_App/aclImdb/tokenizer.pickle'
#path_out = '/home/santanu/Downloads/Mobile_App/word_ind.txt'
def tokenize(path, path_out):
with open(path, 'rb') as handle:
tokenizer = pickle.load(handle)
dict_ = tokenizer.word_index
keys = list(dict_.keys())[:50000]
values = list(dict_.values())[:50000]
total_words = len(keys)
f = open(path_out, 'w')
for i in range(total_words):
line = str(keys[i]) + ',' + str(values[i]) + '\n'
f.write(line)
f.close()
if __name__ == '__main__':
with ElapsedTimer('Tokenize'):
fire.Fire(tokenize)
self.df_result = self.test_df.merge(self.train_df,
on=['userid', 'movieid'])
# in order to get the original ids we just need to add 1
self.df_result['userid'] = self.df_result['userid'] + 1
self.df_result['movieid'] = self.df_result['movieid'] + 1
if self.user_info_file != None:
self.df_result = self.df_result.merge(self.user_info_df,
on=['userid'])
if self.movie_info_file != None:
self.df_result = self.df_result.merge(self.movie_info_df,
on=['movieid'])
self.df_result.to_csv(self.outdir + 'test_results.csv', index=False)
print(f'output written to {self.outdir}test_results.csv')
test_rmse = (np.mean(
(self.df_result['rating'].values -
self.df_result['predicted_rating'].values)**2))**0.5
print(f'test RMSE : {test_rmse}')
def main_process(self):
self.read_data()
if self.mode == 'train':
self._train()
else:
self.inference()
if __name__ == '__main__':
with ElapsedTimer('process RBM'):
fire.Fire(recommender)
size=(batch_size, gen_input_dim))
make_trainable(d, False)
#d.trainable = False
# Train the generator on fake images from Noise
g_loss = g_d.train_on_batch(noise, [1] * batch_size)
print("batch %d g_loss : %f" % (index, g_loss))
if index % 10 == 9:
g.save_weights('generator', True)
d.save_weights('discriminator', True)
# Generate Captchas for use
def generate_captcha(gen_input_dim, alpha, num_images, model_dir, outdir):
g = generator(gen_input_dim, alpha)
g.load_weights(model_dir + 'generator')
noise = np.random.normal(loc=0, scale=1, size=(num_images, gen_input_dim))
generated_images = g.predict(noise, verbose=1)
for i in range(num_images):
img = generated_images[i, :]
img = np.uint8(((img + 1) / 2) * 255)
img = Image.fromarray(img)
img.save(outdir + 'captcha_' + str(i) + '.png')
if __name__ == '__main__':
with ElapsedTimer('main'):
fire.Fire()