def init_state(self, param, state):
xp = cuda.get_array_module(param.data)
with cuda.get_device(param.data):
state['n'] = xp.zeros_like(param.data)
state['g'] = xp.zeros_like(param.data)
state['delta'] = xp.zeros_like(param.data)
python类get_device()的实例源码
def init_state(self, param, state):
xp = cuda.get_array_module(param.data)
with cuda.get_device(param.data):
state['v'] = xp.zeros_like(param.data)
def init_state(self, param, state):
xp = cuda.get_array_module(param.data)
with cuda.get_device(param.data):
state['m'] = xp.zeros_like(param.data)
state['v'] = xp.zeros_like(param.data)
def init_state(self, param, state):
xp = cuda.get_array_module(param.data)
with cuda.get_device(param.data):
state['h'] = xp.zeros_like(param.data)
def init_state(self, param, state):
data = param.data
xp = cuda.get_array_module(data)
with cuda.get_device(data):
state['msg'] = xp.zeros_like(data)
state['msdx'] = xp.zeros_like(data)
def _sum_sqnorm(arr):
sq_sum = collections.defaultdict(float)
for x in arr:
with cuda.get_device(x) as dev:
x = x.ravel()
s = x.dot(x)
sq_sum[int(dev)] += s
return sum([float(i) for i in six.itervalues(sq_sum)])
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 update(self, lossfun=None, *args, **kwds):
"""Updates parameters based on a loss function or computed gradients.
This method runs in two ways.
- If ``lossfun`` is given, then use it as a loss function to compute
gradients.
- Otherwise, this method assumes that the gradients are already
computed.
In both cases, the computed gradients are used to update parameters.
The actual update routines are defined by the :meth:`update_one`
method (or its CPU/GPU versions, :meth:`update_one_cpu` and
:meth:`update_one_gpu`).
"""
if lossfun is not None:
self.target.zerograds()
loss = lossfun(*args, **kwds)
loss.backward()
del loss
self.call_hooks()
self.prepare()
self.t += 1
states = self._states
for name, param in self.target.namedparams():
with cuda.get_device(param.data):
self.update_one(param, states[name])
def __call__(self, opt):
if cuda.available:
kernel = cuda.elementwise(
'T p, T decay', 'T g', 'g += decay * p', 'weight_decay')
rate = self.rate
for param in opt.target.params():
p, g = param.data, param.grad
with cuda.get_device(p) as dev:
if int(dev) == -1:
g += rate * p
else:
kernel(p, rate, g)
def __call__(self, opt):
if cuda.available:
kernel = cuda.elementwise(
'T s, T decay', 'T g', 'g += decay * s', 'lasso')
rate = self.rate
for param in opt.target.params():
p, g = param.data, param.grad
xp = cuda.get_array_module(p)
sign = xp.sign(p)
with cuda.get_device(p) as dev:
if int(dev) == -1:
g += rate * sign
else:
kernel(sign, rate, g)
def __call__(self, opt):
norm = numpy.sqrt(_sum_sqnorm([p.grad for p in opt.target.params()]))
rate = self.threshold / norm
if rate < 1:
for param in opt.target.params():
grad = param.grad
with cuda.get_device(grad):
grad *= rate
def backward_gpu(self, x, gy):
if self.out_device == -1:
return cuda.to_gpu(gy[0], device=cuda.get_device(x[0])),
else:
return cuda.copy(gy[0], out_device=cuda.get_device(x[0])),
def to_gpu(self, device=None):
"""Copies the data and gradient arrays to specified GPU.
Args:
device: Target device specifier. If omitted, the current device is
used.
"""
with cuda.get_device(device):
self.data = cuda.to_gpu(self.data)
if self._grad is not None:
self._grad = cuda.to_gpu(self._grad)
def zerograd(self):
"""Initializes the gradient array by zeros."""
with cuda.get_device(self.data) as dev:
if self._grad is None:
xp = numpy if int(dev) == -1 else cuda.cupy
self._grad = xp.zeros_like(self.data)
else:
self._grad.fill(0)
test_optimizers_by_linear_model.py 文件源码
项目：chainer-deconv
作者: germanRos
项目源码
文件源码
阅读 20
收藏 0
点赞 0
评论 0
def accuracy_gpu(self, device=None):
model = self.model
optimizer = self.optimizer
model.to_gpu(device=device)
optimizer.setup(model)
with cuda.get_device(device):
return self._train_linear_classifier(model, optimizer, True)
def test_get_dummy_device(self):
if not cuda.available:
self.assertIs(cuda.get_device(), cuda.DummyDevice)
def test_get_dummy_device_for_empty_array(self):
x = cuda.cupy.array([]).reshape((0, 10))
self.assertIs(cuda.get_device(x), cuda.DummyDevice)
def test_to_gpu_from_another_gpu(self):
cp = cuda.cupy
a = chainer.Variable(cp.zeros(3, dtype=np.float32))
a.grad = cuda.cupy.ones_like(a.data)
b = a.data.copy()
gb = a.grad.copy()
a.to_gpu(1)
self.assertEqual(int(cuda.get_device(a.data)), 1)
self.assertEqual(int(cuda.get_device(a.grad)), 1)
cp.testing.assert_array_equal(a.data, b)
cp.testing.assert_array_equal(a.grad, gb)
def test_zerograds_multi_gpu(self):
cupy = cuda.cupy
with cuda.get_device(1):
a = chainer.Variable(cupy.empty(3, dtype=np.float32))
a.zerograd()
self.assertIsNot(a.grad, None)
self.assertEqual(int(a.grad.device), 1)
with cuda.get_device(1):
g_expect = cupy.zeros_like(a.data)
cupy.testing.assert_array_equal(a.grad, g_expect)
def test_zerograds_fill_multi_gpu(self):
cupy = cuda.cupy
with cuda.get_device(1):
a = chainer.Variable(cupy.empty(3, dtype=np.float32))
a.grad = cupy.empty_like(a.data)
a.zerograd()
self.assertEqual(int(a.grad.device), 1)
with cuda.get_device(1):
g_expect = cupy.zeros_like(a.data)
cupy.testing.assert_array_equal(a.grad, g_expect)
