python类Link()的实例源码

def test_copyparams(self):
        l1 = chainer.Link(x=(2, 3))
        l2 = chainer.Link(x=2)
        l3 = chainer.Link(x=3)
        c1 = chainer.Chain(l1=l1, l2=l2)
        c2 = chainer.Chain(c1=c1, l3=l3)
        l1.x.data.fill(0)
        l2.x.data.fill(1)
        l3.x.data.fill(2)

        self.c2.copyparams(c2)

        numpy.testing.assert_array_equal(self.l1.x.data, l1.x.data)
        numpy.testing.assert_array_equal(self.l2.x.data, l2.x.data)
        numpy.testing.assert_array_equal(self.l3.x.data, l3.x.data)

def setUp(self):
        self.l1 = chainer.Link(x=(2, 3))
        self.l2 = chainer.Link(x=2)
        self.l3 = chainer.Link(x=3)
        self.c1 = chainer.ChainList(self.l1)
        self.c1.add_link(self.l2)
        self.c2 = chainer.ChainList(self.c1, self.l3)

def test_copyparams(self):
        l1 = chainer.Link(x=(2, 3))
        l2 = chainer.Link(x=2)
        l3 = chainer.Link(x=3)
        c1 = chainer.ChainList(l1, l2)
        c2 = chainer.ChainList(c1, l3)
        l1.x.data.fill(0)
        l2.x.data.fill(1)
        l3.x.data.fill(2)

        self.c2.copyparams(c2)

        numpy.testing.assert_array_equal(self.l1.x.data, l1.x.data)
        numpy.testing.assert_array_equal(self.l2.x.data, l2.x.data)
        numpy.testing.assert_array_equal(self.l3.x.data, l3.x.data)

def add(self, *layers):
        with self.init_scope():
            for i, layer in enumerate(layers):
                index = i + len(self.__layers__)

                if isinstance(layer, chainer.Link):
                    setattr(self, "_nn_layer_%d" % index, layer)

                if isinstance(layer, Residual):
                    for _index, _layer in enumerate(layer.__layers__):
                        if isinstance(_layer, chainer.Link):
                            setattr(self, "_nn_layer_{}_res_{}".format(index, _index), _layer)
        self.__layers__ += layers

def set_submodule_layers(self, namespace, module):
        with self.init_scope():
            for index, layer in enumerate(module.__layers__):
                if isinstance(layer, chainer.Link):
                    self.super__setattr__("_nn_{}_layer_{}".format(namespace, index), layer)

                if isinstance(layer, Residual):
                    for resnet_index, _layer in enumerate(layer.__layers__):
                        if isinstance(_layer, chainer.Link):
                            self.super__setattr__("_nn_{}_layer_{}_res_{}".format(namespace, index, resnet_index), _layer)

def set_submodule_links(self, namespace, module):
        with self.init_scope():
            for index, (link_name, link) in enumerate(module.__links__):
                assert isinstance(link, chainer.Link)
                self.super__setattr__("_nn_{}_link_{}".format(namespace, link_name), link)

def __setattr__(self, name, value):
        if self.within_init_scope and isinstance(value, Link):
            new_name = rename(name)

            if new_name == 'conv1_1/conv':
                # BGR -> RGB
                value.W.array[:, ::-1] = value.W.array
                print('{:s} -> {:s} (BGR -> RGB)'.format(name, new_name))
            else:
                print('{:s} -> {:s}'.format(name, new_name))
        else:
            new_name = name

        super(VGGCaffeFunction, self).__setattr__(new_name, value)

