def params_output(self): tf.reset_default_graph() self.creat_model() model_path = tf.train.latest_checkpoint(self.path_data + 'model_save\\') saver = tf.train.Saver() # sess = tf.InteractiveSession() with tf.Session() as sess: # 读取模型参数 saver.restore(sess, model_path) # tf.global_variables() # sess=tf.InteractiveSession() # sess.run(tf.global_variables_initializer()) # 判断待存储参数的文件夹是否存在,若不存在,则新建一个。 if not os.path.exists(self.path_data + 'model_paras\\'): os.makedirs(self.path_data + 'model_paras\\') # 遍历模型参数并存储到csv文件里 for var in tf.global_variables(): print(var) var_value = sess.run(var) var_name = var.name.replace(':', '_').replace(r'/', '_') dataframe(var_value).to_csv( self.path_data + u'model_paras\\{}.csv'.format(var_name), sep=',', encoding='utf_8_sig') # w_1=tf.get_default_graph().get_tensor_by_name('w:0') # w_1=dataframe(w_1.eval()) # w_1.to_csv('.\para_output'+u'\\w_1'+u'.csv',sep=',',encoding='utf_8_sig') return
def import_file_to_database(conn): df = pd.read_csv('owid-covid-data.csv') data = pd.read_csv('country-and-continent-codes-list-csv_csv.csv') pd.dataframe(data) # clean_characters(df) df = df.replace(np.nan, 0) df = df.set_index('iso_code') df = df.drop(0) convert_data_types(df) delete_columns_from_dataframe(df) df.to_sql('DailyCOVID192020', conn, if_exists='replace', index=True)
def OHLC_resample(dataframe, timeframe, column = 'ask'): # =============================================== DESCRIPTION ====================================================== # OHLC Resampler to turn raw data into candlestick data if required, and to switch timeframes, e.g. from 1M to 1H. # param (1) - dataframe: dataframe containing the data we want to resample. # param (2) - timeframe: timeframe that we want for resample. # param (3) - column: which column we are resampling (bid or ask), default set to ask. # return (1) - resampled OHLC data for the given timeframe. grouped = dataframe.groupedby('Symbol') # The below is to turn raw data into candlestick format. This will be required if tick data if np.any(dataframe.columns == 'Ask'): if column == 'ask': ask = grouped['Ask'].resample(timeframe).ohlc() ask_vol = grouped['Ask_Vol'].resample(timeframe).count() resampled = pd.dataframe(ask) resampled['Ask_Vol'] = ask_vol elif column == 'bid': bid = grouped['Bid'].resample(timeframe).ohlc() bid_vol = grouped['Bid_Vol'].resample(timeframe).count() resampled = pd.dataframe(bid) resampled['Bid_Vol'] = bid_vol else: raise ValueError('Column must be a strong. Either ask or bid') # Now resample data that us already in 'candlestick' format (OHLC). To a higher time period elif np.any(dataframe.columns == 'CLOSE'): open = grouped['OPEN'].resample(timeframe).ohlc() close = grouped['CLOSE'].resample(timeframe).ohlc() high = grouped['HIGH'].resample(timeframe).ohlc() low = grouped['LOW'].resample(timeframe).ohlc() ask_vol = grouped['Volume'].resample(timeframe).count() resampled = pd.Dataframe(open) resampled['HIGH'] = high resampled['LOW'] = low resampled['CLOSE'] = close resampled['Volume'] = ask_vol resampled = resampled.dropna() return resampled
def freqPrcnt(dsn, var): dataset = pd.dataframe(dsn) uniq_prcnt = round(prop_table(ftable(dataset[var]), 1) * 100, digits=1) lngth = nlevels(unique(dataset[var])) prcnt = dict() for i in range(1, lngth): prcnt[i] = uniq_prcnt[i]
def remap(self, df): ''' Remap the colums of input data to Chirp-formatted output data. If multiple columns map to the same Chirp-column, they will be concatenated into that column. Args: df (pd.DataFrame) Returns: pd.DataFrame ''' return df.rename(self.mapping, inplace=True) out_columns = {} for k in df.keys(): if k in self.mapping.keys: chirp_field = self.mapping[k] if chirp_field is not None: out_columns[chirp_field] = self._array_new_append( k, out_columns[chirp_field]) out = pd.dataframe() for k in out_columns.keys(): for k2 in out_columns[k]: out[k] return out def _array_new_append(self, v, a): ''' Add value v to array a, or create a new array ''' if a is None: return [v] else: a.append(v) return v
def to_df(X, Y, qualitatif=False): """transform X and Y to a pandas dataframe.""" df = pd.dataframe(np.c_[X, Y]) df.columns = [ 'elevation', 'aspect', 'slope', 'horizontal_distance_to_hydrology', 'vertical_distance_to_hydrology', 'horizontal_distance_to_roadways', 'hillshade_9am', 'hillshade_noon', 'hillshade_3pm', 'horizontal_distance_to_fire_points', 'wilderness_area1', 'wilderness_area2', 'wilderness_area3', 'wilderness_area4', 'soil_type1', 'soil_type2', 'soil_type3', 'soil_type4', 'soil_type5', 'soil_type6', 'soil_type7', 'soil_type8', 'soil_type9', 'soil_type10', 'soil_type11', 'soil_type12', 'soil_type13', 'soil_type14', 'soil_type15', 'soil_type16', 'soil_type17', 'soil_type18', 'soil_type19', 'soil_type20', 'soil_type21', 'soil_type22', 'soil_type23', 'soil_type24', 'soil_type25', 'soil_type26', 'soil_type27', 'soil_type28', 'soil_type29', 'soil_type30', 'soil_type31', 'soil_type32', 'soil_type33', 'soil_type34', 'soil_type35', 'soil_type36', 'soil_type37', 'soil_type38', 'soil_type39', 'soil_type40', 'cover_type' ] if qualitatif: # a poursuivre : peut être avec grep plutot que les index, et pour les wilderness aussi # all soil columns in one df['soil'] = None idX_soil_debut = 14 idX_soil_fin = 54 for i in range(idX_soil_debut, idx_soil_fin): l_idX_bool = df.iloc[:, i].astype(bool) if True in l_idX_bool: df.loc[l_idX_bool, 'soil'] = df.columns[i] df.drop(df.columns[idX_soil_debut:idx_soil_fin], axis=1, inplace=True) return df
def generate_freq(df): '''Takes an input data frame and generates a histogram of number of tweets binned by month. Inputs: Pandas data frame imported from *.csv or *.pkl file Input parameter called "increment", which determined by what time interval the tweets are organized Outputs: Histogram ''' date_bounds = pd.Series(df['tweet_time'].tolist()) date_bounds_ym = (date_bounds.dt.strftime('%Y-%m')).tolist() df['date_md'] = np.array(date_bounds_ym) sort = df.sort_values(by=['date_md']) frq = sort['date_md'].value_counts().to_dict() frq_df = sort['date_md'].value_counts() od = collections.OrderedDict(sorted(frq.items())) rf_dates = list() for item in list(od.keys()): date_rf = date_reformat(item) rf_dates.append(date_rf) data = {"Date": rf_dates, "Freq": list(od.values())} graph_frame = pd.dataframe(data=data) frq_df.to_csv(os.path.join(path, 'tweet_freq_' + today + '.csv')) ax = graph_frame.plot.bar(x="Date", y="Freq", rot=45) plt.show()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--img_url', type=str, required=True, help='input url') parser.add_argument( '--output_dir', type=str, default='results/', help='output directory to save the results (default: results/') parser.add_argument('--model', type=str, default='face_model.pkl', help='path to trained model (default: face_model.pkl)') args = parser.parse_args() output_dir = args.output_dir image_url = args.img_url model_path = args.model if not os.path.isdir(output_dir): os.mkdir(output_dir) # load the model with open(model_path, 'rb') as f: clf, labels = pickle.load(f, encoding="latin1") pred, locs = predict_one_image(image_url, clf, labels, True) if not locs: print("No people found!") return locs = pd.dataframe(locs, columns=['top', 'right', 'bottom', 'left']) df = pd.concat([pred, locs], axis=1) img = draw_attributes(image_url, df) cv2.imwrite(os.path.join(output_dir, "image.jpg"), img) output_csvpath = os.path.join(output_dir, 'image.csv') df.to_csv(output_csvpath, index=False)
def fetch_file(self): try: if not os.path.exists('../data'): os.makedirs('../data') except OSError: print('Plis, place me in the right directory idiot.') exit() self.dataset = pd.dataframe()
def main(): summary_data = get_summary_data() capital_data = summary_data['assets_under_management_B'] weight = pd.dataframe(capital_data / sum(capital_data).todataframe) weight.to_csv( r"C:\My Files\Study\17 Spring\800 - Special Problems in FE (MS)\Code\FE-800\csv\weight.csv" ) print(summary_data)
def fitModel(self, X, y, X_test, n): """ function to optimize parameter and x and y being training data for base models and n being splitting ratio for validation set kindly realize that final metamodel is trained upon and X_test being testing or realtime data """ self.X_train, self.X_val, self.y_train, self.y_val = train_test_split( X, y, test_size=n, random_state=42) self.df_val=pd.dataframe(X_val) self.df_test=pd.dataframe(X_test) for model in self.base_models_: model.fit(X_train, y_train) self.val_pred=model.predict(X_val) self.df_val=pd.concat([df_val,val_pred],axis=1) self.val_test=model.predict(X) self.df_test=pd.concat([df_test,val_test],axis=1) # Now train the cloned meta-model using the out-of-fold predictions as new feature self.meta_model_.fit(self.df_val, self.y_val)
def IterateCheck_UR_Stable(row): # takes row from df of unique eq # take equilibrium value new_u_vals_mat = np.array(uvec).reshape(n, 3) - np.transpose( du1vec, du2vec, dbuvec) # newdf = pd.dataframe(data=new_u_vals_mat, columns=['u1', 'u2', 'bu'])
def filter(method='linear', df=None, fs=1000, cutoff="50", order=2): #takes in a dataframe, a sampling frequency (1 kHz by default), a cutoff frquency, and an order and applies a lowpass butterworth filter to the acceleration data df["ax"] = df["ax"].interpolate(method=method, limit_direction='forward') nyq = 0.5 * fs normal_cutoff = cutoff / nyq b, a = butter(order, normal_cutoff, btype='low', analog=False) data = df["ax"].to_numpy() y = lfilter(b, a, data) data_out = pd.dataframe(y) return data_out
def get_korean_symbol_dataframe(): df_korSym = dataframe() df_korSym['Hangul'] = META_TAGS + HANGULS df_korSym['Symbol'] = META_TAGS + SYMBOLS # df_korSym['Hangul'] = HANGULS # df_korSym['Symbol'] = SYMBOLS # for tag in META_TAGS: # df_korSym.loc[len(df_korSym)] = [tag, tag] return df_korSym
def states_game(): right_tries = 0 wrong_tries = 0 tammy.penup() screen.tracer(0) tammy.goto(100, 280) tammy.hideturtle() tammy.write(f"Right tries{right_tries}/50", align="center", font=("Courier", 20, "normal")) tim.goto(100, 260) tim.write(f"Wrong tries{wrong_tries}", align="center", font=("Courier", 20, "normal")) guessed_states = [] while len(guessed_states) < 50: answer_state = screen.textinput( title="Guess the state", prompt="Whats another state name ?").title() if answer_state == "Exit": missing_states = [] for state in list_states: if state not in guessed_states: missing_states.append(state) new_data = pd.dataframe(missing_states) new_data.to_csv("states_to_learn.csv") for dic in states_dict: for key in dic: if dic[key] == answer_state: right_tries += 1 tammy.clear() tammy.hideturtle() tammy.write(f"Right tries{right_tries}/50", align="right", font=("Courier", 20, "normal")) guessed_states.append(dic[key]) x = dic['x'] y = dic['y'] timmy.hideturtle() timmy.penup() timmy.goto(x, y) timmy.write(answer_state, align='center', font=FONT) elif answer_state not in list_states and answer_state != "Exit": wrong_tries += 1 tim.clear() tim.write(f"Wrong tries{wrong_tries}", align="left", font=("Courier", 20, "normal"))
def tree2OTU_table(mvp_tree): """ get an OTU table from a mvp_tree """ series = [] for terminal in mvp_tree.feature_tree.get_terminals(): try: series.append(terminal.sample_series) except: print('there is no sample series in tree2OTU ') df = pd.dataframe(series) return df
def __init__(self, symbol, margin_ratio=None, instrument_type, point_value=None): '''Init an instrument, either stock or future. For stock, the margin_ratio should be 1 for default. For Furture, you need to give margin_ratio and point_value.''' self.symbol = symbol if margin_ratio is None: self.margin_ratio = 1 self.instrument_type = instrument_type if self.instrument_type == InstrumentType.Future: assert not point_value is None self.point_value = point_value else: self.point_value = 1 self.df = pd.dataframe()
def scale_ingredients_df(self, times): """ Scale ingredients, simple scaling :param ingredients: :param times: :return: """ df = pd.dataframe(self.recipe) ingredients = self.get_ingredients(df) scaled = ingredients['amount'] * times return scaled
def unpacking_bike_numbers(column): """ getting unique list of bikes """ bike_unpack = pd.dataframe(df[column].tolist(), index=df.index) colnames = list(bike_unpack.columns.values) all_bikes = [] all_bikes = bike_unpack[0] for c in colnames: data = bike_unpack[c] pd.concat([all_bikes, data]) all_bikes = all_bikes.unique() return all_bikes
def budpredict(): connection = pg.connect("host='" + DB['host'] + "' dbname=" + DB['dbname'] + " user="******" password='******'password'] + "'") dl = pd.read_sql_query( "select table_name from table_meta where table_meta_id='" + request.json['table_meta_id'] + "';", con=connection) tname = dl['table_name'][0] target = request.json['target'][0] ohl = { 'poutcome': ['poutcome_other', 'poutcome_success', 'poutcome_unknown'], 'marital': ['marital_married', 'marital_single'], 'education': ['education_secondary', 'education_tertiary', 'education_unknown'], 'default': ['default_yes'], 'housing': ['housing_yes'], 'contact': ['contact_telephone', 'contact_unknown'], 'month': [ 'month_aug', 'month_dec', 'month_feb', 'month_jan', 'month_jul', 'month_jun', 'month_mar', 'month_may', 'month_nov', 'month_oct', 'month_sep' ], 'loan': ['loan_yes'], 'y': ['y_yes'], 'job': [ 'job_blue-collar', 'job_entrepreneur', 'job_housemaid', 'job_management', 'job_retired', 'job_self-employed', 'job_services', 'job_student', 'job_technician', 'job_unemployed', 'job_unknown' ] } df = pd.dataframe(request.json['coldata']) for cols in list(df.columns): if (cols in ohl.keys()): df_new = pd.DataFrame(columns=ohl[cols]) for i, r in df.iterrows(): df_new.loc[i] = [0] * len(ohl[cols]) value = cols + '_' + df[cols][i] if (value in ohl[cols]): df_new[value][i] = 1 df = df.drop(columns=cols) df = pd.concat([df, df_new], axis=1, sort=True) with open('tpot_class_' + tname_nc0g1 + '.json', 'r') as fp: col = json.load(fp) mod = joblib.load('tpot_pipeline_' + tname + '_' + target + '.pkl') md = mod.predict(df) res = {'data': col[target][int(md[0])], 'Reply': 'Here you go'} return Response(response=json.dumps(res), status=200)
def getMyRetweetsFavourites(number): data = getMyTweetsData(number) retweets = data[2::4] favourites = data[3::4] for e in favourites: e = int(e) for e in retweets: e = int(e) #print(data) sum_f = sum(favourites) sum_r = sum(retweets) d = {'retweets': [sum_r], 'favourites': [sum_f]} df = dataframe(data=d) return (['retweets','favourites'], [sum_r,sum_f])
def openCsv(filePath, default = ["new df here"]): """ returns the content of the csv file if it exists. Parameters: - filePath: the absolute or relative path to the .csv file - default: default value to load if the file is not located """ try: content = pd.read_csv(filePath, error_bad_lines=False) except Exception: print(f"exception, the filename {filePath} you requested to open was not found.") if (int(input("do you want to make a new file? 1 for yes, 0 for no")) == 1): content = pd.dataframe(default) content.toCsv(filePath, index=False, header=False) return content
def read_all(filetype, startdir='.', recursive=True): ''' Read in all files of common type from a folder, concatenate by row into pandas dataframe filetype = string denoting which file to look for, including globs startdir = directory to start looking in recursive = search subdirectories? ''' out = pd.dataframe() # initiate df for output for dirpath, dirs, files in os.walk(startdir): for file in files: contents = read_default(os.path.join(dirpath, file)) contents['file'] = os.path.basename(file) out.append(contents) return out
def build_comparison_table(self,exhibits): ''' Makes a pandas data frame comparing exhibits ''' comparison = pd.dataframe(columns = self.ex_list, index = self.ex_list) for ex in self.ex_list(): comparison[ex][ex] = 0.0 for (ex1,ex2) in itertools.combinations(self.ex_list,2): v1 = self.ex_vects[ex1[:2]][ex1] v2 = self.ex_vects[ex2[:2]][ex1] d = spatial.distance.cosine(v1,v2) comparison[ex1][ex2] = d comparison[ex2][ex1] = d return comparison
def fetch_csv(directory='/home/', ticker='AMZN'): try: data = pd.read_csv('data-' + ticker + '.csv', sep='\t') except Exception: print('Reading csv for ticker %s failed' % ticker) try: AlexandreScraper.somethingScraper(directory=directory, ticker=ticker) except Exception: print('Scrapping failed for ticker %s ' % ticker) data = pd.dataframe() else: data = pd.read_csv('data-' + ticker + '.csv', sep='\t') else: print('Read csv for ticker %s successful' % ticker) return data
def predict_test(): vector = pd.dataframe([request.json]) if (database.query(vector.id)) ==True: loaded_model = joblib.load(filename) res = str(loaded_model.predict(vector)[0]) result = [ { 'id':0 'prediction':res } ] return jsonify(result) else:
def dbupdate_contractfundamentals(db, stklst): # stklst[i] conté [fConId, fType, fSymbol, fLocalSymbol, fCurrency, fExchange, fTradingClass, fRating, fTradeType, fScanCode,fEpsNext,fFrac52wk, fBeta, fPE0, fDebtEquity, fEVEbitda,fPricetoFCFShare, fYield,fROE, fTargetPrice, fConsRecom,fProjEPS, fProjEPSQ, fProjPE) " # ] try: for i in range(len(stklst)): print('Updating contractfundamentals ' + str(stklst[i][0])) sql = "SELECT * FROM contractfundamentals WHERE fConId = '" + str( stklst[i][0]) + "' " rst = execute_query(db, sql) #print("rst ",rst[0][2],rst[0][19]) #print("stklsttttttttttt ",stklst[i][19]) if type(stklst[i][19]) == "float" and type(rst[0][19]) == "float": stklst[i][6] = stklst[i][19] / rst[0][19] else: stklst[i][6] = 0 print("fSymbol ", rst[0][2], "fTargetPrice ", rst[0][19], "newtargetprice ", stklst[i][19]) sql = "UPDATE contractfundamentals SET frating = 0" execute_query(db, sql) ''' if stklst[i][5] == 0: elif stklst[i][5] == 'M': sql = "UPDATE trades SET tShares = tShares - " + str(stklst[i][3]) + " ,tActive = 0 where tId = " + str(stklst[i][0]) execute_query(db, sql) sql = "INSERT INTO trades (tExecid, tAccId, tConId, tTime, tShares, tPrice, tCommission, tLiquidation, " sql = sql + "toptPrice, toptIV, toptDelta, toptGamma, toptVega, toptTheta, toptPVDividend, toptPriceOfUnderlying, tActive) " # al nou registre, modifiquem l'Execid afegin-hi una C a davant, tActive=1 i tShares = stklst[i][5] new_execid = 'C' + stklst[i][1] sql = sql + "SELECT '" + new_execid + "',tAccId, tConId, tTime," + str(stklst[i][3]) + ", tPrice, tCommission, tLiquidation, " sql = sql + "toptPrice, toptIV, toptDelta, toptGamma, toptVega, toptTheta, " sql = sql + "toptPVDividend, toptPriceOfUnderlying, 1 " # active = 1 sql = sql + "FROM trades WHERE tId = " + str(stklst[i][0]) execute_query(db, sql) ''' selectedstocks = pd.dataframe(stklst) print("selectedStocks", selectedstocks) except Exception as err: print(err) raise
def calculate(dataset_x, dataset_y): loss_list = ['benign', 'dos', 'probe', 'u2r', 'r2l'] model.fit(dataset_x, dataset_y) model_predicted = model.predict(test_x) model_predicted = pd.dataframe(model_predicted) model_predicted.columns = loss_list from sklearn.metrics import precision_score, mean_squared_error, f1_score precision_score = precision_score(test_y, model_predicted, average='micro') print("The precision at round ", round1, ' is ', precision_score) class_proba = model.predict_proba(test_x) loss_function = [] for columns in loss_list: loss_function.append( mean_squared_error(test_y[columns], class_proba[columns])) average_loss = int(sum(loss_function) / 5) print("The loss in ", round1, ' is average_loss')
def frame_filter(dataframe_col, year_repl): dataframe_col = pd.dataframe(dataframe_col[year_repl].dropna()) dataframe_col_re = dataframe_col[year_repl].str.split( ",", expand=True).add_prefix("col") dataframe_col_re.iloc[:, -1] = dataframe_col_re.iloc[:, -1].apply(int) female_data = dataframe_col_re[dataframe_col_re["col_1"] == "F"].sort_values("col_2", ascending=False).head() male_data = dataframe_col_re[dataframe_col_re["col_1"] == "M"].sort_values( "col_2", ascending=False).head() sum_year = dataframe_col_re["col_2"].sum() gender_sum = pd.pivot_table(dataframe_col_re, values=['col_2'], column=["col_1"], aggfunc=np.sum) plt.pie([gender_sum["F"], gender_sum["M"]], explode=[0, 0], labels=["female", "male"], autopct="%1.1f%%") plt.axis("equal") return plt.show()
def clean(dataframe): ''' Cleans raw data. ''' if isinstance(dataframe, pd.DataFrame): # modify content here if ('question1' in dataframe.columns): dataframe['question1_raw'] = dataframe.question1 dataframe['question1'] = clean_question(dataframe.question1) if ('question2' in dataframe.columns): dataframe['question2_raw'] = dataframe.question2 dataframe['question2'] = clean_question(dataframe.question2) if ('is_duplicate' in dataframe.columns): series = dataframe.is_duplicate series = series.apply(pd.to_numeric) dataframe['is_duplicate'] = series if ('id' in dataframe.columns): series = dataframe.id series = series.apply(pd.to_numeric) dataframe['id'] = series if ('qid1' in dataframe.columns): series = dataframe.qid1 series = series.apply(pd.to_numeric) dataframe['qid1'] = series if ('qid2' in dataframe.columns): series = dataframe.qid2 series = series.apply(pd.to_numeric) dataframe['qid2'] = series return dataframe else: raise InputError('dataframe', 'input object is not a pd.DataFrame') return pd.dataframe()
def get_daily_candle(self): '''Create daily candle data from existing dataframe''' self.daily_df = pd.dataframe()
unique = [k for k,g in itertools.groupby(sorted(toy))] unique toy toy.idx toy.ix toy.index.values toy[tnode]=toy.index.values toy['tnode']=toy.index.values toy['node']=toy.index.values toy itertools.groupby(AR) itertools.groupby(toy.AR) unique = [k for k,g in itertools.groupby(toy.AR)] unique unique.ix=unique.index.values df = pd.dataframe(unique) df = pd.DataFrame(unique) df df['k']=df.index.values df df.columns=['AR','k'] mg = pd.join(toy, df, on='AR') mg = pd.merge(toy, df, on='AR') mg unique = [k for k,g in itertools.groupby()] import readline for i in range(readline.get_current_history_length()): print readline.get_history_item(i) unique = [k for k,g in itertools.groupby(mg)] unique itertools.groupby(mg).groups()
scores_nbFeatures_easy = [] scores_nbFeatures_hard = [] scores_PCA_easy = [] scores_PCA_hard = [] for nb_feature in number_features: PCA_model = PCA(number_features) X_tmp = PCA_model.fit_transform(X_train_facile) print X_tmp.shape score_easy = {} score_hard = {} for (name,func) in possible_distances: dist = distances_pairs(X_tmp, pairs_idx,func) score_facile , score_difficile = roc_report(pairs_label,dist,name,False) score_easy[name] = score_facile score_hard[name] = score_difficile scores_PCA_easy.append(score_easy) scores_PCA_hard.append(score_hard) print pd.dataframe(scores_PCA_easy) plt.plot(number_features,scores_nbFeatures_easy,label='score facile') plt.plot(number_features,scores_nbFeatures_hard,label='score difficile') plt.legend(loc='best') plt.savefig('Importance de la PCA.png') plt.show() ''' X_train_hard, Y_train_hard = readfile('data_train_difficile') X_test_facile, Y_test_facile = readfile('data_test_facile') X_test_hard, Y_test_hard = readfile('data_test_difficile') '''
def create(y_predict): y_dataframe = pd.dataframe(y_predict) y_dataframe.to_csv()
# This is my test file for import pandas as pd newDataframe = pd.dataframe() print(type(newDataframe))