Ejemplo n.º 1
0
    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
Ejemplo n.º 2
0
  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
Ejemplo n.º 3
0
    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
Ejemplo n.º 4
0
    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
Ejemplo n.º 5
0
  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
Ejemplo n.º 6
0
  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")
Ejemplo n.º 7
0
    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")
Ejemplo n.º 8
0
    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
Ejemplo n.º 9
0
  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
Ejemplo n.º 10
0
    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
Ejemplo n.º 11
0
  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
Ejemplo n.º 12
0
    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
Ejemplo n.º 13
0
    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
Ejemplo n.º 14
0
  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
Ejemplo n.º 15
0
  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
Ejemplo n.º 16
0
  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