Ejemplo n.º 1
0
    def __init__(self, train=False):
        self.train = train
        super(Mynet, self).__init__()
        with self.init_scope():
            self.enc1 = chainer.Sequential()
            for i in range(2):
                self.enc1.append(L.Convolution2D(None, 32, ksize=3, pad=1, stride=1, nobias=True))
                self.enc1.append(F.relu)
                self.enc1.append(L.BatchNormalization(32))

            self.enc2 = chainer.Sequential()
            for i in range(2):
                self.enc2.append(L.Convolution2D(None, 32, ksize=3, pad=1, stride=1, nobias=True))
                self.enc2.append(F.relu)
                self.enc2.append(L.BatchNormalization(32))

            self.upsample = chainer.Sequential()
            self.upsample.append(L.Deconvolution2D(None, 32, ksize=2, stride=2))
            self.upsample.append(F.relu)
            self.upsample.append(L.BatchNormalization(32))

            self.concat = chainer.Sequential()
            self.concat.append(L.Convolution2D(None, 32, ksize=1, stride=1))
            self.concat.append(F.relu)
            self.concat.append(L.BatchNormalization(32))

            self.dec1 = chainer.Sequential()
            for i in range(2):
                self.dec1.append(L.Convolution2D(None, 32, ksize=3, pad=1, stride=1, nobias=True))
                self.dec1.append(F.relu)
                self.dec1.append(L.BatchNormalization(32))
                
            self.out = L.Convolution2D(None, num_classes+1, ksize=1, pad=0, stride=1, nobias=False)
Ejemplo n.º 2
0
    def test_addgrads(self):
        l1 = links.Linear(2, 3)
        l2 = links.Linear(3, 2)
        l3 = links.Linear(2, 3)
        s1 = chainer.Sequential(l1, l2)
        s2 = chainer.Sequential(s1, l3)
        l1.b.grad.fill(1)
        l2.W.grad.fill(2)
        l2.b.grad.fill(3)
        l3.W.grad.fill(4)
        l3.b.grad.fill(5)
        l1.W.grad.fill(6)

        self.l1.b.grad.fill(-1)
        self.l2.W.grad.fill(-2)
        self.l2.b.grad.fill(-3)
        self.l3.W.grad.fill(-4)
        self.l3.b.grad.fill(-5)
        self.l1.W.cleargrad()

        self.s2.addgrads(s2)
        numpy.testing.assert_array_equal(self.l1.b.grad, numpy.zeros((3, )))
        numpy.testing.assert_array_equal(self.l1.W.grad, l1.W.grad)
        numpy.testing.assert_array_equal(self.l2.W.grad, numpy.zeros((2, 3)))
        numpy.testing.assert_array_equal(self.l2.b.grad, numpy.zeros((2, )))
        numpy.testing.assert_array_equal(self.l3.W.grad, numpy.zeros((3, 2)))
        numpy.testing.assert_array_equal(self.l3.b.grad, numpy.zeros((3, )))
Ejemplo n.º 3
0
    def __init__(self,
                 in_channels,
                 out_channels,
                 nf0,
                 num_down,
                 max_channels,
                 norm=L.BatchNormalization,
                 outermost_linear=False):
        '''
        :param in_channels: Number of input channels
        :param out_channels: Number of output channels
        :param nf0: Number of features at highest level of U-Net
        :param num_down: Number of downsampling stages.
        :param max_channels: Maximum number of channels (channels multiply by 2 with every downsampling stage)
        :param norm: Which norm to use. If None, no norm is used. Default is Batchnorm with affinity.
        :param outermost_linear: Whether the output layer should be a linear layer or a nonlinear one.
        '''
        super().__init__()

        assert (num_down >
                0), "Need at least one downsampling layer in UNet3d."

        # Define the in block
        in_layer = [Conv3dSame(in_channels, nf0, kernel_size=3, bias=False)]

        if norm is not None:
            in_layer += [norm(nf0)]

        in_layer += [F.leaky_relu]

        # Define the center UNet block. The feature map has height and width 1 --> no batchnorm.
        unet_block = UnetSkipConnectionBlock3d(
            int(min(2**(num_down - 1) * nf0, max_channels)),
            int(min(2**(num_down - 1) * nf0, max_channels)),
            norm=None)
        for i in list(range(0, num_down - 1))[::-1]:
            unet_block = UnetSkipConnectionBlock3d(
                int(min(2**i * nf0, max_channels)),
                int(min(2**(i + 1) * nf0, max_channels)),
                submodule=unet_block,
                norm=norm)

        # Define the out layer. Each unet block concatenates its inputs with its outputs - so the output layer
        # automatically receives the output of the in_layer and the output of the last unet layer.
        out_layer = [
            Conv3dSame(2 * nf0,
                       out_channels,
                       kernel_size=3,
                       bias=outermost_linear)
        ]

        if not outermost_linear:
            if norm is not None:
                out_layer += [norm(out_channels)]
            out_layer += [F.relu]
        with self.init_scope():
            self.in_layer = chainer.Sequential(*in_layer)
            self.unet_block = unet_block
            self.out_layer = chainer.Sequential(*out_layer)
