def main_circles():
# init
data = CirclesData()
data.plot_data()
np.random.seed(42)
N = data.Xtrain.shape[0]
inds = np.arange(0, N)
np.random.shuffle(inds)
Xtrain = data.Xtrain[inds]
Ytrain = data.Ytrain[inds]
Nbatch = 15
nx = data.Xtrain.shape[1]
nh = 10
ny = data.Ytrain.shape[1]
eta = 0.03
# Premiers tests, code à modifier
model, loss, optim = init_model(nx, nh, ny, eta)
writer = SummaryWriter()
L, acc = 0, 0
# TODO apprentissage
Nepochs = 200
for i in range(Nepochs):
for j in range(0, N, Nbatch):
Xbatch = Xtrain[j:j + Nbatch]
Ybatch = Ytrain[j:j + Nbatch]
Yhat = model(Xbatch)
L, acc = loss_accuracy(loss, Yhat, Ybatch)
# Calcule les gradients
optim.zero_grad()
L.backward()
optim.step()
# Loss and Accuracy on Test
Yhat_test = model(data.Xtest)
L_test, acc_test = loss_accuracy(loss, Yhat_test, data.Ytest)
data.plot_loss(L, L_test, acc, acc_test)
Ygrid = torch.nn.Softmax(dim=1)(model(data.Xgrid))
data.plot_data_with_grid(Ygrid.detach())
# attendre un appui sur une touche pour garder les figures
input("done")
torch.nn.Linear(nh, ny),
)
loss = torch.nn.CrossEntropyLoss()
optim = torch.optim.SGD(model.parameters(), lr=eta)
return model, loss, optim
def loss_accuracy(Yhat, Y, loss):
L = loss(Yhat, Y)
acc = torch.mean((Yhat.argmax(1) == Y).float())
return L, acc
if __name__ == '__main__':
data = CirclesData()
data.plot_data()
# init
N = data.Xtrain.shape[0]
Nbatch = 16
nx = data.Xtrain.shape[1]
nh = 10
ny = data.Ytrain.shape[1]
model, loss, optim = init_model(nx, nh, ny)
# epoch
acctests = []
for iteration in range(100):
def sgd(model, eta):
# TODO mettre à jour le contenu de params
with torch.no_grad():
for param in model.parameters():
param -= eta * param.grad
model.zero_grad()
if __name__ == '__main__':
# init
data = CirclesData()
data.plot_data()
np.random.seed(42)
N = data.Xtrain.shape[0]
inds = np.arange(0, N)
np.random.shuffle(inds)
Xtrain = data.Xtrain[inds]
Ytrain = data.Ytrain[inds]
Nbatch = 20
nx = data.Xtrain.shape[1]
nh = 10
ny = data.Ytrain.shape[1]
eta = 0.03
# Premiers tests, code à modifier
def sgd(params, grads, eta):
# TODO mettre à jour le contenu de params
params["Wy"] -= grads["Wy"] * eta
params["by"] -= grads["by"] * eta
params["Wh"] -= grads["Wh"] * eta
params["bh"] -= grads["bh"] * eta
return params
if __name__ == '__main__':
# init
data = CirclesData()
# data.plot_data()
N = data.Xtrain.shape[0]
Nepoch = 1500 # 3000
Nbatch = 10
nx = data.Xtrain.shape[1]
nh = 10
ny = data.Ytrain.shape[1]
eta = 0.2
print('Data set size: ', N) # 200 here
params = init_params(nx, nh, ny)
printInterval = 100
trainLosses = []
testLosses = []
# TODO apprentissage
params['Wh'] -= params['Wh'].grad * eta
params['bh'] -= params['bh'].grad * eta
# remet l'accumulateur de gradient à zéro
params['Wy'].grad.zero_()
params['by'].grad.zero_()
params['Wh'].grad.zero_()
params['bh'].grad.zero_()
return params
if __name__ == '__main__':
# init
data = CirclesData()
# data.plot_data()
N = data.Xtrain.shape[0]
Nepoch = 1500 # 3000
Nbatch = 10
nx = data.Xtrain.shape[1]
nh = 10
ny = data.Ytrain.shape[1]
eta = 0.2
print('Data set size: ', N) # 200 here
params = init_params(nx, nh, ny)
printInterval = 100
trainLosses = []
testLosses = []
# TODO apprentissage
return grads
def sgd(params, grads, eta):
with torch.no_grad():
for k in params.keys():
print("nanaanana : ", k, grads[k])
params[k] -= eta * grads[k]
return params
if __name__ == '__main__':
# init
data = CirclesData()
#data.plot_data()
N = data.Xtrain.shape[0]
Nbatch = 10
nx = data.Xtrain.shape[1]
nh = 10
ny = data.Ytrain.shape[1]
eta = 0.03
# Premiers tests, code à modifier
params = init_params(nx, nh, ny)
Yhat, outs = forward(params, data.Xtrain)
L, _ = loss_accuracy(Yhat, data.Ytrain)
grads = backward(params, outs, data.Ytrain)
params = sgd(params, grads, eta)
#print(grads)
return grads
def sgd(params, grads, eta):
# TODO mettre à jour le contenu de params
with torch.no_grad():
for key in params.keys():
params[key] -= eta * grads[key]
return params
if __name__ == '__main__':
# init
data = CirclesData()
#data.plot_data()
N = data.Xtrain.shape[0]
Nbatch = 20
nx = data.Xtrain.shape[1]
nh = 10
ny = data.Ytrain.shape[1]
eta = 0.003
index = np.arange(len(data.Xtrain))
random.shuffle(index)
data.Xtrain = data.Xtrain[index]
data.Ytrain = data.Ytrain[index]
# Premiers tests, code à modifier
params = init_params(nx, nh, ny)
"""Yhat, outs = forward(params, data.Xtrain.double())
L, _ = loss_accuracy(Yhat.double(), data.Ytrain.long())
# Chargement de la classe from tme5 import CirclesData # import de la classe data = CirclesData() # instancie la classe fournie # Accès aux données Xtrain = data.Xtrain # torch.Tensor contenant les entrées du réseau pour l'apprentissage print(Xtrain.shape) # affiche la taille des données : torch.Size([200, 2]) N = Xtrain.shape[0] # nombre d'exemples nx = Xtrain.shape[1] # dimensionalité d'entrée # données disponibles : data.Xtrain, data.Ytrain, data.Xtest, data.Ytest,data.Xgrid # Fonctions d'affichage data.plot_data() # affiche les points de train et test #Ygrid = forward(params, data.Xgrid) # calcul des predictions Y pour tous les points de la grille # (forward et params non fournis, à coder) #data.plot_data_with_grid(Ygrid) # affichage des points et de la frontière de décision gr^ace à la grille #data.plot_loss(loss_train, loss_train, acc_train, acc_test) # affiche les courbes de loss et accuracy en train et test. #Les valeurs à fournir sont des scalaires,elles sont stockées pour vous, # il suffit de passer les nouvelles valeurs à chaque itératio
else:
self.data = data.Xtest
labels = data.Ytest
_,self.labels = torch.max(labels, 1) # must be indice and not one-hot encoder.
def __getitem__(self,index):
return self.data[index],self.labels[index]
def __len__(self):
return len(self.labels)
if __name__ == '__main__':
# data circle
data_circle = CirclesData()
data_circle.plot_data()
N = data_circle.Xtrain.shape[0]
nx = data_circle.Xtrain.shape[1]
nh = 10
ny = data_circle.Ytrain.shape[1]
# model
model = Circle_Model(nx, nh, ny)
# dataloader
batch_size = 50
shuffle_dataset = True
dataset_train = Circle_Dataset(data_circle)
# import torch
from tme5 import CirclesData # import de la classe
from circles import init_params, forward, loss_accuracy, backward, sgd
if __name__ == '__main__':
# Chargement de la classe
data = CirclesData() # instancie la classe fournie
# Acces aux donn ees
Xtrain = data.Xtrain # torch.Tensor contenant les entr ́ees du r ́eseau pour → l'apprentissage
# print('Xtrain.shape: ', Xtrain.shape) # affiche la taille des donn ́ees : torch.Size([200, 2]) N = Xtrain.shape[0] # nombre d'exemples
nx = Xtrain.shape[1] # dimensionalite d'entree
# donn ees disponibles : data.Xtrain, data.Ytrain, data.Xtest, data.Ytest, -> data.Xgrid
# Fonctions d'affichage
# data.plot_data() # affiche les points de train et test
# Test of init_params
# nh = 4
# n = torch.distributions.Normal(torch.tensor(0.0), torch.tensor(0.3))
# wh = n.sample((nh,))
# print('wh: ', wh.shape, '\n', wh)
Ytrain = data.Ytrain
# print(Xtrain[0])
# print('Ytrain: ', Ytrain.shape)
# print(Ytrain)
nh = 6
ny = 2
params = init_params(nx, nh, ny)