def create_multi_node_n_step_rnn(
        actual_link, communicator, rank_in=None, rank_out=None):
    """Create a multi node stacked RNN link from a Chainer stacked RNN link.

    Multi node stacked RNN link is used for model-parallel.
    The created link will receive initial hidden states from the process
    specified by ``rank_in`` (or do not receive if ``None``), execute
    the original RNN compuation, and then send resulting hidden states
    to the process specified by ``rank_out``.

    Compared with Chainer stacked RNN link, multi node stacked RNN link
    returns an extra object called ``delegate_variable``.
    If ``rank_out`` is not ``None``, backward computation is expected
    to be begun from ``delegate_variable``.
    For detail, please refer ``chainermn.functions.pseudo_connect``.

    The following RNN links can be passed to this function:

    - ``chainer.links.NStepBiGRU``
    - ``chainer.links.NStepBiLSTM``
    - ``chainer.links.NStepBiRNNReLU``
    - ``chainer.links.NStepBiRNNTanh``
    - ``chainer.links.NStepGRU``
    - ``chainer.links.NStepLSTM``
    - ``chainer.links.NStepRNNReLU``
    - ``chainer.links.NStepRNNTanh``

    Args:
        link (chainer.Link): Chainer stacked RNN link
        communicator: ChainerMN communicator
        rank_in (int, or None):
            Rank of the process which sends hidden RNN states to this process.
        rank_out (int, or None):
            Rank of the process to which this process sends hiddne RNN states.

    Returns:
        The multi node stacked RNN link based on ``actual_link``.
    """
    chainer.utils.experimental('chainermn.links.create_multi_node_n_step_rnn')
    return _MultiNodeNStepRNN(actual_link, communicator, rank_in, rank_out)

def add_link(self, link, rank_in=None, rank_out=None):
        """Register one connected link with its inout rank.

        Args:
            link (chainer.Link): The link object to be registered.
            rank_in (int, list, or None):
                Ranks from which it receives data. If None is specified,
                the model does not receive from any machines.
            rank_out (int, list, or None):
                Ranks to which it sends data. If None is specified,
                the model will not send to any machine.
        """
        super(MultiNodeChainList, self).add_link(link)
        if isinstance(rank_in, int):
            rank_in = [rank_in]
        if isinstance(rank_out, int):
            rank_out = [rank_out]

        if rank_out is None:
            for _, _rank_out in self._rank_inouts:
                if _rank_out is None:
                    raise ValueError(
                        'MultiNodeChainList cannot have more than two '
                        'computational graph component whose rank_out is None')

        self._rank_inouts.append((rank_in, rank_out))

def _namedpersistents(model):
    assert isinstance(model, chainer.Link)

    for lname, link in model.namedlinks():
        for pname in link._persistent:
            yield lname + '/' + pname, link.__dict__[pname]

def setUp(self):
        if self.accfun is None:
            self.link = SklearnWrapperClassifier(chainer.Link())
        else:
            self.link = SklearnWrapperClassifier(chainer.Link(),
                                         accfun=self.accfun)
        self.link.compute_accuracy = self.compute_accuracy

        self.x = numpy.random.uniform(-1, 1, (5, 10)).astype(numpy.float32)
        self.t = numpy.random.randint(3, size=5).astype(numpy.int32)

def set_params(self, **parameters):
        """set_params is used to set Grid parameters"""
        for parameter, value in parameters.items():
            if parameter == 'predictor':
                if isinstance(value, chainer.Link):
                    del self.predictor
                    with self.init_scope():
                        self.predictor = value
                else:
                    assert False, 'predictor is not Chain instance'
            elif parameter in ['lossfun', 'accfun', 'device']:
                setattr(self, parameter, value)
            else:
                self.sk_params.update({parameter: value})
        return self

def make_variable_list(model):
    variable_list = []
    for child in model.children():
        if isinstance(child, Chain):
            variable_list.extend(make_variable_list(child))
        if isinstance(child, Link):
            variable_list.extend(child.namedparams())
    return variable_list

