FranKGraphBench 0.0.1a0__py2.py3-none-any.whl

framework/recommender/utils/walker.py

@@ -0,0 +1,185 @@
+# Code extracted from: https://raw.githubusercontent.com/benedekrozemberczki/karateclub/master/karateclub/utils/walker.py
+
+import random
+from functools import partial
+from typing import List, Callable
+
+import numpy as np
+import networkx as nx
+from tqdm import tqdm
+
+
+class RandomWalker:
+    """
+    Class to do fast first-order random walks.
+
+    Args:
+        walk_length (int): Number of random walks.
+        walk_number (int): Number of nodes in truncated walk.
+    """
+
+    def __init__(self, walk_length: int, walk_number: int):
+        self.walk_length = walk_length
+        self.walk_number = walk_number
+
+    def do_walk(self, node: int) -> List[str]:
+        """
+        Doing a single truncated random walk from a source node.
+
+        Arg types:
+            * **node** *(int)* - The source node of the random walk.
+
+        Return types:
+            * **walk** *(list of strings)* - A single truncated random walk.
+        """
+        walk: List[int] = [node]
+        for _ in range(self.walk_length - 1):
+            nebs = [node for node in self.graph.neighbors(walk[-1])]
+            if len(nebs) > 0:
+                walk = walk + random.sample(nebs, 1)
+        walk = [str(w) for w in walk]
+        return walk
+
+    def do_walks(self, graph):
+        """
+        Doing a fixed number of truncated random walk from every node in the graph.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to run the random walks on.
+        """
+        self.walks: List[List[str]] = []
+        self.graph = graph
+        for node in tqdm(self.graph.nodes()):
+            for _ in range(self.walk_number):
+                walk_from_node = self.do_walk(node)
+                self.walks.append(walk_from_node)
+
+
+def _check_value(value, name):
+    try:
+        _ = 1 / value
+
+    except ZeroDivisionError:
+        raise ValueError(
+            f"The value of {name} is too small " f"or zero to be used in 1/{name}."
+        )
+
+
+def _undirected(node, graph) -> List[tuple]:
+    edges = graph.edges(node)
+
+    return edges
+
+
+def _directed(node, graph) -> List[tuple]:
+    edges = graph.out_edges(node, data=True)
+
+    return edges
+
+
+def _get_edge_fn(graph) -> Callable:
+    fn = _directed if nx.classes.function.is_directed(graph) else _undirected
+
+    fn = partial(fn, graph=graph)
+    return fn
+
+
+def _unweighted(edges: List[tuple]) -> np.ndarray:
+    return np.ones(len(edges))
+
+
+def _weighted(edges: List[tuple]) -> np.ndarray:
+    weights = map(lambda edge: edge[-1]["weight"], edges)
+
+    return np.array([*weights])
+
+
+def _get_weight_fn(graph) -> Callable:
+    fn = _weighted if nx.classes.function.is_weighted(graph) else _unweighted
+
+    return fn
+
+
+class BiasedRandomWalker:
+    """
+    Class to do biased second order random walks.
+
+    Args:
+        walk_length (int): Number of random walks.
+        walk_number (int): Number of nodes in truncated walk.
+        p (float): Return parameter (1/p transition probability) to move towards previous node.
+        q (float): In-out parameter (1/q transition probability) to move away from previous node.
+    """
+
+    walks: list
+    graph: nx.classes.graph.Graph
+    edge_fn: Callable
+    weight_fn: Callable
+
+    def __init__(self, walk_length: int, walk_number: int, p: float, q: float):
+        self.walk_length = walk_length
+        self.walk_number = walk_number
+
+        _check_value(p, "p")
+        self.p = p
+
+        _check_value(q, "q")
+        self.q = q
+
+    def do_walk(self, node: int) -> List[str]:
+        """
+        Doing a single truncated second order random walk from a source node.
+
+        Arg types:
+            * **node** *(int)* - The source node of the random walk.
+
+        Return types:
+            * **walk** *(list of strings)* - A single truncated random walk.
+        """
+        walk = [node]
+        previous_node = None
+        previous_node_neighbors = []
+        for _ in range(self.walk_length - 1):
+            current_node = walk[-1]
+            edges = self.edge_fn(current_node)
+            current_node_neighbors = np.array([edge[1] for edge in edges])
+
+            weights = self.weight_fn(edges)
+            probability = np.piecewise(
+                weights,
+                [
+                    current_node_neighbors == previous_node,
+                    np.isin(current_node_neighbors, previous_node_neighbors),
+                ],
+                [lambda w: w / self.p, lambda w: w / 1, lambda w: w / self.q],
+            )
+
+            norm_probability = probability / sum(probability)
+            selected = np.random.choice(current_node_neighbors, 1, p=norm_probability)[
+                0
+            ]
+            walk.append(selected)
+
+            previous_node_neighbors = current_node_neighbors
+            previous_node = current_node
+
+        walk = [str(w) for w in walk]
+        return walk
+
+    def do_walks(self, graph) -> None:
+        """
+        Doing a fixed number of truncated random walk from every node in the graph.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to run the random walks on.
+        """
+        self.walks = []
+        self.graph = graph
+
+        self.edge_fn = _get_edge_fn(graph)
+        self.weight_fn = _get_weight_fn(graph)
+
+        for node in tqdm(self.graph.nodes()):
+            for _ in range(self.walk_number):
+                walk_from_node = self.do_walk(node)
+                self.walks.append(walk_from_node)

