def _step(self, inp): self.outs = [] for i in range(self.max_iter): self.s = np.sum(self.np['w'] * inp, axis=1) self.s += self.np['b'] out = self.transf(self.s) if i > 0 and np.abs(out - inp).sum() <= self.delta: break self.outs.append(out) inp = out return out
def euclidean(A, B): """ Euclidean distance function. See scipi.spatial.distance.cdist() :Example: >>> from neurolab import mynp as np >>> euclidean(np.array([0,0]), np.array([[0,1], [0, 5.5]])).tolist() [1.0, 5.5] """ return np.sqrt(np.sum(np.square(A-B) ,axis=1))
def ff_grad_step(net, out, tar, grad=None): """ Calc gradient with backpropogete method, for feed-forward neuran networks on each step :Parametrs: net: Net Feed-forward network inp: array, size = net.ci Input array tar: array, size = net.co Train target deriv: callable Derivative of error function grad:list of dict default(None) Grad on previous step :Returns: grad: list of dict Gradient of net for each layer, format:[{'w':..., 'b':...},{'w':..., 'b':...},...] """ delt = [None] * len(net.layers) if grad is None: grad = [] for i, l in enumerate(net.layers): grad.append({}) for k, v in l.np.items(): grad[i][k] = np.zeros(v.shape) e = out - tar # for output layer ln = len(net.layers) - 1 layer = net.layers[ln] delt[ln] = net.errorf.deriv(e) * layer.transf.deriv(layer.s, out) delt[ln] = delt[ln].reshape((delt[ln].size, 1,)) #replacement for " delt[ln].shape = delt[ln].size, 1" grad[ln]['w'] += delt[ln] * layer.inp grad[ln]['b'] += delt[ln].reshape(delt[ln].size) bp = range(len(net.layers) -2, -1, -1) for ln in bp: layer = net.layers[ln] next = ln + 1 dS = np.sum(net.layers[next].np['w'] * delt[next], axis=0) delt[ln] = dS * layer.transf.deriv(layer.s, layer.out) delt[ln] = delt[ln].reshape((delt[ln].size, 1,)) #replacement for " delt[ln].shape = delt[ln].size, 1" grad[ln]['w'] += delt[ln] * layer.inp grad[ln]['b'] += delt[ln].reshape(delt[ln].size) return grad
def newhop(target, transf=None, max_init=10, delta=0): """ Create a Hopfield recurrent network :Parameters: target: array like (l x net.co) train target patterns transf: func (default HardLims) Activation function max_init: int (default 10) Maximum of recurent iterations delta: float (default 0) Minimum diference between 2 outputs for stop reccurent cycle :Returns: net: Net :Example: >>> net = newhem([[-1, -1, -1], [1, -1, 1]]) >>> output = net.sim([[-1, 1, -1], [1, -1, 1]]) """ target = np.asfarray(target) assert target.ndim == 2 ci = len(target[0]) if transf is None: transf = trans.HardLims() l = layer.Reccurent(ci, ci, transf, max_init, delta) w = l.np['w'] b = l.np['b'] # init weight for i in range(ci): for j in range(ci): if i == j: w[i, j] = 0.0 else: w[i, j] = np.sum(target[:, i] * target[:, j]) / ci b[i] = 0.0 l.initf = None minmax = transf.out_minmax if hasattr(transf, 'out_minmax') else [-1, 1] net = Net([minmax] * ci, ci, [l], [[-1], [0]], None, None) return net
def newhop_old(target, transf=None): """ Create a Hopfield recurrent network. Old version need tool.simhop for use. Will be removed in future versions. :Parameters: target: array like (l x net.co) train target patterns transf: func (default HardLims) Activation function :Returns: net: Net :Example: >>> from neurolab.tool import simhop >>> net = newhop_old([[-1, 1, -1], [1, -1, 1]]) >>> output = simhop(net, [[-1, 1, -1], [1, -1, 1]]) """ target = np.asfarray(target) ci = len(target[0]) if transf is None: transf = trans.HardLims() l = layer.Perceptron(ci, ci, transf) w = l.np['w'] b = l.np['b'] # init weight for i in range(ci): for j in range(ci): if i == j: w[i, j] = 0.0 else: w[i, j] = np.sum(target[:, i] * target[:, j]) / ci b[i] = 0.0 l.initf = None minmax = transf.out_minmax if hasattr(transf, 'out_minmax') else [-1, 1] net = Net([minmax] * ci, ci, [l], [[0], [0]], None, None) return net
def _step(self, inp): self.s = np.sum(self.np['w'] * inp, axis=1) self.s += self.np['b'] return self.transf(self.s)
def __call__(self, e): v = 0.5 * np.sum(np.square(e)) return v
def __call__(self, e): N = e.size v = np.sum(np.square(e)) / N return v
def __call__(self, e): v = np.sum(np.abs(e)) / e.size return v
def __call__(self, e): v = np.sum(np.abs(e)) return v