def test_multiply_other_counter(self):
a = Counter({'b': 5, 'c': 2})
b = Counter({'a': 3, 'b': 5})
c = a * b
self.assertAlmostEqual(c['a'], 0)
self.assertAlmostEqual(c['b'], 25)
self.assertAlmostEqual(c['c'], 0)
def test_add_other_counter(self):
a = Counter({'b': 5, 'c': 2})
b = Counter({'a': 3, 'b': 5})
c = a + b
self.assertAlmostEqual(c['a'], 3)
self.assertAlmostEqual(c['b'], 10)
self.assertAlmostEqual(c['c'], 2)
def __init__(self, log_dir):
super().__init__(name="Logger")
self.device = Params.DEVICE
with tf.device(self.device), self.name_scope:
self.episode_counter = Counter("episode_counter",
start=-1,
dtype=tf.int32)
self.actor_steps_counter = Counter("actor_steps_counter",
start=0,
dtype=tf.int32)
self.get_time = lambda: tf.reshape(
tf.py_function(time.time, [], Tout=tf.float64), ()) * 1000
self.actor_time = tf.Variable(self.get_time())
self.learner_time = tf.Variable(self.get_time())
self.learner_log_steps = tf.cast(Params.LEARNER_LOG_STEPS,
tf.float64)
# Init Tensorboard writer
if Params.LOG_TENSORBOARD:
self.log_dir = log_dir
self.writer = tf.summary.create_file_writer(self.log_dir)
else:
self.writer = None
# Log parameters
self.log_params()
def test_positive(self):
a = Counter({'a': 1})
self.assertTrue(a.positive())
a = Counter({'a': -1})
self.assertFalse(a.positive())
a = Counter({'a': 1, 'b': -1})
self.assertFalse(a.positive())
def test_base_impossible_2(self):
A = sympy.Symbol('A')
B = sympy.Symbol('B')
state_0 = Counter({A: 2})
substrate = Counter({A: 3})
products = Counter({B: 2})
kinetic = A * (A - 1)
new_state, kinetic_val = shift(state_0, substrate, products, kinetic)
self.assertEqual(new_state, None)
self.assertEqual(kinetic_val, None)
def naive_distribution(self, state_0, final_time, burnout_time):
from collections import Counter
distribution = Counter()
conteggi = Counter()
for state, time, dt in self.gillespie(state_0, final_time):
if time<burnout_time:
continue
idx = tuple(state.values())
distribution[idx]+=dt
conteggi[idx]+=1
return state_0.keys(), distribution, conteggi
def test_add_dict_reverse(self):
a = Counter({'b': 5, 'c': 2})
b = {'a': 3, 'b': 5}
c = b + a
self.assertAlmostEqual(c['a'], 3)
self.assertAlmostEqual(c['b'], 10)
self.assertAlmostEqual(c['c'], 2)
def train(args):
base_dir = args.base_dir
dirs = init_dir(base_dir)
init_log(dirs['log'])
config_dir = args.config_dir
copy_file(config_dir, dirs['data'])
config = configparser.ConfigParser()
config.read(config_dir)
# init env
env = init_env(config['ENV_CONFIG'])
logging.info('Training: a dim %r, agent dim: %d' % (env.n_a_ls, env.n_agent))
# init step counter
total_step = int(config.getfloat('TRAIN_CONFIG', 'total_step'))
test_step = int(config.getfloat('TRAIN_CONFIG', 'test_interval'))
log_step = int(config.getfloat('TRAIN_CONFIG', 'log_interval'))
global_counter = Counter(total_step, test_step, log_step)
# init centralized or multi agent
seed = config.getint('ENV_CONFIG', 'seed')
model = init_agent(env, config['MODEL_CONFIG'], total_step, seed)
# disable multi-threading for safe SUMO implementation
summary_writer = tf.summary.FileWriter(dirs['log'])
trainer = Trainer(env, model, global_counter, summary_writer, output_path=dirs['data'])
trainer.run()
# save model
final_step = global_counter.cur_step
logging.info('Training: save final model at step %d ...' % final_step)
model.save(dirs['model'], final_step)
def __init__(self, args, k, train_data):
self.k = k
self.args = args
self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
self.data = torch.tensor(train_data[0]).to(self.device)
self.label = torch.tensor(train_data[1]).to(self.device)
self.counter = Counter()
def main():
"""
Called when midi_store is run directly. Starts a series of database worker processes and kicks off the parsing of
the MIDI files and storing them in the database(s).
"""
parser = OptionParser()
parser.add_option("-d", "--data-directory", dest="data_directory", default="data/")
parser.add_option("-t", "--pool-size", dest="pool_size", default=8, type="int")
parser.add_option("-u", "--username", dest="db_username", default="postgres")
parser.add_option("-p", "--password", dest="db_password", default="postgres")
(options, args) = parser.parse_args()
# construct the mp.Queue of midi files to process
q = Queue()
for root, dirnames, filenames in os.walk(options.data_directory):
for filename in fnmatch.filter(filenames, '*.mid'):
midiPath = os.path.abspath(os.path.join(root, filename))
q.put(midiPath)
# construct the series of database engines
engines = get_engines(options.pool_size,options.db_username,options.db_password)
processes = []
counter = Counter(0)
for i in xrange(options.pool_size):
p = Runner(q,engines[i],counter)
p.start()
processes.append(p)
# wait for all engines to complete.
for p in processes:
p.join()
def test_normalize_1(self):
a = Counter({'a': 3, 'b': 5, 'c': 2})
b = a.normalize()
self.assertAlmostEqual(b.total(), 1.0)
self.assertAlmostEqual(b['a'], 0.3)
self.assertAlmostEqual(b['b'], 0.5)
self.assertAlmostEqual(b['c'], 0.2)
self.assertIs(a.keymap, b.keymap)
def ExtractDataTrack(
track: List[mido.Message],
exclusionThreshold: float) -> Tuple(List[Interval], List[int]):
standaloneIntervals = []
deltaTimes = []
times = [track[0].time]
frequencies = [Note.FromHeight(track[0].note).Frequency]
for idMsg in range(1, len(track)):
dt = track[idMsg].time - track[idMsg - 1].time
if dt < exclusionThreshold:
deltaTimes.append(dt)
n0 = Note.FromHeight(track[idMsg].note)
n1 = Note.FromHeight(track[idMsg - 1].note)
times.append(track[idMsg].time)
frequencies.append(n0.Frequency)
currInterval = Interval.FromNotes(n0, n1)
standaloneIntervals.append(currInterval)
tempSuccessionIntervals = [
(standaloneIntervals[idInterval - 1].ShortStr(),
standaloneIntervals[idInterval].ShortStr())
for idInterval in range(1, len(standaloneIntervals))
]
successionIntervals = LayeredCounter()
for elem in tempSuccessionIntervals:
successionIntervals[elem[0]][elem[1]] += 1
#print(successionIntervals)
standaloneIntervals.sort()
counterStandaloneIntervals = Counter()
counterStandaloneIntervals.AddListElements(
[interval.ShortStr() for interval in standaloneIntervals])
outDeltatimes = Counter()
outDeltatimes.AddListElements(deltaTimes)
return times, frequencies, outDeltatimes, counterStandaloneIntervals, successionIntervals
def __init__(self, env, hidden_layer=[64, 64]):
self.env = env
#self.env.env.disableViewer = False
self.num_inputs = env.observation_space.shape[0]
self.num_outputs = env.action_space.shape[0]
self.hidden_layer = hidden_layer
self.params = Params()
self.Net = ActorCriticNet
self.model = self.Net(self.num_inputs, self.num_outputs,
self.hidden_layer)
self.model.share_memory()
self.shared_obs_stats = Shared_obs_stats(self.num_inputs)
self.memory = ReplayMemory(10000000)
self.value_memory = ReplayMemory(10000000)
self.test_mean = []
self.test_std = []
self.noisy_test_mean = []
self.noisy_test_std = []
self.fig = plt.figure()
#self.fig2 = plt.figure()
self.lr = self.params.lr
plt.show(block=False)
self.test_list = []
self.noisy_test_list = []
self.queue = mp.Queue()
self.value_queue = mp.Queue()
self.mpdone = [mp.Event(), mp.Event(), mp.Event(), mp.Event()]
self.process = []
self.traffic_light = TrafficLight()
self.counter = Counter()
self.best_trajectory = ReplayMemory(5000)
self.best_score_queue = mp.Queue()
self.best_score = mp.Value("f", 0)
self.max_reward = mp.Value("f", 1)
self.expert_trajectory = ReplayMemory(1e7)
self.validation_trajectory = ReplayMemory(6000 * 9)
self.best_validation = 1.0
self.current_best_validation = 1.0
self.return_obs_stats = Shared_obs_stats(1)
self.gpu_model = self.Net(self.num_inputs, self.num_outputs,
self.hidden_layer)
self.base_controller = None
def __init__(self, model):
super().__init__(model)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
self.transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
self.stat = Counter()
def __init__(self, model):
self.model = model
self.device = next(model.parameters()).device
self.transform = transforms.Compose([
transforms.Pad(4),
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32),
transforms.ToTensor()
])
self.stat = Counter()
self.path = "./data/models_dict/%s.ckpt" % self.model.__class__.__name__
def main():
train_transforms = Compose([
Resize((640, 320)),
RandomHorizontalFlip(),
RandomCrop((640, 320), 20),
ToTensor()
])
train_dataset = AmapDataset(DATA_DIR, "train", transforms=train_transforms)
train_loader = DataLoader(train_dataset,
BATCH_SIZE,
True,
num_workers=NUM_WORKERS,
collate_fn=collate_fn)
device = torch.device(DEVICE)
model = MyModule(num_classes=3).to(device)
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.Adam(params, lr=0.001, weight_decay=0.005)
if os.path.exists(MODEL_FILE):
model.load_state_dict(torch.load(MODEL_FILE))
for epoch in range(1, EPOCHS + 1):
model.train()
counter = Counter()
for step, (idx, img, times, label) in enumerate(train_loader):
step, total_step = step + 1, len(train_loader)
img, times, label = img.to(device), times.to(device), label.to(
device)
pred = model(img, times)
loss = nn.functional.cross_entropy(pred, label)
optimizer.zero_grad()
loss.backward()
optimizer.step()
pred = torch.argmax(pred, 1)
acc = (pred == label).float().mean().cpu().detach().numpy()
loss = loss.cpu().detach().numpy()
counter.append(loss=loss, acc=acc)
print(
f"Epoch:{epoch}/{EPOCHS}, Step:{step}/{total_step}, "
f"Loss:{loss:.04f}/{counter.loss:.04f}, "
f"Accuracy:{acc:0.4f}/{counter.acc:.04f}",
end='\r',
flush=True)
torch.save(model.state_dict(), MODEL_FILE)
print()
def escapes(self, start):
"""given a starting state it evaluate which states are reachable and the corresponding transition rate"""
start = Counter(start)
end_states = []
kinetics = []
for substrate, products, kinetic in self.reactions:
end_state, kinetic = shift(start, substrate, products, kinetic)
if kinetic and end_state is not None:
end_states.append(end_state)
kinetics.append(float(kinetic))
kinetics = np.array(kinetics)
return end_states, kinetics
def transition_matrix(self, start):
"""create the transition matrix and the state vector from a starting point
Will stuck in an infinite loop if the CME is not limited
"""
start = Counter(start)
states = [start]
transitions = dict()
for state in states:
for destination, kinetic in zip(*self.escapes(state)):
if destination not in states:
states.append(destination)
transitions[tuple(state.items()), tuple(destination.items())] = kinetic
return transitions, states
def main():
"""
Run harmonic analysis on all songs in all databases. This will take a LONG time.
"""
parser = OptionParser()
parser.add_option("-d",
"--durk-step",
dest="durk_step",
default=4,
type="int")
parser.add_option("-t",
"--pool-size",
dest="pool_size",
default=8,
type="int")
parser.add_option("-u",
"--username",
dest="db_username",
default="postgres")
parser.add_option("-p",
"--password",
dest="db_password",
default="postgres")
(options, args) = parser.parse_args()
print "Creating", options.pool_size, "processes."
processes = []
# Initialize the counter to 0
counter = Counter(0)
# get all database engines
engines = get_engines(options.pool_size, options.db_username,
options.db_password)
# Construct a new HarmonicAnalyzer process for each database.
for i in xrange(options.pool_size):
p = HarmonicAnalyzer(options.durk_step, engines[i], counter)
processes.append(p)
# Start the processes
print "Starting", options.pool_size, "processes."
for p in processes:
p.start()
# And wait for them to finish
for p in processes:
p.join()
def calculate_gradient(self, label, feat_index, weights):
# feat_index does not hold any zero values, but instead it is used to index
# which features are applicable to a particular word. ie feat_vec == [4,5] means
# the 4th and 5th features are 1, and all others are 0
sig_val = self.sigmoid(feat_index, weights)
# Create a Counter object to store the gradients for this token
grad = Counter()
# The cost function being used is (sigma(wx) - y) where sigma is the logistic value, and y is the correct label
# This function keeps all values zero except those that have features show up
for index_val in feat_index:
grad.increment_count(index_val, (sig_val - label))
return grad
def number_folders(folders, pad): if len(folders) == 0: return counter = Counter(0, pad = pad) files = [] for n in folders: n.value = counter.i() + n.value sub_folders = [] sub_files = [] for child in n.children: if child.node_type == '<FOLDER>': sub_folders.append(child) elif child.node_type == '<FILE>': sub_files.append(child) number_folders(sub_folders, pad) number_files(sub_files, pad)
def gillespie(self, start, steps=10):
"""make n step of gillespie simulation given the starting state"""
start = Counter(start)
time = 0.0
while time<steps:
#for i in xrange(steps):
end_states, kinetics = self.escapes(start)
cumulative = np.cumsum(kinetics)
if not len(end_states) or not len(cumulative):
# ho raggiunto uno stato stazionario
yield start, np.inf
break
lambda_tot = cumulative[-1]
dt = rand_exp(1./lambda_tot)
selected = np.searchsorted(cumulative/lambda_tot, np.random.rand())
new_state = end_states[selected]
yield start, time, dt
time +=dt
start = new_state
def main():
# start = time.time()
config = load_config()
num_agents = config['num_agents']
state_dim = config['state_dim']
state_length = config['state_length']
action_dim = config['action_dim']
exploration_param = config['exploration_param']
lr = config['learning_rate']
betas = config['betas']
gamma = config['discount_factor']
K_epochs = config['ppo_epoch']
ppo_clip = config['ppo_clip']
torch.manual_seed(123)
traffic_light = TrafficLight()
counter = Counter()
shared_model = PPO(state_dim, state_length, action_dim, exploration_param,
lr, betas, gamma, K_epochs, ppo_clip)
shared_model.policy.share_memory()
batch_buffer = shared_batch_buffer()
# optimizer = optim.Adam(shared_model.policy.parameters(), lr=lr)
processes = []
p = mp.Process(target=chief,
args=(config, traffic_light, counter, shared_model,
batch_buffer))
p.start()
processes.append(p)
for rank in range(num_agents):
p = mp.Process(target=train,
args=(rank, config, traffic_light, counter,
shared_model, batch_buffer))
p.start()
processes.append(p)
for p in processes:
p.join()
def train(args):
base_dir = args.base_dir
dirs = init_dir(base_dir) #utils
init_log(dirs['log'])#utils
config_dir = args.config_dir
copy_file(config_dir, dirs['data'])
config = configparser.ConfigParser()
config.read(config_dir)
in_test, post_test = init_test_flag(args.test_mode)
# init env
env = init_env(config['ENV_CONFIG']) #seeonce
logging.info('Training: s dim: %d, a dim %d, s dim ls: %r, a dim ls: %r' %
(env.n_s, env.n_a, env.n_s_ls, env.n_a_ls)) #logging?
# init step counter
total_step = int(config.getfloat('TRAIN_CONFIG', 'total_step'))
test_step = int(config.getfloat('TRAIN_CONFIG', 'test_interval'))
log_step = int(config.getfloat('TRAIN_CONFIG', 'log_interval'))
global_counter = Counter(total_step, test_step, log_step)#what is this
# init centralized or multi agent
seed = config.getint('ENV_CONFIG', 'seed')
if env.agent == 'iddpg':
model = IDDPG(env.n_s_ls, env.n_a_ls, env.n_w_ls, total_step,
config['MODEL_CONFIG'], seed=seed)
elif env.agent == 'maddpg': #TODO: Add MADDPG
model = MADDPG(env.n_s_ls, env.n_a_ls, env.n_w_ls, env.n_f_ls, total_step,
config['MODEL_CONFIG'], seed=seed)
summary_writer = tf.summary.FileWriter(dirs['log'])#what is this
trainer = Trainer(env, model, global_counter, summary_writer, in_test, output_path=dirs['data'])#utils
trainer.run()
#if post_test: #how?
# tester = Tester(env, model, global_counter, summary_writer, dirs['data'])
# tester.run_offline(dirs['data'])#utils
# save model#what's this
final_step = global_counter.cur_step
logging.info('Training: save final model at step %d ...' % final_step)
model.save(dirs['model'], final_step)
def test_generation(test_file, lexicon_file):
lexicon = Lexicon(lexicon_file)
counter = Counter()
with open(test_file) as f:
for test in yaml.load(f):
lemma = test.pop("lemma")
location = test.pop("location", "")
for parse, form in test.items():
predicted = lexicon.generate(lemma, parse, context=location)
if predicted is None:
counter.fail("didn't know how to work out {} {} {}".format(lemma, parse, form))
elif strip_length(form) == strip_length(predicted):
counter.success()
continue
elif strip_length(form) not in [strip_length(p) for p in predicted.split("/")]:
counter.fail("{} {} got {} instead of {} in {}".format(lemma, parse, predicted, form, location))
else:
counter.skip("{} {} {} {} {}".format(lemma, parse, form, predicted, location))
counter.results()
def train(args):
base_dir = args.base_dir
dirs = init_dir(base_dir)
init_log(dirs['log'])
config_dir = args.config_dir
copy_file(config_dir, dirs['data'])
config = configparser.ConfigParser()
config.read(config_dir)
in_test, post_test = init_test_flag(args.test_mode)
# init env
env = init_env(config['ENV_CONFIG'])
logging.info('Training: s dim: %d, a dim %d, s dim ls: %r, a dim ls: %r' %
(env.n_s, env.n_a, env.n_s_ls, env.n_a_ls))
# init step counter
total_step = int(config.getfloat('TRAIN_CONFIG', 'total_step'))
test_step = int(config.getfloat('TRAIN_CONFIG', 'test_interval'))
log_step = int(config.getfloat('TRAIN_CONFIG', 'log_interval'))
global_counter = Counter(total_step, test_step, log_step)
# init centralized or multi agent
seed = config.getint('ENV_CONFIG', 'seed')
# coord = tf.train.Coordinator()
# if env.agent == 'a2c':
# model = A2C(env.n_s, env.n_a, total_step,
# config['MODEL_CONFIG'], seed=seed)
if env.agent == 'ia2c':
model = IA2C(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
total_step,
config['MODEL_CONFIG'],
seed=seed)
elif env.agent == 'ma2c':
model = MA2C(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
env.n_f_ls,
total_step,
config['MODEL_CONFIG'],
seed=seed)
elif env.agent == 'iqld':
model = IQL(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
total_step,
config['MODEL_CONFIG'],
seed=0,
model_type='dqn')
else:
model = IQL(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
total_step,
config['MODEL_CONFIG'],
seed=0,
model_type='lr')
# disable multi-threading for safe SUMO implementation
# threads = []
summary_writer = tf.summary.FileWriter(dirs['log'])
trainer = Trainer(env,
model,
global_counter,
summary_writer,
in_test,
output_path=dirs['data'])
trainer.run()
# if in_test or post_test:
# # assign a different port for test env
# test_env = init_env(config['ENV_CONFIG'], port=1)
# tester = Tester(test_env, model, global_counter, summary_writer, dirs['data'])
# def train_fn():
# trainer.run(coord)
# thread = threading.Thread(target=train_fn)
# thread.start()
# threads.append(thread)
# if in_test:
# def test_fn():
# tester.run_online(coord)
# thread = threading.Thread(target=test_fn)
# thread.start()
# threads.append(thread)
# coord.join(threads)
# post-training test
if post_test:
tester = Tester(env, model, global_counter, summary_writer,
dirs['data'])
tester.run_offline(dirs['data'])
# save model
final_step = global_counter.cur_step
logging.info('Training: save final model at step %d ...' % final_step)
model.save(dirs['model'], final_step)
def train(args):
base_dir = args.base_dir
dirs = init_dir(base_dir)
init_log(dirs['log'])
config_dir = args.config_dir
copy_file(config_dir, dirs['data'])
config = configparser.ConfigParser()
config.read(config_dir)
in_test, post_test = init_test_flag(args.test_mode)
# init env
env = init_env(config['ENV_CONFIG'])
logging.info('Training: s dim: %d, a dim %d, s dim ls: %r, a dim ls: %r' %
(env.n_s, env.n_a, env.n_s_ls, env.n_a_ls))
# init step counter
total_step = int(config.getfloat('TRAIN_CONFIG', 'total_step')) #1e6
test_step = int(config.getfloat('TRAIN_CONFIG', 'test_interval')) #2e4
log_step = int(config.getfloat('TRAIN_CONFIG', 'log_interval')) #1e4
global_counter = Counter(total_step, test_step, log_step)
# init centralized or multi agent
seed = config.getint('ENV_CONFIG', 'seed') #12
# coord = tf.train.Coordinator()
if env.agent == 'ia2c':
model = IA2C(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
total_step,
config['MODEL_CONFIG'],
seed=seed)
elif env.agent == 'ma2c':
model = MA2C(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
env.n_f_ls,
total_step,
config['MODEL_CONFIG'],
seed=seed)
elif env.agent == 'codql':
print('This is codql')
num_agents = len(env.n_s_ls)
print('num_agents:', num_agents)
a_dim = env.n_a_ls[0] # ?????????????????? dim ??or num??
print('a_dim:', a_dim)
s_dim = env.n_s_ls[0]
print('env.n_s_ls=', s_dim)
s_dim_wait = env.n_w_ls[0]
print('s_dim_wait:', s_dim_wait)
#obs_space = s_dim # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXxx state dim Error
model = MFQ(nb_agent=num_agents,
a_dim=a_dim,
s_dim=s_dim,
s_dim_wave=s_dim - s_dim_wait,
s_dim_wait=s_dim_wait,
config=config['MODEL_CONFIG'])
elif env.agent == 'dqn':
model = DQN(nb_agent=len(env.n_s_ls),
a_dim=env.n_a_ls[0],
s_dim=env.n_s_ls[0],
s_dim_wave=env.n_s_ls[0] - env.n_w_ls[0],
s_dim_wait=env.n_w_ls[0],
config=config['MODEL_CONFIG'],
doubleQ=False) #doubleQ=False denotes dqn else ddqn
elif env.agent == 'ddpg':
model = DDPGEN(nb_agent=len(env.n_s_ls),
share_params=True,
a_dim=env.n_a_ls[0],
s_dim=env.n_s_ls[0],
s_dim_wave=env.n_s_ls[0] - env.n_w_ls[0],
s_dim_wait=env.n_w_ls[0])
elif env.agent == 'iqld':
model = IQL(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
total_step,
config['MODEL_CONFIG'],
seed=0,
model_type='dqn')
else:
model = IQL(env.n_s_ls,
env.n_a_ls,
env.n_w_ls,
total_step,
config['MODEL_CONFIG'],
seed=0,
model_type='lr')
summary_writer = tf.summary.FileWriter(dirs['log'])
trainer = Trainer(env,
model,
global_counter,
summary_writer,
in_test,
output_path=dirs['data'])
trainer.run()
# save model
final_step = global_counter.cur_step
logging.info('Training: save final model at step %d ...' % final_step)
model.save(dirs['model'], final_step)
def messageObjectToKind(view, messageObject, messageText=None):
"""
This method converts a email message string to
a Chandler C{MailMessage} object
@param messageObject: A C{email.Message} object representation of a mail message
@type messageObject: C{email.Message}
@return: C{MailMessage}
"""
assert isinstance(messageObject, Message.Message), \
"messageObject must be a Python email.Message.Message instance"
assert len(messageObject.keys()) > 0, \
"messageObject data is not a valid RFC2822 message"
assert messageText is None or isinstance(messageText, str), \
"messageText can either be a string or None"
mailStamp = None
icsSummary = None
icsDesc = None
chandlerAttachments = getChandlerAttachments(messageObject)
if chandlerAttachments["eimml"]:
eimml = chandlerAttachments["eimml"][0]
peer = getPeer(view, messageObject)
if peer is None:
# A peer address is required for eimml
# deserialization. If there is no peer
# then ignore the eimml data and return
# an error flag.
return (-1, None)
matchingAddresses = []
for address in addressMatchGenerator(peer):
matchingAddresses.append(address)
# the matchingAddresses list will at least contain the
# peer address since it is an EmailAddress Item and
# there for will be in the EmailAddressCollection index.
statusCode, mailStamp = parseEIMML(view, peer, matchingAddresses,
eimml)
if statusCode != 1:
# There was either an error during
# processing of the eimml or the
# eimml was older than the current
# Item's state so it was ignored.
return (statusCode, None)
elif chandlerAttachments["ics"]:
ics = chandlerAttachments["ics"][0]
result = parseICS(view, ics, messageObject)
if result is not None:
# If the result is None then there
# was an error that prevented converting
# the ics text to a Chandler Item
# in which case the ics is ignored and
# the rest of the message parsed.
mailStamp, icsDesc, icsSummary = result
if not mailStamp:
mailStamp = MailMessage(itsView=view)
mailStamp.fromEIMML = False
if not IGNORE_ATTACHMENTS:
# Save the original message text in a text blob
if messageText is None:
messageText = messageObject.as_string()
mailStamp.rfc2822Message = dataToBinary(mailStamp, "rfc2822Message",
messageText, 'message/rfc822',
'bz2', False)
if getattr(mailStamp, "messageId", None):
# The presence a messageId indicated that
# this message has already been sent or
# received and thus has been updated.
mailStamp.isUpdated = True
#if verbose():
# if messageObject.has_key("Message-ID"):
# messageId = messageObject["Message-ID"]
# else:
# messageId = "<Unknown Message>"
#
# buf = ["Message: %s\n-------------------------------" % messageId]
if not mailStamp.fromEIMML:
# Do not parse the message to build the
# item.body since that data is in the eimml.
if IGNORE_ATTACHMENTS:
counter = None
else:
counter = Counter()
bodyBuffer = {'plain': [], 'html': []}
buf = None
# The body of the message will be contained in the eimml so
# do not try and parse the mail message body.
__parsePart(view, messageObject, mailStamp, bodyBuffer, counter, buf)
mailStamp.body = buildBody(bodyBuffer)
__parseHeaders(view, messageObject, mailStamp, True, True)
if icsSummary or icsDesc:
# If ics summary or ics description exist then
# add them to the message body
mailStamp.body += buildICSInfo(mailStamp, icsSummary, icsDesc)
#if verbose():
# trace("\n\n%s\n\n" % '\n'.join(buf))
return (1, mailStamp)
def setUp(self):
self.globalCounter = Counter()
self.functionCounter = Counter()
self.classCounter = Counter()
self.traitCounter = Counter()
self.typeParameterCounter = Counter()
parser.add_argument('--feature', type=int, default=153, help='features num')
parser.add_argument('--force',
action='store_true',
help='force two leg together')
parser.add_argument('--start-epoch', type=int, default=0, help='start-epoch')
if __name__ == '__main__':
args = parser.parse_args()
os.environ['OMP_NUM_THREADS'] = '1'
torch.manual_seed(args.seed)
num_inputs = args.feature
num_actions = 18
traffic_light = TrafficLight()
counter = Counter()
ac_net = ActorCritic(num_inputs, num_actions)
opt_ac = optim.Adam(ac_net.parameters(), lr=args.lr)
shared_grad_buffers = Shared_grad_buffers(ac_net)
shared_obs_stats = Shared_obs_stats(num_inputs)
if args.resume:
print("=> loading checkpoint ")
checkpoint = torch.load('../../7.87.t7')
#checkpoint = torch.load('../../best.t7')
args.start_epoch = checkpoint['epoch']
#best_prec1 = checkpoint['best_prec1']
ac_net.load_state_dict(checkpoint['state_dict'])
opt_ac.load_state_dict(checkpoint['optimizer'])