FranKGraphBench 0.0.1a0__py2.py3-none-any.whl

framework/experiment.py

@@ -0,0 +1,120 @@
+import yaml
+import json
+import importlib
+from collections import defaultdict
+from copy import deepcopy
+
+from .dataloader.dataloader import load, preprocess, split
+from .recommender.model2class import model2class
+from .evaluator.metric2class import metric2class
+from .reporter.report import Reporter
+from .reporter.report import ExecutionTimesReporter
+
+import numpy as np
+import time
+import cpuinfo
+import psutil
+import GPUtil
+
+def _load_model_class(name):
+    # relative path from root
+    module_name = f'framework.recommender.models.{model2class[name]["submodule"]}'
+    class_name = model2class[name]['class']
+    return module_name, class_name
+
+def _load_metric_class(name):
+    # relative path from root
+    module_name = f'framework.evaluator.{metric2class[name]["submodule"]}'
+    class_name = metric2class[name]['class']
+    return module_name, class_name
+
+def run(config_path):
+    config = None
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    
+    experiment = config['experiment']
+
+    G = load(**experiment['dataset'])
+    preprocess(G, experiment['preprocess'])
+    print(f'Final graph: {G.info()}')
+
+    # Extracting evaluation metrics
+    evaluation_config = experiment['evaluation']
+    eval_metrics = []
+    for metric in evaluation_config['metrics']:
+        module_name, class_name = _load_metric_class(metric)
+        metric_class = getattr(importlib.import_module(module_name), class_name)
+        k = evaluation_config['k']
+        relevance_threshold = evaluation_config['relevance_threshold']
+        metric_instance = metric_class(k, relevance_threshold)
+        eval_metrics.append(metric_instance)
+
+    # Loop over dataset (specially if its a k-fold split)
+    model_metrics = defaultdict(list)
+    model_execution_times = defaultdict(list)
+    for fold, dataset in enumerate(split(G, **experiment['split'])):
+        print(f'{fold+1}-Fold: evaluating model ...')
+        print(G.info()) 
+
+        for model_config in experiment['models']:
+            start_time = time.time()
+            # Loading model dinamically 
+            module_name, class_name = _load_model_class(model_config['name'])
+            model = getattr(importlib.import_module(module_name), class_name)
+            model = model(model_config['config'], **model_config['parameters'])
+            
+            # Training model
+            G_train, ratings_train = dataset.get_train_data()
+            print(f'Training model: {model.name()}...')
+
+            model.train(G_train, ratings_train)
+            # Getting recomendations
+            # From this data I can evaluate the result for validation and test data
+            recs = model.get_recommendations(k=k)
+            
+            ratings_test = dataset.get_test_data()
+
+            model_execution_times[model.name()].append(time.time() - start_time)
+
+            metric_vals = []
+            for metric in eval_metrics:
+                metric_val = metric.eval(ratings_test, recs) 
+                print(f'{metric.name()}: {metric_val}')
+                metric_vals.append(metric_val)
+
+            print(f'Execution time: {model_execution_times[model.name()][-1]}s')
+
+            model_metrics[model.name()].append(metric_vals) 
+        
+        print('----'*20)
+
+
+    print(f'Metrics final result')
+    for model, metrics in model_metrics.items():
+        print(f'{model}')
+        metrics_mean = np.array(metrics).mean(axis=0)
+        metrics_std = np.array(metrics).std(axis=0)
+        for idx, (metric_mean, metric_std) in enumerate(zip(metrics_mean, metrics_std)):
+            print(f'\t{eval_metrics[idx].name()} mean: {metric_mean} +- {metric_std}')
+    print('')
+    print(f'Execution times final result')
+    for model, execution_times in model_execution_times.items():
+        print(f'model: {model}; CPU: {cpuinfo.get_cpu_info()["brand_raw"]}; RAM: {round(psutil.virtual_memory().total/(1024**3))}GB; GPUs: {[gpu.name for gpu in GPUtil.getGPUs()]}')
+        execution_times_mean = np.array(execution_times).mean(axis=0)
+        execution_times_std = np.array(execution_times).std(axis=0)
+        print(f'\tmean: {execution_times_mean}s +- {execution_times_std}s')    
+
+    reporter = Reporter(experiment['report']['file'], eval_metrics)
+    reporter.report(model_metrics)
+
+    if 'execution_times' in experiment['report']:
+        et_reporter = ExecutionTimesReporter(experiment['report']['execution_times']['file'])
+        et_reporter.report(model_execution_times)
+                
+        
+
+
+
+
+

framework/recommender/model2class.py

