def __init__(self,
num_inputs,
recurrent=False,
hidden_size=512,
map_width=20):
super(MicropolisBase_fixedmap, self).__init__(recurrent, hidden_size,
hidden_size)
self.map_width = map_width
self.num_maps = int(math.log(self.map_width, 2))
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0.1), nn.init.calculate_gain('relu'))
self.skip_compress = init_(nn.Conv2d(num_inputs, 15, 1, stride=1))
self.conv_0 = nn.Conv2d(num_inputs, 64, 1, 1, 0)
init_(self.conv_0)
self.conv_1 = nn.Conv2d(64, 64, 5, 1, 2)
init_(self.conv_1)
self.conv_2 = nn.Conv2d(64, 64, 3, 1, 1)
init_(self.conv_2)
self.critic_compress = init_(nn.Conv2d(79, 64, 3, 1, 1))
self.critic_downsize = init_(nn.Conv2d(64, 64, 3, 2, 1))
self.critic_conv = init_(nn.Conv2d(64, 64, 3, 2, 1))
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0))
self.actor_compress = init_(nn.Conv2d(79, 19, 3, 1, 1))
self.critic_conv_1 = init_(nn.Conv2d(64, 1, 1, 1, 0))
# self.critic_conv_2 = init_(nn.Conv2d(1, 1, 2, 1, 0)) # for 40x40 map
self.train()
def __init__(self,
num_inputs,
recurrent=False,
hidden_size=256,
map_width=20,
num_actions=18):
super(MicropolisBase_FullyConv, self).__init__(recurrent, hidden_size,
hidden_size)
num_actions = num_actions
self.map_width = map_width
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0.1), nn.init.calculate_gain('relu'))
self.embed = init_(nn.Conv2d(num_inputs, 32, 1, 1, 0))
self.k5 = init_(nn.Conv2d(32, 16, 5, 1, 2))
self.k3 = init_(nn.Conv2d(16, 32, 3, 1, 1))
state_size = map_width * map_width * 32
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.dense = init_(nn.Linear(state_size, 256))
self.val = init_(nn.Linear(256, 1))
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0))
self.act = init_(nn.Conv2d(32, num_actions, 1, 1, 0))
def __init__(self,
num_inputs,
activation,
recurrent=False,
hidden_size=512):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
self.activation = activation
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
self.conv1 = init_(nn.Conv2d(num_inputs, 32, 8, stride=4))
self.conv2 = init_(nn.Conv2d(32, 64, 4, stride=2))
self.conv3 = init_(nn.Conv2d(64, 32, 3, stride=1))
if self.activation == 0:
self.f1 = init_(nn.Linear(11264, hidden_size))
print("Use relu activation for f1 layer")
elif self.activation == 1:
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0),
nn.init.calculate_gain('tanh'))
self.f1 = init_(nn.Linear(11264, hidden_size))
print("Use tanh activation for f1 layer")
else:
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0),
nn.init.calculate_gain('sigmoid'))
self.f1 = init_(nn.Linear(11264, hidden_size))
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def __init__(self, chan, outputs, atoms):
super(CNNBase, self).__init__() #recurrent, hidden_size, hidden_size)
self.actions = outputs
self.chan = chan
self.atoms = atoms
self.new_size = 1
self.dist = Cat(self.atoms, self.actions)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
# For 80x60 input
self.main = nn.Sequential(
init_(nn.Conv2d(chan, 32, kernel_size=5, stride=2)),
nn.BatchNorm2d(32),
nn.ReLU(),
#Print(),
init_(nn.Conv2d(32, 32, kernel_size=5, stride=2)),
nn.BatchNorm2d(32),
nn.ReLU(),
init_(nn.Conv2d(32, 32, kernel_size=4, stride=2)),
nn.BatchNorm2d(32),
nn.ReLU(),
#Print(),
Flatten(),
init_(nn.Linear(1568, self.atoms)),
#Print(),
nn.ReLU())
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.critic_linear = init_(nn.Linear(self.atoms, 1))
self.train()
def __init__(self,
obs_shape,
num_actions,
base_kwargs=None,
extra_kwargs=None):
super(Policy, self).__init__()
self.use_backpack = extra_kwargs['use_backpack']
self.recurrent_hidden_state_size = 1
num_outputs = num_actions
hidden_size = 512
conv_init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0),
nn.init.calculate_gain('relu'))
lin_init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.model = nn.Sequential(
conv_init_(nn.Conv2d(obs_shape[0], 32, 8, stride=4)), nn.ReLU(),
conv_init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(),
conv_init_(nn.Conv2d(64, 32, 3, stride=1)), nn.ReLU(), Flatten(),
conv_init_(nn.Linear(32 * 7 * 7, hidden_size)), nn.ReLU(),
lin_init_(nn.Linear(hidden_size, num_outputs)))
if self.use_backpack:
extend(self.model)
self.model.train()
def __init__(self, num_inputs, recurrent=False, hidden_size=128):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
# For 80x60 input
self.main = nn.Sequential(
init_(nn.Conv2d(num_inputs, 32, kernel_size=5, stride=2)),
nn.BatchNorm2d(32),
nn.ReLU(),
init_(nn.Conv2d(32, 32, kernel_size=5, stride=2)),
nn.BatchNorm2d(32),
nn.ReLU(),
init_(nn.Conv2d(32, 32, kernel_size=4, stride=2)),
nn.BatchNorm2d(32),
nn.ReLU(),
#Print(),
Flatten(),
#nn.Dropout(0.2),
init_(nn.Linear(32 * 7 * 5, hidden_size)),
nn.ReLU())
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def make_corpus():
utils.init()
interests = list(utils.get_all_interests())
corpus = MyCorpus(interests)
corpus.build_interests_to_articles()
corpus.build_dict()
corpus.write_corpus()
def __init__(self):
super(Decoder, self).__init__()
self.emb_dim = config.emb_dim
self.hidden_dim = config.hidden_dim
self.attn_word = WordAttention()
self.attn_sec = SectionAttention()
self.combine_context = nn.Linear(self.hidden_dim * 2 + self.emb_dim,
self.emb_dim)
self.softmax = nn.Softmax(dim=1)
self.rnn = nn.LSTM(self.emb_dim,
self.hidden_dim,
num_layers=1,
batch_first=True,
bidirectional=False)
utils.init(self.rnn)
if config.pointer:
self.sigmoid = nn.Sigmoid()
self.linear_pointer = nn.Linear(self.emb_dim + self.hidden_dim * 4,
1)
self.feat = nn.Linear(self.hidden_dim * 2,
self.hidden_dim * 2,
bias=False)
self.linear = nn.Linear(self.hidden_dim * 3, self.hidden_dim)
self.linear.weight.data.normal_(std=1e-4)
self.linear.bias.data.normal_(std=1e-4)
self.vocab = nn.Linear(self.hidden_dim, config.vocab_size)
self.vocab.weight.data.normal_(std=1e-4)
self.vocab.bias.data.normal_(std=1e-4)
def __init__(self, num_inputs, recurrent=False, hidden_size=512):
super(MicropolisBase, self).__init__(recurrent, hidden_size,
hidden_size)
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0), nn.init.calculate_gain('relu'))
import sys
self.skip_compress = init_(nn.Conv2d(num_inputs, 15, 1, stride=1))
self.conv_0 = nn.Conv2d(num_inputs, 64, 1, 1, 0)
init_(self.conv_0)
self.conv_1 = nn.Conv2d(64, 64, 5, 1, 2)
init_(self.conv_1)
self.conv_2 = nn.Conv2d(1, 1, 3, 1, 0)
init_(self.conv_2)
self.conv_2_chan = nn.ConvTranspose2d(1, 1, (1, 3), 1, 0)
init_(self.conv_2_chan)
self.conv_3 = nn.ConvTranspose2d(1, 1, 3, 1, 0)
init_(self.conv_3)
self.conv_3_chan = nn.Conv2d(1, 1, (1, 3), 1, 0)
init_(self.conv_3_chan)
self.actor_compress = init_(nn.Conv2d(79, 20, 3, 1, 1))
self.critic_compress = init_(nn.Conv2d(79, 8, 1, 1, 1))
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0))
self.critic_conv_1 = init_(nn.Conv2d(8, 1, 20, 20, 0))
self.train()
def generate(self, in_base_path, out_base_path):
self.in_base_path = in_base_path;
self.out_base_path = out_base_path;
utils.makedirs(out_base_path);
imgutils.init(in_base_path);
utils.init(in_base_path);
self.blog = Struct(json.load(utils.open_file(self.in_base_path + "/blog.json")));
# copy static content
cmd = "cp -rf " + in_base_path + "/static/* " + out_base_path;
print("copy static content: " + cmd)
proc = utils.execute_shell(cmd);
# 'dynamic' content
for c in ["sticky", "posts"]:
setattr(self, c, []);
self.generate_content(c);
# home page
self.generate_home();
# feed
self.generate_feed();
def __init__(self, num_inputs, recurrent=False, hidden_size=512):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
self.emb = nn.Embedding(10, 8)
self.main = nn.Sequential(
init_(nn.Conv2d(num_inputs * 8, 64, 3, stride=2, padding=1)),
nn.ReLU(), init_(nn.Conv2d(64, 128, 3, stride=2, padding=1)),
nn.ReLU(), init_(nn.Conv2d(128, 256, 3, stride=2, padding=1)),
nn.ReLU(), Flatten(), init_(nn.Linear(256 * 1 * 1, hidden_size)),
nn.ReLU())
"""
self.main = nn.Sequential(
Flatten(),
init_(nn.Linear(3 * 8 * 8, 512)),
nn.ReLU(),
init_(nn.Linear(512, 512)),
nn.ReLU(),
init_(nn.Linear(512, hidden_size)),
nn.ReLU()
)
"""
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def __init__(self, num_inputs, activation=1, modulation=False, recurrent=False, hidden_size=512):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
print("model modulation:", modulation)
self.activation = activation
self.modulation = modulation
init_ = lambda m: init(m,
nn.init.orthogonal_,
lambda x: nn.init.constant_(x, 0),
nn.init.calculate_gain('relu'))
self.conv1 = init_(nn.Conv2d(num_inputs, 32, 8, stride=4))
self.conv2 = init_(nn.Conv2d(32, 64, 4, stride=2))
self.conv3 = init_(nn.Conv2d(64, 32, 3, stride=1))
if self.activation == 1:
init_ = lambda m: init(m,
nn.init.orthogonal_,
lambda x: nn.init.constant_(x, 0),
nn.init.calculate_gain('tanh'))
self.f1 = init_(nn.Linear(32 * 7 * 7, hidden_size))
init_ = lambda m: init(m,
nn.init.orthogonal_,
lambda x: nn.init.constant_(x, 0))
if self.modulation:
self.critic_linear = init_(nn.Linear(hidden_size+1, 1))
else:
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def __init__(self,
num_inputs,
recurrent=False,
hidden_size=512,
obs_mean=0.0,
obs_std=255.0):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
self.obs_mean = obs_mean
self.obs_std = obs_std
self.main = nn.Sequential(
init_(nn.Conv2d(num_inputs, 32, 8, stride=4)),
nn.LeakyReLU(0.2, inplace=True), nn.BatchNorm2d(32),
init_(nn.Conv2d(32, 64, 4, stride=2)),
nn.LeakyReLU(0.2, inplace=True), nn.BatchNorm2d(64),
init_(nn.Conv2d(64, 64, 3, stride=1)),
nn.LeakyReLU(0.2, inplace=True), nn.BatchNorm2d(64), Flatten(),
init_(nn.Linear(64 * 7 * 7, hidden_size)),
nn.BatchNorm1d(hidden_size))
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def __init__(
self, obs_shape, action_space, use_cuda
): #use_cuda is not used and for compatibility reasons (I2A needs the use_cuda parameter)
super(AtariModel, self).__init__()
from i2a.utils import get_linear_dims_after_conv
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
input_channels = obs_shape[0]
input_dims = obs_shape[1:]
self.conv1 = init_(
nn.Conv2d(input_channels, 16, kernel_size=3, stride=1, padding=0))
self.conv2 = init_(
nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=0))
self.conv3 = init_(
nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=0))
self.conv4 = init_(
nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=0))
self.linear_input_size = get_linear_dims_after_conv(
[self.conv1, self.conv2, self.conv3, self.conv4], input_dims)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.linear1 = init_(nn.Linear(self.linear_input_size, 256))
self.critic_linear = init_(nn.Linear(256, 1))
self.actor_linear = init_(nn.Linear(256, action_space))
self.train()
def __init__(self):
super(Encoder, self).__init__()
self.emb_dim = config.emb_dim
self.hidden_dim = config.hidden_dim
self.dropout = nn.Dropout(config.drop_out)
self.rnn_word = nn.LSTM(self.emb_dim,
self.hidden_dim,
num_layers=config.enc_layers,
bidirectional=config.enc_bidi,
batch_first=True)
self.rnn_sec = nn.LSTM(self.hidden_dim,
self.hidden_dim,
num_layers=config.enc_layers,
bidirectional=config.enc_bidi,
batch_first=True)
utils.init(self.rnn_word)
utils.init(self.rnn_sec)
self.sec = nn.Linear(self.hidden_dim * 2, self.hidden_dim)
self.linear_hidden = nn.Linear(self.hidden_dim * 2, self.hidden_dim)
self.linear_hidden.weight.data.normal_(std=1e-4)
self.linear_hidden.bias.data.normal_(std=1e-4)
self.linear_cell = nn.Linear(self.hidden_dim * 2, self.hidden_dim)
self.linear_cell.weight.data.normal_(std=1e-4)
self.linear_cell.bias.data.normal_(std=1e-4)
def __init__(self, num_inputs, use_gru):
super(CNNBase, self).__init__()
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
self.main = nn.Sequential(
init_(nn.Conv2d(num_inputs, 32, 8, stride=4)), nn.ReLU(),
init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(),
init_(nn.Conv2d(64, 32, 3, stride=1)), nn.ReLU(), Flatten(),
init_(nn.Linear(32 * 7 * 7, 512)), nn.ReLU())
if use_gru:
self.gru = nn.GRUCell(512, 512)
nn.init.orthogonal_(self.gru.weight_ih.data)
nn.init.orthogonal_(self.gru.weight_hh.data)
self.gru.bias_ih.data.fill_(0)
self.gru.bias_hh.data.fill_(0)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.critic_linear = init_(nn.Linear(512, 1))
self.train()
def main():
utils.init()
#interests = set(list(utils.get_all_interests())[:50])
interests = utils.get_all_interests()
matrix = build_article_adjacencies(interests)
write_matrix(matrix)
write_ids_to_indexes()
def __init__(self,
num_inputs,
recurrent=False,
hidden_size=512,
map_width=20,
num_actions=18):
super(MicropolisBase_fixed, self).__init__(recurrent, hidden_size,
hidden_size)
self.num_recursions = map_width
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0.1), nn.init.calculate_gain('relu'))
self.skip_compress = init_(nn.Conv2d(num_inputs, 15, 1, stride=1))
self.conv_0 = init_(nn.Conv2d(num_inputs, 64, 1, 1, 0))
self.conv_1 = init_(nn.Conv2d(64, 64, 5, 1, 2))
for i in range(1):
setattr(self, 'conv_2_{}'.format(i),
init_(nn.Conv2d(64, 64, 3, 1, 1)))
self.critic_compress = init_(nn.Conv2d(79, 64, 3, 1, 1))
for i in range(1):
setattr(self, 'critic_downsize_{}'.format(i),
init_(nn.Conv2d(64, 64, 2, 2, 0)))
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0))
self.actor_compress = init_(nn.Conv2d(79, 19, 3, 1, 1))
self.critic_conv = init_(nn.Conv2d(64, 1, 1, 1, 0))
self.train()
def __init__(self, num_inputs, recurrent=False, hidden_size=512):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
init_ = lambda m: init(m,
nn.init.orthogonal_,
lambda x: nn.init.constant_(x, 0),
nn.init.calculate_gain('relu'))
self.main = nn.Sequential(
init_(nn.Conv2d(num_inputs, 32, 8, stride=4)),
nn.ReLU(),
init_(nn.Conv2d(32, 64, 4, stride=2)),
nn.ReLU(),
init_(nn.Conv2d(64, 32, 3, stride=1)),
nn.ReLU(),
Flatten(),
init_(nn.Linear(32 * 7 * 7, hidden_size)),
nn.ReLU()
)
init_ = lambda m: init(m,
nn.init.orthogonal_,
lambda x: nn.init.constant_(x, 0))
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def main():
utils.init()
# interests = set(list(utils.get_all_interests())[:50])
interests = utils.get_all_interests()
matrix = build_article_adjacencies(interests)
write_matrix(matrix)
write_ids_to_indexes()
def __init__(self, num_inputs, use_gru, num_actions):
super(CNNBaseUnshare, self).__init__()
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
init2_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.actor = nn.Sequential(
init_(nn.Conv2d(num_inputs, 32, 8, stride=4)), nn.ReLU(),
init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(),
init_(nn.Conv2d(64, 32, 3, stride=1)), nn.ReLU(), Flatten(),
init_(nn.Linear(32 * 7 * 7, 512)), nn.ReLU(),
init2_(nn.Linear(512, num_actions)))
self.critic = nn.Sequential(
init_(nn.Conv2d(num_inputs, 32, 8, stride=4)), nn.ReLU(),
init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(),
init_(nn.Conv2d(64, 32, 3, stride=1)), nn.ReLU(), Flatten(),
init_(nn.Linear(32 * 7 * 7, 512)), nn.ReLU(),
init2_(nn.Linear(512, 1)))
if use_gru:
raise NotImplementedError
self.train()
def __init__(self,
img_num_features,
v_num_features,
recurrent=False,
hidden_size=512):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
self.cnn_backbone = nn.Sequential(
init_(nn.Conv2d(img_num_features, 32, 8, stride=4)), nn.ReLU(),
init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(),
init_(nn.Conv2d(64, 32, 3, stride=1)), nn.ReLU(), Flatten(),
init_(nn.Linear(32 * 7 * 7, hidden_size)), nn.ReLU())
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.fc_backbone = nn.Sequential(
init_(nn.Linear(v_num_features, hidden_size // 4)), nn.ReLU(),
init_(nn.Linear(hidden_size // 4, hidden_size // 2)), nn.ReLU(),
init_(nn.Linear(hidden_size // 2, hidden_size)), nn.ReLU())
self.fc_joint = nn.Sequential(
init_(nn.Linear(hidden_size * 2, hidden_size * 2)), nn.ReLU(),
init_(nn.Linear(hidden_size * 2, hidden_size)), nn.ReLU(),
init_(nn.Linear(hidden_size, hidden_size)), nn.ReLU())
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def __init__(self,
num_inputs,
recurrent=False,
hidden_size=512,
map_width=20):
super(MicropolisBase_squeeze, self).__init__(recurrent, hidden_size,
hidden_size)
self.chunk_size = 2
self.map_width = map_width
#self.num_maps = 4
self.num_maps = int(math.log(
self.map_width, self.chunk_size)) # how many different sizes
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, -10), nn.init.calculate_gain('relu'))
linit_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.cmp_in = init_(nn.Conv2d(num_inputs, 64, 1, stride=1, padding=0))
for i in range(self.num_maps):
setattr(self, 'prj_life_obs_{}'.format(i),
init_(nn.Conv2d(64, 64, 3, stride=1, padding=1)))
setattr(self, 'cmp_life_obs_{}'.format(i),
init_(nn.Conv2d(128, 64, 3, stride=1, padding=1)))
#self.shrink_life = init_(nn.Conv2d(64, 64, 3, 3, 0))
#self.conv_1 = init_(nn.Conv2d(64, 64, 3, 1, 1))
#self.lin_0 = linit_(nn.Linear(1024, 1024))
for i in range(self.num_maps):
if i == 0:
setattr(self, 'dwn_{}'.format(i),
init_(nn.Conv2d(64, 64, 2, stride=2, padding=0)))
setattr(
self, 'expand_life_{}'.format(i),
init_(nn.ConvTranspose2d(64 + 64, 64, 2, stride=2, padding=0)))
setattr(self, 'prj_life_act_{}'.format(i),
init_(nn.Conv2d(64, 64, 3, stride=1, padding=1)))
setattr(self, 'cmp_life_act_{}'.format(i),
init_(nn.Conv2d(128, 64, 3, stride=1, padding=1)))
setattr(self, 'cmp_life_val_in_{}'.format(i),
init_(nn.Conv2d(128, 64, 3, stride=1, padding=1)))
setattr(self, 'dwn_val_{}'.format(i),
init_(nn.Conv2d(64, 64, 2, stride=2, padding=0)))
if i == self.num_maps - 1:
setattr(self, 'prj_life_val_{}'.format(i),
init_(nn.Conv2d(64, 64, 3, stride=1, padding=1)))
else:
setattr(self, 'prj_life_val_{}'.format(i),
init_(nn.Conv2d(64, 64, 3, stride=1, padding=1)))
self.cmp_act = init_(nn.Conv2d(128, 64, 3, stride=1, padding=1))
init_ = lambda m: init(m, nn.init.dirac_, lambda x: nn.init.constant_(
x, 0.1))
self.act_tomap = init_(nn.Conv2d(64, 19, 5, stride=1, padding=2))
self.cmp_val_out = init_(nn.Conv2d(64, 1, 1, stride=1, padding=0))
self.train()
def main():
import utils
from call_graph_analysis import process_jni_dir
utils.init()
init_arg_parser()
logging.info(config.DEFAULT_AOSP_PATH)
logging.info(config.framework_core_jni_path())
process_jni_dir(config.framework_core_jni_path())
def main():
utils.init()
last_update_id = None
features = Features()
while True:
updates = get_updates(last_update_id)
if len(updates["result"]) > 0:
last_update_id = get_last_update_id(updates) + 1
features.music(updates)
controlButtons(updates["result"])
time.sleep(0.5)
def __init__(self, num_inputs, hidden_size=512, num_actions=4,
use_duel=False, use_noisy_net=False):
super(IQN_C51, self).__init__()
self.num_actions = num_actions
self.use_duel = use_duel
self.use_noisy_net = use_noisy_net
self.quantile_embedding_dim = 64
self.pi = np.pi
init_ = lambda m: init(m,
nn.init.kaiming_uniform_,
lambda x: nn.init.constant_(x, 0),
gain=nn.init.calculate_gain('relu'),
mode='fan_in')
init2_ = lambda m: init(m,
nn.init.kaiming_uniform_,
lambda x: nn.init.constant_(x, 0),
gain=nn.init.calculate_gain('relu'),
mode='fan_in')
self.conv1 = init_(nn.Conv2d(num_inputs, 32, 8, stride=4))
self.conv2 = init_(nn.Conv2d(32, 64, 4, stride=2))
self.conv3 = init_(nn.Conv2d(64, 32, 3, stride=1))
if use_noisy_net:
Linear = NoisyLinear
else:
Linear = nn.Linear
# ----------------------------------------------------------------------------
# self.fc1 = Linear(32*7*7, hidden_size)
self.fc2 = Linear(hidden_size, num_actions*1)
# ----------------------------------------------------------------------------
Atari_Input = torch.FloatTensor(1, num_inputs, 84, 84)
temp_fea = self.conv3(self.conv2(self.conv1(Atari_Input)))
temp_fea = temp_fea.view(temp_fea.size(0), -1)
state_net_size = temp_fea.size(1)
del Atari_Input
del temp_fea
self.quantile_fc0 = nn.Linear(self.quantile_embedding_dim, state_net_size)
self.quantile_fc1 = nn.Linear(state_net_size, hidden_size)
# ----------------------------------------------------------------------------
if self.use_duel:
self.quantile_fc_value = Linear(hidden_size, 1)
# Param init
if not use_noisy_net:
self.quantile_fc0 = init2_(self.quantile_fc0)
self.quantile_fc1 = init2_(self.quantile_fc1)
self.fc2 = init2_(self.fc2)
if self.use_duel:
self.quantile_fc_value = init2_(self.quantile_fc_value)
def __init__(self, *args, **kwargs):
# Inherit from basic framework
MobotFramework.__init__(self)
rpyc.Service.__init__(self, *args, **kwargs)
init("mobot service instance created")
# Status
self._connected = False
# Remote video streaming therad
self.videostop = threading.Event()
self.videothd = None
def __init__(self, num_inputs, recurrent=False, hidden_size=512):
super(CNNBase, self).__init__(recurrent, hidden_size, hidden_size)
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0), nn.init.calculate_gain('relu'))
num_inputs = 6
# hidden_size = 100
# self.main = nn.Sequential(
# init_(nn.Conv2d(num_inputs, 32, 8, stride=4)),
# nn.ReLU(),
# init_(nn.Conv2d(32, 64, 4, stride=2)),
# nn.ReLU(),
# init_(nn.Conv2d(64, 32, 3, stride=1)),
# nn.ReLU(),
# Flatten(),
# init_(nn.Linear(32 * 7 * 7, hidden_size)),
# nn.ReLU()
# )
# self.main = nn.Sequential(
# init_(nn.Conv2d(num_inputs, 16, 3,padding=1, stride=1)),
# nn.ReLU(),
# nn.MaxPool2d(kernel_size = 2),
# init_(nn.Conv2d(16, 32, 3,padding=1, stride=1)),
# nn.ReLU(),
# nn.MaxPool2d(kernel_size = 2),
# init_(nn.Conv2d(32, 32, 3,padding=1, stride=1)),
# nn.ReLU(),
# nn.MaxPool2d(kernel_size = 2),
# init_(nn.Conv2d(32, 16, 3,padding=1, stride=1)),
# nn.ReLU(),
# # nn.MaxPool2d(kernel_size = 2),
# Flatten(),
# init_(nn.Linear(16 * 11 * 11, hidden_size)),
# nn.ReLU()
# )
self.main = nn.Sequential(
init_(nn.Conv2d(num_inputs, 16, 3, padding=1, stride=1)),
nn.ReLU(), init_(nn.Conv2d(16, 32, 3, padding=1, stride=1)),
nn.ReLU(), init_(nn.Conv2d(32, 32, 3, padding=1, stride=1)),
nn.ReLU(), init_(nn.Conv2d(32, 16, 3, padding=1, stride=1)),
nn.ReLU(), Flatten(), init_(nn.Linear(16 * 11 * 11, hidden_size)),
nn.ReLU())
init_ = lambda m: init(m, nn.init.orthogonal_, lambda x: nn.init.
constant_(x, 0))
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def black_box_eval(files, dataset, test_loader, epsilon, alpha):
'''
list of models to use for black-box attacks
:param duos:
:return:
'''
res = []
model_s, optimizer_s, use_cuda_s = init(dataset, 0.001)
model_t, optimizer_t, use_cuda_t = init(dataset, 0.001)
for i, target in enumerate(files):
sres = [target, [], [], []]
for j, source in enumerate(files):
if j == i:
continue
print(f"attacking {target} from {source}")
model_s, optimizer_s, _ = load_check_point(source, model_s,
optimizer_s)
model_t, optimizer_t, _ = load_check_point(target, model_t,
optimizer_t)
accs = [target]
try:
print("running fgsm")
accs.append(
fgsm_attack(test_loader,
model_s,
True,
F.cross_entropy,
test_batch,
init_ep=epsilon,
max_range=1,
target_model=model_t))
for it in [20, 100]:
accs.append(
invoke_pgd_attack(test_loader,
model_s,
True,
epsilon,
alpha,
F.cross_entropy,
test_batch,
iters=it,
target_model=model_t))
res.append(accs)
except Exception as e:
print(f"Exception model: {e}")
res.append(sres)
continue
print(f"res:\n {res}")
with open(f"blackboxdataset{dataset}", "wb") as f:
pickle.dump(res, f)
def main():
utils.init()
for line in sys.stdin:
tokens = line.split('\t')
page_id_str = tokens[0]
if hash(page_id_str) % int(1 / FRACTION_PAGES_TO_SUMMARIZE) != 0:
continue
results_str = tokens[-1]
if len(page_id_str) < 2:
print 'invalid page key: %s' % ` page_id_str `
else:
page_id = int(page_id_str[1:-1]) # drop open / close quotes
features = tokens[1] if len(tokens) == 3 else ''
summarize(page_id, results_str.strip(), features)
def main():
utils.init()
articleIds = getArticleIds()
random.shuffle(articleIds)
i = 0
for id in articleIds:
if i >= N_COLS * N_ROWS:
break
scores = getScores(id)[:MAX_VALUES]
if scores:
plotOne(id, scores, i)
i += 1
pyplot.show()
def main():
utils.init()
for line in sys.stdin:
tokens = line.split('\t')
page_id_str = tokens[0]
if hash(page_id_str) % int(1/FRACTION_PAGES_TO_SUMMARIZE) != 0:
continue
results_str = tokens[-1]
if len(page_id_str) < 2:
print 'invalid page key: %s' % `page_id_str`
else:
page_id = int(page_id_str[1:-1]) # drop open / close quotes
features = tokens[1] if len(tokens) == 3 else ''
summarize(page_id, results_str.strip(), features)
def main():
utils.init()
articleIds = getArticleIds()
random.shuffle(articleIds)
i = 0
for id in articleIds:
if i >= N_COLS * N_ROWS:
break
scores = getScores(id)[:MAX_VALUES]
if scores:
plotOne(id, scores, i)
i += 1
pyplot.show()
def __init__(self, num_inputs, recurrent=False, hidden_size=64):
super(MLPBase, self).__init__(recurrent, num_inputs, hidden_size)
if recurrent:
num_inputs = hidden_size
init_ = lambda m: init(m,
init_normc_,
lambda x: nn.init.constant_(x, 0))
self.actor = nn.Sequential(
init_(nn.Linear(num_inputs, hidden_size)),
nn.Tanh(),
init_(nn.Linear(hidden_size, hidden_size)),
nn.Tanh()
)
self.critic = nn.Sequential(
init_(nn.Linear(num_inputs, hidden_size)),
nn.Tanh(),
init_(nn.Linear(hidden_size, hidden_size)),
nn.Tanh()
)
self.critic_linear = init_(nn.Linear(hidden_size, 1))
self.train()
def solve_random(n,m):
file_out = open('output.txt', 'w')
initial, current, final = ut.init(n,m)
last_sol = m
print('states: ', initial, current, final)
counter = 0
while not ut.is_final_state(current,n,m):
# alege i,j
tower_i, tower_j = random(n)
print('towers: ', tower_i, tower_j)
if ut.valid_transition(current, tower_i, tower_j) is True:
print('is valid')
current = ut.transition(current, tower_i, tower_j)
s = '(%d, %d)\n' % (tower_i, tower_j)
file_out.write(s)
counter = 0
#if current[last_sol] == n:
#last_sol -= 1
if counter == 100:
break
current = ut.transition(current, tower_i, tower_j)
counter += 1
print('states: ', initial, current, final)
file_out.close()
def signal_handler(signal, frame):
zk = utils.init()
election_children = zk.get_children(ELECTION_PATH)
for child in election_children:
print("Deleting election child: " + str(child))
zk.delete(ELECTION_PATH + "/" + child)
return
def get_similar():
utils.init()
logging.info('loading interests from svd/interests.txt')
interests = [
utils.get_interest_by_id(int(line))
for line in open('svd/interests.txt')
]
index = gensim.similarities.docsim.Similarity.load('svd/lda_index.txt')
for (i1, similarities) in enumerate(index):
ordered = []
for (i2, sim) in enumerate(similarities):
ordered.append((sim, i2))
ordered.sort()
ordered.reverse()
for (sim, i2) in ordered[:500]:
print '%s=%s %s=%s %.7f' % (interests[i1].id, interests[i1].text, interests[i2].id, interests[i2].text, sim)
def search():
if request.method == "GET":
if 'username' in session:
return render_template("search.html",username = session["username"])
else:
return render_template("search.html")
else:
symb = request.form['symb']
q = utils.init(symb)
if 'username' in session:
return render_template("stocks.html",username = session["username"], q=q)
else:
return render_template("stocks.html", q=q)
def describe_lda():
utils.init()
model = gensim.models.ldamodel.LdaModel.load('svd/lda.txt')
def article_name(article_id):
name = utils.get_article_name(article_id)
return name.encode('ascii', 'ignore') if name else 'unknown'
# print 'information about topics:'
# for i in random.sample(range(model.num_topics), 50):
# print 'topic %d:' % i
# topic = model.state.get_lambda()[i]
# topic = topic / topic.sum() # normalize to probability dist
# for id in numpy.argsort(topic)[::-1][:10]:
# score = topic[id]
# article_id = model.id2word[id]
# print '\t%.6f: %s' % (score, article_name(article_id))
dictionary = model.id2word
interests = list(utils.get_all_interests())
for i in random.sample(interests, 50):
article_id1 = utils.get_article_id_for_interest(i)
if not article_id1:
continue
doc = make_doc(i, dictionary)
doc_lda = model[doc]
doc_lda.sort(key=lambda pair: pair[1])
doc_lda.reverse()
sys.stdout.write('topics for %s (article %s):\n' % (i.text, article_name(article_id1)))
for (topic_id, topic_score) in doc_lda:
sys.stdout.write('\t%.6f topic %d:' % (topic_score, topic_id))
topic = model.state.get_lambda()[topic_id]
topic = topic / topic.sum() # normalize to probability dist
for id in numpy.argsort(topic)[::-1][:10]:
score = topic[id]
article_id = model.id2word[id]
sys.stdout.write(', ' + article_name(article_id))
sys.stdout.write('\n')
def studentCode(self, data):
utils.init()
coeff = q1.binom(*data)
self.__postprocess.write('{}\n'.format(len(utils.cache())))
return coeff
# return (0,0)
# Error is the offset of the bottom trackpoint from middle of frame
if len(self.trackingpts) == 0: return (0, 0)
err = self.trackingpts[0][0] - V_WIDTH / 2
# Proportion term
pterm = err * self.p
# Calculate the integral term
self.errorsum += err
iterm = self.errorsum * self.i
# Calculate the derivative term
dterm = (err - self.preverr) * self.d
self.preverr = err
# Drive is the difference in speed between two wheels
# Drive is positive when turning left
drive = int(pterm + iterm + dterm)
lwheel = -(self.basespeed + drive)
rwheel = -(self.basespeed - drive)
# Cap the wheel speeds to [-255, 255]
lwheel = max(min(lwheel, 255), -255)
rwheel = max(min(rwheel, 255), -255)
return (lwheel, rwheel)
if __name__ == "__main__":
init("initiating mobot server")
server = ThreadedServer(MobotService, port = MOBOT_PORT)
server.start()
def __init__(self, *args, **kwargs):
rpyc.Service.__init__(self, *args, **kwargs)
init("mobot service instance created")
# Status
self.uptime = time.time()
self.missionuptime = time.time()
self._connected = False
self.filterstate = 0
self.values = {
'BRIG': 0, 'CNST': 50, 'BLUR': 4,
'THRS': 150, 'SIZE': 3, 'CERT': 0.7, 'PTS': 4, 'RADI': 30,
'A': 0.6, 'B': 0.3, 'C': 0.1,
'TCHS': 0.5, 'GATG': 14, 'MAXS': 100
}
self.status = {
'STAT': STAT_ONLINE, 'ACTT': 0, 'MIST': 0, 'DELY': 0,
'GATC': 0, 'SPED': 0, 'PROT': 0, 'CVST': STAT_ONLINE,
'BATT': 100, 'ADDR': LOCAL_ADDR
}
self.emptyfootage = np.zeros((V_HEIGHT, V_WIDTH), dtype = np.uint8)
self.cntframe = self.emptyfootage
self.trackingpts = []
self.vL = 0 # left speed
self.vR = 0 # right speed
self.encL = 0 # left encoder
self.encR = 0 # right encoder
self.touchcount = 0
# Main EV3 control threads
self.loopstop = threading.Event()
self.loopthd = threading.Thread(target=self.mainloop,
args=(self.loopstop,))
self.loopthd.daemon = True
self.hardwarestop = threading.Event()
self.hardwarethd = threading.Thread(target=self.update,
args=(self.hardwarestop,))
self.hardwarethd.daemon = True
# Remote video streaming therad
self.videostop = threading.Event()
self.videothd = None
# Enable camera
self.stream = io.BytesIO()
init("enabling camera")
CAMERA.resolution = (V_WIDTH, V_HEIGHT)
CAMERA.framerate = FRAMERATE
CAMERA.start_preview()
time.sleep(0.2)
# CAMERA.capture_continuous(self.stream, format='jpeg')
# Image Processor Control Variables
self.done = False # stops Image Processor
self.lock = threading.Lock()
self.pool = [] # Pool of Image Processors
# PID Control Variable
self.basespeed = 200
self.errorsum = 0
self.preverr = 0
self.p = 1.2
self.i = 0
self.d = 1
from lettuce import step, world
from nose.tools import assert_equals, assert_true, assert_false
import utils
import os
import bunch.special
path = os.path.abspath(__file__)
dir_path = os.path.dirname(path)
utils.init(dir_path)
config_file = os.path.join(dir_path, "config.yaml")
config = utils.load_yaml_config(config_file)
bunch_working_dir = dir_path
def dump(obj):
for attr in dir(obj):
print "obj.%s = %s" % (attr, getattr(obj, attr))
mysql_admin = config['db']['admin']
mysql_admin_pwd = config['db']['admin_pwd']
class step_assert(object):
def __init__(self, step):
self.step = step
def assert_true(self, expr):
msg = 'Step "%s" failed ' % self.step.sentence
assert_true(expr, msg)
def assert_false(self, expr):
msg = 'Step "%s" failed ' % self.step.sentence
assert_false(expr, msg)
def __init__(self):
# Note: This class utilizes pre-coded parameters
# This class does not have the ability to interact with client
# Core framework
init('mobot basic framework initiating...')
self.uptime = time.time()
self.missionuptime = time.time()
self.filterstate = 0
self.values = {
'BRIG': 0, 'CNST': 50, 'BLUR': CV_BLUR_FACTOR,
'THRS': 150, 'SIZE': 3, 'CERT': 0.7, 'PTS': 4, 'RADI': 30,
'A': 0.6, 'B': 0.3, 'C': 0.1,
'TCHS': 0.5, 'GATG': 14, 'MAXS': 100
}
self.status = {
'STAT': STAT_ONLINE, 'ACTT': 0, 'MIST': 0, 'DELY': 0,
'GATC': 0, 'SPED': 0, 'PROT': 0, 'CVST': STAT_ONLINE,
'BATT': 100, 'ADDR': LOCAL_ADDR
}
self.emptyfootage = np.zeros((V_HEIGHT, V_WIDTH), dtype = np.uint8)
self.cntframe = self.emptyfootage
self.trackingpts = []
self.vL = 0 # left speed
self.vR = 0 # right speed
self.encL = 0 # left encoder
self.encR = 0 # right encoder
self.touchcount = 0
# Main EV3 control threads
self.loopstop = threading.Event()
self.loopthd = threading.Thread(target=self.mainloop,
args=(self.loopstop,))
self.loopthd.daemon = True
self.hardwarestop = threading.Event()
self.hardwarethd = threading.Thread(target=self.update,
args=(self.hardwarestop,))
self.hardwarethd.daemon = True
# Remote video streaming therad
# self.videostop = threading.Event()
# self.videothd = None
# Enable camera
self.stream = io.BytesIO()
init("enabling camera")
CAMERA.resolution = (V_WIDTH, V_HEIGHT)
CAMERA.framerate = FRAMERATE
CAMERA.start_preview()
time.sleep(0.2)
# CAMERA.capture_continuous(self.stream, format='jpeg')
# Image Processor Control Variables
self.done = False # stops Image Processor
self.lock = threading.Lock()
self.pool = [] # Pool of Image Processors
# PID Control Variable
self.basespeed = MOTOR_BASESPEED
self.errorsum = 0
self.preverr = 0
self.p = CTRL_P
self.i = CTRL_I
self.d = CTRL_D
# Variable that stores inclination button state
self.incline_btn_prev = False
# Loop control state machine
self.loopstate = processing.BifurcationState(V_WIDTH, V_HEIGHT,
LOOP_CHOICES)
print '-s Run standalone mode independent of client'
print '-i Invert the color seen (we are tracking white line)'
print '-m <mode> Select CV Mode being used'
print ' -> alpha: new histogram model'
print ' -> beta: obsolete probabilistic tracking model'
print '------------------ALPHACV EXCLUSIVE OPTIONS------------------'
print '-c Save processed image (under alphacv)'
print '-k Row skip: allow skipping rows for grouping'
print '-t Choose thin: whether we shall favor thinner group'
sys.exit(2)
elif opt in ('-s', '--standalone'):
STANDALONE = True
elif opt in ('-m', '--mode'):
if arg == 'alpha':
init('system running on alpha histogram algorithm.')
CV_MANUAL_MODE = 'alpha'
elif arg == 'beta':
init('system running on beta probabilistic algorithm.')
CV_MANUAL_MODE = 'beta'
else:
warn('not a valid mode, falling back to alpha.')
CV_MANUAL_MODE = 'alpha'
elif opt in ('-i', '--inverted'):
info('inverted cam mode enabled.')
CV_MANUAL_IRNV = True
elif opt in ('-k',):
info('row skipping enabled.')
ALPHA_CV_ROW_SKIP = True
zk.set(self.worker_id, "non")
print("Worker %s created!" %(self.worker_id))
#3.watch znode
zk.DataWatch(self.path, self.assignment_change)
# do something upon the change on assignment
def assignment_change(self, atask, stat):
if atask and not atask == "non" :
#4.5. get task id uppon assignment in workers, get task data in data/yyy
data_path = DATA_PATH + atask
if self.zk.exists(data_path) :
data = self.zk.get(data_path)
#6. execute task with data
result = utils.task(data)
task_path = TASKS_PATH + atask
task_val = atask + "=" + str(result)
# set result in task - task completion
if self.zk.exists(task_path) :
zk.set(task_path, task_val)
print("Worker completed task %s with result %s" %(atask, result))
else :
print("Task %s not found, maybe the connection was lost" %(task_path))
#7. delete assignment
zk.set(self.path, "non")
if __name__ == '__main__':
zk = utils.init()
worker = Worker(zk)
while True:
time.sleep(1)
#!/usr/bin/env python3
import functools, os
import matplotlib.pyplot as plt
import pandas as pd
import utils
utils.init(__file__)
d = utils.skip_comment_char(functools.partial(pd.read_csv, delim_whitespace=True), "imsrg-qdpt/dat_arenergy_by_ml.txt")
d = d[["num_shells", "num_filled", "freq", "ml", "label", "energy"]]
d["method"] = "qdpt"
dq = d
d = pd.read_csv("EOM_IMSRG_qd_attached.dat", delim_whitespace=True)
d["energy"] = d["E(N+1)-E(N)"]
d = d[["shells", "filled", "ML", "omega", "energy"]]
d = d.rename(columns={"shells": "num_shells", "filled": "num_filled", "ML": "ml", "omega": "freq"})
d["label"] = "add"
d["method"] = "eom"
dea = d
d = pd.read_csv("EOM_IMSRG_qd_removed.dat", delim_whitespace=True)
d["energy"] = -d["E(N-1)-E(N)"]
d = d[["shells", "filled", "ML", "omega", "energy"]]
d = d.rename(columns={"shells": "num_shells", "filled": "num_filled", "ML": "ml", "omega": "freq"})
d["label"] = "rm"
d["method"] = "eom"
der = d
d = pd.concat([dq, dea, der])
def stock_trade():
trade_order = request.json
add_1 = trade_order['portofolio_1']
add_2 = trade_order['portofolio_2']
model.trade(add_1['user'], add_1['content'], add_2['user'], add_2['content'])
@app.route("/stockexchange/distribute", method="POST")
def stock_distribute():
portofolio_order = request.json
model.distribute(portofolio_order['user'], portofolio_order['content'])
if __name__ == "__main__":
parser = optparse.OptionParser()
parser.add_option('--mongo_db', default='naive_stock')
parser.add_option('--mongo_host', default='localhost')
parser.add_option('--model', default='transac_stockmarket.TransacStockmarket')
parser.add_option('--server', default='tornado')
parser.add_option('--debug', action='store_true', default=False)
parser.add_option('--reset', action='store_true', default=False)
options, remainder = parser.parse_args()
global model
[module, cls] = options.model.split('.', 1)
m = __import__(module)
c = getattr(m, cls)
model = c()
model.setMongo(options.mongo_host, options.mongo_db)
if options.reset:
utils.init(model)
if options.debug:
debug(True)
run(app=app, host="0.0.0.0", port=os.environ.get("PORT", 8080), reloader=True, server=options.server)
def studentCode(self, data):
utils.init()
q1.printtable(*data)
return utils.result()
def test_sample_person_graph():
# for u in [utils.get_user_by_id(3568), utils.get_user_by_id(16)]:
# for u in [utils.get_user_by_id(16)]:
for u in random.sample(utils.get_all_users(), 200):
print "=" * 80
print
print "results for ", u, " ".join([i.text for i in u.interests])
make_full_person_graph(u)
print
print
print
def test_sample_interest_graph():
for i in random.sample(utils.get_all_interests(), 100):
print "=" * 80
print
print "results for ", i
make_full_interest_graph(i)
print
print
print
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
# LOGGER.setLevel(logging.DEBUG)
utils.init()
# test_sample_interest_graph()
test_sample_person_graph()
