Ejemplo n.º 1
0
    def compute_kernel_row(self):

        K = np.zeros((self.nrow, self.nrow))

        drow = {}

        for i in range(self.nrow):
            iA = np.where(self.xdata[i] > 0)[0]
            nsub = len(iA)
            if nsub > 0:
                A = self.base_vectors[iA]
                AAT = self.kernel_col[iA.reshape((nsub, 1)), iA]
                AATI = sp_lin.pinvh(AAT)
                drow[i] = (np.dot(AATI, A), iA)
            else:
                drow[i] = (None, np.array([]))

        for i in range(self.nrow):
            (BBTI, iB) = drow[i]
            if len(iB) > 0:
                for j in range(i + 1):
                    (AATI, iA) = drow[j]
                    ## = trace(Vhi.T,Vhj)=\braket{Vhi,Vhj}_{Frobenius}
                    ## (BB^T)^{-1}BA^T(AA^T)^{-1}
                    if len(iA) > 0:
                        BAT = self.kernel_col[iB.reshape((len(iB), 1)), iA]
                        ## xP=np.diag(np.dot(BBTI.T,np.dot(BAT,AATI)))
                        xP = np.dot(BBTI, AATI.T) * BAT
                        K[i, j] = np.sum(xP)
                        K[j, i] = K[i, j]
            ## if i%1000==0:
            ## print(i)

        d1 = np.diag(K)
        d2 = d1
        self.kernel_row = kernel_eval_nl(K, d1, d2, self.param_row)
        print('Modular kernel done')

        return
Ejemplo n.º 2
0
  def compute_kernel_row(self):

    K=np.zeros((self.nrow,self.nrow))

    drow={}  

    for i in range(self.nrow):
      iA=np.where(self.xdata[i]>0)[0]
      nsub=len(iA)
      if nsub>0:
        A=self.base_vectors[iA]
        AAT=self.kernel_col[iA.reshape((nsub,1)),iA]
        AATI=sp_lin.pinvh(AAT)
        drow[i]=(np.dot(AATI,A),iA)
      else:
        drow[i]=(None,np.array([]))

    for i in range(self.nrow):
      (BBTI,iB)=drow[i]
      if len(iB)>0:
        for j in range(i+1):
          (AATI,iA)=drow[j]
          ## = trace(Vhi.T,Vhj)=\braket{Vhi,Vhj}_{Frobenius}
          ## (BB^T)^{-1}BA^T(AA^T)^{-1}
          if len(iA)>0:
            BAT=self.kernel_col[iB.reshape((len(iB),1)),iA]
            ## xP=np.diag(np.dot(BBTI.T,np.dot(BAT,AATI)))
            xP=np.dot(BBTI,AATI.T)*BAT
            K[i,j]=np.sum(xP)  
            K[j,i]=K[i,j]
      ## if i%1000==0:
        ## print(i)
        
    d1=np.diag(K)
    d2=d1
    self.kernel_row=kernel_eval_nl(K,d1,d2,self.param_row)
    print('Modular kernel done')
    
    return
Ejemplo n.º 3
0
    def compute_kernel_kernel_row(self, itrates=0):

        K = np.zeros((self.nrow, self.nrow_test))

        drow = {}

        for i in range(self.nrow):
            iA = np.where(self.xdata[i] > 0)[0]
            nsub = len(iA)
            if nsub > 0:
                AAT = self.kernel_col[iA.reshape((nsub, 1)), iA]
                AATI = sp_lin.pinvh(AAT)
                drow[i] = (AATI, iA)
            else:
                drow[i] = (None, None)

        drow_test = {}
        if itrates == 1:
            for i in range(self.nrow_test):
                iA = np.where(self.xdata_test[i] > 0)[0]
                nsub = len(iA)
                if nsub > 0:
                    AAT = self.kernel_col[iA.reshape((nsub, 1)), iA]
                    AATI = sp_lin.pinvh(AAT)
                    drow_test[i] = (AATI, iA)
                else:
                    drow_test[i] = (None, None)
        else:
            drow_test = drow

        for i in range(self.nrow):
            (BBTI, iB) = drow[i]
            if iB is not None:
                if itrates == 0:  ## to avoid double computation of symmetric kernel
                    for j in range(i + 1):
                        (AATI, iA) = drow[j]
                        if iA is not None:
                            KBA = self.kernel_col[iB.reshape((len(iB), 1)), iA]
                            xP = np.dot(KBA.T, np.dot(BBTI, np.dot(KBA, AATI)))
                            K[i, j] = np.sum(xP)
                            K[j, i] = K[i, j]
                elif itrates == 1:
                    for j in range(self.nrow_test):
                        (AATI, iA) = drow_test[j]
                        if iA is not None:
                            KBA = self.kernel_col[iB.reshape((len(iB), 1)), iA]
                            xP = np.dot(KBA.T, np.dot(BBTI, np.dot(KBA, AATI)))
                            K[i, j] = np.sum(xP)
            ## if i%1000==0:
            ## print(i)

        dK = np.sqrt(np.diag(K))
        idK = np.where(dK == 0)[0]
        for i in idK:
            K[i, i] = 1.0
            dK[i] = 1.0
        K = K / np.outer(dK, dK)

        d1 = np.diag(K)
        if itrates == 0:
            d2 = d1
        elif itrates == 1:
            d2 = np.zeros(self.nrow_test)
            for i in range(self.nrow_test):
                (AATI, iA) = drow_test[i]
                if iA is not None:
                    KBA = self.kernel_col[iA.reshape((len(iA), 1)), iA]
                    xP = np.dot(KBA.T, np.dot(AATI, np.dot(KBA, AATI)))
                    d2[i] = np.sum(xP)

        if itrates == 0:
            self.kernel_row = kernel_eval_nl(K, d1, d2, self.param_row)
        elif itrates == 1:
            self.kernel_row_test=kernel_eval_nl(K,d1,d2, \
                                                                self.param_row)

        self.kernel_row = kernel_center(self.kernel_row)
        dK = np.diag(self.kernel_row)
        idK = np.where(dK < 0)[0]
        for i in idK:
            self.kernel_row[i, i] = 0

        dK = np.sqrt(np.diag(self.kernel_row))
        idK = np.where(dK == 0)[0]
        for i in idK:
            self.kernel_row[i, i] = 1.0
            dK[i] = 1.0
        self.kernel_row = self.kernel_row / np.outer(dK, dK)

        ## print('Modular kernel done')

        return