@@ -0,0 +1,46 @@
+model2class = {
+    'deepwalk_based': {
+        'submodule': 'deep_walk_based.model',
+        'class': 'DeepWalkBased'
+    },
+    'transE': {
+        'submodule': 'transE.model',
+        'class': 'TransE'
+    },
+    'transH': {
+        'submodule': 'transH.model',
+        'class': 'TransH'
+    },
+    'transR': {
+        'submodule': 'transR.model',
+        'class': 'TransR'
+    },
+    'transD': {
+        'submodule': 'transD.model',
+        'class': 'TransD'
+    },
+    'rotatE': {
+        'submodule': 'rotatE.model',
+        'class': 'RotatE'
+    },
+    'tuckER': {
+        'submodule': 'tuckER.model',
+        'class': 'TuckER'
+    },
+    'distMult': {
+        'submodule': 'distMult.model',
+        'class': 'DistMult'
+    },
+    'rESCAL': {
+        'submodule': 'rESCAL.model',
+        'class': 'RESCAL'
+    },
+    'complEx': {
+        'submodule': 'complEx.model',
+        'class': 'ComplEx'
+    },
+    'ePHEN': {
+        'submodule': 'ePHEN.model',
+        'class': 'EPHEN'
+    }
+}

framework/recommender/models/complEx/model.py