Ejemplo n.º 4
0
 def __init__(self,
              etype,
              idim,
              elayers,
              eunits,
              eprojs,
              subsample,
              dropout,
              in_channel=1):
     super(Encoder, self).__init__()
     typ = etype.lstrip("vgg").rstrip("p")
     if typ not in ['lstm', 'gru', 'blstm', 'bgru']:
         logging.error(
             "Error: need to specify an appropriate encoder architecture")
     with self.init_scope():
         if etype.startswith("vgg"):
             if etype[-1] == "p":
                 self.enc = chainer.Sequential(
                     VGG2L(in_channel),
                     RNNP(get_vgg2l_odim(idim, in_channel=in_channel),
                          elayers,
                          eunits,
                          eprojs,
                          subsample,
                          dropout,
                          typ=typ))
                 logging.info('Use CNN-VGG + ' + typ.upper() +
                              'P for encoder')
             else:
                 self.enc = chainer.Sequential(
                     VGG2L(in_channel),
                     RNN(get_vgg2l_odim(idim, in_channel=in_channel),
                         elayers,
                         eunits,
                         eprojs,
                         dropout,
                         typ=typ))
                 logging.info('Use CNN-VGG + ' + typ.upper() +
                              ' for encoder')
         else:
             if etype[-1] == "p":
                 self.enc = chainer.Sequential(
                     RNNP(idim,
                          elayers,
                          eunits,
                          eprojs,
                          subsample,
                          dropout,
                          typ=typ))
                 logging.info(typ.upper() +
                              ' with every-layer projection for encoder')
             else:
                 self.enc = chainer.Sequential(
                     RNN(idim, elayers, eunits, eprojs, dropout, typ=typ))
                 logging.info(typ.upper() +
                              ' without projection for encoder')
Ejemplo n.º 5
0
 def setUp(self):
     self.l1 = links.Linear(None, 3)
     self.l2 = links.Linear(3, 2)
     self.l3 = links.Linear(2, 3)
     # s1: l1 -> l2
     self.s1 = chainer.Sequential(self.l1)
     self.s1.append(self.l2)
     # s2: s1 (l1 -> l2) -> l3
     self.s2 = chainer.Sequential(self.s1)
     self.s2.append(self.l3)
