def main(model='NN', web_server=False):
# use Riot Live Client to check if a game is being played
time_sleep = checker()
if not time_sleep:
return
open('lock.txt', 'x').close()
time.sleep(time_sleep)
if web_server:
url = 'http://localhost:8000'
data = web_data(10, model)
prediction10 = requests.post(url, json=data).text
print(prediction10)
time.sleep(300)
data = web_data(15, model)
prediction15 = requests.post(url, json=data).text
print(prediction15)
else:
prediction10 = predictor(10, model)
print(prediction10)
time.sleep(300)
prediction15 = predictor(15, model)
print(prediction15)
os.remove('lock.txt')
def train(args):
from predictor import predictor
logging.basicConfig(level=logging.INFO, filename="something.log")
logger = logging.getLogger("temp")
home_prefix = os.getenv("HOME")
coding_file = args.coding_file.replace("~", home_prefix)
non_coding_file = args.non_coding_file.replace("~", home_prefix)
output_prefix = args.output_prefix
seeker = predictor()
seeker.logger = logger
seeker.train(coding_file, non_coding_file)
graph = {
"atrans": seeker.atrans,
"fe": seeker.fe,
"config": seeker.model.to_json(),
"weights": seeker.model.get_weights()
}
with open(output_prefix + "_config.pkl", "wb") as f:
pkl.dump(graph, f)
logger.info("The configuration has been dumped into " + output_prefix +
"_config.pkl")
def test_make_prediction_on_thread(self):
# create predictor
p = predictor(self.predictor_cfg)
# connect to db
db = database_handler(self.db_path)
# get predictor info
model_info, model_id = p.get_model_info()
self.assertEqual(model_id, self.model_id)
self.assertEqual(model_info["predictor_backend"],
self.predictor_backend)
# create prediction
db.create_prediction(self.prediction_id, model_info, model_id)
# start prediction on thread
pred_thread = prediction_thread(self.db_path,
self.image_path,
self.prediction_id,
predictor=p)
pred_thread.start()
# wait for prediction
time.sleep(self.result_wait_time)
# get prediction result
pred_json = db.get_prediction_json(self.prediction_id)
self.assertEqual(pred_json["prediction_status"], 200)
self.assertNotEqual(pred_json["predictions"], "")
def predict_new(test_sample, c, path):
dict={'0.0':0,'1.0':1,'2.0':2,'3.0':3,'4.0':4,'5.0':5,'6.0':6,'7.0':7,'8.0':8,'9.0':9,'a':11,'b':12, 'c':13,'d':14,
'e':15,'f':16,'g':17,'h':18,'i':19,'j':20,'k':21,'l':22,'m':23,'n':24,'o':25}
u=c.get('labels')
if(c.get('kernel')==1):
ker=kernel.Kernel.gaussian(6)
elif(c.get('kernel')==0):
ker=kernel.Kernel.linear()
else:
print "kernel in multipredict1 error"
pp=np.zeros(u.size)
for k in c.keys():
if k=='kernel' or k=='labels':
continue
i=dict.get(k.split(",")[0])
j=dict.get(k.split(',')[1])
#p=predictor.predictor_new(ker,c.get(k),test_sample)
p1=predictor.predictor(ker,k, path)
p=p1.predict(test_sample)
if p==1:
pp[i]+=1
#pp[j]-=1
else:
pp[j]+=1
#pp[i]-=1
#print i,j, p
print u
print pp
return u[np.argmax(pp)]
def test(args):
home_prefix = os.getenv("HOME")
model_file = args.model_file.replace("~", home_prefix)
input_file = args.input_file.replace("~", home_prefix)
output_prefix = args.output_prefix
with open(model_file, "rb") as f:
configs = pkl.load(f)
seeker = predictor()
seeker.fe = configs["fe"]
seeker.atrans = configs["atrans"]
seeker.model = model_from_json(configs["config"])
seeker.model.set_weights(configs["weights"])
with open(input_file, "r") as f:
lines = f.readlines()
seqs = [lines[i + 1][:-1] for i in range(0, len(lines), 2)]
descs = [lines[i][:-1] for i in range(0, len(lines), 2)]
probs = [predict_one(seeker, s) for s in seqs]
with open(output_prefix + ".output", "w") as f:
f.write("Probability\tDescription\n")
for i in range(len(descs)):
f.write("\t".join([str(float(probs[i])), descs[i]]) + "\n")
def main(ticker):
data = fetch_data.yahoo_fetcher(ticker)
series = window_maker.data_filter(data)
series, normalizer_cache = window_maker.scaler(series)
Xs, ys = window_maker.windowed_dataset(series, 61, 1, 1)
x_train, x_test, y_trian, y_test = predictor.split(Xs, ys)
model = predictor.predictor(x_train, x_test, y_trian, y_test, normalizer_cache)
predictor.next_day(ticker, normalizer_cache, model)
def overall_prediction(lstm_output, cnn_output, length_and_count_embeddings): # joint vector part joint_vector = [] output = predictor.predictor(joint_vector) return output
def predict_new(test_sample, c, path):
dict = {
'0.0': 0,
'1.0': 1,
'2.0': 2,
'3.0': 3,
'4.0': 4,
'5.0': 5,
'6.0': 6,
'7.0': 7,
'8.0': 8,
'9.0': 9,
'a': 11,
'b': 12,
'c': 13,
'd': 14,
'e': 15,
'f': 16,
'g': 17,
'h': 18,
'i': 19,
'j': 20,
'k': 21,
'l': 22,
'm': 23,
'n': 24,
'o': 25
}
u = c.get('labels')
if (c.get('kernel') == 1):
ker = kernel.Kernel.gaussian(6)
elif (c.get('kernel') == 0):
ker = kernel.Kernel.linear()
else:
print "kernel in multipredict1 error"
pp = np.zeros(u.size)
for k in c.keys():
if k == 'kernel' or k == 'labels':
continue
i = dict.get(k.split(",")[0])
j = dict.get(k.split(',')[1])
#p=predictor.predictor_new(ker,c.get(k),test_sample)
p1 = predictor.predictor(ker, k, path)
p = p1.predict(test_sample)
if p == 1:
pp[i] += 1
#pp[j]-=1
else:
pp[j] += 1
#pp[i]-=1
#print i,j, p
print u
print pp
return u[np.argmax(pp)]
def predict_team():
print("i was called")
predict_this = {"team":request.form["team"],
"hg":request.form["hg"],
"attendance":request.form["attendance"],
"hthg":request.form["hthg"],
"htag":request.form["htag"]
}
print(predict_this)
ob = predictor().predict(predict_this)
return ob
def process(headline, description):
tweets_filtered = []
query = headline + ' ' + description
prediction = predictor.predictor(query)
prediction = sorted(prediction, key=lambda i: i[1], reverse=True)
index = prediction[0][0]
category = categories[index]
r = Recommender(query, dataset[category])
results = r.return_results()
#category_index =
return jsonify(results), 200
def __init__(self, dim):
self.dim = dim
self.predictor = predictor(dim[0], dim[1], dim[2])
stime = time.time()
self.arrive_record = [stime for i in range(dim[2])]
self.elapsed_record = [0. for i in range(dim[2])]
self.pnext = np.argmax(self.predictor.predict([self._format_data()]))
self.record = list()
self.hit = 0
self.count = 0
import threading
self.lock = threading.Lock()
def process():
tweets_filtered = []
headline = request.args.get('headline')
description = request.args.get('short_description')
query = headline + ' ' + description
prediction = predictor.predictor(query)
prediction = sorted(prediction, key=lambda i: i[1], reverse=True)
index = prediction[0][0]
category = categories[index]
r = Recommender(query, dataset[category])
results = r.return_results()
#category_index =
print(results)
return jsonify(results), 200
def predict():
if request.method == "POST":
temp = request.values["temperature"]
humidity = request.values["humidity"]
weather = request.values["weather"][0:1]
predict_attr = {"weather": weather, "temp": temp, "humidity": humidity}
ml_model = predictor.predictor(predict_attr)
tmrw_demand = int(round(ml_model["tmrw_demand"]))
score = (round(ml_model["score"], 3)) * 100
return render_template("predict.html",
tmrw_demand=tmrw_demand,
score=score)
else:
return render_template("wrongaccess.html")
def main(options):
"""
Run Phenotype predictor.
"""
eff=effects.effects(options["effects"])
if options["read"]:
raise Exception("Not implemented yet - todo")
else:
data=snp_data.eigenstrat_data(options["data"], options["pops"],
False, options["inbred"], sparse=0)
pred=predictor.predictor(data, eff)
pred.print_values()
def main():
now = get_now()[0]
if ret.retrieve_data(lat, lon, unit, points, file_path_new, file_path_old):
print('GREAT! XML READER EXECUTING...')
read_output_df = read.read_xml(file_path_new)
future_df = pred.predictor(read_output_df, DNI_model_fp, DHI_model_fp)
print(future_df)
print(pred.write_df(write_df_fp, future_df))
print('csv updated at: ' + str(now))
else:
#NOTE, later I will have the ndfd reader actually return a false in the correct place
print('error in reading from ndfd')
def __init__(self, test_sample,multiclass):
u=multiclass.u
self.k=u.size
pp=np.zeros(self.k)
for i in range(self.k):
for j in range(i+1, self.k):
p1=predictor.predictor(multiclass.kernel,str(u[i])+","+str(u[j]))
p=p1.predict(test_sample)
if p==1:
pp[i]+=1
else:
#print i, j
pp[j]+=1
print "pp: ", pp
self.value=u[np.argmax(pp)]
def __init__(self, test_sample, multiclass):
u = multiclass.u
self.k = u.size
pp = np.zeros(self.k)
for i in range(self.k):
for j in range(i + 1, self.k):
p1 = predictor.predictor(multiclass.kernel,
str(u[i]) + "," + str(u[j]))
p = p1.predict(test_sample)
if p == 1:
pp[i] += 1
else:
#print i, j
pp[j] += 1
print "pp: ", pp
self.value = u[np.argmax(pp)]
def show_post(post_id):
# show the post with the given id, the id is an integer
e=pred.predictor(post_id,"hmm")
e.train()
_index=ts.get_hist_data(post_id)
temp="<body>\n"
temp+="<p>open:"+str(_index['open'][0])+"</p>"
temp+="<p>close:"+str(_index['close'][0])+"</p>"
temp+="<p>ma5:"+str(_index['ma5'][0])+"</p>"
temp+="<p>ma10:"+str(_index['ma10'][0])+"</p>"
temp+="<p>ma20:"+str(_index['ma20'][0])+"</p>"
temp+="<p>prediction result:"+str(e.test())+"</p>"
#temp+="<p>pred:"+str()+"</p>"
temp+="</body>"
return temp;#render_template('dsv.html', post_id=post_id)
def main():
num_samples=100
num_features=2
samples = np.random.normal(size=num_samples * num_features).reshape(num_samples, num_features)
labels = 2 * (samples.sum(axis=1) > 0) - 1.0
svm01=trainer.trainer(kernel.Kernel.linear(), 20, '01')
svm01.train(samples,labels)
predictor01=predictor.predictor(samples,labels,kernel.Kernel.linear(),'01')
print predictor01.predict(np.array([0,0]))
print predictor01.predict(np.array([-1,-1]))
print predictor01.predict(np.array([-2,-2]))
print predictor01.predict(np.array([-5,-5]))
#plt.subplot(2, 1, 1)
#plt.scatter(samples[:,0].ravel(), samples[:,1].ravel(), c=labels, alpha=0.5)
plt.show()
def add(choice, lang="python"):
try:
from . import predictor
except:
import predictor
name, f = choice
vobj = predictor.predictor(f)
ans = vobj.generate_vector()
ans.append(name)
try:
with open("model1/dataset.csv", "a", newline='') as file:
writer = csv.writer(file)
writer.writerow(ans)
except:
with open("dataset.csv", "a", newline='') as file:
writer = csv.writer(file)
writer.writerow(ans)
def main():
processList = ['dT', 'kNN', 'rF', 'adaBoost', 'sVM', 'xgBoost']
#processList = ['dT', 'kNN', 'rF', 'adaBoost', 'sVM']
count = 0
ScoreValidBoxPlot = np.ndarray(shape=(5, len(processList)), dtype=float)
ScoreTestBoxPlot = np.ndarray(shape=(5, len(processList)), dtype=float)
algoNames = []
for algo in processList:
dT = predictor(enableLoggingTime=True)
fileName = "%s/%sDataProj" % (algo, algo)
data = dT.loadVariables(fileName=fileName)
ValScoreList = data['ValScoreList']
TestScoreList = data['TestScoreList']
algoName = data['algorithm']
ScoreValidBoxPlot[:, count] = ValScoreList
ScoreTestBoxPlot[:, count] = TestScoreList
algoNames.append(algoName.name)
count += 1
# print ('%s & %0.2f & %s & %s & %s\\\\ \n \hline' % \
# (state_ind, X_train_not_normalized[i], tmp_2004, \
# tmp_pred, tmp_GT))
figName = "All/validationScoreCompare"
#algoNames = ['DT', 'kNN', 'RF', 'AdaBoost', 'SVM']
myBoxPlot(ScoreValidBoxPlot,
algo,
figName,
ylim=[0, 1.0],
title='Validation MCC with different algorithms',
ylabel='MCC',
xticks=algoNames)
figName = "All/testingScoreCompare"
myBoxPlot(ScoreTestBoxPlot,
algo,
figName,
ylim=[0, 1.0],
title='Testing MCC with different algorithms',
ylabel='MCC',
xticks=algoNames)
def capture():
cap = cv2.VideoCapture(0)
while (True):
ret, frame = cap.read()
frame = cv2.flip(frame, 1)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(frame, 100, 200)
roi = cropped(edges)
keypress = cv2.waitKey(1)
if keypress == ord('q'):
break
if keypress == ord('s'):
save(roi)
value = predictor()
print(value)
cv2.imshow("ROI", roi)
cap.release()
cv2.destroyAllWindows()
def __init__(self, test_sample): # u is the array of unique labels
u = np.load('multipliers/labels.npz')['ulabels']
if (np.load('multipliers/labels.npz')['k'] == 1):
k = kernel.Kernel.gaussian(6)
else:
print "kernel in multipredict1 error"
self.k = u.size
pp = np.zeros(self.k)
for i in range(self.k):
for j in range(i + 1, self.k):
p1 = predictor.predictor(k, str(u[i]) + "," + str(u[j]))
p = p1.predict(test_sample)
#print u[i],u[j], p
if p == 1:
pp[i] += 1
pp[j] -= 1
else:
#print i, j
pp[j] += 1
pp[i] -= 1
print u
print pp
self.value = u[np.argmax(pp)]
def __init__(self, test_sample): # u is the array of unique labels
u=np.load('multipliers/labels.npz')['ulabels']
if(np.load('multipliers/labels.npz')['k']==1):
k=kernel.Kernel.gaussian(6)
else:
print "kernel in multipredict1 error"
self.k=u.size
pp=np.zeros(self.k)
for i in range(self.k):
for j in range(i+1, self.k):
p1=predictor.predictor(k,str(u[i])+","+str(u[j]))
p=p1.predict(test_sample)
#print u[i],u[j], p
if p==1:
pp[i]+=1
pp[j]-=1
else:
#print i, j
pp[j]+=1
pp[i]-=1
print u
print pp
self.value=u[np.argmax(pp)]
def update_output_div(input_value):
location = geolocator.geocode(input_value)
if location is None:
return [html.P("Not found!")]
prediction = predictor(lat = location.latitude, lon = location.longitude, severity = "Severe")
closest_infrastructure = closest(lat = location.latitude, lon = location.longitude, n_samples = 1)
investor_str = ''' Company name: {0}
Number of employees: {1}
Main product: {2}'''.format(
location.longitude,
location.latitude,
prediction[0]
)
return [
html.P(f"Longitude: {location.longitude}"),
html.P(f"Latitude: {location.latitude}"),
html.P(f"Cyclists at risk? {prediction[0]}"),
html.P(f"Pedestrians at risk? {prediction[1]}"),
html.P("Closest infrastructure:"),
dataframe_to_table(closest_infrastructure)
]
predictorSquaredErrors = []
baselineSquaredErrors = []
for i in range(n):
#generate the testing and training sets for this fold of the validations
testing = allbins[i]
training = []
for bin in allbins:
if bin != testing:
training.extend(bin) # add the bin to the training set if it is not the testing bin, which yields n-1 bins for training and 1 bin for testing
model = buildModel(training, args.attributes)
for tweet in testing:
prediction = predictor(tweet, model)
actual = tweet['score']
squaredError = (prediction - actual) ** 2
predictorSquaredErrors.append(squaredError)
baselineSquaredError = actual ** 2
baselineSquaredErrors.append(baselineSquaredError)
predictorMSE = mean(predictorSquaredErrors)
baselineMSE = mean(baselineSquaredErrors)
improvement = ((baselineMSE - predictorMSE) / baselineMSE) * 100
improvements.append(improvement)
print "Baseline mean squared error: " + str(baselineMSE)
from predictor import predictor
while True:
print(predictor(input('enter url: ')))
parser = argparse.ArgumentParser()
parser.add_argument("-e", "--embfile", type=str, help="The path of .emb file")
parser.add_argument("-dgf", "--drugfile", type=str, help="The path of drug id file")
parser.add_argument("-dsf", "--diseasefile", type=str, help="The path of one disease id file")
parser.add_argument("-mf", "--modelfile", type=str, help="The path of model file")
parser.add_argument("-o", "--outpath", type=str, help="The output path")
args = parser.parse_args()
graph = pd.read_csv(args.embfile, sep='\t', header=None)
graph = graph.set_index([0])
drug_curie_list = list(pd.read_csv(args.drugfile, sep='\t', header=0)['id'])
disease_curie_list = list(pd.read_csv(args.diseasefile, sep='\t', header=None)[0])
## build up the prediction model
pred = predictor(model_file=args.modelfile)
## pre-create an array of all drugs which will be used in create_array function.
drug_array = graph.loc[drug_curie_list, :].to_numpy()
def create_array(curie):
#print(curie, flush=True)
disease_array = graph.loc[[curie for _ in range(len(drug_curie_list))], :].to_numpy()
return np.multiply(disease_array, drug_array)
array_list = [elem for elem in map(create_array, disease_curie_list)]
X = np.concatenate(array_list)
all_prob = list(pred.prob(X)[:, 1])
disease_col = list(itertools.chain.from_iterable(itertools.repeat(x, len(drug_curie_list)) for x in disease_curie_list))
def start_loop(predictor, example):
"""
The Prediction loop. This is where the logic happens.
:input predictor: the predictor function. def predictor(inputs=[], batch_size=8)
:input example: a pickled json of the example input.
This function starts a loop. Does not return anything.
"""
# warmup
_utils.warmup(predictor, example)
# find optimal batch size and get_time_per example
batch_size, time_per_example = _utils.find_optimum_batch_sizes(
predictor, example)
max_wait_time = time_per_example * _utils.MAX_WAIT
# write batch size to temp file for use in generating _run.sh
os.system(f"echo {batch_size} > {_utils.batch_size_file_path}")
# list of files/data to be processed is tracked here.
to_process = None
_utils.logger.info("Starting prediction loop")
last_paused_time = 0
while True:
time.sleep(_utils.PREDICTION_LOOP_SLEEP)
# Get the latest list of to process data
to_process = _utils.get_to_process_list(_utils.FILE_MODE)
if not to_process:
continue
_utils.logger.info(f"{len(to_process)} inputs left in queue.")
if len(to_process) < batch_size - 1:
# start the wait
if not last_paused_time:
last_paused_time = time.time()
_utils.logger.info(f"Waiting for more inputs for batching.")
continue
# if waiting for less than max_wait_time, continue waiting
if time.time() - last_paused_time < max_wait_time:
_utils.logger.info(f"Waiting for more inputs for batching.")
continue
# waiting completed
last_paused_time = 0
# The "batch" here is a batch of inputs.
# since, each input might contain more than one example (client side batching)
# we pass the batch_size paramter to predictor
# this is especially helpfull for most of the major deep learning libraries
# that accept batch_size as a parameter to predict call
# TLDR; predictor function should respect a parameter named batch_size
for batch in _utils.get_batch(to_process, batch_size):
_utils.logger.info(f"Processing batch with unique_ids: {batch}")
# in_data will contain flattened list of user inputs.
# batch = [['1', '2'], ['3'], ['4,5,6']] will result in
# in_data = [1, 2, 3, 4, 5, 6]
# number_of_examples_per_req = [2, 1, 3]
# This way, we can pass the in_data to predictor function with above calculated batch_size
# later, we can use number_of_examples_per_req to re-order preds in to batches.
in_data = []
number_of_examples_per_req = []
for i, in_path in enumerate(batch):
try:
if _utils.FILE_MODE:
in_list = glob.glob(in_path + "/*")
else:
in_list = pickle.load(open(in_path, "rb"))
in_data += in_list
number_of_examples_per_req.append(len(in_list))
except Exception as ex:
batch[i] = None
batch = [example for example in batch if example is not None]
if len(in_data) == 0:
continue
try:
results = predictor(in_data, batch_size=batch_size)
except Exception as ex:
_utils.logger.exception(ex, exc_info=True)
results = [str(ex) for _ in in_data]
for i, in_path in enumerate(batch):
# we use number_of_examples_per_req to re-order preds in to batches.
# result is the list of preds for the current batch
result = results[:number_of_examples_per_req[i]]
# remove current batch from list of all predictions
results = results[number_of_examples_per_req[i]:]
_in_data = in_data[:number_of_examples_per_req[i]]
in_data = in_data[number_of_examples_per_req[i]:]
if _utils.FILE_MODE:
_in_data = [os.path.basename(j) for j in _in_data]
remove_till = _in_data[0].index(".") + 1
_in_data = [j[remove_till:] for j in _in_data]
result = {
in_sub_path: sub_result
for in_sub_path, sub_result in zip(_in_data, result)
}
os.system(f"rm -rf {in_path}")
in_path = in_path[:-4]
else:
os.system(f"rm -rf {in_path}")
res_path = _utils.in_path_to_res_path(in_path)
pickle.dump(result, open(res_path, "wb"), protocol=2)
_utils.logger.info(f"result written for {res_path}")
_utils.create_symlink_in_ram(res_path)
def main():
#processList = ['xgBoost']
printConfMat = False
processList = ['dT', 'kNN', 'rF', 'adaBoost', 'sVM', 'xgBoost']
count = 0
for algo in processList:
dT = predictor(enableLoggingTime=True)
fileName = "%s/%sDataProj" % (algo, algo)
data = dT.loadVariables(fileName=fileName)
ValScoreList = data['ValScoreList']
ValScoreStdList = data['ValScoreStdList']
TestScoreList = data['TestScoreList']
TestConfList = data['TestConfList']
bestParamList = data['bestParamList']
scoring = data['scoring']
scoring = scoring.name
# Fold data [OuterFoldNo][ParamListIndex][Accu/Conf][InnerFoldNo]
OuterInnerFoldData = data['OuterInnerFoldData']
sweepingList = data['sweepingList']
NoOfParam = len(sweepingList)
print NoOfParam
OuterFoldNo = data['OuterFoldNo']
InnerFoldNo = data['InnerFoldNo']
bestParamIndexInSwpList = data['bestParamIndexInSwpList']
print("Fold no - Outer %d, Inner %d\n" % (OuterFoldNo, InnerFoldNo))
#print TestAccuList
print("Sweeping param list: %s\n" % (sweepingList))
#print( "Each Inner Fold Size: %d\n" % len(eachInnerFold[0][1]) )
print("best Params: %s\n" % (bestParamList))
print("best Params List index in paramList : %s\n" %
(bestParamIndexInSwpList))
print("Outer Fold Size: %d\n" % len(OuterInnerFoldData))
ScoreBoxPlot = np.ndarray(shape=(InnerFoldNo, OuterFoldNo),
dtype=float)
# Fold 1
for outI in range(OuterFoldNo):
print("Fold #%d\n" % (outI))
FoldData = OuterInnerFoldData[outI]
bestParamScore = np.array(
FoldData[bestParamIndexInSwpList[outI]][0])
ScoreBoxPlot[:, outI] = bestParamScore
bestParamConf = np.array(
FoldData[bestParamIndexInSwpList[outI]][3])
print("\tBest param Avg. Valid. Score = %0.8f\n" %
(np.mean(bestParamScore)))
print("\tBest param Valid. Score. = \t\t")
print bestParamScore
# mean of accuracy for all param in outer fold
FoldAllAvgScore = np.ndarray(shape=(NoOfParam), dtype=float)
for paramI in range(NoOfParam):
paramAllScore = np.array(FoldData[paramI][0])
paramMeanScore = paramAllScore.mean()
FoldAllAvgScore[paramI] = paramMeanScore
printForLatexTable(FoldAllAvgScore, outI)
if printConfMat:
for inn in range(InnerFoldNo):
fileName = "%s/O%d_I%d_conf" % (algo, outI, inn)
dT.printConfusionMatrix(bestParamConf[inn],
filename=fileName)
fileName = "%s/Test_O%d_conf" % (algo, outI)
dT.printConfusionMatrix(TestConfList[outI], filename=fileName)
printForLatexTableValidTest(ValScoreList, TestScoreList)
print ValScoreList
#print AccuracyBoxPlot
# Create a figure instance
figName = "%s/%s_bestParamValidScore.eps" % (algo, algo)
myBoxPlot(ScoreBoxPlot,
algo,
figName,
ylim=[0, 1.0],
title='%s with optimal params in Validation Set' % (scoring),
ylabel='MCC')
figName = "%s/%s_testingScore.eps" % (algo, algo)
myPlot(TestScoreList,
algo,
figName,
ylim=[0, 1.0],
xlabel='Outer Fold No.',
ylabel='MCC',
title='%s with optimal params in Testing Set' % (scoring))
count += 1
def main():
capture()
predictor()
cl2.fit(train[label], train["Survived"])
cl3.fit(train[label], train["Survived"])
cl4.fit(train[label], train["Survived"])
cl5.fit(train[label], train["Survived"])
cl6.fit(train[label], train["Survived"])
rf.fit(train[label], train["Survived"])
test_predict = pd.DataFrame.copy(test)
test_predict["Survived"] = rf.predict(test_predict[label])
return test_predict
func_train = util.adaptData
func_test = util.adaptData
na = util.getNumAdaptData()
if na == 1:
label = np.asarray(['Pclass', 'Sex', 'Age', 'SibSp', 'Parch'])
elif na == 2:
label = np.asarray(['Pclass', 'Sex', 'Age', 'Fare'])
elif na == 5:
label = np.asarray([
"Age", "Pclass", "Sex", "SibSp", "Parch", "Fare_bin", "EC", "EQ", "ES",
"Family", "Title", "Deck", "ASP"
])
else:
label = util.getParam()
model = model_ensemble
path = "../Predictions/ensemble.csv"
p.predictor(func_test, func_test, label, model, path)
from celery import Celery
from socket import gethostname
from predictor import predictor
from gcloud import datastore
clientds = datastore.Client()
key = clientds.key('booktable')
hostnm = gethostname()
import time
app = Celery('predictor', backend='amqp')
pred = predictor()
#define the functions we will call remotely here
@app.task
def predict(abstract, title, source):
prediction = pred.predict(statement, source)
entity = datastore.Entity(key=key)
entity['partition'] = hostname'
entity['date'] = str(time.time())
entity['title' ] = title
entity['prediction'] = str(prediction)
clientds.put(entity)
return [prediction]
if grid_elt is None:
eclf1 = VotingClassifier(estimators=[('lr', clf1), ('gb', clf2),
('knn', clf3)],
voting='soft',
weights=[1, 1, 1])
else:
eclf1 = VotingClassifier(estimators=[('lr', clf1), ('gb', clf2),
('knn', clf3)],
voting='soft',
weights=grid_elt)
eclf1.fit(train[label], train['hotel_cluster'])
prediction = eclf1.predict_proba(test[label])
return util.best_proba(prediction), eclf1
if __name__ == '__main__':
if util.getPCA():
label = util.getParam()
else:
label = util.getParam()
model = model_voting
path = "../Predictions/voting.csv"
p.predictor(label, model, path)
from QueryCOHD import QueryCOHD
from COHDUtilities import COHDUtilities
import SimilarNodesInCommon
import CustomExceptions
import numpy as np
import fisher_exact
import NormGoogleDistance
NormGoogleDistance = NormGoogleDistance.NormGoogleDistance()
# TODO: Temp file path names etc
sys.path.append(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'MLDrugRepurposing/FWPredictor'))
import predictor
p = predictor.predictor(
model_file=os.path.join(os.path.dirname(os.path.abspath(__file__)),
'MLDrugRepurposing/FWPredictor/LogModel.pkl'))
p.import_file(None,
graph_file=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'MLDrugRepurposing/FWPredictor/rel_max.emb.gz'),
map_file=os.path.join(os.path.dirname(os.path.abspath(__file__)),
'MLDrugRepurposing/FWPredictor/map.csv'))
class SMEDrugRepurposingFisher:
def __init__(self):
None
@staticmethod
def answer(disease_id, use_json=False, num_show=25):
