dream

1
import logging
2
import time
3
import os
4
import pickle
5

6
import numpy as np
7
from flask import Flask, request, jsonify
8
import sentry_sdk
9

10
sentry_sdk.init(os.getenv("SENTRY_DSN"))
11

12

13
logging.basicConfig(format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO)
14
logger = logging.getLogger(__name__)
15

16
app = Flask(__name__)
17

18
DATABASE_PATH = os.getenv("DATABASE_PATH")
19

20
TOP_V = 3
21
TOP_K = 3
22

23
scenario_skills = [
24
    "dff_animals_skill",
25
    "news_api_skill",
26
    "dff_food_skill",
27
    "dff_travel_skill",
28
    "dff_sport_skill",
29
    "dff_science_skill",
30
    "dff_music_skill",
31
    "game_cooperative_skill",
32
    "dff_book_skill",
33
    "dff_movie_skill",
34
    "dff_gossip_skill",
35
]
36

37
topic2skill = {
38
    "Movies_TV": "dff_movie_skill",
39
    "Music": "dff_music_skill",
40
    "SciTech": "dff_science_skill",
41
    "Literature": "dff_book_skill",
42
    "Travel_Geo": "dff_travel_skill",
43
    "Celebrities": "dff_gossip_skill",
44
    "Games": "game_cooperative_skill",
45
    "Pets_Animals": "dff_animals_skill",
46
    "Sports": "dff_sport_skill",
47
    "Food_Drink": "dff_food_skill",
48
    "News": "news_api_skill",
49
}
50

51

52
with open(DATABASE_PATH, "rb") as f:
53
    database = pickle.load(f)
54

55

56
def get_candidate_topics(embedding):
57
    scores = np.array(embedding).dot(np.array(database).T)
58
    top_indices = np.argsort(scores)[::-1]
59
    similarity_vector = np.sum(np.array([database[top_idx] for top_idx in top_indices[:TOP_V]]), 0)
60
    candidate_topics_idx = np.argsort(similarity_vector)[::-1][:TOP_K]
61
    candidate_topics = [scenario_skills[idx] for idx in candidate_topics_idx]
62
    return candidate_topics
63

64

65
def handler(requested_data):
66
    st_time = time.time()
67
    logger.warning(requested_data)
68

69
    active_skills_batch = requested_data["active_skills"]
70
    cobot_topics_batch = requested_data["cobot_topics"]
71

72
    candidate_topics_batch = []
73

74
    for active_skills, cobot_topics in zip(active_skills_batch, cobot_topics_batch):
75
        try:
76
            skills_dict = {skill: 0 for skill in scenario_skills}
77

78
            for skill in active_skills:
79
                if skill in scenario_skills:
80
                    skills_dict[skill] += 1
81

82
            for topic in cobot_topics:
83
                if topic in topic2skill.keys():
84
                    skill = topic2skill[topic]
85
                    skills_dict[skill] += 1
86

87
            total_skill = sum(skills_dict.values())
88
            embedding = [skills_dict[skill] / total_skill if total_skill > 0 else 0 for skill in scenario_skills]
89
            used_topics = [skill for skill in scenario_skills if skills_dict[skill] > 0]
90
            candidate_topics = get_candidate_topics(embedding)
91
            candidate_topics = [skill for skill in candidate_topics if skill not in used_topics]
92
            if "game_cooperative_skill" in candidate_topics:
93
                candidate_topics += ["dff_gaming_skill"]
94
            candidate_topics_batch.append(candidate_topics)
95
        except Exception as exc:
96
            logger.exception(exc)
97
            sentry_sdk.capture_exception(exc)
98
            candidate_topics_batch.append([])
99

100
    total_time = time.time() - st_time
101
    logger.info(f"topic_recommendation exec time: {total_time:.3f}s")
102
    logger.warning(candidate_topics_batch)
103
    return candidate_topics_batch
104

105

106
@app.route("/respond", methods=["POST"])
107
def respond():
108
    response = handler(request.json)
109
    return jsonify(response)
110

111

112
if __name__ == "__main__":
113
    app.run(debug=False, host="0.0.0.0", port=3000)
114