framework/reporter/report.py

@@ -0,0 +1,101 @@
+import pandas as pd
+import numpy as np
+import typing as t
+import os
+import cpuinfo
+import psutil
+import GPUtil
+
+class Reporter:
+    def __init__(self, output_file, eval_metrics):
+        self.filename = output_file
+        self.eval_metrics = eval_metrics
+
+    def report(self, results) -> None:
+        """
+        Creates the .csv file with experiment results
+        """
+        results = self.__process(results)
+        df = pd.DataFrame.from_dict(results, orient='index')
+        df['model'] = df.index
+        df = df.set_index('model')
+
+        self.__to_csv(df)        
+
+    def __to_csv(self, df):
+        folder = os.path.dirname(self.filename)
+        if not os.path.isdir(folder):
+            os.makedirs(folder)
+        df.to_csv(self.filename)
+
+    def __process(self, results) -> t.Dict[str, t.Dict[str, float]]:
+        """
+        returns 
+            For k-fold: 
+                {model_name: {fold-1_metric: value, fold-1_metric2: value, ..., metric_mean:value, metric_std}}
+            For hold-out:
+                {model_name: {metric1: value, metric2: value}}
+        """
+        results_processed = {}
+        for model, metrics in results.items():
+            report = {}
+            if len(metrics) > 1:
+                for fold, fold_metrics in enumerate(metrics):
+                    for i, metric in enumerate(fold_metrics):
+                        col = f'fold-{fold+1}_{self.eval_metrics[i].name()}'
+                        report[col] = metric
+                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)):
+                    col_mean = f'{self.eval_metrics[idx].name()}_mean'
+                    col_std = f'{self.eval_metrics[idx].name()}_std'
+                    report[col_mean] = metric_mean
+                    report[col_std] = metric_std
+            else:
+                metrics = metrics[0]
+                for i, metric in enumerate(metrics):
+                    report[self.eval_metrics[i].name()] = metric
+
+                
+            results_processed[model] = report
+
+        return results_processed
+    
+class ExecutionTimesReporter:
+    def __init__(self, output_file):
+        self.filename = output_file
+
+    def report(self, results):
+        """
+        Creates the .csv file with experiment results
+        """
+        results = self.__process(results)
+        df = pd.DataFrame.from_dict(results, orient='index')
+        df['model'] = df.index
+        df = df.set_index('model')
+
+        self.__to_csv(df)
+        
+    def __to_csv(self, df):
+        folder = os.path.dirname(self.filename)
+        if not os.path.isdir(folder):
+            os.makedirs(folder)
+        df.to_csv(self.filename)
+
+    def __process(self, results) -> t.Dict[str, float]:
+        """
+        returns 
+            {model_name (machine_specs): {fold-1_execution_time: value, fold-2_execution_time: value, ..., execution_time_mean:value,execution_time_std}}
+        """
+        results_processed = {}
+        for model, execution_times in results.items():
+            report = {}
+            for fold, execution_time in enumerate(execution_times):
+                report[f'fold-{fold+1}_execution_time'] = execution_time
+            report['execution_time_mean'] = np.array(execution_times).mean(axis=0)
+            report['execution_time_std'] = np.array(execution_times).std(axis=0)
+            
+            results_processed[f'{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()]})'] = report
+        
+        return results_processed

framework/utils.py

@@ -0,0 +1,10 @@
+def get_optional_argument(config, key, default=False):
+    try:
+        return config[key]
+    except KeyError:
+        return default
+    except TypeError:
+        return default
+    except Exception as e:
+        print(e)
+        return default