RuntimeError: mat1 and mat2 must have the same dtype

[anthonysirico]

Has anyone received this before?

Traceback (most recent call last):
  File "/snap/pycharm-community/327/plugins/python-ce/helpers/pydev/pydevconsole.py", line 364, in runcode
    coro = func()
  File "<input>", line 1, in <module>
  File "/snap/pycharm-community/327/plugins/python-ce/helpers/pydev/_pydev_bundle/pydev_import_hook.py", line 21, in do_import
    module = self._system_import(name, *args, **kwargs)
  File "/home/polar/GDL-TMS/python/run_model.py", line 50, in <module>
    train()
  File "/home/polar/GDL-TMS/python/run_model.py", line 29, in train
    out = model(data.x, data.edge_index, data.batch)  # Perform a single forward pass.
  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/GDL-TMS/python/gnn_model.py", line 19, in forward
    x = self.conv1(x, 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/graph_conv.py", line 88, in forward
    out = self.lin_rel(out)
  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/dense/linear.py", line 132, in forward
    return F.linear(x, self.weight, self.bias)
RuntimeError: mat1 and mat2 must have the same dtype

from abc import ABC

from scipy.io import loadmat
import pandas as pd
from torch_geometric.data import InMemoryDataset
import torch
import numpy as np
import torch_geometric
from tqdm import tqdm
from typing import Union, List
from torch import Tensor
from collections.abc import Sequence
from torch_geometric.utils import from_networkx
from sklearn.preprocessing import LabelEncoder
import networkx as nx


def _get_node_features(nxg, nl):
    nl = dict(enumerate(nl[:nxg.number_of_nodes()]))

    nx.set_node_attributes(nxg, nl, 'feature')

    return nxg


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

    @property
    def raw_file_names(self):
        return ['/home/polar/GDL-TMS/data/graphs.mat', '/home/polar/GDL-TMS/data/nl.json']

    @property
    def processed_file_names(self) -> list[str]:
        return ['data.pt']

    def download(self):
        pass

    def process(self):
        raw_data = loadmat(self.raw_file_names[0], squeeze_me=True)
        data = pd.DataFrame(raw_data['Graphs'])
        node_labels = pd.read_json(self.raw_file_names[1])

        le = LabelEncoder()
        encoded_node_labels = node_labels.apply(le.fit_transform, axis=1)

        tms_graphs = []
        for index, graph in tqdm(data.iterrows(), total=len(data)):
            nxg = nx.DiGraph(data['A'][index])
            nxg = _get_node_features(nxg, encoded_node_labels.loc[[index]].item())
            pyg = from_networkx(nxg, group_node_attrs=['feature'])
            pyg.y_compiled = torch.tensor(data['compiled'][index], dtype=torch.long)
            pyg.y_simulated = torch.tensor(data['simulated'][index], dtype=torch.long)
            tms_graphs.append(pyg)

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

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

        data_known, slices_known = self.collate(tms_graphs)

        torch.save((data_known, slices_known), self.processed_paths[0])

    def _get_node_features(self, nxg, nl):
        nl = dict(enumerate(nl[:nxg.number_of_nodes()]))

        nx.set_node_attributes(nxg, nl, 'feature')

        return nxg

[wsad1]

What is the dtype of data.x ?
This error is probably because data.x isn't of type float.

[anthonysirico]

oh, ok. its type long.

[wsad1]

Yeah try converting it to float.

[anthonysirico]

@rusty1s
So i am still running into the same problem after changing the x to torch.float64. According to
https://discuss.pytorch.org/t/runtimeerror-mat1-and-mat2-must-have-the-same-dtype/166759/5

this might have to do with the dtypes of the weights that are automatically generated with InMemory dataset. If this is the case, how do we change the dtype the weight values?

from abc import ABC

from scipy.io import loadmat
import pandas as pd
from torch_geometric.data import InMemoryDataset
import torch
import numpy as np
import torch_geometric
from tqdm import tqdm
from typing import Union, List
from torch import Tensor
from collections.abc import Sequence
from torch_geometric.utils import from_networkx
from sklearn.preprocessing import LabelEncoder
import networkx as nx


def _get_node_features(nxg, nl):
    nl = dict(enumerate(nl[:nxg.number_of_nodes()]))

    nx.set_node_attributes(nxg, nl, 'feature')

    return nxg


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

    @property
    def raw_file_names(self):
        return ['/home/polar/GDL-TMS/data/graphs.mat', '/home/polar/GDL-TMS/data/nl.json']

    @property
    def processed_file_names(self) -> list[str]:
        return ['data.pt']

    def download(self):
        pass

    def process(self):
        raw_data = loadmat(self.raw_file_names[0], squeeze_me=True)
        data = pd.DataFrame(raw_data['Graphs'])
        node_labels = pd.read_json(self.raw_file_names[1])

        le = LabelEncoder()
        encoded_node_labels = node_labels.apply(le.fit_transform, axis=1)

        tms_graphs = []
        for index, graph in tqdm(data.iterrows(), total=len(data)):
            nxg = nx.DiGraph(data['A'][index])
            pyg = from_networkx(nxg)
            pyg.x = self._get_node_features(nxg, encoded_node_labels[index])
            pyg.y_compiled = torch.tensor(data['compiled'][index], dtype=torch.long)
            pyg.y_simulated = torch.tensor(data['simulated'][index], dtype=torch.long)
            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]

        data_known, slices_known = self.collate(tms_graphs)

        torch.save((data_known, slices_known), self.processed_paths[0])

    def _get_node_features(self, nxg, nl):

        nl = nl[:nxg.number_of_nodes()]

        nl = torch.tensor(nl, dtype=torch.float64).resize(len(nl), 1)

        return nl

