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")
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):
perm = np.random.permutation(N)
Xtrain = data.Xtrain[perm, :]
# 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
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)
dataloader_train = data.DataLoader(dataset_train,shuffle=shuffle_dataset,batch_size=batch_size)
