DeeGLMath

PyTorch搭建ResNet模型（在CIFAR10数据集上准确率达到了90%）

PyTorch搭建ResNet模型

https://zhuanlan.zhihu.com/p/101332297

为了减少时间成本，本文只复现了ResNet-18模型，诸如ResNet-34、ResNet-50、ResNet-101、ResNet-152等更深层的神经网络模型，可以在ResNet-18的基础上修改而来。ResNet由于在顺序结构神经网络中引入了残差块（Residual Block），因此得名Residual Networks（ResNet）。

Residual Block：

ResNet-18与ResNet-50：

ResNet-34：

# import packages
import torch
import torchvision

# Device configuration.
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# Transform configuration and data augmentation.
transform_train = torchvision.transforms.Compose([torchvision.transforms.Pad(4),
                                                 torchvision.transforms.RandomHorizontalFlip(),
                                                 torchvision.transforms.RandomCrop(32),
                                                 torchvision.transforms.ToTensor(),
                                                 torchvision.transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
transform_test = torchvision.transforms.Compose([torchvision.transforms.ToTensor(),
                                                torchvision.transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])

# Hyper-parameters
num_classes = 10
batch_size = 100
learning_rate = 0.001
num_epochs = 80

# Load downloaded dataset.
train_dataset = torchvision.datasets.CIFAR10('data/CIFAR/', download=False, train=True, transform=transform_train)
test_dataset = torchvision.datasets.CIFAR10('data/CIFAR/', download=False, train=False, transform=transform_test)

# Data Loader.
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# Define 3x3 convolution.
def conv3x3(in_channels, out_channels, stride=1):
    return torch.nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)

# Define Residual block
class ResidualBlock(torch.nn.Module):
    def __init__(self, in_channels, out_channels, stride=1, downsample=None):
        super(ResidualBlock, self).__init__()
        self.conv1 = conv3x3(in_channels, out_channels, stride)
        self.bn1 = torch.nn.BatchNorm2d(out_channels)
        self.relu = torch.nn.ReLU(inplace=True)
        self.conv2 = conv3x3(out_channels, out_channels)
        self.bn2 = torch.nn.BatchNorm2d(out_channels)
        self.downsample = downsample
        
    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        if self.downsample :
            residual = self.downsample(x)
        out += residual
        out = self.relu(out)
        return out

# Define ResNet-18
class ResNet(torch.nn.Module):
    def __init__(self, block, layers, num_classes):
        super(ResNet, self).__init__()
        self.in_channels = 16
        self.conv = conv3x3(3, 16)
        self.bn = torch.nn.BatchNorm2d(16)
        self.relu = torch.nn.ReLU(inplace=True)
        self.layer1 = self._make_layers(block, 16, layers[0])
        self.layer2 = self._make_layers(block, 32, layers[1], 2)
        self.layer3 = self._make_layers(block, 64, layers[2], 2)
        self.layer4 = self._make_layers(block, 128, layers[3], 2)
        self.avg_pool = torch.nn.AdaptiveAvgPool2d((1, 1))
        self.fc = torch.nn.Linear(128, num_classes)
        
    def _make_layers(self, block, out_channels, blocks, stride=1):
        downsample = None
        if (stride != 1) or (self.in_channels != out_channels):
            downsample = torch.nn.Sequential(
                conv3x3(self.in_channels, out_channels, stride=stride),
                torch.nn.BatchNorm2d(out_channels))
        layers = []
        layers.append(block(self.in_channels, out_channels, stride, downsample))
        self.in_channels = out_channels
        for i in range(1, blocks):
            layers.append(block(out_channels, out_channels))
        return torch.nn.Sequential(*layers)
    
    def forward(self, x):
        out = self.conv(x)
        out = self.bn(out)
        out = self.relu(out)
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = self.avg_pool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out

# Make model.
model = ResNet(ResidualBlock, [2, 2, 2, 2], num_classes).to(device)

# Loss ans optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# For updating learning rate.
def update_lr(optimizer, lr):
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr

# Train the model.
total_step = len(train_loader)
curr_lr = learning_rate
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = images.to(device)
        labels = labels.to(device)
        
        # Forward pass.
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if (i+1) % 100 == 0:
            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, total_step, loss.item()))
    # Decay learning rate.
    if (epoch+1) % 20 == 0:
        curr_lr /= 3
        update_lr(optimizer, curr_lr)