Ejemplo n.º 6
0
def get_encoder_decoder(src_vocab_size,
                        tgt_vocab_size,
                        N=6,
                        model_size=512,
                        ff_size=2048,
                        num_heads=8,
                        dropout_ratio=0.1):
    """
        Convenience function that returns the full transformer model including encoder and decoder.
    :param src_vocab_size: the number of classes for the encoder
    :param tgt_vocab_size: the number of classes for the decoder
    :param N: stack size of the decoder
    :param model_size: the number of hidden units in the transformer
    :param ff_size: the number of hidden units in the PositionwiseFeedForward part of the decoder
    :param num_heads: number of attention heads in the attention parts of the model
    :param dropout_ratio: dropout ratio for regularization
    :return: the transformer model
    """
    attention = MultiHeadedAttention(num_heads,
                                     model_size,
                                     dropout_ratio=dropout_ratio)
    feed_forward = PositionwiseFeedForward(model_size,
                                           ff_size,
                                           dropout_ratio=dropout_ratio)
    positional_encoding = PositionalEncoding(model_size,
                                             dropout_ratio=dropout_ratio)

    encoder_layer = EncoderLayer(model_size,
                                 copy.deepcopy(attention),
                                 copy.deepcopy(feed_forward),
                                 dropout_ratio=dropout_ratio)
    encoder = Encoder(encoder_layer, N)

    decoder_layer = DecoderLayer(model_size,
                                 copy.deepcopy(attention),
                                 copy.deepcopy(attention),
                                 feed_forward,
                                 dropout_ratio=dropout_ratio)
    decoder = Decoder(decoder_layer, N)

    src_embeddings = Embedding(model_size, src_vocab_size)
    tgt_embeddings = Embedding(model_size, tgt_vocab_size)

    src_embeddings = chainer.Sequential(src_embeddings, positional_encoding)
    tgt_embeddings = chainer.Sequential(tgt_embeddings, positional_encoding)

    model = EncoderDecoder(encoder, decoder, src_embeddings, tgt_embeddings)

    return model
Ejemplo n.º 7
0
def get_network(model_name, **kwargs):
    if model_name == 'mv2':
        from pose.models.network_mobilenetv2 import MobilenetV2
        return MobilenetV2(**kwargs)
    elif model_name == 'resnet18':
        from pose.models.network_resnet import ResNet, AdditionalLayer
        resnet = chainer.Sequential(ResNet(n_layers=18),
                                    AdditionalLayer(ch=512))
        return resnet
    elif model_name == 'resnet34':
        from pose.models.network_resnet import ResNet, AdditionalLayer
        resnet = chainer.Sequential(ResNet(n_layers=34),
                                    AdditionalLayer(ch=512))
        return resnet
    else:
        raise Exception('Invalid model name')
Ejemplo n.º 8
0
 def test_init(self):
     self.assertIs(self.s1[0], self.l1)
     self.assertEqual(self.l1.name, '0')
     self.assertIs(self.s2[0], self.s1)
     self.assertEqual(self.s1.name, '0')
     with self.assertRaises(ValueError):
         chainer.Sequential(0)
    def __init__(self, in_ch, out_ch, stride):
        super(BasicBlock, self).__init__()
        reduction = 0.5
        self.stride = stride
        self.in_ch  = in_ch
        self.out_ch = out_ch
        if stride == 2:
            reduction = 1
        elif in_ch > out_ch:
            reduction = 0.25

        with self.init_scope():
            self.conv1 = L.Convolution2D(in_ch, int(in_ch * reduction),
                                         ksize=1, stride=stride, nobias=False)
            self.bn1   = L.BatchNormalization(int(in_ch * reduction))
            self.conv2 = L.Convolution2D(int(in_ch * reduction), int(in_ch * reduction * 0.5),
                                         ksize=1, stride=1, nobias=False)
            self.bn2   = L.BatchNormalization(int(in_ch * reduction * 0.5))
            self.conv3 = L.Convolution2D(int(in_ch * reduction * 0.5), int(in_ch * reduction),
                                         ksize=(1, 3), stride=1, pad=(0, 1), nobias=False)
            self.bn3   = L.BatchNormalization(int(in_ch * reduction))
            self.conv4 = L.Convolution2D(int(in_ch * reduction), int(in_ch * reduction),
                                         ksize=(3, 1), stride=1, pad=(1, 0), nobias=False)
            self.bn4   = L.BatchNormalization(int(in_ch * reduction))
            self.conv5 = L.Convolution2D(int(in_ch * reduction), out_ch,
                                         ksize=1, stride=1, nobias=False)
            self.bn5   = L.BatchNormalization(out_ch)

            self.shortcut = chainer.Sequential(lambda x: x)
            if stride == 2 or in_ch != out_ch:
                self.shortcut.append(L.Convolution2D(in_ch, out_ch, ksize=1, stride=stride, nobias=False))
                self.shortcut.append(L.BatchNormalization(out_ch))