def __fit(self, content_image, style_image, epoch_num, callback=None):
        xp = self.xp
        input_image = None
        height, width = content_image.shape[-2:]
        base_epoch = 0
        old_link = None
        for stride in [4, 2, 1][-self.resolution_num:]:
            if width // stride < 64:
                continue
            content_x = xp.asarray(content_image[:,:,::stride,::stride])
            if self.keep_color:
                style_x = util.luminance_only(xp.asarray(style_image[:,:,::stride,::stride]), content_x)
            else:
                style_x = xp.asarray(style_image[:,:,::stride,::stride])
            content_layer_names = self.content_layer_names
            with chainer.using_config('enable_backprop', False):
                content_layers = self.model(content_x)
            content_layers = [(name, content_layers[name]) for name in content_layer_names]
            style_layer_names = self.style_layer_names
            with chainer.using_config('enable_backprop', False):
                style_layers = self.model(style_x)
            style_grams = [(name, util.gram_matrix(style_layers[name])) for name in style_layer_names]
            if input_image is None:
                if self.initial_image == 'content':
                    input_image = xp.asarray(content_image[:,:,::stride,::stride])
                else:
                    input_image = xp.random.normal(0, 1, size=content_x.shape).astype(np.float32) * 0.001
            else:
                input_image = input_image.repeat(2, 2).repeat(2, 3)
                h, w = content_x.shape[-2:]
                input_image = input_image[:,:,:h,:w]
            link = chainer.Link(x=input_image.shape)
            if self.device_id >= 0:
                link.to_gpu()
            link.x.data[:] = xp.asarray(input_image)
            self.optimizer.setup(link)
            for epoch in six.moves.range(epoch_num):
                loss_info = self.__fit_one(link, content_layers, style_grams)
                if callback:
                    callback(base_epoch + epoch, link.x, loss_info)
            base_epoch += epoch_num
            input_image = link.x.data
        return link.x

def __fit(self, content_image, style_image, epoch_num, callback=None):
        xp = self.xp
        input_image = None
        height, width = content_image.shape[-2:]
        base_epoch = 0
        for stride in [4, 2, 1][-self.resolution_num:]:
            if width // stride < 64:
                continue
            content_x = xp.asarray(content_image[:,:,::stride,::stride])
            if self.keep_color:
                style_x = util.luminance_only(xp.asarray(style_image[:,:,::stride,::stride]), content_x)
            else:
                style_x = xp.asarray(style_image[:,:,::stride,::stride])
            content_layer_names = self.content_layer_names
            with chainer.using_config('enable_backprop', False):
                content_layers = self.model(content_x)
            content_layers = [(name, content_layers[name]) for name in content_layer_names]
            style_layer_names = self.style_layer_names
            with chainer.using_config('enable_backprop', False):
                style_layers = self.model(style_x)
            style_patches = []
            for name in style_layer_names:
                patch = util.patch(style_layers[name])
                patch_norm = F.expand_dims(F.sum(patch ** 2, axis=1) ** 0.5, 1)
                style_patches.append((name, patch, patch_norm))
            if input_image is None:
                if self.initial_image == 'content':
                    input_image = xp.asarray(content_image[:,:,::stride,::stride])
                else:
                    input_image = xp.random.uniform(-20, 20, size=content_x.shape).astype(np.float32)
            else:
                input_image = input_image.repeat(2, 2).repeat(2, 3)
                h, w = content_x.shape[-2:]
                input_image = input_image[:,:,:h,:w]
            link = chainer.Link(x=input_image.shape)
            if self.device_id >= 0:
                link.to_gpu()
            link.x.data[:] = xp.asarray(input_image)
            self.optimizer.setup(link)
            for epoch in six.moves.range(epoch_num):
                loss_info = self.__fit_one(link, content_layers, style_patches)
                if callback:
                    callback(base_epoch + epoch, link.x, loss_info)
            base_epoch += epoch_num
            input_image = link.x.data
        return link.x

