def upload_image(): if request.method == "POST": if request.files: fasta = request.files["fasta"] if fasta.filename == "": #print("No filename") flash('Warning! Select a fasta file before upload and run') return redirect(request.url) if allowed_files(fasta.filename): filename = secure_filename(fasta.filename) path = os.path.join(app.config["UPLOAD_FOLDER"], filename) #print(path) fasta.save(path) #print("fasta saved") #data = handle_fa(path) prediction(path) if os.path.exists(path): if filename != 'sample.fasta': os.remove(path) filename = 'prediction.csv' return redirect('/downloadfile/'+ filename) else: #print("That file extension is not allowed") flash('Error! That file extension is not allowed, upload only fasta file') return redirect(request.url) return render_template('index.html')
def main(): data = Data('./data/train.csv', './data/test.csv') data.preprocess_data() x_train_sets, y_train_sets, x_test_sets, y_test_set = data.k_fold_train_test_sets( ) models = ["LogisticRegression", "VotingClassifier"] for model in models: k_fold_mean_score(x_train_sets, y_train_sets, x_test_sets, y_test_set, model) x_train, x_test = Data.train_test_vectors(data.TRAIN_DF.text, data.TEST_DF.text, [3000, 0.4], "TFIDF") y_train = data.TRAIN_DF.label print("Predictions for the LogisticRegression Model") y_pred = prediction(x_train, y_train, x_test, "LogisticRegression") write_submission(y_pred, "./submissions/lr_submission.csv") print("Predictions for the VotingClassifier Model") y_pred = prediction(x_train, y_train, x_test, "VotingClassifier") write_submission(y_pred, "./submissions/evc_submission.csv")
def main(): mode = sys.argv[1] if mode == 'predict': output_name = sys.argv[2] model_name = sys.argv[3] print '---------------------------------------------' print 'Predicting new images' print '---------------------------------------------' pred_array, pred_file = dp.CNNDataPreProcess.predict_prep('predict') pred_pre = dp.CNNDataPreProcess.cnn_preprocess(pred_array) pred_result = model.pred_model(pred_pre, model_name) model.prediction(pred_result, pred_file, output_name) else: print '---------------------------------------------' print 'Load image, black_white them, and resize them' print '---------------------------------------------' if mode == 'train': training_step = int(sys.argv[2]) model_name = sys.argv[3] train_sample, train_label = (dp.CNNDataPreProcess.train_eval_prep( 'train_organized', 'train_disorganized', 'train')) print '---------------------------------------------' print 'Train model' print '---------------------------------------------' model.train_model(train_sample, train_label, training_step, model_name) if mode == 'eval': model_name = sys.argv[2] eval_sample, eval_label = (dp.CNNDataPreProcess.train_eval_prep( 'eval_organized', 'eval_disorganized', 'eval')) print '---------------------------------------------' print 'Evaluate model' print '---------------------------------------------' print '---------------------------------------------' print 'Evaluation Accuracy' print '---------------------------------------------' print model.eval_model(eval_sample, eval_label, model_name)
def forecast(n, n_days, val): if n == None: return [""] if val == None: raise PreventUpdate fig = prediction(val, int(n_days) + 1) return [dcc.Graph(figure=fig)]
def home(): # print(request.form) data = request.form.get('data') print(data) h = prediction(str(data)) # print('hi',h) return str(h)
def search(): if "image" not in request.files: return jsonify({"error": "image file is required"}) try: image_file = request.files["image"].read() npimg = np.fromstring(image_file, np.uint8) img = cv2.imdecode(npimg, cv2.IMREAD_COLOR) img_pil = Image.fromarray(img) image_feature = prediction(img_pil).squeeze().cpu().detach().numpy() close_list = main_search(image_feature) print(len(close_list)) ret = [] scores = [] for i in close_list: ret.append(i["image"]) scores.append(str(i["score"])) # print(ret) # return jsonify(close_list) # return json.dumps(close_list) return jsonify({"list": ret, "scores": scores}) # return render_template('template.html', image_name=ret) except Exception as e: print("error in deploy.py line 41", str(e)) return jsonify( {"error": "something went wrong with the uploaded file"})
def k_fold_mean_score(x_train_sets, y_train_sets, x_test_sets, y_test_set, model): print("Model: " + model) final_confusion_matrix = [[0, 0], [0, 0]] scores = [] for x_train, y_train, x_test, y_test in zip(x_train_sets, y_train_sets, x_test_sets, y_test_set): x_train, x_test = Data.train_test_vectors(x_train, x_test, [3000, 0.4], "TFIDF") y_pred = prediction(x_train, y_train, x_test, model) tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel() final_confusion_matrix[0][0] += tn final_confusion_matrix[0][1] += fp final_confusion_matrix[1][0] += fn final_confusion_matrix[1][1] += tp scores.append(score_on_model(x_train, y_train, x_test, y_test, model)) avg = np.mean(scores, axis=0) print("Score for train: " + str(avg[0])) print("Score for test: " + str(avg[1])) print(final_confusion_matrix) plt.figure(figsize=(10, 7)) plt.title(model) sn.heatmap(final_confusion_matrix, annot=True, fmt='g', linewidths=10, cmap="YlGnBu") plt.savefig('./plots/confusion_matrix_' + model)
def loadarguments(): step_loss = [] if args['L'] == False: pickle.dump(step_loss, open(args['loss'], 'wb')) #pickle.dump(step_loss, open(args['loss'], 'wb')) torch.set_default_tensor_type('torch.FloatTensor') torch.manual_seed(args['seed']) shared_model = Policy(3, args['action_space']) if args['curiosity']: final_dim = 6 * 6 * 32 inverse_model = Inverse(3, args['action_space']) mapping_model = mapping(args['action_space'], final_dim) prediction_model = prediction(args['action_space'], final_dim) else: inverse_model = None mapping_model = None prediction_model = None if device == 'cuda': with torch.cuda.device(1): shared_model.cuda() if args['curiosity']: inverse_model.cuda() mapping_model.cuda() prediction_model.cuda() if args['L']: if device == 'cpu': shared_model.load_state_dict( torch.load(args['lmn'], map_location=torch.device('cpu'))) if args['curiosity']: model_name = args['curiosity_mn'] inverse_model.load_state_dict( torch.load(model_name + '_inverse', map_location=torch.device('cpu'))) mapping_model.load_state_dict( torch.load(model_name + '_mapping', map_location=torch.device('cpu'))) prediction_model.load_state_dict( torch.load(model_name + '_prediction', map_location=torch.device('cpu'))) else: shared_model.load_state_dict(torch.load(args['lmn'])) if args['curiosity']: model_name = args['curiosity_mn'] inverse_model.load_state_dict( torch.load(model_name + '_inverse')) mapping_model.load_state_dict( torch.load(model_name + '_mapping')) prediction_model.load_state_dict( torch.load(model_name + '_prediction')) shared_model.share_memory() if args['curiosity']: inverse_model.share_memory() mapping_model.share_memory() prediction_model.share_memory() return shared_model, inverse_model, mapping_model, prediction_model
def result(): if request.method == 'POST': sym1 = request.form.get('symptom 1') sym2 = request.form.get('symptom 2') sym3 = request.form.get('symptom 3') import model pred = model.prediction(sym1,sym2,sym3) return render_template("result.html",result =pred)
def predict(id): words = request.args.get("words") np_words = np.array([words]) test_data = {'instances': np_words.tolist()} data = json.dumps(test_data) response_json = prediction(np_words.tolist()) return response_json
def loadarguments(): global env_conf global env global setup_json global shared_model global inverse_model global mapping_model global prediction_model global saved_state global optimizer global torch global step_loss #step_loss = pickle.load(open('TDW_A2C_step_loss_reward_sum.p', 'rb')) step_loss = [] if args['L'] == False: pickle.dump(step_loss, open('TDW_curiosity_PPO_step_loss_reward_sum.p', 'wb')) torch.set_default_tensor_type('torch.FloatTensor') torch.manual_seed(args['seed']) the_gpu_id = 1 shared_model = Policy(3, action_space) final_dim = 800 inverse_model = Inverse(3, action_space) mapping_model = mapping(action_space, final_dim) prediction_model = prediction(action_space, final_dim) if device == 'cuda' and True: with torch.cuda.device(the_gpu_id): shared_model.cuda() inverse_model.cuda() mapping_model.cuda() prediction_model.cuda() shared_model.share_memory() inverse_model.share_memory() mapping_model.share_memory() prediction_model.share_memory() if args['L']: shared_model.load_state_dict(torch.load('tdw_ppo_curiosity_model')) inverse_model.load_state_dict( torch.load('tdw_ppo_curiosity_model_inverse')) mapping_model.load_state_dict( torch.load('tdw_ppo_curiosity_model_mapping')) prediction_model.load_state_dict( torch.load('tdw_ppo_curiosity_model_prediction')) optimizer = None
def makeprediction(): result = model.prediction(fileName) print(result) result1 = np.amax(result[0]) result = np.where(result[0] == result1) if result[0] == 0: predicted.configure(text='About') predicted.place(x=298, y=182.5) elif result[0] == 1: predicted.configure(text='Banks') predicted.place(x=298, y=182.5) elif result[0] == 2: predicted.configure(text='Called') predicted.place(x=298, y=182.5)
def predict(): if "image1" not in request.files: return jsonify({"error": "image file is required"}) #print(request.files.get("image")) try: filestr = request.files['image1'].read() filestr2 = request.files['image2'].read() typ = request.form["type"] if typ is None: typ = "tripplet" npimg = np.fromstring(filestr, np.uint8) npimg2 = np.fromstring(filestr2, np.uint8) img = cv2.imdecode(npimg, cv2.IMREAD_COLOR) img2 = cv2.imdecode(npimg2, cv2.IMREAD_COLOR) img_pil = Image.fromarray(img) img_pil2 = Image.fromarray(img2) output1 = prediction(img_pil, model_type=typ).squeeze().cpu().detach().numpy() output2 = prediction(img_pil2, model_type=typ).squeeze().cpu().detach().numpy() # print(cosine_similarity(output1,output2)) value = cosine_similarity(output1, output2) if value > 0.5: result = "same image" else: result = "different image" return jsonify({ "similarity_score": str("Result :" + result + " " + " , \n\n Cosine Similarity Value :" + str(value)) }) except Exception as e: print("error in deploy.py line 63", str(e)) return jsonify( {"error": "something went wrong with the uploaded file"})
def predict(): if request.method == "POST": location = request.form['location'] bhk = request.form['bhk'] bath = request.form['bath'] balcony = request.form['balcony'] sqft = request.form['sqft'] area_type = request.form['area_type'] availability = request.form['availability'] pred = model.prediction(location, bhk, bath, balcony, sqft, area_type, availability) return render_template("result.html", prediction=pred) else: return render_template('index.html')
def show_result(): """ 显示结果 """ img_path = e.get() if len(img_path) == 0: tkinter.messagebox.showinfo('提示', '请选择图片路径') return try: img = cv2.imread(img_path) test_data = imgProcess.process(img) result = model.prediction(test_data) plt.imshow(img) plt.axis('off') plt.title(result, fontsize=20) plt.show() except: tkinter.messagebox.showinfo('提示', '请选择图片路径')
def predict_test(): words = 'bangun tidur siang tengah aneh pindah texas milik konsentrasi halhal kerja rumah kelas 10 cepat jam ' \ 'dentang 4 henti mudah laku pindah kerja rumah tantang kerja sibuk putus habis berjamjam laku bayar ' \ 'perhati kelas barangbarang benarbenar keras tinggal lacak tahun malas jenius hei lambat baik benarbenar ' \ 'fokus tinggal kampus konsentrasi mudah sayang tinggal rumah awas ketat tua omel adik omel omel omel ' \ 'titik repot pergi jalan sekolah pergi pustaka ajar pindah memberitahu salah pindah pergi lindung milik ' \ 'khawatir dunia satusatunya jaga kamar bersih bantu bisnis uang ut hidup asrama apartemen semester pikir ' \ 'ambil untung off topik pergi jalan enam malam milik ledak cinta austin tinggal va pergi dc waktu milik ' \ 'ledak siswa lari malam bersenangsenang tanggung bersenangsenang prioritas lurus tinggal rumah kau harap ' \ 'laku tanggung adik kacau pergi gila pindah guru tinggi kacau karir guru tinggi pesta alas utama pergi ' \ 'bersenangsenang biar pergi jajah dunia india budaya india nilainilai india lawan bersenangsenang maksud ' \ 'temu orangorang pacar pesta bersenangsenang sekolah sulit pikir milik bebas tempat tekan buat sekolah ' \ 'tua harap senang tulis pergi tulis bantu pikir urut harap bersenangsenang baca untung ta ' input = np.array([words]) test_data = {'instances': input.tolist()} data = json.dumps(test_data) response_json = prediction(input.tolist()) return response_json
def run_prediction( data_path=None, model_properties=None): ''' Prediction's for the Model ''' if data_path is None or model_properties is None: raise ValueError('Need Data path , Config pathand Model Properties as argument !') config_map = model_properties['config_map'] data_to_predict = read_json_data(data_path) data = data_to_predict.copy() data = data.replace('NA', np.NaN) data[config_map['encode_columns']] = data[config_map['encode_columns']].astype(float) data[config_map['scale_columns']] = data[config_map['scale_columns']].astype(float) data = impute_data(data, config_map) data = one_hot_encoding(data, config_map['encode_columns']) data = hash_encoding(data, config_map['hash_columns'], 5, 'string') data = data[model_properties['X_train'].columns] predictions = prediction(data, model_properties) data_to_predict['predicted_delivery_seconds'] = list(predictions.flatten()) predicted_data = data_to_predict[['delivery_id', 'predicted_delivery_seconds']] return predicted_data
def predict(): #These are for the API request TIME_DELTA = 1 hours = 80 * 24 #DAYS PER HOURS #Retrieve form selected data selected_crypto = list(request.form.values()) #Fetch market data crypto_series = fetch_market_data.get_historical_hourly_price( selected_crypto[0], 'USD', hours, TIME_DELTA) #Normalization data series_norm = normalization(crypto_series) pred = prediction(series_norm) #Este retorna el gráfico del api #return render_template('index.html', prediction_text='You selected: {}'.format(plot_close_price(crypto_series,selected_crypto[0]))) #Este debería retornar el pred #INTEL MKL ERROR: El sistema operativo no puede ejecutar %1. mkl_intel_thread.dll. #Intel MKL FATAL ERROR: Cannot load mkl_intel_thread.dll. return render_template('index.html', prediction_text='You selected: {}'.format(pred))
def predict(): input_features=[x for x in request.form.values()] gender=input_features[0] age=int(input_features[1]) hypertension=int(input_features[2]) disease=int(input_features[3]) married=input_features[4] work=str(input_features[5]) area=input_features[6] glucose=float(input_features[7]) bmi=float(input_features[8]) smoke=input_features[9] # l=[gender,age,hypertension,disease,married,work,area,glucose,bmi,smoke] predicted_value=model.prediction(gender,age,hypertension,disease,married,work,area,glucose,bmi,smoke) if predicted_value==0: predicted_value="Good News! Patient has no Stroke" elif predicted_value==1: predicted_value="Oops! Patient going with Stroke" return render_template('index.html',predicted_text=predicted_value)
def predict(): predicted_talks = prediction() return jsonify(predicted_talks), 200
import json import os from flask import Flask, jsonify, request from flask_cors import CORS from model import prediction import tensorflow as tf import base64 import ast app = Flask(__name__) CORS(app) predictionObj = prediction() @app.route("/predict/", methods=['POST', 'GET']) def predict(): try: encoded_string = request.form.get('BASE64') # image = 'pi2235-03-3.jpg' # encoded_string = "" # with open(image, "rb") as image_file: # encoded_string = base64.b64encode(image_file.read()) ret, predicted_class, name, family, author = predictionObj.predict( encoded_string) if not ret: ret_dict = {'Error': True, 'Message': 'Error in prediction'} return jsonify(ret_dict)
import pandas as pd import datetime import pickle from model import prediction today = datetime.date.today() next_week = today + datetime.timedelta(days=7) matches = pd.DataFrame.from_csv('future_matches.csv') matches['date'] = pd.to_datetime(matches['date']) next_matches = matches[matches['date'].between(today,next_week)] while len(next_matches)== 0: next_week = next_week + datetime.timedelta(days=7) next_matches = matches[matches['date'].between(today, next_week)] current_ratings = pickle.load(open('ratings_mid_2017_2.pickle','rb')) predictions = [] for i,match in next_matches.iterrows(): home_team = match['home_team'] away_team = match['away_team'] spread, home_win_prob = prediction(home_team,away_team,n_sims=1000,use_ratings=current_ratings) predictions.append([match['date'],home_team,away_team,spread,home_win_prob]) pd.DataFrame(predictions).to_csv('predictions_next_week.csv')
def main(): anssdic = {} front_up() try: st.write('User Logged in as', name_dict['name']) pk = login_dict["key"] na = name_dict['name'] #st.write("primary key" ,pk) st.write("Name ", na) except: st.error(" Please Log in") st.title("SURVEY") if st.checkbox('Question I', key='q1'): st.info(" Did your child struggle to learn to count?") ansq1 = st.radio("Answer:", ['Yes-frequently', 'Sometimes', 'No-never'], key='q1') anssdic['ansq1'] = ansq1 if st.button("SUBMIT", key='q1'): st.write(ansq1) marks1 = submit(ans=ansq1, question="1") st.write(marks1) diss.update({'marks1': marks1}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question II', key='q2'): st.info( "Does he/she say numbers out of order — long after peers have mastered this skill? " ) ansq2 = st.radio("Answer:", ['Yes-frequently', 'Sometimes', 'No-never'], key='q2') anssdic['ansq2'] = ansq2 if st.button("SUBMIT", key='q2'): st.write(ansq2) marks2 = submit(ans=ansq2, question="2") diss.update({'marks2': marks2}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question III', key='q3'): st.info( " Does your child not seem to understand the connection between the symbol “4” and the word “four?” Does he make mistakes when reading or following directions involving number words and symbols?" ) ansq3 = st.radio("Answer:", ['Yes-frequently', 'Sometimes', 'No -never'], key='q3') anssdic['ansq3'] = ansq3 if st.button("SUBMIT", key='q3'): st.write(ansq3) marks3 = submit(ans=ansq3, question="3") diss.update({'marks3': marks3}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question IV', key='q4'): st.info( "Does your child struggle to connect the concept of numbers to real-world items? When you ask him how many cookies are left, for example, does he seem confused by the question or answer incorrectly?" ) ansq4 = st.radio("Answer", ['Yes-frequently', 'Sometimes', 'No-never'], key='q4') anssdic['ansq4'] = ansq4 if st.button("SUBMIT", key='q4'): st.write(ansq4) marks4 = submit(ans=ansq4, question="4") diss.update({'marks4': marks4}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question V', key='q5'): st.info( "Does your child not seem to understand the difference between adding and subtracting? Does she confuse the + and – symbols when completing math problems?" ) ansq5 = st.radio("Answer:", ['Yes-frequently', 'Sometimes', 'No-never'], key='q5') anssdic['ansq5'] = ansq5 if st.button("SUBMIT", key='q5'): st.write(ansq5) marks5 = submit(ans=ansq5, question="5") diss.update({'marks5': marks5}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question VI', key='q6'): st.info("Does your child still count on his fingers past third grade?") ansq6 = st.radio("Answer:", ['Yes-frequently', 'Sometimes', 'No-never'], key='q6') anssdic['ansq6'] = ansq6 if st.button("SUBMIT", key='q6'): st.write(ansq6) marks6 = submit(ans=ansq6, question="6") diss.update({'marks6': marks6}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question VII', key='q7'): st.info(" Difficulty sustaining attention; seems " "hyper" " or " "daydreamer" " ") ansq7 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q7') anssdic['ansq7'] = ansq7 if st.button("SUBMIT", key='q7'): st.write(ansq7) marks7 = submit(ans=ansq7, question="7") diss.update({'marks7': marks7}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question VIII', key='q8'): st.info( "Confused by letters, numbers, words, sequences, or verbal explanations." ) ansq8 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q8') anssdic['ansq8'] = ansq8 if st.button("SUBMIT", key='q8'): st.write(ansq8) marks8 = submit(ans=ansq8, question="8") diss.update({'marks8': marks8}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question IX', key='q9'): st.info(" Reads and rereads with little comprehension") ansq9 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q9') anssdic['ansq9'] = ansq9 if st.button("SUBMIT", key='q9'): st.write(ansq9) marks9 = submit(ans=ansq9, question="9") diss.update({'marks9': marks9}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question X', key='q10'): st.info( "Difficulty putting thoughts into words; speaks in halting phrases; leaves sentences incomplete." ) ansq10 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q10') anssdic['ansq10'] = ansq10 if st.button("SUBMIT", key='q10'): st.write(ansq10) marks10 = submit(ans=ansq10, question="10") diss.update({'marks10': marks10}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XI', key='q11'): st.info( "Can count, but has difficulty counting objects and dealing with money." ) ansq11 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q11') anssdic['ansq11'] = ansq11 if st.button("SUBMIT", key='q11'): st.write(ansq11) marks11 = submit(ans=ansq11, question="11") diss.update({'marks11': marks11}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XII', key='q12'): st.info( "ory for sequences, facts and information that has not been experienced." ) ansq12 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q12') anssdic['ansq12'] = ansq12 if st.button("SUBMIT", key='q12'): st.write(ansq12) marks12 = submit(ans=ansq12, question="12") diss.update({'marks12': marks12}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XIV', key='q13'): st.info( "Complains of dizziness, headaches or stomach aches while reading." ) ansq13 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q13') anssdic['ansq13'] = ansq13 if st.button("SUBMIT", key='q13'): st.write(ansq13) marks13 = submit(ans=ansq13, question="13") diss.update({'marks13': marks13}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XIV', key='q14'): st.info("Is reading extremely difficult? (Below grade or age level.") ansq14 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q14') anssdic['ansq14'] = ansq14 if st.button("SUBMIT", key='q14'): st.write(ansq14) marks14 = submit(ans=ansq14, question="14") diss.update({'marks14': marks14}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XV', key='q15'): st.info("Is spelling ability poor? Letters missed, reversed etc?") ansq15 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q15') anssdic['ansq15'] = ansq15 if st.button("SUBMIT", key='q15'): st.write(ansq15) marks15 = submit(ans=ansq15, question="15") diss.update({'marks15': marks15}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XVI', key='q16'): st.info( "Is it difficult to rhyme words?(Not sure? Play a rhyming game with your child or student)." ) ansq16 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q16') anssdic['ansq16'] = ansq16 if st.button("SUBMIT", key='q16'): st.write(ansq16) marks16 = submit(ans=ansq16, question="16") diss.update({'marks16': marks16}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XVII', key='q17'): st.info( "Is there difficulty telling time on a clock with hands and/or tying shoes with laces?" ) ansq17 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q17') anssdic['ansq17'] = ansq17 if st.button("SUBMIT", key='q17'): st.write(ansq17) marks17 = submit(ans=ansq17, question="17") diss.update({'marks17': marks17}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XVIII', key='q18'): st.info( "Is there difficulty finding the right words while speaking? Lots of ums, ahs, 'those things', and 'that stuff'." ) ansq18 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q18') anssdic['ansq18'] = ansq18 if st.button("SUBMIT", key='q18'): st.write(ansq18) marks18 = submit(ans=ansq18, question="18") diss.update({'marks18': marks18}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XIX', key='q19'): st.info( " Pauses, repeats or makes frequent mistakes when reading aloud.") ansq19 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q19') anssdic['ansq19'] = ansq19 if st.button("SUBMIT", key='q19'): st.write(ansq19) marks19 = submit(ans=ansq19, question="19") diss.update({'marks19': marks19}) #st.write(anssdic) #st.write(diss) if st.checkbox('Question XX', key='q20'): st.info("Unusually high or low tolerance for pain.") ansq20 = st.radio("Answer:", ['Yes', 'No', 'Unknown'], key='q20') anssdic['ansq20'] = ansq20 if st.button("SUBMIT", key='q20'): st.write(ansq20) marks20 = submit(ans=ansq20, question="20") diss.update({'marks20': marks20}) st.write("Your answers", anssdic) #st.write(diss) if st.button("Submit the quiz", key='submit'): try: if bool(anssdic['ansq1']) and bool(anssdic['ansq2']) and bool( anssdic['ansq3'] ) and bool(anssdic['ansq4']) and bool(anssdic['ansq5']) and bool( anssdic['ansq6'] ) and bool(anssdic['ansq7']) and bool(anssdic['ansq8']) and bool( anssdic['ansq9'] ) and bool(anssdic['ansq10']) and bool(anssdic['ansq11']) and bool( anssdic['ansq12']) and bool(anssdic['ansq13']) and bool( anssdic['ansq14']) and bool( anssdic['ansq15']) and bool( anssdic['ansq16']) and bool( anssdic['ansq17']) and bool( anssdic['ansq18']) and bool( anssdic['ansq19']) and bool( anssdic['ansq20']): conn = MySQLdb.connect("localhost", "ryan", "mark50", "dyslexia") c = conn.cursor() query = 'INSERT INTO survey(pk,name,mone,mtwo,mthree,mfour,mfive,msix,mseven,meight,mnine,mten,meleven,mtwelve,mthirteen, mfourteen,mfifteen,msixteen, mseventeen, meighteen,mnineteen,mtwenty) VALUES ("%s", "%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s");' % ( pk, na, diss['marks1'], diss['marks2'], diss['marks3'], diss['marks4'], diss['marks5'], diss['marks6'], diss['marks7'], diss['marks8'], diss['marks9'], diss['marks10'], diss['marks11'], diss['marks12'], diss['marks13'], diss['marks14'], diss['marks15'], diss['marks16'], diss['marks17'], diss['marks18'], diss['marks19'], diss['marks20']) #query = 'INSERT INTO quiz(pk,name,mone,mtwo,mthree,mfour,mfive,msix,mseven,meight,mnine,mten) VALUES ("%s", "%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s");' % (pk,na,dis['marks1'],dis['marks2'],dis['marks3'],dis['marks4'],dis['marks5'],dis['marks6'],dis['marks7'],dis['marks8'],dis['marks9'],dis['marks10']) c.execute(query) conn.commit() except KeyError: st.warning("Please Login") except MySQLdb.IntegrityError: st.warning("Already Submitted") except UnboundLocalError: st.warning("Please answer all questions") #CREATE TABLE survey (pk int PRIMARY KEY,name varchar(100),mone int,mtwo int,mthree int,mfour int,mfive int ,msix int,mseven int,meight int,mnine int,mten int,meleven int,mtwelve int,mthirteen int , mfourteen int,mfifteen int,msixteen int, mseventeen int, meighteen int,mnineteen int,mtwenty int); #query = 'INSERT INTO quiz(pk,name,mone,mtwo,mthree,mfour,mfive,msix,mseven,meight,mnine,mten,meleven,mtwelve,mthirteen, mfourteen,mfifteen,msixteen, mseventeen, meighteen,mnineteen,mtwenty) VALUES ("%s", "%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s");' % (pk,na,diss['marks1'],diss['marks2'],diss['marks3'],diss['marks4'],diss['marks5'],diss['marks6'],diss['marks7'],diss['marks8'],diss['marks9'],diss['marks10'],diss['marks11'],diss['marks12'],diss['marks13'],diss['marks14'],diss['marks15'],diss['marks16'],diss['marks17'],diss['marks18'],diss['marks19'],diss['marks20']) if st.button("Check your result", key='result'): try: with st.spinner(text="DyslexiaML is Analyzing"): pred = prediction(user_prime_key=pk) if int(pred) == 2: st.balloons() st.success("Your Child Does Not Has Dyslexia!! ") elif int(pred) == 1: st.success( "Your Child Has Mild Dyslexia Symptoms. Consult Doctor " ) else: st.success( "Your Child Has Dyslexia Symptoms. Consult Doctor ") except UnboundLocalError: st.warning("Please Login")
# In[11]: normX = featurescaling(X[:, 1:]) X[:, 1:] = normX[0] # In[12]: theta = np.zeros(shape=(X.shape[1], 1)) # In[13]: result = gradientdescent(X, y, theta, 0.05, 5000, 0) finaltheta = result[0] # In[29]: from model import prediction # In[30]: predict = prediction(finaltheta, normX[1], normX[2]) # In[37]: import pickle modelname = modelname + ".pkl" with open(modelname, 'wb') as output: pickle.dump(predict, output)
def predict(): predicted_talks = prediction() return jsonify(predicted_talks), 200
import tfutils.opt import tfutils.modeling import data import model as mnist import trainer # Data batcher = data.batcher() x, y = batcher.placeholders() # Model logits = mnist.logits(x) # logits # Accuracy y_hat = mnist.prediction(logits) # predicted label accuracy = tfutils.modeling.accuracy(y, y_hat) # Optimization step = tfutils.opt.global_step() cost = mnist.cost(y, logits, regularize=True) train_step = tf.train.MomentumOptimizer(0.0005, 0.9).minimize( cost, global_step=step) model_vars = { 'x': x, 'y': y, 'logits': logits, 'y_hat': y_hat, 'accuracy': accuracy, 'cost': cost,
def train(): global FLAGS training = tf.placeholder(tf.bool) global_step = tf.get_variable( 'global_step', trainable=False, shape=(), dtype=tf.int32, initializer=tf.zeros_initializer()) x = tf.placeholder( tf.float32, shape=[FLAGS.batch_size, FLAGS.sequence_len]) seq_length = tf.placeholder(tf.int32, shape=[FLAGS.batch_size]) y_indexs = tf.placeholder(tf.int64) y_values = tf.placeholder(tf.int32) y_shape = tf.placeholder(tf.int64) y = tf.SparseTensor(y_indexs, y_values, y_shape) num_channels = [FLAGS.hiddens] * (FLAGS.layers - 1) + [5] kernel_size = FLAGS.ksize dropout = FLAGS.dout logits, ratio = model.inference(x, num_channels, FLAGS.sequence_len, kernel_size, training, dropout) ctc_loss = model.loss(logits, seq_length, y) tf.summary.scalar('ctc_loss', ctc_loss) opt = model.train_opt( FLAGS.step_rate, FLAGS.max_steps, global_step=global_step, opt_name="Adam") gradients = opt.compute_gradients(ctc_loss) """ for g in gradients: tf.summary.histogram("%s-grad" % g[1].name, g[0]) """ step = opt.apply_gradients(gradients, global_step=global_step) learningrate=opt._lr error,predictdense = model.prediction(logits, seq_length, y) init = tf.global_variables_initializer() saver = tf.train.Saver(max_to_keep=2) summary = tf.summary.merge_all() print("Training settings:") for pro in dir(FLAGS): if not pro.startswith('_'): print("%s:%s" % (pro, getattr(FLAGS, pro))) sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) if FLAGS.retrain == False: sess.run(init) print("Model inited, begin loading data. \n") else: saver.restore( sess, tf.train.latest_checkpoint(FLAGS.model_dir + FLAGS.model_name)) print("Model loaded, begin loading data. \n") summary_writer = tf.summary.FileWriter( FLAGS.model_dir + FLAGS.model_name + os.path.sep + 'summary' + os.path.sep, sess.graph) train_data, vali_data = generate_train_valid_datasets() start = time.time() for i in range(FLAGS.max_steps): # print('train_data shape : ', len(train_data.event)) batch_x, seq_len, batch_y = train_data.next_batch(FLAGS.batch_size) indxs, values, shape = batch_y feed_dict = { x: batch_x, seq_length: seq_len / ratio, y_indexs: indxs, y_values: values, y_shape: shape, training: True } loss_val, _ = sess.run([ctc_loss, step], feed_dict=feed_dict) print('learning rate: ',sess.run(learningrate)) print('iteration:%d,loss_val:%5.3f' % (i,loss_val)) # validation every 10 iterations if i % 10 == 0: global_step_val = tf.train.global_step(sess, global_step) valid_x, valid_len, valid_y = vali_data.next_batch(FLAGS.batch_size) indxs, values, shape = valid_y feed_dict = { x: valid_x, seq_length: valid_len / ratio, y_indexs: indxs, y_values: values, y_shape: shape, training: True } error_val = sess.run(error, feed_dict=feed_dict) # print(sess.run(predictdense,feed_dict=feed_dict)) end = time.time() print("Step %d/%d Epoch %d, batch number %d, train_loss: %5.3f validate_edit_distance: %5.3f Elapsed Time/step: %5.3f" % (i, FLAGS.max_steps, train_data.epochs_completed,train_data.index_in_epoch, loss_val, error_val,(end - start) / (i + 1))) saver.save( sess, FLAGS.model_dir + FLAGS.model_name + os.path.sep + 'model.ckpt', global_step=global_step_val) summary_str = sess.run(summary, feed_dict=feed_dict) summary_writer.add_summary( summary_str, global_step=global_step_val) summary_writer.flush() global_step_val = tf.train.global_step(sess, global_step) print("Model %s saved." % (FLAGS.model_dir + FLAGS.model_name)) print("Reads number %d" % (train_data.reads_n)) saver.save( sess, FLAGS.model_dir + FLAGS.model_name + os.path.sep + 'final.ckpt', global_step=global_step_val)
def main(): if os.path.isfile(macro._LOCAL_SAVE_DATA) == 0: # download data and compute featuers (see "download_data.py") # atomic_numbers use to compute composition vector # labels is target properties (formation energy) train_labels, compositions, features, atomic_numbers = dl.get_data() # compute bag-of-atom vector that trains GAN (see "preprocess.py") boa_vectors = pre.compute_bag_of_atom_vector(compositions, atomic_numbers) train_data = np.concatenate([boa_vectors, features], axis=1) save_data = pd.DataFrame( np.concatenate([train_labels, train_data], axis=1)) save_data.to_csv(macro._LOCAL_SAVE_DATA, index=False, header=False) else: data = pd.read_csv(macro._LOCAL_SAVE_DATA, delimiter=',', engine="python", header=None) data = np.array(data) train_labels, train_data = np.split(data, [1], axis=1) # normalization of training data such that min is 0 and max is 1 (see "preprocess.py") normalized_train_data, data_max, data_min = pre.normalize_for_train( train_data) normalized_train_labels, max_train_prop, min_train_prop = pre.normalize_for_train( train_labels) # Save normalization parameter to .csv to use generation save_data = pd.DataFrame( np.concatenate([max_train_prop, min_train_prop, data_max, data_min], axis=0)) save_data.to_csv(macro._SAVE_NORMALIZATION_PARAM, index=False, header=False) ### start initialization of training GAN ### # set hyperparameters batch_size = macro._BATCH_SIZE # batch size noise_dim = macro._NOISE_DIM # dimension of noise to input generator property_dim = macro._PROP_DIM # the number of properties lamb = macro._LAMB # hyperparameter for W-GAN-GP max_epoch = macro._MAX_EPOCH # maximum iteration of outer loop max_train_only_dis = macro._MAX_EPOCH_TRAIN_DISCRIMINATOR # maximum iteration of inner loop defined by W-GAN-GP paper (https://arxiv.org/pdf/1704.00028.pdf) max_loop = int(train_data.shape[0] / batch_size) # set model (see "model.py") # in this code, we apply AC-GAN based network architecture (https://arxiv.org/abs/1610.09585) # difference between AC-GAN is that our model is the regression, not classification gen = model.generator(normalized_train_data.shape[1]) dis = model.discriminator(normalized_train_data.shape[1]) # rf is the output layer of discriminator that discriminates real or fake rf = model.real_fake() # pred is the output layer of discriminator that predicts target property pred = model.prediction() # set optimization method dis_opt = Adam(lr=1.0e-4, beta_1=0.0, beta_2=0.9) gen_opt = Adam(lr=1.0e-4, beta_1=0.0, beta_2=0.9) # first set discriminator's parameters for training gen.trainable = False # generator's parameter does not update dis.trainable = True rf.trainable = True pred.trainable = True # set variables when inputting real data real_inputs = Input(shape=normalized_train_data.shape[1:]) dis_real_outputs = dis(real_inputs) real_fake_from_real = rf(dis_real_outputs) predictions_from_real = pred(dis_real_outputs) # set variables when inputting fake data fake_inputs = Input(shape=(noise_dim + property_dim, )) gen_fake_outputs = gen(fake_inputs) dis_fake_outputs = dis(gen_fake_outputs) real_fake_from_fake = rf(dis_fake_outputs) # set loss function for discriminator # in this case, we apply W-GAN-GP based loss function because of improving stability # W-GAN-GP (https://arxiv.org/pdf/1704.00028.pdf) # W-GAN-GP is unsupervised training, on the other hand, our model is supervised (conditional). # So, we apply wasserstein_loss to real_fake part and apply mean_squared_error to prediction part interpolate = model.RandomWeightedAverage()( [real_inputs, gen_fake_outputs]) dis_interpolate_outputs = dis(interpolate) real_fake_interpolate = rf(dis_interpolate_outputs) # gradient penalty of W-GAN-GP gp_reg = partial(model.gradient_penalty, interpolate=interpolate, lamb=lamb) gp_reg.__name__ = 'gradient_penalty' # connect inputs and outputs of the discriminator # prediction part is trained by only using training dataset (i.e., predict part is not trained by generated samples) dis_model = Model(inputs=[real_inputs, fake_inputs],\ outputs=[real_fake_from_real, real_fake_from_fake, real_fake_interpolate, predictions_from_real]) # compile dis_model.compile(loss=[model.wasserstein_loss,model.wasserstein_loss,\ gp_reg,'mean_squared_error'],optimizer=dis_opt) # second set generator's parameters for training gen.trainable = True # generator's parameters only update dis.trainable = False rf.trainable = False pred.trainable = False # set variables when inputting noise and target property gen_inputs = Input(shape=(noise_dim + property_dim, )) gen_outputs = gen(gen_inputs) # set variables for discriminator when inputting fake data dis_outputs = dis(gen_outputs) real_fake = rf(dis_outputs) predictions = pred(dis_outputs) # connect inputs and outputs of the discriminator gen_model = Model(inputs=[gen_inputs], outputs=[real_fake, predictions]) # compile # generator is trained by real_fake classification and prediction of target property gen_model.compile(loss=[model.wasserstein_loss, 'mean_squared_error'], optimizer=gen_opt) # if you need progress bar progbar = Progbar(target=max_epoch) # set the answer to train each model real_label = [-1] * batch_size fake_label = [1] * batch_size dummy_label = [0] * batch_size #real = np.zeros((batch_size,train_data.shape[1]), dtype=np.float32) inputs = np.zeros((batch_size, noise_dim + property_dim), dtype=np.float32) # epoch for epoch in range(max_epoch): # iteration for loop in range(max_loop): # shuffle to change the trainng order and select data sdata, slabels, bak = pre.paired_shuffle(normalized_train_data, normalized_train_labels) real = sdata[loop * batch_size:(loop + 1) * batch_size] properties = slabels[loop * batch_size:(loop + 1) * batch_size] # generator's parameters does not update gen.trainable = False dis.trainable = True rf.trainable = True pred.trainable = True # train discriminator for train_only_dis in range(max_train_only_dis): noise = np.random.uniform( -1, 1, (batch_size, noise_dim)).astype(np.float32) for i in range(len(noise)): inputs[i] = np.hstack((noise[i], properties[i])) dis_loss = dis_model.train_on_batch( [real, inputs], [real_label, fake_label, dummy_label, properties]) # second train only generator gen.trainable = True dis.trainable = False rf.trainable = False pred.trainable = False noise = np.random.uniform(-1, 1, (batch_size, noise_dim)).astype( np.float32) for i in range(len(noise)): inputs[i] = np.hstack((noise[i], properties[i])) gen_loss = gen_model.train_on_batch([inputs], [real_label, properties]) # if you need progress bar progbar.add(1, values=[("dis_loss", dis_loss[0]), ("gen_loss", gen_loss[0])]) # save generated samples and models eval.save(normalized_train_data, gen, dis, pred, rf) backend.clear_session()
def main(filename): print('loading data') # Establish database connection with open( '/data/groups/schools1/mlpolicylab_fall20_schools1/pipeline/db_info.yaml', 'r') as f: db_params = yaml.safe_load(f)['db'] engine = create_engine('postgres://:@{host}:{port}/{dbname}'.format( host=db_params['host'], port=db_params['port'], dbname=db_params['dbname'], )) # Load data from database to dataframe df = load_data(filename, engine) # Split dataframe into train and test data. splits, years_reference = train_test_split(df) for i, (train_df, test_df) in enumerate(splits): print(f'processing split {i}') # Explore data for each of the cohort explore_data(train_df) # Process train and test data seperately updated_df_train = process_data(train_df) updated_df_test = process_data(test_df) # Upload the test and train data to database for future reference and easy retrival updated_df_train.columns = [ col.replace('(', '').replace(')', '').replace(' ', '_').replace('/', '_') for col in updated_df_train.columns ] updated_df_test.columns = [ col.replace('(', '').replace(')', '').replace(' ', '_').replace('/', '_') for col in updated_df_test.columns ] table_name = timestamp + '_' + str(years_reference[i][1]) + '_' + str( years_reference[i][0]) df_to_db(table_name, 'processed_data', updated_df_train, updated_df_test, engine) # Retreive test and train data from database processed_train, processed_test = db_to_df(table_name, 'processed_data', engine) updated_df_train_f = processed_train.copy() updated_df_train_l = processed_train.copy() updated_df_test_f = processed_test.copy() updated_df_test_l = processed_test.copy() # Create features for test and train data features_train, train_student_ids = create_features(updated_df_train_f) features_test, test_student_ids = create_features(updated_df_test_f) # Create labels label_train = create_label(updated_df_train_l) label_test = create_label(updated_df_test_l) # Concatenating features and labels to save in the database train_concat = pd.concat([features_train, label_train], axis=1, sort=False) test_concat = pd.concat([features_test, label_test], axis=1, sort=False) # Calculating baseline rate using grade 9 gpa and base rate baseline_precision = baseline(test_concat, years_reference[i]) base_rate = sum(train_concat.not_graduated) / len(train_concat) # Saving and reading from database df_to_db(table_name, 'model_data', train_concat, test_concat, engine) model_train, model_test = db_to_df(table_name, 'model_data', engine) features_train = model_train.iloc[:, :-1] label_train = model_train.iloc[:, -1] features_test = model_test.iloc[:, :-1] label_test = model_test.iloc[:, -1] # Build model algos = ["Logistic", "SVM", "RandomForest", "DecisionTree"] gs_params = { "Logistic": ParameterGrid({ 'solver': ['lbfgs', 'liblinear', 'saga'], 'C': [0.001, 0.01, 0.1, 1, 2, 5, 10] }), "SVM": ParameterGrid({ 'C': [0.01, 1, 2, 5, 10], 'kernel': ['rbf', 'sigmoid'] }), "RandomForest": ParameterGrid({ 'n_estimators': [30, 50, 100, 500, 1000, 10000], 'max_depth': [5, 10, 20, 50], 'min_samples_split': [5, 10, 15], 'max_features': ['auto', 'log2', 'sqrt'] }), "DecisionTree": ParameterGrid({ 'criterion': ['gini', 'entropy'], 'max_depth': [5, 10, 20, 50], 'min_samples_split': [5, 10, 15] }) } print('performing model grid search') for model_name in algos: params = gs_params[model_name] for param in params: model = build_model(features_train, label_train, model_name, param) # Perform prediction pred_proba_train = prediction(features_train, model) pred_proba_test = prediction(features_test, model) # Convert prediction probabilities to dataframes for further processing pred_train_df = pd.DataFrame(pred_proba_train, columns=['probability']) pred_test_df = pd.DataFrame(pred_proba_test, columns=['probability']) # Retreive hyperparameters for processing hyperparameters = ' '.join( ["{}: {}".format(key, param[key]) for key in param.keys()]) pred_train_df['model'], pred_train_df[ 'params'] = model_name, hyperparameters pred_test_df['model'], pred_test_df[ 'params'] = model_name, hyperparameters # Get the prediction scores for test and train data predictions_train = pd.concat( [train_student_ids, pred_train_df], axis=1, sort=False) predictions_test = pd.concat([test_student_ids, pred_test_df], axis=1, sort=False) # Calculate the bias metrics TPR_gender, FDR_gender = bias_metrics(predictions_test, processed_test, 'gender') TPR_disadvantagement, FDR_disadvantagement = bias_metrics( predictions_test, processed_test, 'disadvantagement') # Load the prediction results to database for creating visualizations df_to_db(table_name, 'predictions', predictions_train, predictions_test, engine) # Evaluate model metric = evaluate_model(features_test, label_test, model, model_name, baseline_precision, hyperparameters, columns=model_train.columns[:-1]) # saving results df_summary = pd.DataFrame({ 'test_year': years_reference[i][1], 'train_since': years_reference[i][0], 'algorithm': model_name, 'hyperparameters': hyperparameters, 'baserate': base_rate, 'baseline': [baseline_precision], 'precision': metric, 'TPR_gender': TPR_gender, 'FDR_gender': FDR_gender, 'TPR_disadvantagement': TPR_disadvantagement, 'FDR_disadvantagement': FDR_disadvantagement }) df_summary.to_sql(name=timestamp, schema='performance_metrics', con=engine, if_exists='append', index=False)
batch_size = 16 print("Batch Size", batch_size) # converting the data into sequences of batch_size # Each sequence/window is normalised train_x, train_y, norm_y_train = seq_and_norm(train, batch_size) test_x, test_y, norm_y_test = seq_and_norm(test, batch_size) train_loss, val_loss, model = LSTM_train(train_x, train_y, batch_size) plt.plot(train_loss, label="Training Loss") plt.plot(val_loss, label='Validation Loss') plt.legend() plt.show() # predictions on train and test + inverse transformation train_pred = prediction(train_x, model, norm_y_train) test_pred = prediction(test_x, model, norm_y_test) test_rmspe = eval_metrics(norm_y_test[:, 0], test_pred) train_rmspe = eval_metrics(norm_y_train[:, 0], train_pred) print("Test Set RMSPE: {rmspe}%".format(rmspe=test_rmspe)) print("Train Set RMSPE: {rmspe}%".format(rmspe=train_rmspe)) # plot trading signal prediction and actual generate_plot(index_train, [train_pred, norm_y_train[:, 0]], ["Predicted Train", "Actual Train"], "Trading Signal RMSPE {}%".format(train_rmspe), "Trading Signal", "Time Period") generate_plot(index_train, [test_pred, norm_y_test[:, 0]], ["Predicted Test", "Actual Test"],