@@ -0,0 +1,193 @@
+from framework.dataloader.graph.node import UserNode, ItemNode
+from ...recommender import Recommender
+
+from pykeen.pipeline import pipeline
+from pykeen.triples import TriplesFactory
+from pykeen.datasets import Dataset
+from sklearn.neighbors import NearestNeighbors
+
+
+import numpy as np
+import torch
+import typing as t
+
+"""
+    Recommender base class
+"""
+
+
+class ComplEx(Recommender):
+    def __init__(
+        self,
+        config: dict,
+        embedding_dim: int = 200,
+        entity_initializer=None,
+        relation_initializer=None,
+        regularizer=None,
+        regularizer_kwargs=None,
+        epochs: int = 5,
+        seed: int = 42,
+        evaluation_fallback: bool = True,
+        all_recs: bool = False,
+        triples: str = "all",
+    ):
+        super().__init__(config)
+        self.embedding_dim = embedding_dim
+        self.entity_initializer = entity_initializer
+        self.relation_initializer = relation_initializer
+        self.regularizer = regularizer
+        self.regularizer_kwargs = regularizer_kwargs
+        self.epochs = epochs
+        self.seed = seed
+        self.evaluation_fallback = evaluation_fallback
+        self.all_recs = all_recs
+        self.triples = triples
+        self._triples = None
+        self._embedding = {}
+
+    def name(self):
+        text = "ComplEx based model + cosine similarity"
+        text += f";embedding_dim={self.embedding_dim};entity_initializer={self.entity_initializer};relation_initializer={self.relation_initializer};regularizer={self.regularizer};epochs={self.epochs};seed={self.seed}"
+        return text
+
+    def train(self, G_train, ratings_train):
+        self.G_train = G_train
+        if self.triples == "all":
+            self._triples = G_train.get_all_triples()
+        elif self.triples == "ratings":
+            self._triples = G_train.get_ratings_triples()
+        self.fit()
+
+    def get_recommendations(self, k: int = 5) -> t.Dict[UserNode, t.List[ItemNode]]:
+        """
+        :param k: cutoff recommendation (int)
+        :return dict of recommendations for each user
+            of type {user1: [item1, item2]}
+        """
+        
+        users = list(self.G_train.get_user_nodes())
+        items = list(self.G_train.get_item_nodes())
+
+        users_embeddings = np.array([self._embedding[user] for user in users])
+        items_embeddings = np.array([self._embedding[item] for item in items])
+
+        n_neighbors = self._get_n_neighbors(users, items, k)
+        knn = NearestNeighbors(n_neighbors=n_neighbors, metric="cosine")
+        knn.fit(items_embeddings)
+        rec_indices = knn.kneighbors(users_embeddings, return_distance=False)
+
+        recommendations = {}
+        for user_idx, user in enumerate(users):
+            rated_items = self.G_train.get_user_rated_items(user)
+            recs = []
+            for item_idx in rec_indices[user_idx]:
+                item = items[item_idx]
+                if item not in rated_items:
+                    recs.append(item)
+                    if not self.all_recs and len(recs) == k:
+                        break
+
+            recommendations[user] = recs
+
+        return recommendations
+
+    def get_user_recommendation(self, user: UserNode, k: int = 5):
+        raise NotImplementedError(
+            "Override get_user_recommendation() for your model subclass."
+        )
+
+    def fit(self):
+        triples = TriplesFactory.from_labeled_triples(
+            self._triples[["head", "relation", "tail"]].values,
+            create_inverse_triples=False,
+            entity_to_id=None,
+            relation_to_id=None,
+            compact_id=False,
+            filter_out_candidate_inverse_relations=True,
+            metadata=None,
+        )
+
+        dataset = Dataset.from_tf(triples, ratios=[0.95, 0.05, 0.0])
+        entity_to_id = dataset.entity_to_id
+
+        result = pipeline(
+            dataset=dataset,
+            model="ComplEx",
+            model_kwargs=dict(
+                embedding_dim=self.embedding_dim,
+                entity_initializer=self.entity_initializer,
+                relation_initializer=self.relation_initializer,
+                regularizer=self.regularizer,
+                regularizer_kwargs=self.regularizer_kwargs,
+            ),
+            epochs = self.epochs,
+            random_seed = self.seed,
+            evaluation_fallback= self.evaluation_fallback,
+        )
+        model = result.model
+
+        users_iter = self.G_train.get_user_nodes()
+        items_iter = self.G_train.get_item_nodes()
+
+        users = list(users_iter)
+        items = list(items_iter)
+
+        # deal with entities that might have not been embedded
+        users_indices, users_no_embedding = [], []
+        for user in users_iter:
+            try:
+                users_indices.append(entity_to_id[user.__str__()])
+            except:
+                users_no_embedding.append(user)
+                users.remove(user)
+                continue
+        users_indices = torch.LongTensor(users_indices)
+
+        items_indices, items_no_embedding = [], []
+        for item in items_iter:
+            try:
+                items_indices.append(entity_to_id[item.__str__()])
+            except:
+                items_no_embedding.append(item)
+                items.remove(item)
+                continue
+        items_indices = torch.LongTensor(items_indices)
+
+        users_embeddings = (model.entity_representations[0](indices=users_indices).detach().cpu().numpy())
+        items_embeddings = (model.entity_representations[0](indices=items_indices).detach().cpu().numpy())
+
+        concat_users_embeddings, concat_items_embeddings = np.zeros((len(users_embeddings), self.embedding_dim*2)), np.zeros((len(items_embeddings), self.embedding_dim*2))
+
+        # complex data not supported by sklearn
+        for index, ue in enumerate(users_embeddings):
+            concat_users_embeddings[index] = np.concatenate((np.real(ue), np.imag(ue)))
+        for index, ie in enumerate(items_embeddings):
+            concat_items_embeddings[index] = np.concatenate((np.real(ie), np.imag(ie)))
+
+        if len(users_no_embedding) > 0:
+            concat_users_embeddings = np.concatenate((concat_users_embeddings, np.zeros((len(users_no_embedding), self.embedding_dim*2), dtype=concat_users_embeddings.dtype)), axis=0)
+            users = users + users_no_embedding
+
+        if len(items_no_embedding) > 0:
+            concat_items_embeddings = np.concatenate((concat_items_embeddings, np.zeros((len(items_no_embedding), self.embedding_dim*2), dtype=concat_items_embeddings.dtype)), axis=0)
+            items = items + items_no_embedding
+
+        for index, user in enumerate(users):
+            self._embedding[user] = concat_users_embeddings[index]
+
+        for index, item in enumerate(items):
+            self._embedding[item] = concat_items_embeddings[index]
+
+    def _get_n_neighbors(self, users, items, top_k):
+        n_neighbors = 0
+        if self.all_recs:
+            n_neighbors = len(items)
+        else:
+            max_recs = 0
+            for user in users:
+                rated_items = self.G_train.get_user_rated_items(user)
+                if len(rated_items) > max_recs:
+                    max_recs = len(rated_items)
+            n_neighbors = min(max_recs + top_k, len(items))
+
+        return n_neighbors

framework/recommender/models/deep_walk_based/model.py

