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)
import compute import loader import plotter dataset = loader.load_dataset('patient_1') data = dataset["data"] mask = dataset["mask"] threshold = 95.0 scaled = compute.to_hounsfield_units(data) masked = list(map(lambda i: compute.apply_mask(i, mask, threshold), scaled)) gradients = compute.compute_gradients(masked) masked_gradients = list( map(lambda i: compute.apply_mask(i, mask, threshold), gradients)) def slicer(arr): return arr[30, :, :] scaled_slices = list(map(slicer, scaled)) masked_slices = list(map(slicer, masked)) gradient_slices = list(map(slicer, masked_gradients)) plotter.plot(scaled_slices, masked_slices, gradient_slices) plotter.show()