def __init__(self):
super(Policy, self).__init__()
self.affine1 = nn.Linear(4, 128)
self.action_head = nn.Linear(128, 2)
self.value_head = nn.Linear(128, 1)
self.saved_actions = []
self.rewards = []
def __init__(self, input_dim, d_key=None, d_value=None, n_head=1, dropout_rate=0.):
super(MultiHeadAttention, self).__init__()
self.n_head = n_head
self.d_key = input_dim // n_head if d_key is None else d_value
self.d_value = input_dim // n_head if d_value is None else d_value
self.dropout_rate = dropout_rate
self.q_proj = nn.Linear(input_dim, self.d_key * self.n_head)
self.k_proj = nn.Linear(input_dim, self.d_key * self.n_head)
self.v_proj = nn.Linear(input_dim, self.d_value * self.n_head)
def __init__(self):
super(Policy, self).__init__()
self.affine1 = nn.Linear(4, 128)
self.affine2 = nn.Linear(128, 2)
self.dropout_ratio = 0.6
self.saved_log_probs = []
self.rewards = []
def __init__(self, t_dim, num_class):
super(REModel, self).__init__()
self.pc_fc1 = nn.Linear(t_dim, t_dim)
self.pc_fc2 = nn.Linear(t_dim, num_class)
self.multi_head_attn = MultiHeadAttention(t_dim, n_head=8)
self.conv1d = Conv1d(t_dim * 4, t_dim, filter_size=3, padding=1)
self.po_fc = nn.Linear(t_dim, 1)
self.po1_fc = nn.Linear(t_dim, num_class)
self.po2_fc = nn.Linear(t_dim, num_class)
def __init__(self):
super(ModelLinear, self).__init__()
models = []
with supernet(expand_ratio=(1, 2, 4)) as ofa_super:
models1 = []
models1 += [nn.Embedding(size=(64, 64))]
models1 += [nn.Linear(64, 128)]
models1 += [nn.LayerNorm(128)]
models1 += [nn.Linear(128, 256)]
models1 = ofa_super.convert(models1)
models += models1
self.models = paddle.nn.Sequential(*models)
def __init__(self,
img_size=256,
style_dim=64,
num_domains=2,
max_conv_dim=512):
super().__init__()
self.num_domains = num_domains
dim_in = 2**14 // img_size
blocks = []
blocks += [nn.Conv2D(3, dim_in, 3, 1, 1)]
repeat_num = int(np.log2(img_size)) - 2
for _ in range(repeat_num):
dim_out = min(dim_in * 2, max_conv_dim)
blocks += [ResBlk(dim_in, dim_out, downsample=True)]
dim_in = dim_out
blocks += [LeakyRelu(alpha=0.2)]
blocks += [nn.Conv2D(dim_out, dim_out, 4, 1, 0)]
blocks += [LeakyRelu(alpha=0.2)]
self.shared = fluid.dygraph.Sequential(*blocks)
self.unshared = fluid.dygraph.Sequential()
for _ in range(num_domains):
self.unshared.add_sublayer(f'lsub_{_}',
nn.Linear(dim_out, style_dim))
def __init__(self, t_dim, maxlen, char_num, word_num, word_dim, word_vec, num_class,
padding_idx=0, dropout_rate=0.25):
super(KGModel, self).__init__()
self.pe = nn.Embedding(size=[maxlen, t_dim],
param_attr=fluid.ParamAttr(name="position_embedding.w_0",
initializer=fluid.initializer.ConstantInitializer(
value=0.)))
self.ce = nn.Embedding(size=[char_num, t_dim], padding_idx=padding_idx,
param_attr=fluid.ParamAttr(name="char_embedding.w_0"))
self.we_p = nn.Embedding(size=[word_num, word_dim], padding_idx=padding_idx,
param_attr=fluid.ParamAttr(name="word_embedding.w_0",
initializer=fluid.initializer.NumpyArrayInitializer(
word_vec),
trainable=False))
self.we = nn.Linear(word_dim, t_dim, param_attr=fluid.ParamAttr(name="word_embedding.w_1"), bias_attr=False)
self.er_model = ERModel(t_dim)
self.re_model = REModel(t_dim, num_class)
self.padding_idx = padding_idx
self.dropout_rate = dropout_rate
def __init__(self,
in_channels,
out_channels,
in_size,
is_bias=True,
is_bn=True,
is_relu=True,
is_test=False):
super(FCBNReluLayer, self).__init__()
self.is_bn = is_bn
self.is_relu = is_relu
if is_bias:
bias_init = fluid.ParamAttr(
initializer=fluid.initializer.ConstantInitializer(0.))
else:
bias_init = False
self.linear = nn.Linear(in_channels * in_size * in_size,
out_channels,
bias_attr=bias_init)
self.bn = nn.BatchNorm(out_channels,
param_attr=norm_weight_init(),
bias_attr=norm_bias_init(),
act=None,
momentum=0.9,
use_global_stats=is_test)
def __init__(self, inplanes=-1, planes=400, loss_weight=0.5):
super(AuxHead, self).__init__()
self.convs = \
ConvModule(inplanes, inplanes * 2, kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1), bias=False)
self.loss_weight = loss_weight
self.dropout = nn.Dropout(p=0.5)
self.fc = nn.Linear(inplanes * 2, planes)
def __init__(self):
super(ClsLite, self).__init__()
self.conv_cfg = dict(type='Conv')
self.norm_cfg = dict(type='BN')
self._make_stem_layer()
self.avgpool = nn.Pool2D(pool_type='avg', global_pooling=True)
self.fc = nn.Linear(128, 2, act='softmax')
def __init__(self):
super(Model, self).__init__()
with supernet(kernel_size=(3, 5, 7), expand_ratio=[1, 2,
4]) as ofa_super:
models = []
models += [nn.Conv2D(1, 6, 3)]
models += [ReLU()]
models += [nn.Pool2D(2, 'max', 2)]
models += [nn.Conv2D(6, 16, 5, padding=0)]
models += [ReLU()]
models += [nn.Pool2D(2, 'max', 2)]
models += [
nn.Linear(784, 120),
nn.Linear(120, 84),
nn.Linear(84, 10)
]
models = ofa_super.convert(models)
self.models = paddle.nn.Sequential(*models)
def __init__(self):
super(ModelLinear, self).__init__()
models = []
with supernet(expand_ratio=(1, 2, 4)) as ofa_super:
models1 = []
models1 += [nn.Linear(64, 128)]
models1 += [nn.Linear(128, 256)]
models1 = ofa_super.convert(models1)
models += models1
with supernet(channel=((64, 128, 256), (64, 128, 256))) as ofa_super:
models1 = []
models1 += [nn.Linear(256, 128)]
models1 += [nn.Linear(128, 256)]
models1 = ofa_super.convert(models1)
models += models1
self.models = paddle.nn.Sequential(*models)
def __init__(self, style_dim, num_features):
super().__init__()
self.norm = fluid.dygraph.InstanceNorm(
num_features,
epsilon=1e-05,
param_attr=fluid.ParamAttr(
initializer=fluid.initializer.Constant(1.0), trainable=False),
bias_attr=fluid.ParamAttr(
initializer=fluid.initializer.Constant(0.0), trainable=False),
dtype='float32') # affine=False,对应代码中的两个参数设置
self.fc = nn.Linear(style_dim, num_features * 2)
def __init__(self, t_dim):
super(ERModel, self).__init__()
self.dilated_gated_conv1d_list = []
for i in range(3):
self.dilated_gated_conv1d_list.append(
DilatedGatedConv1d(t_dim, t_dim, filter_size=3, padding=1, dilation=1))
self.dilated_gated_conv1d_list.append(
DilatedGatedConv1d(t_dim, t_dim, filter_size=3, padding=2, dilation=2))
self.dilated_gated_conv1d_list.append(
DilatedGatedConv1d(t_dim, t_dim, filter_size=3, padding=5, dilation=5))
self.dilated_gated_conv1d_list.append(DilatedGatedConv1d(t_dim, t_dim, filter_size=3, padding=1, dilation=1))
self.dilated_gated_conv1d_list.append(DilatedGatedConv1d(t_dim, t_dim, filter_size=3, padding=1, dilation=1))
self.dilated_gated_conv1d_list.append(DilatedGatedConv1d(t_dim, t_dim, filter_size=3, padding=1, dilation=1))
self.pn1_fc1 = nn.Linear(t_dim, t_dim)
self.pn1_fc2 = nn.Linear(t_dim, 1)
self.pn2_fc1 = nn.Linear(t_dim, t_dim)
self.pn2_fc2 = nn.Linear(t_dim, 1)
self.multi_head_attn = MultiHeadAttention(t_dim, n_head=8)
self.conv1d = Conv1d(t_dim * 2, t_dim, filter_size=3, padding=1)
self.ps1_fc = nn.Linear(t_dim, 1)
self.ps2_fc = nn.Linear(t_dim, 1)
def __init__(self, name_scope, num_classes=1):
super(LeNet, self).__init__(name_scope)
# 创建卷积和池化层块，每个卷积层使用Sigmoid激活函数，后面跟着一个2x2的池化
self.conv1 = nn.Conv2D(num_channels=1,
num_filters=6,
filter_size=5,
act='sigmoid')
self.pool1 = nn.Pool2D(pool_size=2, pool_stride=2, pool_type='max')
self.conv2 = nn.Conv2D(num_channels=6,
num_filters=16,
filter_size=5,
act='sigmoid')
self.pool2 = nn.Pool2D(pool_size=2, pool_stride=2, pool_type='max')
# 创建第3个卷积层
self.conv3 = nn.Conv2D(num_channels=16,
num_filters=120,
filter_size=4,
act='sigmoid')
# 创建全连接层，第一个全连接层的输出神经元个数为64， 第二个全连接层输出神经元个数为分裂标签的类别数
self.fc1 = nn.Linear(input_dim=120, output_dim=64, act='sigmoid')
self.fc2 = nn.Linear(input_dim=64, output_dim=num_classes)
def __init__(self,
backbone,
neck,
head,
train_cfg=None,
test_cfg=None,
pretrained=None):
super(Classifier, self).__init__()
self.dropout = backbone.pop('dropout')
self.backbone = ResNet(**backbone)
self.train_cfg = train_cfg
self.test_cfg = test_cfg
self.triple_loss = TripletLoss()
self.avgpool = nn.Pool2D(pool_type='avg', global_pooling=True)
self.fc = nn.Linear(512, 2, act='softmax')
self.init_weights(pretrained=pretrained)
def __init__(self, latent_dim=16, style_dim=64, num_domains=2):
super().__init__()
layers = []
layers += [nn.Linear(latent_dim, 512, act='relu')]
for _ in range(3):
layers += [nn.Linear(512, 512, act='relu')]
self.shared = fluid.dygraph.Sequential(*layers)
self.unshared = fluid.dygraph.Sequential()
for _ in range(num_domains):
sublayer = fluid.dygraph.Sequential(
nn.Linear(512, 512, act='relu'), nn.Linear(512,
512,
act='relu'),
nn.Linear(512, 512, act='relu'), nn.Linear(512, style_dim))
self.unshared.add_sublayer(f'lsub_{_}', sublayer)
def __init__(self,
name,
Block,
layers,
num_classes=1000,
groups=1,
is_test=False):
"""
:param name: str, namescope
:param layers: int, the layer of defined network
:param num_classes: int, the dimension of final output
:param groups: int, default is 1
"""
super(ResNet, self).__init__(name_scope=name)
support_layers = [18, 34, 50, 101, 152]
assert layers in support_layers, \
"support layer can only be one of [18, 34, 50, 101, 152]"
self.layers = layers
if layers == 18:
depths = [2, 2, 2, 2]
elif layers == 50 or layers == 34:
depths = [3, 4, 6, 3]
elif layers == 101:
depths = [3, 4, 23, 3]
elif layers == 152:
depths = [3, 8, 36, 3]
strides = [1, 2, 2, 2]
num_filters = [64, 128, 256, 512]
self.in_channels = 64
self.dilation = 1
self.groups = groups
self.conv_bn_init = ConvBNLayer(3,
out_channels=self.in_channels,
filter_size=7,
stride=2,
is_test=is_test)
block_collect = []
downsample = None
for i in range(len(depths)):
# collect layers in each block
_block = []
stride = strides[i]
out_channel = num_filters[i]
if stride != 1 or self.in_channels != num_filters[
i] * Block.expansion:
downsample = True
bottleneck_block = self.add_sublayer(
"block{}_0".format(i),
Block(self.in_channels,
out_channel,
stride=stride,
is_downsample=downsample,
is_test=is_test))
downsample = False
_block.append(bottleneck_block)
self.in_channels = num_filters[i] * Block.expansion
for j in range(1, depths[i]):
bottleneck_block = self.add_sublayer(
"block{}_{}".format(i, j),
Block(self.in_channels, out_channel, is_test=is_test))
_block.append(bottleneck_block)
# collect blocks
block_collect.append(_block)
self.block_collect = block_collect
self.maxpool = nn.Pool2D(pool_size=3,
pool_stride=2,
pool_padding=1,
pool_type="max")
self.global_pool = nn.Pool2D(pool_type='avg', global_pooling=True)
self.fc = nn.Linear(input_dim=512 * Block.expansion,
output_dim=num_classes)
def __init__(self):
super(SiameseNetwork, self).__init__()
self.model = MobileNet()
self.linear1 = nn.Linear(input_dim=3 * 8 * 8, output_dim=3 * 8 * 4)
self.linear2 = nn.Linear(input_dim=3 * 8 * 4, output_dim=3 * 8 * 2)
self.linear3 = nn.Linear(input_dim=3 * 8 * 2, output_dim=24)
def __init__(self,
name,
input_dim=(128, 256),
pred_input_dim=(256, 256),
pred_inter_dim=(256, 256),
is_test=False):
super(AtomIouNet, self).__init__(name)
self.name = self.full_name()
self.conv3_1r = ConvBNReluLayer(input_dim[0],
128,
filter_size=3,
stride=1,
is_test=is_test)
self.conv3_1t = ConvBNReluLayer(input_dim[0],
256,
filter_size=3,
stride=1,
is_test=is_test)
self.conv3_2t = ConvBNReluLayer(256,
pred_input_dim[0],
filter_size=3,
stride=1,
is_test=is_test)
self.fc3_1r = ConvBNReluLayer(128,
256,
filter_size=3,
stride=1,
padding=0,
is_test=is_test)
self.conv4_1r = ConvBNReluLayer(input_dim[1],
256,
filter_size=3,
stride=1,
is_test=is_test)
self.conv4_1t = ConvBNReluLayer(input_dim[1],
256,
filter_size=3,
stride=1,
is_test=is_test)
self.conv4_2t = ConvBNReluLayer(256,
pred_input_dim[1],
filter_size=3,
stride=1,
is_test=is_test)
self.fc34_3r = ConvBNReluLayer(512,
pred_input_dim[0],
filter_size=1,
stride=1,
padding=0,
is_test=is_test)
self.fc34_4r = ConvBNReluLayer(512,
pred_input_dim[1],
filter_size=1,
stride=1,
padding=0,
is_test=is_test)
self.fc3_rt = FCBNReluLayer(pred_input_dim[0],
pred_inter_dim[0],
in_size=5,
is_test=is_test)
self.fc4_rt = FCBNReluLayer(pred_input_dim[1],
pred_inter_dim[1],
in_size=3,
is_test=is_test)
bias_init = fluid.initializer.ConstantInitializer(0.)
self.iou_predictor = nn.Linear(pred_inter_dim[0] + pred_inter_dim[1],
1,
bias_attr=bias_init)
self.outs = {}