Ejemplo n.º 10
0
    def test_insert(self):
        funcs = [
            functions.sin,
            functions.cos,
            functions.tan,
        ]
        # Prepare the original sequential before insertion.
        orig = []
        for orig_is_link in self.orig:
            if orig_is_link:
                orig.append(links.Linear((3, 3)))
            else:
                orig.append(funcs.pop(0))

        # The subject of insertion
        if self.is_link:
            subj = links.Linear((3, 3))
        else:
            subj = funcs.pop(0)

        # Instantiate the sequential
        seq = chainer.Sequential(*orig)

        if self.expect_error:
            with pytest.raises(IndexError):
                seq.insert(self.pos, subj)
        else:
            seq.insert(self.pos, subj)

            # Inserting to the `orig` similarly for the following comparison
            orig.insert(self.pos, subj)

            assert len(seq) == len(self.orig) + 1
            for i in range(len(self.orig) + 1):
                assert seq[i] is orig[i]
Ejemplo n.º 11
0
 def test_call_with_multiple_inputs(self):
     model = chainer.Sequential(
         lambda x, y: (x * 2, y * 3, x + y),
         lambda x, y, z: x + y + z
     )
     y = model(2, 3)
     self.assertEqual(y, 18)
Ejemplo n.º 12
0
def test_get_item_error(slices):
    model = chainer.Sequential(
        lambda x: F.get_item(x, slices=slices))
    x = input_generator.increasing(2, 3, 4)

    with pytest.raises(ValueError):
        export(model, x)
Ejemplo n.º 13
0
def build_decoder(vocab_size,
                  N=6,
                  model_size=512,
                  ff_size=2048,
                  num_heads=8,
                  dropout_ratio=0.1):
    attention = MultiHeadedAttention(num_heads,
                                     model_size,
                                     dropout_ratio=dropout_ratio)
    feed_forward = PositionwiseFeedForward(model_size,
                                           ff_size,
                                           dropout_ratio=dropout_ratio)
    positional_encoding = PositionalEncoding(model_size,
                                             dropout_ratio=dropout_ratio)

    decoder_layer = DecoderLayer(model_size,
                                 copy.deepcopy(attention),
                                 copy.deepcopy(attention),
                                 feed_forward,
                                 dropout_ratio=dropout_ratio)

    decoder = Decoder(decoder_layer, N)

    embeddings = Embedding(model_size, vocab_size)

    return chainer.Sequential(embeddings, positional_encoding), decoder
Ejemplo n.º 14
0
    def __init__(self, n_fg_class=None, pretrained_model=None):
        super(YOLOv3, self).__init__()

        param, path = utils.prepare_pretrained_model(
            {'n_fg_class': n_fg_class}, pretrained_model, self._models)

        self.n_fg_class = param['n_fg_class']
        self.use_preset('visualize')

        with self.init_scope():
            self.extractor = Darknet53Extractor()
            self.subnet = chainer.ChainList()

        for i, n in enumerate((512, 256, 128)):
            self.subnet.append(chainer.Sequential(
                Conv2DBNActiv(n * 2, 3, pad=1, activ=_leaky_relu),
                Convolution2D(
                    len(self._anchors[i]) * (4 + 1 + self.n_fg_class), 1)))

        default_bbox = []
        step = []
        for k, grid in enumerate(self.extractor.grids):
            for v, u in itertools.product(range(grid), repeat=2):
                for h, w in self._anchors[k]:
                    default_bbox.append((v, u, h, w))
                    step.append(self.insize / grid)
        self._default_bbox = np.array(default_bbox, dtype=np.float32)
        self._step = np.array(step, dtype=np.float32)

        if path:
            chainer.serializers.load_npz(path, self, strict=False)
