def visualize_layer_activations(model, im, layer_idx):
"""Compute the activations for each feature map for the given layer for
this particular image. Note that the input x should be a mini-batch
of size one, i.e. a single image.
"""
if model._device_id is not None and model._device_id >= 0: # Using GPU
im = cuda.cupy.array(im)
activations = model.activations(Variable(im), layer_idx)
if isinstance(activations, cuda.ndarray):
activations = cuda.cupy.asnumpy(activations)
# Rescale to [0, 255]
activations -= activations.min()
activations /= activations.max()
activations *= 255
return activations.astype(np.uint8)
python类ndarray()的实例源码
def to_cpu(self):
"""Copies parameter variables and persistent values to CPU.
This method does not handle non-registered attributes. If some of such
attributes must be copied to CPU, the link implementation must
override this method to do so.
Returns: self
"""
if self._cpu:
return self
d = self.__dict__
for name in self._params:
d[name].to_cpu()
for name in self._persistent:
value = d[name]
if isinstance(value, cuda.ndarray):
d[name] = value.get()
self._cpu = True
return self
def __init__(self, in_size, out_size, pool_size,
wscale=1, initialW=None, initial_bias=0):
linear_out_size = out_size * pool_size
if initialW is not None:
initialW = initialW.reshape(linear_out_size, in_size)
if initial_bias is not None:
if numpy.isscalar(initial_bias):
initial_bias = numpy.full(
(linear_out_size,), initial_bias, dtype=numpy.float32)
elif isinstance(initial_bias, (numpy.ndarray, cuda.ndarray)):
initial_bias = initial_bias.reshape(linear_out_size)
else:
raise ValueError(
'initial bias must be float, ndarray, or None')
super(Maxout, self).__init__(
linear=linear.Linear(
in_size, linear_out_size, wscale,
nobias=initial_bias is None, initialW=initialW,
initial_bias=initial_bias))
self.out_size = out_size
self.pool_size = pool_size
def forward(self, inputs):
"""Applies forward propagation to input arrays.
It delegates the procedure to :meth:`forward_cpu` or
:meth:`forward_gpu` by default. Which it selects is determined by the
type of input arrays.
Implementations of :class:`Function` must implement either CPU/GPU
methods or this method.
Args:
inputs: Tuple of input array(s).
Returns:
Tuple of output array(s).
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
if any(isinstance(x, cuda.ndarray) for x in inputs):
return self.forward_gpu(inputs)
else:
return self.forward_cpu(inputs)
def forward_cpu(self, inputs):
"""Applies forward propagation to input arrays on CPU.
Args:
inputs: Tuple of :class:`numpy.ndarray` object(s).
Returns:
tuple: Tuple of :class:`numpy.ndarray` object(s).
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
raise NotImplementedError()
def backward_cpu(self, inputs, grad_outputs):
"""Applies backprop to output gradient arrays on CPU.
Args:
inputs: Tuple of input :class:`numpy.ndarray` object(s).
grad_outputs: Tuple of output gradient :class:`numpy.ndarray`
object(s).
Returns:
tuple: Tuple of input gradient :class:`numpy.ndarray` object(s).
Some or all of them can be ``None``, if the function is not
differentiable on corresponding inputs.
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
return tuple(None for _ in inputs)
def backward_gpu(self, inputs, grad_outputs):
"""Applies backprop to output gradient arrays on GPU.
Args:
inputs: Tuple of input :class:`cupy.ndarray`
object(s).
grad_outputs: Tuple of output gradient
:class:`cupy.ndarray` object(s).
Returns:
tuple: Tuple of input gradient :class:`cupy.ndarray`
object(s). Some or all of them can be ``None``, if the function is
not differentiable on corresponding inputs.
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
return tuple(None for _ in inputs)
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0,
wscale=1, bias=0, nobias=False, outsize=None, use_cudnn=True,
initialV=None, dtype=np.float32):
kh, kw = _pair(ksize)
self.stride = _pair(stride)
self.pad = _pair(pad)
self.outsize = (None, None) if outsize is None else outsize
self.use_cudnn = use_cudnn
self.dtype = dtype
self.nobias = nobias
self.out_channels = out_channels
self.in_channels = in_channels
V_shape = (in_channels, out_channels, kh, kw)
super(Deconvolution2D, self).__init__(V=V_shape)
if isinstance(initialV, (np.ndarray, cuda.ndarray)):
assert initialV.shape == (in_channels, out_channels, kh, kw)
initializers.init_weight(self.V.data, initialV, scale=math.sqrt(wscale))
if nobias:
self.b = None
else:
self.add_uninitialized_param("b")
self.add_uninitialized_param("g")
def __init__(self, left_size, right_size, out_size,
nobias=(False, False, False),
initialW=None, initial_bias=None):
super(Biaffine, self).__init__()
self.in_sizes = (left_size, right_size)
self.out_size = out_size
self.nobias = nobias
with self.init_scope():
shape = (left_size + int(not(self.nobias[0])),
right_size + int(not(self.nobias[1])),
out_size)
if isinstance(initialW, (np.ndarray, cuda.ndarray)):
assert initialW.shape == shape
self.W = variable.Parameter(
initializers._get_initializer(initialW), shape)
if not self.nobias[2]:
if initial_bias is None:
initial_bias = 0
self.b = variable.Parameter(initial_bias, (self.out_size,))
else:
self.b = None
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0,
wscale=1, bias=0, nobias=False, outsize=None, use_cudnn=True,
initialV=None, dtype=np.float32):
kh, kw = _pair(ksize)
self.stride = _pair(stride)
self.pad = _pair(pad)
self.outsize = (None, None) if outsize is None else outsize
self.use_cudnn = use_cudnn
self.dtype = dtype
self.nobias = nobias
self.out_channels = out_channels
self.in_channels = in_channels
V_shape = (in_channels, out_channels, kh, kw)
super(Deconvolution2D, self).__init__(V=V_shape)
if isinstance(initialV, (np.ndarray, cuda.ndarray)):
assert initialV.shape == (in_channels, out_channels, kh, kw)
initializers.init_weight(self.V.data, initialV, scale=math.sqrt(wscale))
if nobias:
self.b = None
else:
self.add_uninitialized_param("b")
self.add_uninitialized_param("g")
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0,
wscale=1, bias=0, nobias=False, outsize=None, use_cudnn=True,
initialV=None, dtype=np.float32):
kh, kw = _pair(ksize)
self.stride = _pair(stride)
self.pad = _pair(pad)
self.outsize = (None, None) if outsize is None else outsize
self.use_cudnn = use_cudnn
self.dtype = dtype
self.nobias = nobias
self.out_channels = out_channels
self.in_channels = in_channels
V_shape = (in_channels, out_channels, kh, kw)
super(Deconvolution2D, self).__init__(V=V_shape)
if isinstance(initialV, (np.ndarray, cuda.ndarray)):
assert initialV.shape == (in_channels, out_channels, kh, kw)
initializers.init_weight(self.V.data, initialV, scale=math.sqrt(wscale))
if nobias:
self.b = None
else:
self.add_uninitialized_param("b")
self.add_uninitialized_param("g")
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0,
wscale=1, bias=0, nobias=False, outsize=None, use_cudnn=True,
initialV=None, dtype=np.float32):
kh, kw = _pair(ksize)
self.stride = _pair(stride)
self.pad = _pair(pad)
self.outsize = (None, None) if outsize is None else outsize
self.use_cudnn = use_cudnn
self.dtype = dtype
self.nobias = nobias
self.out_channels = out_channels
self.in_channels = in_channels
V_shape = (in_channels, out_channels, kh, kw)
super(Deconvolution2D, self).__init__(V=V_shape)
if isinstance(initialV, (np.ndarray, cuda.ndarray)):
assert initialV.shape == (in_channels, out_channels, kh, kw)
initializers.init_weight(self.V.data, initialV, scale=math.sqrt(wscale))
if nobias:
self.b = None
else:
self.add_uninitialized_param("b")
self.add_uninitialized_param("g")
def check_add_deconv_layers(self, nobias=True):
"""Add a deconvolutional layer for each convolutional layer already
defined in the network."""
if len(self.deconv_blocks) == len(self.conv_blocks):
return
for conv_block in self.conv_blocks:
deconv_block = []
for conv in conv_block:
out_channels, in_channels, kh, kw = conv.W.data.shape
if isinstance(conv.W.data, cuda.ndarray):
initialW = cuda.cupy.asnumpy(conv.W.data)
else:
initialW = conv.W.data
deconv = L.Deconvolution2D(out_channels, in_channels,
(kh, kw), stride=conv.stride,
pad=conv.pad,
initialW=initialW,
nobias=nobias)
if isinstance(conv.W.data, cuda.ndarray):
deconv.to_gpu()
self.add_link('de{}'.format(conv.name), deconv)
deconv_block.append(deconv)
self.deconv_blocks.append(deconv_block)
def sample(self, trainer):
x = trainer.updater.sample()
x = x.data
if cuda.available and isinstance(x, cuda.ndarray):
x = cuda.to_cpu(x)
return x
def __call__(self, key, value):
ret = value
if isinstance(value, cuda.ndarray):
value = cuda.to_cpu(value)
arr = numpy.asarray(value)
compression = None if arr.size <= 1 else self.compression
self.group.create_dataset(key, data=arr, compression=compression)
return ret
def __call__(self, key, value):
dataset = self.group[key]
if isinstance(value, numpy.ndarray):
dataset.read_direct(value)
elif isinstance(value, cuda.ndarray):
value.set(numpy.asarray(dataset))
else:
value = type(value)(numpy.asarray(dataset))
return value
def __call__(self, key, value):
key = key.lstrip('/')
ret = value
if isinstance(value, cuda.ndarray):
value = value.get()
arr = numpy.asarray(value)
self.target[self.path + key] = arr
return ret
def __call__(self, key, value):
key = key.lstrip('/')
dataset = self.npz[self.path + key]
if isinstance(value, numpy.ndarray):
numpy.copyto(value, dataset)
elif isinstance(value, cuda.ndarray):
value.set(numpy.asarray(dataset))
else:
value = type(value)(numpy.asarray(dataset))
return value
def __init__(self, left_size, right_size, out_size, nobias=False,
initialW=None, initial_bias=None):
super(Bilinear, self).__init__(W=(left_size, right_size, out_size))
self.in_sizes = (left_size, right_size)
self.nobias = nobias
# TODO(Kenta OONO): I do not know appropriate way of
# initializing weights in tensor network.
# This initialization is a modification of
# that of Linear function.
if isinstance(initialW, (numpy.ndarray, cuda.ndarray)):
assert initialW.shape == self.W.data.shape
initializers.init_weight(self.W.data, initialW)
if not self.nobias:
self.add_param('V1', (left_size, out_size))
self.add_param('V2', (right_size, out_size))
self.add_param('b', out_size)
if isinstance(initial_bias, tuple):
V1, V2, b = initial_bias
elif initial_bias is None:
V1 = V2 = None
b = 0
else:
raise ValueError('initial_bias must be tuple or None')
if isinstance(V1, (numpy.ndarray, cuda.ndarray)):
assert V1.shape == self.V1.data.shape
if isinstance(V2, (numpy.ndarray, cuda.ndarray)):
assert V2.shape == self.V2.data.shape
if isinstance(b, (numpy.ndarray, cuda.ndarray)):
assert b.shape == self.b.data.shape
initializers.init_weight(self.V1.data, V1)
initializers.init_weight(self.V2.data, V2)
initializers.init_weight(self.b.data, b)
def __init__(self, array):
super(Parameter, self).__init__()
self.add_param('W', array.shape, dtype=array.dtype)
self.W.data = array
if isinstance(array, cuda.ndarray):
self.to_gpu(array)
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0,
wscale=1, bias=0, nobias=False, outsize=None, use_cudnn=True,
initialW=None, initial_bias=None):
kh, kw = _pair(ksize)
self.stride = _pair(stride)
self.pad = _pair(pad)
self.outsize = (None, None) if outsize is None else outsize
self.use_cudnn = use_cudnn
W_shape = (in_channels, out_channels, kh, kw)
super(Deconvolution2D, self).__init__(W=W_shape)
if isinstance(initialW, (numpy.ndarray, cuda.ndarray)):
assert initialW.shape == (in_channels, out_channels, kh, kw)
# For backward compatibility, the scale of weights is proportional to
# the square root of wscale.
initializers.init_weight(self.W.data, initialW,
scale=math.sqrt(wscale))
if nobias:
self.b = None
else:
self.add_param('b', out_channels)
if isinstance(initial_bias, (numpy.ndarray, cuda.ndarray)):
assert initial_bias.shape == (out_channels,)
if initial_bias is None:
initial_bias = bias
initializers.init_weight(self.b.data, initial_bias)
def prepare(self):
"""Prepares for an update.
This method initializes missing optimizer states (e.g. for newly added
parameters after the set up), and copies arrays in each state
dictionary to CPU or GPU according to the corresponding parameter
array.
"""
states = self._states
for name, param in self.target.namedparams():
if name not in states:
state = {}
self.init_state(param, state)
states[name] = state
else:
state = states[name]
with cuda.get_device(param.data) as dev:
if int(dev) == -1: # cpu
for key, value in six.iteritems(state):
if isinstance(value, cuda.ndarray):
state[key] = value.get()
else: # gpu
cupy = cuda.cupy
for key, value in six.iteritems(state):
if isinstance(value, numpy.ndarray):
state[key] = cuda.to_gpu(value)
elif (isinstance(value, cupy.ndarray) and
value.device != dev):
state[key] = cupy.copy(value)
def init_state_gpu(self, param, state):
"""Initializes the optimizer state on GPU.
This method is called from :meth:`init_state` by default.
Args:
param (~chainer.Variable): Parameter variable. Its data array is
of type :class:`cupy.ndarray`.
state (dict): State dictionary.
.. seealso:: :meth:`init_state`
"""
pass
def accumulate_grads(self, grads):
"""Accumulates gradients from other source.
This method just adds given gradient arrays to gradients that this
optimizer holds. It is typically used in data-parallel optimization,
where gradients for different shards are computed in parallel and
aggregated by this method. This method correctly treats multiple GPU
devices.
Args:
grads (Iterable): Iterable of gradient arrays to be accumulated.
.. deprecated:: v1.5
Use the :meth:`chainer.Link.addgrads` method of the target link
instead.
"""
for param, g_src in zip(self.target.params(), grads):
g_dst = param.grad
if isinstance(g_dst, numpy.ndarray):
g_dst += cuda.to_cpu(g_src)
continue
with cuda.get_device(g_dst):
if (isinstance(g_src, cuda.ndarray) and
g_dst.device != g_src.device):
g_dst += cuda.copy(g_src, out_device=g_dst.device)
else:
g_dst += cuda.to_gpu(g_src)
def update_one(self, param, state):
"""Updates a parameter based on the corresponding gradient and state.
This method calls appropriate one from :meth:`update_param_cpu` or
:meth:`update_param_gpu`.
Args:
param (~chainer.Variable): Parameter variable.
state (dict): State dictionary.
"""
if isinstance(param.data, numpy.ndarray):
self.update_one_cpu(param, state)
else:
self.update_one_gpu(param, state)
def backward(self, inputs, grad_outputs):
# In this function, `grad_outputs` contains cuda arrays even when
# `inputs` only contains numpy arrays.
if isinstance(inputs[0], cuda.ndarray):
return self.backward_gpu(inputs, grad_outputs)
else:
return self.backward_cpu(inputs, grad_outputs)
def _check_constant_type(value):
if numpy.isscalar(value):
return
elif isinstance(value, (numpy.ndarray, cuda.ndarray)):
return
else:
raise ValueError(
'value must be scalar, ndarray, or Variable')
def empty_like(x):
if cuda.available and isinstance(x, cuda.ndarray):
return cuda.cupy.empty_like(x)
else:
return numpy.empty_like(x)
def _get_type(name, index, array, accept_none):
var = '{0}[{1}]'.format(name, index)
if accept_none and array is None:
# case that gradient is not given
return Variable(TypeInfo((), None), var)
assert(isinstance(array, numpy.ndarray) or
isinstance(array, cuda.ndarray))
return Variable(TypeInfo(array.shape, array.dtype), var)
def backward(self, inputs, grad_outputs):
"""Applies backprop to output gradient arrays.
It delegates the procedure to :meth:`backward_cpu` or
:meth:`backward_gpu` by default. Which it selects is determined by the
type of input arrays and output gradient arrays. Implementations of
:class:`Function` must implement either CPU/GPU methods or this method,
if the function is intended to be backprop-ed.
Args:
inputs: Tuple of input arrays.
grad_outputs: Tuple of output gradient arrays.
Returns:
tuple: Tuple of input gradient arrays. Some or all of them can be
``None``, if the function is not differentiable on
inputs.
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
if any(isinstance(x, cuda.ndarray) for x in inputs + grad_outputs):
return self.backward_gpu(inputs, grad_outputs)
else:
return self.backward_cpu(inputs, grad_outputs)
