TypeError: linear(): argument 'input' (position 1) must be Tensor, not NoneType

[anthonysirico]

Using the qm9 model:

dim = 64


class Net(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.lin0 = torch.nn.Linear(1, dim, dtype=torch.float64)

        nn = Sequential(Linear(5, 128, dtype=torch.float64), ReLU(), Linear(128, dim * dim, dtype=torch.float64))
        self.conv = NNConv(dim, dim, nn, aggr='mean')
        self.gru = GRU(dim, dim)

        self.set2set = Set2Set(dim, processing_steps=3)
        self.lin1 = torch.nn.Linear(2 * dim, dim, dtype=torch.float64)
        self.lin2 = torch.nn.Linear(dim, 1, dtype=torch.float64)

    def forward(self, data):
        out = F.relu(self.lin0(data.x))
        h = out.unsqueeze(0)

        for i in range(3):
            m = F.relu(self.conv(out, data.edge_index, data.edge_attr))
            out, h = self.gru(m.unsqueeze(0), h)
            out = out.squeeze(0)

        out = self.set2set(out, data.batch)
        out = F.relu(self.lin1(out))
        out = self.lin2(out)
        return out.view(-1)

I checked the type for out, its torch.float64 but for some reason I'm still getting TypeError: linear(): argument 'input' (position 1) must be Tensor, not NoneType where everything that I'm inputting has an assigned tensor.

Full out put is

Traceback (most recent call last):
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/IPython/core/interactiveshell.py", line 3526, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-48-5f9bc330899e>", line 1, in <module>
    conv(out, data.edge_index)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl
    return forward_call(*args, **kwargs)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch_geometric/nn/conv/nn_conv.py", line 102, in forward
    out = self.propagate(edge_index, x=x, edge_attr=edge_attr, size=size)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch_geometric/nn/conv/message_passing.py", line 467, in propagate
    out = self.message(**msg_kwargs)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch_geometric/nn/conv/nn_conv.py", line 114, in message
    weight = self.nn(edge_attr)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl
    return forward_call(*args, **kwargs)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/container.py", line 217, in forward
    input = module(input)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl
    return forward_call(*args, **kwargs)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/linear.py", line 114, in forward
    return F.linear(input, self.weight, self.bias)
TypeError: linear(): argument 'input' (position 1) must be Tensor, not NoneType

I know it has something to do with the Sequential nn .

[anthonysirico]

also, im trying different nn, are there any nn's that accept floats, GCNConv only accepts doubles.

[rusty1s]

Do you have a minimal example to reproduce? Can I just change this model in the examples/qm9.py script?

[anthonysirico]

@rusty1s So for my model, its pretty much the same except that the lin0 input features is 1, and the first Linear layer of the sequential nn is dim=64.

import torch
from torch.nn import Linear, ReLU, Sequential, GRU
from torch_geometric.nn import NNConv, Set2Set
import torch.nn.functional as F

dim = 64


class Net(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.lin0 = torch.nn.Linear(1, dim, dtype=torch.float64)

        nn = Sequential(Linear(dim, 128, dtype=torch.float64), ReLU(), Linear(128, dim * dim, dtype=torch.float64))
        self.conv = NNConv(dim, dim, nn, aggr='mean')
        self.gru = GRU(dim, dim)

        self.set2set = Set2Set(dim, processing_steps=3)
        self.lin1 = torch.nn.Linear(2 * dim, dim, dtype=torch.float64)
        self.lin2 = torch.nn.Linear(dim, 1, dtype=torch.float64)

    def forward(self, data):
        out = F.relu(self.lin0(data.x))
        h = out.unsqueeze(0)

        for i in range(3):
            m = F.relu(self.conv(out, data.edge_index, data.edge_attr))
            out, h = self.gru(m.unsqueeze(0), h)
            out = out.squeeze(0)

        out = self.set2set(out, data.batch)
        out = F.relu(self.lin1(out))
        out = self.lin2(out)
        return out.view(-1)

The overall dataset is:

dataset.data = Data(edge_index=[2, 665380], weight=[665380], x=[540246, 1], catalog=[32612], compiled=[32612], simulated=[32612], Utility=[32612], Objectives=[163060])

Everything is torch.int64 except data.Utility and data.Objectives which are torch.float64.
The set creation is:

import os.path as osp
import pickle
from abc import ABC
from tqdm import tqdm
import pandas as pd
import torch
from torch_geometric.data import InMemoryDataset
from torch_geometric.utils import from_networkx
import networkx as nx
from sklearn.preprocessing import LabelEncoder
import math

target = 0


def _get_node_features(networkx_graph, node_labels):
    nl = node_labels[0:len(networkx_graph.nodes)]
    nl = dict(enumerate(nl))
    nx.set_node_attributes(networkx_graph, nl, 'feature')
    return networkx_graph


class TMSDataset(InMemoryDataset, ABC):
    def __init__(self, root, transform=None, pre_transform=None, pre_filter=None):
        super(TMSDataset, self).__init__(root, transform, pre_transform, pre_filter)
        self.data, self.slices = torch.load(self.processed_paths[0])

    def mean(self, target: int) -> float:
        y = torch.cat([self.get(i).Utility for i in range(len(self))], dim=0)
        return float(y[:, target].mean())

    def std(self, target: int) -> float:
        y = torch.cat([self.get(i).Utility for i in range(len(self))], dim=0)
        return float(y[:, target].std())

    @property
    def raw_file_names(self):
        return ['networkx_graphs.pickle', 'nl.json', 'graph_features.csv']

    @property
    def processed_file_names(self):
        return 'tms_graphs.pt'

    def download(self):
        pass

    def process(self):
        tms_graphs = []
        networkx_graphs = pickle.load(open(self.raw_paths[0], 'rb'))
        node_labels = pd.read_json(self.raw_paths[1])
        graph_features = pd.read_csv(self.raw_paths[2])
        encoder = LabelEncoder()
        encoded_node_labels = node_labels.apply(encoder.fit_transform, axis=1)

        for index in tqdm(range(len(networkx_graphs))):
            nx_graph = networkx_graphs[index]
            nx_graph = _get_node_features(nx_graph, encoded_node_labels[index])
            pyg = from_networkx(nx_graph, group_node_attrs=['feature'])
            pyg.catalog = torch.tensor(graph_features['Catalog Code'][index], dtype=torch.long)
            pyg.compiled = torch.tensor(graph_features['compiled'][index], dtype=torch.long)
            pyg.simulated = torch.tensor(graph_features['simulated'][index], dtype=torch.long)
            if math.isnan(graph_features['Utility'][index]):
                pyg.Utility = torch.nan_to_num(torch.tensor(graph_features['Utility'][index])).to(dtype=torch.float32)
            else:
                pyg.Utility = torch.tensor(graph_features['Utility'][index])

            if math.isnan(graph_features['min J1'][index]):
                j1 = torch.nan_to_num(torch.tensor(graph_features['min J1'][index])).to(dtype=torch.float32)
            else:
                j1 = torch.tensor(graph_features['min J1'][index])
            if math.isnan(graph_features['min J2'][index]):
                j2 = torch.nan_to_num(torch.tensor(graph_features['min J2'][index])).to(dtype=torch.float32)
            else:
                j2 = torch.tensor(graph_features['min J2'][index])
            if math.isnan(graph_features['min J3'][index]):
                j3 = torch.nan_to_num(torch.tensor(graph_features['min J3'][index])).to(dtype=torch.float32)
            else:
                j3 = torch.tensor(graph_features['min J3'][index])
            if math.isnan(graph_features['min J4'][index]):
                j4 = torch.nan_to_num(torch.tensor(graph_features['min J4'][index])).to(dtype=torch.float32)
            else:
                j4 = torch.tensor(graph_features['min J4'][index])
            if math.isnan(graph_features['min J5'][index]):
                j5 = torch.nan_to_num(torch.tensor(graph_features['min J5'][index])).to(dtype=torch.float32)
            else:
                j5 = torch.tensor(graph_features['min J5'][index])

            objectives = [j1, j2, j3, j4, j5]
            pyg.Objectives = torch.stack(objectives)

            tms_graphs.append(pyg)

        if self.pre_filter is not None:
            tms_graphs = [data for data in tms_graphs if self.pre_filter(data)]

        if self.pre_transform is not None:
            tms_graphs = [self.pre_transform(data) for data in tms_graphs]

        torch.save(self.collate(tms_graphs), self.processed_paths[0])

Setting it up the same way as in the example gives me:

Traceback (most recent call last):
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/IPython/core/interactiveshell.py", line 3526, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-21-ceddd11289fa>", line 28, in <module>
    loss = train(epoch)
  File "<ipython-input-21-ceddd11289fa>", line 8, in train
    loss = F.mse_loss(model(data), data.Utility)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl
    return forward_call(*args, **kwargs)
  File "/media/polar/ubuntu/tms_project/source_code/qm9_nn.py", line 23, in forward
    out = F.relu(self.lin0(data.x))
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl
    return forward_call(*args, **kwargs)
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/modules/linear.py", line 114, in forward
    return F.linear(input, self.weight, self.bias)
RuntimeError: mat1 and mat2 must have the same type

So then I cast data.x.to(torch.float) and get the same error, so I think its data.weight so I do the same thing. So when everything is the same type, I get the error above. Also, I do not perform any of the transforms or mean or std as qm9 shows.

[rusty1s]

If your features are of torch.int64, you should actually convert them to floating point via one_hot rather than simple casting. In addition, note that the MLP in NNConv maps edge features to a weight matrix, so it needs to be defined as

nn = Sequential(Linear(edge_attr.size(-1), ...), ...)

[anthonysirico]

@rusty1s But what if i dont have edge features? Does that matter?

[rusty1s]

NNConv expects edge features to be present, so this does matter. If you don't have any edge features, you would need to use a different GNN layer.