Ejemplo n.º 15
0
    def __init__(self,
                 nf0,
                 occnet_nf,
                 frustrum_dims,
                 accmulative_threshold=None):
        super().__init__()

        self.occnet_nf = occnet_nf
        self.frustrum_dims = frustrum_dims
        self.frustrum_depth = frustrum_dims[-1]
        self.depth_coords = None
        self.accmulative_threshold = accmulative_threshold if accmulative_threshold else 4
        print(self.accmulative_threshold)

        with self.init_scope():
            self.occlusion = chainer.Sequential(
                Conv3dSame(nf0 + 1, self.occnet_nf, kernel_size=1, bias=True),
                # L.BatchNormalization(self.occnet_nf),
                F.leaky_relu,
                Conv3dSame(self.occnet_nf, 1, kernel_size=1, bias=True),
                lambda x: x - self.accmulative_threshold,
                F.sigmoid,
            )
        depth_coords = np.arange(
            -self.frustrum_depth // 2, self.frustrum_depth //
            2)[None, None, :, None, None] / self.frustrum_depth
        self.depth_coords = np.tile(depth_coords,
                                    (1, 1, 1, self.frustrum_dims[0],
                                     self.frustrum_dims[0])).astype("float32")
        self.register_persistent('depth_coords')
Ejemplo n.º 16
0
def create_model(weight='auto', activate=F.sigmoid):
    resnet = ResNet50Layers(pretrained_model=weight)
    model = chainer.Sequential(lambda x: resnet(x, layers=['res5'])['res5'],
                               L.Linear(None, 128))
    if activate:
        model.append(activate)
    return model
Ejemplo n.º 17
0
 def _make_layers(self, num_block, width_x, out_ch, stride):
     strides = [stride] + [1] * (num_block -1)
     layers  = chainer.Sequential()
     for _stride in strides:
         layers.append(BasicBlock(int(width_x * self.in_ch), int(width_x * out_ch), _stride))
         self.in_ch = out_ch
     return layers
Ejemplo n.º 18
0
    def __init__(self,
                 n_units: int,
                 num_hidden_layers: int = 3,
                 initialW: Union[None, ch.Initializer] = None,
                 initial_bias: Union[None, ch.Initializer] = None):
        """
        Constructor

        Parameters
        ----------
        n_units : int
            The number of units in the hidden layers. 256 was used in the paper.
        num_hidden_layers : int
            The number of hidden layers. 3 was used in the paper.
        initialW : ch.Initializer or None
            The initial value of the weights
        initial_bias : ch.Initializer or None
            The initial value of the biases
        """
        super(Encoder, self).__init__()

        linears = []
        with self.init_scope():
            layer = ch.Sequential(
                L.Linear(n_units, initialW=initialW,
                         initial_bias=initial_bias), F.sigmoid)
            self._hidden = layer.repeat(num_hidden_layers)
Ejemplo n.º 19
0
 def __init__(self,
              in_channels,
              out_channels,
              kernel_size,
              bias=True,
              padding_layer=None):
     '''
     :param in_channels: Number of input channels
     :param out_channels: Number of output channels
     :param kernel_size: Scalar. Spatial dimensions of kernel (only quadratic kernels supported).
     :param bias: Whether or not to use bias.
     :param padding_layer: Which padding to use. Default is reflection padding.
     '''
     super().__init__()
     if padding_layer is not None:
         assert False, "padding layer is not supported"
     ka = kernel_size // 2
     kb = ka - 1 if kernel_size % 2 == 0 else ka
     with self.init_scope():
         self.net = chainer.Sequential(
             ReflectionPad(pad_width=((ka, kb), (ka, kb), (ka, kb))),
             EqualizedConv3d(in_channels,
                             out_channels,
                             kernel_size,
                             stride=1,
                             nobias=not bias))
Ejemplo n.º 20
0
    def test_output(self, name, slices):
        name = 'get_item_' + name

        model = chainer.Sequential(lambda x: F.get_item(x, slices=slices))
        x = input_generator.increasing(2, 3, 4)

        self.expect(model, x, name=name, expected_num_initializers=0)
