Merge pull request #98 from janezd/nxgroups-weights

NXGroups: Add different weights and normalizations

Author: janezd

orangecontrib/network/widgets/OWNxGroups.py

@@ -1,8 +1,11 @@
+from itertools import repeat
+
 import numpy as np
 
 from Orange.data import DiscreteVariable, Table, Domain
 from Orange.widgets import gui
-from Orange.widgets.settings import ContextSetting, DomainContextHandler
+from Orange.widgets.settings import ContextSetting, DomainContextHandler, \
+    Setting
 from Orange.widgets.utils.itemmodels import DomainModel
 from Orange.widgets.widget import Input, Output, OWWidget, Msg
 from orangecontrib.network import Graph
@@ -33,42 +36,70 @@ class Error(OWWidget.Error):
     resizing_enabled = False
     want_main_area = False
 
+    NoWeights, WeightByDegrees, WeightByWeights = range(3)
+    weight_labels =\
+        ["No weights", "Number of connections", "Sum of connection weights"]
+
     settingsHandler = DomainContextHandler()
     feature = ContextSetting(None)
+    weighting = Setting(2)
+    normalize = Setting(True)
 
     def __init__(self):
         super().__init__()
         self.network = None
         self.data = None
         self.effective_data = None
-        self.output_network = None
+        self.out_nodes = self.out_edges = None
 
         info_box = gui.widgetBox(self.controlArea, "Info")
         self.input_label = gui.widgetLabel(info_box, "")
