mat1 and mat2 must have the same dtype

[anthonysirico]

I can't figure out which values are the wrong type. I got this the first time when I ran it and my data.Utillity values were mixed between torch.float32 and torch.float64. I made them all torch.float64 and I'm still getting the same error. Maybe someone here can find my error.

Dataset Process:

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]))
            else:
                pyg.Utility = torch.tensor(graph_features['Utility'][index], dtype=torch.float64)

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

            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])

Model, using qm9 example:

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

        nn = Sequential(Linear(5, 128), ReLU(), Linear(128, dim * dim))
        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)
        self.lin2 = torch.nn.Linear(dim, 1)

    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)

Running:

dataset = TMSDataset('/media/polar/ubuntu/tms_project/data')
target = 0
dim = 64
mean = dataset.Utility.mean(dim=0, keepdim=True)
std = dataset.Utility.std(dim=0, keepdim=True)
from torch_geometric.loader import DataLoader
test_dataset = dataset[:10000]
val_dataset = dataset[10000:20000]
train_dataset = dataset[20000:]
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False)
val_loader = DataLoader(val_dataset, batch_size=128, shuffle=False)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
import torch
from qm9_nn import Net
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Net().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min',
                                                       factor=0.7, patience=5,
                                                       min_lr=0.00001)
Processing...
100%|██████████| 32612/32612 [00:13<00:00, 2487.67it/s]
Done!
def train(epoch):
    model.train()
    loss_all = 0
    for data in train_loader:
        data = data.to(device)
        optimizer.zero_grad()
        loss = F.mse_loss(model(data), data.Utility)
        loss.backward()
        loss_all += loss.item() * data.num_graphs
        optimizer.step()
    return loss_all / len(train_loader.dataset)
def test(loader):
    model.eval()
    error = 0
    for data in loader:
        data = data.to(device)
        error += (model(data) * std - data.Utility * std).abs().sum().item()  # MAE
    return error / len(loader.dataset)
best_val_error = None
for epoch in range(1, 301):
    lr = scheduler.optimizer.param_groups[0]['lr']
    loss = train(epoch)
    val_error = test(val_loader)
    scheduler.step(val_error)
    if best_val_error is None or val_error <= best_val_error:
        test_error = test(test_loader)
        best_val_error = val_error
    print(f'Epoch: {epoch:03d}, LR: {lr:7f}, Loss: {loss:.7f}, '
          f'Val MAE: {val_error:.7f}, Test MAE: {test_error:.7f}')
    ```

Error
```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-5-ceddd11289fa>", line 28, in <module>
    loss = train(epoch)
  File "<ipython-input-5-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

[anthonysirico]

Had to cast all linear layers to torch.float64 since my data was float64

[rusty1s]

I suggest to cast your data to float32 instead. float64 will definitely slow your network down.

[anthonysirico]

It's because torch.nan_to_num makes it a float64 I tried changing it but it seems permanent. So I made everything else float64 to have the same drype.

[akihironitta]

As far as I checked, torch.nan_to_num respects the original dtype of its input.

I tried changing it but it seems permanent.

I'm not sure if I understand, but I still believe you should be able to convert the torch.float64 tensor to torch.float32, e.g.:

-               j1 = torch.nan_to_num(torch.tensor(graph_features['min J1'][index]))
+               j1 = torch.nan_to_num(torch.tensor(graph_features['min J1'][index])).to(torch.float32)