Init commit of ease model

app.py

@@ -0,0 +1,120 @@
+import streamlit as st
+from streamlit_option_menu import option_menu
+from func import *
+from model import *
+
+
+if "user_preferences" not in st.session_state:
+    st.session_state["user_preferences"] = {}
+
+if "user_titles" not in st.session_state:
+    st.session_state["user_titles"] = []
+
+data = pd.read_pickle("data/2k_titles.pkl")
+
+def games_recomm(preferences_id):
+    if "rs" in st.session_state:
+        del st.session_state["rs"]
+    
+    with st.spinner("Getting recommendation..."):
+        pref_value = []
+        for id in preferences_id:
+            if st.session_state[id] == "Positive":
+                pref_value.append(1)
+            elif st.session_state[id] == "Negative":
+                pref_value.append(0)
+        
+        pred_df = pd.DataFrame({
+            'user_id': [999999] * len(preferences_id),
+            'app_id': preferences_id,
+            'is_recommended': pref_value
+        })
+
+        res = ease_model(pred_df=pred_df, k=10)
+        st.session_state['rs'] = res
+
+    # st.write(len(st.session_state['rs']))
+    if len(st.session_state['rs']) >= 1:
+        st.success(f"Go to result page to view top {len(st.session_state['rs'])} recommendations.")
+    else:
+        st.error("Recommendation failed. Please reload the session.")
+
+        # st.write(res)
+
+# Main Page Header
+# Consist of Home page, Result page, About page, and Log page
+def spr_sidebar():
+    menu = option_menu(
+        menu_title=None,
+        options=['Home', 'Result', 'About'],
+        icons=['house', 'joystick', 'info-square'],
+        menu_icon='cast',
+        default_index=0,
+        orientation='horizontal'
+    )
+
+    # Change 'app_mode' state based on current page
+    if menu == 'Home':
+        st.session_state['app_mode'] = 'Home'
+    elif menu == 'Result':
+        st.session_state['app_mode'] = 'Result'
+    elif menu == 'About':
+        st.session_state['app_mode'] = 'About'
+
+# Home page. One of the page in Main Header
+def home_page():
+    st.title("Steam Recommendation System")
+
+    # st.session_state['user_title'] = st.session_state['input_title']
+    preferences = st.multiselect(
+        label="Input games you like:",
+        options=list(data),
+        key="user_titles")
+
+    user_input = generate_app_gamebox(preferences)
+
+    state = st.button("Get state")
+
+    if state:
+        st.session_state["user_preferences"] = user_input
+        
+        st.markdown("---")
+        games_recomm(st.session_state["user_preferences"])
+
+        st.session_state
+
+
+
+# Result page
+# Show the list of predictions for active user
+def result_page():
+    if "rs" not in st.session_state:
+        st.error('Please input preferences titles and run "Get recommendation"')
+    else:
+        st.success(f'Top {len(st.session_state["rs"])}')
+        st.session_state
+
+        user_res = generate_res_gamebox(ids=st.session_state['rs'])
+
+# About page
+# Show the information of the project and the sites
+
+
+def about_page():
+    pass
+
+
+def main():
+    spr_sidebar()
+    # st.session_state
+
+    if st.session_state['app_mode'] == 'Home':
+        home_page()
+    elif st.session_state['app_mode'] == 'Result':
+        result_page()
+    elif st.session_state['app_mode'] == 'About':
+        about_page()
+
+
+if __name__ == '__main__':
+    main()

data/2k_ids.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd9e84631b0dd97fe7d0fe982a28a03c9c65a4d1042437385137d05c92f829b3
+size 60873

data/2k_titles.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2689a911254553451cdd573c751192f098d12b3b1cc9d872f7ac2e7b0d840018
+size 60873

func.py

@@ -0,0 +1,54 @@
+import pandas as pd
+import streamlit as st
+import requests
+
+from io import BytesIO
+from PIL import Image
+
+data_titles = pd.read_pickle("data/2k_titles.pkl")
+data_ids = pd.read_pickle("data/2k_ids.pkl")
+
+def generate_app_gamebox(titles):
+    titles_id = []
+    # selectboxes_id = {}
+
+    for title in titles:
+        titles_id.append(data_titles[title])
+
+    for id in titles_id:
+        url = f"https://cdn.cloudflare.steamstatic.com/steam/apps/{id}/header.jpg"
+        resp = requests.get(url)
+
+        if resp.status_code == 200:
+            container = st.container()
+            img_col, pref_col = container.columns([3, 2])
+
+            img_col.image(BytesIO(resp.content))
+            pref_col.selectbox(
+                "Your rating:",
+                options=["Positive", "Negative"],
+                key=id,
+            )
+    
+    return titles_id
+
+def generate_res_gamebox(ids):
+    # titles_list = []
+
+    for id in ids:
+        # titles_list.append(data_ids[id])
+        url_page = f"https://store.steampowered.com/app/{id}/"
+        url_img = f"https://cdn.cloudflare.steamstatic.com/steam/apps/{id}/header.jpg"
+        resp = requests.get(url_img)
+
+        if resp.status_code == 200:
+            with st.container():
+                st.image(BytesIO(resp.content))
+                st.caption(data_ids[id])
+            
+            st.divider()
+
+    # for title in titles_list:
+    #     # url = f"https://store.steampowered.com/app/"
+    #     with st.container():
+

