[公开]北三河流域取用水监测计量能力提升重点项目（中央）——遥测终端及通讯模块升级改造及感知能力完善中标公告

009/Deep-Learning-for-Computer-Vision-Practical-Exercises

/09_PyTorch/09.2_1DConvolution/1DConvolution.py
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.autograd import Variable

# Hyperparameters
batch_size = 256

# Data
train_set = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True)

# Model
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 16, 3, stride=1, padding=1)
self.pool = nn.MaxPool2d(2, 2) # Maxpooling layer
self.conv2 = nn.Conv2d(16, 32, 3, stride=1, padding=1)
self.fc1 = nn.Linear(32 * 14 * 14, 128) # Linear layer
self.fc2 = nn.Linear(128, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 32 * 14 * 14)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

# Train the model
for epoch in range(5): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(train_loader, 0):
# get the inputs
inputs, labels = data
# wrap them in Variable
inputs, labels = Variable(inputs), Variable(labels)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.data[0]
if i % 100 == 99: # print every 100 mini-batches
print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
running_loss = 0.0

print('Finished Training')

/09_PyTorch/09.3_DenseNet/densenet.py
from typing import List

from torch import Tensor
from torch.nn import Module
from torch.nn.functional import relu

from .. import _utils
from .._functions import _conv2d, _conv3d
from .._functions import _conv_transpose2d, _conv_transpose3d
from .._functions import _max_pool2d, _max_pool3d
from .._functions import _avg_pool2d, _avg_pool3d
from .._functions import _upsample_nearest2d, _upsample_nearest3d
from .._functions import _upsample_bilinear2d, _upsample_bilinear3d

class _Conv(Module):
def __init__(self, in_channels: int, out_channels: int, kernel_size: int, stride: int, padding: int = 0,
groups: int = 1, bias: bool = True, dilation: int = 1, padding_mode: str = 'zeros'):
super(_Conv, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_size = kernel_size
self.stride = stride
self.padding = padding
self.groups = groups
self.bias = bias
self.dilation = dilation
self.padding_mode = padding_mode
self._weight = None
self._bias = None
self._conv = None

def forward(self, input: Tensor) -> Tensor:
if self._weight is None:
self._weight = torch.nn.Parameter(torch.Tensor(self.out_channels, self.in_channels // self.groups,
*self.kernel_size))
torch.nn.init.kaiming_uniform_(self._weight, a=1)
self._bias = torch.nn.Parameter(torch.Tensor(self.out_channels))
torch.nn.init.uniform_(self._bias)
self._weight = self._weight.to(input.device)
self._bias = self._bias.to(input.device)
if self._conv is None:
self._conv = _conv2d if input.dim() == 4 else _conv3d

return self._conv(input, self._weight, self._bias, self.stride, self.padding, self.dilation,
self.groups, self.padding_mode)

def extra_repr(self) -> str:
return ('{in_channels}, {out_channels}, kernel_size={kernel_size}, stride={stride}, padding={padding}, '
'dilation={dilation}, groups={groups}, bias={bias}, padding_mode={padding_mode}').format(**self.__dict__)

class _ConvTranspose(Module):
def __init__(self, in_channels: int, out_channels: int, kernel_size: int, stride: int, padding: int = 0,
output_padding: int = 0, groups: int =