タスク 1:
最初のレベル: PyTorch を使用してネットワーク モデルを構築する
引数解析をインポートする
輸入トーチ
torch.nn を nn としてインポート
torch.nn.functionをFとしてインポート
torch.optim を optim としてインポートします
torchvision からのインポート データセット、変換
torch.optim.lr_scheduler から StepLR をインポート
クラスネット(nn.モジュール):
def __init__(自分自身):
＃＃＃＃＃＃＃＃＃＃ 始める ＃＃＃＃＃＃＃＃＃＃
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.dropout1 = nn.Dropout(0.25)
self.dropout2 = nn.Dropout(0.5)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
＃＃＃＃＃＃＃＃＃＃ 終わり ＃＃＃＃＃＃＃＃＃＃
def forward(self, 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.dropout1(x)
x = トーチ.フラットテン(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.dropout2(x)
x = self.fc2(x)
出力 = F.log_softmax(x, dim=1)
出力を返す
＃＃＃＃＃＃＃＃＃＃ 終わり ＃＃＃＃＃＃＃＃＃＃
第 2 レベル: PyTorch を使用してネットワーク モデルをトレーニングする
__future__ から print_function をインポート
引数解析をインポートする
輸入トーチ
torch.nn を nn としてインポート
torch.nn.functionをFとしてインポート
torch.optim を optim としてインポートします
torchvision からのインポート データセット、変換
torch.optim.lr_scheduler から StepLR をインポート
クラスネット(nn.モジュール):
def __init__(自分自身):
＃＃＃＃＃＃＃＃＃＃ 始める ＃＃＃＃＃＃＃＃＃＃
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.dropout1 = nn.Dropout(0.25)
self.dropout2 = nn.Dropout(0.5)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, 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.dropout1(x)
x = トーチ.フラットテン(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.dropout2(x)
x = self.fc2(x)
出力 = F.log_softmax(x, dim=1)
出力を返す
＃＃＃＃＃＃＃＃＃＃ 終わり ＃＃＃＃＃＃＃＃＃＃
def train(引数、モデル、デバイス、train_loader、オプティマイザー、エポック):
＃＃＃＃＃＃＃＃＃＃ 始める ＃＃＃＃＃＃＃＃＃＃
バッチ_idx の場合、(データ、ターゲット) の enumerate(train_loader):
データ、ターゲット = data.to(デバイス)、ターゲット.to(デバイス)
オプティマイザー.zero_grad()
出力 = モデル(データ)
loss = F.nll_loss(出力, ターゲット)
loss.backward()
オプティマイザー.ステップ()
＃＃＃＃＃＃＃＃＃＃ 終わり ＃＃＃＃＃＃＃＃＃＃
バッチ_idx % args.log_interval == 0 の場合:
print('トレイン エポック: {} [{}/{} ({:.0f}%)]\t損失: {:.6f}'.format(
エポック、batch_idx * len(データ)、len(train_loader.dataset)、
100. * バッチ_idx / len(train_loader), loss.item()))
args.dry_run の場合:
壊す
def test(モデル、デバイス、test_loader):
モデル.eval()
テストロス = 0
正解 = 0
torch.no_grad() を使用:
データの場合、test_loader のターゲット:
データ、ターゲット = data.to(デバイス)、ターゲット.to(デバイス)
出力 = モデル(データ)
test_loss += F.nll_loss(output, target,duction='sum').item() # バッチ損失を合計します
pred = Output.argmax(dim=1, keepdim=True) # 最大対数確率のインデックスを取得します
正しい += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
test_acc = 100. * 正しい / len(test_loader.dataset)
print('\nテストセット: 平均損失: {:.4f}、精度: {}/{} ({:.0f}%)\n'.format(
test_loss、正しい、len(test_loader.dataset)、
テスト_acc))
test_acc > 95 の場合:
print("成功!")
def main():
# トレーニング設定
parser = argparse.ArgumentParser(description='PyTorch MNIST の例')
parser.add_argument('--batch-size'、type=int、default=64、metavar='N'、
help='トレーニング用の入力バッチ サイズ (デフォルト: 64)')
parser.add_argument('--test-batch-size'、type=int、default=1000、metavar='N'、
help='テスト用のバッチ サイズを入力 (デフォルト: 1000)')
parser.add_argument('--epochs'、type=int、default=1、metavar='N'、
help='トレーニングするエポック数 (デフォルト: 14)')
parser.add_argument('--lr'、type=float、default=1.0、metavar='LR'、
help='学習率 (デフォルト: 1.0)')
parser.add_argument('--gamma'、type=float、default=0.7、metavar='M'、
help='学習率ステップガンマ (デフォルト: 0.7)')
parser.add_argument('--no-cuda'、action='store_true'、default=False、
help='CUDA トレーニングを無効にする')
parser.add_argument('--dry-run'、action='store_true'、default=False、
help='単一パスを簡単にチェック')
parser.add_argument('--seed'、type=int、default=1、metavar='S'、
help='ランダムシード (デフォルト: 1)')
parser.add_argument('--log-interval'、type=int、default=10、metavar='N'、
help='トレーニングステータスを記録するまでに待機するバッチ数')
parser.add_argument('--save-model'、action='store_true'、default=False、
help='現在のモデルを保存する場合')
args = parser.parse_args()
use_cuda = args.no_cuda および torch.cuda.is_available() ではありません
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
train_kwargs = {'batch_size': args.batch_size}
test_kwargs = {'batch_size': args.test_batch_size}
use_cuda の場合:
cuda_kwargs = {'num_workers': 1,
'pin_memory': True、
'シャッフル': True}
train_kwargs.update(cuda_kwargs)
test_kwargs.update(cuda_kwargs)
変換=transforms.Compose([
変換.ToTensor()、
変換.Normalize((0.1307,), (0.3081,))
])
dataset1 = datasets.MNIST('/data/workspace/myshixun/data', train=True, download=True,
変換=変換)
dataset2 = datasets.MNIST('/data/workspace/myshixun/data', train=False,
変換=変換)
train_loader = torch.utils.data.DataLoader(dataset1,**train_kwargs)
test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)
モデル = Net().to(デバイス)
optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
スケジューラー = StepLR(オプティマイザー、step_size=1、gamma=args.gamma)
range(1, args.epochs + 1) 内のエポックの場合:
train(引数、モデル、デバイス、train_loader、オプティマイザー、エポック)
テスト(モデル、デバイス、test_loader)
スケジューラー.ステップ()
args.save_model の場合:
torch.save(model.state_dict(), "mnist_cnn.pt")
__name__ == '__main__'の場合:
主要（）