Exemple complet d'enregistrement du modèle pytoch + enregistrement du modèle pytoch seuls les paramètres d'entraînement sont - ils enregistrés? Oui (+ Solution)

        Le test utilise unliner model,Il y a d'autres questions.pytorch Enregistrer le modèle enregistrer seulement les paramètres d'entraînement？

saveModèle

# Importer des paquets
import glob
import os

import torch
import matplotlib.pyplot as plt
import random #Utilisé par l'Itérateur de données pour générer des données aléatoires

# Générer un ensemble de données x1Catégorie0,x2Catégorie1
n_data = torch.ones(50, 2)  # Forme de base des données
x1 = torch.normal(2 * n_data, 1)  # shape=(50, 2)
y1 = torch.zeros(50)  # Type0 shape=(50, 1)
x2 = torch.normal(-2 * n_data, 1)  # shape=(50, 2)
y2 = torch.ones(50)  # Type1 shape=(50, 1)
# Attention! x, y Les données doivent être présentées sous la forme suivante(torch.catEst de fusionner les données)
x = torch.cat((x1, x2), 0).type(torch.FloatTensor) y = torch.cat((y1, y2), 0).type(torch.FloatTensor) # Visualisation des ensembles de données plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn') plt.show() # Lecture des données： def data_iter(batch_size, x, y): num_examples = len(x) indices = list(range(num_examples))
    random.shuffle(indices)  # L'ordre de lecture des échantillons est aléatoire
    for i in range(0, num_examples, batch_size):
        j = torch.LongTensor(indices[i: min(i + batch_size, num_examples)]) #Peut - être moins d'une dernière foisbatch
        yield  x.index_select(0, j), y.index_select(0, j)

#############################################################################################################
def saver(model_state_dict, optimizer_state_dict, model_path, epoch, max_to_save=30):
    total_models = glob.glob(model_path + '*')
    if len(total_models) >= max_to_save:
        total_models.sort()
        os.remove(total_models[0])

    state_dict = {
    }
    state_dict["model_state_dict"] = model_state_dict
    state_dict["optimizer_state_dict"] = optimizer_state_dict

    torch.save(state_dict, model_path + 'h' + str(epoch))
    print('models {} save successfully!'.format(model_path + 'hahaha' + str(epoch)))



################################################################################################################

import torch.nn as nn
import torch.optim as optim



class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net = nn.Sequential(nn.Linear(2, 1), nn.ReLU())

    def forward(self, x):
        return self.net(x)

def loss(y_hat, y):
    return (y_hat - y.view(y_hat.size())) ** 2 / 2



def accuracy(y_hat, y):  #@save
    """Calculer la quantité correcte prévue."""
    cmp = y_hat.type(y.dtype) > 0.5 # Plus grand que0.5Catégorie1
    result=cmp.type(y.dtype)
    acc = 1-float(((result-y).sum())/ len(y))
    return acc;

lr = 0.03
num_epochs = 3 # Nombre d'Itérations
batch_size = 10 # Taille du lot
model = net()
params =  list(model.parameters())
optimizer = torch.optim.Adam(params, 1e-4)

for epoch in range(num_epochs):
    for X, y_train in data_iter(batch_size, x, y):
        optimizer.zero_grad()
        l = loss(model(X), y_train).sum()  # l Il s'agit de petits lots XEtyPerte de
        l.backward(retain_graph=True)
        optimizer.step()
        print(l)
    saver(model.state_dict(), optimizer.state_dict(), "./", epoch + 1,  max_to_save=100)

loadModèle

# Importer des paquets
import glob
import os

import torch
import matplotlib.pyplot as plt
import random #Utilisé par l'Itérateur de données pour générer des données aléatoires