Ejemplo n.º 21
0
    def test_sequential(self):
        model = chainer.Sequential(
            chainer.links.Linear(3),
            chainer.functions.relu,
            chainer.links.Linear(4),
        )
        self.assertEqual(
            names_of_links(model),
            {'/0', '/1'}
        )
        self.assertIs(model._layers[1], chainer.functions.relu)
        to_factorized_noisy(model)
        self.assertEqual(
            names_of_links(model),
            {
                '/0', '/0/mu', '/0/sigma',
                '/1', '/1/mu', '/1/sigma',
            })
        self.assertIs(model._layers[1], chainer.functions.relu)
        model(numpy.ones((2, 3), numpy.float32))

        # assert new parameters are used
        y = model(numpy.ones((2, 3), numpy.float32))
        chainer.functions.sum(y).backward()
        for p in model.params():
            self.assertIsNotNone(p.grad)
Ejemplo n.º 22
0
 def _net_model(self):
     layer = chainer.Sequential(L.Linear(self.n_units), F.relu)
     model = layer.repeat(1)
     model.append(L.Linear(self.n_out))
     return L.Classifier(self._net_model(),
                         lossfun=F.sigmoid_cross_entropy,
                         accfun=F.binary_accuracy)
Ejemplo n.º 23
0
    def __init__(self,
                 idim,
                 attention_dim=256,
                 attention_heads=4,
                 linear_units=2048,
                 num_blocks=6,
                 dropout_rate=0.1,
                 positional_dropout_rate=0.1,
                 attention_dropout_rate=0.0,
                 input_layer="conv2d",
                 pos_enc_class=PositionalEncoding,
                 initialW=None,
                 initial_bias=None):
        """Initialize Encoder.

        Args:
            idim (int): Input dimension.
            args (Namespace): Training config.
            initialW (int, optional):  Initializer to initialize the weight.
            initial_bias (bool, optional): Initializer to initialize the bias.

        """
        super(Encoder, self).__init__()
        initialW = chainer.initializers.Uniform if initialW is None else initialW
        initial_bias = chainer.initializers.Uniform if initial_bias is None else initial_bias
        self.do_history_mask = False
        with self.init_scope():
            channels = 64  # Based in paper
            if input_layer == 'conv2d':
                idim = int(np.ceil(np.ceil(idim / 2) / 2)) * channels
                self.input_layer = Conv2dSubsampling(channels,
                                                     idim,
                                                     attention_dim,
                                                     dropout=dropout_rate,
                                                     initialW=initialW,
                                                     initial_bias=initial_bias)
            elif input_layer == 'linear':
                self.input_layer = LinearSampling(idim,
                                                  attention_dim,
                                                  initialW=initialW,
                                                  initial_bias=initial_bias)
            elif input_layer == "embed":
                self.input_layer = chainer.Sequential(
                    L.EmbedID(idim, attention_dim, ignore_label=-1),
                    pos_enc_class(attention_dim, positional_dropout_rate))
                self.do_history_mask = True
            else:
                raise ValueError("unknown input_layer: " + input_layer)
            self.norm = LayerNorm(attention_dim)
        for i in range(num_blocks):
            name = 'encoders.' + str(i)
            layer = EncoderLayer(attention_dim,
                                 d_units=linear_units,
                                 h=attention_heads,
                                 dropout=attention_dropout_rate,
                                 initialW=initialW,
                                 initial_bias=initial_bias)
            self.add_link(name, layer)
        self.n_layers = num_blocks
