Greetings,

My data consists of time-series samples with 100 steps, each containing 2 features. In other words, my data is shaped as `(samples, steps, features)`

.

The model I’m currently implementing works in TensorFlow, but I’m having trouble properly implementing it in PyTorch.

```
class KnownDetector(Model):
def __init__(self):
super(KnownDetector, self).__init__()
self.TCP = tf.keras.Sequential([
layers.Conv1D(filters=32, kernel_size=3, activation="relu", input_shape=(100, 2)), # 100 packets, 2 features
layers.MaxPool1D(pool_size=3, padding='same'),
layers.Conv1D(filters=32, kernel_size=3, activation="relu"), # 100 packets, 2 features
layers.MaxPool1D(pool_size=3, padding='same'),
layers.Conv1D(filters=32, kernel_size=3, activation="relu"), # 100 packets, 2 features
layers.Flatten(),
layers.Dense(128),
layers.Dense(num_classes, activation='softmax') # num_classes = 36 in this example
])
def call(self, x):
return self.TCP(x)
fx = KnownDetector()
fx.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(), optimizer='adam', metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])
fx.fit(train_data, train_labels, epochs=30, validation_data=(val_data, val_labels))
```

My understanding is that the input should be reshaped from `(steps, input_dim)`

to `(input_dim, steps)`

.

PyTorch equivalent:

```
class ModelKnown(torch.nn.Module):
def __init__(self):
super().__init__()
self.TCP = torch.nn.Sequential(torch.nn.Conv1d(in_channels=2, out_channels=32, kernel_size=3),
torch.nn.ReLU(),
torch.nn.MaxPool1d(kernel_size=3),
torch.nn.Conv1d(in_channels=32, out_channels=32, kernel_size=3),
torch.nn.ReLU(),
torch.nn.MaxPool1d(kernel_size=3),
torch.nn.Conv1d(in_channels=32, out_channels=32, kernel_size=3),
torch.nn.Flatten(),
torch.nn.Linear(in_features=256, out_features=128),
torch.nn.Linear(in_features=128, out_features=36),
torch.nn.Softmax(1))
def forward(self, x):
return self.TCP(x)
```

PyTorch doesn’t have a compile the same way TF does, so I’ve been doing my best following pytorch documentation:

```
x = torch.from_numpy(data)
y = torch.from_numpy(labels.to_numpy())
x.requires_grad=True
# Construct our model by instantiating the class defined above
model = ModelKnown()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-6)
for t in range(20):
# Forward pass: Compute predicted y by passing x to the model
y_pred = model(x)
# Compute and print loss
loss = criterion(y_pred, y)
print(t, loss.item())
optimizer.zero_grad()
loss.backward()
optimizer.step()
```

This outputs:

```
0 3.5832407474517822
1 3.5832395553588867
... # and so on
```

- What am I doing incorrectly here?
- In TensorFlow, I’m passing data for evaluation, is there a way to do so for PyTorch?

Thanks in advance for any help!