def deleteSingleCategory(self, categoryID): if not BaseModel.baseRequest( self, "SELECT * FROM categories WHERE Id='{0}'", categoryID): return {'message': 'Not found'}, 404 BaseModel.baseRequest(self, "DELETE FROM categories WHERE Id='{0}'", categoryID) return {'message': 'Delete successful'}, 200
def updateLikesQuantity(self, commentID): if not BaseModel.baseRequest( self, "SELECT * FROM comments WHERE Id='{0}'", commentID): return {'message': 'Not found'}, 404 parser = reqparse.RequestParser() parser.add_argument('action', type=str, help='add or remove', required=True) args = parser.parse_args() _action = args['action'] if (_action == 'add'): BaseModel.baseRequest( self, "UPDATE comments SET likesQuantity = likesQuantity + 1 WHERE Id='{0}'", commentID) return {'message': 'Updated succesfully'}, 200 elif (_action == 'remove'): BaseModel.baseRequest( self, "UPDATE comments SET likesQuantity = likesQuantity - 1 WHERE Id='{0}'", commentID) return {'message': 'Updated succesfully'}, 200 else: return {'message': 'action not found'}, 404
def __init__(self): BaseModel.__init__(self) self.identifier = 'WordBasedSeq2Seq1000Units20EpochsFastText' self.params['batch_size'] = 64 self.params['epochs'] = 20 self.params['latent_dim'] = 1000 self.params['MAX_SEQ_LEN'] = 100 self.params['EMBEDDING_DIM'] = 300 self.params['MAX_WORDS_DE'] = 35000 self.params['MAX_WORDS_EN'] = 20000 self.params['P_DENSE_DROPOUT'] = 0.2 self.BASE_DATA_DIR = "../../DataSets" self.BASIC_PERSISTENCE_DIR = '../../Persistence/' + self.identifier if not os.path.exists(self.BASIC_PERSISTENCE_DIR): os.makedirs(self.BASIC_PERSISTENCE_DIR) self.MODEL_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR) self.GRAPH_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR, 'Graph') self.MODEL_CHECKPOINT_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR) self.TRAIN_DATA_FILE = os.path.join( self.BASE_DATA_DIR, 'Training/DE_EN_(tatoeba)_train.txt') self.VAL_DATA_FILE = os.path.join( self.BASE_DATA_DIR, 'Validation/DE_EN_(tatoeba)_validation.txt') self.model_file = os.path.join(self.MODEL_DIR, 'model.h5') self.LATEST_MODELCHKPT = os.path.join(self.MODEL_CHECKPOINT_DIR, 'model.878-1.90.hdf5') self.START_TOKEN = "_GO" self.END_TOKEN = "_EOS" self.UNK_TOKEN = "_UNK" self.preprocessing = True
def get_user(self): user = eval("%s.find_one({'email':'%s','valid':True})" % (self._mongocollection, self.email)) if user: hash = self.get_password_hash(user.get('salt')) if user.get('password')== hash: BaseModel.__init__(self, self.db, user['_id'])
def predict(self): regr = linear_model.LinearRegression() regr.fit(self.x_train, self.y_train) train_result = regr.predict(self.x_train) test_result = regr.predict(self.x_test) BaseModel.export_prediction(test_result, 'LinearRegression') return (train_result, test_result)
def __init__(self): BaseModel.__init__(self) self.identifier = 'char_seq2seq_second_approach' self.params['BATCH_SIZE'] = 128 self.params['EMBEDDING_DIM'] = 100 self.params['EPOCHS'] = 15 self.params['LATENT_DIM'] = 256 self.params['NUM_TOKENS'] = 70 self.params['MAX_NUM_SAMPLES'] = 1000000 self.params['MAX_NUM_WORDS'] = 20000 self.params['MAX_SENTENCES'] = 1000 self.params['MAX_SEQ_LEN'] = 1800 self.UNKNOWN_CHAR = '\r' self.BASE_DATA_DIR = "../../DataSets" self.BASIC_PERSISTENCE_DIR = '../../persistent/persistentModelseq2seqbugfree' self.GRAPH_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR, 'Graph') self.MODEL_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR) self.MODEL_CHECKPOINT_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR) self.LATEST_MODEL_CHKPT = os.path.join( self.MODEL_CHECKPOINT_DIR, 'chkp2prepro_64_100_15_256_1000000_20000_1000_1800_70_70_0.8_char___tfmodelprepro.35999-54.06.hdf5' ) self.token_idx_file = os.path.join(self.BASIC_PERSISTENCE_DIR, "input_token_idx_preprocessed.npy") self.train_en_file = os.path.join(self.BASE_DATA_DIR, 'Training/train.en') self.train_de_file = os.path.join(self.BASE_DATA_DIR, 'Training/train.de') self.encoder_model_file = os.path.join(self.MODEL_DIR, 'encoder_model.h5') self.model_file = os.path.join(self.MODEL_DIR, 'model.h5') self.decoder_model_file = os.path.join(self.MODEL_DIR, 'decoder_model.h5')
def __init__(self): BaseModel.__init__(self) self.identifier = 'CharSeq2SeqTutOneHotInput' self.params['batch_size'] = 265 self.params['epochs'] = 100 self.params['latent_dim'] = 256 self.params['num_samples'] = 150000 self.params['num_encoder_tokens'] = 91 self.params['num_decoder_tokens'] = 123 self.params['max_encoder_seq_length'] = 71 self.params['max_decoder_seq_length'] = 138 self.BASE_DATA_DIR = "../../DataSets" self.BASIC_PERSISTENCE_DIR = '../../persistent/chr_teacher_force_manythings' self.MODEL_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR) self.input_token_idx_file = os.path.join(self.BASIC_PERSISTENCE_DIR, "input_token_index.npy") self.target_token_idx_file = os.path.join(self.BASIC_PERSISTENCE_DIR, "target_token_index.npy") self.data_path = self.BASE_DATA_DIR + 'Training/deu.txt' self.encoder_model_file = os.path.join(self.MODEL_DIR, 'encoder_model.h5') self.model_file = os.path.join(self.MODEL_DIR, 's2s2.h5') self.decoder_model_file = os.path.join(self.MODEL_DIR, 'decoder_model.h5')
def deleteSingleUser(self, userID): if not BaseModel.baseRequest( self, "SELECT * FROM users WHERE UserId='{0}'", userID): return {'message': 'Not found'}, 404 BaseModel.baseRequest(self, "DELETE FROM users WHERE UserId='{0}'", userID) return {'message': 'Delete successful'}, 200
def __init__(self, args, corpus): self.skill_num = int(corpus.n_skills) self.emb_size = args.emb_size self.hidden_size = args.hidden_size self.num_layer = args.num_layer self.dropout = args.dropout BaseModel.__init__(self, model_path=args.model_path)
def getAdviceComments(self, adviceID): results = BaseModel.baseRequest( self, "SELECT * FROM comments WHERE adviceID='{0}'", adviceID) BaseModel.baseRequest( self, "UPDATE advices SET ViewsQuantity = ViewsQuantity + 1 WHERE Id='{0}'", adviceID) return results
def __init__(self, user_num, item_num, u_vector_size, i_vector_size, *args, **kwargs): self.u_vector_size, self.i_vector_size = u_vector_size, i_vector_size assert self.u_vector_size == self.i_vector_size self.ui_vector_size = self.u_vector_size self.user_num = user_num self.item_num = item_num BaseModel.__init__(self, *args, **kwargs)
def predict(self): svr_rbf = SVM.SVR(kernel='rbf', C=1e3, gamma=0.1) train_result = svr_rbf.fit(self.x_train, self.y_train).predict(self.x_train) test_result = svr_rbf.fit(self.x_train, self.y_train).predict(self.x_test) BaseModel.export_prediction(test_result, 'SVR_RBF_C1e3_Gamma01') return (train_result, test_result)
def save(self, newPassword=False): user = eval("%s.find_one({'email':'%s'})" % (self._mongocollection, self.email)) if user is None or newPassword: self.salt = os.urandom(20).decode('ascii', 'ignore') self.password = self.get_password_hash(self.salt) self.token = self.generate_token() BaseModel.save(self)
def __init__(self, class_num, feature_num, user_num, item_num, u_vector_size, i_vector_size, random_seed, model_path): self.u_vector_size, self.i_vector_size = u_vector_size, i_vector_size assert self.u_vector_size == self.i_vector_size self.ui_vector_size = self.u_vector_size self.user_num = user_num self.item_num = item_num BaseModel.__init__(self, class_num=class_num, feature_num=feature_num, random_seed=random_seed, model_path=model_path)
def __init__(self, args, corpus): self.emb_size = args.emb_size self.time_scalar = args.time_scalar self.relation_num = corpus.n_relations self.category_num = corpus.item_meta_df['category'].max() + 1 self.item2cate = dict( zip(corpus.item_meta_df['item_id'].values, corpus.item_meta_df['category'].values)) BaseModel.__init__(self, args, corpus)
def __init__(self, class_num, feature_num, feature_dims, f_vector_size, layers, random_seed, model_path): self.feature_dims = feature_dims self.f_vector_size = f_vector_size self.layers = layers BaseModel.__init__(self, class_num=class_num, feature_num=feature_num, random_seed=random_seed, model_path=model_path)
def __init__(self, args, corpus): self.dataset = args.dataset self.problem_num = int(corpus.n_problems) self.skill_num = int(corpus.n_skills) self.emb_size = args.emb_size self.dropout = args.dropout self.max_step = args.max_step # total dimension of sparse feature vector self.num_features = self.problem_num + self.skill_num * 3 + 3 BaseModel.__init__(self, model_path=args.model_path)
def __init__(self, variable_num, v_vector_size, layers, r_logic, r_length, sim_scale, sim_alpha, *args, **kwargs): self.variable_num = variable_num self.v_vector_size = v_vector_size self.r_logic = r_logic self.r_length = r_length self.layers = layers BaseModel.__init__(self, *args, **kwargs) assert self.label_min == 0 assert self.label_max == 1 self.sim_scale = sim_scale self.sim_alpha = sim_alpha
def run(settings): save_file = 'saves/{}/save.model'.format(settings.name) model = BaseModel(save_file) if not os.path.exists(settings.input): raise Exception('Input file doesnt exist: {}'.format(settings.input)) with open(settings.input, 'r') as f: text_input = ''.join(f.readlines()) text_input = clean_text(text_input) result = model.predict([text_input]) print('Input text is: {}'.format(labels[result[0]]))
def predict(self): regr_rf = RFR(max_depth=17, random_state=9, n_estimators=50, n_jobs=-1) regr_rf.fit(self.x_train, self.y_train) train_result = regr_rf.predict(self.x_train) test_result = regr_rf.predict(self.x_test) export_filename = 'RandomForestReg' if self.drop_feature_names: export_filename += '_without_' + '_'.join(self.drop_feature_names) BaseModel.export_prediction(test_result, export_filename) return (train_result, test_result)
def __init__(self, label_min, label_max, feature_num, user_num, item_num, u_vector_size, i_vector_size, r_weight, ppl_weight, pos_weight, random_seed, model_path): self.u_vector_size, self.i_vector_size = u_vector_size, i_vector_size assert self.u_vector_size == self.i_vector_size self.ui_vector_size = self.u_vector_size self.user_num = user_num self.item_num = item_num self.r_weight = r_weight self.ppl_weight = ppl_weight self.pos_weight = pos_weight self.sim_scale = 10 BaseModel.__init__(self, label_min=label_min, label_max=label_max, feature_num=feature_num, random_seed=random_seed, model_path=model_path)
def __init__(self): BaseModel.__init__(self) self.identifier = 'WordBasedSeq2Seq1000Units20EpochsGLOVE' self.params['batch_size'] = 64 self.params['val_batch_size'] = 256 self.params['epochs'] = 20 self.params['latent_dim'] = 1000 self.params['MAX_SEQ_LEN'] = 100 self.params['EMBEDDING_DIM'] = 300 self.params['MAX_WORDS_DE'] = 40000 self.params['MAX_WORDS_EN'] = 40000 self.params['P_DENSE_DROPOUT'] = 0.2 self.params['VALIDATION_FREQ'] = 1 self.BASE_DATA_DIR = "../../DataSets" self.BASIC_PERSISTENCE_DIR = '../../Persistence/' + self.identifier if not os.path.exists(self.BASIC_PERSISTENCE_DIR): os.makedirs(self.BASIC_PERSISTENCE_DIR) self.MODEL_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR) self.GRAPH_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR, 'Graph') self.MODEL_CHECKPOINT_DIR = os.path.join(self.BASIC_PERSISTENCE_DIR) self.WEIGHT_FILES = [] dir = os.listdir(self.MODEL_CHECKPOINT_DIR) for file in dir: if file.endswith("hdf5"): self.WEIGHT_FILES.append( os.path.join(self.MODEL_CHECKPOINT_DIR, file)) self.WEIGHT_FILES.sort( key=lambda x: int(x.split('model.')[1].split('-')[0])) if len(self.WEIGHT_FILES) == 0: print("no weight files found") else: self.LATEST_MODELCHKPT = self.WEIGHT_FILES[len(self.WEIGHT_FILES) - 1] self.TRAIN_DATA_FILE = os.path.join( self.BASE_DATA_DIR, 'Training/DE_EN_(tatoeba)_train.txt') self.VAL_DATA_FILE = os.path.join( self.BASE_DATA_DIR, 'Validation/DE_EN_(tatoeba)_validation.txt') self.model_file = os.path.join(self.MODEL_DIR, 'model.h5') self.PRETRAINED_GLOVE_FILE = os.path.join(self.BASE_DATA_DIR, 'glove.6B.300d.txt') self.START_TOKEN = "_GO" self.END_TOKEN = "_EOS" self.UNK_TOKEN = "_UNK" self.preprocessing = False self.use_bleu_callback = False
def activate(self, token): user = eval("%s.find_one({'token':'%s'}" % (self._mongocollection, token)) if user: self._id = user['_id'] user['token'] = '' user['valid'] = True user.save() BaseModel.__init__(self, self.db, user['_id']) return True else: return False
def createCategory(self): parser = reqparse.RequestParser() parser.add_argument('name', type=str, help='Category Name', required=True) args = parser.parse_args() _name = args['name'] if Categories.IsCategoryNameExists(self, _name): return {'message': 'Category name already exists'}, 200 BaseModel.baseRequest(self, "Insert Into categories(Name) values ('{0}') ", _name) return {'message': 'Category creation success'}, 201
def parse_model_args(parser, model_name='NLR'): parser.add_argument('--v_vector_size', type=int, default=64, help='Size of feature vectors.') parser.add_argument('--r_logic', type=float, default=0.1, help='Weight of logic regularizer loss') parser.add_argument('--r_length', type=float, default=0.001, help='Weight of vector length regularizer loss') parser.add_argument( '--sim_scale', type=int, default=10, help='Expand the raw similarity *sim_scale before sigmoid.') parser.add_argument( '--sim_alpha', type=float, default=0, help='Similarity function divide (square sum then sim_alpha)') parser.add_argument('--layers', type=int, default=1, help='Number of or/and/not hidden layers.') return BaseModel.parse_model_args(parser, model_name)
def loss(self, feed_dict, predictions): if self.stage == 1: real_batch_size = feed_dict['batch_size'] pos_pred, neg_pred = predictions[:real_batch_size * 2], predictions[real_batch_size * 2:] loss = self.kg_loss(pos_pred, neg_pred, utils.numpy_to_torch(np.ones(real_batch_size * 2))) else: loss = BaseModel.loss(self, feed_dict, predictions) return loss
def get_feed_dict(self, corpus, data, batch_start, batch_size, phase): feed_dict = BaseModel.get_feed_dict(self, corpus, data, batch_start, batch_size, phase) real_batch_size = feed_dict['batch_size'] user_ids = data['user_id'][batch_start:batch_start + real_batch_size].values feed_dict['user_id'] = utils.numpy_to_torch(user_ids) # [batch_size] return feed_dict
def createComment(self): parser = reqparse.RequestParser() parser.add_argument('adviceID', type=int, help='AdviceID', required=True) parser.add_argument('authorName', type=str, help='AuthorName', required=True) parser.add_argument('content', type=str, help='Comment body', required=True) parser.add_argument('likesQuantity', type=int, help='Number of Likes', required=True) args = parser.parse_args() _adviceID = args['adviceID'] _authorName = args['authorName'] _createDate = str(datetime.now()) _content = args['content'] _likesQuantity = args['likesQuantity'] conn = Comments.mysql.connect() cursor = conn.cursor() cursor.callproc( 'spCreateComment', (_adviceID, _authorName, _createDate, _content, _likesQuantity)) data = cursor.fetchall() if len(data) is 0: conn.commit() cursor.close() conn.close() BaseModel.baseRequest( self, "UPDATE advices SET CommentsQuantity = CommentsQuantity + 1 WHERE Id='{0}'", _adviceID) return {'message': 'Comment creation success'}, 201 else: return {'message': str(data[0])}
def parse_model_args(parser, model_name='RecModel'): parser.add_argument('--u_vector_size', type=int, default=64, help='Size of user vectors.') parser.add_argument('--i_vector_size', type=int, default=64, help='Size of item vectors.') return BaseModel.parse_model_args(parser, model_name)
def parse_model_args(parser, model_name='CFKG'): parser.add_argument('--emb_size', type=int, default=64, help='Size of embedding vectors.') parser.add_argument('--margin', type=float, default=0, help='Margin in hinge loss.') return BaseModel.parse_model_args(parser, model_name)
def parse_model_args(parser, model_name='DeepModel'): parser.add_argument('--f_vector_size', type=int, default=64, help='Size of feature vectors.') parser.add_argument('--layers', type=str, default='[64]', help="Size of each layer.") return BaseModel.parse_model_args(parser, model_name)
def parse_model_args(parser, model_name='GRU4Rec'): parser.add_argument('--emb_size', type=int, default=64, help='Size of embedding vectors.') parser.add_argument('--hidden_size', type=int, default=200, help='Size of hidden vectors in GRU.') return BaseModel.parse_model_args(parser, model_name)
def parse_model_args(parser): parser.add_argument('--emb_size', type=int, default=64, help='Size of embedding vectors.') parser.add_argument('--time_scalar', type=int, default=60 * 60 * 24 * 100, help='Time scalar for time intervals.') return BaseModel.parse_model_args(parser)
def __init__(self,_DBCON, _id=None, email=None, password=None): """ Class to represent a user. There are two salts to every password, one is stored in settings.py and never changes, the other comes from a generated random sequence and is stored in the database along with the password hash """ self._salt = settings.SALT self.fields = [ ('email', email), ('password', password), ('token', ''), ('salt', ''), ('valid', False), ('facebookuserId', None), ('added', datetime.datetime.now()), ] BaseModel.__init__(self, _DBCON, _id) if email and password: self.get_user()