Fit transform

.gitignore

@@ -127,3 +127,9 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# VSCode project settings
+.vscode/
+
+# Mac OS X clutter
+**/.DS_Store

karateclub/estimator.py

@@ -26,21 +26,36 @@ def get_embedding(self):
         """Getting the embeddings (graph or node level)."""
         pass
 
+    def fit_transform(self):
+        """Fitting a model and getting the embeddings."""
+        pass
+
     def get_memberships(self):
         """Getting the membership dictionary."""
         pass
 
+    def fit_predict(self):
+        """Fitting a model and getting the membership."""
+        pass
+
     def get_cluster_centers(self):
         """Getting the cluster centers."""
         pass
-
-    def get_params(self):
+
+    def get_params(self, deep=True):
+        # Ignore deep=False, since we don't have nested estimators
         """Get parameter dictionary for this estimator.."""
         rx = re.compile(r'^\_')
         params = self.__dict__
         params = {key: params[key] for key in params if not rx.search(key)}
         return params
 
+    def set_params(self, **parameters):
+        """Set the parameters of this estimator."""
+        for parameter, value in parameters.items():
+            setattr(self, parameter, value)
+        return self
+
     def _set_seed(self):
         """Creating the initial random seed."""
         random.seed(self.seed)

karateclub/node_embedding/attributed/ae.py

@@ -141,3 +141,23 @@ def get_embedding(self) -> np.array:
             * **embedding** *(Numpy array)* - The embedding of nodes.
         """
         return np.concatenate(self._embeddings, axis=1)
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/asne.py

@@ -1,6 +1,7 @@
 import random
 import numpy as np
 import networkx as nx
+from typing import Union
 from scipy.sparse import coo_matrix
 from karateclub.estimator import Estimator
 from gensim.models.doc2vec import Doc2Vec, TaggedDocument
@@ -91,3 +92,23 @@ def get_embedding(self) -> np.array:
         """
         embedding = self._embedding
         return embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/bane.py

@@ -136,3 +136,23 @@ def get_embedding(self) -> np.array:
         """
         embedding = self._B
         return embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/feathernode.py

@@ -138,3 +138,23 @@ def get_embedding(self) -> np.array:
             * **embedding** *(Numpy array)* - The embedding of nodes.
         """
         return self._feature_blocks
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/fscnmf.py

@@ -162,3 +162,23 @@ def get_embedding(self) -> np.array:
         """
         embedding = np.concatenate([self._B_1, self._U], axis=1)
         return embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/musae.py

@@ -145,3 +145,23 @@ def get_embedding(self) -> np.array:
         """
         embedding = np.concatenate(self.embeddings, axis=1)
         return embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/sine.py

@@ -119,3 +119,23 @@ def get_embedding(self) -> np.array:
         """
         embedding = self.embedding
         return embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/tadw.py

@@ -156,3 +156,23 @@ def get_embedding(self) -> np.array:
             [np.transpose(self._W), np.transpose(np.dot(self._H, self._T))], axis=1
         )
         return embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      X: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, X)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/attributed/tene.py

@@ -152,3 +152,23 @@ def get_embedding(self) -> np.array:
         """
         embedding = np.concatenate([self._M, self._Q], axis=1)
         return embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      T: Union[np.array, coo_matrix],
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **X** *(Scipy COO array)* - The binary matrix of node features.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, T)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/meta/neu.py

@@ -77,3 +77,23 @@ def get_embedding(self) -> np.array:
             * **embedding** *(Numpy array)* - The embedding of nodes.
         """
         return self._embedding
+
+    def fit_transform(self,
+                      graph: nx.classes.graph.Graph,
+                      model: Estimator,
+                      y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **model** *(KC embedding model)* - Karate Club embedding.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph, model)
+        if y is None:
+            return self._embedding
+        else:
+            return self._embedding, y

karateclub/node_embedding/neighbourhood/boostne.py

@@ -240,3 +240,19 @@ def get_embedding(self) -> np.array:
         """
         embedding = np.concatenate(self._embeddings, axis=1)
         return embedding
+
+    def fit_transform(self, graph: nx.classes.graph.Graph, y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/neighbourhood/deepwalk.py

@@ -87,3 +87,19 @@ def get_embedding(self) -> np.array:
             * **embedding** *(Numpy array)* - The embedding of nodes.
         """
         return np.array(self._embedding)
+
+    def fit_transform(self, graph: nx.classes.graph.Graph, y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/neighbourhood/diff2vec.py

@@ -88,3 +88,19 @@ def get_embedding(self) -> np.array:
             * **embedding** *(Numpy array)* - The embedding of nodes.
         """
         return np.array(self._embedding)
+
+    def fit_transform(self, graph: nx.classes.graph.Graph, y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph)
+        if y is None:
+            return self.get_embedding()
+        else:
+            return self.get_embedding(), y

karateclub/node_embedding/neighbourhood/first_order_line.py

@@ -95,4 +95,20 @@ def get_embedding(self) -> np.array:
         Return types:
             * **embedding** *(Numpy array)* - The embedding of nodes.
         """
-        return self.embedding
+        return self.embedding
+
+    def fit_transform(self, graph: nx.classes.graph.Graph, y=None) -> np.array:
+        r"""Fits model to input graph and returns embeddings.
+
+        Arg types:
+            * **graph** *(NetworkX graph)* - The graph to be embedded.
+            * **y** *(None)* - Not used. For consistency with scikit-learn API.
+
+        Return types:
+            * **embedding** *(Numpy array)* - The embedding of nodes.
+        """
+        self.fit(graph)
+        if y is None:
+            return self.embedding
+        else:
+            return self.embedding, y