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()