class EventType:
ARRIVAL = -1
#Silly implementation, find a workaround
SERVICE_FINISH = []
config = Config('perfsim.config')
NUM_SERVER = config.NUM_SERVER
for i in range(0, NUM_SERVER):
SERVICE_FINISH.append(i)
#NOTE : Service finish may or may not mean departure
def type_from_num(self, queue_number):
#This function will always be called with queue number
#For zeroth row, the event is SERVICE_FINISH[1]
return EventType.SERVICE_FINISH[queue_number]
def queue_from_event(self, etype):
'''
Right now, the enumeration is simple. The queue associated with
SERVICE_FINISH[i] is i - 1
'''
return etype
def name(self, number):
if (number == -1):
return "ARRIVAL"
else:
return "SERVICE_FINISH Q" + str(number)
name = classmethod(name)
type_from_num = classmethod(type_from_num)
queue_from_event = classmethod(queue_from_event)
def test_config_update(self, _, mock: Mock):
mock.return_value = 2
conf = Config()
mock.return_value = 10
self.assertEqual(True, conf.check_config_update())
conf.update_config()
self.assertEqual(10, conf.last_modification)
def main(image):
# Configuration for hyper-parameters
config = Config()
# Image Preprocessing
transform = config.test_transform
# Load vocabulary
with open(os.path.join(config.vocab_path, 'vocab.pkl'), 'rb') as f:
vocab = pickle.load(f)
# Build Models
encoder = EncoderCNN(config.embed_size)
encoder.eval() # evaluation mode (BN uses moving mean/variance)
decoder = DecoderRNN(config.embed_size, config.hidden_size, len(vocab),
config.num_layers)
# Load the trained model parameters
encoder.load_state_dict(
torch.load(
os.path.join(config.teacher_cnn_path, config.trained_encoder)))
decoder.load_state_dict(
torch.load(
os.path.join(config.teacher_lstm_path, config.trained_decoder)))
# Prepare Image
image = Image.open(image)
image_tensor = Variable(transform(image).unsqueeze(0))
# Set initial states
state = (Variable(torch.zeros(config.num_layers, 1, config.hidden_size)),
Variable(torch.zeros(config.num_layers, 1, config.hidden_size)))
# If use gpu
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
state = [s.cuda() for s in state]
image_tensor = image_tensor.cuda()
# Generate caption from image
feature = encoder(image_tensor)
sampled_ids = decoder.sample(feature, state)
sampled_ids = sampled_ids.cpu().data.numpy()
# Decode word_ids to words
sampled_caption = []
for word_id in sampled_ids:
word = vocab.idx2word[word_id]
sampled_caption.append(word)
if word_id == 96:
sampled_caption.append('<end>')
break
if word == '<end>':
break
sentence = ' '.join(sampled_caption)
# Print out image and generated caption.
print(sentence)
return sentence
def test_passenger_generation():
"""Tests passenger generation"""
config_name = get_full_class_name(Config)
with patch(config_name + '.graph_dict',
new_callable=PropertyMock) as mock_graph_dict:
with patch(config_name + '.lines_dict',
new_callable=PropertyMock) as mock_lines_dict:
with patch(config_name + '.traffic_data_dict',
new_callable=PropertyMock) as mock_traffic_dict:
mock_graph_dict.return_value = {
'A': [('B', 1)],
'B': [('A', 1)]
}
mock_lines_dict.return_value = {
0: {
'id': 0,
'bus_capacity': 1,
'frequency1': 10000000,
'frequency2': 1000000000,
'route1': ['B', 'A'],
'route2': ['A', 'B']
}
}
config = Config(["A", "B"], {}, {}, {}, 1.0)
mock_traffic_dict.return_value = {
'A': {
'A': 0,
'B': 120
},
'B': {
'A': 0,
'B': 0
}
}
generated = []
model = []
simulation = Simulation(config)
print(config.lines_dict)
simulation.refresh()
simulation.refresh()
for i in range(100000):
simulation.refresh()
if simulation.stops['A'].passengers:
generated.append(
simulation.stops['A'].passengers[0].count)
for i in range(len(generated) - 1, 0, -1):
generated[i] -= generated[i - 1]
model.append(np.random.poisson(2))
model.append(np.random.poisson(2))
generated = np.sort(np.array(generated))
model = np.sort(np.array(model))
res = sum(np.abs(generated - model) != 0)
assert res / len(
generated) <= 0.02, " jak nie dziolo to odpalic od nowa i nie narzekac, " \
"bo tak naprawde dziala tylko czasem nie"
def main():
config = Config()
splits = ['train', 'val']
for split in splits:
image_dir = os.path.join(config.image_path, '%s2014/' % split)
output_dir = os.path.join(config.image_path, '%s2014resized' % split)
resize_images(image_dir, output_dir,
(config.image_size, config.image_size))
def __init__(self):
config = Config()
self.myclient = pymongo.MongoClient(
config.get('database', 'host'), int(config.get('database',
'port')))
self.mydb = self.myclient[config.get('database', 'db_name')]
self.mydb.authenticate(config.get('database', 'user'),
config.get('database', 'password'))
def main():
config = Config()
vocab = build_vocab(json=os.path.join(config.caption_path,
'captions_train2014.json'),
threshold=config.word_count_threshold)
vocab_path = os.path.join(config.vocab_path, 'vocab.pkl')
with open(vocab_path, 'wb') as f:
pickle.dump(vocab, f, pickle.HIGHEST_PROTOCOL)
print("Saved the vocabulary wrapper to ", vocab_path)
def main():
start = time.time()
config_data_path = r'./config/config.json'
config = Config(config_data_path)
data_df, date_list, industry_list = data_process(config)
date_factor = date_list.sort_values()
industry_factor = industry_list.sort_values()
compute_factor(data_df, date_factor, industry_factor, config)
print('cost time:', time.time() - start)
def setup(self):
""""preform basic configuration, create the Config object which enables configuration to preform
configuration with usage of config.json"""
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
self.config = Config()
self.config.start()
self.client = Client(self.config)
self.agentLog = collector.AgentLogCollector()
logging.info("Agent initialized successfully!")
def build_default(deployment_home, cwd, CommandClasses):
"""
Create a runtime from the command line arguments and configuration on
disk.
If you want something more custom, e.g. in testing, you can build
it yourself ;)
"""
if len(CommandClasses):
arg_parser = CommandClasses[0].build_arg_parser()
else:
arg_parser = Runtime.__create_placeholder_arg_parser()
Runtime.add_default_arguments(arg_parser)
runtime = Runtime()
for CommandClass in CommandClasses:
CommandClass.register_services(runtime)
for ServiceClass in runtime.each_service_class():
add_default_arguments_method = getattr(ServiceClass,
'add_default_arguments',
None)
if add_default_arguments_method and callable(
add_default_arguments_method):
ServiceClass.add_default_arguments(arg_parser)
options = arg_parser.parse_args()
if not hasattr(options, 'deployment_home'):
options.deployment_home = deployment_home
config = Config()
config.set_options(options)
config.set_cwd(cwd)
if hasattr(CommandClass, 'DOTFILE_NAME'):
config.set_dotfile_name(CommandClass.DOTFILE_NAME)
try:
config.read()
except Exception as e:
if not hasattr(
CommandClass,
'is_config_required') or CommandClass.is_config_required():
exc_info = sys.exc_info()
raise e, None, exc_info[2]
log = Log()
log.set_options(options)
runtime.set_options(options)
runtime.set_config(config)
runtime.set_log(log)
runtime.set_cwd(cwd)
return runtime
def __init__(self):
LOG.debug("JellyfinClient initializing...")
self.config = Config()
self.http = HTTP(self)
self.wsc = WSClient(self)
self.auth = ConnectionManager(self)
self.jellyfin = api.API(self.http)
self.callback_ws = callback
self.callback = callback
def dim_division_main():
"""
维度划分程序主入口
:return:
"""
# 获取配置对象
conf = Config()
logging.info("维度划分开始")
dim_division(conf)
logging.info("维度划分结束")
def v1(pretrained=False):
config = Config()
model, _ = caption.build_model(config)
if pretrained:
checkpoint = torch.hub.load_state_dict_from_url(
url='https://github.com/saahiluppal/catr/releases/download/0.1/weights_9348032.pth',
map_location='cpu'
)
model.load_state_dict(checkpoint['model'])
return model
def get_length_dist():
# Load configuration
config = Config()
# Get distribution of num_events
result = []
with open(config.data_path, 'r') as data_file:
lines = data_file.readlines()
for line in lines:
user_behave = json.loads(line).values()[0]
result.append(len(user_behave))
return result
def __init__(self):
self.config = Config()
self.__running = True
import os
os.environ['SDL_VIDEO_CENTERED'] = '1'
self.__screen = pygame.display.set_mode(
self.config.get(self.config.RESOLUTION))
if self.config.get(self.config.FULLSCREEN):
self.toggle_fullscreen()
pygame.display.set_caption("ISN Project")
self.__clock = pygame.time.Clock()
self.__dtime = 0
self.__scene = Scenes.test_scene.SceneTest(self)
def __init__(self):
cnf = Config()
self.csv_model_path = cnf.csv_model_path
self.new_file_dir = cnf.new_csv_dir
self.resource_csv = cnf.resource_csv
self.partNos_count = cnf.partNos_count
self.asc_codes_count = cnf.asc_codes_count
self.logger = logger
self.csv_model_name = None
self.start_time = time.time()
self.load_resource_csv()
self.load_csv_model()
def main():
conf = Config().config
while CONTINUE_WORKING:
to_draw = {
'isp': internet_speed_summary.InternetSpeed(conf).get_speed(),
'qnap': qnap_summary.QnapSummary(conf).get_stats(),
'pihole': pi_hole_summary.PiHoleSummary(conf).get_stats()
}
canvas = canvas_helper.CanvasHelper()
canvas.draw(to_draw)
sleep(1)
def run_dim_cluster_main(syscode):
conf = Config()
logging.info("{}系统分析开始".format(syscode))
input_helper, output_helper = dynamic_import(conf)
input_conn, output_conn = get_input_output_conn(conf)
tables_schedule = output_helper.get_all_fk_tables(output_conn, conf.output_schema)
filter_fks = output_helper.get_all_fk_id_in_detail(output_conn, conf.output_schema)
tables = [tup for tup in tables_schedule if tup[0] == syscode]
logging.info("分析表数量：{}".format(len(tables)))
run_analyse(conf, input_conn, output_conn, tables, filter_fks)
logging.info("{}系统分析结束".format(syscode))
close_odbc_connection(input_conn)
close_db2_connection(output_conn)
def feature_main(sys_code, table_code, etl_date, date_offset, alg):
"""
字段特征分析程序入口
:param sys_code: 系统编号
:param table_code: 表编号
:param etl_date: 卸数日期
:param date_offset: 日期偏移量
:param alg: 卸数方式
:return:
"""
etl_dates = date_trans(etl_date, date_offset)
conf = Config()
# 2、开始按表分析字段特征
logging.info("{}表特征分析开始".format(table_code))
analyse_table_feature(conf, sys_code, table_code, alg, etl_dates)
logging.info("{}表特征分析完成".format(table_code))
def main(_):
# Load configuration
config = Config()
# Build the graph and run session
with tf.Graph().as_default(), tf.Session() as sess:
autoEncoder = AutoEncoder(config)
autoEncoder.build_model()
sess.run(tf.initialize_all_variables())
for epoch in range(config.num_epoch):
with open(config.data_path, 'r') as data_file:
mse = autoEncoder.run_epoch(sess, data_file)
if epoch % 1 == 0:
print('Epoch %d has mean square error: %g' % (epoch, mse))
saver = tf.train.Saver(tf.all_variables())
saver.save(sess, config.save_path)
def main():
config_path = r'./config/config.json'
config = Config(config_path)
mrawret_save_path = config.mrawret_save_path
mrawret = pd.read_csv(mrawret_save_path)
num = len(mrawret)
func = lambda x: (pow(x, 1/num) - 1) * 52
factor_model_return = mrawret.loc[num-1, 'factor_model_cum'] / mrawret.loc[0, 'factor_model_cum']
hs300index_return = mrawret.loc[num-1, 'hs300index_cum'] / mrawret.loc[0, 'hs300index_cum']
net_ret_return = mrawret.loc[num-1, 'net_ret_cum'] / mrawret.loc[0, 'net_ret_cum']
print('factor model ', func(factor_model_return))
print('hs300index', func(hs300index_return))
print("net_ret ", func(net_ret_return))
print("*" * 50)
print('factor model ', np.mean(mrawret.loc[1:, 'factor_model']) * 52)
print('hs300index ', np.mean(mrawret.loc[1:, 'hs300index']) * 52)
print('net_ret ', np.mean(mrawret.loc[1:, 'net_ret']) * 52)
def test_bus_generation():
"""Tests bus generation"""
config_name = get_full_class_name(Config)
with patch(config_name + '.graph_dict',
new_callable=PropertyMock) as mock_graph_dict:
with patch(config_name + '.lines_dict',
new_callable=PropertyMock) as mock_lines_dict:
with patch(config_name + '.traffic_data_dict',
new_callable=PropertyMock) as mock_traffic_dict:
mock_graph_dict.return_value = {
'A': [('B', 1)],
'B': [('A', 1)]
}
mock_lines_dict.return_value = {
0: {
'id': 0,
'bus_capacity': 20,
'frequency1': 10,
'frequency2': 1000,
'route1': ['B', 'A'],
'route2': ['A', 'B']
}
}
config = Config(["A", "B"], {}, {}, {}, 1.0)
mock_traffic_dict.return_value = {
'A': {
'A': 0,
'B': 0
},
'B': {
'A': 0,
'B': 0
}
}
simulation = Simulation(config)
assert Bus.BUS_COUNTER == 0
simulation.refresh()
simulation.refresh()
assert Bus.BUS_COUNTER == 2
for i in range(1, 10):
for _ in range(10):
simulation.refresh()
assert Bus.BUS_COUNTER == 2 + i
def test_init(self, _):
dict_ = {
"config_update_delay": 10,
"server": {
"ip": "localhost",
"port": 8081
},
"send_frequency": 10,
"send_agent_errors": False,
"sys_logs": {
"send": True,
"limit": 200,
"reverse": True,
"priority": "ERROR"
}
}
mock = mock_open(read_data=json.dumps(dict_))
with patch("configuration.open", mock):
conf = Config()
self.assertEqual(10, conf.get_send_frequency())
self.assertEqual('localhost', conf.get_server_ip())
self.assertEqual(8081, conf.get_server_port())
self.assertEqual(dict_['sys_logs'], conf.logs_config.__dict__)
def __init__(self,
input_filename,
parameters=None,
output_filenames=None,
extrap_filenames=None):
# Give default values to attributes that are not specified at
# instantiation. These values must be changed *after* instantiation.
self.use_brune = True
self.use_gsl = True
self.ext_par_file = '\n'
self.ext_capture_file = '\n'
self.command = 'AZURE2'
self.root_directory = ''
self.config = Config(input_filename, parameters=parameters)
'''
If parameters are not specified, they are inferred from the input file.
'''
if parameters is None:
self.parameters = self.config.parameters.copy()
else:
self.parameters = parameters.copy()
'''
If output files are not specified, they are inferred from the input file.
'''
if output_filenames is None:
self.output_filenames = self.config.data.output_files
else:
self.output_filenames = output_filenames
'''
If extrapolation files are not specified, they are inferred from the input file.
'''
if extrap_filenames is None:
self.extrap_filenames = self.config.test.output_files
else:
self.extrap_filenames = extrap_filenames
def main():
# Load configuration
config = Config()
# Parse user_list representations
user_list = []
user_id_list = []
with open(config.rep_path, "r") as data_file:
lines = data_file.readlines()
for line in lines:
user_ = line.split(":")[1].replace("[", "").replace(']"}',
"").split()
user = [float(u) for u in user_[1:len(user_)]]
user_list.append(user)
user_id_list.append(
line.split(":")[0].replace("{", "").replace('"', ""))
user_list = np.array(user_list)
user_id_list = np.array(user_id_list)
# If tsne is already run
path_user_tsne = os.path.join(os.path.dirname(config.save_path),
"user_tsne")
if os.path.isfile(path_user_tsne):
user_tsne = load_object(path_user_tsne)
else:
# Run TSNE
model = TSNE(n_components=2, random_state=0)
np.set_printoptions(suppress=True)
user_tsne = model.fit_transform(user_list)
# Save TSNE objects
print "Save user_tsne."
save_object(user_tsne, "save/user_tsne")
# Run KMeans clustering
kmeans = KMeans(init="k-means++", n_clusters=8, n_init=10)
km = kmeans.fit(user_list)
# Get cluster labels
labels = km.labels_
unique_labels = set(labels)
# Save clustering results
save_object(user_id_list, "save/user_ids_km")
save_object(labels, "save/labels_km")
# Save the cluster_to_user dict
cluster_to_user = dict()
for k in unique_labels:
class_member_mask = (labels == k)
class_k = user_id_list[class_member_mask]
cluster_to_user[k] = class_k
save_object(cluster_to_user, "save/cluster_to_user")
# Save the user_to_cluster dict
user_to_cluster = dict()
for user, label in zip(user_id_list, labels):
user_to_cluster[user] = label
save_object(user_to_cluster, "save/user_to_cluster")
# Plot results
colors = plt.get_cmap("Spectral")(np.linspace(0, 1, len(unique_labels)))
for k, col in zip(unique_labels, colors):
class_member_mask = (labels == k)
xy = user_tsne[class_member_mask]
plt.plot(xy[:, 0],
xy[:, 1],
"o",
markerfacecolor=col,
markeredgecolor="k",
markersize=3)
plt.title("KMeans Clustering")
plt.show()
parser.add_argument('--v', type=str, help='version', default='v3')
args = parser.parse_args()
image_path = args.path
version = args.v
if version == 'v1':
model = torch.hub.load('saahiluppal/catr', 'v1', pretrained=True)
elif version == 'v2':
model = torch.hub.load('saahiluppal/catr', 'v2', pretrained=True)
elif version == 'v3':
model = torch.hub.load('saahiluppal/catr', 'v3', pretrained=True)
else:
raise NotImplementedError('Version not implemented')
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
config = Config()
start_token = tokenizer.convert_tokens_to_ids(tokenizer._cls_token)
end_token = tokenizer.convert_tokens_to_ids(tokenizer._sep_token)
image = Image.open(image_path)
image = coco.val_transform(image)
image = image.unsqueeze(0)
def create_caption_and_mask(start_token, max_length):
caption_template = torch.zeros((1, max_length), dtype=torch.long)
mask_template = torch.ones((1, max_length), dtype=torch.bool)
caption_template[:, 0] = start_token
mask_template[:, 0] = False
def main():
# Configuration for hyper-parameters
config = Config()
# Image preprocessing
transform = config.train_transform
# Load vocabulary wrapper
with open(os.path.join(config.vocab_path, 'vocab.pkl'), 'rb') as f:
vocab = pickle.load(f)
# Build data loader
image_path = os.path.join(config.image_path, 'train2014')
json_path = os.path.join(config.caption_path, 'captions_train2014.json')
train_loader = get_data_loader(image_path, json_path, vocab,
transform, config.batch_size,
shuffle=True, num_workers=config.num_threads)
total_step = len(train_loader)
# Build Models
teachercnn = EncoderCNN(config.embed_size)
teachercnn.eval()
studentcnn = StudentCNN_Model1(config.embed_size)
#Load the best teacher model
teachercnn.load_state_dict(torch.load(os.path.join('../TrainedModels/TeacherCNN', config.trained_encoder)))
studentlstm = DecoderRNN(config.embed_size, config.hidden_size/2,
len(vocab), config.num_layers/2)
if torch.cuda.is_available():
teachercnn.cuda()
studentcnn.cuda()
studentlstm.cuda()
# Loss and Optimizer
criterion_lstm = nn.CrossEntropyLoss()
criterion_cnn = nn.MSELoss()
params = list(studentlstm.parameters()) + list(studentcnn.parameters())
optimizer_lstm = torch.optim.Adam(params, lr=config.learning_rate)
optimizer_cnn = torch.optim.Adam(studentcnn.parameters(), lr=config.cnn_learningrate)
print('entering in to training loop')
# Train the Models
for epoch in range(config.num_epochs):
for i, (images, captions, lengths, img_ids) in enumerate(train_loader):
images = Variable(images)
captions = Variable(captions)
if torch.cuda.is_available():
images = images.cuda()
captions = captions.cuda()
targets = pack_padded_sequence(captions, lengths, batch_first=True)[0]
# Forward, Backward and Optimize
optimizer_lstm.zero_grad()
optimizer_cnn.zero_grad()
features_tr = teachercnn(images)
features_st = studentcnn(images)
outputs = studentlstm(features_st, captions, lengths)
loss = criterion(features_st, features_tr.detach()) + criterion_lstm(outputs, targets)
loss.backward()
optimizer_cnn.step()
optimizer_lstm.step()
# Print log info
if i % config.log_step == 0:
print('Epoch [%d/%d], Step [%d/%d], Loss: %.4f, Perplexity: %5.4f'
%(epoch, config.num_epochs, i, total_step,
loss.data[0], np.exp(loss.data[0])))
# Save the Model
if (i+1) % config.save_step == 0:
torch.save(studentlstm.state_dict(),
os.path.join(config.student_lstm_path,
'decoder-%d-%d.pkl' %(epoch+1, i+1)))
torch.save(studentcnn.state_dict(),
os.path.join(config.student_cnn_path,
'encoder-%d-%d.pkl' %(epoch+1, i+1)))
import torch
import cv2
import numpy as np
import random
import matplotlib.pyplot as plt
import os
import glob
import json
from skimage import exposure
import warnings
from configuration import Config
import multiprocessing
multiprocessing.set_start_method('spawn', True)
cfg = Config()
class ImageGenerator(Dataset):
def __init__(self, input_path, num_images, transform=None):
with open(input_path, 'r') as f:
self.img_list = f.readlines()
self.num_images = num_images
self.transform = transform
def __len__(self):
return (self.num_images // cfg.batch_size) * cfg.batch_size
def __getitem__(self, idx):
def main():
# Configuration for hyper-parameters
torch.cuda.set_device(0)
config = Config()
# Image preprocessing
transform = config.train_transform
# Load vocabulary wrapper
with open(os.path.join(config.vocab_path, 'vocab.pkl'), 'rb') as f:
vocab = pickle.load(f)
# Build data loader
train_image_path = os.path.join(config.image_path, 'train2017')
json_path = os.path.join(config.caption_path, 'captions_train2017.json')
train_loader = get_data_loader(train_image_path,
json_path,
vocab,
transform,
config.batch_size,
shuffle=False,
num_workers=config.num_threads)
val_image_path = os.path.join(config.image_path, 'val2017')
json_path = os.path.join(config.caption_path, 'captions_val2017.json')
val_loader = get_data_loader(val_image_path,
json_path,
vocab,
transform,
config.batch_size,
shuffle=False,
num_workers=config.num_threads)
total_step = len(train_loader)
# Build Models
encoder = EncoderCNN(config.embed_size)
encoder.eval()
decoder = DecoderRNN(config.embed_size, config.hidden_size, len(vocab),
config.num_layers)
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
# Loss and Optimizer
criterion = nn.CrossEntropyLoss()
params = list(decoder.parameters()) + list(encoder.resnet.fc.parameters())
optimizer = torch.optim.Adam(params, lr=config.learning_rate)
print('entering in to training loop')
# Train the Models
with open('train1_log.txt', 'w') as logfile:
logfile.write('Validation Error,Training Error')
for epoch in range(0, 25):
for i, (images, captions, lengths,
img_ids) in enumerate(train_loader):
images = Variable(images)
captions = Variable(captions)
if torch.cuda.is_available():
images = images.cuda()
captions = captions.cuda()
targets = pack_padded_sequence(captions,
lengths,
batch_first=True)[0]
# Forward, Backward and Optimize
optimizer.zero_grad()
features = encoder(images)
outputs = decoder(features, captions, lengths)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
# Print log info
if i % config.log_step == 0:
print(
'Epoch [%d/%d], Step [%d/%d], Loss: %.4f, Perplexity: %5.4f'
% (epoch, config.num_epochs, i, total_step,
loss.data[0], np.exp(loss.data[0])))
# Save the Model
if (i + 1) % config.save_step == 0:
torch.save(
encoder.state_dict(),
os.path.join(config.teacher_cnn_path,
'encoder-%d-%d.pkl' % (epoch + 1, i + 1)))
torch.save(
decoder.state_dict(),
os.path.join(config.teacher_lstm_path,
'decoder-%d-%d.pkl' % (epoch + 1, i + 1)))
print('Just Completed an Epoch, Initite Validation Error Test')
avgvalloss = 0
for j, (images, captions, lengths,
img_ids) in enumerate(val_loader):
images = Variable(images)
captions = Variable(captions)
if torch.cuda.is_available():
images = images.cuda()
captions = captions.cuda()
targets = pack_padded_sequence(captions,
lengths,
batch_first=True)[0]
optimizer.zero_grad()
features = encoder(images)
outputs = decoder(features, captions, lengths)
valloss = criterion(outputs, targets)
if j == 0:
avgvalloss = valloss.data[0]
avgvalloss = (avgvalloss + valloss.data[0]) / 2
if ((j + 1) % 1000 == 0):
print('Average Validation Loss: %.4f' % (avgvalloss))
logfile.write(
str(avgvalloss) + ',' + str(loss.data[0]) + str('\n'))
break
#!/usr/local/bin/python3.7
import const as cs
from configuration import Config
from reaction import Reaction
# Read temperature
print("Calculation of the reaction rate")
T_K = float(input("Type temperature (in K): "))
if T_K < 0.0:
raise Exception("Negative temperature")
# Initiate thermodynamics objects
in_state = Config("initial state")
ts_state = Config("transition state")
fi_state = Config("final state")
print()
print(in_state)
print(ts_state)
print(fi_state)
diss = Reaction("dissociation", in_state, ts_state, fi_state, T_K)
print(diss)
