def main():
# Get DF working with all the data
df = prep_df()
# Keeping history (vectors)
cost_hist = list([])
parameters_hist = list([])
# Initiate graph (with standard edges)
initial_graph, initial_parameters = generate_graph(df)
# Actual cost
g = m.run_model(initial_graph)
old_cost = m.calc_error(g)
# Initial parameters
# parameters = [0.5]
cost_hist.append(old_cost)
parameters_hist.append(initial_parameters)
T = 1.0
T_min = 0.001
# original = 0.9
alpha = 0.9
parameters = initial_parameters
while T > T_min:
print 'Temp: ', T
#graph, parameters = generate_graph(df, initial_parameters)
i = 1
# original = 100
while i <= 100:
new_parameters = list(neighbor(parameters))
graph, parameters = generate_graph(df, new_parameters)
g = m.run_model(graph)
new_cost = m.calc_error(g)
if new_cost < old_cost:
parameters = new_parameters[:]
parameters_hist.append(parameters)
old_cost = new_cost
#print new_cost
cost_hist.append(old_cost)
else:
ap = acceptance_probability(old_cost, new_cost, T)
if ap > random():
parameters = new_parameters[:]
parameters_hist.append(parameters)
old_cost = new_cost
#print new_cost
cost_hist.append(old_cost)
i += 1
T = T * alpha
plot_results(parameters, cost_hist, parameters_hist)
return parameters, cost_hist, parameters_hist
def trainmodel():
try:
run_model()
resp = jsonify(success=True)
resp.status_code = 200
return resp
except:
resp = jsonify(success=False)
resp.status_code = 201
return jsonify(resp)
def trainmodel():
try:
nb_epoch = int(request.args['nb_epoch'])
run_model(nb_epochs=nb_epoch)
resp = jsonify(success=True)
resp.status_code = 200
return resp
except:
resp = jsonify(success=False)
resp.status_code = 201
return jsonify(resp)
def process_project(wdir, p, cfg):
# if h.verbosity == h.LOG_DEBUG:
# print(p)
data = p['data']
# Branches based on type of quantification specified in the .config file
if cfg['MODEL']['Type'] == 'Stability':
ms.run_model(wdir, data, cfg)
if cfg['MODEL']['Type'] == 'Relative':
mr.run_model(wdir, data, cfg)
if cfg['MODEL']['Type'] == 'Absolute':
m.run_model(wdir, data, cfg)
def home():
createTablesWhenNecessary()
if flask.request.args.get('pricesLeftInPercent') == None:
return flask.jsonify(error='PARAMETER_NOT_GIVEN',
parameter='pricesLeftInPercent')
if flask.request.args.get('timePassedInPercent') == None:
return flask.jsonify(error='PARAMETER_NOT_GIVEN',
parameter='timePassedInPercent')
prices_left_in_percent = float(
flask.request.args.get('pricesLeftInPercent'))
time_passed_in_percent = float(
flask.request.args.get('timePassedInPercent'))
prices_give_out_tendency_in_percent = get_current_prices_give_out_tendency_in_percent(
)
give_out_price = model.run_model(time_passed_in_percent,
prices_left_in_percent,
prices_give_out_tendency_in_percent)
addParticipationToTable(1 if give_out_price else 0)
return flask.jsonify(
error='',
give_out_price=give_out_price,
prices_give_out_tendency_in_percent=prices_give_out_tendency_in_percent,
prices_left_in_percent=prices_left_in_percent,
time_passed_in_percent=time_passed_in_percent)
def main(args):
# Unitprot fasta sequence to train ProtVec model
fastaFile = "data/fasta/uniprot_sprot.fasta"
processedDataFile = "data/processedData/" + str(
args.len) + "seq_embeddings_" + args.seqtype + ".pkl"
# if biovec is not trained, train the model. Otherwise, load the preprocessed data
if not isfile(processedDataFile):
if not isfile("data/embeddings/" + str(args.len) +
"grams_embeddings.txt"):
print("Generating embeddings for subsequences of length " +
str(args.len) + ".")
run_biovec(fastaFile, args)
else:
print("Using pre-generated embeddings")
# set the folder name (with test sequence fasta file) inside data folder as organism
organism = ["eDBD_195"]
for org in organism:
print(org)
folder_name = "data/" + org + "/"
if not os.path.exists(folder_name):
os.makedirs((folder_name))
test_fasta = folder_name + "seq.fasta"
test_output = folder_name + "testSequence_" + args.seqtype + ".csv"
test_df = parse_fasta_sequences(test_fasta, test_output)
preprocess_sequences(processedDataFile,
args,
test_data_file=test_output)
print("Running model")
classes = [
'end_preference', 'periodic_preference', 'groove_preference',
'dyad_preference', 'gyre_spanning', 'orientational_preference',
'nucleosome_stability'
]
if args.binding == -1:
selected_classes = np.arange(len(classes))
else:
selected_classes = np.asarray([args.binding])
print("Training for ", list(map(classes.__getitem__,
selected_classes)))
run_model(org, folder_name, processedDataFile, args, classes,
selected_classes)
def run_inference():
img = request
img = np.fromstring(img.get_data(), np.uint8)
img = cv2.imdecode(img, cv2.IMREAD_COLOR)
cv2.imwrite("Image.jpg", img)
seg_map = run_model(graph, img)
action = inference(seg_map)
return action
def runTest(data_ids, data_conflicts, team_size, test_name="Test"):
# Calculate number of students and teams
num_students = len(data_ids)
num_teams = num_students // team_size + min(1, num_students % team_size)
# Deduplicate conflicts
conflicts = []
ids = [row[0] for row in data_ids]
for i in range(len(data_conflicts)):
conflict = [
ids.index(data_conflicts[i][0]),
ids.index(data_conflicts[i][3])
]
inverse_conflict = [
ids.index(data_conflicts[i][3]),
ids.index(data_conflicts[i][0])
]
if inverse_conflict not in conflicts:
conflicts.append(conflict)
# Get gpa vector
gpas = [int(round(float(row[4]))) for row in data_ids]
# Run model
raw_output = run_model(num_students, num_teams, team_size, conflicts, gpas)
output = {"model": {"hasConflicts": raw_output["hasConflicts"]}}
# Create empty teams
output['teams'] = {}
for team in range(num_teams):
output['teams'][team + 1] = {'members': []}
# Fill teams with assignments
for i, a in enumerate(raw_output["assignments"]):
output['teams'][a + 1]["members"].append(data_ids[i][0])
# Create people
output['people'] = {}
for i in range(len(data_ids)):
output['people'][data_ids[i][0]] = {
'id': data_ids[i][0],
'firstName': data_ids[i][1],
'lastName': data_ids[i][2],
'email': data_ids[i][3],
'gpa': round(float(data_ids[i][4])),
'conflicts': []
}
for j in range(len(data_conflicts)):
if data_conflicts[j][0] == data_ids[i][0]:
output['people'][data_ids[i][0]]['conflicts'].append(
data_conflicts[j][3])
# Create test report file
getTestReport(output, data_ids, data_conflicts, num_teams, team_size,
test_name)
def create_musicxml(path, measure_length, key_number):
"""
This function takes the path to an uploaded file, its measure_length, and its key number
(usually info inputted by user) and passes the image through the first neural net to extract the measures,
then passes each measure through the second neural net to convert it to xml.
The handle_page function covers the first part and the run_model function covers the second.
"""
handle_page(path, measure_length, key_number,
os.path.join(MEDIA_ROOT, 'current_measures'))
measures = []
# initialize the xml output
soup = BeautifulSoup(features='xml')
score_partwise = soup.new_tag('score-partwise', version='3.1')
part_list = soup.new_tag('part-list')
score_part = soup.new_tag('score-part', id='P1')
part_name = soup.new_tag('part-name')
soup.append(score_partwise)
score_partwise.append(part_list)
part_list.append(score_part)
score_part.append(part_name)
part_name.append('Piano')
part = soup.new_tag('part', id='P1')
score_partwise.append(part)
# loop through each extracted measure and convert it to xml
# if the conversion fails, return a blank measure
for i in range(
len(os.listdir(os.path.join(MEDIA_ROOT, 'current_measures')))):
print('handling measure ', i + 1)
measure_soup = run_model(
os.path.join(MEDIA_ROOT, 'current_measures', f'subimage{i}.png'),
measure_length, key_number)
if measure_soup:
measure = measure_soup.find('measure')
# only need the key and time sig info on the first measure
if i != 0:
attributes = measure.find('attributes')
attributes.extract()
measures.append(measure)
print(f'measure {i+1} successful')
else:
blank_measure = get_blank_measure(measure_length)
measures.append(blank_measure)
print('error in measure ', i + 1)
for measure in measures:
part.append(measure)
# pick a random filename for the output
filename = np.random.choice(list('abcdefghijklmnopqrstuvwxyz0123456789'),
size=16)
filename = ''.join(filename)
with open(os.path.join(MEDIA_ROOT, f'{filename}.musicxml'), 'w+') as f:
f.write(str(soup))
return filename
def plot_png(path):
plt.cla() # Don't create fig and ax here since plotlib keeps them alive
N, t_min, t_max, R_0, I_0, R0, D, y_max, t0_date = params()
t, S, I, R = run_model(R0, D, N, I_0, R_0, t_min, t_max)
plot(ax, t, S, I, R, t0_date, y_max)
output = io.BytesIO()
FigureCanvasAgg(fig).print_png(output)
return Response(output.getvalue(), mimetype='image/png')
def main():
args = parse_args()
adj, edges, feats, labels = load_data(args.input)
embeddings = run_model(edges, adj, feats, args.lamb, args.eta, args.dimension, args.learning_rate, args.epoch,
gpu_fraction=args.gpu_fraction,
batchsize=args.batchsize,
print_every_epoch=args.print_every_epoch,
scope_name='default')
# save the embeddings
np.savetxt(args.output, embeddings, delimiter=',')
# performance evaluation
indice = np.random.permutation(labels.shape[0])
acc = node_classification(embeddings, labels, indice)
print("Node classification: ACC={}".format(acc))
def measure_upload(request):
if request.method == 'POST':
form = UploadedMeasureForm(request.POST, request.FILES)
if form.is_valid():
file = form.save()
path = 'media/' + str(file.measure)
key_number = int(str(file.key))
measure_length = int(str(file.time_signature))
s = run_model(path, measure_length, key_number)
with open('media/output.musicxml', 'w+') as f:
f.write(s)
return HttpResponseRedirect(reverse('measure_output'))
elif request.method == 'GET':
form = UploadedMeasureForm()
context = {'form': form}
return render(request, 'measure_upload.html', context)
def page_upload(request):
if request.method == 'POST':
form = UploadedPageForm(request.POST, request.FILES)
if form.is_valid():
file = form.save()
path = 'media/' + str(file.page)
key_number = int(str(file.key))
measure_length = int(str(file.time_signature))
handle_page(str(file.page), measure_length, key_number,
'media/current_measures/')
measures = []
soup = BeautifulSoup(features='xml')
score_partwise = soup.new_tag('score-partwise', version='3.1')
part_list = soup.new_tag('part-list')
score_part = soup.new_tag('score-part', id='P1')
part_name = soup.new_tag('part-name')
soup.append(score_partwise)
score_partwise.append(part_list)
part_list.append(score_part)
score_part.append(part_name)
part_name.append('Piano')
part = soup.new_tag('part', id='P1')
score_partwise.append(part)
os.chdir('..')
for i in range(len(os.listdir('./media/current_measures/'))):
measure_soup = run_model(
f'./media/current_measures/subimage{i}.png', 16, 0)
measure = measure_soup.find('measure')
if i != 0:
attributes = measure.find('attributes')
attributes.extract()
measures.append(measure)
for measure in measures:
part.append(measure)
with open('media/output_musicxml.musicxml', 'w+') as f:
f.write(str(soup))
return HttpResponseRedirect('media/output_musicxml.musicxml')
elif request.method == 'GET':
form = UploadedPageForm()
context = {'form': form}
return render(request, 'page_upload.html', context)
def generate_teams(model_input, model_dict):
print("!! run model")
result = run_model(num_students=model_input["num_students"],
num_teams=model_input["num_teams"],
team_size=model_input["team_size"],
conflicts=model_input["conflicts"],
gpas=model_input["gpas"],
ifgpa=model_input["ifgpa"] == "true")
print("!! model finished")
print(result)
model_dict["status"] = "finished"
model_dict["result"] = result
print("!! process finished")
def main():
rmtree('out')
makedirs('out')
parser = argparse.ArgumentParser()
parser.add_argument('content_image')
parser.add_argument('style_image')
args = parser.parse_args()
content_input = matrix_from_image_file(args.content_image, 0.1)
style_input = matrix_from_image_file(args.style_image)
model = build_model(layers, content_input, style_input)
wp = WeightProvider()
for i in range(10000):
content_weights, style_weights = wp.get_weights()
print('Using weights:\n{}\n{}'.format(content_weights, style_weights))
outfile = f'out/run_{i:0>3}.png'
rel_content_weights = [
w * CONTENT_WEIGHT_MULTIPLIER for w in content_weights
]
img, losses = run_model(model, RUNS_PER_EPOCH, content_input.shape,
rel_content_weights, style_weights)
img.save(outfile)
r = {
'img':
outfile,
'layers':
package_layers(
zip(layers, content_weights, losses[:8], style_weights,
losses[8:])),
'parts': ['content', 'style'],
}
with open(RESULTS_FILE, 'w') as fh:
dump(r, fh)
def menu():
value = 0
if request.method == "POST":
req = request.form
age = req.get('age')
height = req.get('height')
weight = req.get('weight')
budget = req.get('budget')
allergies = req.get('allergies')
ingredients = req.get('ingredients')
sex = req.get('sex')
activity = req.get('activity')
breakfast, lunch, dinner = run_model(int(age), int(weight),
float(height), int(budget),
ingredients, allergies, activity,
sex)
value = 1
if value == 1:
return render_template(
'menu.html',
breakfast_title=breakfast['Title'],
price_b=breakfast['Price'],
fat_b=breakfast['Fat'],
carbs_b=breakfast['Carbs'],
protein_b=breakfast['Protein'],
calories_b=breakfast["Calories"],
lunch_title=lunch['Title'],
price_l=lunch['Price'],
fat_l=lunch['Fat'],
carbs_l=lunch['Carbs'],
protein_l=lunch['Protein'],
calories_l=lunch["Calories"],
dinner_title=dinner['Title'],
price_d=dinner['Price'],
fat_d=dinner['Fat'],
carbs_d=dinner['Carbs'],
protein_d=dinner['Protein'],
calories_d=dinner["Calories"],
)
else:
return render_template('menu.html')
import pandas as pd
import numpy as np
import os
os.chdir('C:/Users/ALLEN/Desktop/PythonTest/HousePrice/')
import preprocess as pre
import model
train = pd.read_csv('C:/Users/ALLEN/Desktop/PythonTest/HousePrice/train.csv')
test = pd.read_csv('C:/Users/ALLEN/Desktop/PythonTest/HousePrice/test.csv')
x_train, y_train, test, test_ID = pre.input_data(train, test)
model.run_model(x_train, y_train, test, test_ID, 'nn')
def upload(userid):
# if the page is sending a post request
if request.method == 'POST':
# check if the post request has the file part
if 'file[]' not in request.files:
# if there is no file at all then return this
return 'didnt work'
# otherwise retrieve the file
print('before request')
file = request.files.getlist('file[]')
print('after request')
print(file)
# if the file name is blank then basically no file was selected.
# return back to the same page
# if file.filename == '':
# return redirect('/upload/' + str(userid))
# if the file path is satisfactory then
# get the current date and time
now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
small_images = []
for image in file:
print(image)
print(image.filename)
# if the filename is nothing then there is no file
# if so, redirect back to the same page.
if image.filename == '':
return redirect('/upload/%r' % userid)
if file:
# open the image using pillow
img = Image.open(image)
# find its dimensions
width, height = img.size
# if the file is not standard size
if img.size != (512, 512):
if width < 300 or height < 300:
# add image to small images list
small_images = small_images + [str(image)]
# skip image
continue
print(img.size)
# then either resixe the image or...
img = img.resize((512, 512))
# Crop the center of the image
# new_width, new_height = (512, 512)
# left = (width - new_width) / 2
# top = (height - new_height) / 2
# right = (width + new_width) / 2
# bottom = (height + new_height) / 2
# img = img.crop((left, top, right, bottom))
# if the image is too small then say it is too small
elif width < 256 or height < 256:
# we will deal with this later
print(img.size, 'too smol')
# initialise file path to nothing
path = ''
# if the user is signed in as a guest
if userid == 0:
# use the standard file path, overwrite the original if it exists.
path = '/static/images/guestimage.png'
else:
# otherwise if the user is signed in
# count how many images the user has already entered
# these should be saves seperately and not overwritten
images = Images.query.filter(
Images.user_id.like(userid)).all()
count = len(images)
# create a unique file name based on the user and how many images they have already entered.
# this allows us to recreate the path easily in a way that is user specific
path = '/static/images/%s_%s_image.png' % (str(userid),
count)
# save the image
img.save('.' + path)
# run the image through the model
output = run_model('.' + path)
print(output)
# create a new image object to store
new_image = Images(
user_id=userid,
image_path=path,
# default scan image and notes to nothing for now
# scan_image_path=str(output['scan_img']),
scan_image_path=path.rstrip('.png') + 'scan.png',
cancer_class=int(output['cancer_class']),
notes=str(output),
date_time_added=now)
# add the image to the db
db.session.add(new_image)
db.session.commit()
print(path)
# return the show_image page to display the image the person just uploaded
# return render_template('show_image.html',
# userid=str(userid),
# # pass in the new image path
# image_path=path,
# )
# if there are any undersized images, render this message html
if small_images != []:
return render_template('message_sent.html',
user=Users.query.get_or_404(userid),
message='an image was too small',
images=small_images)
return redirect(url_for('.show_image', userid=userid, timestamp=now))
# if request is not post, render upload page
return render_template('/upload.html', userid=userid)
def main():
tickers = pd.read_csv("./Nasdaq_Screeners.csv")["Symbol"].tolist()
## asks user for the ticker to be analyzed
while True:
print("Type symbol of stock to be analyzed: ")
user_input = input()
if user_input.upper() in tickers:
print("Ticker validation successful")
ts = TimeSeries(key="OS6T161LRRJ4V9N2", output_format="pandas")
data, meta_data = ts.get_daily_adjusted(
symbol=user_input, outputsize="full"
)
break
print("Invalid tickerv: try different ticker")
## Variables
#### Need to edit this part
train_forward = 0
n_training = 2000
timesteps = 0
repeat = 1
all_data = np.zeros((10, 10, repeat))
final_data = np.zeros((10, 10))
for k in range(1): ##change to x axis
for j in range(1): ## change to y axis
timesteps = 10 * (j + 1)
forecast_days = 10 * (k + 1)
n_testing = timesteps + 70
temp = np.zeros(repeat)
for i in range(repeat):
train_forward = 500 * i + 500
x_data = dt.to_techin(data, forecast_days)
y_data = dt.to_updown(data, forecast_days, len(x_data))
toolbox = pp.pptoolbox(
x_data, train_forward, n_training, n_testing, timesteps
)
x_train = toolbox.x_train()
x_test = toolbox.x_test()
y_train = toolbox.y_train(y_data)
y_test = toolbox.y_test(y_data)
temp[i] = md.run_model(timesteps, x_train, y_train, x_test, y_test)
all_data[k, j, i] = temp[i]
final_data[k, j] = st.median(temp)
# give final_data to plot.py
# give user statistical report
##finsih!!!!
test_data = [
[36.0, 46.0, 54.0, 58.5, 24.5, 57.5, 63.0, 48.0, 52.0, 58.5],
[52.0, 43.5, 54.5, 49.5, 44.0, 45.0, 58.5, 38.0, 69.0, 59.5],
[33.5, 35.0, 56.0, 47.0, 61.0, 49.0, 63.0, 56.0, 57.5, 49.5],
[33.0, 44.5, 48.5, 53.5, 49.5, 59.5, 64.0, 62.5, 49.5, 42.5],
[40.0, 41.0, 53.0, 46.0, 55.0, 59.0, 46.5, 56.0, 51.0, 52.0],
[28.0, 39.5, 53.5, 57.0, 60.5, 59.5, 58.0, 57.0, 69.0, 57.0],
[32.5, 44.0, 42.5, 57.0, 59.5, 56.5, 61.0, 56.0, 66.0, 65.5],
[34.0, 31.0, 47.0, 52.5, 56.5, 60.0, 63.0, 37.0, 52.5, 62.0],
[27.0, 41.5, 56.0, 54.5, 57.0, 41.0, 61.0, 51.5, 56.5, 65.0],
[28.0, 35.0, 50.0, 50.0, 60.0, 60.0, 45.0, 52.5, 64.5, 56.0],
]
final_data = np.array(test_data)
dt.report(final_data, user_input)
plt.plot(100, 100, final_data)
import sampling import model sampling.Cap() model.run_model()
def analyzeImage():
# Validate Request
data = request.form
imageBatchUploadId = data.get('imageBatchUploadId', None)
hasBatchId = bool(imageBatchUploadId is not None)
if not hasBatchId:
return (jsonify({'ok': False, 'message': 'Bad request'}), 400)
print("/analyze: Request Validation successful")
# Get all images for filename
images = mongo.db.images.find({'imageBatchUploadId': imageBatchUploadId})
scores = []
for image in images:
print("/analyze: " + image['imageFileName'])
# Get image by filename
filename = image['imageFileName']
storage = gridfs.GridFS(mongo.db)
out = storage.get_version(filename)
image_bytes = out.read()
img, original_format = bytes_to_image(image_bytes)
image_list = [(filename, img)]
# Run model
results_dict = model.run_model(image_list)
model_output_scores = results_dict[filename]['scores']
scores = []
for output in model_output_scores:
if "N/A" not in output:
scores.append(output)
classifiedImage = Image.fromarray(
results_dict[filename]['classifiedImage'])
print("/analyze: Score = ", scores)
if len(scores) == 0:
print("Removing")
mongo.db.images.remove({'imageFileName': {'$eq': filename}})
else:
# Update mongo document about this image with classification results
classified_filename = filename + "-classified"
mongo.db.images.update_one({'imageFileName': filename}, {
'$set': {
'classifiedImageFileName': classified_filename,
'scores': scores
}
})
# Save the new image
output = io.BytesIO()
classifiedImage.save(output, format=original_format)
storage.put(output.getvalue(),
filename=classified_filename,
content_type="image/png")
if all(score is not None for score in scores):
response = jsonify({'status': 200, 'ok': True})
response.headers.add('Access-Control-Allow-Origin', '*')
return response
else:
response = jsonify({
'ok': False,
'message': 'Internal Error in classification model'
})
response.headers.add('Access-Control-Allow-Origin', '*')
return response
def results():
time_start = time.time()
# get params
params = parse_params(request)
app.logger.info(f'... params = {params}')
highlight_before = params['highlight_before']
highlight_after = params['highlight_after']
baseline_before = params['baseline_before']
baseline_after = params['baseline_after']
return_type = params['return_type']
remote_host = params['remote_host']
local_host = params['local_host']
model = params['model']
score_thold = params['score_thold']
model_level = params['model'].get('model_level', 'dim')
# get charts to pull data for
charts = get_chart_list(host=remote_host)
# get data
df = get_data(remote_host, charts, after=baseline_after, before=highlight_before,
diff=True, ffill=True, numeric_only=True, nunique_thold=0.05)
colnames = list(df.columns)
arr_baseline = df.query(f'{baseline_after} <= time_idx <= {baseline_before}').values
arr_highlight = df.query(f'{highlight_after} <= time_idx <= {highlight_before}').values
charts = list(set([col.split('|')[0] for col in colnames]))
app.logger.info(f'... len(charts) = {len(charts)}')
app.logger.info(f'... len(colnames) = {len(colnames)}')
app.logger.info(f'... arr_baseline.shape = {arr_baseline.shape}')
app.logger.info(f'... arr_highlight.shape = {arr_highlight.shape}')
time_got_data = time.time()
app.logger.info(f'... time start to data = {time_got_data - time_start}')
# get scores
results_dict = run_model(model, colnames, arr_baseline, arr_highlight)
time_got_scores = time.time()
app.logger.info(f'... time data to scores = {round(time_got_scores - time_got_data, 2)}')
# get results to df
df_results = results_to_df(results_dict, score_thold)
time_done = time.time()
app.logger.info(f'... time total = {round(time_done - time_start, 2)}')
# build response
if return_type == 'html':
charts = df_results['chart'].values.tolist()
counts = OrderedDict(Counter([c.split('.')[0] for c in charts]).most_common())
counts = ' | '.join([f"{c}:{counts[c]}" for c in counts])
summary_text = f"number of charts = {df_results['chart'].nunique()}, number of dimensions = {len(df_results)}, {counts}"
charts_to_render = []
for chart in df_results['chart'].unique():
df_results_chart = df_results[df_results['chart'] == chart]
dimensions = ','.join(df_results_chart['dimension'].values.tolist())
rank = df_results_chart['chart_rank'].unique().tolist()[0]
score_avg = round(df_results_chart['score'].mean(), 2)
score_min = round(df_results_chart['score'].min(), 2)
score_max = round(df_results_chart['score'].max(), 2)
charts_to_render.append(
{
"id": chart,
"title": f"{rank} - {chart} - score_avg = {score_avg}, score_min = {score_min}, score_max = {score_max}",
"after": baseline_after,
"before": highlight_before,
"data_host": "http://" + f"{remote_host.replace('127.0.0.1', local_host)}/".replace('//', '/'),
"dimensions": dimensions
}
)
return render_template(
'results.html', charts=charts_to_render, highlight_after=highlight_after*1000,
highlight_before=highlight_before*1000, summary_text=summary_text
)
elif return_type == 'json':
return jsonify(df_results.to_dict(orient='records'))
else:
return None
def rerun_model():
run_model()
return "completed running model"
def run(create_df=False):
if create_df:
scrape(start=20)
run_model()
def estimate():
data = request.get_json()
result = run_model(data["data"])
return jsonify(data=result)
baseline_before = highlight_after - 1
baseline_after = baseline_before - (window_size * baseline_window_multiplier)
# get charts
charts = get_chart_list(starts_with=starts_with, host=host)
# get data
colnames, arr_baseline, arr_highlight = get_data(host, charts, baseline_after,
baseline_before,
highlight_after,
highlight_before)
time_got_data = time.time()
print(f'... time start to data = {time_got_data - time_start}')
# get scores
results = run_model(model, charts, colnames, arr_baseline, arr_highlight)
time_got_scores = time.time()
print(f'... time data to scores = {round(time_got_scores - time_got_data, 2)}')
# df_results_chart
df_results_chart = results_to_df(results, model)
time_got_results = time.time()
print(
f'... time scores to results = {round(time_got_results - time_got_scores, 2)}'
)
time_done = time.time()
print(f'... time total = {round(time_done - time_start,2)}')
print(df_results_chart)
import nltk
# ### Process Data###
# query_news_from_nyt()
# interpolate_df = query_stock_price()
# merging_data(interpolate_df)
# ### IF FIRST TIME USE NLTK ###
# nltk.download()
# ### Build Model ###
print('### Build Model ###')
df, df_stocks = processWithData()
df, df_stocks = sentimentIntensity(df, df_stocks)
print('### read data and sentiment intensity success:', df.head())
datasetNorm = normalize_data(df)
print('### normalize data success:', datasetNorm.head())
hp = generate_hyperparameters(len(datasetNorm.index))
xTrain, yTrain, xTest, yTest = split_train_and_test_set(datasetNorm, hp)
print('### split train and test data success:')
# ### Run model ###
run_model(
{'xTrain': xTrain, 'yTrain': yTrain, 'xTest': xTest, 'yTest': yTest}, hp)
def main():
args = _parse_args()
data_dir = args.data_dir
res_file = args.res_file
run_feature(data_dir)
run_model(res_file)
import argparse
from model import run_model
import scraper
parser = argparse.ArgumentParser()
parser.add_argument('--lang',
nargs='*',
type=str,
default=["en", "es", "de", "zh-CN"])
parser.add_argument('environment',
help='The environment the tests will run on')
args = parser.parse_args()
scraper.sample(args.environment, args.lang)
run_model('2019 hackathon example.csv', '.')
def runme():
if (len(sys.argv) > 1 and sys.argv[1] == "fill"):
run_model()
run_test()
port = int(os.environ.get('PORT', 5000))
app.run(debug=True, port=port, host='0.0.0.0')
inds = []
for i in range(len(df['losses'])):
if loss_name in df['losses'][i]:
inds.append(i)
best_ind = inds[np.argmin(df['val_loss'][inds])]
print(df.iloc[best_ind])
pdb.set_trace()
# >> x_train, x_test (mock_data)
training_size, test_size, input_dim = 1039, 116, 8896
noise_level = 0.5
center_factor, h_factor = 5., 0.2
x, x_train, y_train, x_test, y_test = \
ml.signal_data(training_size=training_size,
test_size=test_size,
input_dim=input_dim,
noise_level=noise_level,
center_factor=center_factor,
h_factor=h_factor)
num_classes, orbit_gap_start, orbit_gap_end = False, False, False
ticid_train, ticid_test = False, False
rms_train, rms_test = False, False
# >> run model
history, model, x_predict = ml.run_model(x_train, y_train, x_test, y_test, p,
supervised=False)
ml.diagnostic_plots(history, model, p, output_dir, '', x, x_train, x_test,
x_predict, mock_data=True)