-        self.__set_input_label_text()
-
-        feature_box = gui.widgetBox(self.controlArea, "Group by")
-        self.feature_model = DomainModel(valid_types=DiscreteVariable)
-        self.feature_combo = gui.comboBox(
-            feature_box, self, "feature", contentsLength=15,
-            callback=self.__feature_combo_changed, model=self.feature_model
+        self.output_label = gui.widgetLabel(info_box, "")
+        self._set_input_label_text()
+        self._set_output_label_text(None)
+
+        gui.comboBox(
+            self.controlArea, self, "feature", box="Group by",
+            callback=self.__feature_combo_changed,
+            model=DomainModel(valid_types=DiscreteVariable)
+        )
+        radios = gui.radioButtons(
+            self.controlArea, self, "weighting", box="Output weights",
+            btnLabels=self.weight_labels, callback=self.__feature_combo_changed
+        )
+        gui.separator(radios)
+        gui.checkBox(
+            radios, self, "normalize", "Normalize by geometric mean",
+            callback=self.__feature_combo_changed
         )
 
-    def __set_input_label_text(self):
-        text = "No data on input."
-        if self.network is not None:
-            dir_ = "Directed" if self.network.is_directed() else "Undirected"
-            text = f"{dir_} graph\n{self.network.number_of_nodes()}" \
-                   f" nodes, {self.network.number_of_edges()} edges"
-        self.input_label.setText(text)
+    def _set_input_label_text(self):
+        if self.network is None:
+            self.input_label.setText("Input: no data")
+        else:
+            self.input_label.setText(
+                f"Input: "
+                f"{self.network.number_of_nodes()} nodes, "
+                f"{self.network.number_of_edges()} edges")
+
+    def _set_output_label_text(self, output_network):
+        if output_network is None:
+            self.output_label.setText("Output: no data")
+            self.out_nodes = self.out_edges = None
+        else:
+            self.out_nodes = output_network.number_of_nodes()
+            self.out_edges = output_network.number_of_edges()
+            self.output_label.setText(
+                f"Output: {self.out_nodes} nodes, {self.out_edges} edges"
+            )
 
     def __feature_combo_changed(self):
         self.commit()
 
     @Inputs.network
     def set_network(self, network):
         self.network = network
-        self.__set_input_label_text()
+        self._set_input_label_text()
 
     @Inputs.data
     def set_data(self, data):
@@ -79,7 +110,7 @@ def handleNewSignals(self):
         self.clear_messages()
         self.set_effective_data()
         self.set_feature_model()
-        if self.feature_model:
+        if self.controls.feature.model():
             self.openContext(self.effective_data)
         self.commit()
 
@@ -101,56 +132,77 @@ def set_effective_data(self):
 
     def set_feature_model(self):
         data = self.effective_data
-        self.feature_model.set_domain(data and data.domain)
-        self.feature = self.feature_model[0] if self.feature_model else None
+        feature_model = self.controls.feature.model()
+        feature_model.set_domain(data and data.domain)
+        self.feature = feature_model[0] if feature_model else None
 
     def commit(self):
         if self.feature is None:
-            self.output_network = None
-            self.Outputs.network.send(None)
-            self.Outputs.data.send(None)
-            return
-
-        self._map_network()
-        self.Outputs.network.send(self.output_network)
-        self.Outputs.data.send(self.output_network.items())
+            output_network = None
+        else:
+            output_network = self._map_network()
+        self.Outputs.network.send(output_network)
+        self.Outputs.data.send(output_network and output_network.items())
+        self._set_output_label_text(output_network)
 
     def _map_network(self):
-        edges = self.network.edges(data='weight')
-        row, col, weights = zip(*edges)
-        row, col = self._map_into_feature_values(np.array(row), np.array(col))
-        edges = self._construct_edges(row, col, np.array(weights))
+        if self.weighting == self.WeightByWeights:
+            edges = self.network.edges(data='weight')
+            row, col, weights = map(np.array, zip(*edges))
+        else:
+            edges = self.network.edges()
+            row, col = map(np.array, zip(*edges))
+            weights = None
+        if self.normalize:
+            self._normalize_weights(row, col, weights)
+        row, col = self._map_into_feature_values(row, col)
+        edges = self._construct_edges(row, col, weights)
 
         network = Graph()
         network.add_nodes_from(range(len(self.feature.values)))
         network.add_weighted_edges_from(edges)
         network.set_items(self._construct_items())
-        self.output_network = network
+        return network
+
+    def _normalize_weights(self, row, col, weights):
+        if weights is None:
+            weights = np.ones((len(row)), dtype=float)
+            degs = np.array(sorted(self.network.degree()))[:, 1]
+        else:
+            degs = np.array(sorted(self.network.degree(weight="weight")))[:, 1]
+        weights /= np.sqrt(degs.T[row] * degs.T[col])
 
     def _map_into_feature_values(self, row, col):
         selected_column = self.effective_data.get_column_view(self.feature)[0]
         return (selected_column[row].astype(np.float64),
                 selected_column[col].astype(np.float64))
 
-    @staticmethod
-    def _construct_edges(col, row, weights):
+    def _construct_edges(self, col, row, weights):
         # remove edges that connect to "unknown" group
         mask = ~np.any(np.isnan(np.vstack((row, col))), axis=0)
         # remove edges within a node
         mask = np.logical_and((row != col), mask)
-        row, col, weights = row[mask], col[mask], weights[mask]
+        row, col = row[mask], col[mask]
+        if weights is not None:
+            weights = weights[mask]
 
         # find unique edges
         mask = row > col
         row[mask], col[mask] = col[mask], row[mask]
 
-        array = np.vstack((row, col))
+        array = np.vstack((row.astype(int), col.astype(int)))
         (row, col), inverse = np.unique(array, axis=1, return_inverse=True)
 
-        # assign each edge the sum of weights of belonging original edges
-        weights = np.array(
-            [np.sum(weights[inverse == i]) for i in range(len(row))])
-        return [(int(u), int(v), w) for u, v, w in zip(row, col, weights)]
+        if self.weighting == self.NoWeights:
+            return zip(row, col, repeat(1.0))
+        elif self.weighting == self.WeightByDegrees:
+            return zip(
+                row, col,
+                (np.sum(inverse == i).astype(float) for i in range(len(row))))
+        else:  # self.WeightByWeights
+            return zip(
+                row, col,
+                (np.sum(weights[inverse == i]) for i in range(len(row))))
 
     def _construct_items(self):
         domain = Domain([self.feature])
@@ -164,12 +216,15 @@ def send_report(self):
             ("Number of vertices", self.network.number_of_nodes()),
             ("Number of edges", self.network.number_of_edges())])
         self.report_data("Input data", self.effective_data)
-        self.report_items("Group by", [("Feature", self.feature.name)])
-        if self.output_network:
+        self.report_items("Settings", [
+            ("Group by", self.feature.name),
+            ("Weights", self.weight_labels[self.weighting].lower() +
+             (", normalized by geometric mean" if self.normalize else ""))
+        ])
+        if self.out_nodes is not None:
             self.report_items("Output network", [
-                ("Number of vertices", self.output_network.number_of_nodes()),
-                ("Number of edges", self.output_network.number_of_edges())])
-            self.report_data("Output data", self.output_network.items())
+                ("Number of vertices", self.out_nodes),
+                ("Number of edges", self.out_edges)])
 
 
 def main():

orangecontrib/network/widgets/tests/test_OWNxGroups.py

@@ -66,9 +66,9 @@ def test_outputs(self):
 
         self.assertIsInstance(network, Graph)
         self.assertSetEqual(set(network.nodes()), set(range(3)))
-        edges_ = list(network.edges(data='weight'))
-        for n1, n2, w in [(0, 1, 12.), (1, 2, 7.), (0, 2, 20.)]:
-            self.assertTrue((n1, n2, w) in edges_)
+        edges_ = list(network.edges())
+        for n1, n2 in [(0, 1), (1, 2), (0, 2)]:
+            self.assertTrue((n1, n2) in edges_)
 
         self.assertIsInstance(network.items(), Table)