def compute_kernel(self, itrain, itest):
if self.ifeature == 0:
if self.icategory == 0:
(self.XTrainNorm,self.XTestNorm)= \
mmr_normalization(self.norm.ilocal,self.norm.iscale, \
self.data[itrain], \
self.data[itest],0)[:2]
if self.Y0 is not None:
self.Y0Norm=mmr_normalization(self.norm.ilocal,self.norm.iscale, \
self.Y0,None,0)[0]
if self.prekernel_params.kernel_type in (0, 1, 2, 3):
xdata = [self.XTrainNorm, None]
(self.K,self.d1,self.d2)=kernel_eval_kernel(xdata,None,None, \
self.kernel_params)
if self.Y0 is None:
if len(itest) > 0:
xdata = [self.XTrainNorm, self.XTestNorm]
(self.Kcross,self.d1c,self.d2c)=kernel_eval_kernel(xdata,None, \
None, \
self.kernel_params)
else:
xdata = [self.XTrainNorm, self.Y0Norm]
(self.Kcross,self.d1c,self.d2c)=kernel_eval_kernel(xdata,None, \
None, \
self.kernel_params)
elif self.prekernel_params.kernel_type in (5, ):
(m, n) = self.data.shape
datanorm = np.zeros((m, n))
datanorm[itrain] = self.XTrainNorm
datanorm[itest] = self.XTestNorm
K = gaussian_process_type_kernel(
datanorm, self.prekernel_params.ipar1)
(self.K,self.Kcross,self.d1,self.d2,self.d1c,self.d2c)= \
kernel_localscale(K,None,itrain,itest,self.kernel_params, \
ilocal=self.norm.ilocal,iscale=self.norm.iscale)
else: ## implicit feature given by kernel
if self.Kraw is not None: ## Tanimoto
kdata = self.Kraw
kdataY0 = self.Krawcross
else:
kdata = self.data
kdataY0 = None
(self.K,self.Kcross,self.d1,self.d2,self.d1c,self.d2c)= \
kernel_localscale(kdata,kdataY0,itrain,itest, \
self.kernel_params, \
ilocal=self.norm.ilocal,iscale=self.norm.iscale)
return
def compute_kernel(self,itrain,itest):
if self.ifeature==0:
if self.icategory==0:
(self.XTrainNorm,self.XTestNorm)= \
mmr_normalization(self.norm.ilocal,self.norm.iscale, \
self.data[itrain], \
self.data[itest],0)[:2]
if self.Y0 is not None:
self.Y0Norm=mmr_normalization(self.norm.ilocal,self.norm.iscale, \
self.Y0,None,0)[0]
if self.prekernel_params.kernel_type in (0,1,2,3):
xdata=[self.XTrainNorm,None]
(self.K,self.d1,self.d2)=kernel_eval_kernel(xdata,None,None, \
self.kernel_params)
if self.Y0 is None:
if len(itest)>0:
xdata=[self.XTrainNorm,self.XTestNorm]
(self.Kcross,self.d1c,self.d2c)=kernel_eval_kernel(xdata,None, \
None, \
self.kernel_params)
else:
xdata=[self.XTrainNorm,self.Y0Norm]
(self.Kcross,self.d1c,self.d2c)=kernel_eval_kernel(xdata,None, \
None, \
self.kernel_params)
elif self.prekernel_params.kernel_type in (5,):
(m,n)=self.data.shape
datanorm=np.zeros((m,n))
datanorm[itrain]=self.XTrainNorm
datanorm[itest]=self.XTestNorm
K=gaussian_process_type_kernel(datanorm,self.prekernel_params.ipar1)
(self.K,self.Kcross,self.d1,self.d2,self.d1c,self.d2c)= \
kernel_localscale(K,None,itrain,itest,self.kernel_params, \
ilocal=self.norm.ilocal,iscale=self.norm.iscale)
else: ## implicit feature given by kernel
if self.Kraw is not None: ## Tanimoto
kdata=self.Kraw
kdataY0=self.Krawcross
else:
kdata=self.data
kdataY0=None
(self.K,self.Kcross,self.d1,self.d2,self.d1c,self.d2c)= \
kernel_localscale(kdata,kdataY0,itrain,itest, \
self.kernel_params, \
ilocal=self.norm.ilocal,iscale=self.norm.iscale)
return
def compute_base_vectors(self):
## column kernel
xdata = self.xdata.T
xdata=mmr_normalization( \
self.norm_col.ilocal,self.norm_col.iscale, \
xdata,np.array([]),0)[0]
K = np.dot(xdata, xdata.T)
Knl = kernel_eval_kernel((K, ), None, None, self.param_col)[0]
self.kernel_col = Knl
## normalize kernel items
dK = np.sqrt(np.diag(self.kernel_col))
idK = np.where(dK == 0)[0]
for i in idK:
self.kernel_col[i, i] = 1.0
dK[i] = 1.0
self.kernel_col = self.kernel_col / np.outer(dK, dK)
(v, w) = sp_lin.svd(self.kernel_col)[:2]
self.base_vectors = v * np.outer(np.ones(self.ncol), np.sqrt(w))
return
def prediction(testInput):
global cMMR
testInput = np.array(testInput)
if len(testInput.shape) == 1:
testInput = testInput.reshape(1, len(testInput))
(mtest, ntest) = testInput.shape
testInput -= np.outer(np.ones(mtest), cMMR.training_center)
xnorm = np.sqrt(np.sum(testInput**2))
xnorm += (xnorm == 0)
testInput = testInput / np.outer(xnorm, np.ones(ntest))
xdata = [cMMR.XKernel[0].XTrainNorm, testInput]
(cMMR.XKernel[0].Kcross,cMMR.XKernel[0].d1c,cMMR.XKernel[0].d2c)= \
kernel_eval_kernel(xdata,None,None,cMMR.XKernel[0].kernel_params)
## ######################################
## check the test accuracy
t0 = time.clock()
cPredictTes = cMMR.mmr_test(cMMR.dual, itraindata=1)
## counts the proportion the ones predicted correctly
if cMMR.itestmode == 2:
ypred=inverse_knn(cMMR.YKernel.get_Y0(cMMR.itrain), \
cPredictTes)
yconf = cPredictTes.zPredconf
else:
ypred = cPredictTes.zPred
## cEvaluationTes=mmr_eval_binvector(cMMR.YKernel.get_test(cMMR.itest),ypred)
return (list(ypred), list(yconf))
def compute_base_vectors(self):
## column kernel
xdata=self.xdata.T
xdata=mmr_normalization( \
self.norm_col.ilocal,self.norm_col.iscale, \
xdata,np.array([]),0)[0]
K=np.dot(xdata,xdata.T)
Knl=kernel_eval_kernel((K,),None,None,self.param_col)[0]
self.kernel_col=Knl
## normalize kernel items
dK=np.sqrt(np.diag(self.kernel_col))
idK=np.where(dK==0)[0]
for i in idK:
self.kernel_col[i,i]=1.0
dK[i]=1.0
self.kernel_col=self.kernel_col/np.outer(dK,dK)
(v,w)=sp_lin.svd(self.kernel_col)[:2]
self.base_vectors=v*np.outer(np.ones(self.ncol),np.sqrt(w))
return
def prediction(testInput):
global cMMR
testInput=np.array(testInput)
if len(testInput.shape)==1:
testInput=testInput.reshape(1,len(testInput))
(mtest,ntest)=testInput.shape
testInput-=np.outer(np.ones(mtest),cMMR.training_center)
xnorm=np.sqrt(np.sum(testInput**2))
xnorm+=(xnorm==0)
testInput=testInput/np.outer(xnorm,np.ones(ntest))
xdata=[cMMR.XKernel[0].XTrainNorm,testInput]
(cMMR.XKernel[0].Kcross,cMMR.XKernel[0].d1c,cMMR.XKernel[0].d2c)= \
kernel_eval_kernel(xdata,None,None,cMMR.XKernel[0].kernel_params)
## ######################################
## check the test accuracy
t0=time.clock()
cPredictTes= cMMR.mmr_test(cMMR.dual,itraindata=1)
## counts the proportion the ones predicted correctly
if cMMR.itestmode==2:
ypred=inverse_knn(cMMR.YKernel.get_Y0(cMMR.itrain), \
cPredictTes)
yconf=cPredictTes.zPredconf
else:
ypred=cPredictTes.zPred
## cEvaluationTes=mmr_eval_binvector(cMMR.YKernel.get_test(cMMR.itest),ypred)
return(list(ypred),list(yconf))
def compute_base_kernel_vectors(self):
## column kernel
xdata0 = np.copy(self.xdata)
xdata=mmr_normalization( \
self.norm_col.ilocal,-1, \
xdata0,np.array([]),0)[0]
xdata = xdata.T
m = xdata.shape[0]
xdata=mmr_normalization( \
-1,self.norm_col.iscale, \
xdata,np.array([]),0)[0]
ikern_type = 1 ## =0 linear, =1 cond prob
if ikern_type == 0:
K = np.dot(xdata, xdata.T)
elif ikern_type == 1:
K0 = np.dot(xdata0.T, xdata0) + 1
K0 = K0 / m
## K=np.dot(K0,K0)/np.outer(np.diag(K0),np.diag(K0))
K = np.dot(K0, K0) * np.outer(np.diag(K0), np.diag(K0))
dK = np.sqrt(np.diag(K))
K = K / np.outer(dK, dK)
elif ikern_type == 2: # Tanimoto
K = tanimoto(np.dot(xdata0.T, xdata0))
Knl = kernel_eval_kernel((K, None), None, None, self.param_col)[0]
icenter = 0
if icenter >= 0:
(Ka, aKa) = mmr_geometricmedian_ker(Knl)
Ka1 = np.outer(Ka, np.ones(m))
Knl_center = Knl + aKa - Ka1 - Ka1.T
ineg = np.where(np.diag(Knl_center) < 0)[0]
for i in ineg:
Knl_center[i, i] = 0.0
self.kernel_col = Knl_center
else:
self.kernel_col = Knl
iscale = -1
## normalize kernel items
if iscale >= 0:
dK = np.sqrt(np.diag(self.kernel_col))
idK = np.where(dK == 0)[0]
for i in idK:
self.kernel_col[i, i] = 1.0
dK[i] = 1.0
self.kernel_col = self.kernel_col / np.outer(dK, dK)
if np.isnan(self.kernel_col).any()==True and \
np.isfinite(self.kernel_col).all()!=True:
print('!!!!!')
return
def compute_base_kernel_vectors(self):
## column kernel
xdata0=np.copy(self.xdata)
xdata=mmr_normalization( \
self.norm_col.ilocal,-1, \
xdata0,np.array([]),0)[0]
xdata=xdata.T
m=xdata.shape[0]
xdata=mmr_normalization( \
-1,self.norm_col.iscale, \
xdata,np.array([]),0)[0]
ikern_type=1 ## =0 linear, =1 cond prob
if ikern_type==0:
K=np.dot(xdata,xdata.T)
elif ikern_type==1:
K0=np.dot(xdata0.T,xdata0)+1
K0=K0/m
## K=np.dot(K0,K0)/np.outer(np.diag(K0),np.diag(K0))
K=np.dot(K0,K0)*np.outer(np.diag(K0),np.diag(K0))
dK=np.sqrt(np.diag(K))
K=K/np.outer(dK,dK)
elif ikern_type==2: # Tanimoto
K=tanimoto(np.dot(xdata0.T,xdata0))
Knl=kernel_eval_kernel((K,None),None,None,self.param_col)[0]
icenter=0
if icenter>=0:
(Ka,aKa)=mmr_geometricmedian_ker(Knl)
Ka1=np.outer(Ka,np.ones(m))
Knl_center=Knl+aKa-Ka1-Ka1.T
ineg=np.where(np.diag(Knl_center)<0)[0]
for i in ineg:
Knl_center[i,i]=0.0
self.kernel_col=Knl_center
else:
self.kernel_col=Knl
iscale=-1
## normalize kernel items
if iscale>=0:
dK=np.sqrt(np.diag(self.kernel_col))
idK=np.where(dK==0)[0]
for i in idK:
self.kernel_col[i,i]=1.0
dK[i]=1.0
self.kernel_col=self.kernel_col/np.outer(dK,dK)
if np.isnan(self.kernel_col).any()==True and \
np.isfinite(self.kernel_col).all()!=True:
print('!!!!!')
return
def edge_prekernel(self, X, params_spec):
(m, n) = X.shape ## xdataraw[0]
dalpha = {}
dxy = {}
ialpha = 1
ny = 2
nitem = 3
self.ddiag = np.zeros(m)
csolver = mmr_solver_cls.cls_mmr_solver()
## read the edges
for iview in range(m):
xy = X[iview]
nxy = len(xy) // nitem
xy = xy[:nxy * nitem]
xy = xy.reshape((nxy, nitem))
ixy = np.where(xy[:, 0] > 0)[0]
xy = xy[ixy]
x = xy[:, :2] ## edge position
ya = xy[:, 2] ## edge angle
y = np.vstack((np.cos(ya), np.sin(ya))).T
## normalize the locations
ilocal = self.norm.ilocal
iscale = self.norm.iscale
(xnorm, xdummy, opar) = mmr_normalization(ilocal, iscale, x, None,
0)
## xnorm=x
self.dxy[iview] = [xnorm, y]
if ialpha == 1:
Ky = np.dot(y, y.T)
xdata = [xnorm, None]
(Kx, dx1, dx2) = kernel_eval_kernel(xdata, None, None,
params_spec)
C = 1
D = 0
xalpha = csolver.mmr_solver(Kx, Ky, C, D, 1, 1, 1, 1)
self.dalpha[iview] = xalpha
else:
xalpha = np.ones(len(y)) / len(y)
self.dalpha[iview] = xalpha
self.ddiag[iview] = np.dot(xalpha, np.dot(Kx * Ky, xalpha))
return
def edge_prekernel(self,X,params_spec):
(m,n)=X.shape ## xdataraw[0]
dalpha={}
dxy={}
ialpha=1
ny=2
nitem=3
self.ddiag=np.zeros(m)
csolver=mmr_solver_cls.cls_mmr_solver()
## read the edges
for iview in range(m):
xy=X[iview]
nxy=len(xy)//nitem
xy=xy[:nxy*nitem]
xy=xy.reshape((nxy,nitem))
ixy=np.where(xy[:,0]>0)[0]
xy=xy[ixy]
x=xy[:,:2] ## edge position
ya=xy[:,2] ## edge angle
y=np.vstack((np.cos(ya),np.sin(ya))).T
## normalize the locations
ilocal=self.norm.ilocal
iscale=self.norm.iscale
(xnorm,xdummy,opar)=mmr_normalization(ilocal,iscale,x,None,0)
## xnorm=x
self.dxy[iview]=[xnorm,y]
if ialpha==1:
Ky=np.dot(y,y.T)
xdata=[xnorm,None]
(Kx,dx1,dx2)=kernel_eval_kernel(xdata,None,None,params_spec)
C=1
D=0
xalpha=csolver.mmr_solver(Kx,Ky,C,D,1,1,1,1)
self.dalpha[iview]=xalpha
else:
xalpha=np.ones(len(y))/len(y)
self.dalpha[iview]=xalpha
self.ddiag[iview]=np.dot(xalpha,np.dot(Kx*Ky,xalpha))
return
def prekernel(self,itrain,itest,params_spec):
mtrain=len(itrain)
mtest=len(itest)
K=np.zeros((mtrain,mtest))
for i0 in range(mtrain):
i=itrain[i0]
for j0 in range(mtest):
j=itest[j0]
xdata=[self.dxy[i][0],self.dxy[j][0]]
(Kx,dx1,dx2)=kernel_eval_kernel(xdata,None,None,params_spec)
Ky=np.dot(self.dxy[i][1],self.dxy[j][1].T)
K[i0,j0]=np.dot(self.dalpha[i],np.dot((Ky*Kx),self.dalpha[j]))
d1=self.ddiag[itrain]
d2=self.ddiag[itest]
return(K,d1,d2)
def prekernel(self, itrain, itest, params_spec):
mtrain = len(itrain)
mtest = len(itest)
K = np.zeros((mtrain, mtest))
for i0 in range(mtrain):
i = itrain[i0]
for j0 in range(mtest):
j = itest[j0]
xdata = [self.dxy[i][0], self.dxy[j][0]]
(Kx, dx1, dx2) = kernel_eval_kernel(xdata, None, None,
params_spec)
Ky = np.dot(self.dxy[i][1], self.dxy[j][1].T)
K[i0, j0] = np.dot(self.dalpha[i],
np.dot((Ky * Kx), self.dalpha[j]))
d1 = self.ddiag[itrain]
d2 = self.ddiag[itest]
return (K, d1, d2)
