Hi ,
I am trying to implement swap auto-encoder with one of categorical column,in following data column “Name” is categorical and rest of first 3 columns are numerical
X = np.array([[1,2,3,'A'], [4,5,6,'A'],[7,8,9,'A'],[10,11,12,'B'],[13,14,15,'B'],[16,17,18,'B'],[19,20,21,'B'],[22,23,24,'B']])
X = pd.DataFrame(data=X,columns=['ID1','ID2','ID3','Name'])
X
| ID1 | ID2 | ID3 | Name | |
|---|---|---|---|---|
| 0 | 1 | 2 | 3 | A |
| 1 | 4 | 5 | 6 | A |
| 2 | 7 | 8 | 9 | A |
| 3 | 10 | 11 | 12 | B |
| 4 | 13 | 14 | 15 | B |
| 5 | 16 | 17 | 18 | B |
| 6 | 19 | 20 | 21 | B |
| 7 | 22 | 23 | 24 | B |
Here is my autoencoder
class Autoencoder(nn.Module):
def __init__(self,emb_szs,n_cont):
super().__init__()
self.embeds = nn.ModuleList([nn.Embedding(no_emb,sz_emb) for no_emb,sz_emb in emb_szs])
n_emb = sum([sz_emb for no_emb,sz_emb in emb_szs])
n_in = n_emb+n_cont
self.encoder = nn.Sequential(
nn.Linear(n_in,50),
nn.BatchNorm1d(50),
nn.ReLU(),
nn.Linear(50,10),
nn.BatchNorm1d(10),
nn.ReLU()
)
self.decoder = nn.Sequential(
nn.Linear(10,50),
nn.BatchNorm1d(50),
nn.ReLU())
self.decoder_recon = nn.Linear(50,n_in)
self.decoder_classifier = nn.Linear(50,n_in)
def forward(self,x_cat,x_cont):
#x = [e(x_cat[:,i]) for i,e in enumerate(self.embeds)]
#x = torch.cat(x, 1)
# x = torch.cat([x, x_cont], 1) # input layer
x = self.encoder(x)
x = self.decoder(x)
reconstruction = self.decoder_recon(x)
logits = self.decoder_classifier(x)
return reconstruction,logits
def get_encoder_state(self,x):
encoded = self.encoder(x)
return encoded
I am swapping randomly , one numerical column row values to another row values for same numerical column
class swapDataset:
def __init__(self, cont_x, noise,cat_x):
self.cont = cont_x.drop(cat_x,axis=1).copy().values.astype(np.float32) # numerical columns
self.cat = cont_x.loc[:,cat_x].copy().values.astype(np.int64) # categorical columns
self.noise = noise
def __len__(self):
return (self.cont.shape[0])
def __getitem__(self, idx):
sample = self.cont[idx, :].copy()
sample = self.swap_sample(sample)
dct = {
'x' : torch.tensor(sample, dtype=torch.float),
'y' : torch.tensor(self.cont[idx, :], dtype=torch.float),
'z' : torch.tensor(self.cat[idx, :], dtype=torch.int64)
}
return dct
def swap_sample(self,sample):
#print(sample.shape)
num_samples = self.cont.shape[0]
num_features = self.cont.shape[1]
if len(sample.shape) == 2:
batch_size = sample.shape[0]
random_row = np.random.randint(0, num_samples, size=batch_size)
for i in range(batch_size):
random_col = np.random.rand(num_features) < self.noise
#print(random_col)
sample[i, random_col] = self.cont[random_row[i], random_col]
else:
batch_size = 1
random_row = np.random.randint(0, num_samples, size=batch_size)
random_col = np.random.rand(num_features) < self.noise
#print(random_col)
#print(random_col)
sample[ random_col] = self.cont[random_row, random_col]
return sample
cat_cols =['Name']
for col in cat_cols:
X[col] = LabelEncoder().fit_transform(X[col])
train_dataset = swapDataset(X,0.2,cat_cols) # Swapping data using above swapDataset method
data_loader = torch.utils.data.DataLoader(train_dataset, batch_size=2, shuffle=False)
cat_dims = [int(X[col].nunique()) for col in cat_cols]
print(cat_dims)
emb_dims = [(x, min(50, (x + 1) // 2)) for x in cat_dims]
print(emb_dims)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
autoencoder= Autoencoder(emb_dims, 3).to(device)
[2]
[(2, 1)]
When i train , i am getting following error
num_epochs = 200
outputs = []
running_loss = 0.0
criterion = nn.MSELoss()
for epoch in range(num_epochs):
for data in data_loader:
inputs, targets,cat = data['x'].to(device), data['y'].to(device),data['z'].to(device)
recon,logits = autoencoder(cat,inputs)
print(recon)
print(targets)
loss_recon = criterion(recon,targets) # calculate loss
loss_classifier = criterion(logits,inputs)
#loss = loss_recon + loss_classifier
loss = loss_classifier
optimizer.zero_grad()
loss.backward()
optimizer.step() # update weights
if not scheduler.__class__ == torch.optim.lr_scheduler.ReduceLROnPlateau:
scheduler.step(loss)
running_loss += loss.item()
print(f'Epoch: {epoch+1}, Loss Classifier:{loss_classifier}, combined loss {loss}')
tensor([[-0.0963, 0.2478, -0.0934, 0.1523],
[ 0.4680, 0.1963, 0.4263, -0.1038]], grad_fn=<AddmmBackward>)
tensor([[1., 2., 3.],
[4., 5., 6.]])
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
/tmp/ipykernel_36/2034992058.py in <module>
12 print(targets)
13
---> 14 loss_recon = criterion(recon,targets) # calculate loss
15 loss_classifier = criterion(logits,inputs)
16
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
1049 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
1050 or _global_forward_hooks or _global_forward_pre_hooks):
-> 1051 return forward_call(*input, **kwargs)
1052 # Do not call functions when jit is used
1053 full_backward_hooks, non_full_backward_hooks = [], []
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/loss.py in forward(self, input, target)
526
527 def forward(self, input: Tensor, target: Tensor) -> Tensor:
--> 528 return F.mse_loss(input, target, reduction=self.reduction)
529
530
/opt/conda/lib/python3.7/site-packages/torch/nn/functional.py in mse_loss(input, target, size_average, reduce, reduction)
3087 reduction = _Reduction.legacy_get_string(size_average, reduce)
3088
-> 3089 expanded_input, expanded_target = torch.broadcast_tensors(input, target)
3090 return torch._C._nn.mse_loss(expanded_input, expanded_target, _Reduction.get_enum(reduction))
3091
/opt/conda/lib/python3.7/site-packages/torch/functional.py in broadcast_tensors(*tensors)
71 if has_torch_function(tensors):
72 return handle_torch_function(broadcast_tensors, tensors, *tensors)
---> 73 return _VF.broadcast_tensors(tensors) # type: ignore[attr-defined]
74
75
RuntimeError: The size of tensor a (4) must match the size of tensor b (3) at non-singleton dimension 1
What i understood is target and recon does not have same dimension ,I am not sure whether this is how we embed input in autoencoder , if it is then how can we embed output?