Ejemplo n.º 4
0
  def compute_kernel_kernel_row(self,itrates=0):

    K=np.zeros((self.nrow,self.nrow_test))

    drow={}  

    for i in range(self.nrow):
      iA=np.where(self.xdata[i]>0)[0]
      nsub=len(iA)
      if nsub>0:
        AAT=self.kernel_col[iA.reshape((nsub,1)),iA]
        AATI=sp_lin.pinvh(AAT)
        drow[i]=(AATI,iA)
      else:
        drow[i]=(None,None)

    drow_test={}  
    if itrates==1:
      for i in range(self.nrow_test):
        iA=np.where(self.xdata_test[i]>0)[0]
        nsub=len(iA)
        if nsub>0:
          AAT=self.kernel_col[iA.reshape((nsub,1)),iA]
          AATI=sp_lin.pinvh(AAT)
          drow_test[i]=(AATI,iA)
        else:
          drow_test[i]=(None,None)
    else:
      drow_test=drow

    for i in range(self.nrow):
      (BBTI,iB)=drow[i]
      if iB is not None:
        if itrates==0:  ## to avoid double computation of symmetric kernel
          for j in range(i+1):
            (AATI,iA)=drow[j]
            if iA is not None:
              KBA=self.kernel_col[iB.reshape((len(iB),1)),iA]
              xP=np.dot(KBA.T,np.dot(BBTI,np.dot(KBA,AATI)))
              K[i,j]=np.sum(xP)  
              K[j,i]=K[i,j]
        elif itrates==1:
          for j in range(self.nrow_test):
            (AATI,iA)=drow_test[j]
            if iA is not None:
              KBA=self.kernel_col[iB.reshape((len(iB),1)),iA]
              xP=np.dot(KBA.T,np.dot(BBTI,np.dot(KBA,AATI)))
              K[i,j]=np.sum(xP)  
      ## if i%1000==0:
        ## print(i)

    dK=np.sqrt(np.diag(K))
    idK=np.where(dK==0)[0]
    for i in idK:
      K[i,i]=1.0
      dK[i]=1.0
    K=K/np.outer(dK,dK)
    
    d1=np.diag(K)
    if itrates==0:
      d2=d1
    elif itrates==1:
      d2=np.zeros(self.nrow_test)
      for i in range(self.nrow_test):
        (AATI,iA)=drow_test[i]
        if iA is not None:
          KBA=self.kernel_col[iA.reshape((len(iA),1)),iA]
          xP=np.dot(KBA.T,np.dot(AATI,np.dot(KBA,AATI)))
          d2[i]=np.sum(xP)  
      
    if itrates==0:
      self.kernel_row=kernel_eval_nl(K,d1,d2,self.param_row)
    elif itrates==1:
      self.kernel_row_test=kernel_eval_nl(K,d1,d2, \
                                                          self.param_row)
      
    self.kernel_row=kernel_center(self.kernel_row)
    dK=np.diag(self.kernel_row)
    idK=np.where(dK<0)[0]
    for i in idK:
      self.kernel_row[i,i]=0
      
    dK=np.sqrt(np.diag(self.kernel_row))
    idK=np.where(dK==0)[0]
    for i in idK:
      self.kernel_row[i,i]=1.0
      dK[i]=1.0
    self.kernel_row=self.kernel_row/np.outer(dK,dK)

    ## print('Modular kernel done')
    
    return