dataset[0].x.dtype = torch.float64
dataset[0].weight = torch.int64
dataset[0].edge_index.dtype = torch.int64
dataset[0].y.dtype = torch.int64

Traceback (most recent call last):
  File "/snap/pycharm-community/327/plugins/python-ce/helpers/pydev/pydevconsole.py", line 364, in runcode
    coro = func()
  File "<input>", line 1, in <module>
  File "/snap/pycharm-community/327/plugins/python-ce/helpers/pydev/_pydev_bundle/pydev_import_hook.py", line 21, in do_import
    module = self._system_import(name, *args, **kwargs)
  File "/home/polar/GDL-TMS/python/run_model.py", line 50, in <module>
    train()
  File "/home/polar/GDL-TMS/python/run_model.py", line 29, in train
    out = model(data.x, data.edge_index, data.batch)  # Perform a single forward pass.
  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/GDL-TMS/python/gnn_model.py", line 19, in forward
    x = self.conv1(x, 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/graph_conv.py", line 88, in forward
    out = self.lin_rel(out)
  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/dense/linear.py", line 132, in forward
    return F.linear(x, self.weight, self.bias)
RuntimeError: mat1 and mat2 must have the same dtype

[wsad1]

try converting to float
data.x = data.x.to(torch.float)

[anthonysirico]

@wsad1 @rusty1s
That worked, but now im getting

Traceback (most recent call last):
  File "/snap/pycharm-community/327/plugins/python-ce/helpers/pydev/pydevconsole.py", line 364, in runcode
    coro = func()
  File "<input>", line 1, in <module>
  File "/snap/pycharm-community/327/plugins/python-ce/helpers/pydev/_pydev_bundle/pydev_import_hook.py", line 21, in do_import
    module = self._system_import(name, *args, **kwargs)
  File "/home/polar/GDL-TMS/python/run_model.py", line 50, in <module>
    train()
  File "/home/polar/GDL-TMS/python/run_model.py", line 30, in train
    loss = criterion(out, data.y_compiled)  # Compute the loss solely based on the training nodes.
  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/loss.py", line 1174, in forward
    return F.cross_entropy(input, target, weight=self.weight,
  File "/home/polar/venv/pygeo/lib/python3.10/site-packages/torch/nn/functional.py", line 3029, in cross_entropy
    return torch._C._nn.cross_entropy_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index, label_smoothing)
TypeError: cross_entropy_loss(): argument 'input' (position 1) must be Tensor, not NoneType

my model worked fine before the update.

[anthonysirico]

UPDATE so out is type none.

I called the same way i have in previous models, I don't know why this one is acting differently. I cant confirm what dtype out is without doing it manually.

import torch
from torch_geometric.loader import DataLoader
import gnn_model as gnn
from tms_dataset import TMSDataset
from tqdm import tqdm

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)

