[WIP] Release 0.9.1 (#499)

* update release file

* add python 3.11 to tests

* build wheels

* build wheels again

* remove python 3.7 from tests

* add tests for layers

* remove useless data

* remove useless data

* ad test on batching for GNN

* add test alpha=0

Author: rflamary

.github/workflows/build_tests.yml

@@ -22,7 +22,7 @@ jobs:
     strategy:
       max-parallel: 4
       matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
 
     steps:
     - uses: actions/checkout@v1
@@ -52,7 +52,7 @@ jobs:
     - name: Set up Python 
       uses: actions/setup-python@v1
       with:
-        python-version: 3.9
+        python-version: "3.10"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
@@ -73,18 +73,19 @@ jobs:
     - name: Set up Python 
       uses: actions/setup-python@v1
       with:
-        python-version: 3.9
+        python-version: "3.10"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest
+        pip install pytest pytest-cov
     - name: Install POT
       run: |
         pip install -e .
     - name: Run tests
       run: |
-        python -m pytest --durations=20 -v test/ ot/ --color=yes
-
+        python -m pytest --durations=20 -v test/ ot/ --color=yes --cov=./ --cov-report=xml
+    - name: Upload coverage reports to Codecov with GitHub Action
+      uses: codecov/codecov-action@v3
 
   macos:
      runs-on: macos-latest

.github/workflows/build_wheels.yml

@@ -19,22 +19,22 @@ jobs:
 
     steps:
     - uses: actions/checkout@v1
-    - name: Set up Python 3.8
+    - name: Set up Python 3.10
       uses: actions/setup-python@v1
       with:
-        python-version: 3.8
+        python-version: "3.10"
 
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
 
     - name: Install cibuildwheel
       run: |
-        python -m pip install cibuildwheel==2.2.2
+        python -m pip install cibuildwheel==2.14.1
 
     - name: Build wheels
       env:
-        CIBW_SKIP: "pp*-win* pp*-macosx* cp2* pp* cp36*" # remove pypy on mac and win (wrong version)
+        CIBW_SKIP: "pp*-win* pp*-macosx* cp2* pp* cp36* cp*musl*" # remove pypy on mac and win (wrong version)
       run: |
         python -m cibuildwheel --output-dir wheelhouse
 
@@ -57,15 +57,15 @@ jobs:
     - name: Set up Python 3.8
       uses: actions/setup-python@v1
       with:
-        python-version: 3.8
+        python-version: "3.10"
 
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
 
     - name: Install cibuildwheel
       run: |
-        python -m pip install cibuildwheel==2.2.2
+        python -m pip install cibuildwheel==2.14.1
 
     - name: Set up QEMU
       if: runner.os == 'Linux'

ot/gnn/_layers.py

@@ -124,14 +124,14 @@ def __init__(self, n_features, n_tplt=2, n_tplt_nodes=2, alpha=None, train_node_
             if multi_alpha:
                 self.alpha0 = torch.Tensor([0] * self.n_tplt)
             else:
-                alpha0 = torch.Tensor([0])
-            self.alpha0 = nn.Parameter(alpha0)
+                self.alpha0 = torch.Tensor([0])
+            self.alpha0 = nn.Parameter(self.alpha0)
         else:
             if multi_alpha:
                 self.alpha0 = torch.Tensor([alpha] * self.n_tplt)
             else:
                 self.alpha0 = torch.Tensor([alpha])
-            self.alpha0 = torch.logit(alpha0)
+            self.alpha0 = torch.logit(self.alpha0)
 
     def forward(self, x, edge_index, batch=None):
         """
@@ -227,8 +227,8 @@ def __init__(self, n_features, n_tplt=2, n_tplt_nodes=2, train_node_weights=True
         self.feature_init_std = feature_init_std
 
         _, tplt_features, self.q0 = TFGW_template_initialization(self.n_tplt, self.n_tplt_nodes, self.n_features, self.feature_init_mean, self.feature_init_std)
-        self.tplt_features = nn.Parameter(tplt_features)
 
+        self.tplt_features = nn.Parameter(tplt_features)
         self.softmax = nn.Softmax(dim=1)
 
         if train_node_weights:

test/test_gnn.py

@@ -10,21 +10,21 @@
 
 try:  # test if pytorch_geometric is installed
     import torch_geometric
+    import torch
+    from torch_geometric.nn import Linear
+    from torch_geometric.data import Data as GraphData
+    from torch_geometric.loader import DataLoader
+    import torch.nn as nn
+    from ot.gnn import TFGWPooling, TWPooling
+
 except ImportError:
     torch_geometric = False
 
 
 @pytest.mark.skipif(not torch_geometric, reason="pytorch_geometric not installed")
-def test_TFGW():
+def test_TFGW_optim():
     # Test the TFGW layer by passing two graphs through the layer and doing backpropagation.
 
-    import torch
-    from torch_geometric.nn import Linear
-    from torch_geometric.data import Data as GraphData
-    from torch_geometric.loader import DataLoader
-    import torch.nn as nn
-    from ot.gnn import TFGWPooling
-
     class pooling_TFGW(nn.Module):
         """
         Pooling architecture using the TFGW layer.
@@ -52,6 +52,8 @@ def forward(self, x, edge_index):
 
             return x
 
+    torch.manual_seed(0)
+
     n_templates = 3
     n_template_nodes = 3
     n_nodes = 10
@@ -86,19 +88,135 @@ def forward(self, x, edge_index):
             loss = criterion(out, data.y)
             loss.backward()
             optimizer.step()
+            optimizer.zero_grad()
+
+
+@pytest.mark.skipif(not torch_geometric, reason="pytorch_geometric not installed")
+def test_TFGW_variants():
+    # Test the TFGW layer by passing two graphs through the layer and doing backpropagation.
+
+    class GNN_pooling(nn.Module):
+        """
+        Pooling architecture using the TW layer.
+        """
+
+        def __init__(self, n_features, n_templates, n_template_nodes, pooling_layer):
+            """
+            Pooling architecture using the TW layer.
+            """
+            super().__init__()
+
+            self.n_features = n_features
+            self.n_templates = n_templates
+            self.n_template_nodes = n_template_nodes
+
+            self.TFGW = pooling_layer
+
+            self.linear = Linear(self.n_templates, 1)
+
+        def forward(self, x, edge_index, batch=None):
+
+            x = self.TFGW(x, edge_index, batch=batch)
+
+            x = self.linear(x)
+
+            return x
+
+    n_templates = 3
+    n_template_nodes = 3
+    n_nodes = 10
+    n_features = 3
+
+    torch.manual_seed(0)
+
+    C1 = torch.randint(0, 2, size=(n_nodes, n_nodes))
+    edge_index1 = torch.stack(torch.where(C1 == 1))
+    x1 = torch.rand(n_nodes, n_features)
+    graph1 = GraphData(x=x1, edge_index=edge_index1, y=torch.tensor([0.]))
+    batch1 = torch.tensor([1] * n_nodes)
+    batch1[:n_nodes // 2] = 0
+
+    criterion = torch.nn.CrossEntropyLoss()
+
+    for train_node_weights in [True, False]:
+        for alpha in [None, 0, 0.5]:
+            for multi_alpha in [True, False]:
+                model = GNN_pooling(n_features, n_templates, n_template_nodes,
+                                    pooling_layer=TFGWPooling(n_templates, n_template_nodes, n_features, alpha=alpha, multi_alpha=multi_alpha, train_node_weights=train_node_weights))
+
+                # predict
+                out1 = model(graph1.x, graph1.edge_index)
+                loss = criterion(out1, graph1.y)
+                loss.backward()
+
+                # predict on batch
+                out1 = model(graph1.x, graph1.edge_index, batch1)
+
+
+@pytest.mark.skipif(not torch_geometric, reason="pytorch_geometric not installed")
+def test_TW_variants():
+    # Test the TFGW layer by passing two graphs through the layer and doing backpropagation.
+
+    class GNN_pooling(nn.Module):
+        """
+        Pooling architecture using the TW layer.
+        """
+
+        def __init__(self, n_features, n_templates, n_template_nodes, pooling_layer):
+            """
+            Pooling architecture using the TW layer.
+            """
+            super().__init__()
+
+            self.n_features = n_features
+            self.n_templates = n_templates
+            self.n_template_nodes = n_template_nodes
+
+            self.TFGW = pooling_layer
+
+            self.linear = Linear(self.n_templates, 1)
+
+        def forward(self, x, edge_index, batch=None):
+
+            x = self.TFGW(x, edge_index, batch=batch)
+
+            x = self.linear(x)
+
+            return x
+
+    n_templates = 3
+    n_template_nodes = 3
+    n_nodes = 10
+    n_features = 3
+
+    torch.manual_seed(0)
+
+    C1 = torch.randint(0, 2, size=(n_nodes, n_nodes))
+    edge_index1 = torch.stack(torch.where(C1 == 1))
+    x1 = torch.rand(n_nodes, n_features)
+    graph1 = GraphData(x=x1, edge_index=edge_index1, y=torch.tensor([0.]))
+    batch1 = torch.tensor([1] * n_nodes)
+    batch1[:n_nodes // 2] = 0
+
+    criterion = torch.nn.CrossEntropyLoss()
+
+    for train_node_weights in [True, False]:
+
+        model = GNN_pooling(n_features, n_templates, n_template_nodes,
+                            pooling_layer=TWPooling(n_templates, n_template_nodes, n_features, train_node_weights=train_node_weights))
+
+        out1 = model(graph1.x, graph1.edge_index)
+        loss = criterion(out1, graph1.y)
+        loss.backward()
+
+        # predict on batch
+        out1 = model(graph1.x, graph1.edge_index, batch1)
 
 
 @pytest.mark.skipif(not torch_geometric, reason="pytorch_geometric not installed")
 def test_TW():
     # Test the TW layer by passing two graphs through the layer and doing backpropagation.
 
-    import torch
-    from torch_geometric.nn import Linear
-    from torch_geometric.data import Data as GraphData
-    from torch_geometric.loader import DataLoader
-    import torch.nn as nn
-    from ot.gnn import TWPooling
-
     class pooling_TW(nn.Module):
         """
         Pooling architecture using the TW layer.
@@ -126,6 +244,8 @@ def forward(self, x, edge_index):
 
             return x
 
+    torch.manual_seed(0)
+
     n_templates = 3
     n_template_nodes = 3
     n_nodes = 10
@@ -160,3 +280,4 @@ def forward(self, x, edge_index):
             loss = criterion(out, data.y)
             loss.backward()
             optimizer.step()
+            optimizer.zero_grad()