def doDirFix(dirList_, recurse_, deFuxDir_): # fold here ⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1 print(f"""{CF.NEWLINE}checking directories for sanity, and fixing what I can, any items I can't repair will give an uncaught exception intentionally until I figure out the most common things to happen and a way to fix them""") print(f"""{CF.INDENTIN}this list should not contain anything except directories, other entries will be skipped (continue)""") print(f"""{CF.INDENTIN}it is assumed you are handing this function a "good" list, symlinks and so forth managed previously, it just does what it is supposed to do""") # 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ for thisEntry_ in dirList_: CF.whirl() # fix directory modes, make your list correctly, passing in here it is assumed to be accurate, and since the rest of the code is somewhat useless without this being accomplished, there is no option for this # and no trial run, nor error checking by intent, also the list is assumed to be reversed, no exceptions are caught # ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ # 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ if (thisEntry_[FO.ICANWRITE] is not True) or (thisEntry_[FO.ICANEXECUTE] is not True): FO.setMode(thisEntry_[FO.PATH], FO.CHMODDIR) # ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 ⥣2 # likewise I prefer to have the defuxing of directories always done, rather than an option # strip directory names down to DIRBLACKLIST = "[a-zA-Z0-9./]+" # PCRE for directory characters to blacklist as it's result # this list is assumed to be reversed so that it operates from the deepest nesting out thus not invalidating the list # ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ ⥣1⥥ # 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ 2⥥ if thisEntry_[FO.BLACKTAIL] != "": FO.MOVE(thisEntry_[FO.PATH], thisEntry_[FO.WHITEFULLNAME])
def rating_rec(): if request.method == 'POST': idcode = request.form['idcode'] rate = request.form['rate'] filename = request.form['filename'] CF.update_rating(idcode, filename, float(rate)) return "1" else: return "-1"
def __main__(argv_): # fold here ⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1⥥1 CF.setOptions(argv_) if CF.OPTIONSDICT[CF.SPREADFILES] is True: FO.fixDest(CF.OPTIONSDICT[CF.DESTDIR], CF.OPTIONSDICT[CF.NUMSPREADDIRS]) # print(f"""{CF.NEWLINE}{CF.outputOptionsStruct()}{CF.NEWLINE}|{CF.NEWLINE}""") # print(f"""OPTIONSHELPDICT as returned by outputHelp(["-h"]){CF.NEWLINE}{CF.outputHelp([])}""") # 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ 1⥥ thisDirList_ = FO.scanADir(CF.OPTIONSDICT[CF.SOURCEDIR], CF.OPTIONSDICT[CF.RECURSE]) # fixed by default, no option exists, the mode and defuxing of directories makes life so much easier for me 99.99% of the time thisDirList_.reverse() doDirListFix(thisDirList_, CF.OPTIONSDICT[CF.RECURSE], CF.OPTIONSDICT[CF.DEFUXTHINGS]): thisFileList_ = FO.scanADirForFiles(CF.OPTIONSDICT[CF.SOURCEDIR], CF.OPTIONSDICT[CF.RECURSE])
def find_movies(self): """ Callback for "Find" button. Call the functions provided by the CF module to find recommended movies for a user. The returned result is shown in the list box """ # Get user input User ID, make sure it is a valid number try: user_id = self.user_id_var.get() except ValueError: tkMessageBox.showerror("Input Error", "Please enter a number as User ID") return # clear the previous result self.result_list.delete(0, END) try: # call the function provided by the recommender system to get # the top recommended movies movies = ur.getmemovies(self.ratings, user_id, self.movie_names) # display the returned movies in the listbox for item in movies: self.result_list.insert(END, item) except IndexError: # Invalid user id that runs out of index of the data tkMessageBox.showerror("Input Error", "Invalid User ID") except Exception as e: # Handle any unexpected error thrown by the recommender system tkMessageBox.showerror("Unexpected Error", e)
def find_movies(self): # Get user input rating, make sure it is a valid number try: for var in self.rating_vars: r = var.get() if r < 1 or r > 5: raise ValueError except ValueError: tkMessageBox.showerror("Input Error", "Please enter a number 1-5 for ratings") return # clear the previous result self.result_list.delete(0, END) try: # call the function provided by the recommender system to get # the top recommended movies for idx, var in zip(self.chosen_movies, self.rating_vars): self.ratings[USER_ID][idx] = var.get() movies = ur.recommend(self.ratings, USER_ID, self.sim_mat, NUM_MOVIES) # display the returned movies in the listbox for idx, rating in movies: self.result_list.insert(END, self.movie_names[idx + 1]) except Exception as e: # Handle any unexpected error thrown by the recommender system tkMessageBox.showerror("Unexpected Error", e)
def send_rec1(idcode): filename = CF.recommend(idcode) if os.path.isfile(os.path.join(app.config['REC_FOLDER'], filename)): response = make_response(send_from_directory(app.config['REC_FOLDER'], filename)) response.headers['Content-Disposition'] = "attachment; filename=" + filename return response else: return "-2"
def send_test(catenum): filename = CF.select_random_item_with_category(int(catenum)) if os.path.isfile(os.path.join(app.config['REC_FOLDER'], filename)): response = make_response(send_from_directory(app.config['REC_FOLDER'], filename)) response.headers['Content-Disposition'] = "attachment; filename=" + filename return response else: return "-2"
def FILEDICT(fileName_): FILE_PARMS = [ ("&F&", fileName_), ] dictToRtn_ = dict((x, y) for x, y in FILETUP) listToRtn_ = list((x) for x in FILE_POPENARGSTUP) listToRtn_ = CF.subParms(listToRtn_, FILE_PARMS) return listToRtn_, dictToRtn_
def signup(): if request.method == 'POST': name = request.form['name'] tel = request.form['tel'] face = request.files['face'] user = User.query.filter_by(tel = tel).first() if(user): return "-2" # already exists result = engine.execute("select idcode from users order by idcode desc") idcode = result.fetchone() if(idcode == None): _id = 0 else: _id = idcode['idcode'] + 1 result.close() pn = os.path.join(app.config['FACE_FOLDER'], str(_id) + ".jpg") face.save(pn) ha = HairAnalyzer.HairAnalyzer(pn) img = ha.getImage() print(img.shape) face, eyes = ha.detectFace() if (len(eyes)<2): os.remove(pn) return "-3" area = ha.getHairArea(face) face_color=ha.getFaceColor(face,eyes) for i in range(img.shape[0]): for j in range(img.shape[1]): if area[i][j] == 1: img[i][j]=face_color cv2.imwrite(os.path.join(app.config['FACE_FOLDER'], str(_id) + '_face.jpg'), img) facedata = img_face(_id, str(_id) +"_face.jpg") user = User(name,_id,tel) db_session.add(user) db_session.add(facedata) db_session.commit() CF.add_user(str(_id), [], []) CF.show_DB() return str(_id) else: return "-1"
def get_CHFT(frtargs, cols_to_use=['T', 'n_b', 'Z', 'P_LW', 'P_HI', 'P_HeI', 'P_CVI']): #get cooling function from dataframe of input values (for use in calculations for isochronous binning) ''' Function to get cooling and heating functions from an input array Input: frtargs (dataframe/dataframe row): Row containing [temperature, baryon number density, metallicity, P_LW (RT_DISK_VAR_0), P_HI (RT_DISK_VAR_1), P_HeI (RT_DISK_VAR_2), P_CVI (RT_DISK_VAR_3)] cols_to_use (array): Names of the columns to use, can vary depending on setup (but default to 'T', 'n_b', 'Z', 'P_LW', 'P_HI', 'P_HeI', 'P_CVI') Outputs: cfun, hfun, c_time (floats): The cooling and heating functions, and the cooling time at those values ''' cfargs=[frtargs[col] for col in cols_to_use] (cfun,hfun,ierr)=CF.frtgetcf(*cfargs) #call f2py function to get cooling and heating functions for these inputs c_time = k_boltz*cfargs[0]/(cfargs[1]*cfun) #(kB*T/n_b*Lambda(T)) return [cfun, hfun, c_time] #Return the cooling and heating functions, and the cooling time
def recommend(): if request.method == "GET": token = request.args.get("token") if (token): cfItem = CF.CFItem() li = cfItem.recommend() # for i in li: # print(i) # tmp = RecommendItem() # tmp.itemId = i[0] # tmp.recommendlist = i[1:] # data.append(tmp) print(li) return jsonify({'code': 200, 'data': li}) else: return jsonify({'code': 203, 'data': 'params error'})
def _load_data(self): """ Load ratings and movies data in the files whose names are set in variables RATINGS_DATA and MOVIES_DATA """ # row: users col: movies ratings = np.array(pd.read_csv(RATINGS_DATA, index_col=0)) # use subset of movies self.ratings = ratings[:,:TOTAL_MOVIES] # movies information items = pd.read_csv(MOVIES_DATA, index_col=0) self.movie_names = items.Name[:TOTAL_MOVIES] # pre-compute the similarity matrix print "Computing ratings similarity matrix..." self.sim_mat = ur.getsim(self.ratings)
def recommend(): isbn = [] isbn_num = {} conn = sqlite3.connect("Bookstore.db") cur = conn.cursor() cur.execute('select ISBN from book') rs = cur.fetchall() for line in rs: #print(line) isbn.append(line[0]) print(isbn) i = 0 for num in isbn: isbn_num[num] = i i += 1 print(isbn_num) username = [] username_num = {} cur.execute('select username from users') rs = cur.fetchall() for line in rs: #print(line) username.append(line[0]) print(username) i = 0 for num in username: username_num[num] = i i += 1 print(username_num) evalution = [] cur.execute('select username,ISBN,score from payrecord') rs = cur.fetchall() for line in rs: #print(line) evalution.append([line[0], line[1], line[2]]) print(evalution) conn.commit() conn.close() data = np.full([len(username), len(isbn)], 0.0) for evale in evalution: try: data[username_num[evale[0]]][isbn_num[evale[1]]] = evale[2] except: print(evale) print(data) cf = CF.CF_knearest(k=6) m = [] m = cf.fit(data) print(m) print(len(m)) d = {} flag = 0 for line in m: d[username[flag]] = [ isbn[line[0]], isbn[line[1]], isbn[line[2]], isbn[line[3]], isbn[line[4]], isbn[line[5]] ] flag = flag + 1 print(d) return d #recommend()
def main(): """ This function generates the various collab matrices as output. These matrices are later fed into rmse.py to obtain the various metrics associated with each method. collab_matrix1: Saved as collab_matrixCF.npy. Corresponds to normal Collaborative Filtering case. collab_matrix2: Saved as collab_matrixCFBaseline.npy. Corresponds to Baseline Collaborative Filtering case. collab_matrix3: Saved as collab_matrixSVD.npy. Corresponds to normal SVD case. collab_matrix4: Saved as collab_matrixSVD90.npy. Corresponds to SVD case with 90% energy retained. collab_matrix5: Saved as collab_matrixCUR.npy. Corresponds to normal CUR case. collab_matrix6: Saved as collab_matrixCUR90.npy. Corresponds to CUR case in which intermediate SVD retains 90% energy. """ pp = pprint.PrettyPrinter(indent=4) mID_names = {} number_of_items = 3952 number_of_users = 6040 top_k = 5 mID_uID_rating = np.zeros(shape=(3952, 6040)) f = open(os.getcwd() + '/ml-1m/ratings.dat', encoding='latin-1' ) #Reading file as input and storing it as 2D numpy array for line in f: mID_uID_rating[int(line.split('::')[1]) - 1][int(line.split('::')[0]) - 1] = line.split('::')[2] f.close() print("1**************" ) #This corresponds to the standard Collaborative Filtering Case training_data1, test_data1 = sample(3952, 6040, mID_uID_rating) collab_matrix1 = np.zeros(shape=(number_of_items, number_of_users)) for i in training_data1: collab_matrix1[i[0]][i[1]] = i[2] np.save("test_dataCF.npy", test_data1) collab_matrix1 = CF.normalise_collab_matrix(mID_uID_rating, number_of_items, number_of_users, top_k, collab_matrix1) np.save("collab_matrixCF.npy", collab_matrix1) print( "2**************" ) #This corresponds to the collaborative filtering with the baseline approach training_data2, test_data2 = sample(3952, 6040, mID_uID_rating) collab_matrix2 = np.zeros(shape=(number_of_items, number_of_users)) for i in training_data2: collab_matrix2[i[0]][i[1]] = i[2] np.save("test_dataCFBaseline.npy", test_data2) collab_matrix2 = CF_Baseline.compute(mID_uID_rating, number_of_items, number_of_users, top_k, collab_matrix2) np.save("collab_matrixCFBaseline.npy", collab_matrix2) print("3**************" ) #This corresponds to using SVD for approximating our ratings training_data3, test_data3 = sample(3952, 6040, mID_uID_rating) np.save("test_dataSVD.npy", test_data3) collab_matrix3 = np.zeros(shape=(number_of_items, number_of_users)) for i in training_data3: collab_matrix3[i[0]][i[1]] = i[2] U, Sig, V = svdModified.SVD1(collab_matrix3, False) SVDMat = np.matmul(np.matmul(U, Sig), V.transpose()) np.save("collab_matrixSVD.npy", SVDMat) print( "4**************" ) #Here, we use SVD to approximate ratings. However, we remove concepts until 90% of the variation can still be explained training_data4, test_data4 = sample(3952, 6040, mID_uID_rating) np.save("test_dataSVD90.npy", test_data4) collab_matrix4 = np.zeros(shape=(number_of_items, number_of_users)) for i in training_data4: collab_matrix4[i[0]][i[1]] = i[2] U, Sig, V = svdModified.SVD1(collab_matrix4, True) SVDMat = np.matmul(np.matmul(U, Sig), V.transpose()) np.save("collab_matrixSVD90.npy", SVDMat) print("5**************") #Here, we use CUR to approximate ratings matrix training_data5, test_data5 = sample(3952, 6040, mID_uID_rating) np.save("test_dataCUR.npy", test_data5) collab_matrix5 = np.zeros(shape=(number_of_items, number_of_users)) for i in training_data5: collab_matrix5[i[0]][i[1]] = i[2] C, U, R = matrixFuncs.CUR(collab_matrix5, 1000, True) CURMat = (np.matmul((np.matmul(C, U)), R)) np.save("collab_matrixCUR.npy", CURMat) print( "6**************" ) #CUR is used here. However, the SVD routine called from within CUR corresponds to the 90% energy case. training_data6, test_data6 = sample(3952, 6040, mID_uID_rating) np.save("test_dataCUR90.npy", test_data6) collab_matrix6 = np.zeros(shape=(number_of_items, number_of_users)) for i in training_data6: collab_matrix6[i[0]][i[1]] = i[2] C, U, R = matrixFuncs.CUR(collab_matrix6, 1000, False) CURMat = (np.matmul((np.matmul(C, U)), R)) np.save("collab_matrixCUR90.npy", CURMat)
import Make_DB import CF import Main Make_DB.make_DB() L = [1,4,5,6,14,17,19,22,23,24,28,35,36,40,43,46,48,50,51,56,57,58,60,61,62,63,64,68,69,70,74,75,77,78,80,83,84,85] for i in L: d = Main.check_hair_front("imgs_rec/" + "t" + str(i) +".jpg") print d CF.add_item("t"+ str(i) + ".jpg", d) CF.show_DB()
def get_userCF(self, k=8): return CF.CF(k, 'item')
import CF if __name__ == '__main__': c1 = CF.CF() c1.DelOldFiles(Str='_coco56') pass
# Item base CF # start = time.time() # cf_item_base = CF.CFItemBase(train_data) # end = time.time() # print("time of training ItemBase CF model(s)", end - start) # start = time.time() # print("predicting rate with ItemBase CF model:", cf_item_base.predict(4, 200)) # end = time.time() # print("time of predicting an item with ItemBase CF model(s)", end - start) # no training error = 0 error2 = 0 test_times = 200 cf = CF.CFUserBase(train_data) start = time.time() for i in range(test_times): rand_user = random.randint(0, user_count - 1) j = 0 while train_data[rand_user, j] == 0: j += 1 to_predict = train_data[rand_user, j] train_data[rand_user, j] = 0 print("-----user_id-", rand_user, ", item_id-", j, "-----") print("origin rate:", to_predict) my_predict = cf.predict(rand_user, j) print("predicting rate with ItemBase CF model:", my_predict) error += abs(my_predict - to_predict) error2 += abs(3 - to_predict) train_data[rand_user, j] = to_predict
from CF import * from DataLoader import * import numpy as np from sklearn.model_selection import train_test_split if __name__ == '__main__': filePath = "./data/ml-20m/ratings.csv" print("Loading data:") dataLoader = DataLoader(filePath) Y_data = dataLoader.readFile() print("Done!\n--------------------") y = np.zeros(Y_data.shape[0]) rate_train, rate_test, y_train, y_test = train_test_split(Y_data, y, test_size=0.2) print("User-user Collaborative Filtering: ") cf = CF(rate_train, 5) cf.fit() # cf.print_recommendation() print("-------------------------") print("\nTESTING: \nComputing RMSE: ") cf.RMSE(rate_test)
# me_df = pd.read_csv("alarm_dat.csv", sep=",", index_col=0) to_feed = np.array(me_df) machine_list = list(me_df.index) error_message = pd.read_csv("error_message.txt", sep=";") errors = error_message.columns.values simMat = json.load(open("simMat.txt")) predictiveAlarmText1 = [] predictiveAlarmText2 = [] predictiveAlarmText3 = [] for i in machine_ids: machineId = i if machineId in machine_list: to_search = machine_list.index(machineId) rec_mes = ur.recommend(to_feed, to_search, simMat) mes_id_list = [] for index in range(len(rec_mes)): o_id = rec_mes[index][0] mes_id_list.append(o_id) predictiveAlarmText1.append(errors[mes_id_list[0]]) predictiveAlarmText2.append(errors[mes_id_list[1]]) predictiveAlarmText3.append(errors[mes_id_list[2]]) else: predictiveAlarmText1.append("Warning: no sufficient data for prediction.") predictiveAlarmText2.append("Warning: no sufficient data for prediction.") predictiveAlarmText3.append("Warning: no sufficient data for prediction.") # # data.out is used by DOME to link the
type=str, default=defaults['ClustalO_binary'], help=argparse.SUPPRESS) args = parser.parse_args() if len(args.PDB) == 4: response = urllib2.urlopen( 'https://www.rcsb.org/pdb/download/downloadFastaFiles.do?structureIdList={}&compressionType=uncompressed' .format(args.PDB)) html = response.read() with open(HOME + '/uploads/{}.fasta'.format(args.PDB), "w") as f: f.write(html) with open(HOME + '/uploads/{}.fasta'.format(args.PDB), "r") as f: for line in f: if line.strip('\n') in ("<head>"): CF.cleanexit('PDB code not found.') args.FILENAME = '{}.fasta'.format(args.PDB) else: CF.cleanexit('Your PDB code should be four letters long.') if args.PDB != "None" and args.FILENAME != "None.fasta": message = 'Entered both a PDB code and a default file name. Using the PDB code, {}'.format( args.PDB) print(message) programstart = time.time() #If command line variables are specified, use those. if len(sys.argv) > 1: MainProgram = CF.CF(settings=args) if args.PDB != "None": PDBProgram = PDB.PDB(settings=args)
'Maximum_Sequences' : "2000", 'Blast_E_Value' : "1e-3", 'Consensus_Threshold' : "0",#need to check if zero will give desired results. Might need to be 1 'Consensus_Ratio' : "7", 'Use_Complete_sequences' : "True", 'Alignment_Iterations' : "1", 'Maximum_Redundancy_Threshold' : "0.9", 'Logging' : "False", 'Keep_Temp_Files' : "False", 'Chain' : 'A', 'Angstrom' : "1", 'Residue' : "0", 'PDB_Name' : "None", } settings=CF.setsettings(defaults,configfile) #location of binaries to call settings.BLAST=HOME+"/binaries/blastp" settings.CDHIT=HOME+"/binaries/cd-hit" settings.CLUSTAL=HOME+"/binaries/clustalo-1.2.4-Ubuntu-x86_64" programstart = time.time() #do checks of settings warnings=[] #Run CF checks to check all settings, return any warnings to warnings variable warnings=warnings+CF.checks(settings).warnings MainProgram=CF.CF(settings,warnings=warnings) programend = time.time() print '\nConsensus Finder Completed.' os.rename(HOME+'/uploads/'+settings.FILENAME, HOME+'/completed/'+settings.FILENAME) for i in MainProgram.output[:]:
wordDir = r'D:\temp\project\01Tests\3-fightPlane\Classes' scrEnc = 'utf-8' desEnc = 'gbk' Type = ['.cpp', '.h', '.lrc'] fn1 = FN.FN(wordDir) fn1.analyzeExtensions() c = 1 error = [] oldFiles = [] for i in fn1.filesName: t = fn1.analyzeFN(i) if t[2] in Type: try: with open(t[0] + t[1] + t[2], 'r', encoding=scrEnc) as f: text = f.read() fileDir = t[0] + t[1] + t[2] if (fileDir.find('_coco56_GBK_To_UTF-8') == -1): print('c=', c, sep='') print(t) c += 1 oldFiles.append(fileDir) newFileDir = t[0] + t[1] + '_coco56_GBK_To_UTF-8' + t[2] if (not os.path.exists(newFileDir)): with open(newFileDir, 'w', encoding=desEnc) as f2: f2.write(text) except UnicodeDecodeError: error.append(t) cf = CF.CF(wordDir) cf.MoveOldFilesWithList(oldFiles) print(fn1.filesNum) pass
import CF cfItem = CF.CFItem() for i in cfItem.recommend(): print(i)
def main(): path_resources = 'dataset/pages.json' with open(path_resources) as f: resources = json.load(f) IRM_iter = 2 # which result of IRM iteration will be used th = .025 # threshold for UMF # 5-fold cross validation total = { 'UMF': { 'time': 0., 'f': 0. }, 'Random': { 'time': 0., 'f': 0. }, 'CF': { 'time': 0., 'f': 0. } } for fold in range(1, 5 + 1): path_train_relations = 'dataset/5-fold/train/%d_train.graph' % fold path_test_relations = 'dataset/5-fold/test/%d_test.graph' % fold path_dom0_assignments = 'dataset/5-fold/output/fold%d/dom0' % fold path_dom1_assignments = 'dataset/5-fold/output/fold%d/dom1' % fold # get an index of max-scored cluster assignment """ path_IRM_status = 'dataset/5-fold/output/fold%d/status' % fold statuses = map(lambda l: l.rstrip().split(), open(path_IRM_status).readlines()) scores = map(lambda status: float(status[6]), statuses) best_idx = scores.index(max(scores)) """ # get train relations lines = map(lambda l: l.rstrip().split(' '), open(path_train_relations).readlines()) trains = [] for line in lines: trains.append((int(line[1]), int(line[2]))) trains.sort() # get test relations lines = map(lambda l: l.rstrip().split(' '), open(path_test_relations).readlines()) tests = [] for line in lines: tests.append((int(line[1]), int(line[2]))) tests.sort() print '*** fold %d' % fold ### Tag-weights-based filstering # get cluster assignments for train data user_assignments = map( int, open(path_dom0_assignments).readlines()[IRM_iter].rstrip().split( ' ')) page_assignments = map( int, open(path_dom1_assignments).readlines()[IRM_iter].rstrip().split( ' ')) elapsed_time, f_measure = UMF(trains, tests, resources, user_assignments, page_assignments, th) total['UMF']['time'] += elapsed_time total['UMF']['f'] += f_measure print '[UMF] elapsed time: %.3f, F-measure: %.5f' % (elapsed_time, f_measure) ### Random recommendation elapsed_time, f_measure = random_recommend(trains, tests, 333951) total['Random']['time'] += elapsed_time total['Random']['f'] += f_measure print '[Random (average of 5)] elapsed time: %.3f, F-measure: %.5f' % ( elapsed_time, f_measure) ### User-based collaborative filtering ([n_recommends / n_user] tuples per a user) elapsed_time, f_measure = CF(trains, tests, 333951) total['CF']['time'] += elapsed_time total['CF']['f'] += f_measure print '[CF] elapsed time: %.3f, F-measure: %.5f' % (elapsed_time, f_measure) print '*** Result (average of 5-folds)' for method, d in total.items(): print '[%s] elapsed time: %.3f F-measure: %.5f' % (method, d['time'] / 5., d['f'] / 5.)
def get_itemCF(self, k=8): return CF.CF(k)
import CF if __name__ == '__main__': d1 = CF.CF(r'D:\0COCO\本科\大二下学期\2017新东方计算机') vType = ['.mp4', '.avi', '.vob', '.mkv', '.VOB', '.flv', '.wmv', '.mov', '.rmvb', '.ts'] d1.MoveOldFiles(vType, Str = '_coco56') #d1.MoveOldFiles(Str = '_coco56') pass
# Read out command line arguments args = sys.argv # Parse input # If wrong return a bad request if (len(args) < 3 or (len(args) > 1 and int(args[1]) <= 0 ) or (len(args) > 2 and args[2] == "")): print "BAD REQUEST" # Else return the sentiment value else: dataset = args[1] message = args[2] # Dataset ID print dataset print message Classifier = CF.Classifier() (success, sentiment, P_sentiment, certainty_sentiment) = Classifier.classify( message ) if( sentiment == 0 or success ): print "True" print sentiment print certainty_sentiment else: print "False" for i in range(2): print 0