def _inverse(self, y, n=None): """Project 'y' to the input space using the first 'n' components. :param y: Vectors from the output space. :type y: numpy.ndarray :param n: The number of components to use for projection to the input space. If 'n' is not set, use all available components. :type n: int :return: The projected vectors. :rtype: numpy.ndarray :raises mdp.NodeException: If the valid dimension is exceeded. """ if n is None: n = y.shape[1] if n > self.output_dim: error_str = ("y has dimension %d," " should be at most %d" % (n, self.output_dim)) raise mdp.NodeException(error_str) v = self.get_recmatrix() if n is not None: return mult(y, v[:n, :]) return mult(y, v)
def matmult_n_MDP_benchmark(dim): """ This benchmark multiplies two non-contiguous matrices using the MDP internal matrix multiplication routine. First argument matrix dimensionality""" a = numx_rand.random((dim,dim)).T b = numx_rand.random((dim,dim)).T mult(a,b)
def _train(self, x, y): """ :param x: Array of different input observations. :type x: numpy.ndarray :param y: Array of size (x.shape[0], output_dim) that contains the observed output to the input x's. :type y: numpy.ndarray """ # initialize internal vars if necessary if self._xTx is None: if self.with_bias: x_size = self._input_dim + 1 else: x_size = self._input_dim self._xTx = numx.zeros((x_size, x_size), self._dtype) self._xTy = numx.zeros((x_size, self._output_dim), self._dtype) if self.with_bias: x = self._add_constant(x) # update internal variables self._xTx += mult(x.T, x) self._xTy += mult(x.T, y) self._tlen += x.shape[0]
def _sample_h(self, v, x): # returns P(h=1|v,W,b) and a sample from it dynamic_b = mult(x, self.b) probs = Oger.utils.LogisticFunction.f(self.bh + mult(v, self.w) + dynamic_b) h = (probs > random(probs.shape)).astype(self.dtype) return probs, h
def matmult_n_MDP_benchmark(dim): """ This benchmark multiplies two non-contiguous matrices using the MDP internal matrix multiplication routine. First argument matrix dimensionality""" a = numx_rand.random((dim, dim)).T b = numx_rand.random((dim, dim)).T mult(a, b)
def _train(self, x): """Update the principal components. :param x: Data vectors. :type x: numpy.ndarray """ [w1, w2] = self._amnesic(self.get_current_train_iteration() + 1) red_j = self.output_dim red_j_flag = False explained_var = 0.0 r = x for j in range(self.output_dim): v = self._v[:, j:j + 1] d = self.d[j] v = w1 * v + w2 * mult(r, v) / d * r.T d = mdp.numx_linalg.norm(v) vn = old_div(v, d) r = r - mult(r, vn) * vn.T explained_var += d if not red_j_flag: ratio = explained_var / self._var_tot if ratio > self.var_rel: red_j = j red_j_flag = True self._v[:, j:j + 1] = v self.v[:, j:j + 1] = vn self.d[j] = d self._var_tot = explained_var self._reduced_dims = red_j
def _energy(self, v, h): if self._gaussian: return ((((v - self.bv) ** 2).sum() / 2) - mult(h, self.bh) - (mult(v, self.w) * h).sum(axis=1)) else: return (-mult(v, self.bv) - mult(h, self.bh) - (mult(v, self.w) * h).sum(axis=1))
def _energy(self, v, h): if self._gaussian: return ((((v - self.bv)**2).sum() / 2) - mult(h, self.bh) - (mult(v, self.w) * h).sum(axis=1)) else: return (-mult(v, self.bv) - mult(h, self.bh) - (mult(v, self.w) * h).sum(axis=1))
def _calculate_gradient(self, y): x = self._last_x dy = Oger.utils.LogisticFunction.df(x, self._last_y) * y dw = mult(x.T, dy) self._gradient_vector = numx.concatenate((dw.ravel(), dy.sum(axis=0))) dx = mult(self.w, dy.T).T return dx
def _inverse(self, y, n=None): """Project data from the output to the input space using the first 'n' components. If 'n' is not set, use all available components. :param y: Data to be projected to the input space. :type y: numpy.ndarray :param n: Number of first principle components. :type n: int :return: The projected data :rtype: numpy.ndarray """ if n is None: n = y.shape[1] if n > self.output_dim: error_str = ("y has dimension %d," " should be at most %d" % (n, self.output_dim)) raise mdp.NodeException(error_str) v = self.get_recmatrix() if n is not None: return mult(y, v[:n, :]) + self.avg return mult(y, v) + self.avg
def _gsfa(self, x): for layernum in xrange(self._nlayers): z = self.fa[layernum](x) if layernum == self._nlayers - 1: x = mult(z, self.v[layernum][:, 1:self.output_dim + 1]) else: x = mult(z, self.v[layernum][:, :self._npoly]) return x
def _calculate_gradient(self, y): ''' y is the gradient that is propagated from the previous layer''' x = self._last_x dy = self.transfer_func.df(x, self._last_y) * y dw = mult(x.T, dy) self._gradient_vector = numx.concatenate((dw.ravel(), dy.sum(axis=0))) dx = mult(self.w, dy.T).T return dx
def _train(self, x): phi, phi_, a, r, done = self._split_x(x) td_err = r + self._gamma * self.get_value(phi_) - self.get_value(phi) grad_theta = self._alpha * mult(phi.T, td_err) grad_psi = self._beta * mult(phi.T, (td_err > 0) * (a - self.get_action(phi))) self._theta += grad_theta self._psi += grad_psi self.td_err = td_err
def _sample_v(self, h, x): # returns P(v=1|h,W,b) and a sample from it dynamic_b = mult(x, self.a) v_in = self.bv + mult(h, self.w.T) + dynamic_b if self._gaussian: return v_in, v_in else: probs = Oger.utils.LogisticFunction.f(v_in) v = (probs > random(probs.shape)).astype(self.dtype) return probs, v
def _energy(self, v, h, x): ba = mult(x, self.a) bb = mult(x, self.b) ba += self.bv bb += self.bh if self._gaussian: return (((v - ba) ** 2).sum() / 2 - (h * bb).sum(axis=1) - (mult(v, self.w) * h).sum(axis=1)) else: return (-(v * ba).sum(axis=1) - (h * bb).sum(axis=1) - (mult(v, self.w) * h).sum(axis=1))
def _energy(self, v, h, x): ba = mult(x, self.a) bb = mult(x, self.b) ba += self.bv bb += self.bh if self._gaussian: return (((v - ba)**2).sum() / 2 - (h * bb).sum(axis=1) - (mult(v, self.w) * h).sum(axis=1)) else: return (-(v * ba).sum(axis=1) - (h * bb).sum(axis=1) - (mult(v, self.w) * h).sum(axis=1))
def test_mult_diag(): dim = 20 d = numx_rand.random(size=(dim,)) dd = numx.diag(d) mtx = numx_rand.random(size=(dim, dim)) res1 = utils.mult(dd, mtx) res2 = utils.mult_diag(d, mtx, left=True) assert_array_almost_equal(res1, res2, 10) res1 = utils.mult(mtx, dd) res2 = utils.mult_diag(d, mtx, left=False) assert_array_almost_equal(res1, res2, 10)
def _train(self, x, y): # initialize internal vars if necessary if self._xTx is None: x_size = self._input_dim + 1 self._xTx = numx.zeros((x_size, x_size), self._dtype) self._xTy = numx.zeros((x_size, self._output_dim), self._dtype) x = self._add_constant(x) # update internal variables self._xTx += mult(x.T, x) self._xTy += mult(x.T, y) self._tlen += x.shape[0]
def _inverse(self, y, n=None): """Project 'y' to the input space using the first 'n' components. If 'n' is not set, use all available components.""" if n is None: n = y.shape[1] if n > self.output_dim: error_str = "y has dimension %d," " should be at most %d" % (n, self.output_dim) raise mdp.NodeException(error_str) v = self.get_recmatrix() if n is not None: return mult(y, v[:n, :]) + self.avg return mult(y, v) + self.avg
def get_CD_gradient(self, x, n_updates=1): """Use Gibbs sampling to estimate the contrastive divergence gradient. - x: a binary matrix having different variables on different columns and observations on the rows (concatenation of visibles and context) - n_updates: number of CD iterations. Default value: 1 Returns a tuple (dw, dbv, dbh, da, db) that contains the gradients of the weights and the biases of the visibles and the hidden respectively and the autoregressive gradients da and db. """ # useful quantities n = x.shape[0] v, x = self._split_data(x) w, a, b, bv, bh = self.w, self.a, self.b, self.bv, self.bh # first update of the hidden units for the data term ph_data, h_data = self._sample_h(v, x) # n updates of both v and h for the model term h_model = h_data.copy() for i in range(n_updates): pv_model, v_model = self._sample_v(h_model, x) ph_model, h_model = self._sample_h(v_model, x) # find dw data_term = mult(v.T, ph_data) model_term = mult(v_model.T, ph_model) dw = (data_term - model_term) / n # find da data_term = v model_term = v_model # Should I include the weight decay here as well? da = mult(x.T, data_term - model_term) / n # find db data_term = ph_data model_term = ph_model db = mult(x.T, data_term - model_term) / n # find dbv data_term = v.sum(axis=0) model_term = v_model.sum(axis=0) dbv = (data_term - model_term) / n # find dbh data_term = ph_data.sum(axis=0) model_term = ph_model.sum(axis=0) dbh = (data_term - model_term) / n return (dw, dbv, dbh, da, db)
def _inverse(self, y, n=None): """Project 'y' to the input space using the first 'n' components. If 'n' is not set, use all available components.""" if n is None: n = y.shape[1] if n > self.output_dim: error_str = ("y has dimension %d," " should be at most %d" % (n, self.output_dim)) raise mdp.NodeException(error_str) v = self.get_recmatrix() if n is not None: return mult(y, v[:n, :]) + self.avg return mult(y, v) + self.avg
def _get_laplacian(adj, normalize='True'): if normalize: d = adj.sum(axis=1) identity = mdp.numx.identity(len(d)) mat_lapl = identity * d - adj osd = mdp.numx.zeros(len(d)) for i in range(len(d)): if d[i] > 0: osd[i] = mdp.numx.sqrt(1.0 / d[i]) t = identity * osd return mult(t, mult(mat_lapl, t)) else: mat_degree = mdp.numx.diag(adj.sum(axis=0)) return mat_degree - adj
def guess(input, reservoir, dirname): #print input.shape """ pylab.plot(input) pylab.show() pylab.figure() """ try: beta = np.loadtxt(dirname + os.sep + 'beta.mat') except: return 0 #19 x = reservoir.execute(input) #m = readout._execute(x) #m = mult(x, readout.beta) m = mult(x, beta) # find maximum place of m mcs = np.zeros(m.shape[1]) for i in range(m.shape[1]): mc = sum(m[:,i]) / m.shape[1] mcs[i] = mc return mcs.argmax()
def _execute(self, x, n=None): """Project the input on the first 'n' principal components. :param x: The input that is to project. :type x: numpy.ndarray :param n: The number of first principle components to project on. If 'n' is not set, use all available components. :type n: int :return: The projected input. :rtype: numpy.ndarray """ if n is not None: return mult(x, self.v[:, :n]) return mult(x, self.v)
def _down_pass(self, h, top_updates=0, epsilon=0.1, decay=0., momentum=0.): """ top_updates -- set >0 for top node, so that it ends up sampling from the prior """ # TODO: check input pv, v = self._sample_v(h) for _ in range(top_updates): ph, h = self._sample_h(v) pv, v = self._sample_v(h) # reconstruct hidden state ph1, h1 = self._sample_h(v) # adapt generative weights delta = mult(v.T, (h - ph1))/v.shape[0] self.dw_sleep = (momentum*self.dw_sleep + epsilon*(delta - decay*self.w_rec)) self.w_rec += self.dw_sleep # adapt biases delta = (h - ph1).mean(axis=0) self.dbh = momentum*self.dbh + epsilon*delta self.bh += self.dbh return v, pv, mdp.utils.norm2(self.dbh)
def _down_pass(self, h, top_updates=0, epsilon=0.1, decay=0.0, momentum=0.0): """ top_updates -- set >0 for top node, so that it ends up sampling from the prior """ # TODO: check input pv, v = self._sample_v(h) for _ in range(top_updates): ph, h = self._sample_h(v) pv, v = self._sample_v(h) # reconstruct hidden state ph1, h1 = self._sample_h(v) # adapt generative weights delta = mult(v.T, (h - ph1)) / v.shape[0] self.dw_sleep = momentum * self.dw_sleep + epsilon * (delta - decay * self.w_rec) self.w_rec += self.dw_sleep # adapt biases delta = (h - ph1).mean(axis=0) self.dbh = momentum * self.dbh + epsilon * delta self.bh += self.dbh return v, pv, mdp.utils.norm2(self.dbh)
def _execute(self, data, n=None): """ Execute learned transformation on *data*. Projects the given data to the axis of the most significant eigenvectors and returns the data in this lower-dimensional subspace. """ # 'INITIALIZATION' if self.retained_channels == None: self.retained_channels = data.shape[1] if n is None: n = self.retained_channels if self.channel_names is None: self.channel_names = data.channel_names if len(self.channel_names) < self.retained_channels: self.retained_channels = len(self.channel_names) self._log( "To many channels chosen for the retained channels! Replaced by maximum number.", level=logging.CRITICAL) if not (self.output_dim == self.retained_channels): # overwrite internal output_dim variable, since it is set wrong self._output_dim = self.retained_channels # 'Real' Processing #projected_data = super(PCANodeWrapper, self)._execute(data, n) x = data.view(numpy.ndarray) projected_data = mult(x - self.avg, self.v[:, :self.retained_channels]) if self.new_channels is None: self.new_channel_names = [ "pca%03d" % i for i in range(projected_data.shape[1]) ] return TimeSeries(projected_data, self.new_channel_names, data.sampling_frequency, data.start_time, data.end_time, data.name, data.marker_name)
def _inverse(self, y): # counter-rotate input x = mult(y, self.RP.T) # invert whitening node if needed if not self.whitened: x = self.white.inverse(x) return x
def _execute(self, x): #---------------------------------------------------- # similar algorithm to that within self.stop_training() # refer there for notes & comments on code #---------------------------------------------------- N = self.data.shape[0] Nx = x.shape[0] W = numx.zeros((Nx, N), dtype=self.dtype) k, r = self.k, self.r d_out = self.output_dim Q_diag_idx = numx.arange(k) for row in range(Nx): #find nearest neighbors of x in M M_xi = self.data-x[row] nbrs = numx.argsort( (M_xi**2).sum(1) )[:k] M_xi = M_xi[nbrs] #find corrected covariance matrix Q Q = mult(M_xi, M_xi.T) if r is None and k > d_out: sig2 = (svd(M_xi, compute_uv=0))**2 r = numx.sum(sig2[d_out:]) Q[Q_diag_idx, Q_diag_idx] += r if r is not None: Q[Q_diag_idx, Q_diag_idx] += r #solve for weights w = self._refcast(numx_linalg.solve(Q , numx.ones(k))) w /= w.sum() W[row, nbrs] = w #multiply weights by result of SVD from training return numx.dot(W, self.training_projection)
def get_value(self, phi, a=None): """Returns q value(s).""" if a is not None: return (phi * self._theta[:, a.ravel()].T).sum(axis=1, keepdims=True) else: return mult(phi, self._theta)
def get_quadratic_form(self, nr): """Return the matrix H, the vector f and the constant c of the quadratic form 1/2 x'Hx + f'x + c that defines the output of the component 'nr' of the SFA node. :param nr: The component 'nr' of the SFA node. :returns: The matrix H, the vector f and the constant c of the quadratic form. :rtype: numpy.ndarray, numpy.ndarray, float """ if self.sf is None: self._if_training_stop_training() sf = self.sf[:, nr] c = -mult(self.avg, sf) n = self.input_dim f = sf[:n] h = numx.zeros((n, n), dtype=self.dtype) k = n for i in range(n): for j in range(n): if j > i: h[i, j] = sf[k] k = k + 1 elif j == i: h[i, j] = 2 * sf[k] k = k + 1 else: h[i, j] = h[j, i] return QuadraticForm(h, f, c, dtype=self.dtype)
def _execute(self, x): #---------------------------------------------------- # similar algorithm to that within self.stop_training() # refer there for notes & comments on code #---------------------------------------------------- N = self.data.shape[0] Nx = x.shape[0] W = numx.zeros((Nx, N), dtype=self.dtype) k, r = self.k, self.r d_out = self.output_dim Q_diag_idx = numx.arange(k) for row in range(Nx): #find nearest neighbors of x in M M_xi = self.data - x[row] nbrs = numx.argsort((M_xi**2).sum(1))[:k] M_xi = M_xi[nbrs] #find corrected covariance matrix Q Q = mult(M_xi, M_xi.T) if r is None and k > d_out: sig2 = (svd(M_xi, compute_uv=0))**2 r = numx.sum(sig2[d_out:]) Q[Q_diag_idx, Q_diag_idx] += r if r is not None: Q[Q_diag_idx, Q_diag_idx] += r #solve for weights w = self._refcast(numx_linalg.solve(Q, numx.ones(k))) w /= w.sum() W[row, nbrs] = w #multiply weights by result of SVD from training return numx.dot(W, self.training_projection)
def _execute(self, data, n = None): """ Execute learned transformation on *data*. Projects the given data to the axis of the most significant eigenvectors and returns the data in this lower-dimensional subspace. """ # 'INITIALIZATION' if self.retained_channels==None: self.retained_channels = data.shape[1] if n is None: n = self.retained_channels if self.channel_names is None: self.channel_names = data.channel_names if len(self.channel_names)<self.retained_channels: self.retained_channels = len(self.channel_names) self._log("To many channels chosen for the retained channels! Replaced by maximum number.",level=logging.CRITICAL) if not(self.output_dim==self.retained_channels): # overwrite internal output_dim variable, since it is set wrong self._output_dim = self.retained_channels # 'Real' Processing #projected_data = super(PCANodeWrapper, self)._execute(data, n) x = data.view(numpy.ndarray) projected_data = mult(x-self.avg, self.v[:, :self.retained_channels]) if self.new_channels is None: self.new_channel_names = ["pca%03d" % i for i in range(projected_data.shape[1])] return TimeSeries(projected_data, self.new_channel_names, data.sampling_frequency, data.start_time, data.end_time, data.name, data.marker_name)
def _sample_v(self, h, sample_l=False, concatenate=True): # returns P(v=1|h,W,b), a sample from it, P(l=1|h,W,b), # and a sample from it ldim, vdim = self._labels_dim, self._visible_dim # activation a = self.bv + mult(h, self.w.T) av, al = a[:, :vdim], a[:, vdim:] # ## visible units: logistic activation probs_v = old_div(1.,(1. + exp(-av))) v = (probs_v > random(probs_v.shape)).astype('d') # ## label units: softmax activation # subtract maximum to regularize exponent exponent = al - rrep(al.max(axis=1), ldim) probs_l = exp(exponent) probs_l /= rrep(probs_l.sum(axis=1), ldim) if sample_l: # ?? todo: I'm sure this can be optimized l = numx.zeros((h.shape[0], ldim)) for t in range(h.shape[0]): l[t, :] = mdp.numx_rand.multinomial(1, probs_l[t, :]) else: l = probs_l.copy() if concatenate: probs = numx.concatenate((probs_v, probs_l), axis=1) x = numx.concatenate((v, l), axis=1) return probs, x else: return probs_v, probs_l, v, l
def _sample_v(self, h, sample_l=False, concatenate=True): # returns P(v=1|h,W,b), a sample from it, P(l=1|h,W,b), # and a sample from it ldim, vdim = self._labels_dim, self._visible_dim # activation a = self.bv + mult(h, self.w.T) av, al = a[:, :vdim], a[:, vdim:] # ## visible units: logistic activation probs_v = old_div(1., (1. + exp(-av))) v = (probs_v > random(probs_v.shape)).astype('d') # ## label units: softmax activation # subtract maximum to regularize exponent exponent = al - rrep(al.max(axis=1), ldim) probs_l = exp(exponent) probs_l /= rrep(probs_l.sum(axis=1), ldim) if sample_l: # ?? todo: I'm sure this can be optimized l = numx.zeros((h.shape[0], ldim)) for t in range(h.shape[0]): l[t, :] = mdp.numx_rand.multinomial(1, probs_l[t, :]) else: l = probs_l.copy() if concatenate: probs = numx.concatenate((probs_v, probs_l), axis=1) x = numx.concatenate((v, l), axis=1) return probs, x else: return probs_v, probs_l, v, l
def get_quadratic_form(self, nr): """ Return the matrix H, the vector f and the constant c of the quadratic form 1/2 x'Hx + f'x + c that defines the output of the component 'nr' of the SFA node. """ if self.sf is None: self._if_training_stop_training() sf = self.sf[:, nr] c = -mult(self.avg, sf) n = self.input_dim f = sf[:n] h = numx.zeros((n, n), dtype=self.dtype) k = n for i in range(n): for j in range(n): if j > i: h[i, j] = sf[k] k = k+1 elif j == i: h[i, j] = 2*sf[k] k = k+1 else: h[i, j] = h[j, i] return QuadraticForm(h, f, c, dtype=self.dtype)
def _execute(self, x): """Return slow feature response. :return: Slow feature response. """ if self.remove_mean: x = self.avgnode._execute(x) return mult(x, self.sf)
def _sample_v(self, h): # returns P(v=1|h,W,b) and a sample from it v_in = self.bv + mult(h, self.w.T) if self._gaussian: return v_in, v_in else: probs = 1. / (1. + exp(-v_in)) v = (probs > random(probs.shape)).astype(self.dtype) return probs, v
def test_random_rot(): dim = 20 tlen = 10 for i in xrange(tlen): x = utils.random_rot(dim, dtype='f') assert x.dtype.char=='f', 'Wrong dtype' y = utils.mult(x.T, x) assert_almost_equal(numx_linalg.det(x), 1., 4) assert_array_almost_equal(y, numx.eye(dim), 4)
def _execute(self, x, n=None): """Compute the output of the slowest functions. If 'n' is an integer, then use the first 'n' slowest components.""" if n: sf = self.sf[:, :n] bias = self._bias[:n] else: sf = self.sf bias = self._bias return mult(x, sf) - bias
def _execute(self, x): if not self._is_initialized: self.initialize() n = x.shape[0] if n > 1: bias = numx.tile(self.b, (n, 1)) else: bias = self.b y = self.transfer_func.f(mult(x, self.w) + bias) return y
def _sample_v(self, h): # returns P(v=n|h,W,b) and a sample from it # un-normalized poisson rate, l l = exp(self.bv + mult(h, self.w.T)) # now we normalize it wrt length of wordvector and partition function l = l * self.v.sum(axis=1)[:,newaxis] / l.sum(axis=1)[:,newaxis] probs = self._Ps(self.v, l) v = (probs > random(probs.shape)).astype(self.dtype) return probs, v
def _train(self, x): """Update the minor components.""" c = mult(x.T, x) for j in range(self.output_dim): v = self.v[:, j:j + 1] d = self.d[j] n = self.eps / (1 + j * 1.2) a = mult(c, v) if self.normalize: v = (1.5 - n) * v - n * a else: v = (1.5 - n * (d ** 2)) * v - n * a l = mult(v.T, v) c += self.gamma * mult(v, v.T) / l self.v[:, j:j + 1] = v self.d[j] = mdp.numx.sqrt(l) if self.normalize: self.v[:, j:j + 1] = old_div(v, self.d[j])
def _train(self, x): """Update the minor components.""" c = mult(x.T, x) for j in range(self.output_dim): v = self.v[:, j:j + 1] d = self.d[j] n = self.eps / (1 + j * 1.2) a = mult(c, v) if self.normalize: v = (1.5 - n) * v - n * a else: v = (1.5 - n * (d**2)) * v - n * a l = mult(v.T, v) c += self.gamma * mult(v, v.T) / l self.v[:, j:j + 1] = v self.d[j] = mdp.numx.sqrt(l) if self.normalize: self.v[:, j:j + 1] = old_div(v, self.d[j])
def _mgs(a): m, n = a.shape v = a.copy() r = numx.zeros((n, n)) for i in range(n): r[i, i] = numx_linalg.norm(v[:, i]) v[:, i] = v[:, i]/r[i, i] for j in range(i+1, n): r[i, j] = mult(v[:, i], v[:, j]) v[:, j] = v[:, j] - r[i, j]*v[:, i] # q is v return v, r
def testSFANode(): dim=10000 freqs = [2*numx.pi*1, 2*numx.pi*5] t = numx.linspace(0,1,num=dim) mat = numx.array([numx.sin(freqs[0]*t), numx.sin(freqs[1]*t)]).T mat = (old_div((mat - mean(mat[:-1,:], axis=0)), std(mat[:-1,:],axis=0))) des_mat = mat.copy() mat = mult(mat,uniform((2,2))) + uniform(2) sfa = mdp.nodes.SFANode() sfa.train(mat) out = sfa.execute(mat) correlation = old_div(mult(des_mat[:-1,:].T,out[:-1,:]),(dim - 2)) assert sfa.get_eta_values(t=0.5) is not None, 'get_eta is None' assert_array_almost_equal(abs(correlation), numx.eye(2), decimal-3) sfa = mdp.nodes.SFANode(output_dim = 1) sfa.train(mat) out = sfa.execute(mat) assert out.shape[1]==1, 'Wrong output_dim' correlation = old_div(mult(des_mat[:-1,:1].T,out[:-1,:]),(dim - 2)) assert_array_almost_equal(abs(correlation), numx.eye(1), decimal - 3)