def main():
args = argparser.parse_args()
pdf_doc = PDF_Doc()
pdf = pdf_doc.get_pdf_doc(args.fromobject)
if args.to == 'results/':
_save_pdf('results/', pdf_doc.full_name, pdf)
else:
_save_pdf(args.to, pdf_doc.full_name, pdf)
def main():
"""TODO: Docstring for main.
:returns: TODO
"""
args = parse_args()
drugs, protiens,relations, ddi, ppi, dpi = read_data(args)
# print(eval_kfold(drugs, protiens, relations, ddi, ppi, dpi, args))
print(eval_1fold(drugs, protiens, relations, ddi, ppi, dpi, args))
def main(argv=None):
opt = parse_args(argv)
tasks = TCGAMeta(download=True, preload=True)
task = tasks[113]
# Setup the results dictionary
filename = "experiments/results/clinical-tasks.pkl"
try:
results = pickle.load(open(filename, "rb"), encoding='latin1')
print("Loaded Checkpointed Results")
except Exception as e:
print(e)
results = pd.DataFrame(columns=[
'task', 'acc_metric', 'model', 'graph', 'trial', 'train_size',
'time_elapsed'
])
print("Created a New Results Dictionary")
train_size = 50
trials = 3
cuda = True
exp = []
for trial in range(trials):
model = GCN(cuda=cuda,
dropout=opt.dropout,
num_layer=opt.num_layer,
channels=opt.channels,
embedding=opt.embedding,
aggregation=opt.aggregation,
lr=opt.lr,
agg_reduce=opt.agg_reduce,
seed=trial)
task._samples = task._samples - task._samples.mean(axis=0)
task._samples = task._samples / task._samples.var()
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(
task._samples,
task._labels,
stratify=task._labels,
train_size=train_size,
test_size=len(task._labels) - train_size)
adj = sparse.csr_matrix(nx.to_numpy_matrix(GeneManiaGraph().nx_graph))
model.fit(X_train, y_train, adj=adj)
y_hat = []
for chunk in get_every_n(X_test, 10):
y_hat.extend(np.argmax(model.predict(chunk), axis=1).numpy())
exp.append(model.metric(y_test, y_hat))
print(exp)
report_results([{
"name": "acc_metric",
"type": "objective",
"value": np.array(exp).mean()
}])
def main():
"""
Play RPS
"""
try:
opts, args = getopt.getopt(sys.argv[1:], "n:pPh",
["numgames=", "print", "plot", "help"])
except getopt.GetoptError as err:
print(str(err))
print(usage())
sys.exit(2)
ngames = 100
printg = False
plot = False
for opt, arg in opts:
if opt in ("-n", "--numgames"):
ngames = int(arg)
elif opt in ("-p", "--print"):
printg = True
elif opt in ("-P", "--plot"):
plot = True
elif opt in ("-h", "--help"):
print(usage())
sys.exit(0)
if len(args) == 2:
p1_pstyle, p1_hsize = ap.parse_args(args[0])
p2_pstyle, p2_hsize = ap.parse_args(args[1])
p_1 = Player(play_style=p1_pstyle, hist=p1_hsize)
p_2 = Player(play_style=p2_pstyle, hist=p2_hsize)
else:
p_1 = Player(play_style=_HIST, hist=2)
p_2 = Player(play_style=_SEQ)
games = MultipleGames(p_1,
p_2,
num_games=ngames,
print_games=printg,
plot=plot)
games.arrange_tournament()
def main(argv=None):
opt = parse_args(argv)
dataset = datasets.TCGADataset()
dataset.df = dataset.df - dataset.df.mean(axis=0)
gene_graph = GeneManiaGraph()
search_num_genes = [50, 100, 200, 300, 500, 1000, 2000, 4000, 8000, 16300]
test_size = 300
cuda = torch.cuda.is_available()
exp = []
for num_genes in search_num_genes:
start_time = time.time()
gene = "RPL4"
model = GCN(cuda=cuda,
dropout=opt.dropout,
num_layer=opt.num_layer,
channels=opt.channels,
embedding=opt.embedding,
aggregation=opt.aggregation,
lr=opt.lr,
agg_reduce=opt.agg_reduce)
dataset.labels = dataset.df[gene].where(
dataset.df[gene] > 0).notnull().astype("int")
dataset.labels = dataset.labels.values if type(
dataset.labels) == pd.Series else dataset.labels
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(
dataset.df,
dataset.labels,
stratify=dataset.labels,
train_size=opt.train_size,
test_size=opt.test_size,
random_state=opt.seed)
if num_genes == 16300:
neighbors = gene_graph.nx_graph
else:
neighbors = gene_graph.bfs_sample_neighbors(gene, num_genes)
X_train = X_train[list(neighbors.nodes)].copy()
X_test = X_test[list(neighbors.nodes)].copy()
X_train[gene] = 1
X_test[gene] = 1
adj = sparse.csr_matrix(nx.to_numpy_matrix(neighbors))
model.fit(X_train, y_train, adj=adj)
y_hat = model.predict(X_test)
y_hat = np.argmax(y_hat, axis=1)
auc = sklearn.metrics.roc_auc_score(y_test,
np.asarray(y_hat).flatten())
del model
exp.append(auc)
report_results([{
"name": "auc",
"type": "objective",
"value": np.array(exp).mean()
}])
def main():
args = parse_args()
transcribe = Transcriber()
chunker = ChunkSpeaker()
converter = Converter()
try:
if args.mode == 'transcribe':
transcribe.transcribe(args.input_folder, args.output_folder)
if args.mode == 'chunk_speaker':
chunker.chunk(args.audio_input_path, args.speech_segmentation_path,
args.output_folder)
if args.mode == 'convert':
converter.convert(args.type, args.online_folder,
args.chunks_text_path, args.output_folder)
except InputError as e:
print(f'{InputError.__name__}:\n\t{e}')
def main():
os.chdir(os.path.expanduser('~'))
if not os.path.exists('./.tikup'):
os.mkdir('./.tikup')
os.chdir('./.tikup')
args = parse_args()
username = args.user
delete = args.no_delete
limit = args.limit
archive = args.use_download_archive
downloadType = ''
if archive:
try:
file = open('archive.txt', 'r+')
except FileNotFoundError:
f = open('archive.txt', 'x')
f.close()
file = open('archive.txt', 'r+')
else:
file = None
did = str(random.randint(10000, 999999999))
if args.hashtag: # Download hashtag
downloadType = 'hashtag'
tiktoks = getHashtagVideos(username, limit)
elif args.id: # Download user ID
downloadType = 'id'
tiktoks = [username]
elif args.liked: # Download liked
downloadType = 'liked'
tiktoks = getLikedVideos(username, limit)
else: # Download username
downloadType = 'username'
tiktoks = getUsernameVideos(username, limit)
tiktoks = downloadTikToks(username, tiktoks, file, downloadType, did)
if args.no_upload: # Upload to IA
uploadTikToks(tiktoks, file, delete)
try:
file.close()
except:
pass
print('')
def main():
args = parse_args(__doc__, ['env', 'mode', 'timesteps'])
env = gym.make(args.env)
env.render(mode=args.mode)
obs = env.reset()
env.unwrapped.set_gravity(-1)
# TODO: use controller arg
ctrl = leanLeftRightController(env)
for _ in range(args.timesteps):
obs, _, done, _ = env.step(ctrl.get_action(obs))
if done:
print(
'\n=============\nThe episode has finished, restarting\n=============\n'
)
time.sleep(1)
obs = env.reset()
ctrl.reset()
def main():
args = argparser.parse_args()
file_path = args.file_path
buffer_size = args.buffer_size
comparator = args.comparator
if file_path is None:
file_path = input('Input file path: ')
if buffer_size is None:
buffer_size = int(input('Input buffer size: '))
if comparator is None:
comparator = input('Input comparator: ')
if os.path.exists('temp'):
shutil.rmtree('temp')
os.mkdir('temp')
make_temp_files(file_path, buffer_size, COMPARATORS[comparator], args.r)
sort(COMPARATORS[comparator], args.r)
def main():
args = argparser.parse_args()
try:
page_id = get_page_id(args.url)
except (RuntimeError, requests.exceptions.ConnectionError) as error:
print("{}: runtime error: {}".format(sys.argv[0], error), file=sys.stderr)
sys.exit(1)
print("Downloading posts. This may take some time, be patient...")
postsReceiver = PostsReceiver(page_id=page_id)
try:
if not args.workers or args.workers > 1:
posts = postsReceiver.parallel_receive(max_workers=args.workers)
else:
posts = postsReceiver.receive()
except KeyboardInterrupt:
msg = "{}: {}".format(sys.argv[0], "Keyboard interrupt. Exiting...")
print(msg, file=sys.stderr)
sys.exit(1)
except VKApiError as error:
print("{}: vk api error: {}".format(sys.argv[0], error), file=sys.stderr)
sys.exit(1)
except Exception as error:
msg = "{}: catastrophic error: {}".format(sys.argv[0], error)
print(msg, file=sys.stderr)
sys.exit(1)
if args.reposts:
posts = sorted(posts, key=lambda x: -x.reposts)
else:
posts = sorted(posts, key=lambda x: -x.likes)
pretty_print(posts[: args.top], page_id, args.reposts)
#!/usr/bin/env python
# Generative Adversarial Networks (GAN) example with 2D samples in PyTorch.
import os
from skimage import io
import torch
import torch.nn as nn
from torch.autograd import Variable
from sampler import generate_lut, sample_2d
from visualizer import GANDemoVisualizer
from argparser import parse_args
from networks import SimpleMLP
DIMENSION = 2
args = parse_args()
cuda = False if args.cpu else True
bs = args.batch_size
z_dim = args.z_dim
density_img = io.imread(args.input_path, True)
lut_2d = generate_lut(density_img)
visualizer = GANDemoVisualizer('GAN 2D Example Visualization of {}'.format(args.input_path))
generator = SimpleMLP(input_size=z_dim, hidden_size=args.g_hidden_size, output_size=DIMENSION)
discriminator = SimpleMLP(input_size=DIMENSION, hidden_size=args.d_hidden_size, output_size=1)
if cuda:
generator.cuda()
discriminator.cuda()
criterion = nn.BCELoss()
def main():
""" Mostly inspired from
https://github.com/totti0223/gradcamplusplus/blob/master/gradcamutils.py#L10 """
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # Makes TensorFlow shut up
args = parse_args()
logger = get_logger(args.verbose)
logger.info(
"Loading the input image and resizing it to (224, 224) as required by the model."
)
image = np.array(load_img(args.input, target_size=(224, 224)),
dtype=np.uint8)
logger.info(
"Pre-processing the image like ImageNet's were when VGG was trained (sub mean from channels) "
"also add the batch dimension (only one image)")
image_processed = preprocess_input(np.expand_dims(image, axis=0))
logger.info("Instantiate the pre-trained VGG19")
model = VGG19(include_top=True, input_shape=(224, 224, 3))
logger.info("Gets which class is the most activated")
prediction = model.predict(image_processed)
predicted_class = np.argmax(prediction)
predicted_class_name = decode_predictions(prediction, top=1)[0][0][1]
logger.info(
"Gets the tensor object (a scalar here) which is activated when showing the image"
)
y_c_tensor = model.output[0, predicted_class]
logger.info(
"Gets the tensor object corresponding to the output of the studied convolution layer"
)
A_tensor = model.get_layer(args.layer).output
logger.info("Gets the tensor containing the gradient of y_c w.r.t. A")
gradient_tensor = K.gradients(y_c_tensor, A_tensor)[0]
logger.info(
"Creates a function that takes as input the model's input "
"and outputs the convolutions' result and the gradient of the prediction w.r.t. it"
)
run_graph = K.function([model.input], [A_tensor, gradient_tensor])
logger.info("Runs the graph using the inputted image")
A, gradient = run_graph([image_processed])
A, gradient = A[0], gradient[
0] # Gets the result of the first batch dimension
logger.info("Performs global average pooling onto the activation gradient")
alpha_c = np.mean(gradient, axis=(0, 1))
logger.info("Weighs the filters maps with the activation coefficient")
L_c = np.dot(A, alpha_c)
logger.info("Resizes the localisation map to match the input image's size")
L_c = zoom(L_c, 224 / L_c.shape[0])
logger.info("Plots the original image and the superimposed heat map")
plt.subplots(nrows=1, ncols=2, dpi=160, figsize=(7, 4))
plt.subplots_adjust(left=0.01,
bottom=0.0,
right=0.99,
top=0.96,
wspace=0.11,
hspace=0.2)
plt.subplot(121)
plt.title("Original image")
plt.imshow(image)
plt.axis("off")
plt.subplot(122)
plt.title("{}th dimension ({}) \nw.r.t layer {}".format(
predicted_class, predicted_class_name, args.layer))
plt.imshow(image)
plt.imshow(L_c, alpha=0.5, cmap="jet")
plt.axis("off")
if args.output is not None:
logger.info("Saves the figure under {}".format(args.output))
plt.savefig(args.output, dpi=300)
if not args.quiet:
plt.show()
def doWork():
args, kwargs = argparser.parse_args()
kmeans(*args, **kwargs)
def main():
nb_total_steps = 1000
nb_iterations = 40
hidden_layers = [256, 256]
writer = tensorboardX.SummaryWriter()
args = parse_args(__doc__, ['env'])
env = gym.make(args.env)
ctrl = rand_ctrl = RandomController(env)
# ipdb.set_trace()
print('#inputs : %d' % ctrl.nb_inputs())
print('#actions: %d' % ctrl.nb_actions())
# f_net = make_net(
# [ctrl.nb_inputs() + ctrl.nb_actions()] + hidden_layers + [ctrl.nb_inputs()],
# [nn.ReLU() for _ in hidden_layers],
# )
f_net = MOENetwork(
nb_inputs=ctrl.nb_inputs() + ctrl.nb_actions(),
nb_experts=4,
gait_layers=[64],
expert_layers=[64, ctrl.nb_inputs()],
)
data = collect_data(env, ctrl, nb_total_steps*10)
# ipdb.set_trace()
dynamics = DynamicsModel(env, f_net, data.get_all(), writer=writer)
# cost_func = lambda s,a,sn: -sn[3].item() # refers to vx
cost_func = get_cost(args.env) # refers to vx
# data.calc_normalizations()
# dynamics.fit(data)
mpc_ctrl = MPCcontroller(env, dynamics.predict, cost_func, num_simulated_paths=100, horizon=10, num_mpc_steps=10)
eval_args = EvaluationArgs(nb_burnin_steps=4, nb_episodes=10, horizons=[1, 2, 4, 8, 16, 32])
for i in range(nb_iterations):
print('Iteration', i)
new_data = collect_data(env, ctrl, nb_total_steps)
dynamics.fit(*new_data.get_all())
data.extend(new_data)
dynamics.fit(*data.sample(sample_size=4*nb_total_steps))
evaluate_and_log_dynamics(
dynamics.predict, env, rand_ctrl, writer=writer, i_step=i, args=eval_args
)
evaluate_and_log_dynamics(
dynamics.predict, env, mpc_ctrl, writer=writer, i_step=i, args=eval_args
)
# dynamics.fit(*data.get_all())
if random.random() > 0.5:
ctrl = rand_ctrl
else:
ctrl = mpc_ctrl
env = gym.make(args.env)
ctrl = MPCcontroller(env, dynamics.predict, cost_func, num_simulated_paths=1000, num_mpc_steps=4)
# TODO
env.render(mode='human')
obs = env.reset()
for _ in range(100):
# time.sleep(1. / 60.)
obs, r, done, _ = env.step(ctrl.get_action(obs))
# print(' ', cost_func(obs))
if done:
print("done:", r, obs)
time.sleep(1)
ctrl.reset()
obs = env.reset()
ipdb.set_trace()
def main():
args = parse_args()
# __________________ Params ___________________
sample_size = args.sample_size
train_batch_size = args.train_batch_size
test_batch_size = 128
num_epochs = args.num_epochs
num_workers = args.num_worker
lr = args.learning_rate
start_epoch = 0
# _____________________________________________
manual_seed = random.randint(1, 10000)
random.seed(manual_seed)
torch.manual_seed(manual_seed)
torch.cuda.manual_seed_all(manual_seed)
torch.set_num_threads(num_workers + 1)
cudnn.benchmark = True
# cudnn.deterministic = False
cudnn.enabled = True
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
coco_train = Coco(
'datasets/data/coco_data/person_keypoints_train2017.json', 'train',
sample_size, transforms.Compose([normalize]))
coco_val = Coco('datasets/data/coco_data/person_keypoints_val2017.json',
'train', sample_size, transforms.Compose([normalize]))
train_loader = DataLoader(coco_train,
batch_size=train_batch_size,
shuffle=True,
num_workers=num_workers,
pin_memory=False)
val_loader = DataLoader(coco_val,
batch_size=test_batch_size,
shuffle=False,
num_workers=num_workers,
pin_memory=False)
pose_net = bninception(out_chn=2)
model = DataParallel(pose_net)
model.cuda()
#checkpoint = torch.load('models/m_100.pth')
#pretrained_dict = checkpoint['state_dict']
#model.load_state_dict(pretrained_dict)
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
#os.makedirs(args.log, exist_ok=True)
for epoch in range(start_epoch, num_epochs):
if epoch == 100:
for param_group in optimizer.param_groups:
param_group['lr'] = 1e-4
dloss, scale_loss = train(train_loader, model, optimizer)
tloss = 'det_loss ' + str(dloss) + ' scale loss ' + str(scale_loss)
dloss, scale_loss = train_test(val_loader, model)
test_loss = 'det_loss ' + str(dloss) + ' scale loss ' + str(scale_loss)
with open('losses/train_loss_384.txt', 'a') as the_file:
the_file.write(str(tloss) + '\n')
with open('losses/test_loss_384.txt', 'a') as the_file:
the_file.write(str(test_loss) + '\n')
ckpt = {
'epoch': epoch,
'optimizer': optimizer.state_dict(),
'state_dict': model.state_dict()
}
#os.makedirs(args.model_save_path, exist_ok=True)
#ckpt_name = os.path.join(args.model_save_path, 'epoch_%d.ckpt' % epoch)
torch.save(ckpt, 'models/m_384_' + str(epoch) + '.pth')
