def build_detail_site(data, label_func, j2_env, linestyles, batch=False):
for (name, runs) in data.items():
print("Building '%s'" % name)
all_runs = runs.keys()
label = label_func(name)
data = {"normal": [], "scatter": []}
for plottype in args.plottype:
xn, yn = plot_variants[plottype]
data["normal"].append(
create_plot(runs, xn, yn, convert_linestyle(linestyles),
j2_env))
if args.scatter:
data["scatter"].append(
create_plot(runs, xn, yn, convert_linestyle(linestyles),
j2_env, "Scatterplot ", "bubble"))
# create png plot for summary page
data_for_plot = {}
for k in runs.keys():
data_for_plot[k] = prepare_data(runs[k], 'k-nn', 'qps')
plot.create_plot(
data_for_plot, False, False, True, 'k-nn', 'qps',
args.outputdir + get_algorithm_name(name, batch) + ".png",
linestyles, batch)
with open(args.outputdir + get_algorithm_name(name, batch) + ".html",
"w") as text_file:
text_file.write(
j2_env.get_template("detail_page.html").render(title=label,
plot_data=data,
args=args,
batch=batch))
def build_detail_site(data, label_func, j2_env, linestyles, batch=False):
for (name, runs) in data.items():
print("Building '%s'" % name)
all_runs = runs.keys()
label = label_func(name)
data = {"normal": [], "scatter": []}
for plottype in args.plottype:
xn, yn = plot_variants[plottype]
data["normal"].append(create_plot(
runs, xn, yn, convert_linestyle(linestyles), j2_env))
if args.scatter:
data["scatter"].append(
create_plot(runs, xn, yn, convert_linestyle(linestyles),
j2_env, "Scatterplot ", "bubble"))
# create png plot for summary page
data_for_plot = {}
for k in runs.keys():
data_for_plot[k] = prepare_data(runs[k], 'k-nn', 'qps')
plot.create_plot(
data_for_plot, False,
False, True, 'k-nn', 'qps',
args.outputdir + get_algorithm_name(name, batch) + ".png",
linestyles, batch)
output_path = "".join([args.outputdir,
get_algorithm_name(name, batch),
".html"])
with open(output_path, "w") as text_file:
text_file.write(j2_env.get_template("detail_page.html").
render(title=label, plot_data=data,
args=args, batch=batch))
def optimize(
filename='sodium-chloride-example.npz',
dim=3,
temp=120,
width=0,
tol_opt=1 / 500,
):
print('optimize')
parameters, positions, types, boxsize = load.load_input_file(filename)
width = boxsize[1] / 1000
particles = create_particle_object(parameters, positions, types)
print(parameters)
box = system.Box(dim, boxsize, particles, temp)
# return system.Box(dim, boxsize, particles, temp)
if width == 0: # if no width specified
width = boxsize[0] / 5000
r_skin_LJ = 2 * n_reuse_nblist * np.linalg.norm(width * np.ones(3))
save_system_history = True
box.compute_LJneighbourlist(r_cut_LJ, r_skin_LJ)
box.compute_LJ_potential(r_cut_LJ, r_skin_LJ)
box.optimize(n_opt_max, n_steps_opt, tol_opt, n_reuse_nblist, n_skip,
width, save_system_history, r_cut_LJ, r_skin_LJ)
box.simulate(n_steps_sim, n_reuse_nblist, n_skip, width,
save_system_history, r_cut_LJ, r_skin_LJ)
pos_history = box.pos_history
pot_history = np.asarray(box.pot_history)
plot.create_plot(boxsize[1], pos_history, pot_history, r_cut_LJ,
n_steps_opt, n_skip)
print('running time:', time.time() - start)
def makePlot(self, home, away, betData, dbResult):
if len(betData) > 0:
if len(betData[0]) == 3 and not None in betData[0]:
winH = list(map(lambda x: x[0], betData))
remisX = list(map(lambda x: x[2], betData))
winA = list(map(lambda x: x[1], betData))
plot.create_plot(home,
away,
winH,
winA,
remisX,
result=dbResult)
elif len(betData[0]) == 2 or None in betData[0]:
winH = list(map(lambda x: x[0], betData))
winA = list(map(lambda x: x[1], betData))
plot.create_plot(home, away, winH, winA, result=dbResult)
def index():
"""
the main page of the app
POST:
validate input symbol and create heroku plot
GET:
load search bar
"""
if request.method == 'POST' and 'symbol' in request.form:
symbl = request.form['symbol'].upper()
if 'WIKI/' + symbl in tickers['quandl code'].values:
try:
name = tickers.loc[tickers['quandl code'] ==
'WIKI/' + symbl, 'name'].values[0]
script, div = create_plot(symbl, name)
return render_template('index.html', place_holder='Input Stock Symbol...',
plot_script=script, plot_div=div)
except:
return render_template('index.html',
place_holder='An error has occured.')
else:
return render_template('index.html',
place_holder='Stock Symbol not recognized. Please try again...')
else:
return render_template('index.html', place_holder='Input Stock Symbol...')
def main():
parser = argparse.ArgumentParser(
description=
'Calculate and render probabilities of matchups for the show "Are You The One?".'
)
parser.add_argument(
'season',
type=str,
help='the name of a season available in the "seasons" folder, like "s1"'
)
parser.add_argument('--profile',
dest='profile',
action='store_true',
help='if provided, profiles the code')
args = parser.parse_args()
print(f'Reading season {args.season}')
season_data = seasons.read_season(args.season)
print(f'Preparing season')
season = seasons.convert_season(season_data)
print(f'Simulating season')
with timer.start(args.profile) as t:
output = simulation.simulate(season)
print(f'Simulation completed in {t.elapsed} seconds')
print(f'Plotting season')
fig = plot.create_plot(season, output)
fig.show()
def index():
"""
the main page of the app
POST:
validate input symbol and create heroku plot
GET:
load search bar
"""
if request.method == 'POST' and 'symbol' in request.form:
symbl = request.form['symbol'].upper()
if 'WIKI/' + symbl in tickers['quandl code'].values:
try:
name = tickers.loc[tickers['quandl code'] == 'WIKI/' + symbl,
'name'].values[0]
script, div = create_plot(symbl, name)
return render_template('index.html',
place_holder='Input Stock Symbol...',
plot_script=script,
plot_div=div)
except:
return render_template('index.html',
place_holder='An error has occured.')
else:
return render_template(
'index.html',
place_holder='Stock Symbol not recognized. Please try again...'
)
else:
return render_template('index.html',
place_holder='Input Stock Symbol...')
def simulate(filename='sodium-chloride-example.npz'):
print('simulate')
parameters, positions, types, boxsize = load.load_input_file(filename)
width = boxsize[1] / 1000
particles = create_particle_object(parameters, positions, types)
box = system.Box(dim, boxsize, particles, temp)
box.compute_LJneighbourlist(r_cut_LJ, r_skin_LJ)
box.compute_LJ_potential(r_cut_LJ, r_skin_LJ)
box.simulate(n_steps_sim, n_reuse_nblist, n_skip, width,
save_system_history, r_cut_LJ, r_skin_LJ)
pos_history = box.pos_history
pot_history = np.asarray(box.pot_history)
plot.create_plot(boxsize[1], pos_history, pot_history, r_cut_LJ,
n_steps_opt, n_skip)
print('running time:', time.time() - start)
def index():
if request.method=='POST':
print("Posted")
bar=None
content_title="NEW SAMPLE PLOT"
content=request.form.to_dict()
print(content)
bar=create_plot(content)
return render_template('index.html',plot=bar,comment='This is your gantt chart:')
else:
return render_template('index.html',plot=None,comment='Your chart will appear here:')
def main():
print "K-Means algorithm illustrated through the iris dataset"
print "The algorithm uses random initialization and iterates until no iris"
print "switches clusters."
print "If matplotlib is installed, the resulting clusters are illustrated"
print "in a graphical manner."
print
# import the data
irii = import_csv()
# create and initialize the algorithm
kmeans = KMeans(3, irii, euclidean_similarity)
# run the algorithm
num_iterations = kmeans.run()
print "K-Means ran in %d iterations" % (num_iterations)
print
print "SSE Values for each cluster:"
for cluster_num, sse in enumerate(kmeans.sses()):
num_members = len(kmeans.clusters[cluster_num])
print "Cluster %d (%d members): %f" % (cluster_num, num_members, sse)
print
# create a plot
try:
print "Plotting sepal length vs sepal width."
print "Colors indicate the cluster, as identified by k-means across all"
print "attributes. The symbol indicates the 'correct' group, as"
print "determined by the name of the IRIS. The black + symbols indicate"
print "the centroids."
create_plot(kmeans)
except:
print "There was a plotting error. Do you have matplotlib installed?"
def run(args):
if not os.path.exists('outputs'):
os.mkdir('outputs')
# Select the optimization criterion/task
LearnerClass = Learner_Clustering
criterion = MCL()
# Prepare dataloaders
train_loader, eval_loader = cxr(batch_sz=args["batch_size"],
num_workers=args["workers"],
mask=args["mask"])
# Prepare the model
if args["num_classes"] < 0: # Use ground-truth number of classes/clusters
args["num_classes"] = train_loader.num_classes
model = LearnerClass.create_model(args["model_type"], args["model"],
args["num_classes"])
model = torch.nn.DataParallel(model)
# GPU
if args["use_gpu"]:
model = model.cuda()
criterion = criterion.cuda()
torch.cuda.manual_seed(1)
print('Criterion:', criterion)
optim_args = {'lr': args["lr"]}
#optimizer = torch.optim.__dict__[args["optimizer"]](model.parameters(), **optim_args)
#optimizer = torch.optim.Adam(model.parameters(),lr=0.0002, betas=(0.9, 0.999))
optimizer = torch.optim.Adam(model.parameters(),
lr=args["lr"],
betas=(0.9, 0.999))
scheduler = MultiStepLR(optimizer, milestones=args["schedule"], gamma=0.1)
learner = LearnerClass(model, criterion, optimizer, scheduler)
all_loss_history = []
train_acc_history = []
train_auc_history = []
val_acc_history = []
val_auc_history = []
for epoch in range(args["start_epoch"], args["epochs"]):
best_perm_acc, best_perm_auc, loss_history, avg_best_acc, avg_best_auc = train(
epoch, train_loader, learner, args)
train_acc_history.append(avg_best_acc)
train_auc_history.append(avg_best_auc)
all_loss_history = all_loss_history + loss_history
#KPI = 0
val_acc, val_auc = evaluate(eval_loader, model, args, best_perm_auc,
best_perm_acc)
val_acc_history.append(val_acc)
val_auc_history.append(val_auc)
print("==========================Summary==================")
#print("model", args["model"])
print("lr", args["lr"])
print("loss", args["loss"])
print("number of epoch", args["epochs"])
print("weight_decay", args["weight_decay"])
print("mask", args["mask"])
print("train_auc_history", train_auc_history)
print("val_auc_history", val_auc_history)
print("train_acc_history", train_acc_history)
print("val_acc_history", val_acc_history)
create_plot(all_loss_history, args, train_acc_history, val_acc_history,
train_auc_history, val_auc_history)
torch.save(
model, "model/" + args["loss"] + "_mask" + str(args["mask"]) + "_wd" +
str(args["weight_decay"]) + '.pt')
args["mask"]) + "_" + args["loss"] + "_lr" + str(
args["lr"]) + "_wd" + str(
args["weight_decay"]) + "_drop_rate" + str(
args["drop_rate"]) + "_" + str(auroc_avg) + ".pkl"
torch.save(model.state_dict(), model_saved_path)
print("==========================Summary==================")
print("number of epoch", args["epoch"])
print("model", args["model"])
print("batch size", args["batch_size"])
print("mask", args["mask"])
print("learning rate: ", args["lr"])
print("scheduler: ", args["scheduler"])
print("weight_decay", args["weight_decay"])
print("loss function", args["loss"])
print("drop rate: ", args["drop_rate"])
print("train_auc_history", train_auc_history)
print("val_auc_history", val_auc_history)
print("train_acc_history", train_acc_history)
print("val_acc_history", val_acc_history)
print("train_perc_history", train_perc_history)
print("val_perc_history", val_perc_history)
print("train_recall_history", train_recall_history)
print("val_recall_history", val_recall_history)
create_plot(loss_history, args, train_acc_history, val_acc_history,
train_auc_history, val_auc_history)
#all_thresholds
best_t_index = val_auc_history.index(max(val_auc_history))
#print("best_t_index",best_t_index)
best_t = all_thresholds[best_t_index]
#print("best_t", best_t)
def index():
bar = create_plot()
return render_template("index.html", grapJSON=grapJSON)
<h2>Plots for %(id)s</h2>""" % { "id" : ds_name }
for plottype in args.plottype:
xn, yn = plot_variants[plottype]
print "Processing '%s' with %s" % (ds, plottype)
output_str += create_plot(ds_name, runs, xn, yn, linestyles)
if args.scatter:
output_str += """
<hr />
<h2>Scatterplots for %(id)s""" % { "id" : ds_name }
for plottype in args.plottype:
xn, yn = plot_variants[plottype]
print "Processing scatterplot '%s' with %s" % (ds, plottype)
output_str += create_plot(ds, runs, xn, yn, linestyles, "Scatterplot ", "bubble")
# create png plot for summary page
plot.create_plot(runs, True, False,
False, True, 'k-nn', 'qps', args.outputdir + ds + ".png",
create_linestyles(all_algos))
output_str += """
</div>
</div>
</body>
</html>
"""
with open(args.outputdir + ds + ".html", "w") as text_file:
text_file.write(output_str)
# Build a website for each algorithm
# Build website. TODO Refactor with dataset code.
for (algo, runs) in all_runs_by_algorithm.items():
all_data = runs.keys()
output_str = get_html_header(algo)
def load_tree(filename):
"""
filename: str, 从文件中读取已经生成的决策树
"""
import pickle
fr = open(filename, 'rb')
#print(fr.readlines())
return pickle.load(fr)
def get_lenses(filename='lenses.txt'):
fr = open(filename)
lenses = [inst.strip().split('\t') for inst in fr.readlines()]
feature_name = ['age', 'prescript', 'astigmatic', 'tear_rate']
assert len(lenses[0]) == 5
labels = [inst[4] for inst in lenses]
lenses = [inst[:4] for inst in lenses]
return lenses, labels, feature_name
if __name__ == '__main__':
#feature_name = ['no surfacing', 'flippers']
#my_tree = retrieve_tree(0)
#save_tree(my_tree, 'classify_tree.pkl')
#print(load_tree('classify_tree.pkl'))
#print(classify(my_tree, feature_name, [1, 1]))
lenses, labels, feature_name = get_lenses()
lenses_tree = create_tree(lenses, labels, feature_name)
create_plot(lenses_tree)
df = pd.read_csv("/data/home/cs224n/fake_news_data/merged.csv")
# Set `y`
Y = [1 if label == 'REAL' else 0 for label in df.label]
# Drop the `label` column
df.drop("label", axis=1)
print('extract configuration from input texts ...')
X = df['summarized_text']
config = fit_input_text(X)
config['num_target_tokens'] = 2
print('configuration extracted from input texts ...')
classifier = LstmClassifier(config)
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X,
Y,
test_size=0.2,
random_state=42)
print('training size: ', len(Xtrain))
print('testing size: ', len(Xtest))
print('start fitting ...')
history = classifier.fit(Xtrain, Ytrain, Xtest, Ytest)
create_plot(history, "LSTM RNN")
def cvrp(data, set, vehicles, strategy):
"""Solve the CVRP problem."""
# Instantiate the data problem.
data, name = modelData.create_data_model(data, set, vehicles)
# Create the routing index manager.
manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']),
data['num_vehicles'], data['depot'])
# Create Routing Model.
routing = pywrapcp.RoutingModel(manager)
# initial plot
plot.create_initial_plot(data['points'], name)
# Create and register a transit callback.
def distance_callback(from_index, to_index):
"""Returns the distance between the two nodes."""
# Convert from routing variable Index to distance matrix NodeIndex.
from_node = manager.IndexToNode(from_index)
to_node = manager.IndexToNode(to_index)
return data['distance_matrix'][from_node][to_node]
transit_callback_index = routing.RegisterTransitCallback(distance_callback)
# Define cost of each arc.
routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
# Add Capacity constraint.
def demand_callback(from_index):
"""Returns the demand of the node."""
# Convert from routing variable Index to demands NodeIndex.
from_node = manager.IndexToNode(from_index)
return data['demands'][from_node]
demand_callback_index = routing.RegisterUnaryTransitCallback(
demand_callback)
routing.AddDimensionWithVehicleCapacity(
demand_callback_index,
0, # null capacity slack
data['vehicle_capacities'], # vehicle maximum capacities
True, # start cumul to zero
'Capacity')
# Setting solution heuristic.
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
if strategy == 'first-solution':
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.AUTOMATIC)
elif strategy == 'local-search':
search_parameters.local_search_metaheuristic = (
routing_enums_pb2.LocalSearchMetaheuristic.AUTOMATIC)
search_parameters.time_limit.seconds = 20
else:
search_parameters.local_search_metaheuristic = (
routing_enums_pb2.LocalSearchMetaheuristic.AUTOMATIC)
search_parameters.time_limit.seconds = 25
# search_parameters.local_search_metaheuristic = (
# routing_enums_pb2.LocalSearchMetaheuristic.TABU_SEARCH)
# search_parameters.time_limit.seconds = 20
# Solve the problem.
assignment = routing.SolveWithParameters(search_parameters)
# Print solution.
if assignment:
vehicle_distance, vehicle_load, text = print.print_solution(
data, manager, routing, assignment)
routes = getRoutes.get_routes(manager, routing, assignment,
data['num_vehicles'])
# Display the routes.
route_arr = print.print_routes(routes)
plot.create_plot(data['points'], routes, vehicle_distance, name)
return vehicle_distance, vehicle_load, text, name, route_arr
