def train(self, Y_train, X_train, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) log = Log(logging, "LNU.train()") log.message("start") Wall = [] MSE = [] w = [] # Training for epoch in range(epochs): yn, w, Wall0, MSE0, e = self.countSerie(Y_train, X_train, prediction=prediction) Wall.append(Wall0) MSE.append(MSE0) log.message("done \n") return yn, w, e, Wall, MSE
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) learning = kwargs.get('learning', True) log = Log(logging, "MLPGD.count()") log.message("start") yr = Y #muw = 0.05 #muv = 0.01 muv = 0.005 N = len(Y) n1 = 400 nx = len(X) * 4 + 1 nv = 1 + n1 nxi = nv if len(self.w) < 1: self.w = randn( n1, nx ) / nx if len(self.v) < 1: self.v = randn( nv ) / nv e = zeros( N ) y = Y.copy() #x = ones( nx ) xi = ones( nxi ) dxidny = zeros ( n1 + 1 ) dydv = zeros(( N, nv )) dydw = zeros( ( N, nx, n1 ) ) SSE = zeros( epochs ) for epoch in range( epochs ): for k in range ( N - prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate((x, [ X[i][k], X[i][k-1], X[i][k-2], X[i][k-3] ])) ny = dot( self.w, x ) xi[1:] = self.phi(ny) y[ k + prediction ] = dot( self.v, xi ) e[ k ] = yr[ k ] - y[ k ] #weights of output neuron dydv[k, :] = xi dv = muv/(1+sum(xi**2))*e[k]*dydv[k] # normalized GD if learning: self.v = self.v + dv return y
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) learning = kwargs.get('learning', True) log = Log(logging, "MLPGD.count()") log.message("start") yr = Y #muw = 0.05 #muv = 0.01 muv = 0.005 N = len(Y) n1 = 400 nx = len(X) * 4 + 1 nv = 1 + n1 nxi = nv if len(self.w) < 1: self.w = randn(n1, nx) / nx if len(self.v) < 1: self.v = randn(nv) / nv e = zeros(N) y = Y.copy() #x = ones( nx ) xi = ones(nxi) dxidny = zeros(n1 + 1) dydv = zeros((N, nv)) dydw = zeros((N, nx, n1)) SSE = zeros(epochs) for epoch in range(epochs): for k in range(N - prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate( (x, [X[i][k], X[i][k - 1], X[i][k - 2], X[i][k - 3]])) ny = dot(self.w, x) xi[1:] = self.phi(ny) y[k + prediction] = dot(self.v, xi) e[k] = yr[k] - y[k] #weights of output neuron dydv[k, :] = xi dv = muv / (1 + sum(xi**2)) * e[k] * dydv[k] # normalized GD if learning: self.v = self.v + dv return y
def countSerie(self, Y, X, **kwargs): # optional parameters prediction = kwargs.get('prediction', 1) mu = kwargs.get('mu', 0.9) self.w = kwargs.get('weigths', self.w) logging = kwargs.get('logging', False) log = Log(logging, "MLP.phiCell()") log.message("start") N = len(Y) # X.shape[0] e = zeros(N) yn = Y.copy() # init output neuronu (site) nx = len(X) * 3 + 1 #lenX * X width + 1 nw = (nx * nx + nx) / 2 if len(self.w) < 1: self.w = random.randn(nw) / nw x = [] colx = [] J = zeros((N, nw)) I = eye(nw) # for record MSE = [] #mean squer error for k in range(N - prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate( (x, [X[i][k], X[i][k - 1], X[i][k - 2]])) #, X[i][k-3], X[i][k-4], X[i][k-5] ])) colx = [] for i in range(nx): for j in range(i, nx): colx.append(x[i] * x[j]) yn[k + prediction] = dot(self.w, colx) e[k] = Y[k] - yn[k] dydw = colx # for QNU and HONU (Higher Order Neural Units) J[k, :] = dydw print "___" print len(dot(linalg.inv(dot(J.T, J) + 1.0 / mu * I), J.T)) print len(e) print len(inv(dot(J.T, J) + 1. / mu * I)) dw = dot(dot(linalg.inv(dot(J.T, J) + 1.0 / mu * I), J.T), e) self.w = self.w + dw MSE.append(sum(e**2) / N) return yn, self.w, MSE, e
def countSerie(self, Y, X, **kwargs): # optional parameters prediction = kwargs.get('prediction', 1) mu = kwargs.get('mu', 0.9) self.w = kwargs.get('weigths', self.w) logging = kwargs.get('logging', False) log = Log(logging, "MLP.phiCell()") log.message("start") N=len(Y) # X.shape[0] e=zeros(N) yn=Y.copy() # init output neuronu (site) nx = len(X) * 3 + 1 #lenX * X width + 1 nw=(nx*nx+nx)/2 if len(self.w) < 1: self.w = random.randn(nw)/nw x=[] colx=[] J=zeros((N,nw)) I=eye(nw) # for record MSE = [] #mean squer error for k in range(N-prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate((x, [ X[i][k], X[i][k-1] , X[i][k-2]]))#, X[i][k-3], X[i][k-4], X[i][k-5] ])) colx = [] for i in range(nx): for j in range(i,nx): colx.append(x[i]*x[j]) yn[k+prediction]=dot(self.w,colx) e[k]=Y[k]-yn[k] dydw=colx # for QNU and HONU (Higher Order Neural Units) J[k,:]=dydw print "___" print len(dot(linalg.inv(dot(J.T,J)+1.0/mu*I),J.T)) print len(e) print len(inv(dot(J.T,J)+1./mu*I)) dw=dot(dot(linalg.inv(dot(J.T,J)+1.0/mu*I),J.T),e) self.w=self.w+dw MSE.append(sum(e**2)/N) return yn, self.w, MSE, e
def train(self, Y_train, X_train, **kwargs): prediction = kwargs.get('prediction', 1) logging = kwargs.get('logging', False) log = Log(logging, "RBF.train()") log.message("start") self.W = [] self.Y = [] # every row is RBF neuron center for k in range(len(X_train[0])): self.W.append([]) for i in range(len(X_train)): l = k - prediction self.W[k].append([ X_train[i][l] ]) #, X_train[i][l-1], X_train[i][l-2], X_train[i][l-3], X_train[i][l-4] ]) self.Y.append(Y_train[k]) log.message("done \n")
def train(self, Y_train, X_train, **kwargs): prediction = kwargs.get('prediction', 1) logging = kwargs.get('logging', False) log = Log(logging, "RBF.train()") log.message("start") self.W = [] self.Y = [] # every row is RBF neuron center for k in range(len(X_train[0])): self.W.append([]) for i in range(len(X_train)): l = k - prediction self.W[k].append( [X_train[i][l]] ) #, X_train[i][l-1], X_train[i][l-2], X_train[i][l-3], X_train[i][l-4] ]) self.Y.append(Y_train[k]) log.message("done \n")
def countSerie(self, Y, X, **kwargs): # optional parameters prediction = kwargs.get('prediction', 1) mu = kwargs.get('mu', 0.1) self.w = kwargs.get('weigths', self.w) logging = kwargs.get('logging', False) log = Log(logging, "LNU.count()") log.message("start") # for counting nx = len(X) * 4 + 1 #lenX * X width + 1 nw = nx N = len(Y) e = zeros(N) # "prazdna " array pro vypocet chyb v delce dat yn = Y.copy() # init vystup neuronu (site) yn[0] = float('nan') log.message(yn[1]) x = [1.] x = array(x) if len(self.w) < 1: self.w = random.randn(nw) / nw print self.w self.w = random.randn(nw) print self.w # for record Wall = [] Wall.append(self.w) #initial weigth MSE = [] for k in range(N - prediction): ## input vector x = [1.] for i in range(len(X)): x = concatenate( (x, [X[i][k], X[i][k - 1], X[i][k - 2], X[i][k - 3]])) # neuron count yn[k + prediction] = dot(self.w, x) if not isnan(yn[k]): e[k] = Y[k] - yn[k] #update weights dydw = x # pro LNU dy/dw = x dw = mu / (1 + sum(x**2)) * e[k] * dydw # normalizovany GD self.w = self.w + dw #for plotting Wall.append(self.w) MSE.append(sum(e**2) / N) log.message("done \n") return yn, self.w, Wall, MSE, e
def train(self, Y_train, X_train, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) log = Log(logging, "QNU.train()") log.message("start") Wall = [] MSE = [] # Training for epoch in range(epochs): yn, w, MSE0, e = self.countSerie(Y_train, X_train, prediction = prediction) Wall.append(w) MSE.append(MSE0) log.message("done \n") return yn, w, e, Wall, MSE
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) beta = kwargs.get('beta', 0.1) logging = kwargs.get('logging', False) log = Log(logging, "RBF.count()") log.message("start") N = len(Y) self.Yn = Y.copy() e = zeros(N) colx = [] allColx = [] for j in range(N - prediction): log.message(j, conditioned=True) #update neuronu LIFO (moving window) start updating after prediction lag if (j > 0 and j > prediction): self.W = self.W[1:] #remove first self.W.append(allColx[-prediction]) self.Y = self.Y[1:] #remove first self.Y.append(Y[j]) colx = [] for i in range(len(X)): colx.append( [X[i][j]]) #, X[i][j-1], X[i][j-2], X[i][j-3], X[i][j-4]]) allColx.append(colx) Nw = len(self.W) phi = zeros(Nw) nu = zeros(Nw) for i in range(Nw): nu[i] = self.fnu(asarray(self.W[i]), asarray(colx)) #nu[i]=fnu(W[i,:],x) phi = self.fphi(nu, beta) # output of RBF self.Yn[j + prediction] = sum( asarray(phi) * asarray(self.Y)) / sum(asarray(phi)) log.message("done \n") return self.Yn
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) beta = kwargs.get('beta', 0.1) logging = kwargs.get('logging', False) log = Log(logging, "RBF.count()") log.message("start") N=len(Y) self.Yn=Y.copy() e=zeros(N) colx = [] allColx = [] for j in range(N-prediction): log.message(j, conditioned=True) #update neuronu LIFO (moving window) start updating after prediction lag if (j > 0 and j > prediction): self.W = self.W[1:] #remove first self.W.append(allColx[-prediction]) self.Y = self.Y[1:] #remove first self.Y.append(Y[j]) colx = [] for i in range(len(X)): colx.append([X[i][j] ]) #, X[i][j-1], X[i][j-2], X[i][j-3], X[i][j-4]]) allColx.append(colx) Nw=len(self.W) phi=zeros(Nw) nu=zeros(Nw) for i in range(Nw): nu[i]=self.fnu(asarray(self.W[i]),asarray(colx)) #nu[i]=fnu(W[i,:],x) phi=self.fphi(nu,beta) # output of RBF self.Yn[j+prediction]=sum(asarray(phi)*asarray(self.Y))/sum(asarray(phi)) log.message("done \n") return self.Yn
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) lw = kwargs.get('learningWindow', 0) ol = kwargs.get('overLearn', 0) log = Log(logging, "MLPGD.count()") log.message("start") yr = Y muw = 0.05 muv = 0.01 N = len(Y) nx = len(X) * 4 + 1 n1 = 5 nv = 1 + n1 nxi = nv if len(self.w) < 1: self.w = randn(n1, nx) / nx if len(self.v) < 1: self.v = randn(nv) / nv e = zeros(lw) y = Y.copy() #x = ones( nx ) xi = ones(nxi) dxidny = zeros(n1 + 1) dydv = zeros((lw, nv)) dydw = zeros((lw, nx, n1)) Lv = eye(nv) Lw = eye(nx) SSE = zeros(epochs) for epoch in range(epochs): for k in range(N - prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate( (x, [X[i][k], X[i][k - 1], X[i][k - 2], X[i][k - 3]])) ny = dot(self.w, x) xi[1:] = self.phi(ny) y[k + prediction] = dot(self.v, xi) ek = yr[k] - y[k] e = concatenate((e, [ek])) e = delete(e, 0, 0) #weights of output neuron dydv = delete(dydv, 0, 0) dydv = vstack((dydv, xi)) #vweights of hidden nodes dxidny[1:] = self.dphidny(ny) dydwk = zeros((1, nx, n1)) for i in range(1, n1 + 1): dydwk[0, :, i - 1] = self.v[i] * dxidny[i] * x dydw = delete(dydw, 0, 0) dydw = vstack((dydw, dydwk)) if k > lw and k % ol == 0: print k Jv = dydv dv = dot(dot(inv(dot(Jv.T, Jv) + 1. / muv * Lv), Jv.T), e) self.v = self.v + dv for i in range(1, n1 + 1): Jw = dydw[:, :, i - 1] dw = dot(dot(inv(dot(Jw.T, Jw) + 1. / muw * Lw), Jw.T), e) self.w[i - 1, :] = self.w[i - 1, :] + dw SSE[epoch] = dot(e, e) return y
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) log = Log(logging, "MLPGD.count()") log.message("start") yr = Y muw = 0.05 muv = 0.01 N = len(Y) n1 = 2 nx = len(X) * 4 + 1 nv = 1 + n1 nxi = nv if len(self.w) < 1: self.w = randn(n1, nx) / nx if len(self.v) < 1: self.v = randn(nv) / nv e = zeros(N) y = Y.copy() #x = ones( nx ) xi = ones(nxi) dxidny = zeros(n1 + 1) dydv = zeros((N, nv)) dydw = zeros((N, nx, n1)) Lv = eye(nv) Lw = eye(nx) SSE = zeros(epochs) for epoch in range(epochs): for k in range(N - prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate( (x, [X[i][k], X[i][k - 1], X[i][k - 2], X[i][k - 3]])) ny = dot(self.w, x) xi[1:] = self.phi(ny) y[k + prediction] = dot(self.v, xi) e[k] = yr[k] - y[k - prediction] #weights of input neuron dydv[k, :] = xi #weights of hidden nodes dxidny[1:] = self.dphidny(ny) for i in range(1, n1 + 1): dydw[k, :, i - 1] = self.v[i] * dxidny[i] * x Jv = dydv dv = dot(dot(inv(dot(Jv.T, Jv) + 1. / muv * Lv), Jv.T), e) self.v = self.v + dv for i in range(1, n1 + 1): Jw = dydw[:, :, i - 1] dw = dot(dot(inv(dot(Jw.T, Jw) + 1. / muw * Lw), Jw.T), e) self.w[i - 1, :] = self.w[i - 1, :] + dw SSE[epoch] = dot(e, e) return y
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) lw = kwargs.get('learningWindow', 0) ol = kwargs.get('overLearn', 0) log = Log(logging, "MLPGD.count()") log.message("start") yr = Y muw = 0.05 muv = 0.01 N = len(Y) nx = len(X) * 4 + 1 n1 = 5 nv = 1 + n1 nxi = nv if len(self.w) < 1: self.w = randn( n1, nx ) / nx if len(self.v) < 1: self.v = randn( nv ) / nv e = zeros( lw ) y = Y.copy() #x = ones( nx ) xi = ones( nxi ) dxidny = zeros ( n1 + 1 ) dydv = zeros(( lw, nv )) dydw = zeros(( lw, nx, n1 )) Lv = eye( nv ) Lw = eye( nx ) SSE = zeros( epochs ) for epoch in range( epochs ): for k in range ( N - prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate((x, [ X[i][k], X[i][k-1], X[i][k-2], X[i][k-3] ])) ny = dot( self.w, x ) xi[1:] = self.phi(ny) y[ k + prediction ] = dot( self.v, xi ) ek = yr[ k ] - y[ k ] e = concatenate(( e, [ek] )) e = delete(e, 0, 0) #weights of output neuron dydv = delete(dydv, 0, 0) dydv = vstack(( dydv, xi )) #vweights of hidden nodes dxidny[1:] = self.dphidny(ny) dydwk = zeros( ( 1, nx, n1 ) ) for i in range(1, n1 + 1 ): dydwk[0, :,i-1] = self.v[ i ] * dxidny[ i ] * x dydw = delete(dydw, 0, 0) dydw = vstack(( dydw, dydwk)) if k > lw and k % ol == 0: print k Jv = dydv dv = dot( dot( inv( dot( Jv.T, Jv ) + 1. / muv * Lv ), Jv.T ), e ) self.v = self.v + dv for i in range( 1, n1 + 1 ): Jw = dydw[ :, :, i - 1 ] dw = dot( dot( inv( dot( Jw.T, Jw ) + 1. / muw * Lw ), Jw.T ), e ) self.w[ i - 1, : ] = self.w[ i - 1, : ] + dw SSE[ epoch ] = dot( e, e ) return y
def count(self, Y, X, **kwargs): prediction = kwargs.get('prediction', 1) epochs = kwargs.get('epochs', 1) logging = kwargs.get('logging', False) log = Log(logging, "MLPGD.count()") log.message("start") yr = Y muw = 0.05 muv = 0.01 N = len(Y) n1 = 2 nx = len(X) * 4 + 1 nv = 1 + n1 nxi = nv if len(self.w) < 1: self.w = randn( n1, nx ) / nx if len(self.v) < 1: self.v = randn( nv ) / nv e = zeros( N ) y = Y.copy() #x = ones( nx ) xi = ones( nxi ) dxidny = zeros ( n1 + 1 ) dydv = zeros(( N, nv )) dydw = zeros( ( N, nx, n1 ) ) Lv = eye( nv ) Lw = eye( nx ) SSE = zeros( epochs ) for epoch in range( epochs ): for k in range ( N - prediction): #input vector x = [1.] for i in range(len(X)): x = concatenate((x, [ X[i][k], X[i][k-1], X[i][k-2], X[i][k-3] ])) ny = dot( self.w, x ) xi[1:] = self.phi(ny) y[ k + prediction ] = dot( self.v, xi ) e[ k ] = yr[ k ] - y[ k - prediction] #weights of input neuron dydv[k, :] = xi #weights of hidden nodes dxidny[1:] = self.dphidny(ny) for i in range(1, n1 + 1 ): dydw[k, :, i-1 ] = self.v[ i ] * dxidny[ i ] * x Jv = dydv dv = dot( dot( inv( dot( Jv.T, Jv ) + 1. / muv * Lv ), Jv.T ), e ) self.v = self.v + dv for i in range( 1, n1 + 1 ): Jw = dydw[ :, :, i - 1 ] dw = dot( dot( inv( dot( Jw.T, Jw ) + 1. / muw * Lw ), Jw.T ), e ) self.w[ i - 1, : ] = self.w[ i - 1, : ] + dw SSE[ epoch ] = dot( e, e ) return y
def countSerie(self, Y, X, **kwargs): # optional parameters prediction = kwargs.get('prediction', 1) mu = kwargs.get('mu', 0.1) self.w = kwargs.get('weigths', self.w) logging = kwargs.get('logging', False) log = Log(logging, "LNU.count()") log.message("start") # for counting nx = len(X) * 4 + 1 #lenX * X width + 1 nw = nx N=len(Y) e=zeros(N) # "prazdna " array pro vypocet chyb v delce dat yn = Y.copy() # init vystup neuronu (site) yn[0] = float('nan') log.message(yn[1]) x = [1.] x = array(x) if len(self.w) < 1: self.w = random.randn(nw)/nw print self.w self.w = random.randn(nw) print self.w # for record Wall = [] Wall.append(self.w) #initial weigth MSE = [] for k in range(N-prediction): ## input vector x = [1.] for i in range(len(X)): x = concatenate((x, [ X[i][k], X[i][k-1], X[i][k-2], X[i][k-3] ])) # neuron count yn[k+prediction]=dot(self.w,x) if not isnan(yn[k]): e[k]=Y[k]-yn[k] #update weights dydw=x # pro LNU dy/dw = x dw=mu/(1+sum(x**2))*e[k]*dydw # normalizovany GD self.w=self.w+dw #for plotting Wall.append(self.w) MSE.append(sum(e**2)/N) log.message("done \n") return yn, self.w, Wall, MSE, e