Epoch [1/80], Step [100/500], Loss: 1.6278
Epoch [1/80], Step [200/500], Loss: 1.3368
Epoch [1/80], Step [300/500], Loss: 1.3774
Epoch [1/80], Step [400/500], Loss: 1.2487
Epoch [1/80], Step [500/500], Loss: 1.0083
Epoch [2/80], Step [100/500], Loss: 1.1344
Epoch [2/80], Step [200/500], Loss: 0.8391
Epoch [2/80], Step [300/500], Loss: 1.1451
Epoch [2/80], Step [400/500], Loss: 1.1581
Epoch [2/80], Step [500/500], Loss: 1.0138
Epoch [3/80], Step [100/500], Loss: 0.8204
Epoch [3/80], Step [200/500], Loss: 0.9306
Epoch [3/80], Step [300/500], Loss: 0.6666
Epoch [3/80], Step [400/500], Loss: 0.9254
Epoch [3/80], Step [500/500], Loss: 0.7068
Epoch [4/80], Step [100/500], Loss: 0.7309
Epoch [4/80], Step [200/500], Loss: 0.6603
Epoch [4/80], Step [300/500], Loss: 0.5715
Epoch [4/80], Step [400/500], Loss: 0.6693
Epoch [4/80], Step [500/500], Loss: 0.6240
Epoch [5/80], Step [100/500], Loss: 0.6171
Epoch [5/80], Step [200/500], Loss: 0.7757
Epoch [5/80], Step [300/500], Loss: 0.5394
Epoch [5/80], Step [400/500], Loss: 0.4437
Epoch [5/80], Step [500/500], Loss: 0.5371
Epoch [6/80], Step [100/500], Loss: 0.5737
Epoch [6/80], Step [200/500], Loss: 0.7505
Epoch [6/80], Step [300/500], Loss: 0.4102
Epoch [6/80], Step [400/500], Loss: 0.3542
Epoch [6/80], Step [500/500], Loss: 0.5393
Epoch [7/80], Step [100/500], Loss: 0.4987
Epoch [7/80], Step [200/500], Loss: 0.4006
Epoch [7/80], Step [300/500], Loss: 0.4238
Epoch [7/80], Step [400/500], Loss: 0.4722
Epoch [7/80], Step [500/500], Loss: 0.4706
Epoch [8/80], Step [100/500], Loss: 0.5829
Epoch [8/80], Step [200/500], Loss: 0.5226
Epoch [8/80], Step [300/500], Loss: 0.4381
Epoch [8/80], Step [400/500], Loss: 0.4344
Epoch [8/80], Step [500/500], Loss: 0.4641
Epoch [9/80], Step [100/500], Loss: 0.5033
Epoch [9/80], Step [200/500], Loss: 0.4500
Epoch [9/80], Step [300/500], Loss: 0.4019
Epoch [9/80], Step [400/500], Loss: 0.4249
Epoch [9/80], Step [500/500], Loss: 0.5130
Epoch [10/80], Step [100/500], Loss: 0.4057
Epoch [10/80], Step [200/500], Loss: 0.4189
Epoch [10/80], Step [300/500], Loss: 0.4459
Epoch [10/80], Step [400/500], Loss: 0.4157
Epoch [10/80], Step [500/500], Loss: 0.3352
Epoch [11/80], Step [100/500], Loss: 0.4696
Epoch [11/80], Step [200/500], Loss: 0.3871
Epoch [11/80], Step [300/500], Loss: 0.3810
Epoch [11/80], Step [400/500], Loss: 0.4613
Epoch [11/80], Step [500/500], Loss: 0.3651
Epoch [12/80], Step [100/500], Loss: 0.3487
Epoch [12/80], Step [200/500], Loss: 0.3225
Epoch [12/80], Step [300/500], Loss: 0.3127
Epoch [12/80], Step [400/500], Loss: 0.4051
Epoch [12/80], Step [500/500], Loss: 0.3588
Epoch [13/80], Step [100/500], Loss: 0.5568
Epoch [13/80], Step [200/500], Loss: 0.3759
Epoch [13/80], Step [300/500], Loss: 0.2941
Epoch [13/80], Step [400/500], Loss: 0.5200
Epoch [13/80], Step [500/500], Loss: 0.3995
Epoch [14/80], Step [100/500], Loss: 0.4985
Epoch [14/80], Step [200/500], Loss: 0.4564
Epoch [14/80], Step [300/500], Loss: 0.2351
Epoch [14/80], Step [400/500], Loss: 0.4535
Epoch [14/80], Step [500/500], Loss: 0.5108
Epoch [15/80], Step [100/500], Loss: 0.3881
Epoch [15/80], Step [200/500], Loss: 0.4429
Epoch [15/80], Step [300/500], Loss: 0.2841
Epoch [15/80], Step [400/500], Loss: 0.4210
Epoch [15/80], Step [500/500], Loss: 0.2653
Epoch [16/80], Step [100/500], Loss: 0.4307
Epoch [16/80], Step [200/500], Loss: 0.2401
Epoch [16/80], Step [300/500], Loss: 0.1996
Epoch [16/80], Step [400/500], Loss: 0.2240
Epoch [16/80], Step [500/500], Loss: 0.2821
Epoch [17/80], Step [100/500], Loss: 0.2849
Epoch [17/80], Step [200/500], Loss: 0.2965
Epoch [17/80], Step [300/500], Loss: 0.3777
Epoch [17/80], Step [400/500], Loss: 0.4469
Epoch [17/80], Step [500/500], Loss: 0.2752
Epoch [18/80], Step [100/500], Loss: 0.2665
Epoch [18/80], Step [200/500], Loss: 0.3726
Epoch [18/80], Step [300/500], Loss: 0.1999
Epoch [18/80], Step [400/500], Loss: 0.2555
Epoch [18/80], Step [500/500], Loss: 0.2895
Epoch [19/80], Step [100/500], Loss: 0.1635
Epoch [19/80], Step [200/500], Loss: 0.1796
Epoch [19/80], Step [300/500], Loss: 0.4037
Epoch [19/80], Step [400/500], Loss: 0.2623
Epoch [19/80], Step [500/500], Loss: 0.1818
Epoch [20/80], Step [100/500], Loss: 0.2265
Epoch [20/80], Step [200/500], Loss: 0.4131
Epoch [20/80], Step [300/500], Loss: 0.2777
Epoch [20/80], Step [400/500], Loss: 0.3146
Epoch [20/80], Step [500/500], Loss: 0.3028
Epoch [21/80], Step [100/500], Loss: 0.3265
Epoch [21/80], Step [200/500], Loss: 0.2229
Epoch [21/80], Step [300/500], Loss: 0.2388
Epoch [21/80], Step [400/500], Loss: 0.2601
Epoch [21/80], Step [500/500], Loss: 0.1227
Epoch [22/80], Step [100/500], Loss: 0.2175
Epoch [22/80], Step [200/500], Loss: 0.2641
Epoch [22/80], Step [300/500], Loss: 0.1847
Epoch [22/80], Step [400/500], Loss: 0.1926
Epoch [22/80], Step [500/500], Loss: 0.2075
Epoch [23/80], Step [100/500], Loss: 0.1859
Epoch [23/80], Step [200/500], Loss: 0.1570
Epoch [23/80], Step [300/500], Loss: 0.2750
Epoch [23/80], Step [400/500], Loss: 0.0908
Epoch [23/80], Step [500/500], Loss: 0.1936
Epoch [24/80], Step [100/500], Loss: 0.1485
Epoch [24/80], Step [200/500], Loss: 0.1572
Epoch [24/80], Step [300/500], Loss: 0.1881
Epoch [24/80], Step [400/500], Loss: 0.1262
Epoch [24/80], Step [500/500], Loss: 0.3006
Epoch [25/80], Step [100/500], Loss: 0.2768
Epoch [25/80], Step [200/500], Loss: 0.0902
Epoch [25/80], Step [300/500], Loss: 0.2313
Epoch [25/80], Step [400/500], Loss: 0.1361
Epoch [25/80], Step [500/500], Loss: 0.2736
Epoch [26/80], Step [100/500], Loss: 0.1499
Epoch [26/80], Step [200/500], Loss: 0.1687
Epoch [26/80], Step [300/500], Loss: 0.1190
Epoch [26/80], Step [400/500], Loss: 0.1117
Epoch [26/80], Step [500/500], Loss: 0.1268
Epoch [27/80], Step [100/500], Loss: 0.1518
Epoch [27/80], Step [200/500], Loss: 0.1603
Epoch [27/80], Step [300/500], Loss: 0.1415
Epoch [27/80], Step [400/500], Loss: 0.2641
Epoch [27/80], Step [500/500], Loss: 0.0748
Epoch [28/80], Step [100/500], Loss: 0.2301
Epoch [28/80], Step [200/500], Loss: 0.2718
Epoch [28/80], Step [300/500], Loss: 0.2650
Epoch [28/80], Step [400/500], Loss: 0.0754
Epoch [28/80], Step [500/500], Loss: 0.1454
Epoch [29/80], Step [100/500], Loss: 0.1373
Epoch [29/80], Step [200/500], Loss: 0.1285
Epoch [29/80], Step [300/500], Loss: 0.1345
Epoch [29/80], Step [400/500], Loss: 0.1153
Epoch [29/80], Step [500/500], Loss: 0.2338
Epoch [30/80], Step [100/500], Loss: 0.1643
Epoch [30/80], Step [200/500], Loss: 0.0779
Epoch [30/80], Step [300/500], Loss: 0.1455
Epoch [30/80], Step [400/500], Loss: 0.1288
Epoch [30/80], Step [500/500], Loss: 0.2127
Epoch [31/80], Step [100/500], Loss: 0.2214
Epoch [31/80], Step [200/500], Loss: 0.1338
Epoch [31/80], Step [300/500], Loss: 0.1166
Epoch [31/80], Step [400/500], Loss: 0.0748
Epoch [31/80], Step [500/500], Loss: 0.2321
Epoch [32/80], Step [100/500], Loss: 0.1146
Epoch [32/80], Step [200/500], Loss: 0.1730
Epoch [32/80], Step [300/500], Loss: 0.1165
Epoch [32/80], Step [400/500], Loss: 0.2201
Epoch [32/80], Step [500/500], Loss: 0.0860
Epoch [33/80], Step [100/500], Loss: 0.1171
Epoch [33/80], Step [200/500], Loss: 0.1427
Epoch [33/80], Step [300/500], Loss: 0.1329
Epoch [33/80], Step [400/500], Loss: 0.1102
Epoch [33/80], Step [500/500], Loss: 0.1330
Epoch [34/80], Step [100/500], Loss: 0.1335
Epoch [34/80], Step [200/500], Loss: 0.1465
Epoch [34/80], Step [300/500], Loss: 0.1598
Epoch [34/80], Step [400/500], Loss: 0.0849
Epoch [34/80], Step [500/500], Loss: 0.0847
Epoch [35/80], Step [100/500], Loss: 0.2173
Epoch [35/80], Step [200/500], Loss: 0.1172
Epoch [35/80], Step [300/500], Loss: 0.1516
Epoch [35/80], Step [400/500], Loss: 0.1212
Epoch [35/80], Step [500/500], Loss: 0.0644
Epoch [36/80], Step [100/500], Loss: 0.0651
Epoch [36/80], Step [200/500], Loss: 0.1346
Epoch [36/80], Step [300/500], Loss: 0.0986
Epoch [36/80], Step [400/500], Loss: 0.1141
Epoch [36/80], Step [500/500], Loss: 0.1344
Epoch [37/80], Step [100/500], Loss: 0.1834
Epoch [37/80], Step [200/500], Loss: 0.1162
Epoch [37/80], Step [300/500], Loss: 0.1637
Epoch [37/80], Step [400/500], Loss: 0.0949
Epoch [37/80], Step [500/500], Loss: 0.1504
Epoch [38/80], Step [100/500], Loss: 0.1251
Epoch [38/80], Step [200/500], Loss: 0.1133
Epoch [38/80], Step [300/500], Loss: 0.1080
Epoch [38/80], Step [400/500], Loss: 0.0686
Epoch [38/80], Step [500/500], Loss: 0.1099
Epoch [39/80], Step [100/500], Loss: 0.0616
Epoch [39/80], Step [200/500], Loss: 0.1919
Epoch [39/80], Step [300/500], Loss: 0.1736
Epoch [39/80], Step [400/500], Loss: 0.1276
Epoch [39/80], Step [500/500], Loss: 0.0810
Epoch [40/80], Step [100/500], Loss: 0.1305
Epoch [40/80], Step [200/500], Loss: 0.1893
Epoch [40/80], Step [300/500], Loss: 0.0975
Epoch [40/80], Step [400/500], Loss: 0.0918
Epoch [40/80], Step [500/500], Loss: 0.0549
Epoch [41/80], Step [100/500], Loss: 0.0390
Epoch [41/80], Step [200/500], Loss: 0.0826
Epoch [41/80], Step [300/500], Loss: 0.0812
Epoch [41/80], Step [400/500], Loss: 0.1012
Epoch [41/80], Step [500/500], Loss: 0.0991
Epoch [42/80], Step [100/500], Loss: 0.1419
Epoch [42/80], Step [200/500], Loss: 0.1208
Epoch [42/80], Step [300/500], Loss: 0.0862
Epoch [42/80], Step [400/500], Loss: 0.0817
Epoch [42/80], Step [500/500], Loss: 0.0749
Epoch [43/80], Step [100/500], Loss: 0.0834
Epoch [43/80], Step [200/500], Loss: 0.0713
Epoch [43/80], Step [300/500], Loss: 0.0794
Epoch [43/80], Step [400/500], Loss: 0.1317
Epoch [43/80], Step [500/500], Loss: 0.0561
Epoch [44/80], Step [100/500], Loss: 0.1528
Epoch [44/80], Step [200/500], Loss: 0.0989
Epoch [44/80], Step [300/500], Loss: 0.1040
Epoch [44/80], Step [400/500], Loss: 0.0633
Epoch [44/80], Step [500/500], Loss: 0.0580
Epoch [45/80], Step [100/500], Loss: 0.0817
Epoch [45/80], Step [200/500], Loss: 0.0723
Epoch [45/80], Step [300/500], Loss: 0.0435
Epoch [45/80], Step [400/500], Loss: 0.1233
Epoch [45/80], Step [500/500], Loss: 0.0652
Epoch [46/80], Step [100/500], Loss: 0.0720
Epoch [46/80], Step [200/500], Loss: 0.0727
Epoch [46/80], Step [300/500], Loss: 0.0731
Epoch [46/80], Step [400/500], Loss: 0.1015
Epoch [46/80], Step [500/500], Loss: 0.1100
Epoch [47/80], Step [100/500], Loss: 0.1373
Epoch [47/80], Step [200/500], Loss: 0.0711
Epoch [47/80], Step [300/500], Loss: 0.0612
Epoch [47/80], Step [400/500], Loss: 0.1126
Epoch [47/80], Step [500/500], Loss: 0.0481
Epoch [48/80], Step [100/500], Loss: 0.0284
Epoch [48/80], Step [200/500], Loss: 0.0472
Epoch [48/80], Step [300/500], Loss: 0.0857
Epoch [48/80], Step [400/500], Loss: 0.0402
Epoch [48/80], Step [500/500], Loss: 0.0856
Epoch [49/80], Step [100/500], Loss: 0.0678
Epoch [49/80], Step [200/500], Loss: 0.0627
Epoch [49/80], Step [300/500], Loss: 0.0598
Epoch [49/80], Step [400/500], Loss: 0.0643
Epoch [49/80], Step [500/500], Loss: 0.0256
Epoch [50/80], Step [100/500], Loss: 0.0903
Epoch [50/80], Step [200/500], Loss: 0.0344
Epoch [50/80], Step [300/500], Loss: 0.0522
Epoch [50/80], Step [400/500], Loss: 0.0502
Epoch [50/80], Step [500/500], Loss: 0.0344
Epoch [51/80], Step [100/500], Loss: 0.0654
Epoch [51/80], Step [200/500], Loss: 0.0376
Epoch [51/80], Step [300/500], Loss: 0.0347
Epoch [51/80], Step [400/500], Loss: 0.0391
Epoch [51/80], Step [500/500], Loss: 0.0918
Epoch [52/80], Step [100/500], Loss: 0.0627
Epoch [52/80], Step [200/500], Loss: 0.0631
Epoch [52/80], Step [300/500], Loss: 0.1437
Epoch [52/80], Step [400/500], Loss: 0.1198
Epoch [52/80], Step [500/500], Loss: 0.0595
Epoch [53/80], Step [100/500], Loss: 0.0501
Epoch [53/80], Step [200/500], Loss: 0.0416
Epoch [53/80], Step [300/500], Loss: 0.0831
Epoch [53/80], Step [400/500], Loss: 0.0350
Epoch [53/80], Step [500/500], Loss: 0.0257
Epoch [54/80], Step [100/500], Loss: 0.0628
Epoch [54/80], Step [200/500], Loss: 0.0533
Epoch [54/80], Step [300/500], Loss: 0.0226
Epoch [54/80], Step [400/500], Loss: 0.0379
Epoch [54/80], Step [500/500], Loss: 0.0605
Epoch [55/80], Step [100/500], Loss: 0.1083
Epoch [55/80], Step [200/500], Loss: 0.1897
Epoch [55/80], Step [300/500], Loss: 0.0573
Epoch [55/80], Step [400/500], Loss: 0.0658
Epoch [55/80], Step [500/500], Loss: 0.0485
Epoch [56/80], Step [100/500], Loss: 0.0430
Epoch [56/80], Step [200/500], Loss: 0.0346
Epoch [56/80], Step [300/500], Loss: 0.0393
Epoch [56/80], Step [400/500], Loss: 0.0278
Epoch [56/80], Step [500/500], Loss: 0.0634
Epoch [57/80], Step [100/500], Loss: 0.0588
Epoch [57/80], Step [200/500], Loss: 0.0300
Epoch [57/80], Step [300/500], Loss: 0.0223
Epoch [57/80], Step [400/500], Loss: 0.1497
Epoch [57/80], Step [500/500], Loss: 0.0777
Epoch [58/80], Step [100/500], Loss: 0.0809
Epoch [58/80], Step [200/500], Loss: 0.0934
Epoch [58/80], Step [300/500], Loss: 0.0982
Epoch [58/80], Step [400/500], Loss: 0.1587
Epoch [58/80], Step [500/500], Loss: 0.0417
Epoch [59/80], Step [100/500], Loss: 0.0371
Epoch [59/80], Step [200/500], Loss: 0.1052
Epoch [59/80], Step [300/500], Loss: 0.0455
Epoch [59/80], Step [400/500], Loss: 0.0274
Epoch [59/80], Step [500/500], Loss: 0.0616
Epoch [60/80], Step [100/500], Loss: 0.1352
Epoch [60/80], Step [200/500], Loss: 0.0750
Epoch [60/80], Step [300/500], Loss: 0.0705
Epoch [60/80], Step [400/500], Loss: 0.0296
Epoch [60/80], Step [500/500], Loss: 0.0380
Epoch [61/80], Step [100/500], Loss: 0.0438
Epoch [61/80], Step [200/500], Loss: 0.0599
Epoch [61/80], Step [300/500], Loss: 0.0504
Epoch [61/80], Step [400/500], Loss: 0.0469
Epoch [61/80], Step [500/500], Loss: 0.0534
Epoch [62/80], Step [100/500], Loss: 0.0200
Epoch [62/80], Step [200/500], Loss: 0.0518
Epoch [62/80], Step [300/500], Loss: 0.0660
Epoch [62/80], Step [400/500], Loss: 0.0473
Epoch [62/80], Step [500/500], Loss: 0.0292
Epoch [63/80], Step [100/500], Loss: 0.0576
Epoch [63/80], Step [200/500], Loss: 0.0643
Epoch [63/80], Step [300/500], Loss: 0.0856
Epoch [63/80], Step [400/500], Loss: 0.0674
Epoch [63/80], Step [500/500], Loss: 0.0834
Epoch [64/80], Step [100/500], Loss: 0.0638
Epoch [64/80], Step [200/500], Loss: 0.0802
Epoch [64/80], Step [300/500], Loss: 0.0700
Epoch [64/80], Step [400/500], Loss: 0.0195
Epoch [64/80], Step [500/500], Loss: 0.0488
Epoch [65/80], Step [100/500], Loss: 0.0358
Epoch [65/80], Step [200/500], Loss: 0.0692
Epoch [65/80], Step [300/500], Loss: 0.0298
Epoch [65/80], Step [400/500], Loss: 0.0233
Epoch [65/80], Step [500/500], Loss: 0.0875
Epoch [66/80], Step [100/500], Loss: 0.0298
Epoch [66/80], Step [200/500], Loss: 0.0509
Epoch [66/80], Step [300/500], Loss: 0.0227
Epoch [66/80], Step [400/500], Loss: 0.1122
Epoch [66/80], Step [500/500], Loss: 0.0954
Epoch [67/80], Step [100/500], Loss: 0.0623
Epoch [67/80], Step [200/500], Loss: 0.0213
Epoch [67/80], Step [300/500], Loss: 0.0553
Epoch [67/80], Step [400/500], Loss: 0.0296
Epoch [67/80], Step [500/500], Loss: 0.0715
Epoch [68/80], Step [100/500], Loss: 0.0543
Epoch [68/80], Step [200/500], Loss: 0.0407
Epoch [68/80], Step [300/500], Loss: 0.0370
Epoch [68/80], Step [400/500], Loss: 0.0279
Epoch [68/80], Step [500/500], Loss: 0.0512
Epoch [69/80], Step [100/500], Loss: 0.0297
Epoch [69/80], Step [200/500], Loss: 0.0583
Epoch [69/80], Step [300/500], Loss: 0.0760
Epoch [69/80], Step [400/500], Loss: 0.0403
Epoch [69/80], Step [500/500], Loss: 0.0189
Epoch [70/80], Step [100/500], Loss: 0.1321
Epoch [70/80], Step [200/500], Loss: 0.0988
Epoch [70/80], Step [300/500], Loss: 0.0440
Epoch [70/80], Step [400/500], Loss: 0.0250
Epoch [70/80], Step [500/500], Loss: 0.0671
Epoch [71/80], Step [100/500], Loss: 0.0293
Epoch [71/80], Step [200/500], Loss: 0.0672
Epoch [71/80], Step [300/500], Loss: 0.0317
Epoch [71/80], Step [400/500], Loss: 0.0436
Epoch [71/80], Step [500/500], Loss: 0.0260
Epoch [72/80], Step [100/500], Loss: 0.0429
Epoch [72/80], Step [200/500], Loss: 0.0222
Epoch [72/80], Step [300/500], Loss: 0.0480
Epoch [72/80], Step [400/500], Loss: 0.0367
Epoch [72/80], Step [500/500], Loss: 0.0134
Epoch [73/80], Step [100/500], Loss: 0.0628
Epoch [73/80], Step [200/500], Loss: 0.0403
Epoch [73/80], Step [300/500], Loss: 0.0436
Epoch [73/80], Step [400/500], Loss: 0.1032
Epoch [73/80], Step [500/500], Loss: 0.0663
Epoch [74/80], Step [100/500], Loss: 0.0192
Epoch [74/80], Step [200/500], Loss: 0.0254
Epoch [74/80], Step [300/500], Loss: 0.0436
Epoch [74/80], Step [400/500], Loss: 0.1073
Epoch [74/80], Step [500/500], Loss: 0.0539
Epoch [75/80], Step [100/500], Loss: 0.0437
Epoch [75/80], Step [200/500], Loss: 0.0813
Epoch [75/80], Step [300/500], Loss: 0.0821
Epoch [75/80], Step [400/500], Loss: 0.0847
Epoch [75/80], Step [500/500], Loss: 0.0428
Epoch [76/80], Step [100/500], Loss: 0.0912
Epoch [76/80], Step [200/500], Loss: 0.0295
Epoch [76/80], Step [300/500], Loss: 0.0700
Epoch [76/80], Step [400/500], Loss: 0.0480
Epoch [76/80], Step [500/500], Loss: 0.0358
Epoch [77/80], Step [100/500], Loss: 0.0178
Epoch [77/80], Step [200/500], Loss: 0.0154
Epoch [77/80], Step [300/500], Loss: 0.0662
Epoch [77/80], Step [400/500], Loss: 0.0258
Epoch [77/80], Step [500/500], Loss: 0.0811
Epoch [78/80], Step [100/500], Loss: 0.0542
Epoch [78/80], Step [200/500], Loss: 0.0643
Epoch [78/80], Step [300/500], Loss: 0.0575
Epoch [78/80], Step [400/500], Loss: 0.0371
Epoch [78/80], Step [500/500], Loss: 0.0512
Epoch [79/80], Step [100/500], Loss: 0.0240
Epoch [79/80], Step [200/500], Loss: 0.0133
Epoch [79/80], Step [300/500], Loss: 0.0532
Epoch [79/80], Step [400/500], Loss: 0.0760
Epoch [79/80], Step [500/500], Loss: 0.0356
Epoch [80/80], Step [100/500], Loss: 0.0728
Epoch [80/80], Step [200/500], Loss: 0.0553
Epoch [80/80], Step [300/500], Loss: 0.0228
Epoch [80/80], Step [400/500], Loss: 0.0324
Epoch [80/80], Step [500/500], Loss: 0.0701

