def minmax(input): """ Calculate min, max for each row """ input = np.asfarray(input) assert input.ndim == 2 min = input.min(axis=0) max = input.max(axis=0) out = [x for x in zip(min, max)] return tuple(out)
def __init__(self, x): x = np.asfarray(x) if x.ndim != 2: raise ValueError('x mast have 2 dimensions') min = np.min(x, axis=0) dist = np.max(x, axis=0) - min min = min.reshape((1, min.size,)) #replacement for " min.shape = 1, min.size" dist = dist.reshape((1, dist.size,)) #replacement for " dist.shape = 1, dist.size" self.min = min self.dist = dist
def newhem(target, transf=None, max_iter=10, delta=0): """ Create a Hemming recurrent network with 2 layers :Parameters: target: array like (l x net.co) train target patterns transf: func (default SatLinPrm(0.1, 0, 10)) Activation function of input layer 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 = newhop([[-1, -1, -1], [1, -1, 1]]) >>> output = net.sim([[-1, 1, -1], [1, -1, 1]]) """ target = np.asfarray(target) assert target.ndim == 2 cn = target.shape[0] ci = target.shape[1] if transf is None: transf = trans.SatLinPrm(0.1, 0, 10) layer_inp = layer.Perceptron(ci, cn, transf) # init input layer layer_inp.initf = None layer_inp.np['b'][:] = float(ci) / 2 for i, tar in enumerate(target): layer_inp.np['w'][i][:] = tar / 2 layer_out = layer.Reccurent(cn, cn, trans.SatLinPrm(1, 0, 1e6), max_iter, delta) # init output layer layer_out.initf = None layer_out.np['b'][:] = 0 eps = - 1.0 / cn for i in range(cn): layer_out.np['w'][i][:] = [eps] * cn layer_out.np['w'][i][i] = 1 # create network minmax = [[-1, 1]] * ci layers = [layer_inp, layer_out] connect = [[-1], [0], [1]] net = Net(minmax, cn, layers, connect, None, None) return net
def __init__(self, ci, cn, transf, max_iter, delta): Layer.__init__(self, ci, cn, cn, {'w': (cn, ci), 'b': cn}) self.max_iter = max_iter self.delta = delta self.transf = transf self.outs = [] if not hasattr(transf, 'out_minmax'): test = np.asfarry([-1e100, -100, -10, -1, 0, 1, 10, 100, 1e100]) val = self.transf(test) self.out_minmax = np.array([val.min(), val.max()] * self.co) else: self.out_minmax = np.asfarray([transf.out_minmax] * self.co) self.initf = None self.s = np.zeros(self.cn)
def __init__(self, ci, cn, transf): Layer.__init__(self, ci, cn, cn, {'w': (cn, ci), 'b': cn}) self.transf = transf if not hasattr(transf, 'out_minmax'): test = np.asfarry([-1e100, -100, -10, -1, 0, 1, 10, 100, 1e100]) val = self.transf(test) self.out_minmax = np.array([val.min(), val.max()] * self.co) else: self.out_minmax = np.asfarray([transf.out_minmax] * self.co) # default init function self.initf = init.initwb_reg #self.initf = init.initwb_nw self.s = np.zeros(self.cn)
def simhop(net, input, n=10): """ Simuate hopfied network OLD VERSION, now you may use newhop new with native sim method This function may be deleted in future (use newhop(...).sim()) :Parameters: net: Net Simulated recurrent neural network like Hopfield (newhop_old only) input: array like (N x net.ci) Train input patterns n: int (default 10) Maximum number of simulated steps :Return: output: array Network outputs full_output: list of array Network outputs, including the intermediate results :Exmamle: >>> from .net import newhop_old >>> target = [[-1, -1, -1], [1, -1, 1]] >>> net = newhop_old(target) >>> simhop(net, target)[0] array([[-1., -1., -1.], [ 1., -1., 1.]]) """ input = np.asfarray(input) assert input.ndim == 2 assert input.shape[1] == net.layers[-1].co assert input.shape[1] == net.ci output = [] for inp in input: net.layers[-1].out = inp out = [] for i in range(n): o = net.step(inp) if i>0 and np.all(out[-1] == o): break out.append(o) output.append(np.array(out)) return np.array([r[-1] for r in output]), output
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 __init__(self, inp_minmax, co, layers, connect, trainf, errorf): self.inp_minmax = np.asfarray(inp_minmax) self.out_minmax = np.zeros([co, 2]) self.ci = self.inp_minmax.shape[0] self.co = co self.layers = layers self.trainf = trainf self.errorf = errorf self.inp = np.zeros(self.ci) self.out = np.zeros(self.co) # Check connect format assert self.inp_minmax.ndim == 2 assert self.inp_minmax.shape[1] == 2 if len(connect) != len(layers) + 1: raise ValueError("Connect error") # Check connect links tmp = [0] * len(connect) for con in connect: for s in con: if s != -1: tmp[s] += 1 for l, c in enumerate(tmp): if c == 0 and l != len(layers): raise ValueError("Connect error: Lost the signal " + "from the layer " + str(l - 1)) self.connect = connect # Set inp_minmax for all layers for nl, nums_signal in enumerate(self.connect): if nl == len(self.layers): minmax = self.out_minmax else: minmax = self.layers[nl].inp_minmax ni = 0 for ns in nums_signal: t = self.layers[ns].out_minmax if ns != -1 else self.inp_minmax if ni + len(t) > len(minmax): raise ValueError("Connect error: on layer " + str(l - 1)) minmax[ni : ni + len(t)] = t ni += len(t) if ni != len(minmax): raise ValueError("Connect error: Empty inputs on layer " + str(l - 1)) self.init()
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 sim(self, input): """ Simulate a neural network :Parameters: input: array like array input vectors :Returns: outputs: array like array output vectors """ input = np.asfarray(input) assert input.ndim == 2 assert input.shape[1] == self.ci output = np.zeros([len(input), self.co]) for inp_num, inp in enumerate(input): output[inp_num, :] = self.step(inp) return output
def newlvq(minmax, cn0, pc): """ Create a learning vector quantization (LVQ) network :Parameters: minmax: list of list, the outer list is the number of input neurons, inner lists must contain 2 elements: min and max Range of input value cn0: int Number of neurons in input layer pc: list List of percent, sum(pc) == 1 :Returns: net: Net :Example: >>> # create network with 2 inputs, >>> # 2 layers and 10 neurons in each layer >>> net = newlvq([[-1, 1], [-1, 1]], 10, [0.6, 0.4]) """ pc = np.asfarray(pc) assert sum(pc) == 1 ci = len(minmax) cn1 = len(pc) assert cn0 > cn1 layer_inp = layer.Competitive(ci, cn0) layer_out = layer.Perceptron(cn0, cn1, trans.PureLin()) layer_out.initf = None layer_out.np['b'].fill(0.0) layer_out.np['w'].fill(0.0) inx = np.floor(cn0 * pc.cumsum()) for n, i in enumerate(inx): st = 0 if n == 0 else inx[n - 1] layer_out.np['w'][n][st:i].fill(1.0) net = Net(minmax, cn1, [layer_inp, layer_out], [[-1], [0], [1]], train.train_lvq, error.MSE()) return net
def __call__(self, net, input, target=None, **kwargs): """ Run train process :Parameters: net: Net instance network input: array like (l x net.ci) train input patterns target: array like (l x net.co) train target patterns - only for train with teacher **kwargs: dict other Train parametrs """ self.params = self.defaults.copy() self.params["train"] = self.defaults["train"].copy() for key in kwargs: if key in self.params: self.params[key] = kwargs[key] else: self.params["train"][key] = kwargs[key] args = [] input = np.asfarray(input) assert input.ndim == 2 assert input.shape[1] == net.ci args.append(input) if target is not None: target = np.asfarray(target) assert target.ndim == 2 assert target.shape[1] == net.co assert target.shape[0] == input.shape[0] args.append(target) def epochf(err, net, *args): """Need call on each epoch""" if err is None: err = train.error(net, *args) self.error.append(err) epoch = len(self.error) show = self.params["show"] if show and (epoch % show) == 0: print("Epoch: {0}; Error: {1};".format(epoch, err)) if err < self.params["goal"]: raise TrainStop("The goal of learning is reached") if epoch >= self.params["epochs"]: raise TrainStop("The maximum number of train epochs is reached") train = self._train_class(net, *args, **self.params["train"]) Train.__init__(train, epochf, self.params["epochs"]) self.error = [] try: train(net, *args) except TrainStop as msg: if self.params["show"]: print(msg) else: if self.params["show"] and len(self.error) >= self.params["epochs"]: print("The maximum number of train epochs is reached") return self.error
def renorm(self, x): x = np.asfarray(x) res = x * self.dist + self.min return res
def __call__(self, x): x = np.asfarray(x) res = (x - self.min) / self.dist return res