@@ -0,0 +1,149 @@
+from framework.dataloader.graph.node import UserNode
+from ...recommender import Recommender
+from ...utils.walker import BiasedRandomWalker
+
+import walker
+import numpy as np
+import networkx as nx
+from gensim.models.word2vec import Word2Vec
+from sklearn.neighbors import NearestNeighbors
+from copy import deepcopy
+
+from ....dataloader.graph.node import ItemNode
+
+class DeepWalkBased(Recommender):
+    def __init__(
+            self, 
+            config : dict, 
+            walk_len : int, 
+            n_walks : int, 
+            p : float = 1.0,
+            q : float = 1.0,
+            embedding_size : int = 64,
+            workers : int = 4,
+            window_size : int = 3,
+            epochs: int = 1,
+            learning_rate : float = 0.05,
+            min_count : int = 1,
+            seed : int = 42,
+            all_recs : bool = False 
+        ):
+        super().__init__(config)
+        self.walk_len = walk_len
+        self.n_walks = n_walks
+        self.embedding_size = embedding_size
+        self.p, self.q = p, q
+        self.workers = workers
+        self.window_size = window_size
+        self.epochs = epochs
+        self.learning_rate = learning_rate
+        self.min_count = min_count
+        self.seed = seed
+        self.all_recs = all_recs
+        self._embedding = {}
+
+    def name(self):
+        text = 'Node2Vec based model + cosine similarity'
+        text += f';q={self.q};p={self.p};embedding_size={self.embedding_size}'
+        return text
+
+    def train(self, G_train, ratings_train):
+        self.G_train = G_train
+        self.fit()
+
+    def get_recommendations(self, k: int = 5):
+        # Set doesnt guarantee the order of set elements
+        users = list(self.G_train.get_user_nodes())
+        items = list(self.G_train.get_item_nodes())
+
+        users_embeddings = np.array([self._embedding[user] for user in users])
+        items_embeddings = np.array([self._embedding[item] for item in items])
+
+        n_neighbors = self._get_n_neighbors(users, items, k)
+        knn = NearestNeighbors(n_neighbors=n_neighbors, metric='cosine')
+        knn.fit(items_embeddings)
+        rec_indices = knn.kneighbors(users_embeddings, return_distance=False)
+
+        recommendations = {}
+        for user_idx, user in enumerate(users):
+            rated_items = self.G_train.get_user_rated_items(user)
+            recs = []
+            for item_idx in rec_indices[user_idx]:
+                item = items[item_idx]
+                if item not in rated_items:
+                    recs.append(item)
+                    if not self.all_recs and len(recs) == k:
+                        break
+            
+            recommendations[user] = recs
+        
+        return recommendations
+
+    def get_user_recommendation(self, user: UserNode, k: int = 5):
+        items = self.G_train.get_item_nodes()
+        rated_items = self.G_train.get_user_rated_items(user)
+        unrated_items = list(items - rated_items)
+        user_embedding = self._embedding[user].reshape(1, -1)
+        items_embeddings = np.array([self._embedding[item] for item in unrated_items])
+        n_neighbors = k if not self.all_recs else len(unrated_items)
+        knn = NearestNeighbors(n_neighbors=n_neighbors, metric='cosine')
+        knn.fit(items_embeddings)
+        rec_indices = knn.kneighbors(user_embedding, return_distance=False)
+
+        recs = []
+        for idx in rec_indices[0]:
+            recs.append(unrated_items[idx])
+
+        return recs
+
+
+    def fit(self):
+        graph = self.G_train.convert_node_labels_to_integer()
+        self.walks = walker.random_walks(
+            graph, n_walks=self.n_walks, walk_len=self.walk_len
+        )
+        print(f'Random walk shape: {self.walks.shape}')
+        self.walks = self.walks.tolist()
+
+        model = Word2Vec(
+            self.walks,
+            sg=1,
+            hs=1,
+            alpha=self.learning_rate,
+            epochs=self.epochs,
+            vector_size=self.embedding_size,
+            window=self.window_size,
+            min_count=self.min_count,
+            workers=self.workers,
+            seed=self.seed
+        )
+
+        for node in graph.nodes():
+            self._embedding[graph.nodes[node]['old_label']] = model.wv[node]
+        
+        # self.G_train.convert_back()
+    
+    # def _convert_node_labels_to_integer(self, G):
+    #     N = G.number_of_nodes()
+    #     mapping = dict(zip(G.nodes(), range(0, N)))
+    #     nx.relabel_nodes(G, mapping, copy=False)
+    #     nx.set_node_attributes(G, {v: k for k, v in mapping.items()}, 'old_label')
+
+    def _convert_back(self, G):
+        mapping = {node: G.nodes[node]['old_label'] for node in G.nodes()}
+        nx.relabel_nodes(G, mapping, copy=False)
+        nx.set_node_attributes(G, {v: k for k, v in mapping.items()}, 'old_label')
+
+    def _get_n_neighbors(self, users, items, top_k):
+        n_neighbors = 0
+        if self.all_recs:
+            n_neighbors = len(items)
+        else:
+            max_recs = 0
+            for user in users:
+                rated_items = self.G_train.get_user_rated_items(user)
+                if len(rated_items) > max_recs:
+                    max_recs = len(rated_items)
+            n_neighbors = min(max_recs + top_k, len(items))
+        
+        return n_neighbors