def __init__(self, encoding_dim):
super(Autoencoder, self).__init__()
## encoder ##
# linear layer (784 -> encoding_dim)
self.fc1 = F.Linear(28 * 28, encoding_dim)
## decoder ##
# linear layer (encoding_dim -> input size)
self.fc2 = F.Linear(encoding_dim, 28 * 28)
def __init__(self):
super(GeneratorNet, self).__init__()
n_features = 100
n_out = 784
self.hidden0 = nn.Sequential(nn.Linear(n_features, 256),
nn.LeakyReLU(0.2))
self.hidden1 = nn.Sequential(nn.Linear(256, 512), nn.LeakyReLU(0.2))
self.hidden2 = nn.Sequential(nn.Linear(512, 1024), nn.LeakyReLU(0.2))
self.out = nn.Sequential(nn.Linear(1024, n_out), nn.Tanh())
def __init__(self):
super(CVAE, self).__init__()
self.relu = nn.ReLU()
self.sigmoid = nn.Sigmoid()
# For Encoder
self.fcE = nn.Linear(X_dim + y_dim, h_dim)
self.fcE_mu = nn.Linear(h_dim, Z_dim)
self.fcE_var = nn.Linear(h_dim, Z_dim)
# For Decoder
self.fcD1 = nn.Linear(Z_dim + y_dim, h_dim)
self.fcD2 = nn.Linear(h_dim, X_dim)
def __init__(self):
super(DiscriminatorNet, self).__init__()
n_features = 784
n_out = 1
self.hidden0 = nn.Sequential(nn.Linear(n_features, 1024),
nn.LeakyReLU(0.2), nn.Dropout(0.3))
self.hidden1 = nn.Sequential(nn.Linear(1024, 512), nn.LeakyReLU(0.2),
nn.Dropout(0.3))
self.hidden2 = nn.Sequential(nn.Linear(512, 256), nn.LeakyReLU(0.2),
nn.Dropout(0.3))
self.out = nn.Sequential(torch.nn.Linear(256, n_out),
torch.nn.Sigmoid())
def gradient_descent_pytorch_using_nn():
batch_size, input_dim, hidden_layer_size, output_dim = 64, 1000, 100, 10
x = torch.randn(batch_size, input_dim)
y = torch.randn(batch_size, output_dim)
#ici on définit notre réseaud de neuronne. on voit ici une première couche linaire avec les input
#un relu et une dernière couche lineair avec les outputs
model = torch.nn.Sequential(
nn.Linear(input_dim, hidden_layer_size),
nn.ReLU(),
nn.Linear(hidden_layer_size, output_dim),
)
#on définit la loss on moyen de la fonction nn qui récupère directement la fonction et son traitement
loss_fn = nn.MSELoss(reduction='sum')
#on définit l'optimizer qui permet de rentre l'update des poids automatique dans un facon spécifique ici Adam mais possible SGD ou autre
#optimizer_fn = torch.optim.Adam(model.parameters(), lr=learning_rate)
for i in range(epochs):
#ici nos input rentre dans le model
y_pred = model(x)
#on définit la fonction de loss avec le y_pred ainsi que les outputs
loss = loss_fn(y_pred, y)
#on met les gradients à 0 avant de faire le backward pass
model.zero_grad()
#calcule le gradient de la loss en fonction de tout les parametres possible du model.
# à l'interne les paramètres de tous les modules ont le requires_grad=True
# donc cette appel calculera le gradients de tout les paramètres du model
loss.backward()
#soit on fait manuellement comme précedement
# mais la vu que notre model nous retour tout les paramètres on les récupères directement
# grace à parametre() et on update les poids en fonctzion du learning rate
with torch.no_grad():
for param in model.parameters():
param -= learning_rate * param.grad
def __init__(self, block, Norm):
super(DNN, self).__init__()
self.R1 = block(1*9, Norm)
self.R2 = block(4*9, Norm)
self.R3 = block(16*9, Norm)
self.last = F.Linear(576, 1)
def forward(self, x):
if self.bias is not None:
out = F.Linear(x, self.weight * self.w_mul, self.bias * self.b_mul)
else:
out = F.Linear(x, self.weight * self.w_mul)
return out
def forward(self, input): return F.Linear(input, self.mask*self.weight, self.bias)