Spaces:
Sleeping
Sleeping
File size: 3,872 Bytes
cefcefa |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
import torch.nn as nn
import torch.nn.functional as F
import pytorch_lightning as pl
class MLP(pl.LightningModule):
def __init__(self, input_size, xcol='emb', ycol='avg_rating', batch_norm=True):
super().__init__()
self.input_size = input_size
self.xcol = xcol
self.ycol = ycol
# self.layers = nn.Sequential(
# nn.Linear(self.input_size, 2048),
# nn.ReLU(),
# nn.BatchNorm1d(2048),
# nn.Dropout(0.4),
# nn.Linear(2048, 512),
# nn.ReLU(),
# nn.BatchNorm1d(512),
# nn.Dropout(0.3),
# nn.Linear(512, 256),
# nn.ReLU(),
# nn.BatchNorm1d(256),
# nn.Dropout(0.2),
# nn.Linear(256, 128),
# nn.ReLU(),
# nn.BatchNorm1d(128),
# nn.Dropout(0.1),
# nn.Linear(128, 32),
# nn.ReLU(),
# nn.Linear(32, 1)
# )
self.layers = nn.Sequential(
nn.Linear(self.input_size, 1024),
# nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(1024, 128),
# nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(128, 64),
# nn.ReLU(),
nn.Dropout(0.1),
nn.Linear(64, 16),
# nn.ReLU(),
nn.Linear(16, 1)
)
def forward(self, x):
return self.layers(x)
def training_step(self, batch, batch_idx):
x = batch[self.xcol]
y = batch[self.ycol].reshape(-1, 1)
x_hat = self.layers(x)
loss = F.mse_loss(x_hat, y)
return loss
def validation_step(self, batch, batch_idx):
x = batch[self.xcol]
y = batch[self.ycol].reshape(-1, 1)
x_hat = self.layers(x)
loss = F.mse_loss(x_hat, y)
return loss
# def configure_optimizers(self):
# optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)
# return optimizer
class ResidualBlock(nn.Module):
def __init__(self, input_size, output_size, batch_norm=True, dropout_rate=0.0):
super(ResidualBlock, self).__init__()
self.linear = nn.Linear(input_size, output_size)
self.relu = nn.ReLU()
self.batch_norm = nn.BatchNorm1d(output_size) if batch_norm else nn.Identity()
self.dropout = nn.Dropout(dropout_rate)
self.adjust_dims = nn.Linear(input_size, output_size) if input_size != output_size else nn.Identity()
def forward(self, x):
identity = self.adjust_dims(x)
out = self.linear(x)
out = self.relu(out)
out = self.batch_norm(out)
out = self.dropout(out)
out += identity
out = self.relu(out)
return out
class ResMLP(pl.LightningModule):
def __init__(self, input_size, xcol='emb', ycol='avg_rating', batch_norm=True):
super().__init__()
self.input_size = input_size
self.xcol = xcol
self.ycol = ycol
self.layers = nn.Sequential(
ResidualBlock(input_size, 2048, batch_norm, dropout_rate=0.3),
ResidualBlock(2048, 512, batch_norm, dropout_rate=0.3),
ResidualBlock(512, 256, batch_norm, dropout_rate=0.2),
ResidualBlock(256, 128, batch_norm, dropout_rate=0.1),
nn.Linear(128, 32),
nn.ReLU(),
nn.Linear(32, 1)
)
def forward(self, x):
return self.layers(x)
def training_step(self, batch, batch_idx):
x = batch[self.xcol]
y = batch[self.ycol].reshape(-1, 1)
x_hat = self.layers(x)
loss = F.mse_loss(x_hat, y)
return loss
def validation_step(self, batch, batch_idx):
x = batch[self.xcol]
y = batch[self.ycol].reshape(-1, 1)
x_hat = self.layers(x)
loss = F.mse_loss(x_hat, y)
return loss
|