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