# Générer un ensemble de données x1Catégorie0,x2Catégorie1
n_data = torch.ones(50, 2)  # Forme de base des données
x1 = torch.normal(2 * n_data, 1)  # shape=(50, 2)
y1 = torch.zeros(50)  # Type0 shape=(50, 1)
x2 = torch.normal(-2 * n_data, 1)  # shape=(50, 2)
y2 = torch.ones(50)  # Type1 shape=(50, 1)
# Attention! x, y Les données doivent être présentées sous la forme suivante(torch.catEst de fusionner les données)
x = torch.cat((x1, x2), 0).type(torch.FloatTensor) y = torch.cat((y1, y2), 0).type(torch.FloatTensor) # Visualisation des ensembles de données plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn') plt.show() # Lecture des données： def data_iter(batch_size, x, y): num_examples = len(x) indices = list(range(num_examples))
    random.shuffle(indices)  # L'ordre de lecture des échantillons est aléatoire
    for i in range(0, num_examples, batch_size):
        j = torch.LongTensor(indices[i: min(i + batch_size, num_examples)]) #Peut - être moins d'une dernière foisbatch
        yield  x.index_select(0, j), y.index_select(0, j)

#############################################################################################################
def saver(model_state_dict, optimizer_state_dict, model_path, epoch, max_to_save=30):
    total_models = glob.glob(model_path + '*')
    if len(total_models) >= max_to_save:
        total_models.sort()
        os.remove(total_models[0])

    state_dict = {
    }
    state_dict["model_state_dict"] = model_state_dict
    state_dict["optimizer_state_dict"] = optimizer_state_dict

    torch.save(state_dict, model_path + 'h' + str(epoch))
    print('models {} save successfully!'.format(model_path + 'hahaha' + str(epoch)))



################################################################################################################

import torch.nn as nn
import torch.optim as optim



class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net = nn.Sequential(nn.Linear(2, 1), nn.ReLU())

    def forward(self, x):
        return self.net(x)

def loss(y_hat, y):
    return (y_hat - y.view(y_hat.size())) ** 2 / 2



def accuracy(y_hat, y):  #@save
    """Calculer la quantité correcte prévue."""
    cmp = y_hat.type(y.dtype) > 0.5 # Plus grand que0.5Catégorie1
    result=cmp.type(y.dtype)
    acc = 1-float(((result-y).sum())/ len(y))
    return acc;

lr = 0.03
num_epochs = 3 # Nombre d'Itérations
batch_size = 10 # Taille du lot
model = net()
params =  list(model.parameters())
optimizer = torch.optim.Adam(params, 1e-4)

# for epoch in range(num_epochs):
# for X, y_train in data_iter(batch_size, x, y):
# optimizer.zero_grad()
# l = loss(model(X), y_train).sum() # l Il s'agit de petits lots XEtyPerte de
# l.backward(retain_graph=True)
# optimizer.step()
# print(l)
# saver(model.state_dict(), optimizer.state_dict(), "./", epoch + 1, max_to_save=100)




def loader(model_path):
    state_dict = torch.load(model_path)
    model_state_dict = state_dict["model_state_dict"]
    optimizer_state_dict = state_dict["optimizer_state_dict"]
    return model_state_dict, optimizer_state_dict

model_state_dict, optimizer_state_dict = loader("h1")
model.load_state_dict(model_state_dict)
optimizer.load_state_dict(optimizer_state_dict)

print('pretrained models loaded!')

pytorch Enregistrer le modèle enregistrer seulement les paramètres d'entraînement？- Oui.

class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net = nn.Sequential(nn.Linear(2, 1), nn.ReLU())
        self.notrain= torch.rand((64, 64), dtype=torch.float)

    def forward(self, x):
        return self.net(x)

Solutions

class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net = nn.Sequential(nn.Linear(2, 1), nn.ReLU())
        # self.notrain = torch.rand((64, 64), dtype=torch.float)
        self.notrain = torch.nn.Parameter(torch.ones(64, 64))

    def forward(self, x):
        return self.net(x)

for epoch in range(num_epochs):
    for X, y_train in data_iter(batch_size, x, y):
        optimizer.zero_grad()
        l = loss(model(X), y_train).sum()  # l Il s'agit de petits lots XEtyPerte de
        l.backward(retain_graph=True)
        optimizer.step()
        print(l)
        model.notrain.data = model.notrain.data+2
    saver(model.state_dict(), optimizer.state_dict(), "./", epoch + 1,  max_to_save=100)

Référence et plus

PyTorch DataLoaderDebug ：Aléatoiremask Ou une sélection aléatoire des données bug