# Test the model.
model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        
    print('Accuracy of the model on the test images: {} %'.format(100 * correct / total))

Accuracy of the model on the test images: 89.89 %

# Save the model
torch.save(model.state_dict(), 'ResNet.ckpt')

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！小猪包333 写论文人工智能 AI写作深度学习计算机视觉
在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
[实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估 pytorch python 机器学习
文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
[实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用 pytorch 深度学习人工智能机器学习 python 优化器
文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
吴恩达深度学习笔记(30)-正则化的解释极客Array
正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
计算机视觉中，Pooling的作用 Wils0nEdwards 计算机视觉人工智能
在计算机视觉中，Pooling（池化）是一种常见的操作，主要用于卷积神经网络（CNN）中。它通过对特征图进行下采样，减少数据的空间维度，同时保留重要的特征信息。Pooling的作用可以归纳为以下几个方面：1.降低计算复杂度与内存需求Pooling操作通过对特征图进行下采样，减少了特征图的空间分辨率（例如，高度和宽度）。这意味着网络需要处理的数据量会减少，从而降低了计算量和内存需求。这对大型神经网络
神经网络-损失函数红米煮粥神经网络人工智能深度学习
文章目录一、回归问题的损失函数1.均方误差（MeanSquaredError,MSE）2.平均绝对误差（MeanAbsoluteError,MAE）二、分类问题的损失函数1.0-1损失函数（Zero-OneLossFunction）2.交叉熵损失（Cross-EntropyLoss）3.合页损失（HingeLoss）三、总结在神经网络中，损失函数（LossFunction）扮演着至关重要的角色，它
损失函数与反向传播 Star_. PyTorch pytorch 深度学习 python
损失函数定义与作用损失函数(lossfunction)在深度学习领域是用来计算搭建模型预测的输出值和真实值之间的误差。1.损失函数越小越好2.计算实际输出与目标之间的差距3.为更新输出提供依据（反向传播)常见的损失函数回归常见的损失函数有：均方差（MeanSquaredError，MSE）、平均绝对误差（MeanAbsoluteErrorLoss，MAE）、HuberLoss是一种将MSE与MAE
BP神经网络的传递函数大胜归来19 MATLAB
BP网络一般都是用三层的，四层及以上的都比较少用；传输函数的选择，这个怎么说，假设你想预测的结果是几个固定值，如1,0等，满足某个条件输出1，不满足则0的话，首先想到的是hardlim函数，阈值型的，当然也可以考虑其他的；然后，假如网络是用来表达某种线性关系时，用purelin---线性传输函数；若是非线性关系的话，用别的非线性传递函数，多层网络时，每层不一定要用相同的传递函数，可以是三种配合，可
神经网络传递函数sigmoid,神经网络传递函数作用快乐的小荣荣神经网络机器学习深度学习人工智能
神经网络传递函数选取不同会有特别大差别嘛？只是最后一层，但前面层是非线性，那么可能存在区别不大的情况。线性函数f(a*input)=af(input),一般来说，input为向量，最简化情况下，可以假设input的各个维度，a1=a2=a3。。。意味着你线性层只是简单的对输入做了scale~而神经网络能起作用的原因，在于通过足够复杂的非线性函数，来模拟任何的分布。所以，神经网络必须要用非线性函数。
【安装环境】配置MMTracking环境 xuanyu22 安装环境机器学习神经网络深度学习 python
版本v0.14.0安装torchnumpy的版本不能太高，否则后面安装时会发生冲突。先安装numpy，因为pytorch的安装会自动配置高版本numpy。condainstallnumpy=1.21.5mmtracking支持的torch版本有限，需要找到合适的condainstallpytorch==1.11.0torchvision==0.12.0cudatoolkit=10.2-cpytor
Python和R均方根误差平均绝对误差算法模型亚图跨际 Python 交叉知识 R 回归模型误差指标归一化均方根误差生态状态指标神经网络成本误差气体排放气候模型多项式拟合
要点回归模型误差评估指标归一化均方根误差生态状态指标神经网络成本误差计算气体排放气候算法模型Python误差指标均方根误差和平均绝对误差均方根偏差或均方根误差是两个密切相关且经常使用的度量值之一，用于衡量真实值或预测值与观测值或估计值之间的差异。估计器θ^\hat{\theta}θ^相对于估计参数θ\thetaθ的RMSD定义为均方误差的平方根：RMSD⁡(θ^)=MSE⁡(θ^)=E((θ^−θ
Python(PyTorch)和MATLAB及Rust和C++结构相似度指数测量导图亚图跨际 Python 交叉知识算法量化检查图像压缩质量低分辨率多光谱峰值信噪比端到端优化图像压缩手术机器人三维实景实时可微分渲染重建三维可视化
要点量化检查图像压缩质量低分辨率多光谱和高分辨率图像实现超分辨率分析图像质量图像索引/多尺度结构相似度指数和光谱角映射器及视觉信息保真度多种指标峰值信噪比和结构相似度指数测量结构相似性图像分类PNG和JPEG图像相似性近似算法图像压缩，视频压缩、端到端优化图像压缩、神经图像压缩、GPU变速图像压缩手术机器人深度估计算法重建三维可视化推理图像超分辨率算法模型三维实景实时可微分渲染算法MATLAB结构
【深度学习】训练过程中一个OOM的问题，太难查了 weixin_40293999 深度学习深度学习人工智能
现象：各位大佬又遇到过ubuntu的这个问题么？现象是在训练过程中，ssh上不去了，能ping通，没死机，但是ubunutu的pc侧的显示器，鼠标啥都不好用了。只能重启。问题原因：OOM了95G，尼玛！！！！pytorch爆内存了，然后journald假死了，在journald被watchdog干掉之后，系统就崩溃了。这种规模的爆内存一般，即使被oomkill了，也要卡半天的，确实会这样，能不能配
Pyorch中 nn.Conv1d 与 nn.Linear 的区别迪三 #NN_Layer 神经网络
即一维卷积层和全联接层的区别nn.Conv1d和nn.Linear都是PyTorch中的层，它们用于不同的目的，主要区别在于它们处理输入数据的方式和执行的操作类型。nn.Conv1d通过应用滑动过滤器来捕捉序列数据中的局部模式，适用于处理具有时间或序列结构的数据。nn.Linear通过将每个输入与每个输出相连接，捕捉全局关系，适用于将输入数据作为整体处理的任务。1.维度与输入nn.Conv1d（一
图片中的上采样，下采样和通道融合(up-sample, down-sample, channel confusion) 迪三 #图像处理_PyTorch 计算机视觉深度学习人工智能
前言以conv2d为例（即图片），Pytorch中输入的数据格式为tensor，格式为:[N,C,W,H,W]第一维N.代表图片个数，类似一个batch里面有N张图片第二维C.代表通道数，在模型中输入如果为彩色，常用RGB三色图，那么就是3维，即C=3。如果是黑白的，即灰度图，那么只有一个通道，即C=1第三维H.代表图片的高度，H的数量是图片像素的列数第四维W.代表图片的宽度，W的数量是图片像素的
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
机器学习VS深度学习 nfgo 机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
大数据毕业设计hadoop+spark+hive知识图谱租房数据分析可视化大屏租房推荐系统 58同城租房爬虫房源推荐系统房价预测系统计算机毕业设计机器学习深度学习人工智能 2401_84572577 程序员大数据 hadoop 人工智能
做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。我先来介绍一下这些东西怎么用，文末抱走。（1）Python所有方向的学习路线（
深度学习-13-小语言模型之SmolLM的使用皮皮冰燃深度学习深度学习
文章附录1SmolLM概述1.1SmolLM简介1.2下载模型2运行2.1在CPU/GPU/多GPU上运行模型2.2使用torch.bfloat162.3通过位和字节的量化版本3应用示例4问题及解决4.1attention_mask和pad_token_id报错4.2max_new_tokens=205参考附录1SmolLM概述1.1SmolLM简介SmolLM是一系列尖端小型语言模型，提供三种规
【NLP5-RNN模型、LSTM模型和GRU模型】一蓑烟雨紫洛 nlp rnn lstm gru nlp
RNN模型、LSTM模型和GRU模型1、什么是RNN模型RNN（RecurrentNeuralNetwork)中文称为循环神经网络，它一般以序列数据为输入，通过网络内部的结构设计有效捕捉序列之间的关系特征，一般也是以序列形式进行输出RNN的循环机制使模型隐层上一时间步产生的结果，能够作为当下时间步输入的一部分（当下时间步的输入除了正常的输入外还包括上一步的隐层输出）对当下时间步的输出产生影响2、R
基于深度学习的农作物病害检测 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的农作物病害检测利用卷积神经网络（CNN）、生成对抗网络（GAN）、Transformer等深度学习技术，自动识别和分类农作物的病害，帮助农业工作者提高作物管理效率、减少损失。1.农作物病害检测的挑战病害种类繁多：农作物病害的类型多样，不同病害在同一作物上的表现差异很大，同时同一种病害在不同生长阶段的症状也可能不同。环境影响：天气、光照、湿度等外部环境因素会影响农作物的表现，使得病害检
基于深度学习的文本引导的图像编辑 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的文本引导的图像编辑（Text-GuidedImageEditing）是一种通过自然语言文本指令对图像进行编辑或修改的技术。它结合了图像生成和自然语言处理（NLP）的最新进展，使用户能够通过描述性文本对图像内容进行精确的调整和操控。1.文本引导的图像编辑的挑战文本和图像之间的对齐：如何将文本中的语义信息准确地映射到图像中的特定区域或元素是一个关键挑战。这涉及到多模态数据的对齐和理解。编
深度学习--对抗生成网络（GAN, Generative Adversarial Network） Ambition_LAO 深度学习生成对抗网络
对抗生成网络（GAN,GenerativeAdversarialNetwork）是一种深度学习模型，由IanGoodfellow等人在2014年提出。GAN主要用于生成数据，通过两个神经网络相互对抗，来生成以假乱真的新数据。以下是对GAN的详细阐述，包括其概念、作用、核心要点、实现过程、代码实现和适用场景。1.概念GAN由两个神经网络组成：生成器（Generator）和判别器（Discrimina
web报表工具FineReport常见的数据集报错错误代码和解释老A不折腾 web报表 finereport 代码可视化工具
在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 NS_LayerReport_MultiDs=错误代码
Java的WeakReference与WeakHashMap bylijinnan java 弱引用
首先看看 WeakReference wiki 上 Weak reference 的一个例子： public class ReferenceTest { public static void main(String[] args) throws InterruptedException { WeakReference r = new Wea
Linux——（hostname）主机名与ip的映射 eksliang linux hostname
一、什么是主机名无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的；主机名是用于什么的呢？答：在一个局域网中，每台机器都有一个主
oracle 常用技巧 18289753290
oracle常用技巧 ①复制表结构和数据 create table temp_clientloginUser as select distinct userid from tbusrtloginlog ②仅复制数据如果表结构一样 insert into mytable select * &nb
使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException 酷的飞上天空 exception
有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
IT系统分析师如何学习大数据蓝儿唯美大数据
我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
spring学习——简介 a-john spring
Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 为了降低Java开发的复杂性，
自定义颜色的xml文件 aijuans xml
<?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
运营到底是做什么的？ aoyouzi 运营到底是做什么的？
文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
js面向对象类和对象百合不是茶 js 面向对象函数创建类和对象
接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下 ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似下面介绍一些js的类和对象的创建的技术一:类和对
web.xml之资源管理对象配置 resource-env-ref bijian1013 java web.xml servlet
resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 <resource-env-ref> <resource-env-ref-name>资源名</resource-env-ref-name> <resource-env-ref-type>查找资源时返回的资源类
Create a composite component with a custom namespace sunjing
https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace When you developed a composite component the namespace you would be seeing would
【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter bit1129 mongodb
一、复本集为什么要加入Arbiter这个角色回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。什么是Artiber？ An arbiter does not have a copy of data set and cannot become a primary. Replica sets may have arbiters to add a
Javascript开发笔记白糖_ JavaScript
获取iframe内的元素通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
Web浏览器Chrome打开一段时间后，运行alert无效 bozch Web chorme alert 无效
今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。试了试其他浏览器，发现都是没有问题的。开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了就关闭浏览器重启。结果就好了，这也太怪异了。难道是cho
编程之美-高效地安排会议图着色问题贪心算法 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class GraphColoringProblem { /**编程之美高效地安排会议图着色问题贪心算法 * 假设要用很多个教室对一组
机器学习相关概念和开发工具 chenbowen00 算法 matlab 机器学习
基本概念：机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。开发工具 M
[宇宙经济学]关于在太空建立永久定居点的可能性 comsci 经济
大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
oracle 11g database control 证书错误 daizj oracle 证书错误 oracle 11G 安装
oracle 11g database control 证书错误 win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面解决办法：是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
Java I/O之用FilenameFilter实现根据文件扩展名删除文件游其是你 FilenameFilter
在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例 dcj3sjt126com c array
# include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; //a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4] int i; for (i=0; i<5; ++i) printf("%d\n",
PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。就是唯一且不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引 dcj3sjt126com primary
PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。就是唯一且不能为空。INDEX 索引，普通的UNIQUE 唯一索引。不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号 INT会员姓名
java集合辅助类 Collections、Arrays shuizhaosi888 Collections Arrays HashCode
Arrays、Collections 1 ）数组集合之间转换 public static <T> List<T> asList(T... a) { return new ArrayList<>(a); } a）Arrays.asL
Spring Security（10）——退出登录logout 234390216 logout Spring Security 退出登录 logout-url LogoutFilter
要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
透过源码学前端之 Backbone 三 Model 逐行分析JS源代码 backbone 源码分析 js学习
Backbone 分析第三部分 Model 概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里，但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件，如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。
SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter 乒乓狂魔 springMVC
这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 HttpMessageConverter接口介绍： public interface HttpMessageConverter<T> { /** * Indicate
分布式基础知识和算法理论 bluky999 算法 zookeeper 分布式一致性哈希 paxos
分布式基础知识和算法理论 BY [email protected] 本文永久链接：http://nodex.iteye.com/blog/2103218 在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
Android Studio的.gitignore以及gitignore无效的解决 bell0901 android gitignore
　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store
成为高级程序员的10个步骤 tomcat_oracle 编程
What 软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 Why 得到更多的报酬！因为你的薪水会随着你水平的提高而增加提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进历经更大的挑战。随着你的成长，各种影响力也会提高。
mongdb在linux下的安装 xtuhcy mongodb linux
一、查询linux版本号： lsb_release -a LSB Version: :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa

PyTorch搭建ResNet模型（在CIFAR10数据集上准确率达到了90%）

PyTorch搭建ResNet模型

你可能感兴趣的:(深度学习,pytorch,深度学习,神经网络)