Ejemplo n.º 24
0
    def make_model(self, env):
        n_hidden_channels = 20
        obs_size = env.observation_space.low.size

        if self.recurrent:
            v = StatelessRecurrentSequential(
                L.NStepLSTM(1, obs_size, n_hidden_channels, 0),
                L.Linear(
                    None, 1, initialW=chainer.initializers.LeCunNormal(1e-1)),
            )
            if self.discrete:
                n_actions = env.action_space.n
                pi = StatelessRecurrentSequential(
                    L.NStepLSTM(1, obs_size, n_hidden_channels, 0),
                    policies.FCSoftmaxPolicy(
                        n_hidden_channels, n_actions,
                        n_hidden_layers=0,
                        nonlinearity=F.tanh,
                        last_wscale=1e-1,
                    )
                )
            else:
                action_size = env.action_space.low.size
                pi = StatelessRecurrentSequential(
                    L.NStepLSTM(1, obs_size, n_hidden_channels, 0),
                    policies.FCGaussianPolicy(
                        n_hidden_channels, action_size,
                        n_hidden_layers=0,
                        nonlinearity=F.tanh,
                        mean_wscale=1e-1,
                    )
                )
            return StatelessRecurrentBranched(pi, v)
        else:
            v = chainer.Sequential(
                L.Linear(None, n_hidden_channels),
                F.tanh,
                L.Linear(
                    None, 1, initialW=chainer.initializers.LeCunNormal(1e-1)),
            )
            if self.discrete:
                n_actions = env.action_space.n
                pi = policies.FCSoftmaxPolicy(
                    obs_size, n_actions,
                    n_hidden_layers=1,
                    n_hidden_channels=n_hidden_channels,
                    nonlinearity=F.tanh,
                    last_wscale=1e-1,
                )
            else:
                action_size = env.action_space.low.size
                pi = policies.FCGaussianPolicy(
                    obs_size, action_size,
                    n_hidden_layers=1,
                    n_hidden_channels=n_hidden_channels,
                    nonlinearity=F.tanh,
                    mean_wscale=1e-1,
                )
            return A3CSeparateModel(pi=pi, v=v)
Ejemplo n.º 25
0
 def test_output(self):
     model = chainer.Sequential(
         F.where
     )
     cond = np.array([[1, 0, 0], [0, 1, 0]], dtype=np.bool)
     x = input_generator.increasing(2, 3)
     y = np.zeros((2, 3), np.float32)
     self.expect(model, (cond, x, y), skip_opset_version=[7, 8])
Ejemplo n.º 26
0
    def _test_load_ppo(self, gpu):
        winit = chainerrl.initializers.Orthogonal(1.)
        winit_last = chainerrl.initializers.Orthogonal(1e-2)
        action_size = 3
        policy = chainer.Sequential(
            L.Linear(None, 64, initialW=winit),
            F.tanh,
            L.Linear(None, 64, initialW=winit),
            F.tanh,
            L.Linear(None, action_size, initialW=winit_last),
            policies.GaussianHeadWithStateIndependentCovariance(
                action_size=action_size,
                var_type='diagonal',
                var_func=lambda x: F.exp(2 * x),  # Parameterize log std
                var_param_init=0,  # log std = 0 => std = 1
            ),
        )

        vf = chainer.Sequential(L.Linear(None, 64, initialW=winit), F.tanh,
                                L.Linear(None, 64, initialW=winit), F.tanh,
                                L.Linear(None, 1, initialW=winit))

        model = links.Branched(policy, vf)

        opt = chainer.optimizers.Adam(3e-4, eps=1e-5)
        opt.setup(model)

        agent = agents.PPO(model,
                           opt,
                           obs_normalizer=None,
                           gpu=gpu,
                           update_interval=2048,
                           minibatch_size=64,
                           epochs=10,
                           clip_eps_vf=None,
                           entropy_coef=0,
                           standardize_advantages=True,
                           gamma=0.995,
                           lambd=0.97)

        model, exists = download_model("PPO",
                                       "Hopper-v2",
                                       model_type=self.pretrained_type)
        agent.load(model)
        if os.environ.get('CHAINERRL_ASSERT_DOWNLOADED_MODEL_IS_CACHED'):
            assert exists
