def receive(self, x):
values = compute.compute_values(x)
gradients = compute.compute_gradients(x, values)
for param in gradients:
if isinstance(param, expr.parameter):
param.value -= self.learning_rate * gradients[param]
return values[x]
def receive(self, x):
values = compute.compute_values(x)
gradients = compute.compute_gradients(x, values)
for param in gradients:
if isinstance(param, expr.parameter):
if param not in self.sum_gradients2:
self.sum_gradients2[param] = numpy.full_like(param.value, self.delta)
self.sum_gradients2[param] += gradients[param] ** 2
param.value -= self.learning_rate * gradients[param] / numpy.sqrt(self.sum_gradients2[param])
return values[x]
def receive(self, x):
values = compute.compute_values(x)
gradients = compute.compute_gradients(x, values)
for param in self.velocities:
self.velocities[param] *= self.momentum_coeff
for param in gradients:
if isinstance(param, expr.parameter):
if param not in self.velocities:
self.velocities[param] = numpy.zeros_like(param.value)
self.velocities[param] -= self.learning_rate * gradients[param]
for param in self.velocities:
param.value += self.velocities[param]
return values[x]
def receive(self, x):
values = compute.compute_values(x)
gradients = compute.compute_gradients(x, values)
for param in gradients:
if isinstance(param, expr.parameter):
if param not in self.ave_gradients2:
self.ave_gradients2[param] = numpy.zeros_like(param.value)
if param not in self.ave_updates2:
self.ave_updates2[param] = numpy.zeros_like(param.value)
self.ave_gradients2[param] *= self.decay
self.ave_gradients2[param] += (1-self.decay) * gradients[param] ** 2
update = gradients[param] * numpy.sqrt((self.ave_updates2[param] + self.epsilon) /
(self.ave_gradients2[param] + self.epsilon))
self.ave_updates2[param] *= self.decay
self.ave_updates2[param] += (1-self.decay) * update ** 2
param.value -= update
return values[x]
"""Tile an array into nonoverlapping blocks and return the maximum
value of each block."""
rk = len(blockshape)
return amax(pool(a, blockshape), axis=tuple(range(rk, rk*2)))
def mean_pool(a, blockshape):
"""Tile an array into nonoverlapping blocks and return the mean
value of each block."""
rk = len(blockshape)
return mean(pool(a, blockshape), axis=tuple(range(rk, rk*2)))
if __name__ == "__main__":
import compute
from expr import parameter
a = parameter(numpy.random.uniform(-1., 1., (16, 16)))
b = convolve(a, constant(numpy.random.uniform(-1., 1., (3, 3))), mode='full')
c = max_pool(b, (2, 2))
#d = b * constant(numpy.random.uniform(-1., 1., (18, 18)))
o = asum(c)
values = compute.compute_values(o)
auto = compute.compute_gradients(o, values)[a]
check = compute.check_gradients(o)[a]
d = (auto-check).ravel()
print "error:", d.dot(d)