def __init__(self, n_layers,  # ??
                 in_size,  # ?????????
                 out_size,  # ?????(?????????????)
                 dropout_rate,
                 name="",
                 use_cudnn=True):
        weights = []
        direction = 1  # ????????????????????1???
        t_name = name
        if name is not "":
            t_name = '%s_' % (name)

        for i in six.moves.range(n_layers):
            for di in six.moves.range(direction):
                weight = chainer.Link()
                for j in six.moves.range(8):
                    if i == 0 and j < 4:
                        w_in = in_size
                    elif i > 0 and j < 4:
                        w_in = out_size * direction
                    else:
                        w_in = out_size
                    weight.add_param('%sw%d' % (t_name, j), (out_size, w_in))
                    weight.add_param('%sb%d' % (t_name, j), (out_size,))
                    getattr(weight, '%sw%d' %
                            (t_name, j)).data[...] = np.random.normal(
                                0, np.sqrt(1. / w_in), (out_size, w_in))
                    getattr(weight, '%sb%d' % (t_name, j)).data[...] = 0
                weights.append(weight)

        super(NStepLSTMpp, self).__init__(*weights)

        self.n_layers = n_layers
        self.dropout_rate = dropout_rate
        self.use_cudnn = use_cudnn
        self.out_size = out_size
        self.direction = direction
        self.ws = [[getattr(w, '%sw0' % (t_name)),
                    getattr(w, '%sw1' % (t_name)),
                    getattr(w, '%sw2' % (t_name)),
                    getattr(w, '%sw3' % (t_name)),
                    getattr(w, '%sw4' % (t_name)),
                    getattr(w, '%sw5' % (t_name)),
                    getattr(w, '%sw6' % (t_name)),
                    getattr(w, '%sw7' % (t_name))] for w in self]
        self.bs = [[getattr(w, '%sb0' % (t_name)),
                    getattr(w, '%sb1' % (t_name)),
                    getattr(w, '%sb2' % (t_name)),
                    getattr(w, '%sb3' % (t_name)),
                    getattr(w, '%sb4' % (t_name)),
                    getattr(w, '%sb5' % (t_name)),
                    getattr(w, '%sb6' % (t_name)),
                    getattr(w, '%sb7' % (t_name))] for w in self]

def __init__(self,
                 predictor=None,
                 lossfun=softmax_cross_entropy.softmax_cross_entropy,
                 accfun=accuracy.accuracy,
                 device=-1,
                 **sk_params
                 ):
        """

        :param predictor (~chainer.links.Chain): 
        :param lossfun: loss function
        :param accfun: accuracy function. When `None` is set, accuracy is not 
        calculated during the training and `loassfun` is used for `score`.
        :param device (int): GPU device id. -1 indicates to use CPU.
        :param sk_params (dict): dict of parameters. This is used for 
        `GridSearchCV` and `RandomizedSearchCV` internally. 
        """
        super(SklearnBaseWrapper, self).__init__()
        if predictor is None:
            # Temporal counter measure to pass `check_estimator`,
            # sklearn need to support default constructor
            # TODO: Should dynamically asign n_out, instead of using magic parameter.
            predictor = chainer.links.Linear(None, self._default_n_out)
        if isinstance(predictor, chainer.Link):
            # print('[DEBUG] predictor instance')
            with self.init_scope():
                self.predictor = predictor
            self.predictor_constructor = predictor.__class__
        elif is_function(predictor) or issubclass(predictor, chainer.Link):
            # print('[DEBUG] predictor is constructor')
            self.predictor_constructor = predictor
        else:
            print("[ERROR] predictor should be either Chain class instance or"
                  "function which returns Chain class instance")
            assert False

        self.lossfun = lossfun
        self.accfun = accfun
        self.compute_accuracy = accfun is not None
        self.y = None
        self.loss = None
        self.accuracy = None
        self.inputs = None

        # Ensure initialization, necessary for GridSearch
        self.device = -1
        if hasattr(self, 'predictor'):
            self.predictor.to_cpu()
        self.update_device(device)

        self.sk_params = sk_params