dataset = TMSDataset('test2')

training_set = dataset[:31000]
val_set = dataset[31000:]

training_loader = DataLoader(training_set, batch_size=32, shuffle=True)
val_loader = DataLoader(val_set, batch_size=32, shuffle=False)

model = gnn.GCN(hidden_channels=63).to(device)
print(model)

optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
criterion = torch.nn.CrossEntropyLoss()
def train():
    model.train()

    total_loss = 0
    for data in training_loader:  # Iterate in batches over the training dataset.
        data = data.to(device)
        out = model(data.x, data.edge_index, data.batch)  # Perform a single forward pass.
        loss = criterion(out, data.y_compiled)  # Compute the loss solely based on the training nodes.
        loss.backward()  # Derive gradients.
        optimizer.step()  # Update parameters based on gradients.
        optimizer.zero_grad()  # Clear gradients.

def test(loader):
    model.eval()

    correct = 0
    for data in loader:  # Iterate in batches over the training/test dataset.
        data = data.to(device)
        out = model(data.x, data.edge_index, data.batch)
        pred = out.argmax(dim=1)  # Use the class with highest probability.
        correct += int((pred == data.y_compiled).sum())  # Check against ground-truth labels.
    return correct / len(loader.dataset)  # Derive ratio of correct predictions.

train_accuracy = []
val_accuracy = []
epochs = 100
for epoch in tqdm(range(1, epochs + 1), total=epochs):
    train()
    train_acc = test(training_loader)
    train_accuracy.append(train_acc)
    val_acc = test(val_loader)
    val_accuracy.append(val_acc)

[rusty1s]

How is gnn.GCN defined? Does it actually return something? :)

[anthonysirico]

yes, when i call it, it prints the model and says its built.

from torch_geometric.nn import GraphConv
from torch_geometric.nn import global_mean_pool
from torch.nn import Linear
import torch.nn.functional as F
import torch


class GCN(torch.nn.Module):
    def __init__(self, hidden_channels):
        super(GCN, self).__init__()
        torch.manual_seed(12345)
        self.conv1 = GraphConv(1, hidden_channels)
        self.conv2 = GraphConv(hidden_channels, hidden_channels)
        self.conv3 = GraphConv(hidden_channels, hidden_channels)
        self.lin = Linear(hidden_channels, 2)

    def forward(self, x, edge_index, batch):
        # 1. Obtain node embeddings
        x = self.conv1(x, edge_index)
        x = x.relu()
        x = self.conv2(x, edge_index)
        x = x.relu()
        x = self.conv3(x, edge_index)

        # 2. Readout layer
        x = global_mean_pool(x, batch)  # [batch_size, hidden_channels]

        # 3. Apply a final classifier
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.lin(x)

        return

[rusty1s]

How about return x instead of return?

[anthonysirico]

lol thanks man! that did it, cant believe I didn't catch that.

[anthonysirico]

one last question, when i do .from_networkx and use the group_node_attributes, is there a way to import them as floats? because sine they're int, it automatically does it as int for data.x

[rusty1s]

You can do data.x = data.x.to(torch.float) afterwards.

[anthonysirico]

thanks