def __init__(self,
inplanes,
planes,
kernel_size=3,
stride=1,
downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = nn.conv2d(inplanes,
planes,
kernel_size,
stride,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(planes, momentum=BN_MOMENTUM)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.conv2d(planes,
planes,
kernel_size,
stride,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes, momentum=BN_MOMENTUM)
self.downsample = downsample
self.stride = stride
def conv_3_block(in_dim, out_dim): # 3개의 합성곱 레이어를 만드는 콘브 블럭입니다.
model = nn.Sequential(
nn.Conv2d(in_dim, out_dim, kernel_size=3, padding=1), nn.ReLU(),
nn.conv2d(out_dim, out_dim, kernel_size=3, padding=1), nn.ReLU(),
nn.conv2d(out_dim, out_dim, kernel_size=3, padding=1), nn.ReLU(),
nn.MaxPool2d(2, 2))
return model
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 18 * 18, 800)
self.fc2 = nn.Linear(800, 120)
self.fc3 = nn.Linear(120, 2)
def __init__(self):
super().__init__()
self.conv1 = nn.conv2d(1, 6, kernel_size = 5)
self.conv2 = nn.conv2d(6, 16, kernel_size = 5)
self.pool1 = nn.MaxPool2d((2, 2), stride = 2)
self.pool2 = nn.MaxPool2d((2, 2), stride = 2)
self.linear1 = nn.Linear(16 * 5 * 5, 120)
self.linear2 = nn.Linear(120, 84)
self.linear3 = nn.Linear(84, 10)
self.relu = nn.ReLU(inplace = True)
def __init__(self,inplanes,planes,stride=1,downsample=None):
#construct a sample, build layers, 3x3 convolutional layers
super(BasicBlock,self).__init__()
self.conv1 = nn.conv2d(inplanes,planes,stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.conv2d(planes,planes,stride)
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride=stride
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.conv2d(1, 32, 5, 2, padding=2)
self.conv2 = nn.conv2d(16, 64, 5, 2, padding=2)
self.conv3 = nn.conv2d(64, 32, 5, 2, padding=2)
self.fc1 = nn.Linear(512, 64)
self.fc2 = nn.Linear(64, 32)
self.fc3 = nn.Linear(32, 8)
self.fc4 = nn.Linear(8, 1)
self.init_weights()
def __init__(self):
super(SensorToDryspotBoolModel, self).__init__()
self.dropout = nn.dropout(0.1)
self.maxpool = nn.maxpool2d(2, 2)
self.conv1 = nn.conv2d(1, 32, (7, 7))
self.conv2 = nn.conv2d(32, 64, (5, 5))
self.conv3 = nn.conv2d(64, 128, (3, 3))
self.conv4 = nn.conv2d(128, 256, (3, 3))
self.fc1 = nn.linear(256, 1024)
self.fc2 = nn.linear(1024, 512)
self.fc3 = nn.linear(512, 128)
self.fc_f = nn.linear(128, 1)
def __init__(self, args):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 4, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.conv2d(4, 4, 5)
self.fc1 = nn.Linear(4 * 37 * 37, 256)
self.fc2 = nn.Linear(256, 15)
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 6, 3)
self.conv2 = nn.conv2d(6, 16, 3)
self.fc1 = nn.linear(16 * 6 * 6, 120)
self.fc2 - nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, input, generation_input):
size = input.size()
batch_size = size[0]
channels = size[1]
weights = self.generator(generation_input)
weight_size = weights.size()
weights.reshape(batch_size * weight_size[0], weight_size[1],
weight_size[2], weight_size[3])
weight_size = weights.size()
# weight size resolution:
assert (weight_size[0] % batch_size == 0,
"Filter size not an integer multiple of the batch size!")
out_channels = weight_size[0] // batch_size
filters = weight_size[1]
width = weight_size[2]
height = weight_size[3]
filters = weight_size[1]
debatched = input.reshape(channels * batch_size, size[2], size[3])
result = nn.conv2d(debatched,
weights,
stride=self.stride,
padding=self.padding,
dilation=self.dilation,
groups=batch_size)
result = result.reshape(batch_size, filters,
result.size()[2],
result.size()[3])
return result
def __init__(self, z_dim):
super(Enocder, self).__init__()
self.Activation = nn.LeakyReLU(inplace=True, negative_slope=0.2)
self.normalization = nn.BatchNorm2d()
self.conv1 = nn.Conv2d(in_channels=3,
out_channels=64,
kernel_size=4,
stride=2,
bias=True) #32x32 --> 14x14
self.conv2 = nn.Conv2d(in_channels=64,
out_channels=128,
kernel_size=4,
stride=2,
padding=1,
bias=True) #14x14 --> 7x7
self.conv3 = nn.conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1,
bias=True) #7x7 --> 4x4
self.dense_net = nn.Linear(256 * 4 * 4, z_dim)
def __init__(self, num_class=1000):
super(AlexNet, self).__init__()
self.features = nn.Swquential(
nn.conv2d(3, 64, kernel_size=11, stride=4, padding=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(64, 192, kernel_size=3, stride=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(192, 384, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(384, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, kernel_size=3, padding=1),
nn.ReLU(inpalce=True),
nn.MaxPool2d(kernel_size=3, stride=2),
)
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(256 * 6 * 6, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, num_classes),
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), 256 * 6 * 6)
x = self.classifier(x)
return x
def conv3x3(in_channels, out_channels, stride=1):
return nn.conv2d(in_channels,
out_channels,
kernet_size=3,
stride=stride,
padding=1,
bias=False)
def __init__(self,
input_shape=((4, 32, 32), (6, 16, 16)),
feature_size=128,
kernel_size=3):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, feature_size, kernel_size, 1)
self.conv2 = nn.conv2d(feature_size, input_shape[-1][0], kernel_size,
1)
self.rBlock = ResBlock(feature_size, kernel_size)
def __init__(self, input_size, output_size) -> None:
""""""
super(CNN, self).__init__()
self.kernel_size = 3
self.stride = 2
self.layers = nn.Sequential(
nn.conv2d(input_size, output_size, self.kernel_size, self.stride),
nn.ReLU(),
nn.MaxPool2d(),
)
def build_dc_classifier():
"""
Build and return a PyTorch model for the DCGAN discriminator implementing
the architecture above.
"""
model = nn.Sequential(
Unflatten(batch_size,1,28,28),
nn.conv2d(1,32,5,1),#32*24*24
nn.LeakyReLU(inplace=True,negative_slope = 0.01),
nn.MaxPool2d(2,2), #32*12*12
nn.conv2d(32,64,5,1),# 64*8*8
nn.LeakyReLU(inplace=True,negative_slope = 0.01),
nn.MaxPool2d(2,2),#64*4*4
Flatten(),
nn.Linear(4*4*64,4*4*64)
nn.LeakyReLU(inplace=True,negative_slope = 0.01),
nn.Linear(4*4*64,1),
)
return model
def __init__(self):
super(vgg19ca, self).__init__()
############# 256-256 ##############
#haze_class = models.vgg19_bn(pretrained=True)
#self.feature = nn.Sequential(haze_class.features[0])
#for i in range(1,3):
# self.feature.add_module(str(i),haze_class.features[i])
self.conv1 = nn.conv2d(1,24,kernel_size=3,stride=1,padding=1)
self.conv61 = nn.Conv2d(24,64,kernel_size=3,stride=1,padding=1)
def __init__(self, in_channels, distillation_rate=0.25):
super(IMDModule_speed, self).__init__()
self.distilled_channels = int(in_channels * distillation_rate)
self.remaining_channels = int(in_channels - self.distilled_channels)
self.c1 = sequential(
nn.conv2d(in_channels,
in_channels,
kernel_size=(1, 3),
dilation=(1, 2)),
nn.conv2d(in_channels,
in_channels,
kernel_size=(3, 1),
dilation=(2, 1)),
)
self.c2 = conv_layer(self.remaining_channels, in_channels, 3)
self.c3 = conv_layer(self.remaining_channels, in_channels, 3)
self.c4 = conv_layer(self.remaining_channels, self.distilled_channels,
3)
self.act = activation('lrelu', neg_slope=0.05)
self.c5 = conv_layer(self.distilled_channels * 4, in_channels, 1)
def build_classifier(input_features, hidden_layers, output_features):
classifier = nn.conv2d()
if hidden_layers is None:
classifier.add_module('fc0',
nn.conv2d(input_features, output_features))
else:
layer_sizes = zip(hidden_layers[:-1], hidden_layers[1:])
classifier.add_module('fc0',
nn.conv2d(input_features, hidden_layers[0]))
classifier.add_module('relu0', nn.ReLU())
classifier.add_module('drop0', nn.Dropout(.6))
classifier.add_module('relu1', nn.ReLU())
classifier.add_module('drop1', nn.Dropout(.5))
for i, (h1, h2) in enumerate(layer_sizes):
classifier.add_module('fc' + str(i + 1), nn.Linear(h1, h2))
classifier.add_module('relu' + str(i + 1), nn.ReLU())
classifier.add_module('drop' + str(i + 1), nn.Dropout(.5))
classifier.add_module(
'output', nn.Linear(hidden_layers[-1], output_features))
return classifier
def forward(self, x1, x2):
x_mul = x1.mul(x2)
x_add = torch.add(x1, x2)
x_norm_l1 = torch.abs(x1 - x2)
x_norm_l2 = x_norm_l1.mul(x_norm_l1)
x = torch.cat((x_mul, x_add, x_norm_l1, x_norm_l2), 1)
x = x.view(x1.size(0), 1, 4, x1.size(1)) # batch_size, c, h, w
x = nn.Conv2d(1, 32, (1, 4))(x)
x = x.view(x1.size(0), x1.size(1), 32, 1)
x = nn.conv2d(512, 1, (1, 32))(x)
x = x.view(x1.size(0), -1)
return x
def __init__(self, activation: str, mask_conv: bool):
super(VGGExtractor, self).__init__(activation)
self.mask_conv = mask_conv
self.conv = nn.Sequential(
nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(num_features=64), self.activation,
nn.conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(num_feature=64), self.activation,
nn.MaxPool2d(2, stride=2),
nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(num_features=128), self.activation,
nn.Conv2d(128, 128, kernel_size=3, strid=1, padding=1, bias=False),
nn.BatchNorm2d(num_feature=128), self.activation,
nn.MaxPool2d(2, stride=2))
if mask_conv:
self.conv = MaskConv(self.conv)
def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d, use_sigmoid=False, gpu_ids=[]):
super(ImgLSTM, self).__init__()
#Setting
self.gpu_ids = gpu_ids
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
#Network
self.net = [
nn.Conv2d(input_nc,64, kernel_size=3, stride=1, bias=use_bias),
nn.ReLu(True),
nn.MaxPool2d(kernel_size=2,stride=2),
nn.Conv2d(64,128, kernel_size=3, stride=1, bias=use_bias),
nn.ReLu(True),
nn.MaxPool2d(kernel_size=2,stride=2),
nn.Conv2d(128,256,kernel_size=3,stride=1,bias=use_bias),
nn.ReLu(True),
nn.Conv2d(256,256,kernel_size=3,stride=1,bias=use_bias),
nn.ReLu(True),
nn.MaxPool2d(kernel_size=2,stride=1,bias=use_bias),
nn.Conv2d(256,512,kernel_size=3,stride=1,bias=use_bias),
nn.ReLu(True),
nn.conv2d(512,512,kernel_size=3,stride=1,bias=use_bias),
nn.ReLu(True),
nn.MaxPool2d(kernel_size=2,stride=1,bias=use_bias),
nn.Conv2d(512,512,kernel_size=2,stride=1,bias=use_bias),
nn.ReLu(True)
]
self.net = nn.Sequential(*self.net)
def __init__(self,
input_channels,
hidden_channels,
kernel_size=3,
stride=1,
padding=0,
dilation=1,
hidden_kernel_size=1,
bias=True):
super(ConvLSTMCell, self).__init__()
self.input_channels = input_channels
self.hidden_channels = hidden_channels
self.kernel_size = _pair(kernel_size)
self.stride = _pair(stride)
self.padding = _pair(padding)
self.dilation = _pair(dilation)
self.hidden_kernel_size = _pair(hidden_kernel_size)
hidden_padding = _pair(hidden_kernel_size // 2)
gate_channels = 4 * self.hidden_channels
self.conv_ih = nn.Conv2d(in_channels=self.input_channels,
out_channels=gate_channels,
kernel_size=self.kernel_size,
stride=self.stride,
padding=self.padding,
dilation=self.dilation,
bias=bias)
self.conv_hh = nn.conv2d(in_channels=self.hidden_channels,
out_channels=gate_channels,
kernel_size=hidden_kernel_size,
stride=1,
padding=hidden_padding,
dilation=1,
bias=bias)
self.reset_parameters()
def __init__(self):
super(VGG16, self).__init__()
#network
self.conv1 = nn.Conv2d(3, 64, padding=1, kernel_size=(3, 3), stride=1)
#relu
self.conv2 = nn.Conv2d(64, 64, padding=1, kernel_size=(3, 3), stride=1)
#relu
self.pool1 = nn.MaxPool2d((2, 2), stride=2)
self.conv3 = nn.Conv2d(64,
128,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.conv4 = nn.Conv2d(128,
128,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.pool2 = nn.MaxPool2d((2, 2), stride=2)
self.conv5 = nn.Conv2d(128,
256,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.conv6 = nn.Conv2d(256,
256,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.conv7 = nn.Conv2d(256,
256,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.pool3 = nn.MaxPool2d((2, 2), stride=2)
self.conv8 = nn.Conv2d(256,
512,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.conv9 = nn.Conv2d(512,
512,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.conv10 = nn.conv2d(512,
512,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.pool4 = nn.MaxPool2d((2, 2), stride=2)
self.conv11 = nn.conv2d(512,
512,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.conv12 = nn.conv2d(512,
512,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.conv13 = nn.conv2d(512,
512,
padding=1,
kernel_size=(3, 3),
stride=1)
#relu
self.pool5 = nn.MaxPool2d((2, 2), stride=2)
self.linear1 = nn.Linear(7 * 7 * 512, 4096)
#relu
self.dropout = nn.Dropout(0.5)
self.linear2 = nn.Linear(4096, 1000)
#softmax
self.default_optimizer = torch.optim.SGD(VGG16.parameters(),
lr=0.001,
momentum=0.9)
self.default_loss = torch.nn.CrossEntropyLoss()
def __init__(self, channel_in, kernel_size=3, stride=1, padding=1):
self.conv = nn.conv2d(channel_in, channel_in, kernel_size=kernel_size,
stride=stride, padding=padding, groups=channel_in)
self.norm = nn.BatchNorm2d(channel_in)
def __init__(self, channel_in, channel_out, kernel_size=1,
stride=1, padding=0):
self.conv = nn.conv2d(channel_in, channel_out, kernel_size=kernel_size,
stride=stride, padding=padding)
self.norm = nn.BatchNorm2d(channel_out)
def forward(self, x, h, c):
bsize, tsize, _, h, w = x.size()
self.Wxi = nn.conv2d(1, self.hidden_layer, self.padding, self.stride)
def __init__(self):
super(fcn, self).__init__()
self.layer1 = nn.sequential(
nn.maxpool2d(kernel_size=(4, 4, 4)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3), dilation=(1, 2, 2)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3), dilation=(2, 4, 4)),
nn.maxunpool2d(25, 25, kernel_size=(4, 4, 4)))
self.layer2 = nn.sequential(
nn.maxpool2d(kernel_size=(4, 4, 4)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3), dilation=(1, 2, 2)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3), dilation=(2, 4, 4)),
nn.maxunpool2d(25, 25, kernel_size=(2, 2, 2)))
self.layer3 = nn.sequential(
nn.conv2d(3, 25, kernel_size=(3, 3, 3)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3), dilation=(1, 2, 2)),
nn.conv2d(25, 25, kernel_size=(3, 3, 3), dilation=(2, 4, 4)))
self.layer4 = nn.sequential(
nn.conv2d(75, 75, kernel_size=(3, 3, 3), dilation=(2, 4, 4)),
nn.conv2d(75, 100, kernel_size=(3, 3, 3), dilation=(2, 4, 4)),
nn.conv2d(100, 100, kernel_size=(3, 3, 3), dilation=(2, 4, 4)),
nn.conv2d(100, 100, kernel_size=(3, 3, 3), dilation=(2, 4, 4)),
nn.conv2d(100, 2, kernel_size=(1, 1, 1)))
def conv1x1(inplanes, outplanes, stride=1):
return nn.conv2d(inplanes, outplanes, kernel_size=1, stride=stride, padding=1, bias=False)
