def Operations_listmatrices(listofmatrices,operationnature):#The parameters are tensors
Res=[]
if (operationnature=="Turnintoarray"):
for matrix in listofmatrices:
element=np.copy(mxnet_backend.to_numpy(matrix))
Res.append(element)#computes A.T
return Res
if (operationnature=="Transpose"):
for matrix in listofmatrices:
element=np.copy(mxnet_backend.to_numpy(matrix))
Res.append(tl.tensor(element.T))#computes A.T
return Res
if(operationnature=="Transposetimes"):
for matrix in listofmatrices:
element=np.copy(mxnet_backend.to_numpy(matrix))
Res.append(tl.tensor(np.dot(element.T,element))) #computes A.T*A
return Res
if(operationnature=="NormI"):
for matrix in listofmatrices:
Res.append(tl.norm(matrix,1))
return Res
if(operationnature=="NormII"):
for matrix in listofmatrices:
Res.append(np.power(tl.norm(matrix,2),2))
return Res
if(operationnature=="Tensorize"):
for matrix in listofmatrices:
Res.append(tl.tensor(matrix))
return Res
def Operations_listmatrices(listofmatrices,operationnature):
#This function takes a list of matrices and performs some classical operations on its elements.
#The variable operationnature specifies the operation performed
#The matrices are of tensor type
Res=[]
if (operationnature=="Transpose"):
for matrix in listofmatrices:
#element=np.copy(mxnet_backend.to_numpy(matrix))
element=np.copy(mxnet_backend.to_numpy(matrix))
Res.append(tl.tensor(element.T))#computes A.T
return Res
if(operationnature=="Transposetimes"):
for matrix in listofmatrices:
#element=np.copy(mxnet_backend.to_numpy(matrix))
element=np.copy(mxnet_backend.to_numpy(matrix))
Res.append(tl.tensor(np.dot(element.T,element))) #computes A.T*A
return Res
if(operationnature=="NormI"):
for matrix in listofmatrices:
Res.append(tl.norm(tl.tensor(matrix),1))
return Res
if(operationnature=="NormII"):
for matrix in listofmatrices:
Res.append(np.power(tl.norm(tl.tensor(matrix),2),2))
return Res
if(operationnature=="Tensorize"):
for matrix in listofmatrices:
Res.append(tl.tensor(matrix))
return Res
def Derivativefeatureproblem(Spectrogram, G, A,
B): #The parameters are tensors
derivative = -np.dot(
mxnet_backend.to_numpy(A).T, Spectrogram -
np.dot(np.dot(mxnet_backend.to_numpy(A), mxnet_backend.to_numpy(G)),
mxnet_backend.to_numpy(B).T))
derivative = np.dot(derivative, mxnet_backend.to_numpy(B))
return derivative
def TestPositivity_single(X):
#This function is used to test if the data is inherently positive for a single tensor
#The parameter is a tensor
#Size=np.size(np.array(mxnet_backend.to_numpy(X)))
Size=np.size(mxnet_backend.to_numpy(X))
#Bool=np.sum(np.array(mxnet_backend.to_numpy(X)>=0))/Size
Bool=np.sum(np.array(mxnet_backend.to_numpy(X)>=0))/Size
if(Bool!=1):#There is at least one negative elements
return False
if(Bool==1):
return True
def Lineserchstep(X,G,listoffactors,Nonnegative,setting,A,n,Grad,a,b,alpha,theta,pool):
#This function computes the step with line search
#All the parameters are of tensor type
Matrix_list=list(listoffactors)
r=(np.sqrt(5)-1)/2
As=a
Bs=b
L=Bs-As
lambda1=As+r*r*L
lambda2=As+r*L
nb_iter=0
F1=1
F2=0
Lambda=0
while(nb_iter<5):
nb_iter=nb_iter+1
if(Nonnegative==False):
Matrix_list[n]=A-lambda1*Grad
#F1=np.power(T.norm(X-Tensor_matrixproduct(G,Matrix_list),2),2)+alpha*(1-theta)*np.power(T.norm(A,2),2)
#print(type(A))
#print(A)
#Secours=(alpha*(1-theta)/2)*np.power(tl.norm(listoffactors[n],2),2)
#pdb.set_trace()
F1=Error(X,G,Matrix_list,setting,pool)+(alpha*(1-theta)/2)*np.power(tl.norm(A,2),2)
Matrix_list[n]=tl.tensor(A-lambda2*Grad)
F2=Error(X,G,Matrix_list,setting,pool)+(alpha*(1-theta)/2)*np.power(tl.norm(A,2),2)
if(Nonnegative==True):
Matrix_list[n]=tl.tensor(np.maximum(mxnet_backend.to_numpy(A-lambda1*Grad),0))
#F1=np.power(T.norm(X-Tensor_matrixproduct(G,Matrix_list),2),2)+alpha*(1-theta)*np.power(T.norm(A,2),2)
F1=Error(X,G,Matrix_list,setting,pool)+(alpha*(1-theta)/2)*np.power(tl.norm(A,2),2)
Matrix_list[n]=tl.tensor(np.maximum(mxnet_backend.to_numpy(A-lambda2*Grad),0))
#F2=np.power(T.norm(X-Tensor_matrixproduct(G,Matrix_list),2),2)+alpha*(1-theta)*np.power(T.norm(A,2),2)
F2=Error(X,G,Matrix_list,setting,pool)+(alpha*(1-theta)/2)*np.power(tl.norm(A,2),2)
if(F1>F2):
As=lambda1
lambda1=lambda2
L=Bs-As
lambda2=As+r*L
else:
Bs=lambda2
lambda2=lambda1
L=Bs-As
lambda1=As+r*r*L
if((L<0.001) or nb_iter>=5):
Lambda=(Bs+As)/2
return Lambda
def Gramschmidt(A):
[m,n]=np.array(A.shape,dtype=int)
Q=tl.tensor(np.zeros((m,n)))
R=tl.tensor(np.zeros((n,n)))
for j in range(n):
v=A[:,j]
for i in range(j):
R[i,j]=np.dot(mxnet_backend.to_numpy(Q[:,i]).T,mxnet_backend.to_numpy(A[:,j]))
v=v-R[i,j]*Q[:,i]
R[j,j]=tl.norm(v,2)
Q[:,j]=v/R[j,j]
return Q
def HOSVD(Tensor, Coretensorsize):
N = len(Tensor.shape)
listofmatrices = []
for n in range(N):
U, s, V = np.linalg.svd(mxnet_backend.to_numpy(unfold(Tensor, n)),
full_matrices=True)
A = U[:, 0:Coretensorsize[n]]
listofmatrices.append(A)
Coretensor = Tensor_matrixproduct(
tl.tensor(Tensor),
Operations_listmatrices(
Operations_listmatrices(listofmatrices, "Transpose"), "Tensorize"))
Coretensor = mxnet_backend.to_numpy(Coretensor)
return Coretensor, listofmatrices
def Transform_tensor_into_featuresmatrix(tensor):
size=np.array(tensor.shape,dtype=int)
number_of_samples=size[0]
result=np.zeros((number_of_samples,size[1]*size[2]))
for i in range(number_of_samples):
result[i,:]=np.resize(mxnet_backend.to_numpy(tensor[i,:,:]),np.size(tensor[i,:,:]))
return result
def Proximal_operator(X, step):
#This function computes the proximal operator of the l1 norm
#X is of tensor type
#Res=np.copy(mxnet_backend.to_numpy(X))
Res = np.copy(mxnet_backend.to_numpy(X))
Res = np.sign(Res) * np.maximum(np.abs(Res) - step, 0)
return tl.tensor(Res)
def Factorupdateproblem(X, G, Ainit, listoffactorsmatrices, Nonnegative, alpha,
theta, n, maxiter, step, epsilon):
Anew = tl.tensor(Ainit)
Aold = tl.tensor(np.zeros(Anew.shape))
Aresult = tl.tensor(np.zeros(Anew.shape))
error = np.power(
tl.norm(X - Tensor_matrixproduct(G, listoffactorsmatrices), 2),
2) + alpha * (1 - theta) * np.power(tl.norm(Anew, 2), 2)
#previouserror=0
nbiter = 0
while (nbiter < maxiter):
nbiter = nbiter + 1
Aold = Anew
#previouserror=error
Anew = Aold - step * derivativeDict(X, G, Aold, listoffactorsmatrices,
alpha, theta, n)
if (Nonnegative == True):
Anew = np.maximum(mxnet_backend.to_numpy(Anew), 0)
Anew = tl.tensor(Anew)
Anew = Anew / tl.norm(Anew, 2)
error = np.power(
tl.norm(X - Tensor_matrixproduct(G, listoffactorsmatrices), 2),
2) #+alpha*(1-theta)*np.power(T.norm(Anew,2),2)
Aresult = Anew
#if(previouserror-error<epsilon):
if (np.sqrt(error) / tl.norm(X, 2) < epsilon):
Aresult = Aold
break
return Aresult
def Sparse_code(X,G_init,listoffactors,Nonnegative,step,max_iter,alpha,theta,epsilon):#The parameters are tensors
#This function is used to perform the sparse coding step
#All the tensor and parameters are of tensor type
#G_new=T.tensor(np.copy(mxnet_backend.to_numpy(G_init)))
G_new=tl.tensor(G_init)
G_old=tl.tensor(np.zeros(G_new.shape))
G_result=tl.tensor(np.zeros(G_new.shape))
error=np.power(tl.norm(X-Tensor_matrixproduct(G_new,listoffactors),2),2)#+Lambda*T.norm(G_new,1))
nb_iter=0
error_list=[error]
while(nb_iter<=max_iter):
nb_iter=nb_iter+1
G_old=G_new
G_new=G_old-step*derivativeCore(X,G_old,listoffactors)
if(Nonnegative==True):
G_new=np.maximum(mxnet_backend.to_numpy(G_old-step*(derivativeCore(X,G_old,listoffactors)))+alpha*theta*np.ones(G_old.shape),0)
G_new=tl.tensor(G_new)
if(Nonnegative==False):
G_new=Proximal_operator(G_new,step)
error=np.power(tl.norm(X-Tensor_matrixproduct(G_new,listoffactors),2),2)#+Lambda*T.norm(G_new,1)
G_result=G_new
error_list.append(error)
#if(np.abs(previous_error-error)/error<epsilon):
if(np.sqrt(error)/tl.norm(X,2)<epsilon):
G_result=G_old
error_list=error_list[0:len(error_list)-1]
break
return G_result,error_list,nb_iter
def Retraction(Point,Parameter,backendchoice):
M=Point+Parameter
if(backendchoice=='numpy'):
Q,R=np.linalg.qr(M)
if(backendchoice=='mxnet'):
Q,R=np.linalg.qr(mxnet_backend.to_numpy(M))
return tl.tensor(Q)
def Operations_listmatrices(listofmatrices,operationnature):#The parameters are tensors
Res=[]
if (operationnature=="Arrayconversion"):
for matrix in listofmatrices:
element=tl.tensor(matrix)
Res.append(mxnet_backend.to_numpy(element))
return Res
if (operationnature=="Transpose"):
for matrix in listofmatrices:
element=tl.tensor(matrix)
Res.append(element.T)#computes A.T
return Res
if(operationnature=="Transposetimes"):
for matrix in listofmatrices:
element=tl.tensor(matrix)
Matrix=tl.backend.dot(element.T,element)
Res.append(Matrix) #computes A.T*A
return Res
if(operationnature=="NormI"):
for matrix in listofmatrices:
Res.append(tl.norm(matrix,1))
return Res
if(operationnature=="NormII"):
for matrix in listofmatrices:
Res.append(np.power(tl.norm(matrix,2),2))
return Res
def derivativeDict(X,G,A,listofmatrices,alpha,theta,n):#the parameters are tensors
listoffactors=list(listofmatrices)
listoffactors[n]=tl.tensor(np.identity(X.shape[n]))
WidehatX=Tensor_matrixproduct(X,Operations_listmatrices(listoffactors,"Transpose"))
listoffactors[n]=tl.tensor(np.identity(G.shape[n]))
B=unfold(Tensor_matrixproduct(G,listoffactors),n)
Result=tl.tensor(np.dot(mxnet_backend.to_numpy(unfold(WidehatX,n)),mxnet_backend.to_numpy(unfold(G,n)).T))-tl.tensor(np.dot(mxnet_backend.to_numpy(A),np.dot(mxnet_backend.to_numpy(B),mxnet_backend.to_numpy(B).T)))+alpha*(1-theta)*A
#Res1=np.dot(A,np.dot(B,B.T))
#Res2=alpha*(1-theta)*A
return Result
def Activationcoeffsingle(args): #The parameters are tensors
Gnew = tl.tensor(args[1][args[10]])
Gold = tl.tensor(np.zeros(args[1][args[10]].shape))
Gresult = tl.tensor(np.zeros(args[1][args[10]].shape))
Matrix = np.dot(
np.dot(mxnet_backend.to_numpy(args[2]), mxnet_backend.to_numpy(Gnew)),
mxnet_backend.to_numpy(args[3]).T)
error = tl.norm(args[0][args[10]] - tl.tensor(Matrix), 2) / tl.norm(
args[0][args[10]], 2)
nbiter = 0
while (nbiter < args[5]):
nbiter = nbiter + 1
Gold = Gnew
derivative = Derivativefeatureproblem(args[0][args[10]], Gold, args[2],
args[3], args[7], args[8],
args[9])
Gnew = Gold - args[4] * derivative
if (args[9] == True):
Gnew = tl.tensor(np.maximum(mxnet_backend.to_numpy(Gnew), 0))
Gresult = Gnew
Matrix = np.dot(
np.dot(mxnet_backend.to_numpy(args[2]),
mxnet_backend.to_numpy(Gnew)),
mxnet_backend.to_numpy(args[3]).T)
error = tl.norm(args[0][args[10]] - tl.tensor(Matrix), 2) / tl.norm(
args[0][args[10]], 2)
if (error < args[6]):
break
return Gresult
def ALTO_single(X, Coretensorsize, K, Pre_existingfactors,
sigma): #All the parameters are tensors
ListoffactorsU = list(Pre_existingfactors)
ListoffactorsV = Augmentlist(ListoffactorsU, K, sigma)
Stilde = Tensor_matrixproduct(
X, Operations_listmatrices(ListoffactorsV, "Transpose"))
#core,factors=tucker(Stilde,Coretensorsize,init='random',random_state=2): this was the initial line
core, factors = tucker(Stilde,
Coretensorsize,
init='random',
random_state=1)
Listoffactorsresult = []
for i in range(len(factors)):
Listoffactorsresult.append(
np.dot(mxnet_backend.to_numpy(ListoffactorsV[i]),
mxnet_backend.to_numpy(factors[i])))
Listoffactorsresult = Operations_listmatrices(Listoffactorsresult,
"Tensorize")
return core, Listoffactorsresult
def Tensor_matrixproduct(X,listoffactors):#The parameters are tensors(tensor and matrices)
Res=tl.tensor(np.copy(mxnet_backend.to_numpy(X)))
mode=-1
for matrix in listoffactors:
mode=mode+1
Res=tenalg.mode_dot(Res,matrix,mode)
return Res
def OnlineTensorlearningallblocks(Similaritymatrix, listresponses,
listpredictors, Rank, P, Q, M, K, mu, alpha,
Methodname):
#listresponses contain the data for two consecutive time samples
Choleskysimilaritymatrix = np.copy(Similaritymatrix)
Oldparamtensor = np.zeros((P, Q, M))
Coretensorsize = [Rank, Rank, Rank]
rmselist = []
for m in range(M):
#pdb.set_trace()
Oldparamtensor[:, :,
m] = np.dot(listresponses[0][:, :, m],
np.linalg.pinv(listpredictors[0][:, :, m]))
Core, Newloadingmatrices = HOSVD(
tl.tensor(Oldparamtensor), Coretensorsize
) #tucker(tl.tensor(Oldparamtensor),Coretensorsize,init='svd',random_state=1)
Newparametertensor = Tensor_matrixproduct(
tl.tensor(Core),
Operations_listmatrices(Newloadingmatrices, "Tensorize"))
Oldloadingmatrices = []
for l in range(len(listresponses) - 1):
ResponsetensorX = listresponses[l + 1]
PredictortensorZ = listpredictors[l + 1]
Oldparamtensor = Newparametertensor
Oldloadingmatrices = Newloadingmatrices
print("The block number is")
print(l)
Newparametertensor, Newloadingmatrices = OnlineTensorlearningsingleblock(
Choleskysimilaritymatrix, mxnet_backend.to_numpy(Oldparamtensor),
Oldloadingmatrices, ResponsetensorX, PredictortensorZ, alpha, M, K,
Coretensorsize, Methodname)
rmselist.append(
RMSE(ResponsetensorX, mxnet_backend.to_numpy(Newparametertensor),
PredictortensorZ))
return mxnet_backend.to_numpy(Newparametertensor), rmselist
def Dictionary_update(X,G,listofmatrices,Nonnegative,Pold,Qold,setting,alpha,theta,step,max_iter,epsilon,n,t,period,pool):
#This function is used to perform the gradient descent with line search while enforcing nonnegativity if this option is chosen
#All the parameters are tensors
Anew=tl.tensor(listofmatrices[n])
Aold=tl.tensor(np.zeros(Anew.shape))
Aresult=tl.tensor(np.zeros(Anew.shape))
listoffactors=list(listofmatrices)
error=Error(X,G,listoffactors,setting,pool)#+(alpha*(1-theta)/2)*np.power(T.norm(Anew,2),2)
error_list=[error]
#previous_error=0
nb_iter=0
while(nb_iter<=max_iter):
nb_iter=nb_iter+1
#previous_error=error
Aold=Anew
if(Nonnegative==True):
derivative=derivativeDict(X,G,Aold,listofmatrices,Pold,Qold,setting,alpha,theta,n,t)
if( (nb_iter%period)==0 or (nb_iter==1) ):
a=step/10
b=step
step=Lineserchstep(X,G,listoffactors,Nonnegative,setting,Aold,n,derivative,a,b,alpha,theta,pool)
#Anew=np.maximum(Aold-step*derivativeDict(X,G,Aold,listofmatrices,Pold,Qold,setting,alpha,theta,n,t),0)
Anew=tl.tensor(np.maximum(mxnet_backend.to_numpy(Aold-step*derivative),0))
#Anew=Anew/tl.norm(Anew,2)
#pdb.set_trace()
if(Nonnegative==False):
derivative=derivativeDict(X,G,Aold,listofmatrices,Pold,Qold,setting,alpha,theta,n,t)
if( (nb_iter%period)==0 or (nb_iter==1) ):
a=step/10
b=step
step=Lineserchstep(X,G,listoffactors,Nonnegative,setting,Aold,n,derivative,a,b,alpha,theta,pool)
#Lineserchstep(X,G,listoffactors,Nonnegative,setting,A,n,Grad,a,b,alpha,theta,pool)
Anew=Aold-step*derivativeDict(X,G,Aold,listofmatrices,Pold,Qold,setting,alpha,theta,n,t)
Anew=Anew/tl.norm(Anew,2)
#listoffactors[n]=Anew
#error=T.norm(X-Tensor_matrixproduct(G,listoffactors),2)+alpha*(1-theta)*T.norm(Anew,2)
#pdb.set_trace()
error=Error(X,G,listoffactors,setting,pool)#+alpha*(1-theta)*T.norm(Anew,2)
error_list.append(error)
Aresult=Anew
#print(Norm(X,setting,pool))
#pdb.set_trace()
#if(np.abs(previous_error-error)/error<epsilon):
if(error/Norm(X,setting,pool)<epsilon):
Aresult=Aold
error_list=error_list[0:len(error_list)-1]
break
return Aresult,error_list,nb_iter
def GenerateTensorsNonnegative(Numberofexamples,randomseed):
np.random.seed(randomseed)
Xtrain=np.random.rand(Numberofexamples,30,40,50)
Coretensorsize=np.array([Numberofexamples,20,20,20])
Greal=np.maximum(np.random.normal(loc=0,scale=1,size=Coretensorsize),0)
#The line below changes
listoffactorsreal=[np.random.normal(loc=0,scale=1/10,size=(30,20)),np.random.normal(loc=0,scale=1/10,size=(40,20)),np.random.normal(loc=0,scale=1/10,size=(50,20))]
listoffactorsreal=Nonnegativepart(listoffactorsreal)
for n in range(Numberofexamples):
Xtrain[n,:,:,:]=mxnet_backend.to_numpy(Tensor_matrixproduct(tl.tensor(Greal[n,:,:,:]),Operations_listmatrices(listoffactorsreal,"Tensorize")))
#Xtrain=Xtrain/T.norm(T.tensor(Xtrain),2)
return Xtrain
def Derivativefeatureproblem(Spectrogram, G, A, B, alpha, theta,
Nonnegative): #The parameters are tensors
derivative = -np.dot(
mxnet_backend.to_numpy(A).T,
mxnet_backend.to_numpy(Spectrogram) -
np.dot(np.dot(mxnet_backend.to_numpy(A), mxnet_backend.to_numpy(G)),
mxnet_backend.to_numpy(B).T))
derivative = np.dot(derivative, mxnet_backend.to_numpy(B))
if (Nonnegative == True):
derivative = derivative + alpha * theta * np.ones(G.shape)
return tl.tensor(derivative)
def Reconstruction(Originalimage,patchsize,Coretensorsize,alpha,theta,val,pool):
[I,J,K]=np.array(Originalimage.shape,dtype=int)
Listrestauration=[]
n0=np.min([I,J])
Imrestored=np.zeros((I,J,K))
nbpatches=int(np.floor(n0/patchsize))
Setofpatches=np.zeros((patchsize,patchsize,3,nbpatches))
slicenumber=0
mask=Definemasksingleslice(Originalimage,val,slicenumber)
Setofpatches=Patch_extractionallslices(Originalimage,mask,patchsize,val)
Xtrain_set=[]
for l in range(nbpatches):
Xtrain_set.append(tl.tensor(Setofpatches[:,:,:,l]))
max_iter=100
period=3
Nonnegative=True
epsilon=np.power(10,-3,dtype=float)
step=np.power(10,-6,dtype=float)
Setting="Single"
nbepochs=10
Reprojectornot=False
Minibatchsize=[]
Pre_existingfactors=[]
penaltylasso=alpha*theta
Pre_existingG_settrain=[]
for l in range(nbpatches):
Pre_existingG_settrain.append(tl.tensor(np.maximum(np.random.normal(loc=0,scale=1/4,size=Coretensorsize),0)))
Pre_existingfactors=[tl.tensor(np.maximum(np.random.normal(loc=0,scale=1/4,size=(patchsize,Coretensorsize[0])),0)),tl.tensor(np.maximum(np.random.normal(loc=0,scale=1/4,size=(patchsize,Coretensorsize[1])),0)),tl.tensor(np.maximum(np.random.normal(loc=0,scale=1/4,size=(K,Coretensorsize[2])),0))]
Pre_existingP=[tl.tensor(np.random.normal(loc=0,scale=2,size=(patchsize,Coretensorsize[0]))),tl.tensor(np.random.normal(loc=0,scale=2,size=(patchsize,Coretensorsize[1]))),tl.tensor(np.random.normal(loc=0,scale=2,size=(K,Coretensorsize[2])))]
Pre_existingQ=[tl.tensor(np.random.normal(loc=0,scale=2,size=(Coretensorsize[0],Coretensorsize[0]))),tl.tensor(np.random.normal(loc=0,scale=2,size=(Coretensorsize[1],Coretensorsize[1]))),tl.tensor(np.random.normal(loc=0,scale=2,size=(Coretensorsize[2],Coretensorsize[2])))]
Dictionarymatrices,listobjectivefunctionvalues,Objectivefunction_per_epoch=CyclicBlocCoordinateTucker_setWithPredefinedEpochs(Xtrain_set,Coretensorsize,Pre_existingfactors,Pre_existingG_settrain,backendchoice,Pre_existingP,Pre_existingQ,Nonnegative,Reprojectornot,Setting,Minibatchsize,step,alpha,theta,max_iter,epsilon,period,nbepochs,pool)
Dm=list(Dictionarymatrices)
Dictionarymatricesconverted=Operations_listmatrices(Dictionarymatrices,"Arrayconversion")
mask=Definemasksingleslice(Originalimage,val,0)
for i in range(nbpatches):
for j in range(nbpatches):
patchmask=mask[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize]#[indx,indy]
Aux=Originalimage[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize,:]#[indx,indy,:]
Aux=np.resize(Aux,np.size(Aux))
patchmask=Repetition(patchmask,K)
Auxmask=np.resize(patchmask,np.size(patchmask))
Ind=np.where(Auxmask!=val)[0] #np.nonzero(Auxmask)[0]
yy=Aux[Ind]
Dictionarymatrix=np.kron(Dictionarymatricesconverted[0],Dictionarymatricesconverted[1])
Dictionarymatrix=np.kron(Dictionarymatrix,Dictionarymatricesconverted[2])
Dma=Dictionarymatrix[Ind,:]
clf=linear_model.Lasso(alpha=penaltylasso,fit_intercept=False,positive=True)#fit_intercept=False
clf.fit(Dma,yy)
Activationcoeff=np.reshape(clf.coef_,Coretensorsize)
Restore=Tensor_matrixproduct(Activationcoeff,Dm)
Restore=mxnet_backend.to_numpy(Restore)
Listrestauration.append(Restore)
return Imrestored,Listrestauration
#val=255 #value which allows to define the missing pixels
#ratio=0.4 #ratio of missing pixels
#Hyperspectralimg=np.array(Image.open("Lena.png"))
#[W,H,K]=np.array(Hyperspectralimg.shape,dtype=int)
#Hyperspectralimg=Hyperspectralimg+np.maximum(np.random.normal(loc=0,scale=1,size=(W,H,K)),0)/10
#plt.imshow(Hyperspectralimgpixelsdropped)
#plt.show()
#pdb.set_trace()
#patchsize=16
#Rank=16
#alpha=0.001
#theta=0.1
#[width,length,spectralbands]=np.array(Hyperspectralimg.shape,dtype=int)
#Commonsize=np.min(np.array([width,length,spectralbands]))
#Corentensorsize=[int(Rank),int(Rank),int(Rank)]
#pool=Pool(20)
#Imrestored,Listrestauration=Reconstruction(Hyperspectralimgpixelsdropped,patchsize,Corentensorsize,alpha,theta,val,pool)
#pdb.set_trace()
def CyclicBlocCoordinateTucker_set(X_set,Coretensorsize,Pre_existingfactors,Pre_existingG_set,Pre_existingP,Pre_existingQ,Nonnegative,Reprojectornot,Setting,Minibatchnumber,step,alpha,theta,max_iter,epsilon,period,pool):#All the parameters are arrays,
#This function is used to perform the online setting either for single or minibatch processing
if(Nonnegative==True):
Positivity=TestPositivity(X_set)
if(Positivity==False):
raise Exception("You decide to perform a nonnegative decomposition while some of your tensors present negative entries")
L=len(X_set)
Inferredfactorsresult=list(Pre_existingfactors)
listofactorsfactorsinit=[]
if(Setting=="Single"):
for t in range(L):
print("We are in single online")
print("The tensor processed is")
print(t)
X=X_set[t]
Pre_existingG=Pre_existingG_set[t]
listofactorsfactorsinit=Inferredfactorsresult
Gresult,Inferredfactorsresult=CyclicBlocCoordinateTucker_single(X,Coretensorsize,listofactorsfactorsinit,Pre_existingG,Pre_existingP,Pre_existingQ,Nonnegative,Setting,t+1,step,alpha,theta,max_iter,epsilon,period,pool)
# print("The tensor processed is")
# print(t)
# print(Nonnegative)
# print("The values ofnthe factors are")
#
# print(Inferredfactorsresult[0])
# print(Inferredfactorsresult[1])
# print(Inferredfactorsresult[2])
# print(np.sum(mxnet_backend.to_numpy(Inferredfactorsresult[0])))
# print(np.sum(mxnet_backend.to_numpy(Inferredfactorsresult[1])))
# print(np.sum(mxnet_backend.to_numpy((Inferredfactorsresult[2]))))
N=len(list(X.shape))
Pre_existingG=np.copy(Gresult)
G=tl.tensor(Gresult)
for n in range(N):
listoffactors=list(Inferredfactorsresult)
listoffactors[n]=np.identity(X.shape[n])
WidehatX=Tensor_matrixproduct(X,Operations_listmatrices(listoffactors,"Transpose"))
listoffactors[n]=tl.tensor(np.identity(G.shape[n]))
B=Tensor_matrixproduct(tl.tensor(G),listoffactors)
Pre_existingP[n]=Pre_existingP[n]+np.dot(mxnet_backend.to_numpy(unfold(WidehatX,n)),mxnet_backend.to_numpy(unfold(G,n)).T)
Pre_existingQ[n]=Pre_existingQ[n]+np.dot(mxnet_backend.to_numpy(unfold(B,n)),mxnet_backend.to_numpy(unfold(B,n).T))
if(Reprojectornot==True):
Gresult=[]
for t in range(L):
X=X_set[t]
G_init=Pre_existingG_set[t]
G=Sparse_coding(tl.tensor(X),tl.tensor(G_init),Operations_listmatrices(Inferredfactorsresult,"Tensorize"),Nonnegative,Setting,step,max_iter,alpha,theta,epsilon,pool)
Gresult.append(G)
return Gresult,Inferredfactorsresult
if(Reprojectornot==False):
return Inferredfactorsresult
if(Setting=="MiniBatch"):
X_setdivided=SplitToMinibatch(X_set,Minibatchnumber)
Pre_existingGsetdivided=SplitToMinibatch(Pre_existingG_set,Minibatchnumber)
Pre_existingPold=[]
Pre_existingPnew=list(Pre_existingP)
Pre_existingQold=[]
Pre_existingQnew=list(Pre_existingQ)
#for mininb in range(Minibatchnumber):
for mininb in range(len(Minibatchnumber)):
print("We are minibatch")
print("The minibatch processed is")
print(mininb)
X_minibatch=X_setdivided[mininb]
Pre_existingG_minibatch=Pre_existingGsetdivided[mininb]
Pre_existingPold=Pre_existingPnew
Pre_existingQold=Pre_existingQnew
print("Point I")
Gresult,Inferredfactorsresult=CyclicBlocCoordinateTucker_single(X_minibatch,Coretensorsize,Pre_existingfactors,Pre_existingG_minibatch,Pre_existingPold,Pre_existingQold,Nonnegative,Setting,mininb+1,step,alpha,theta,max_iter,epsilon,period,pool)
print("Point II")
if(mininb!=len(Minibatchnumber)-1):
X_minibatchold=Operations_listmatrices(X_setdivided[mininb],"Tensorize")
N=len(list(X_minibatchold[0].shape))
Inferredfactorsresult=Operations_listmatrices(Inferredfactorsresult,"Tensorize")
minibatchsize=len(X_minibatchold)
Gactivationcoeff=list(Gresult)
for n in range(N):
for r in range(minibatchsize):
X=X_minibatchold[r]
G=Gactivationcoeff[r]
listoffactors=list(Inferredfactorsresult)
listoffactors[n]=np.identity(X.shape[n])
WidehatX=Tensor_matrixproduct(tl.tensor(X),Operations_listmatrices(listoffactors,"Transpose"))
listoffactors[n]=np.identity(G.shape[n])
B=Tensor_matrixproduct(tl.tensor(G),Operations_listmatrices(listoffactors,"Tensorize"))
Pre_existingPnew[n]=Pre_existingPold[n]+np.dot(mxnet_backend.to_numpy(unfold(WidehatX,n)),mxnet_backend.to_numpy(unfold(G,n)).T)
Pre_existingQnew[n]=Pre_existingQold[n]+np.dot(mxnet_backend.to_numpy(unfold(B,n)),mxnet_backend.to_numpy(unfold(B,n)).T)
if(Reprojectornot==True):
for mininb in range(len(Minibatchnumber)):
X_minibatch=Operations_listmatrices(X_setdivided[mininb],"Tensorize")
G_init=Operations_listmatrices(Pre_existingGsetdivided[mininb],"Tensorize")
G=Sparse_coding(X_minibatch,G_init,Inferredfactorsresult,Nonnegative,Setting,step,max_iter,alpha,theta,epsilon,pool)
for activation_coeff in G:
Gresult.append(activation_coeff)
return Gresult,Inferredfactorsresult
if(Reprojectornot==False):
return Inferredfactorsresult
def Proximal_operator(X,step):#The parameter is a tensor
Res=np.copy(mxnet_backend.to_numpy(X))
Res=np.sign(Res)*np.maximum(np.abs(Res)-step,0)
return tl.tensor(Res)
def derivativeDict(X, G, A, listofmatrices, Pold, Qold, setting, alpha, theta,
n, t):
#The function is used to compute the derivative of the objective function with respect the nth dictionary matrix
#The parameters are tensors
listoffactors = list(listofmatrices)
#Pnew=T.tensor(np.copy(mxnet_backend.to_numpy(Pold)))
#Qnew=T.tensor(np.copy(mxnet_backend.to_numpy(Qold)))
Pnew = tl.tensor(Pold)
Qnew = tl.tensor(Qold)
if (setting == "Single"):
listoffactors[n] = np.identity(X.shape[n])
WidehatX = Tensor_matrixproduct(
X, Operations_listmatrices(listoffactors, "Transpose"))
listoffactors[n] = tl.tensor(np.identity(G.shape[n]))
B = Tensor_matrixproduct(G, listoffactors)
#B=unfold(Offset(G),mode)
#pdb.set_trace()
Pnew = Pnew + tl.tensor(
np.dot(mxnet_backend.to_numpy(unfold(WidehatX, n)),
mxnet_backend.to_numpy(unfold(G, n)).T))
Qnew = Qnew + tl.tensor(
np.dot(mxnet_backend.to_numpy(unfold(B, n)),
mxnet_backend.to_numpy(unfold(B, n)).T))
Res = -Pnew / t + tl.tensor(
np.dot(mxnet_backend.to_numpy(A), mxnet_backend.to_numpy(Qnew)) /
t) + alpha * (1 - theta) * A
return Res
if (setting == "MiniBatch"):
rho = len(X)
for r in range(rho):
listoffactors[n] = tl.tensor(np.identity(X[r].shape[n]))
WidehatX = Tensor_matrixproduct(
X[r], Operations_listmatrices(listoffactors, "Transpose"))
Pnew = Pnew + tl.tensor(
np.dot(mxnet_backend.to_numpy(unfold(WidehatX, n)),
mxnet_backend.to_numpy(unfold(G[r], n)).T))
listoffactors[n] = tl.tensor(np.identity(G[r].shape[n]))
B = Tensor_matrixproduct(G[r], listoffactors)
Qnew = Qnew + tl.tensor(
np.dot(mxnet_backend.to_numpy(unfold(B, n)),
mxnet_backend.to_numpy(unfold(B, n).T)))
Res = -Pnew / t + tl.tensor(
np.dot(mxnet_backend.to_numpy(A), mxnet_backend.to_numpy(Qnew)) /
t) + alpha * (1 - theta) * A
return Res
def Reconstruction(Originalimage,patchsize,Rank,alpha,theta,val,pool):
[I,J]=np.array(Originalimage.shape,dtype=int)
Listrestauration=[]
n0=np.min([I,J])
Imrestored=np.zeros((I,J))
#nbx=int(np.floor(n0/patchsize))
nbpatches=int(np.floor(n0/patchsize))
Setofpatches=np.zeros((patchsize,patchsize,nbpatches))
mask=Definemasksingleslice2d(Originalimage,val)
Setofpatches=Patch_extractionallslices2d(Originalimage,mask,patchsize,val)
Xtrain=np.zeros((nbpatches,patchsize,patchsize))
for l in range(nbpatches):
Xtrain[l,:,:]=tl.tensor(Setofpatches[:,:,l])
max_iter=500#0
period=3
Nonnegative=False
epsilon=np.power(10,-3,dtype=float)
step=np.power(10,-5,dtype=float)#np.power(10,-5,dtype=float)
Setting="Single"
nbepochs=3
Reprojectornot=False
Minibatchsize=[]
Pre_existingfactors=[]
Coretensorsize=[Rank,Rank]
penaltylasso=alpha*theta
Ginittrain=np.zeros((nbpatches,Coretensorsize[0],Coretensorsize[1]))
for l in range(nbpatches):
Ginittrain[l,:,:]=tl.tensor(np.maximum(np.random.normal(loc=0,scale=1,size=Coretensorsize),0))
listoffactorsinit=[tl.tensor(np.identity(nbpatches)),tl.tensor(np.maximum(np.random.normal(loc=0,scale=1,size=(patchsize,Coretensorsize[0])),0)),tl.tensor(np.maximum(np.random.normal(loc=0,scale=1,size=(patchsize,Coretensorsize[1])),0))]
start_timetraining=time.clock()
Dictionarymatrices,errorlist,listobjectivefunctionvalues,nbiter=TuckerBatch(Xtrain,[nbpatches,Coretensorsize[0],Coretensorsize[1]],max_iter,listoffactorsinit,Ginittrain,Nonnegative,backendchoice,Reprojectornot,alpha,theta,step,epsilon,pool)
#Dictionarymatrices,errorlist,listobjectivefunctionlist,Objectivefnction_per_epoch,Time_per_epoch,nbiter=TuckerBatch(Xtrain,[nbpatches,Coretensorsize[0],Coretensorsize[1]],max_iter,listoffactorsinit,Ginittrain,Nonnegative,backendchoice,Reprojectornot,alpha,theta,step,epsilon,pool)
#pdb.set_trace()
end_timetraining=time.clock()
Runningtime=end_timetraining-start_timetraining
print("The running time")
print(Runningtime)
pdb.set_trace()
#adress='/Users/Traoreabraham/Desktop/OnlineTensorDictionaryLearning/Hyperspecimpainting/Objectivefunctions/TuckerObjectivefunction'+str(Rank)
#adress='/home/scr/etu/sil821/traorabr/ImageInpainting/Objectivefunctions/TuckerObjectivefunction'+str(Rank)
#np.savez_compressed(adress,Objectivefunction=listobjectivefunctionlist,Objectivefnctionperepoch=Objectivefnction_per_epoch,Timeperepoch=Time_per_epoch)
#pdb.set_trace()
Dm=list(Dictionarymatrices[1:3])
Dictionarymatricesconverted=Operations_listmatrices(Dictionarymatrices[1:3],"Arrayconversion")
mask=Definemasksingleslice2d(Originalimage,val)
#plt.imshow(mask)
#plt.show()
#pdb.set_trace()
for i in range(nbpatches):
for j in range(nbpatches):
#indx=np.array(np.linspace(i*patchsize+1,(i+1)*patchsize,patchsize),dtype=int)
#indy=np.array(np.linspace(j*patchsize+1,(j+1)*patchsize,patchsize),dtype=int)
#pdb.set_trace()
#patchmask=mask[i*patchsize+1:(i+1)*patchsize,j*patchsize+1:(j+1)*patchsize]#[indx,indy]
#Aux=Originalimage[i*patchsize+1:(i+1)*patchsize,j*patchsize+1:(j+1)*patchsize,:]#[indx,indy,:]
patchmask=mask[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize]#[indx,indy]
#plt.imshow(patchmask)
#plt.show()
#print(patchmask)
Aux=Originalimage[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize]#[indx,indy,:]
Aux=np.resize(Aux,np.size(Aux))
#patchmask=Repetition(patchmask,K)
Auxmask=np.resize(patchmask,np.size(patchmask))
Ind=np.where(Auxmask!=val)[0] #np.nonzero(Auxmask)[0]
yy=Aux[Ind]
Dictionarymatrix=np.kron(Dictionarymatricesconverted[0],Dictionarymatricesconverted[1])
Dma=Dictionarymatrix[Ind,:]
clf=linear_model.Lasso(alpha=penaltylasso,fit_intercept=False,positive=True)#fit_intercept=False
#print(Dma.shape)
#print(yy.shape)
clf.fit(Dma,yy)
#print(clf.coef_.shape)
#pdb.set_trace()
Activationcoeff=np.reshape(clf.coef_,(Rank,Rank))
Restore=Tensor_matrixproduct(Activationcoeff,Dm)
Restore=mxnet_backend.to_numpy(Restore)
#plt.imshow(Originalimage[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize,:])
#plt.show()
#plt.imshow(Restore)
#plt.show()
Listrestauration.append(Restore)
#plt.imshow(Restore)
#plt.show()
#plt.imshow(Originalimage[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize,:])
#plt.show()
#pdb.set_trace()
#print(np.argwhere(Restore==0))
#print(i*patchsize)
#print((i+1)*patchsize)
#print(j*patchsize)
#print((j+1)*patchsize)
Imrestored[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize]=Restore
#print(Restore)
#pdb.set_trace()
#print("The values of i and j are")
#print(i,j)
return Imrestored,Listrestauration,Runningtime
def RobustsubspaceLearning_Single(X, Pre_existingprojectionmatrices,
Pre_existingenergymatrices, Pre_existingmean,
beta, alpha, p): #All parameters are arrays
Tensor = tl.tensor(X)
listoffactors = list(Pre_existingprojectionmatrices)
listoffactors = Operations_listmatrices(listoffactors, "Tensorize")
Energymatrices = list(Pre_existingenergymatrices)
Mean = np.copy(Pre_existingmean)
N = len(list(Tensor.shape))
R = Tensor - Tensor_matrixproduct(
X, Operations_listmatrices(listoffactors, "Transposetimes"))
Weightmatriceslist = []
for n in range(N):
Eigenvalue = np.linalg.eig(Energymatrices[n])[0]
U = listoffactors[n]
[I, J] = np.array(U.shape, dtype=int)
Xn = unfold(Tensor, mode=n)
[In, Jn] = np.array(Xn.shape, dtype=int)
Weightmatrix = np.zeros((In, Jn))
Sigma = np.zeros((In, Jn))
for i in range(In):
for j in range(Jn):
Sigma[i, j] = np.max(
np.multiply(np.sqrt(np.abs(Eigenvalue[1:p])),
mxnet_backend.to_numpy(U[1:p, i])))
k = beta * Sigma
if (n == 1):
R = R.T
for i in range(In):
for j in range(Jn):
#Weightmatrix[i,j]=1/(1+np.power(mxnet_backend.to_numpy(R[i,j])/np.maximum(k[i,j],0.001),2)):#This was the initial line
Weightmatrix[i, j] = 1 / (
1 + np.power(R[i, j] / np.maximum(k[i, j], 0.001), 2))
Weightmatriceslist.append(Weightmatrix)
W = np.minimum(Weightmatriceslist[0], Weightmatriceslist[1].T)
WeightTensor = tl.tensor(
np.multiply(np.sqrt(mxnet_backend.to_numpy(W)),
mxnet_backend.to_numpy(Tensor)))
Mean = alpha * Mean + (1 - alpha) * mxnet_backend.to_numpy(WeightTensor)
Projectionmatricesresult = []
Energymatreicesresult = []
for n in range(N):
Xn = unfold(WeightTensor, mode=n)
Covariancematrix = np.dot(
np.dot(
mxnet_backend.to_numpy(listoffactors[n]).T, Energymatrices[n]),
mxnet_backend.to_numpy(listoffactors[n]))
Covariancematrix = alpha * Covariancematrix + (1 - alpha) * np.dot(
mxnet_backend.to_numpy(Xn),
mxnet_backend.to_numpy(Xn).T)
[Un, diagn, V] = np.linalg.svd(Covariancematrix)
diagn = diagn / np.power(tl.norm(Xn, 2), 2)
indices = np.argsort(diagn)
indices = np.flip(indices, axis=0)
[J, I] = np.array(listoffactors[n].shape, dtype=int)
Unew = np.zeros((J, I))
for j in range(J):
Unew[j, :] = Un[indices[j], :]
Sn = np.diag(diagn)
Projectionmatricesresult.append(Unew)
Energymatreicesresult.append(Sn)
return Projectionmatricesresult, Energymatreicesresult, Mean, WeightTensor
def Reconstruction2d(Originalimage, patchsize, Coretensorsize, alpha, theta,
val, pool):
[I, J] = np.array(Originalimage.shape, dtype=int)
Listrestauration = []
n0 = np.min([I, J])
Imrestored = np.zeros((I, J))
#nbx=int(np.floor(n0/patchsize))
nbpatches = int(np.floor(n0 / patchsize))
Setofpatches = np.zeros((patchsize, patchsize, nbpatches))
mask = Definemasksingleslice2d(Originalimage, val)
Setofpatches = Patch_extractionallslices2d(Originalimage, mask, patchsize,
val)
Xtrain_set = []
for l in range(nbpatches):
Xtrain_set.append(tl.tensor(Setofpatches[:, :, l]))
max_iter = 100
period = 3
Nonnegative = True
epsilon = np.power(10, -3, dtype=float)
step = np.power(10, -5, dtype=float) #np.power(10,-6,dtype=float)
Setting = "Single"
nbepochs = 1 #5
Reprojectornot = False
Minibatchsize = []
Pre_existingfactors = []
#Coretensorsize=[Rank,Rank,Rank]
penaltylasso = alpha * theta
Pre_existingG_settrain = []
for l in range(nbpatches):
Pre_existingG_settrain.append(
tl.tensor(
np.maximum(
np.random.normal(loc=0, scale=1, size=Coretensorsize), 0)))
Pre_existingfactors = [
tl.tensor(
np.maximum(
np.random.normal(loc=0,
scale=1,
size=(patchsize, Coretensorsize[0])), 0)),
tl.tensor(
np.maximum(
np.random.normal(loc=0,
scale=1,
size=(patchsize, Coretensorsize[1])), 0))
]
Pre_existingP = [
tl.tensor(
np.random.normal(loc=0,
scale=1,
size=(patchsize, Coretensorsize[0]))),
tl.tensor(
np.random.normal(loc=0,
scale=1,
size=(patchsize, Coretensorsize[1])))
]
Pre_existingQ = [
tl.tensor(
np.random.normal(loc=0,
scale=1,
size=(Coretensorsize[0], Coretensorsize[0]))),
tl.tensor(
np.random.normal(loc=0,
scale=1,
size=(Coretensorsize[1], Coretensorsize[1])))
]
#Dictionarymatrices,listobjectivefunctionvalues,Objectivefunction_per_epoch=CyclicBlocCoordinateTucker_setWithPredefinedEpochs(Xtrain_set,Coretensorsize,Pre_existingfactors,Pre_existingG_settrain,backendchoice,Pre_existingP,Pre_existingQ,Nonnegative,Reprojectornot,Setting,Minibatchsize,step,alpha,theta,max_iter,epsilon,period,nbepochs,pool)
Starttime = time.time()
Gresult4, Dictionarymatrices = ALTO_setWithpredefinedEpochs(
Xtrain_set, Coretensorsize, Pre_existingfactors, 5, pool, 1, nbepochs)
Endtime = time.time()
Runningtime = Endtime - Starttime
print("The running time is")
print(Runningtime)
pdb.set_trace()
Dm = list(Dictionarymatrices)
Dictionarymatricesconverted = Operations_listmatrices(
Dictionarymatrices, "Arrayconversion")
mask = Definemasksingleslice2d(Originalimage, val)
#plt.imshow(mask)
#plt.show()
#pdb.set_trace()
for i in range(nbpatches):
for j in range(nbpatches):
#indx=np.array(np.linspace(i*patchsize+1,(i+1)*patchsize,patchsize),dtype=int)
#indy=np.array(np.linspace(j*patchsize+1,(j+1)*patchsize,patchsize),dtype=int)
#pdb.set_trace()
#patchmask=mask[i*patchsize+1:(i+1)*patchsize,j*patchsize+1:(j+1)*patchsize]#[indx,indy]
#Aux=Originalimage[i*patchsize+1:(i+1)*patchsize,j*patchsize+1:(j+1)*patchsize,:]#[indx,indy,:]
patchmask = mask[i * patchsize:(i + 1) * patchsize,
j * patchsize:(j + 1) * patchsize] #[indx,indy]
#plt.imshow(patchmask)
#plt.show()
#print(patchmask)
Aux = Originalimage[i * patchsize:(i + 1) * patchsize, j *
patchsize:(j + 1) * patchsize] #[indx,indy,:]
Aux = np.resize(Aux, np.size(Aux))
#patchmask=Repetition(patchmask,K)
Auxmask = np.resize(patchmask, np.size(patchmask))
Ind = np.where(Auxmask != val)[0] #np.nonzero(Auxmask)[0]
yy = Aux[Ind]
Dictionarymatrix = np.kron(Dictionarymatricesconverted[0],
Dictionarymatricesconverted[1])
Dma = Dictionarymatrix[Ind, :]
clf = linear_model.Lasso(alpha=penaltylasso,
fit_intercept=False,
positive=False) #fit_intercept=False
#print(Dma.shape)
#print(yy.shape)
clf.fit(Dma, yy)
#print(clf.coef_.shape)
#pdb.set_trace()
Activationcoeff = np.reshape(clf.coef_, (Rank, Rank))
Restore = Tensor_matrixproduct(Activationcoeff, Dm)
Restore = mxnet_backend.to_numpy(Restore)
#plt.imshow(Originalimage[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize,:])
#plt.show()
#plt.imshow(Restore)
#plt.show()
Listrestauration.append(Restore)
#plt.imshow(Restore)
#plt.show()
#plt.imshow(Originalimage[i*patchsize:(i+1)*patchsize,j*patchsize:(j+1)*patchsize,:])
#plt.show()
#pdb.set_trace()
#print(np.argwhere(Restore==0))
#print(i*patchsize)
#print((i+1)*patchsize)
#print(j*patchsize)
#print((j+1)*patchsize)
Imrestored[i * patchsize:(i + 1) * patchsize,
j * patchsize:(j + 1) * patchsize] = Restore
#print(Restore)
#pdb.set_trace()
#print("The values of i and j are")
#print(i,j)
return Imrestored, Listrestauration