def func(argv):
print("hello")
print(cy.Define.strName)
print(cy.Define.nAge)
print("pocketgit")
common.test()
# common.my_abs('free')
print(common.my_abs(3.36))
print(common.power(4, 5))
print(common.fact(5))
p = argparse.ArgumentParser("help123")
p.add_argument('-c', nargs='?',default='cy')
p.add_argument('-y', nargs='?', default='wy')
args = p.parse_args(argv[1:])
if args.c == 'cy':
print("-cy")
# clean
print("Clean my computor.")
# Mac
print("Mac下快速搜索或启动：Command＋Space")
#game
print("game save git")
#time
print("E=mc^2")
def run():
"""
:param app_name: HPC application
:param perf_coln: performance name to be optimized
:param num_core: number of CPU cores
:param num_node: number of computing nodes
:param rand_seed: random seed
:param num_smpl: number of samples
:param pool_size: pool size
:param num_iter: number of iterations
:param prec_rand: precentage of random samples
"""
try:
cm.init()
app_name = cm.app_name
perf_coln = cm.perf_coln
num_smpl = cm.num_smpl
pool_size = cm.pool_size
num_iter = cm.num_iter
prec_rand = cm.prec_rand
if (app_name == "lv"):
conf_colns = data.lv_conf_colns
elif (app_name == "hs"):
conf_colns = data.hs_conf_colns
num_rand = int(num_smpl * prec_rand)
nspi = int((num_smpl - num_rand) / num_iter)
# pool_df = data.gen_smpl(app_name, pool_size)
# conf_df = pool_df.head(num_rand)
conf_df = data.gen_smpl(app_name, num_rand)
train_df = cm.measure_perf(conf_df)
for iter_idx in range(num_iter):
num_curr = num_smpl - nspi * (num_iter - 1 - iter_idx)
pool_df = data.gen_smpl(app_name, pool_size)
pred_top_smpl = learn.whl_pred_top_eval(train_df, pool_df, conf_colns, perf_coln, num_smpl, 0)
pred_top_smpl = pred_top_smpl.sort_values([perf_coln]).reset_index(drop=True)
new_conf_df = pred_top_smpl[conf_colns].head(nspi)
conf_df = tool.df_union(conf_df, new_conf_df)
last = nspi
while (conf_df.shape[0] < num_curr):
last = last + 1
new_conf_df = pred_top_smpl[conf_colns].head(last)
conf_df = tool.df_union(conf_df, new_conf_df)
new_train_df = cm.measure_perf(new_conf_df)
train_df = tool.df_union(train_df, new_train_df)
data.df2csv(train_df, app_name + "_train.csv")
mdl_chk, mdl = learn.train_mdl_chk(train_df, conf_colns, perf_coln)
top_df = cm.find_top('ALe', (mdl_chk, mdl, ), conf_colns, perf_coln, train_df)
cm.test(train_df, conf_colns, perf_coln)
cm.finish(train_df, top_df)
except:
traceback.print_exc()
args['max_sentence_length'],
pdtb_category=args['pdtb_category'])
# load model,optimizer and loss
model, optimizer, criterion = common.get_model(
model=args['model'],
model_path=results_path,
lr=args['learning_rate'],
weight_decay=args['weight_decay'],
pdtb_category=args['pdtb_category'])
print(optimizer)
print(criterion)
if args['cuda']:
torch.backends.cudnn.enabled = True
cudnn.benchmark = True
model.cuda()
criterion = criterion.cuda()
if args['model'] == 'grn16':
common.test_grn16(val_loader, model, criterion, args['cuda'],
args['print_freq'])
elif args['model'] == 'keann':
common.test_keann(val_loader, model, criterion, args['cuda'],
args['print_freq'])
elif args['model'] == 'keann_kg':
common.test_keann_kg(val_loader, model, criterion, args['cuda'],
args['print_freq'])
else:
common.test(val_loader, model, criterion, args['cuda'], args['print_freq'])
def main():
print(common.outNum(100))
common.test()
def getModel():
model = Sequential()
model.add(
LSTM(1000,
activation='tanh',
input_shape=(4, 1),
return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(500, activation='tanh', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(200, activation='tanh', return_sequences=True))
model.add(Dense(1, activation='linear'))
adam = optimizers.Adam(lr=0.0001)
model.compile(loss="mean_squared_error", optimizer=adam)
return model
if __name__ == '__main__':
file = common.readData()
scaler = preprocessing.MinMaxScaler(feature_range=(-1, 1))
data = common.preprocessData(file, scaler)
train_data, test_data = common.splitData(data, 0.8)
common.plotTestAndTrain(train_data, test_data)
x_train, y_train, x_test, y_test = common.prepareForTraining(
train_data, test_data)
model = getModel()
common.train(x_train, y_train, model, 16, 10, "model01.h5")
common.test(model, x_train, y_train, x_test, y_test)
common.predict(model, x_test, y_test, scaler)
"""
http://rosalind.info/problems/revc/
Given: A DNA string s of length at most 1000 bp.
Return: The reverse complement sc of s.
"""
import common
sample_data = "AAAACCCGGT"
sample_output = "ACCGGGTTTT"
comp = dict(A="T", T="A", C="G", G="C")
def complement(dna):
return "".join([x.replace(x, comp[x]) for x in dna[::-1]])
common.test(complement, sample_data, sample_output)
common.runit(complement)
"""
http://rosalind.info/problems/subs/
Given: Two DNA strings s and t (each of length at most 1 kbp).
Return: All locations of t as a substring of s.
"""
import common
import re
sample_data = """GATATATGCATATACTT
ATAT"""
sample_output = "2 4 10"
def motif(inp):
s = inp.splitlines()[0]
t = inp.splitlines()[1]
p = re.compile(r'(?=(%s))' % t)
results = []
for m in p.finditer(s):
results.append(str(m.start() + 1))
return ' '.join(results)
common.test(motif, sample_data, sample_output)
common.runit(motif)
"""
http://rosalind.info/problems/rna/
Given: A DNA string t having length at most 1000 nt.
Return: The transcribed RNA string of t. (T => U)
"""
import common
alphabet = ['A', 'C', 'G', 'U']
sample_data = "GATGGAACTTGACTACGTAAATT"
sample_output = "GAUGGAACUUGACUACGUAAAUU"
def scribe(dna):
out = dna.replace("T", "U")
return out
common.test(scribe, sample_data, sample_output)
common.runit(scribe)
parser.set_defaults(test=False)
args = parser.parse_args()
input_shape = (FB_HEIGHT, WIDTH, COLOR_DEPTH)
if args.test:
model = load_model(modelFileName)
input_shape = (FB_HEIGHT, WIDTH, COLOR_DEPTH)
label_binarizer, clazzes = common.build_label_binarizer()
test_labels, test_features, test_metadata = common.load_data(
label_binarizer, foldsFolder, 'test', [1], input_shape)
common.test(test_labels, test_features, test_metadata, model, clazzes)
else:
accuracies = []
numFolds = len(
glob(os.path.join(foldsFolder, "train_metadata.fold*.npy")))
generator = common.train_generator(numFolds,
foldsFolder,
input_shape,
max_iterations=1)
first = True
for (train_labels, train_features, test_labels, test_features,
test_metadata, clazzes) in generator:
# TODO reset tensorflow
for line in inp.splitlines():
print line
if line.startswith(">"):
if current_dna:
current_dna.get_gc()
dnas.append(current_dna)
current_dna = Dna(ID=line.replace(">", "").strip())
else:
# dna stretches over multiple lines
current_dna.dna_str += line.strip()
dnas.append(current_dna)
# from pprint import pprint
# pprint(dnas)
max_dna = dnas[0]
for d in dnas:
if d.gc > max_dna.gc:
max_dna = d
print ""
print "DNA with largest GC content:"
print max_dna.ID
print max_dna.gc
return "%s\n%s" % (max_dna.ID, str(max_dna.gc))
common.test(gc, sample_data, sample_output)
common.runit(gc)
"""
http://rosalind.info/problems/hamm/
Given: Two DNA strings s and t of equal length (not exceeding 1 kbp).
Return: The Hamming distance dH(s,t).
"""
import common
from itertools import izip
sample_data = """GAGCCTACTAACGGGAT
CATCGTAATGACGGCCT"""
sample_output = "7"
def hamm(inp):
s = inp.splitlines()[0]
t = inp.splitlines()[1]
return str(sum([i != j for i, j in izip(s, t)]))
common.test(hamm, sample_data, sample_output)
common.runit(hamm)
"AGC": "S",
"GGC": "G",
"UGA": "Stop",
"CGA": "R",
"AGA": "R",
"GGA": "G",
"UGG": "W",
"CGG": "R",
"AGG": "R",
"GGG": "G"
}
def code(rna):
# check it starts correctly
if rna[0:3] != "AUG":
return None
# split into 3-letter words
words = [rna[i:i + 3] for i in range(0, len(rna), 3)]
# change to proteins
protein = [codon_table[w] for w in words]
protein = protein[:protein.index("Stop")]
return ''.join(protein)
common.test(code, sample_data, sample_output)
common.runit(code)
def run():
"""
:param app_name: HPC application
:param perf_coln: performance name to be optimized
:param num_core: number of CPU cores
:param num_node: number of computing nodes
:param rand_seed: random seed
:param num_smpl: number of samples
:param pool_size: pool size
:param num_iter: number of iterations
:param prec_rand: precentage of random samples
:param prec_init: precentage of initial samples replaced by equivalent samples
"""
try:
cm.init()
app_name = cm.app_name
perf_coln = cm.perf_coln
num_smpl = cm.num_smpl
pool_size = cm.pool_size
num_iter = cm.num_iter
prec_rand = cm.prec_rand
prec_init = cm.prec_init
if (app_name == "lv"):
conf_colns = data.lv_conf_colns
conf1_colns = data.lmp_conf_colns
conf2_colns = data.vr_conf_colns
elif (app_name == "hs"):
conf_colns = data.hs_conf_colns
conf1_colns = data.ht_conf_colns
conf2_colns = data.sw_conf_colns
num_rand = int(num_smpl * prec_rand)
# pool_df = data.gen_smpl(app_name, pool_size)
# conf_df = pool_df.head(num_rand)
conf_df = data.gen_smpl(app_name, num_rand)
train_df = cm.measure_perf(conf_df)
num_init = int(num_smpl * prec_init)
pool1_df = data.gen_smpl(cm.app1_name(app_name), num_init * 100)
conf1_df = pool1_df.head(num_init)
train1_df = cm.measure_perf(conf1_df)
pool2_df = data.gen_smpl(cm.app2_name(app_name), num_init * 100)
conf2_df = pool2_df.head(num_init)
train2_df = cm.measure_perf(conf2_df)
avg_mach_time = data.sa_mach_time(train_df) / num_rand
avg_sprt_mach_time = (data.app_mach_time(train1_df) + \
data.app_mach_time(train2_df)) / num_init
factor = max(1, avg_mach_time / avg_sprt_mach_time)
if (factor > 1):
num_sprt = int(num_init * factor)
new_conf1_df = pool1_df.head(num_sprt).tail(num_sprt - num_init)
new_train1_df = cm.measure_perf(new_conf1_df)
train1_df = tool.df_union(train1_df, new_train1_df)
new_conf2_df = pool2_df.head(num_sprt).tail(num_sprt - num_init)
new_train2_df = cm.measure_perf(new_conf2_df)
train2_df = tool.df_union(train2_df, new_train2_df)
pool_df = data.gen_smpl(app_name, pool_size)
pred_top_smpl = learn.sprt_pred_top_eval(train1_df, train2_df, pool_df,
conf1_colns, conf2_colns,
conf_colns, perf_coln,
num_smpl, 0)
nspi = int((num_smpl - num_init - num_rand) / num_iter)
for iter_idx in range(num_iter):
num_curr = num_smpl - num_init - nspi * (num_iter - 1 - iter_idx)
pred_top_smpl = pred_top_smpl.sort_values(
[perf_coln]).reset_index(drop=True)
new_conf_df = pred_top_smpl[conf_colns].head(nspi)
conf_df = tool.df_union(conf_df, new_conf_df)
last = nspi
while (conf_df.shape[0] < num_curr):
last = last + 1
new_conf_df = pred_top_smpl[conf_colns].head(last)
conf_df = tool.df_union(conf_df, new_conf_df)
new_train_df = cm.measure_perf(new_conf_df)
train_df = tool.df_union(train_df, new_train_df)
if (iter_idx < num_iter - 1):
pool_df = data.gen_smpl(app_name, pool_size)
pred_top_smpl = learn.whl_pred_top_eval(
train_df, pool_df, conf_colns, perf_coln, num_smpl, 0)
data.df2csv(train_df, app_name + "_train.csv")
mdl_chk, mdl = learn.train_mdl_chk(train_df, conf_colns, perf_coln)
top_df = cm.find_top('TaLeC', (
mdl_chk,
mdl,
), conf_colns, perf_coln, train_df)
cm.test(train_df, conf_colns, perf_coln)
cm.finish(train_df, top_df)
except:
traceback.print_exc()
m are heterozygous, and n are homozygous recessive.
Return: The probability that two randomly selected mating organisms will produce
an individual possessing a dominant allele (and thus displaying the dominant
phenotype). Assume that any two organisms can mate.
"""
import common
from math import factorial
sample_data = "2 2 2"
sample_output = "0.78333"
def prob(inp):
# k homozygous dominant (YY)
# m heterozygous (Yy)
# n homozygous recessive (yy)
k, m, n = [float(x) for x in inp.split(" ")]
N = k + m + n
Nm = N - 1.0
p = (k / N) # YY chosen first
p += (m / N) * (
(k / Nm) + (0.75 * (m - 1) / Nm) + (0.5 * (n / Nm))) # Yy first
p += (n / N) * ((k / Nm) + (0.5 * (m / Nm))) #yy first
return "%.5f" % p
common.test(prob, sample_data, sample_output)
common.runit(prob)
def counter_old(word):
"""brute-force way"""
counter = dict(A=0, C=0, G=0, T=0)
for w in word:
if w in alphabet: # error checking
counter[w] += 1
print counter["A"], counter["C"], counter["G"], counter["T"]
return "%s %s %s %s" % (counter["A"], counter["C"], counter["G"],
counter["T"])
def counter_good(word):
"""nice way"""
counter = dict((x, word.count(x)) for x in alphabet)
print counter["A"], counter["C"], counter["G"], counter["T"]
return "%s %s %s %s" % (counter["A"], counter["C"], counter["G"],
counter["T"])
def counter_fancy(word):
"""super nice way"""
from collections import Counter
counter = Counter(word)
print counter["A"], counter["C"], counter["G"], counter["T"]
return "%s %s %s %s" % (counter["A"], counter["C"], counter["G"],
counter["T"])
common.test(counter_old, sample_data, sample_output)
common.runit(counter_fancy)
d_word_index, results_path = common.get_word_index(args.model, args.glove, args.embedding_size)
# create tester
print("===> creating dataloaders ...")
val_loader = common.get_data_loader(args.model, 'test', d_word_index, args.batch_size, args.max_sentence_length,
pdtb_category=args.pdtb_category)
# load model,optimizer and loss
model, optimizer, criterion = common.get_model(model=args.model,
model_path=results_path,
lr=args.lr,
weight_decay=args.weight_decay,
pdtb_category=args.pdtb_category)
print(optimizer)
print(criterion)
if args.cuda:
torch.backends.cudnn.enabled = True
cudnn.benchmark = True
model.cuda()
criterion = criterion.cuda()
if args.model == 'grn16':
common.test_grn16(val_loader, model, criterion, args.cuda, args.print_freq)
elif args.model == 'keann':
common.test_keann(val_loader, model, criterion, args.cuda, args.print_freq)
elif args.model == 'keann_kg':
common.test_keann_kg(val_loader, model, criterion, args.cuda, args.print_freq)
else:
common.test(val_loader, model, criterion, args.cuda, args.print_freq)
def mnist_classifier_tanh():
# paths
path = dict()
path['project'] = os.path.dirname(os.path.abspath(__file__))
path['state'] = os.path.join(path['project'], 'epoch')
path['dataset'] = os.path.join(path['project'], 'dataset')
path['graph'] = os.path.join(path['project'], 'graph')
path['array'] = os.path.join(path['project'], 'array')
for key, value in path.items():
if not os.path.exists(path[key]):
os.mkdir(path[key])
# parameters
batch_size = 1000
number_of_epochs = 20
learning_rate = 1e-3
device = 'cuda' if torch.cuda.is_available() else 'cpu'
mean = 0.1307
std = 0.3081
loss = nn.CrossEntropyLoss()
train_info_per_batch = 6
validation_info_per_batch = 3
test_info_per_batch = 5
validation_ratio = 0.1
# transform
transform = torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(mean=(mean, ), std=(std, ))
])
# dataset
train_dataset = torchvision.datasets.MNIST(root=path['dataset'],
train=True,
transform=transform,
download=True)
test_dataset = torchvision.datasets.MNIST(root=path['dataset'],
train=False,
transform=transform,
download=True)
# validation dataset
validation_limit = int((1 - validation_ratio) * len(train_dataset))
index_list = list(range(len(train_dataset)))
train_indexes, validation_indexes = index_list[:
validation_limit], index_list[
validation_limit:]
train_sampler = SubsetRandomSampler(train_indexes)
validation_sampler = SequentialSampler(validation_indexes)
# dataset loaders
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
sampler=train_sampler)
validation_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
sampler=validation_sampler)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size)
# model
model = MnistClassifierTanh().to(device)
# optimizer
optimizer = optim.SGD(params=model.parameters(), lr=learning_rate)
epochs = np.arange(start=1, stop=(number_of_epochs + 1), step=1, dtype=int)
print('Mnist Classifier Tanh')
train_losses = []
train_accuracies = []
validation_losses = []
validation_accuracies = []
test_losses = []
test_accuracies = []
for epoch in epochs:
info = 'Epoch {epoch_index}/{number_of_epochs}'
print(info.format(epoch_index=epoch,
number_of_epochs=number_of_epochs))
# train
train_loss, train_accuracy = train(model=model,
device=device,
loader=train_loader,
optimizer=optimizer,
loss=loss,
info_per_batch=train_info_per_batch)
info = 'Train: Average Loss: {train_loss:.5f}, Accuracy: % {train_accuracy:.2f}'
print(
info.format(train_loss=train_loss,
train_accuracy=(100 * train_accuracy)))
train_losses.append(train_loss)
train_accuracies.append(train_accuracy)
# validation
validation_loss, validation_accuracy = test(
model=model,
loader=validation_loader,
device=device,
loss=loss,
info_per_batch=validation_info_per_batch,
info_name='Validation')
info = 'Validation: Average Loss: {validation_loss:.5f}, Accuracy: % {validation_accuracy:.2f}'
print(
info.format(validation_loss=validation_loss,
validation_accuracy=(100 * validation_accuracy)))
validation_losses.append(validation_loss)
validation_accuracies.append(validation_accuracy)
# test
test_loss, test_accuracy = test(model=model,
loader=test_loader,
device=device,
loss=loss,
info_per_batch=test_info_per_batch,
info_name='Test')
info = 'Test: Average Loss: {test_loss:.5f}, Accuracy: % {test_accuracy:.2f}'
print(
info.format(test_loss=test_loss,
test_accuracy=(100 * test_accuracy)))
test_losses.append(test_loss)
test_accuracies.append(test_accuracy)
# epoch state
state_file_name = 'mnist_classifier_tanh_epoch_{epoch_index}.pkl'.format(
epoch_index=epoch)
save_state(model=model,
directory=path['state'],
file_name=state_file_name)
# train loss
save_data(array=train_losses,
directory=path['array'],
file_name='mnist_classifier_tanh_train_loss.npy')
draw_line_graph(x=epochs,
y=train_losses,
x_label='Epoch',
y_label='Loss',
title='Mnist Classifier Tanh Train Loss',
directory=path['graph'],
file_name='mnist_classifier_tanh_train_loss.png')
# train accuracy
save_data(array=train_accuracies,
directory=path['array'],
file_name='mnist_classifier_tanh_train_accuracy.npy')
draw_line_graph(x=epochs,
y=train_accuracies,
x_label='Epoch',
y_label='Accuracy',
title='Mnist Classifier Tanh Train Accuracy',
directory=path['graph'],
file_name='mnist_classifier_tanh_train_accuracy.png')
# validation loss
save_data(array=validation_losses,
directory=path['array'],
file_name='mnist_classifier_tanh_validation_loss.npy')
draw_line_graph(x=epochs,
y=validation_losses,
x_label='Epoch',
y_label='Loss',
title='Mnist Classifier Tanh Validation Loss',
directory=path['graph'],
file_name='mnist_classifier_tanh_validation_loss.png')
# validation accuracy
save_data(array=validation_accuracies,
directory=path['array'],
file_name='mnist_classifier_tanh_validation_accuracy.npy')
draw_line_graph(x=epochs,
y=validation_accuracies,
x_label='Epoch',
y_label='Accuracy',
title='Mnist Classifier Tanh Validation Accuracy',
directory=path['graph'],
file_name='mnist_classifier_tanh_validation_accuracy.png')
# test loss
save_data(array=test_losses,
directory=path['array'],
file_name='mnist_classifier_tanh_test_loss.npy')
draw_line_graph(x=epochs,
y=test_losses,
x_label='Epoch',
y_label='Loss',
title='Mnist Classifier Tanh Test Loss',
directory=path['graph'],
file_name='mnist_classifier_tanh_test_loss.png')
# test accuracy
save_data(array=test_accuracies,
directory=path['array'],
file_name='mnist_classifier_tanh_test_accuracy.npy')
draw_line_graph(x=epochs,
y=test_accuracies,
x_label='Epoch',
y_label='Accuracy',
title='Mnist Classifier Tanh Test Accuracy',
directory=path['graph'],
file_name='mnist_classifier_tanh_test_accuracy.png')
# loss
draw_multi_lines_graph(lines=[
dict(label='Train', data=dict(x=epochs, y=train_losses)),
dict(label='Validation', data=dict(x=epochs, y=validation_losses)),
dict(label='Test', data=dict(x=epochs, y=test_losses))
],
x_label='Epoch',
y_label='Loss',
title='Mnist Classifier Tanh Loss',
directory=path['graph'],
file_name='mnist_classifier_tanh_loss.png')
# accuracy
draw_multi_lines_graph(lines=[
dict(label='Train', data=dict(x=epochs, y=train_accuracies)),
dict(label='Validation', data=dict(x=epochs, y=validation_accuracies)),
dict(label='Test', data=dict(x=epochs, y=test_accuracies))
],
x_label='Epoch',
y_label='Accuracy',
title='Mnist Classifier Tanh Accuracy',
directory=path['graph'],
file_name='mnist_classifier_tanh_accuracy.png')
# open the design YAML file and parse it into a dictionary for passing to raft
with open(fname_design) as file:
design = yaml.load(file, Loader=yaml.FullLoader)
design['potModMaster'] = 1
# grab the depth (currently needs to be passed separately)
depth = float(design['mooring']['water_depth'])
# set up frequency range for computing response over
w = np.arange(0.05, 5,
0.05) # frequency range (to be set by modeling options yaml)
# Create and run the model
model = raft.Model(design, w=w, depth=depth)
model.setEnv(spectrum="unit")
model.calcSystemProps()
model.solveEigen()
model.calcMooringAndOffsets()
model.solveDynamics()
results = model.calcOutputs()
print('-----------------')
testPass = test(prob, results)
print('Test ' + ('FAILED' if not testPass else 'PASSED'))
Return: The total number of rabbit pairs that will be present after n months if
we begin with 1 pair and in each generation, every pair of reproduction-age
rabbits produces a litter of k rabbit pairs (instead of only 1 pair).
"""
import common
sample_data = "5 3"
sample_output = "19"
# Formula: F_n = F_{n-1} + kF_{n-2}
def fib(inp):
n = int(inp.split()[0])
k = int(inp.split()[1])
return str(term(n, k))
def term(i, k):
if i == 1 or i == 2:
return 1
else:
return term(i - 1, k) + (k * term(i - 2, k))
common.test(fib, sample_data, sample_output)
common.runit(fib)
