MetaHIN: Add README

khanhnamle1994 · khanhnamle1994 · commit dad727ca9b88 · 2021-01-05T09:45:45.000-05:00
diff --git a/Meta-Learning/MetaHIN/README.md b/Meta-Learning/MetaHIN/README.md
@@ -0,0 +1,35 @@
+# MetaHIN: Meta-Learning on Heterogeneous Information Networks for Cold-start Recommendation
+
+This is the PyTorch implementation of the paper "[Meta-learning on Heterogeneous Information Networks for Cold-start Recommendation](https://yuanfulu.github.io/publication/KDD-MetaHIN.pdf)" that is adapted from the [original codebase](https://github.com/rootlu/MetaHIN).
+MetaHIN is a novel attempt to exploit meta-learning on Heterogeneous Information Networks for cold-start recommendation, which alleviates the cold-start problem at both data and model levels.
+It leverages multi-faceted semantic contexts and a co-adaption meta-learner in order to learn finer-grained semantic priors for new tasks in both semantic and task-wise manners.
+
+## Scripts
+* [data_helper.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/data_helper.py): This is the data loader script.
+* [data_processor.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/data_processor.py): This is the data processor script.
+* [config.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/config.py): This is the configuration script that includes hyper-parameters used to train MetaHIN.
+* [embedding_init.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/embedding_init.py): This is the embedding script that converts user and item input features into user and item embeddings.
+* [metaHIN.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/metaHIN.py): This is the model script that defines MetaHIN.
+* [meta_learner.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/meta_learner.py): This is the training script that trains MAMO by updating the parameters in a meta-learning paradigm.
+* [evaluation.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/evaluation.py): This is the evaluation script that evaluates the performance of learned embeddings w.r.t clustering and classification.
+* [main.py](https://github.com/khanhnamle1994/MetaRec/blob/master/Meta-Learning/MetaHIN/main.py): This is the main script that executes the whole code.
+
+## Requirements
+
+```
+- Python 3.6.9
+- PyTorch 1.4.0
+```
+See the detailed [requirements](https://github.com/rootlu/MetaHIN/blob/master/requirements.txt).
+
+## Citation
+
+```
+@inproceedings{lu2020meta,
+  title={Meta-learning on Heterogeneous Information Networks for Cold-start Recommendation},
+  author={Lu, Yuanfu and Fang, Yuan and Shi, Chuan},
+  booktitle={Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery \& Data Mining},
+  pages={1563--1573},
+  year={2020}
+}
+```
diff --git a/Meta-Learning/MetaHIN/config.py b/Meta-Learning/MetaHIN/config.py
@@ -1,7 +1,7 @@
 # MetaHIN configuration
 config = {
     'dataset': 'movielens',  # specify MovieLens1M dataset
-    'mp': ['um', 'umum', 'umam', 'umdm'],  #
+    'mp': ['um', 'umum', 'umam', 'umdm'],  # a set of meta-paths
     'file_num': 12,  # each task contains 12 files for movielens
 
     # item parameters
@@ -24,15 +24,15 @@
 
     'first_fc_hidden_dim': 64,  # number of dimensions in the first fully-connected hidden layer
     'second_fc_hidden_dim': 64,  # number of dimensions in the second fully-connected hidden layer
-    'mp_update': 1,
-    'local_update': 1,
+    'mp_update': 1,  # meta-path update
+    'local_update': 1,  # local update
     'lr': 5e-4,  # step size Beta (global learning rate)
-    'mp_lr': 5e-3,
+    'mp_lr': 5e-3,  # meta-path learning rate
     'local_lr': 5e-3,  # step size Alpha (local learning rate)
     'batch_size': 32,  # number of tasks for each batch
     'num_epoch': 100,  # number of epochs
-    'neigh_agg': 'mean',
-    'mp_agg': 'mean'
+    'neigh_agg': 'mean',  # neighborhood aggregation
+    'mp_agg': 'mean'  # meta-path aggregation
 }
 
 '''
diff --git a/Meta-Learning/MetaHIN/data_processor.py b/Meta-Learning/MetaHIN/data_processor.py
@@ -0,0 +1,224 @@
+# Import packages
+import os
+import json
+import pandas as pd
+import numpy as np
+import torch
+import re
+import random
+import pickle
+import os
+from tqdm import tqdm
+import collections
+
+random.seed(13)
+
+# Data directories
+input_dir = '../../ml-1m/original/'
+output_dir = 'processed-data'
+
+# List of possible states
+states = ["warm_up", "user_cold_testing", "item_cold_testing", "user_and_item_cold_testing", "meta_training"]
+
+if not os.path.exists("{}/meta_training/".format(output_dir)):
+    os.mkdir("{}/log/".format(output_dir))
+    for state in states:
+        os.mkdir("{}/{}/".format(output_dir, state))
+        if not os.path.exists("{}/{}/{}".format(output_dir, "log", state)):
+            os.mkdir("{}/{}/{}".format(output_dir, "log", state))
+
+# Load ratings data
+ui_data = pd.read_csv(input_dir + 'ratings.dat', names=['user', 'item', 'rating', 'timestamp'],
+                      sep="::", engine='python')
+print("Number of ratings:", len(ui_data))
+
+# Load user data
+user_data = pd.read_csv(input_dir + 'users.dat', names=['user', 'gender', 'age', 'occupation_code', 'zip'],
+                        sep="::", engine='python')
+
+# Load item data
+item_data = pd.read_csv(input_dir + 'movies_extrainfos.dat',
+                        names=['item', 'title', 'year', 'rate', 'released', 'genre',
+                               'director', 'writer', 'actors', 'plot', 'poster'],
+                        sep="::", engine='python', encoding="utf-8")
+
+user_list = list(set(ui_data.user.tolist()) | set(user_data.user))
+item_list = list(set(ui_data.item.tolist()) | set(item_data.item))
+
+user_num = len(user_list)
+item_num = len(item_list)
+print("Number of users:", user_num, "and Number of items:", item_num)
+
+"""
+1 - Code to process user and item features
+"""
+
+
+def load_list(fname):
+    """
+    Function to load a file into a Python list
+    :param fname: file name
+    :return: Python list
+    """
+    list_ = []
+    with open(fname, encoding="utf-8") as f:
+        for line in f.readlines():
+            list_.append(line.strip())
+    return list_
+
+
+rate_list = load_list("{}/m_rate.txt".format(input_dir))  # list of rate levels
+genre_list = load_list("{}/m_genre.txt".format(input_dir))  # list of genres
+actor_list = load_list("{}/m_actor.txt".format(input_dir))  # list of actors
+director_list = load_list("{}/m_director.txt".format(input_dir))  # list of directors
+gender_list = load_list("{}/m_gender.txt".format(input_dir))  # list of genders
+age_list = load_list("{}/m_age.txt".format(input_dir))  # list of ages
+occupation_list = load_list("{}/m_occupation.txt".format(input_dir))  # list of occupations
+zipcode_list = load_list("{}/m_zipcode.txt".format(input_dir))  # list of zipcodes
+
+# Verify the lists
+print("Number of rate levels:", len(rate_list), "\n",
+      "Number of genres:", len(genre_list), "\n",
+      "Number of actors:", len(actor_list), "\n",
+      "Number of directors:", len(director_list), "\n",
+      "Number of gender:", len(gender_list), "\n",
+      "Number of age:", len(age_list), "\n",
+      "Number of occupation:", len(occupation_list), "\n",
+      "Number of zipcodes:", len(zipcode_list))
+
+
+def item_converting(row, rate_list, genre_list, director_list, actor_list):
+    """
+    Convert item data into PyTorch tensor
+    :param row: current row
+    :param rate_list: list of rate levels
+    :param genre_list: list of movie genres
+    :param director_list: list of directors
+    :param actor_list: list of actors
+    """
+    # Convert rate_list to PyTorch Tensor
+    rate_idx = torch.tensor([[rate_list.index(str(row['rate']))]]).long()
+
+    # Convert genre_list to PyTorch Tensor
+    genre_idx = torch.zeros(1, 25).long()
+    for genre in str(row['genre']).split(", "):
+        idx = genre_list.index(genre)
+        genre_idx[0, idx] = 1  # one-hot vector
+
+    # Convert director_list to PyTorch Tensor
+    director_idx = torch.zeros(1, 2186).long()
+    director_id = []
+    for director in str(row['director']).split(", "):
+        idx = director_list.index(re.sub(r'\([^()]*\)', '', director))
+        director_idx[0, idx] = 1
+        director_id.append(idx + 1)  # id starts from 1, not index
+
+    # Convert actor_list to PyTorch Tensor
+    actor_idx = torch.zeros(1, 8030).long()
+    actor_id = []
+    for actor in str(row['actors']).split(", "):
+        idx = actor_list.index(actor)
+        actor_idx[0, idx] = 1
+        actor_id.append(idx + 1)
+
+    # Concatenate PyTorch tensors into one-dimensional tensor
+    return torch.cat((rate_idx, genre_idx), 1), \
+           torch.cat((rate_idx, genre_idx, director_idx, actor_idx), 1), \
+           director_id, actor_id
+
+
+def user_converting(row, gender_list, age_list, occupation_list, zipcode_list):
+    """
+    Convert user data into PyTorch tensor
+    :param row: current row
+    :param gender_list: list of genders
+    :param age_list: list of ages
+    :param occupation_list: list of occupations
+    :param zipcode_list: list of zipcodes
+    """
+    # Convert gender_list to PyTorch Tensor
+    gender_idx = torch.tensor([[gender_list.index(str(row['gender']))]]).long()
+
+    # Convert age_list to PyTorch Tensor
+    age_idx = torch.tensor([[age_list.index(str(row['age']))]]).long()
+
+    # Convert occupation_list to PyTorch Tensor
+    occupation_idx = torch.tensor([[occupation_list.index(str(row['occupation_code']))]]).long()
+
+    # Convert zipcode_list to PyTorch Tensor
+    zip_idx = torch.tensor([[zipcode_list.index(str(row['zip'])[:5])]]).long()
+
+    # Concatenate PyTorch tensors into one-dimensional tensor
+    return torch.cat((gender_idx, age_idx, occupation_idx, zip_idx), 1)  # (1, 4)
+
+
+# Create a hash map for item features
+movie_fea_hete = {}
+movie_fea_homo = {}
+m_directors = {}
+m_actors = {}
+for idx, row in item_data.iterrows():
+    m_info = item_converting(row, rate_list, genre_list, director_list, actor_list)
+    movie_fea_hete[row['item']] = m_info[0]
+    movie_fea_homo[row['item']] = m_info[1]
+    m_directors[row['item']] = m_info[2]
+    m_actors[row['item']] = m_info[3]
+
+# Create a hash map for user features
+user_fea = {}
+for idx, row in user_data.iterrows():
+    u_info = user_converting(row, gender_list, age_list, occupation_list, zipcode_list)
+    user_fea[row['user']] = u_info
+
+"""
+2 - Code to process meta-path features
+"""
+
+
+def reverse_dict(d):
+    # {1:[a,b,c], 2:[a,f,g],...}
+    re_d = collections.defaultdict(list)
+    for k, v_list in d.items():
+        for v in v_list:
+            re_d[v].append(k)
+    return dict(re_d)
+
+
+a_movies = reverse_dict(m_actors)
+d_movies = reverse_dict(m_directors)
+print("Actor dictionary:", len(a_movies), " and Director dictionary:", len(d_movies))
+
+
+def jsonKeys2int(x):
+    """
+    Turn JSON keys into integers
+    """
+    if isinstance(x, dict):
+        return {int(k): v for k, v in x.items()}
+    return x
+
+
+state = 'meta_training'
+
+# Load user features support set
+support_u_movies = json.load(open(output_dir + state + '/support_u_movies.json', 'r'), object_hook=jsonKeys2int)
+# Load user features query set
+query_u_movies = json.load(open(output_dir + state + '/query_u_movies.json', 'r'), object_hook=jsonKeys2int)
+# Load user target support set
+support_u_movies_y = json.load(open(output_dir + state + '/support_u_movies_y.json', 'r'), object_hook=jsonKeys2int)
+# Load user target query set
+query_u_movies_y = json.load(open(output_dir + state + '/query_u_movies_y.json', 'r'), object_hook=jsonKeys2int)
+
+if support_u_movies.keys() == query_u_movies.keys():
+    u_id_list = support_u_movies.keys()
+print(len(u_id_list))
+
+train_u_movies = {}
+if support_u_movies.keys() == query_u_movies.keys():
+    u_id_list = support_u_movies.keys()
+print(len(u_id_list))
+
+for idx, u_id in tqdm(enumerate(u_id_list)):
+    train_u_movies[int(u_id)] = []
+    train_u_movies[int(u_id)] += support_u_movies[u_id] + query_u_movies[u_id]
+len(train_u_movies)
diff --git a/Meta-Learning/MetaHIN/embedding_init.py b/Meta-Learning/MetaHIN/embedding_init.py
@@ -66,7 +66,7 @@ def forward(self, user_fea):
         return torch.cat((gender_emb, age_emb, occupation_emb, area_emb), 1)  # (1, 4*32)
 
 
-class ItemEmbeddingML(torch.nn.Module):
+class ItemEmbedding(torch.nn.Module):
     """
     Initialize item embedding class
     """
@@ -75,7 +75,7 @@ def __init__(self, config):
         Initialize the item class
         :param config: experiment configuration
         """
-        super(ItemEmbeddingML, self).__init__()
+        super(ItemEmbedding, self).__init__()
         self.num_rate = config['num_rate']  # Number of rate levels
         self.num_genre = config['num_genre']  # Number of genres
         self.embedding_dim = config['embedding_dim']  # Number of embedding dimensions
diff --git a/Meta-Learning/MetaHIN/main.py b/Meta-Learning/MetaHIN/main.py
