def __init__(self): super(Siamese, self).__init__() with self.init_scope(): self.b1 = ResNet18() self.b2 = ResNet18() self.fc1 = Linear(in_size=512, out_size=10) self.fc2 = Linear(in_size=10, out_size=10)
def __init__(self, n_class=None, pretrained_model=None, mean=None, initialW=None, initial_bias=None): if n_class is None: if pretrained_model in self._models: n_class = self._models[pretrained_model]['n_class'] else: n_class = 1000 if mean is None: if pretrained_model in self._models: mean = self._models[pretrained_model]['mean'] else: mean = _imagenet_mean self.mean = mean if initialW is None: # Employ default initializers used in the original paper. initialW = normal.Normal(0.01) if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. initialW = constant.Zero() kwargs = {'initialW': initialW, 'initial_bias': initial_bias} super(VGG16, self).__init__() with self.init_scope(): self.conv1_1 = Conv2DActiv(None, 64, 3, 1, 1, **kwargs) self.conv1_2 = Conv2DActiv(None, 64, 3, 1, 1, **kwargs) self.pool1 = _max_pooling_2d self.conv2_1 = Conv2DActiv(None, 128, 3, 1, 1, **kwargs) self.conv2_2 = Conv2DActiv(None, 128, 3, 1, 1, **kwargs) self.pool2 = _max_pooling_2d self.conv3_1 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs) self.conv3_2 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs) self.conv3_3 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs) self.pool3 = _max_pooling_2d self.conv4_1 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs) self.conv4_2 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs) self.conv4_3 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs) self.pool4 = _max_pooling_2d self.conv5_1 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs) self.conv5_2 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs) self.conv5_3 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs) self.pool5 = _max_pooling_2d self.fc6 = Linear(None, 4096, **kwargs) self.fc6_relu = relu self.fc6_dropout = dropout self.fc7 = Linear(None, 4096, **kwargs) self.fc7_relu = relu self.fc7_dropout = dropout self.fc8 = Linear(None, n_class, **kwargs) self.prob = softmax if pretrained_model in self._models: path = download_model(self._models[pretrained_model]['url']) chainer.serializers.load_npz(path, self) elif pretrained_model: chainer.serializers.load_npz(pretrained_model, self)
def __init__(self, input_size, vocab_size, embed_size, hidden_size): super(Encoder, self).__init__(xi1=Linear(input_size, embed_size), ih1=Linear(embed_size, 4 * hidden_size), hh1=Linear(hidden_size, 4 * hidden_size), xi2=EmbedID(vocab_size, embed_size), ih2=Linear(hidden_size + embed_size, 4 * hidden_size), hh2=Linear(hidden_size, 4 * hidden_size))
def __init__(self): super(Triplet, self).__init__() with self.init_scope(): self.b1 = ResNet18() # self.fc = Linear(in_size=512, out_size=10) # wrong way of making predictions # self.fc = Linear(in_size=512, out_size=5) # right way with 5 traits # self.fc = Linear(in_size=512, out_size=1) # with collapsed traits # self.fc1 = Linear(in_size=512, out_size=2) self.fc1 = Linear(in_size=512, out_size=1) self.fc2 = Linear(in_size=512, out_size=1)
def __init__(self, x_channels=1, y_channels=3, ch=64, activation=F.relu): super().__init__() self.activation = activation initializer = chainer.initializers.GlorotUniform() with self.init_scope(): self.block0_0 = OptimizedBlock(x_channels, ch // 2) self.block0_1 = OptimizedBlock(y_channels, ch // 2) self.block1 = Block(ch, ch * 2, activation=activation, downsample=True) self.block2 = Block(ch * 2, ch * 4, activation=activation, downsample=True) self.block3 = Block(ch * 4, ch * 8, activation=activation, downsample=True) self.block4 = Block(ch * 8, ch * 16, activation=activation, downsample=True) self.block5 = Block(ch * 16, ch * 16, activation=activation, downsample=False) self.l6 = Linear(ch * 16, 1, initialW=initializer)
def __init__(self): super(DummyModel, self).__init__() with self.init_scope(): self.l1 = Linear(3, 1, initialW=numpy.array([[1, 3, 2]]), nobias=True)
def __init__(self, num_layer, node_dim, edge_dim, gpu=0): super(EdgeUpdateNet, self).__init__() self.num_layer = num_layer self.edge_dim = edge_dim self.to_xpu = partial(to_device, gpu) with self.init_scope(): self.gn = ElementLinear(node_dim) for layer in range(self.num_layer): self.add_link('eup{}'.format(layer), EdgeUpdate(edge_dim)) self.add_link('int{}'.format(layer), InteractionNetwork(node_dim)) self.interaction1 = Linear(512) self.interaction2 = Linear(512) self.interaction3 = Linear(4)
def __init__(self, in_size, out_size=None, initial_bias=None, gain=sqrt(2)): super().__init__() self.c = gain * sqrt(1 / in_size) with self.init_scope(): self.linear = Linear(in_size, out_size, initialW=Normal(1.0), initial_bias=initial_bias)
def __init__(self, out_dim=64, hidden_channels=None, n_update_layers=None, n_atom_types=MAX_ATOMIC_NUM, n_edge_types=4, input_type='int', scale_adj=False): super(RelGCNSparse, self).__init__() if hidden_channels is None: hidden_channels = [16, 128, 64] elif isinstance(hidden_channels, int): if not isinstance(n_update_layers, int): raise ValueError( 'Must specify n_update_layers when hidden_channels is int') hidden_channels = [hidden_channels] * n_update_layers with self.init_scope(): if input_type == 'int': self.embed = EmbedAtomID(out_size=hidden_channels[0], in_size=n_atom_types) elif input_type == 'float': self.embed = Linear(None, hidden_channels[0]) else: raise ValueError( "[ERROR] Unexpected value input_type={}".format( input_type)) self.rgcn_convs = chainer.ChainList(*[ RelGCNSparseUpdate(hidden_channels[i], hidden_channels[i + 1], n_edge_types) for i in range(len(hidden_channels) - 1) ]) self.rgcn_readout = ScatterGGNNReadout( out_dim=out_dim, in_channels=hidden_channels[-1], nobias=True, activation=functions.tanh) # self.num_relations = num_edge_type self.input_type = input_type self.scale_adj = scale_adj
def __init__(self, hidden_size): super(Attention_concat, self).__init__( av=Linear(2 * hidden_size, 2 * hidden_size), vw=Linear(2 * hidden_size, 1), ) self.hidden_size = hidden_size
def __init__(self): super(Siamese, self).__init__() with self.init_scope(): self.fc1 = Linear(in_size=1, out_size=1, nobias=True)
def __init__(self): super(Branch, self).__init__() with self.init_scope(): self.fc1 = Linear(in_size=1, out_size=1)
def __init__(self): super(Siamese0, self).__init__() with self.init_scope(): self.b1 = Branch() self.fc1 = Linear(in_size=2, out_size=1)
def __init__(self): super(LastLayers, self).__init__() with self.init_scope(): self.fc = Linear(in_size=256, out_size=5)
def __init__(self): super(SimpleAll, self).__init__() with self.init_scope(): self.fc = Linear(in_size=1, out_size=5) self.bn = BatchNormalization(5)
def reinitialize(self, link: L.Linear): _, in_size = link.W.shape link._initialize_params(in_size)
def update_attributes(self, link: L.Linear): link.out_size, link.in_size = link.W.shape
def __init__(self): super(Deepimpression, self).__init__() with self.init_scope(): self.b1 = ResNet18() self.fc = Linear(in_size=256, out_size=5)
def __init__(self): super(Siamese, self).__init__() with self.init_scope(): self.b1 = ResNet18() self.fc = Linear(in_size=256, out_size=10)
def __init__(self, n_class, pretrained_model='auto'): super(ResNet101FineTuning, self).__init__() with self.init_scope(): self.base = ResNet101Layers(pretrained_model) self.fc6 = Linear(2048, n_class)
def __init__(self, n_units, n_out): super().__init__(l1=Linear(None, n_units), l2=Linear(n_units, n_units), l3=Linear(n_units, n_out))