Ejemplo n.º 27
0
    def test_load_trpo(self):
        winit = chainerrl.initializers.Orthogonal(1.)
        winit_last = chainerrl.initializers.Orthogonal(1e-2)
        action_size = 3
        policy = chainer.Sequential(
            L.Linear(None, 64, initialW=winit),
            F.tanh,
            L.Linear(None, 64, initialW=winit),
            F.tanh,
            L.Linear(None, action_size, initialW=winit_last),
            policies.GaussianHeadWithStateIndependentCovariance(
                action_size=action_size,
                var_type='diagonal',
                var_func=lambda x: F.exp(2 * x),  # Parameterize log std
                var_param_init=0,  # log std = 0 => std = 1
            ),
        )

        vf = chainer.Sequential(
            L.Linear(None, 64, initialW=winit),
            F.tanh,
            L.Linear(None, 64, initialW=winit),
            F.tanh,
            L.Linear(None, 1, initialW=winit),
        )
        vf_opt = chainer.optimizers.Adam()
        vf_opt.setup(vf)

        agent = agents.TRPO(policy=policy,
                            vf=vf,
                            vf_optimizer=vf_opt,
                            update_interval=5000,
                            max_kl=0.01,
                            conjugate_gradient_max_iter=20,
                            conjugate_gradient_damping=1e-1,
                            gamma=0.995,
                            lambd=0.97,
                            vf_epochs=5,
                            entropy_coef=0)

        model, exists = download_model("TRPO",
                                       "Hopper-v2",
                                       model_type=self.pretrained_type)
        agent.load(model)
        if os.environ.get('CHAINERRL_ASSERT_DOWNLOADED_MODEL_IS_CACHED'):
            assert exists
Ejemplo n.º 28
0
 def test_iadd(self):
     l4 = links.Linear(3, 1)
     self.s2 += chainer.Sequential(l4)
     self.assertIs(self.s2[0], self.s1)
     self.assertIs(self.s2[1], self.l3)
     self.assertIs(self.s2[2], l4)
     with self.assertRaises(ValueError):
         self.s2 += 0
Ejemplo n.º 29
0
 def test_extend(self):
     l1 = links.Linear(3, 2)
     l2 = links.Linear(2, 3)
     s3 = chainer.Sequential(l1, l2)
     self.s2.extend(s3)
     self.assertEqual(len(self.s2), 4)
     self.assertIs(self.s2[2], s3[0])
     self.assertIs(self.s2[3], s3[1])
Ejemplo n.º 30
0
    def make_agent(self, env, gpu):
        obs_size = env.observation_space.low.size
        action_size = env.action_space.low.size
        hidden_size = 20
        policy = chainer.Sequential(
            L.Linear(obs_size, hidden_size),
            F.relu,
            L.Linear(hidden_size,
                     action_size,
                     initialW=chainer.initializers.LeCunNormal(1e-1)),
            F.tanh,
            chainerrl.distribution.ContinuousDeterministicDistribution,
        )
        policy_optimizer = optimizers.Adam().setup(policy)
        policy_optimizer.add_hook(chainer.optimizer_hooks.GradientClipping(1))

        def make_q_func_with_optimizer():
            q_func = chainer.Sequential(
                concat_obs_and_action,
                L.Linear(obs_size + action_size, hidden_size),
                F.relu,
                L.Linear(hidden_size,
                         1,
                         initialW=chainer.initializers.LeCunNormal(1e-1)),
            )
            q_func_optimizer = optimizers.Adam(1e-2).setup(q_func)
            q_func_optimizer.add_hook(
                chainer.optimizer_hooks.GradientClipping(1))
            return q_func, q_func_optimizer

        q_func1, q_func1_optimizer = make_q_func_with_optimizer()
        q_func2, q_func2_optimizer = make_q_func_with_optimizer()

        rbuf = chainerrl.replay_buffer.ReplayBuffer(10**6)

        explorer = chainerrl.explorers.AdditiveGaussian(
            scale=0.3, low=env.action_space.low, high=env.action_space.high)

        def burnin_action_func():
            return np.random.uniform(env.action_space.low,
                                     env.action_space.high).astype(np.float32)

        agent = chainerrl.agents.TD3(
            policy=policy,
            q_func1=q_func1,
            q_func2=q_func2,
            policy_optimizer=policy_optimizer,
            q_func1_optimizer=q_func1_optimizer,
            q_func2_optimizer=q_func2_optimizer,
            replay_buffer=rbuf,
            explorer=explorer,
            gamma=0.5,
            minibatch_size=100,
            replay_start_size=100,
            burnin_action_func=burnin_action_func,
        )

        return agent