def predict(input_path, output_path, resources_path):
"""
This is the skeleton of the prediction function.
The predict function will build your model, load the weights from the checkpoint and write a new file (output_path)
with your predictions in the BIES format.
The resources folder should contain everything you need to make the predictions. It is the "resources" folder in your submission.
N.B. DO NOT HARD CODE PATHS IN HERE. Use resource_path instead, otherwise we will not be able to run the code.
:param input_path: the path of the input file to predict.
:param output_path: the path of the output file (where you save your predictions)
:param resources_path: the path of the resources folder containing your model and stuff you might need.
:return: None
"""
model = load_model(resources_path + '/model.h5')
model.summary()
dictionary = load(resources_path + 'dictionary')
word2id = dictionary['word2id']
id2label = dictionary['id2label']
X_chinese, y, characters, sizes = file2BIES(input_path)
# Process X
X_processed = processX(X_chinese, word2id, sentence_size=626)
y_pred = model.predict(X_processed)
prediction = []
arg = np.argmax(y_pred, axis=2)
for i in range(len(arg)):
sentence = arg[i]
labels = []
num_char = np.count_nonzero(X_processed[i])
for char in sentence[0:num_char]:
labels.append(id2label[char])
prediction.append(labels)
score(prediction, y, verbose=True)
# Write prediction file
filename, extension = os.path.splitext(output_path)
with open(filename + '_prediction' + extension, "w+") as f:
for line in prediction:
f.write(''.join(str(e) for e in line))
f.write('\n')
# Write gold file
with open(output_path, "w+") as f:
for line in y:
f.write(''.join(str(e) for e in line))
f.write('\n')
pass
def main():
part2xy = load_dataset_fast('FILIMDB')
train_ids, train_texts, train_labels = part2xy['train']
print('\nTraining classifier on %d examples from train set ...' %
len(train_texts))
st = time()
params = train(train_texts, train_labels)
print('Classifier trained in %.2fs' % (time() - st))
allpreds = []
for part, (ids, x, y) in part2xy.items():
print('\nClassifying %s set with %d examples ...' % (part, len(x)))
st = time()
preds = classify(x, params)
print('%s set classified in %.2fs' % (part, time() - st))
allpreds.extend(zip(ids, preds))
if y is None:
print('no labels for %s set' % part)
else:
score(preds, y)
save_preds(allpreds, preds_fname=PREDS_FNAME)
print('\nChecking saved predictions ...')
score_preds(preds_fname=PREDS_FNAME)
def setup_game():
global gs
gs.update()
gs.snacks.clear()
gs.snake1 = snake.snake(gs, 1)
gs.snake1.setGS(gs)
if gs.obstacles_on:
for _ in range(5):
gs.obstacles.append(cube.cube(gs, random_obstacle(), color=gs.color.grey))
gs.surface = pygame.display.set_mode((gs.width, gs.width + gs.banner_height))
if gs.mode == "race" or gs.mode == "melee":
gs.snake2 = snake.snake(gs, 2)
gs.snake2.setGS(gs)
gs.scr = score.score(gs, True)
else:
gs.scr = score.score(gs, False)
if gs.mode == "melee":
gs.snake1.grow = True
if gs.snake2:
gs.snake2.grow = True
if gs.borders_on:
for x in range(gs.rows):
for y in range(gs.rows):
if x == 0 or y == 0 or y == gs.rows-1 or x == gs.rows-1:
gs.obstacles.append(cube.cube(gs, (x,y), color=gs.color.grey))
if gs.mode != "melee":
for i in range(gs.fruit_count):
gs.snacks.append(cube.cube(gs, random_snack(), color=gs.color.green))
def test_enro(self):
os.chdir('models/en-ro/')
score(['model.npz'], open('../../en-ro/in'),
open('../../en-ro/references'), open('../../en-ro/out_score',
'w'), normalization_alpha)
os.chdir('../..')
self.scoreEqual('en-ro/ref_score', 'en-ro/out_score')
def main():
init(autoreset = True)
print Fore.GREEN + '============================================'
print Fore.GREEN + ' Auto-Score by Soxfmr '
print Fore.GREEN + ' ver 0.2 20151128 '
print Fore.GREEN + '============================================'
try:
username = require('Sutdent Id: ')
password = require('Password: '******'Do you want to ignore the marked record')
settings.IGNORE_ALREADY_SCORED = ignore
if username == '' or password == '':
raise Exception('Invalid input value.')
# Retrieve the user session
log('Preparing the user session...')
session = login(username, password)
# Begin
log(Fore.GREEN + 'Session established. Getting start to marking...')
score(session)
log(Fore.GREEN + 'All done! Now you should login to the education system and confirm all of record!', important = True)
except Exception as e:
print Fore.RED + e.message
def run():
from repeats import repeats
from score import score
from clean import clean
from match import match
from merge import merge
from id_gen import id_gen
import pandas as pd
'''
This is the new (Summer 2019) implementation of scoring, matching, and merging
'''
year = "19"
season = "Sp"
mergeName = 'QuaRCSLt2_' + season + year + '_merged.csv'
PREdata = 'QuaRCSLt2_S19_PRE.csv'
PSTdata = PREdata[:-7] + "POST.csv"
stu_DB_name = "Student_ID_Database.csv"
instr_DB_name = "Instr_ID_Database.csv"
print("Scoring...")
# Score PRE and PST
PREdata = score(PREdata, 'PRE', year, season, 'answ.csv', PREdata[:-4])
PSTdata = score(PSTdata, 'PST', year, season, 'answ.csv', PSTdata[:-4])
# Clean PRE and PST
#PREdata = PREdata[:-4] + "_scored.csv"
#PSTdata = PSTdata[:-4] + "_scored.csv"
print("Cleaning...")
PREdata = clean(PREdata, 'PRE')
PSTdata = clean(PSTdata, 'PST')
# Generate IDs for PRE and PST
# PREdata = PREdata[:-4] + "_cleaned.csv"
# PSTdata = PSTdata[:-4] + "_cleaned.csv"
print("Generating student and instructor IDs...")
PREdata = id_gen(PREdata, 'PRE', year, season, stu_DB_name, instr_DB_name)
PSTdata = id_gen(PSTdata, 'PST', year, season, stu_DB_name, instr_DB_name)
# Split Repeats
print("Splitting...")
PREdata = repeats(PREdata, 'PRE')
PSTdata = repeats(PSTdata, 'PST')
# Match
# PREdata = PREdata[:-4] + "_id.csv"
# PSTdata = PSTdata[:-4] + "_id.csv"
#PREdata = pd.read_csv(PREdata)
#PSTdata = pd.read_csv(PSTdata)
print("Matching...")
PRE_not_matched, PST_not_matched, pairs, instructor_change = match(
PREdata, PSTdata)
# Merge
print("Merging...")
mergedData = merge(PRE_not_matched, PST_not_matched, PREdata, PSTdata,
pairs)
mergedData.to_csv(mergeName, encoding='utf-8', index=False)
print("Merged dataset saved to {0}".format(mergeName))
def main(rectlist):
tracing_and_stencil = tracing(rectlist)
stencil = tracing_and_stencil[0]
trace = tracing_and_stencil[1]
stencil_length = len(stencil) #stencil length
trace_length = len(trace) #trace length
if trace_length >= stencil_length:
length_diff = trace_length - stencil_length
temp_lendiff = length_diff
while temp_lendiff != 0:
index = random.randint(0, (len(trace) - 1))
del (trace[index])
temp_lendiff -= 1
elif stencil_length > trace_length and trace_length != 0:
length_diff = stencil_length - trace_length
temp_lendiff = length_diff
while temp_lendiff != 0:
index = random.randint(0, (len(stencil) - 1))
del (stencil[index])
temp_lendiff -= 1
else:
userScore = 0
f = open("userscores.txt", "a")
f.write(str(userScore))
f.write("\n")
f.close()
return str(int(score.score(trace, stencil))) + '%'
userScore = score.score(trace, stencil)
f = open("userscores.txt", "a")
f.write(str(userScore))
f.write("\n")
f.close()
return str(int(score.score(trace, stencil))) + '%'
def banner():
while True:
print "1. Press 1 for running the tokenizer usually"
print "2. Press 2 for creating the inverted index"
print "3. Press 3 for creating the vectors for the documents"
print "4. Press any other number to search"
choice = int(raw_input("$ "))
if not os.path.exists(TEXT):
print "No Data at All. No Valid Corpus. Please add something to\n" + str(TEXT)
if not os.path.exists(DATA_PATH):
print "No Data Existed, Path Created"
os.mkdir(DATA)
if not os.path.exists(TOKENS) or choice == 1:
print "Creating tokens as they don't exist/You Chose To"
os.mkdir(TOKENS)
tokenizer()
if not os.path.exists(INDICES) or choice == 2:
print "Creating indices as they don't exist"
os.mkdir(INDICES)
counter()
if not os.path.exists(SCORES) or choice == 3:
print "Creating Vectors as they don't exist"
os.mkdir(SCORES)
score()
mod()
if choice > 3 or choice == 0:
print "Search begins"
break
def main():
init(autoreset=True)
print Fore.GREEN + '============================================'
print Fore.GREEN + ' Auto-Score by Soxfmr '
print Fore.GREEN + ' ver 0.2 20151128 '
print Fore.GREEN + '============================================'
try:
username = require('Sutdent Id: ')
password = require('Password: '******'Do you want to ignore the marked record')
settings.IGNORE_ALREADY_SCORED = ignore
if username == '' or password == '':
raise Exception('Invalid input value.')
# Retrieve the user session
log('Preparing the user session...')
session = login(username, password)
# Begin
log(Fore.GREEN + 'Session established. Getting start to marking...')
score(session)
log(Fore.GREEN +
'All done! Now you should login to the education system and confirm all of record!',
important=True)
except Exception as e:
print Fore.RED + e.message
def test_ende(self):
scorer_settings = self.get_settings()
os.chdir('models/en-de/')
score(open('../../en-de/in'), open('../../en-de/references'),
open('../../en-de/out_score', 'w'), scorer_settings)
os.chdir('../..')
self.scoreEqual('en-de/ref_score', 'en-de/out_score')
def simann(firstsol, V, E, R, C, X, sizes, latencies, cache_latencies, requests):
Y = 3
N = 100
best_score = score(latencies, cache_latencies, requests, firstsol)
def cache_size(cache):
return sum([v for v in sizes if v in cache])
def find_cache(videoid):
for i, x in enumerate(caches):
if videoid in x:
return i
return -1
def remove_from_cache(videoid):
idx = find_cache(videoid)
if idx >= 0:
caches[idx].remove(videoid)
l_sizes[idx] -= sizes[videoid]
def move_to_cache(videoid, cacheid):
size = l_sizes[cacheid]
if sizes[videoid] + size > X:
return False
else:
remove_from_cache(videoid)
caches[cacheid].add(videoid)
l_sizes[cacheid] += sizes[videoid]
return True
l_sizes = [cache_size(x) for x in firstsol]
best_sol = [set(x) for x in firstsol]
for i in range(Y):
caches = [set(x) for x in firstsol]
for j in range(N):
print >> sys.stderr, j
prevsol = [set(x) for x in caches]
rv = randint(0, V-1)
for x in range(10):
rc = randint(0, C-1)
if move_to_cache(rv, rc):
break
curr_score = score(latencies, cache_latencies, requests, caches)
if curr_score > best_score:
best_sol = [set(x) for x in caches]
best_score = curr_score
else:
if random() < (float(j) / float(N)):
caches = prevsol
return best_sol
def __init__(self, data, targets, cv_data, cv_targets, extra, layers, epochs=1, smoothing=1, new=True, filename_in=False):
if len(cv_data) != len(cv_targets): raise Exception("Number of CV data and CV targets must be equal")
if len(data) != len(targets): raise Exception("Number of data and targets must be equal")
if new:
class_tr_targets = [str(int(t[0]) - 1) for t in targets] # for pybrain's classification datset
print "...training the DNNRegressor"
if len(layers) > 2: # TODO testing only
net = DNNRegressor(data, extra, class_tr_targets, layers, hidden_layer="TanhLayer", final_layer="SoftmaxLayer", compression_epochs=epochs, bias=True, autoencoding_only=False)
print "...running net.fit()"
net = net.fit()
elif len(layers) == 2:
net = buildNetwork(layers[0], layers[-1], outclass=SoftmaxLayer, bias=True)
ds = ClassificationDataSet(len(data[0]), 1, nb_classes=9)
bag = 1
noisy, _ = self.dropout(data, noise=0.0, bag=bag, debug=True)
bagged_targets = []
for t in class_tr_targets:
for b in range(bag):
bagged_targets.append(t)
for i,d in enumerate(noisy):
t = bagged_targets[i]
ds.addSample(d, t)
ds._convertToOneOfMany()
print "...smoothing for epochs: ", smoothing
self.model = net
preds = [self.predict(d) for d in cv_data]
cv = score(preds, cv_targets, debug=False)
preds = [self.predict(d) for d in data]
tr = score(preds, targets, debug=False)
trainer = BackpropTrainer(net, ds, verbose=True, learningrate=0.0008, momentum=0.04, weightdecay=0.05) # best score 0.398 after 50 compression epochs and 200 epochs with lr=0.0008, weightdecay=0.05, momentum=0.04. Used dropout of 0.2 in compression, 0.5 in softmax pretraining, and no dropout in smoothing.
print "Train score before training: ", tr
print "CV score before training: ", cv
for i in range(smoothing):
trainer.train()
self.model = net
preds = [self.predict(d) for d in cv_data]
cv = score(preds, cv_targets, debug=False)
preds = [self.predict(d) for d in data]
tr = score(preds, targets, debug=False)
print "Train/CV score at epoch ", (i+1), ': ', tr, '/', cv
#if i == 1:
#print "...saving the model"
#save("data/1000_ex_4_hidden/net_epoch_1.txt", net)
#elif i == 3:
#print "...saving the model"
#save("data/1000_ex_4_hidden/net_epoch_3.txt", net)
#elif i == 5:
#print "...saving the model"
#save("data/1000_ex_4_hidden/net_epoch_5.txt", net)
print "...saving the model"
#save("data/1000_ex_4_hidden/net_epoch_10.txt", net)
else:
model = load(filename_in)
self.model = model
def test_enro(self):
os.chdir('models/en-ro/')
score(['model.npz'], open('../../en-ro/in'),
open('../../en-ro/references'), open('../../en-ro/out_score',
'w'))
os.chdir('../..')
self.assertEqual(
open('en-ro/ref_score').read(),
open('en-ro/out_score').read())
def main():
load_cluster_countries__file()
if (mode == "train"):
train_data = build_sentences(modes[mode]['data'])
write_feature_file(train_data, modes[mode]['features'])
train_tagger()
if (mode == 'dev' or mode == 'test'):
tag_words(modes[mode]['data'])
score(modes[mode]['key'], modes[mode]['output'])
def decode_hex(inputStr):
bestStr = ""
bestScore = 0
thisStr = xor_repeating_key(inputStr)
if score(thisStr) > bestScore:
bestScore = score(thisStr)
bestStr = thisStr
return "Plaintext: {}".format(bestStr)
def test_ende(self):
os.chdir('models/en-de/')
score(['model.npz'],
open('../../en-de/in'),
open('../../en-de/references'),
open('../../en-de/out_score', 'w'),
normalize=True)
os.chdir('../..')
self.assertEqual(
open('en-de/ref_score').read(),
open('en-de/out_score').read())
def decode_hex(inputStr):
bestStr = ""
bestScore = 0
# bruteforce all possible values
for i in range(1, 256):
thisStr = xor_single_char_key(inputStr.decode("hex"), chr(i))
if score(thisStr) > bestScore:
bestScore = score(thisStr)
bestStr = thisStr
return "Plaintext: {}".format(bestStr)
def test_ende(self):
os.chdir('models/en-de/')
with open('../../en-de/in', 'r', encoding='utf-8') as in_file, \
open('../../en-de/references', 'r', encoding='utf-8') as ref_file, \
open('../../en-de/out_score', 'w', encoding='utf-8') as score_file:
settings = ScorerSettings()
settings.models = ['model.npz']
settings.minibatch_size = 80
settings.normalization_alpha = 1.0
score(in_file, ref_file, score_file, settings)
os.chdir('../..')
self.scoreEqual('en-de/ref_score', 'en-de/out_score')
def decode_hex():
bestStr = ""
bestScore = 0
with (open(sys.argv[1], "r")) as f:
for i in f:
for j in range(1, 256):
thisStr = xor_single_char_key(i.strip().decode("hex"), chr(j))
if score(thisStr) > bestScore:
bestScore = score(thisStr)
bestStr = thisStr
return "Plaintext: {}".format(bestStr)
def main(transductive: bool = False):
try:
from classifier import pretrain
except ImportError:
part2xy = load_dataset_fast('FILIMDB', parts=SCORED_PARTS)
train_ids, train_texts, train_labels = part2xy['train']
print('\nTraining classifier on %d examples from train set ...' %
len(train_texts))
st = time()
params = train(train_texts, train_labels)
print('Classifier trained in %.2fs' % (time() - st))
else:
part2xy = load_dataset_fast('FILIMDB',
parts=SCORED_PARTS + ('train_unlabeled', ))
train_ids, train_texts, train_labels = part2xy['train']
_, train_unlabeled_texts, _ = part2xy['train_unlabeled']
st = time()
if transductive:
all_texts = list(text for _, text, _ in part2xy.values())
else:
all_texts = [train_texts, train_unlabeled_texts]
total_texts = sum(len(text) for text in all_texts)
print('\nPretraining classifier on %d examples' % total_texts)
params = pretrain(all_texts)
print('Classifier pretrained in %.2fs' % (time() - st))
print('\nTraining classifier on %d examples from train set ...' %
len(train_texts))
st = time()
params = train(train_texts, train_labels, params)
print('Classifier trained in %.2fs' % (time() - st))
del part2xy["train_unlabeled"]
allpreds = []
for part, (ids, x, y) in part2xy.items():
print('\nClassifying %s set with %d examples ...' % (part, len(x)))
st = time()
preds = classify(x, params)
print('%s set classified in %.2fs' % (part, time() - st))
allpreds.extend(zip(ids, preds))
if y is None:
print('no labels for %s set' % part)
else:
score(preds, y)
save_preds(allpreds, preds_fname=PREDS_FNAME)
print('\nChecking saved predictions ...')
score_preds(preds_fname=PREDS_FNAME, data_dir='FILIMDB')
async def load_score(title):
import asyncio
from rank.util import purge
from rank.collect.movie import get_comments
loop = asyncio.get_event_loop()
data = get_comments(title.strip())
lines = ["| {0}".format(purge(comment)) for comment in data]
logger.debug("Got comments")
create = asyncio.create_subprocess_exec("vw", "-c", "-k", "-t", "-i", "data/raw.vw", "-p", "/dev/stdout", "--quiet",
stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE)
logger.debug("Creating classifier")
proc = await create
proc.stdin.write("\n".join(lines).encode("UTF-8"))
await proc.stdin.drain()
proc.stdin.close()
result = await proc.stdout.read()
await proc.wait()
from score import score, parse_num
logger.debug("Calculating score")
ratings = [parse_num(line) for line in result.decode("UTF-8").split("\n")]
for r, c in zip(ratings, data):
logger.debug("Rating: {0}, Comment: {1}".format(r, c))
mean = score(ratings[:-1], base=10)
return True, str(mean)
def initStatScreen(self):
self.times = []
self.pointsPerQuestionn = []
self.scorePerGame = []
self.timePerGame = []
self.gameCategories = []
self.gameDifficulties = []
self.totalQuestions = 0
self.totalGames = 0
self.correct = 0
self.incorrect = 0
statScore = score()
for i in range(len(self.rows)):
#print(self.rows[i][0])
if (self.rows[i][0] == '~' or self.rows[i][0] == '~'
) and self.rows[i + 12][0] != "DNF": # coding=utf-8
self.totalGames = self.totalGames + 1
for j in range(10):
self.times.append(float(self.rows[(i + 2) + j][1]))
self.pointsPerQuestionn.append(
float(
statScore.calculateScore(
int(self.rows[(i + 2) + j][0]),
float(self.rows[(i + 2) + j][1]))))
self.totalQuestions = self.totalQuestions + 1
if int(self.rows[(i + 2) + j][0]) == 1:
self.correct = self.correct + 1
if int(self.rows[(i + 2) + j][0]) == 0:
self.incorrect = self.incorrect + 1
self.scorePerGame.append(int(self.rows[(i + 12)][0]))
self.timePerGame.append(float(self.rows[(i + 12)][1]))
self.gameCategories.append(int(self.rows[(i + 1)][0]))
self.gameDifficulties.append(int(self.rows[(i + 1)][1]))
def __init__(self,width,height):
pygame.init()
self.width = 600
self.height = 600
self.screen = pygame.display.set_mode((600,600))
self.background = pygame.Surface(screen.get_size())
self.ground = background.convert()
self.mixinit = pygame.mixer.pre_init()
self.ship = nimbus.ship(100.0,100.0,90)
self.asteroid aster.asteriod(100,100,90)
self.backfill = background.fill((0,0,0))
self.white = (250, 250,250)
self.screenblit = screen.blit(background,(0,0))
self.laser = laser.bullet
self.mixload = pygame.mixer.music.load('betsky.ogg')
self.mixplay = pygame.mixer.music.play(loops = 15, start = 0.0)
self.player = score.score()
self.flip = pygame.display.flip()
self.allsprites = pygame.sprite.Group((aster))
self.shp = pygame.sprite.Group((nimbus,laser))
self.clock = pygame.time.Clock()
self.keyset = pygame.key.set_repeat(1,10)
self.start_screen = True
self.
self.
self.
self.
self.
self.
self.
self.
self.
self.
def main():
testfarm = Farm((0, 0))
senone = Sensor((44.790300, -92.931998))
sentwo = Sensor((44.790300, -92.931998))
senthree = Sensor((44.790300, -92.931998))
testfarm.add_sensor(senone)
testfarm.add_sensor(sentwo)
testfarm.add_sensor(senthree)
testfarm.pull_current()
testfarm.pull_forecast()
print("\n\n\nRandomized Example Sensor Data")
print("------------------------------")
i = 0
while i < len(testfarm.sensors):
print("sensor " + str(i + 1))
print(testfarm.sensors[i].point)
i += 1
print("\n\n\nExample Aggregate Scores")
print("------------------------")
box = score.score(testfarm, senone.point, senone)
list = []
for datapoints in testfarm.future_forecast:
box = score.aggregateScore(testfarm, datapoints, senone)
list.append(box)
print(list)
def test_imagenet_model(model_name, val_data, gpus, batch_size):
"""test model on imagenet """
logging.info('test %s', model_name)
meta_info = get_model_meta_info(model_name)
[model_name, mean] = convert_caffe_model(model_name, meta_info)
sym, arg_params, aux_params = mx.model.load_checkpoint(model_name, 0)
acc = [mx.metric.create('acc'), mx.metric.create('top_k_accuracy', top_k=5)]
if isinstance(mean, str):
mean_args = {'mean_img':mean}
else:
mean_args = {'rgb_mean':','.join([str(i) for i in mean])}
print(val_data)
(speed,) = score(model=(sym, arg_params, aux_params),
data_val=val_data,
label_name='prob_label',
metrics=acc,
gpus=gpus,
batch_size=batch_size,
max_num_examples=500,
**mean_args)
logging.info('speed : %f image/sec', speed)
for a in acc:
logging.info(a.get())
assert acc[0].get()[1] > meta_info['top-1-acc'] - 0.3
assert acc[1].get()[1] > meta_info['top-5-acc'] - 0.3
def main():
parser = argparse.ArgumentParser(description="Solves camera placing problem")
parser.add_argument("input", help="Path to problem input file", type=str)
args = parser.parse_args()
radius = []
cost = []
points = []
with open(args.input) as f:
for i, line in enumerate(f):
if i == 0:
radius = list(map(lambda x: int(x) - 0.01, line.split(',')))
elif i == 1:
cost = list(map(int, line.split(',')))
else:
x, y = list(map(int, line.split(',')))
points.append((x, y))
start = time()
solution = solve(radius, cost, points)
end = time()
print("solution score:", score(cost, solution), file=sys.stderr)
print("time:", "{:.2f}s".format(end-start), file=sys.stderr)
for c, x, y in solution:
print("{:d},{:.2f},{:.2f}".format(c, x, y))
def submittted():
form_data = request.form
print 'form submitted, data in form:'
print form_data
stochastic = (form_data['stochastic'] == "true")
scores = score.score()
simvalues = playgame.playgame(os.getcwd(), stochastic,
float(form_data['param1']),
float(form_data['param2']))
print 'scores:' + str(scores)
print 'simvalues:' + str(simvalues)
try:
trace2x = score.convert_to_integers(scores[0][0])
trace2y = score.convert_to_integers(scores[0][1])
except:
trace2x = [1]
trace2y = [1]
trace1x = score.convert_to_integers(scores[1][0])
trace1y = score.convert_to_integers(scores[1][1])
trace3x = score.convert_to_integers(simvalues[0])
trace3y = score.convert_to_integers(simvalues[1])
trace4x = score.convert_to_integers(simvalues[0])
trace4y = score.convert_to_integers(simvalues[2])
return render_template("hello.html",
trace1x=trace1x,
trace1y=trace1y,
trace2x=trace2x,
trace2y=trace2y,
trace3x=trace3x,
trace3y=trace3y,
trace4x=trace4x,
trace4y=trace4y)
def scores(board=None,
comp_words=None,
comp_score=None,
user_words=None,
user_score=None):
board = session['board']
comp_words = session['comp_words']
user_words = session['user_words']
comp_score = score(comp_words, word_score)
user_score = score(user_words, word_score)
return render_template('scores.html',
board=board,
comp_words=comp_words,
comp_score=comp_score,
user_words=user_words,
user_score=user_score)
def main():
try:
arg1 = sys.argv[1]
except:
arg1 = 'help'
if arg1 == 'help':
contact_help()
else:
try:
arg2 = sys.argv[2]
except:
print "You must provide a valid argument. See help for details"
return
if arg2 not in 'print' and \
arg2 not in 'scores' and \
arg2 not in 'highest':
print "You must provide an argument. See help for details"
return
dic = file_to_dict(arg1)
if arg2 == 'print':
dic.print_dict()
elif arg2 == 'score':
pprint(score(dic))
elif arg2 == 'highest':
word = highest_score(dic)
print "The highest scoring word is..."
print word['word'], word['score']
else:
print "See help for options"
def play_game(self):
hand_num = 1
d = Deal()
d.commit_deal() # ignoring return for now
self.p1.new_hand(d.human_hand())
self.p2.new_hand(d.computer_hand())
start = d.start_card()
p1_deals = d.human_is_dealer()
while max(self.p1_score, self.p2_score) < 121:
print("Hand # {} Starting new hand p1 score = {} p2 score = {}".format(hand_num, self.p1_score,
self.p2_score))
hand_num += 1
if p1_deals:
print("Player 1 deals")
else:
print("Player 2 deals")
crib = self.p1.discard_cards() + self.p2.discard_cards()
crib_score = score(crib, start, is_crib=True)
hand1_score = score(self.p1.hand, start)
hand2_score = score(self.p2.hand, start)
print("Start {}\nP1 hand {} score {}\nP2 hand {} score {}\ncrib {} score {}.\n".format(card_names(
[start]), card_names(self.p1.hand), hand1_score, card_names(self.p2.hand), hand2_score,
card_names(crib), crib_score))
if p1_deals:
self.p2_score += hand2_score
if self.p2_score > 120:
print("P2 wins. Final score: {}-{}\n".format(self.p1_score, self.p2_score))
break
self.p1_score += hand1_score + crib_score
if self.p1_score > 120:
print("P1 wins. Final score: {}-{}\n".format(self.p1_score, self.p2_score))
break
else:
self.p1_score += hand1_score
if self.p1_score > 120:
print("P1 wins. Final score: {}-{}\n".format(self.p1_score, self.p2_score))
break
self.p2_score += hand2_score + crib_score
if self.p2_score > 120:
print("P2 wins. Final score: {}-{}\n".format(self.p1_score, self.p2_score))
break
d = Deal()
d.commit_deal() # ignoring return for now
self.p1.new_hand(d.human_hand())
self.p2.new_hand(d.computer_hand())
start = d.start_card()
p1_deals = not p1_deals
def xiaoqi(name, merge_file):
fff = if_has_flag(merge_file)
if fff == 0:
json2csv_operate_neo4j_add_time.main(merge_file, name)
return '文件不需要消歧'
dictionary = read_file(merge_file) #把文件读到字典中
change_flag(dictionary)
merge_change = copy.deepcopy(dictionary)
add_delete_flag(dictionary)
del_value(dictionary)
#字典最多四层，删除四次
#for i in range(4):
# del_empty_array(dictionary)
delete_json = copy.deepcopy(dictionary)
#disambiguate
xiaoqi_list = find_same_flag(delete_json, name)
write_keywords_to_file(xiaoqi_list)
# 判断是否有keywords文件 有就删除
if os.path.exists('spider1/keywords.txt'):
os.remove('spider1/keywords.txt')
shutil.move('keywords.txt', 'spider1') #把关键字移动到爬虫目录
os.chdir('/home/chenxl/data_mining_resume/spider1') # 进入爬虫目录
# 如果有items.json就删除
if os.path.exists('items.json'):
os.remove('items.json')
os.system(r"scrapy crawl spider1 -o items.json") #运行爬虫
# 保存爬虫结果
with open('items.json', 'r', encoding='utf-8') as f:
data = json.load(f)
os.remove('keywords.txt')
os.remove('items.json')
os.chdir('../')
sco, disambiguate = score.score(data)
#generate_resume1 有分数
merge_change2 = copy.deepcopy(merge_change)
add_score(sco, merge_change)
monitorItems = merge_dict(merge_change)
loop_dict(monitorItems)
xiaoqi_json = json.dumps(monitorItems, ensure_ascii=False, indent=4)
path = 'static/xiaoqi_json/reserve_score/' + name + '.json'
with open(path, 'w', encoding='utf-8') as file:
json.dump(monitorItems, file, ensure_ascii=False, indent=4)
print("success")
#generate_resume2 没分数
disambiguate_id_list = record_id(disambiguate)
find_flag(disambiguate_id_list, merge_change2)
delete_flag(merge_change2)
monitorItems = merge_dict(merge_change2)
loop_dict(monitorItems)
xiaoqi_json = json.dumps(monitorItems, ensure_ascii=False, indent=4)
path = 'static/xiaoqi_json/no_score/' + name + '.json'
with open(path, 'w', encoding='utf-8') as file:
json.dump(monitorItems, file, ensure_ascii=False, indent=4)
print("success")
neo4j_no_batch_import.main(xiaoqi_json, name)
return xiaoqi_json
def test_imagenet1k_inception_bn(**kwargs):
acc = mx.metric.create("acc")
m = "imagenet1k-inception-bn"
g = 0.72
(speed,) = score(model=m, data_val="data/val-5k-256.rec", rgb_mean="123.68,116.779,103.939", metrics=acc, **kwargs)
r = acc.get()[1]
print("Tested %s acc = %f, speed = %f img/sec" % (m, r, speed))
assert r > g and r < g + 0.1
def main():
try:
from classifier import pretrain
except ImportError:
part2xy = load_dataset_fast('FILIMDB')
train_ids, train_texts, train_labels = part2xy['train']
print('\nTraining classifier on %d examples from train set ...' %
len(train_texts))
st = time()
params = train(train_texts, train_labels)
print('Classifier trained in %.2fs' % (time() - st))
else:
part2xy = load_dataset_fast('FILIMDB',
parts=('train', 'dev', 'test',
'train_unlabeled'))
train_ids, train_texts, train_labels = part2xy['train']
_, train_unlabeled_texts, _ = part2xy['train_unlabeled']
all_texts = train_texts + train_unlabeled_texts
print('\nPretraining classifier on %d examples' % len(all_texts))
st = time()
params = pretrain(all_texts)
print('Classifier pretrained in %.2fs' % (time() - st))
print('\nTraining classifier on %d examples from train set ...' %
len(train_texts))
st = time()
params = train(train_texts, train_labels, params)
print('Classifier trained in %.2fs' % (time() - st))
del part2xy["train_unlabeled"]
allpreds = []
for part, (ids, x, y) in part2xy.items():
print('\nClassifying %s set with %d examples ...' % (part, len(x)))
st = time()
preds = classify(x, params)
print('%s set classified in %.2fs' % (part, time() - st))
allpreds.extend(zip(ids, preds))
if y is None:
print('no labels for %s set' % part)
else:
score(preds, y)
save_preds(allpreds, preds_fname=PREDS_FNAME)
print('\nChecking saved predictions ...')
score_preds(preds_fname=PREDS_FNAME, data_dir='FILIMDB')
def all_matches(s, template):
s = s.upper()
results = list()
for partition in partitions(list(s)):
results.extend(template.match([''.join(part) for part in partition]))
results = list(set(results))
results.sort(key=lambda x: -score(x))
return results
def score_cards(h: str, s: str, crib: bool = False) -> int:
"""score_cards adds up the points for a four-card hand represented as a comma-separated string
and a single start card. The crib Boolean value only affects if flushes of four cards, i.e.,
the hand has all one suit and the started card is another, counts for 4 points (yes for hand,
no for crib)
"""
return score.score([_card_number(c) for c in h.split(',')],
_card_number(s), crib)
def update_score(self, roll):
dice_count = {}
for dice in self.dices:
if dice.strip("D") in roll:
dice_count[self.dices[dice].get_dice()] = dice_count.get(
self.dices[dice].get_dice(), 0) + 1
self.hand_score += score.score(dice_count, True)
return self.hand_score
def test_imagenet1k_resnet(**kwargs):
models = ["imagenet1k-resnet-34", "imagenet1k-resnet-50", "imagenet1k-resnet-101", "imagenet1k-resnet-152"]
accs = [0.72, 0.75, 0.765, 0.76]
for (m, g) in zip(models, accs):
acc = mx.metric.create("acc")
(speed,) = score(model=m, data_val="data/val-5k-256.rec", rgb_mean="0,0,0", metrics=acc, **kwargs)
r = acc.get()[1]
print("testing %s, acc = %f, speed = %f img/sec" % (m, r, speed))
assert r > g and r < g + 0.1
def open_sub_section(self):
if self.position_fire==245:
self.root.destroy()
jeu.jeu(self.email)
elif self.position_fire==310:
self.root.destroy()
import rules as ru
ru.rules(self.email)
elif self.position_fire==375:
self.root.destroy()
import score as sc
sc.score(self.email)
elif self.position_fire==440:
self.root.destroy()
import credit as cd
cd.credit(self.email)
elif self.position_fire==505:
self.root.destroy()
def test_imagenet1k_inception_bn(**kwargs):
acc = mx.metric.create('acc')
m = 'imagenet1k-inception-bn'
g = 0.75
(speed,) = score(model=m,
data_val=VAL_DATA,
rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs)
r = acc.get()[1]
print('Tested %s acc = %f, speed = %f img/sec' % (m, r, speed))
assert r > g and r < g + .1
def test_imagenet1k_inception_bn(args):
acc = mx.metric.create('acc')
m = 'imagenet1k-inception-bn'
g = 0.72
(speed,) = score(model=m,
data_val='data/val-5k-256.rec',
rgb_mean='123.68,116.779,103.939', metrics=acc, **vars(args))
r = acc.get()[1]
print 'Tested %s acc = %f, speed = %f img/sec' % (m, r, speed)
assert r > g and r < g + .1
def solve_single_key(string):
min_score = float('+inf')
plaintext = ""
for i in range(0,255):
p = bytes(map(lambda c: i ^ c, string))
s = score.score(p)
if s < min_score:
min_score = s
plaintext = p
return plaintext
def try_decrypt(string):
min_score = float('+inf')
plaintext = b''
for i in range(0,255):
p = bytes(map(lambda c: i ^ c, string))
s = score.score(p)
if s < min_score:
min_score = s
plaintext = p
return (min_score, plaintext)
def __init__(self, scrn):
Level.new_game()
self.levels = [
#width #mines #mobs
#height #coins #view
Level( 2, 2, 0,{1: 1}),
Level( 5, 5, 4,{1: 4}),
Level( 4, 4, 4,{1: 1}),
Level( 5, 5, 4,{1: 4}),
Level( 6, 6, 6,{1: 4}, life = 1),
Level( 5, 15, 10,{1: 5}, 0, [ 0, 8]),
Level( 5, 5, 7,{1: 5}, 1),
Level( 7, 7, 20,{1: 2}, 2),
Level( 8, 8, 5,{1:10}, portals = 1),
Level( 11, 11, 30,{1:12,5: 2}, 1, portals = 1),
Level( 5, 15, 20,{1: 5,5: 3}, 3, [ 0, 8], life = 1),
Level( 12, 12, 40,{1: 5,5: 3}, 2, [ 8, 8], 1),
Level( 15, 15, 40,{1: 4,5: 6}, 1, [10, 6]),
Level( 15, 15, 80,{1: 5,5: 3}, 5, [10,10], 4),
Level( 15, 15,150,{10: 1}, 1),
Level( 20, 20,350,{20: 1}, 0, [ 4, 4], life = 2),
Level( 15, 15,100,{1:40,2:5,20:1},17)
]
global screen
screen = scrn
screen.clear()
screen.refresh()
self.bank = 0
self.lives = 1
try:
while True:
self.next_level()
except (KeyboardInterrupt):
self.message("Game quit")
except (SystemExit):
score(self.bank, screen,self.message,self.level.height+4)
sleep(0.5)
except:
raise
finally:
screen.clear()
def test_imagenet1k_resnet(**kwargs):
models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152']
accs = [.77, .78]
for (m, g) in zip(models, accs):
acc = mx.metric.create('acc')
(speed,) = score(model=m, data_val=VAL_DATA,
rgb_mean='0,0,0', metrics=acc, **kwargs)
r = acc.get()[1]
print('Tested %s, acc = %f, speed = %f img/sec' % (m, r, speed))
assert r > g and r < g + .1
def search(self, img):
start = datetime.now()
index = self.get_index()
matches = self.match_img(img, index)
matches = score.score(matches)
fin = datetime.now()
print "Search time: ", (fin - start).seconds, " seconds"
return matches
def __init__(self):
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"debug": True
}
handlers=[
(r"/api/login",UserHandler.LoginHandler),
(r"/api/register",UserHandler.RegisterHandler),
(r"/api/perfect",UserHandler.PerfectHandler),
(r"/api/userauthentication",UserHandler.AuthenHandler),
(r"/api/logout",UserHandler.LogoutHandler),
(r"/api/cancel",UserHandler.CancelHandler),
(r"/api/updatecid",UserHandler.UpdateCid),
(r"/api/search",UserHandler.SearchHandler),
(r"/api/getavatar",UserHandler.GetAvatarHandler),
(r"/api/checkrelatives",RelativesHandler.CheckrelativesHandler),
(r"/api/deleterelatives",RelativesHandler.DeleterelativesHandler),
(r"/api/addrelatives",RelativesHandler.AddrelativesHandler),
(r"/api/agreerelatives",RelativesHandler.AgreerelativesHandler),
(r"/api/getvalidation",RelativesHandler.ValidationHandler),
(r"/api/history",HistoryHandler.HistoryHandler),
(r"/api/helpmessage",EventHandler.HelpmessageHandler),
(r"/api/supportmessage",EventHandler.SupportmessageHandler),
(r"/api/finish",EventHandler.FinishHandler),
(r"/api/givecredit",EventHandler.GivecreditHandler),
(r"/api/addaid",EventHandler.AddaidHandler),
(r"/api/sendsupport",EventHandler.SendsupportHandler),
(r"/api/quitaid",EventHandler.QuitaidHandler),
(r"/api/event",EventHandler.EventHandler),
(r"/api/getuserinfo",UserInfoHandler.GetUserInfoHandler),
(r"/api/updateuserinfo",UserInfoHandler.UpdateUserInfoHandler),
(r"/api/getAround",GetArroundEvent.GetArroundEvent),
(r"/api/startfollow",FollowHandler.startFollowHandler),
(r"/api/cancelfollow",FollowHandler.cancelFollowHandler),
(r"/api/thirdpartylogin",ThirdPartHandlers.ThirdPartyLoginHandler),
(r"/api/thirdpartyremoveaccount",ThirdPartHandlers.ThirdPartyRemoveAccountHandler),
(r"/api/thirdpartyfilluserinfo",ThirdPartHandlers.ThirdPartyFillUserInfoHandler),
(r"/api/authstate", Authorize.AuthStateHandler),
(r"/api/requestemailauth", Authorize.RequestEmailAuthHandler),
(r"/api/authemail", Authorize.AuthEmailHandler),
(r"/api/requestphoneauth", Authorize.RequestPhoneAuthHandler),
(r"/api/authphone", Authorize.AuthPhoneHandler)]
tornado.web.Application.__init__(self,handlers,**settings)
self.dbapi=dbapi.dbapi()
self.util=util.util()
self.push = Push()
self.score=score.score()
def search(self, img):
start = datetime.now()
matches = self.match_img(img)
matches = score.score(matches)
for m in matches:
print m.location, m.score
fin = datetime.now()
print "Search time: ", (fin - start).seconds, " seconds"
return matches
def test_imagenet1k_resnet(args):
models = ['imagenet1k-resnet-34',
'imagenet1k-resnet-50',
'imagenet1k-resnet-101',
'imagenet1k-resnet-152']
accs = [.72, .75, .765, .76]
for (m, g) in zip(models, accs):
acc = mx.metric.create('acc')
(speed,) = score(model=m, data_val='data/val-5k-256.rec',
rgb_mean='0,0,0', metrics=acc, **vars(args))
r = acc.get()[1]
print 'testing %s, acc = %f, speed = %f img/sec' % (m, r, speed)
assert r > g and r < g + .1
def process_files(files, source, regex, max_results):
out = []
for filename in filter(isfile, files):
file_score = score.score(filename, source)
for result in match.match_lines(filename, regex, int(args.message_size)):
result.score = file_score
filename = os.path.relpath(result.filename, os.path.curdir)
out += ['%s:%d:%d:%s' % (filename, result.linenr, result.index + 1, result.message)]
if max_results is not None:
max_results -= 1
if max_results <= 0:
return out
return out
def run_prediction(parser=None,args_in=None,competition=False):
"""
Either pick up the arguments from the command line or use the
ones pre-packaged for the script.
"""
global train
global leaderboard
if competition:
logging.info('Running prepackaged arguments (%r)' % args_in)
args = parser.parse_args(args_in)
else:
logging.info('Using arguments from command line %r' % args_in)
args = args_in
train,leaderboard = initialize(args)
if args.tune:
folds = tuning(args)
save_folds(folds)
else:
folds = saved_folds()
predict(folds,args)
if args.score:
score.score()
def recommendations( self, method, args = None ):
data = []
if method == "new":
data = db.session().query( db.Product )\
.order_by( db.Product.date )\
.limit( 5 )\
.all()
elif method == "random":
data = db.session().query( db.Product )\
.limit( 10 )\
.all()
random.shuffle( data )
data = data[:5]
elif method == "recommended":
data = score.score( args["user_id"], 5 )
result = []
for p in data:
d = helpers.get( db.Product ).to_dictionary( p )
result.append( d )
return result
from data import CompressedData from models.classifier import Classifier from sklearn.linear_model import LogisticRegression from score import score import time import sys limit = int(sys.argv[1]) data, targets = CompressedData.data(limit=limit) tr_data, tr_targets = data[:limit/2], targets[:limit/2] cv_data, cv_targets = data[limit/2:], targets[limit/2:] logistic = Classifier(LogisticRegression()) start = time.time() logistic.train(tr_data, tr_targets) print 'duration ', time.time() - start preds = [logistic.predict(c) for c in cv_data] print score(preds, cv_targets)
objective = Objective.MAXIMIZE # data train_data, train_targets = Data.train() test_data, test_targets = Data.test() # feature engineering extra_data = test_data pipe = Pipeline(Polynomial, LogisticRegressionModel, objective, logging.WARN) pipe.fit(train_data, train_targets, extra_data) print pipe.hyperparams # train model train_data = pipe.transform(train_data) voter1 = LogisticRegressionModel(objective, logging.INFO) models = [m(objective, logging.INFO) for m in [SVCModel, LogisticRegressionModel]] ensemble = ClassifierEnsemble(models, voter1, objective, logging.INFO) voter2 = LogisticRegressionModel(objective, logging.INFO) master = ClassifierEnsemble([ensemble], voter2, objective, logging.INFO) master.optimize(train_data, train_targets) master.fit(train_data, train_targets, master.hyperparams) # submission file test_data = pipe.transform(test_data) preds = master.predict(test_data) print score(preds, test_targets)
if args.ignore_case or (args.smart_case and not re.search('[A-Z]', args.pattern)):
flags = re.IGNORECASE
else:
flags = 0
pattern_string = args.pattern
if args.literal:
pattern_string = re.escape(pattern_string)
if args.word_regexp:
pattern_string = "\\b%s\\b" % pattern_string
regex = re.compile(pattern_string, flags)
files = found_filenames
score.exclude_globs = ';'.join(args.exclude_files)
score.low_priority_globs = ';'.join(args.low_priority_globs)
# Map files into (score, filename) tuples
files = map(lambda filename: (score.score(filename, source), filename), files)
# Filter and sort files
files = filter(lambda x: x[0] > 0, files)
files = sorted(files, reverse=True)
# Get back filenames
files = list(zip(*files)[1])
print(os.linesep.join(process_files(files, source, regex, args.max_results)))
def fitness(self):
ng = self.nofgenomes
dna=self.dna
#
self.fit = score.score(dna[0],dna[1],dna[2],dna[3])[0]
return self.fit
dnas[i].fitness()
generation=0
for i in range(10000):
newpop = Generation()
fittestmum=max(dnas, key=lambda dna: dna.fit)
dnas.remove(fittestmum)
fittestdad=max(dnas, key=lambda dna: dna.fit)
dnas.remove(fittestdad)
for parents in range(population/20-1):
mum.append(newpop.choose(dnas))
dad.append(newpop.choose(dnas))
del dnas[:]
dnas.append(fittestmum)
dnas.append(fittestdad)
newpop.breed(fittestmum.dna,fittestdad.dna)
for parents in range(population/20-1):
newpop.breed(mum[parents].dna,dad[parents].dna)
if i % 10 == 0:
print max(dnas, key=lambda dna: dna.fit).fit, 'generation :', generation
generation+=1
a=max(dnas, key=lambda dna: dna.fit)
b=score.score(a.dna[0],a.dna[1],a.dna[2],a.dna[3])
print b,a.dna
#Ain = raw_input("Enter core inlet area: ")
Thrust=1.5*b[3]
print Thrust
#for baby in dnas:
# print baby.fit
#!/usr/bin/python
#!coding=utf-8
import stockmanager
import score
manager = stockmanager.stockmanager()
x = manager.get_stock_index('002204')
x = manager.cal_kline(x)
score = score.score()
x =score.get_level()
for i in x:
print i