model.py

@@ -0,0 +1,115 @@
+import pandas as pd
+import torch
+
+from sklearn.neighbors import KNeighborsClassifier
+
+# sparse_indices = torch.load("data/sparse_indices.pt")
+# sparse_values = torch.load("data/sparse_values.pt")
+class EASE:
+    def __init__(self, train, 
+            user_col='user_id', 
+            item_col='app_id', 
+            score_col='is_recommended',
+            reg=250.):
+        """
+            train: (DataFrame) data of training set
+            user_col: (String) column name of users column
+            item_col: (String) column name of items column
+            score_col: (String) column name of interactions column
+            reg: (Float) EASE's regularization value
+        """
+
+        self.user_col = user_col
+        self.item_col = item_col
+        self.score_col = score_col
+        self.train = train
+        self.reg = reg
+
+        self.user_id_col = user_col + "_index"
+        self.item_id_col = item_col + "_index"
+
+        self.item_lookup = self.generate_label(train, self.item_col)
+
+        self.item_map = {}
+        for item, item_index in self.item_lookup.values:
+            self.item_map[item_index] = item
+
+    def generate_label(self, df, col):
+        dist_labels = df[[col]].drop_duplicates()
+        dist_labels[col +
+                    "_index"] = dist_labels[col].astype("category").cat.codes
+        
+        return dist_labels
+        
+    def predict_active(self, pred_df, weight, k=10, remove_owned=True):
+        """
+            Args:
+                pred_df: (DataFrame) data of user interactions
+                weight: (Tensor) Weight matrix of pre-trained EASE model
+                k: (Integer) number of recommendation to be shown
+                remove_owned: (Boolean) Whether to remove already interacted items
+        """
+        train = pd.concat([self.train, pred_df], axis=0)
+        user_lookup = self.generate_label(train, self.user_col)
+
+        train = train.merge(user_lookup, on=[self.user_col], sort=False)
+        train = train.merge(self.item_lookup, on=[self.item_col], sort=False)
+
+        pred_df = pred_df[[self.user_col]].drop_duplicates()
+        pred_df = pred_df.merge(user_lookup, on=[self.user_col], sort=False)
+
+        indices = torch.LongTensor(train[[self.user_id_col, self.item_id_col]].values)
+        values = torch.FloatTensor(train[self.score_col])
+        sparse = torch.sparse.FloatTensor(indices.T, values)
+
+        # --------------------------------------------------
+        user_act_tensor = sparse.index_select(
+            dim=0, index=torch.LongTensor(pred_df[self.user_id_col])
+        )
+
+        _preds_act_tensor = user_act_tensor @ weight
+        if remove_owned:
+            _preds_act_tensor += -1. * user_act_tensor
+
+        output_preds = []
+        score_preds = []
+        for _preds in _preds_act_tensor:
+            top_items = _preds.topk(k)
+
+            output_preds.append([self.item_map[id] for id in top_items.indices.tolist()])
+            score_preds.append( top_items.values.tolist() )
+
+        pred_df['predicted_items'] = output_preds
+        pred_df['predicted_score'] = score_preds
+        
+        escaped = [
+            ele for i_list in pred_df['predicted_items'].values for ele in i_list
+        ]
+
+        return escaped
+    
+def ease_model(pred_df, k=10):
+    ease_B = torch.load("data/ease_B.pt")
+    train = pd.read_csv("data/recs.csv")
+
+    ease = EASE(train)
+    res = ease.predict_active(pred_df=pred_df, weight=ease_B, k=k)
+
+    return res
+
+
+# def main():
+#     pass
+#     # act_user = pd.DataFrame({
+#     #     'user_id': [999999, 999999, 999999, 999999, 999999, 999999],
+#     #     'app_id': [1689910, 1245620, 814380, 620980, 1551360, 774171],
+#     #     'is_recommended': [0, 1, 1, 0, 1, 1]
+#     # })
+#     # act_indices = torch.FloatTensor(ac)
+
+#     # print(
+#     #     torch.sparse.FloatTensor(sparse_indices.T, sparse_values)
+#     # )
+
+# if __name__ == '__main__':
+#     main()

requirements.txt

@@ -0,0 +1,4 @@
+pandas
+requests
+streamlit
+streamlit_option_menu