def register_user():
# get fields from request
email = request.json["email"].lower()
# pw_hash = request.json["pw_hash"]
year_of_birth = request.json.get("year_of_birth", 1900)
education = request.json.get("education", "N/A")
# get maximum user ID
logger.info("New user: {}".format([email, year_of_birth, education]))
user = 1
if user:
msg = "Email address {} already registered".format(email)
logger.info(msg)
return make_response(statuscodes.EMAIL_ADDRESS_REGISTERED, msg)
else:
new_user_id = 1
model_path = RANKER_PATH_TEMPLATE.format(new_user_id)
return make_response(statuscodes.OK, "Registration successful")
def get_personalized_ranker(user_id, featurizer):
if user_id in personalized_rankers:
logger.info("Using personalized ranker, still in memory.")
ranker = personalized_rankers[user_id]
else:
logger.info("Gotta load ranker or use default...")
try:
# retrieve model
path = RANKER_PATH_TEMPLATE.format(user_id)
ranker = MounicaRanker.staticload(path, featurizer)
except:
ranker = copy.copy(personalized_rankers["default"])
ranker.set_userId(user_id)
ranker.set_nrr(get_personalized_nrr(user_id, nrr_featurizer))
personalized_rankers[user_id] = ranker
logger.info("Rankers in memory for users: {} (total number of {}).".format(
list(personalized_rankers.keys()), len(personalized_rankers)))
return ranker
def register_user():
if not db_connection.test_connection():
msg = "Could not connect to database."
logger.error(msg)
return make_response(statuscodes.DATABASE_CONNECTION_ERROR, msg)
# get fields from request
email = request.json["email"].lower()
# pw_hash = request.json["pw_hash"]
year_of_birth = request.json.get("year_of_birth", 1900)
education = request.json.get("education", "N/A")
# get maximum user ID
logger.info("New user: {}".format([email, year_of_birth, education]))
user = db_connection.get_user(email)
if user:
msg = "Email address {} already registered".format(email)
logger.info(msg)
return make_response(statuscodes.EMAIL_ADDRESS_REGISTERED, msg)
else:
new_user_id = db_connection.insert_user(email)
model_path = RANKER_PATH_TEMPLATE.format(new_user_id)
db_connection.insert_model(new_user_id, year_of_birth, education,
model_path, "ranker")
return make_response(statuscodes.OK, "Registration successful")
logger.info("Not using SSL connection.")
app.debug = False
# LOADING DEFAULT CWI
default_scorer = MounicaScorer.staticload(
SCORER_PATH_TEMPLATE.format("default"))
default_cwi = MounicaCWI.staticload(CWI_PATH_TEMPLATE.format("default"))
default_cwi.set_scorer(default_scorer)
logger.debug("SCORER PATH: {}".format(default_scorer.path))
# LOADING DEFAULT RANKER
nrr_featurizer = FeatureExtractorFast(RESOURCES['en']['nrr'])
default_nrr = MounicaNRR.staticload(NRR_PATH_TEMPLATE.format('default'),
nrr_featurizer)
default_ranker = MounicaRanker.staticload(
RANKER_PATH_TEMPLATE.format('default'), nrr_featurizer)
logger.debug("NRR PATH: {}".format(default_ranker.nrr.model_path))
# LOADING SIMPLIFICATION MODELS
simplification_pipeline = MounicaSimplificationPipeline("default")
simplification_pipeline.setCwi(default_cwi)
simplification_pipeline.setGenerator(MounicaGenerator())
simplification_pipeline.setSelector(MounicaSelector(NGRAM))
simplification_pipeline.setRanker(default_ranker)
logger.info("Base simplifier loaded.")
# CREATING DICTS FOR PERSONALIZED MODELS
personalized_rankers = {"default": default_ranker}
personalized_cwi = {"default": default_cwi}
personalized_scorers = {"default": default_scorer}
personalized_nrrs = {"default": default_nrr}
def save(self, userId):
json = jsonpickle.encode(self)
with open(RANKER_PATH_TEMPLATE.format(userId), 'w') as jsonfile:
jsonfile.write(json)
self.scorer.save()
logger.info("Using SSL connection.")
sslify = SSLify(app)
else:
logger.info("Not using SSL connection.")
app.debug = False
# LOADING DEFAULT MODEL
simplification_pipeline = LexicalSimplificationPipeline("default")
generator = LexiGenerator(synonyms_files=RESOURCES["da"]["synonyms"],
embedding_files=RESOURCES["da"]["embeddings"])
simplification_pipeline.setGenerator(generator)
default_scorer = LexiScorer.staticload(SCORER_PATH_TEMPLATE.format("default"))
logger.debug("SCORER PATH: {}".format(default_scorer.path))
default_ranker = LexiRanker.staticload(RANKER_PATH_TEMPLATE.format("default"))
default_ranker.set_scorer(default_scorer)
default_cwi = LexiCWI.staticload(CWI_PATH_TEMPLATE.format("default"))
default_cwi.set_scorer(default_scorer)
personalized_rankers = {"default": default_ranker}
personalized_cwi = {"default": default_cwi}
personalized_scorers = {"default": default_scorer}
logger.debug("Default ranker: {} ({})".format(default_ranker,
type(default_ranker)))
logger.info("Base simplifier loaded.")
# BLACKLISTED WORDS, not to be simplified
GENERIC_BLACKLIST = db_connection.get_blacklist(None)
logger.debug("Generic blacklist: {}".format(GENERIC_BLACKLIST))
count = -1
pred_rankings = []
for line in open(RESOURCES['en']['nrr']['test'], encoding='utf-8'):
line = line.strip().split('\t')
substitutes = [sub.strip().split(':')[1].strip() for sub in line[3:]]
score_map = {}
for sub in substitutes:
score_map[sub] = 0.0
for s1 in substitutes:
for s2 in substitutes:
if s1 != s2:
count += 1
score = prediction_scores[count]
score_map[s1] += score
pred_rankings.append(sorted(score_map.keys(), key=score_map.__getitem__))
p_at_1, pearson = evaluate_ranker(RESOURCES['en']['nrr']['test'],
pred_rankings)
print("Metrics (P@1, Pearson): %f %f" % (p_at_1 * 100, pearson))
nrr.save()
print('Saved model to %s' % NRR_MODEL_PATH_TEMPLATE.format('default'))
print('Saved NRR wrapper object to %s' % NRR_PATH_TEMPLATE.format('default'))
rank = MounicaRanker('default', nrr)
rank.save('default')
print('Saved MounicaRanker object to %s' %
RANKER_PATH_TEMPLATE.format('default'))