Tarea uno:
El primer nivel: use PyTorch para construir un modelo de red
importar análisis de argumentos
antorcha de importación
importar torch.nn como nn
importar torch.nn.funcional como F
importar torch.optim como optim
de conjuntos de datos de importación de torchvision, transformaciones
desde torch.optim.lr_scheduler importar StepLR
clase Net(nn.Módulo):
def __init__(uno mismo):
########## Comenzar ##########
super(Neto, propio).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.abandono1 = nn.Abandono(0.25)
self.abandono2 = nn.Abandono(0.5)
self.fc1 = nn.Lineal(9216, 128)
self.fc2 = nn.Lineal(128, 10)
########## Fin ##########
def adelante(auto, x):
########## Comenzar ##########
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = self.abandono1(x)
x = antorcha.aplanar(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.abandono2(x)
x = self.fc2(x)
salida = F.log_softmax(x, dim=1)
salida de retorno
########## Fin ##########
El segundo nivel: use PyTorch para entrenar el modelo de red
de __futuro__ importar print_function
importar análisis de argumentos
antorcha de importación
importar torch.nn como nn
importar torch.nn.funcional como F
importar torch.optim como optim
de conjuntos de datos de importación de torchvision, transformaciones
desde torch.optim.lr_scheduler importar StepLR
clase Net(nn.Módulo):
def __init__(uno mismo):
########## comenzar ##########
super(Neto, propio).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.abandono1 = nn.Abandono(0.25)
self.abandono2 = nn.Abandono(0.5)
self.fc1 = nn.Lineal(9216, 128)
self.fc2 = nn.Lineal(128, 10)
def adelante(auto, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = self.abandono1(x)
x = antorcha.aplanar(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.abandono2(x)
x = self.fc2(x)
salida = F.log_softmax(x, dim=1)
salida de retorno
########## fin ##########
def tren (argumentos, modelo, dispositivo, tren_cargador, optimizador, época):
########## comenzar ##########
para batch_idx, (datos, destino) en enumerar (train_loader):
datos, destino = datos.a(dispositivo), destino.a(dispositivo)
optimizador.zero_grad()
salida = modelo (datos)
pérdida = F.nll_loss(salida, destino)
pérdida.hacia atrás()
optimizador.paso()
########## fin ##########
si lote_idx % args.log_interval == 0:
print('Época del tren: {} [{}/{} ({:.0f}%)]\tPérdida: {:.6f}'.format(
época, batch_idx * len(datos), len(train_loader.dataset),
100. * lote_idx / len(cargador_de_tren), loss.item()))
si args.dry_run:
romper
def test(modelo, dispositivo, test_loader):
modelo.eval()
prueba_pérdida = 0
correcto = 0
con antorcha.no_grad():
para datos, objetivo en test_loader:
datos, destino = datos.a(dispositivo), destino.a(dispositivo)
salida = modelo (datos)
test_loss += F.nll_loss(salida, objetivo, reducción='suma').item() # suma la pérdida del lote
pred = salida.argmax(dim=1, keepdim=True) # obtener el índice de la máxima probabilidad de registro
correcto += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.conjunto de datos)
test_acc = 100. * correcto / len (test_loader.conjunto de datos)
print('\nConjunto de prueba: Pérdida promedio: {:.4f}, Precisión: {}/{} ({:.0f}%)\n'.format(
test_loss, correcto, len(test_loader.dataset),
test_acc))
si prueba_acc > 95:
imprimir("¡éxito!")
def principal():
# Configuración de entrenamiento
analizador = argparse.ArgumentParser (descripción = 'Ejemplo de PyTorch MNIST')
analizador.add_argument('--tamaño del lote', tipo=int, predeterminado=64, metavar='N',
help='ingrese el tamaño del lote para el entrenamiento (predeterminado: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
help='tamaño del lote de entrada para la prueba (predeterminado: 1000)')
parser.add_argument('--epochs', type=int, default=1, metavar='N',
help='número de épocas para entrenar (predeterminado: 14)')
parser.add_argument('--lr', type=float, default=1.0, metavar='LR',
help='tasa de aprendizaje (predeterminado: 1.0)')
parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
help='Grama de paso de tasa de aprendizaje (predeterminado: 0.7)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='deshabilita el entrenamiento CUDA')
parser.add_argument('--dry-run', action='store_true', default=False,
help='comprobar rápidamente una sola pasada')
parser.add_argument('--seed', type=int, default=1, metavar='S',
ayuda = 'semilla aleatoria (predeterminado: 1)')
parser.add_argument('--intervalo de registro', type=int, default=10, metavar='N',
help='cuántos lotes hay que esperar antes de registrar el estado de entrenamiento')
parser.add_argument('--save-model', action='store_true', default=False,
help='Para guardar el modelo actual')
argumentos = analizador.parse_args()
use_cuda = no args.no_cuda y torch.cuda.is_disponible()
torch.manual_seed(args.seed)
dispositivo = torch.device("cuda" si use_cuda else "cpu")
train_kwargs = {'batch_size': args.batch_size}
test_kwargs = {'batch_size': args.test_batch_size}
si use_cuda:
cuda_kwargs = {'núm_trabajadores': 1,
'pin_memoria': Cierto,
'shuffle': Verdadero}
tren_kwargs.update(cuda_kwargs)
prueba_kwargs.update(cuda_kwargs)
transform=transforma.Compose([
transforma.ToTensor(),
transforma.Normalizar((0.1307,), (0.3081,))
])
conjunto de datos1 = conjuntos de datos.MNIST('/datos/espacio de trabajo/myshixun/datos', entrenar=Verdadero, descargar=Verdadero,
transformar = transformar)
dataset2 = datasets.MNIST('/data/workspace/myshixun/data', tren=Falso,
transformar = transformar)
tren_cargador = antorcha.utils.datos.DataLoader(conjunto de datos1,**tren_kwargs)
test_loader = torch.utils.data.DataLoader(conjunto de datos2, **test_kwargs)
modelo = Net().to(dispositivo)
optimizador = optim.Adadelta(modelo.parámetros(), lr=args.lr)
programador = StepLR(optimizador, step_size=1, gamma=args.gamma)
para época en rango (1, args.epochs + 1):
entrenar (argumentos, modelo, dispositivo, tren_cargador, optimizador, época)
prueba (modelo, dispositivo, test_loader)
programador.paso()
si args.save_model:
antorcha.guardar(modelo.state_dict(), "mnist_cnn.pt")
si __nombre__ == '__principal__':
principal()