#!/usr/bin/env python3

# -*- coding: utf-8 -*-

"""

Created on Wed Aug 8 10:41:21 2018

@author: Anna SONG

KSD.py implements the `2D Kendall Shape Dictionary' that we propose in

[Song, Uhlmann, Fageot & Unser, Dictionary Learning for 2D Kendall Shapes (2019)].

Given a dataset of preshapes z_1,...,z_K in (C^N,Phi) endowed with the Hermitian

product Phi, the original problem to be minimized by

the dictionary D = [d_1,...,d_J] \in \C^{N \times J}

the weights A = [a_1,...,a_K] \in \C^{J \times K}

is written as

min_{D,A} sum_k d_F([z_k],[D a_k])^2 (*)

- d_F is the Full Procrustes distance

- where the atoms d_j in C^N are constrained to be preshapes

- the weights a_k in C^J are subject to |a_k|_0 <= N_0

- and such that D a_k are preshapes.

As shown in our article, this can be reformulated as as simple L2 problem in the complex setting

min_{D,A} sum_k || z_k - D a_k ||_Phi^2 (**)

- where the atoms d_j in C^N are constrained to be preshapes

- and the weights a_k in C^J are subject to |a_k|_0 <= N_0.

The solutions to the two minimization problems are equivalent up to a rescaling of the weights a_k.

KSD.py implements the minimization in the form of (**).

The 2D Kendall Shape Dictionary classically alternates between:

- a sparse coding step : the weights A are updated using a Cholesky-based

Order Recursive Matching Pursuit (ORMP), as a direct adaptation to the

complex setting of Mairal's implementation for the real setting in the SPAMS toolbox.

- a dictionary update : following the Method of Optimal Directions (MOD),

we update D as

D <- [z_1,...,z_K] @ A^H @ (A @ A^H)^{-1}

D <- Pi_S(D) (center and normalize all the atoms d_j)

Rmks:

- there is no need for a gradient descent with respect to D, although the expression

of the gradient can be explicited:

Grad_D [ sum_k || z_k - D a_k ||_Phi^2 ]

= 2 Phi (D @ sum_k a_k @ a_k^H - sum_k z_k @ a_k^H )

- after the sparse coding step in (**), D a_k are not preshapes, but just centered.

One can decide to rescale them so as to obtain preshapes.

- the sparse coding step ensures that the reconstructions D a_k in (**) are optimally

aligned to the data z_k (resp., optimally rotated in (*) if considering the corresponding

preshapes).

- in the dictionary update step:

- if A @ A^H is not invertible, we use the

SVD decomposition of A (see the article).

- In practice, the preshaping step D <- Pi_S(D) is just the normalization of

all the columns d_j (because the previous operation already centers them,

since z_1,...,z_K are already centered).

"""

import numpy as np

from numpy import pi

import matplotlib.pyplot as plt

import os

import scipy

import random

import time

from settings import M, N, K, data_type, test_k_set, database, choice, shapes # dataset contained in shapes

from settings import draw, drawMany

from settings import Psi, Phi, norm, her

from settings import multi_complex2real

from shapespace import theta, align_rot

import multiprocessing as mp

from itertools import product

from itertools import repeat

''' INITIALIZATION '''

def initializeD_c(J,dataset) :

return D_c

''' SPARSE CODING '''

def ORMP_cholesky(D_c,dataset,N0) : # columns of D_c must be preshapes

return A_c

'''ORMP_cholesky_real() and OMP() are not used in this script, but it is interesting to

write them as a comparison to ORMP_cholesky(). Empirically, OMP() behaves badly compared

ORMP_cholesky_real() for small values of N0, and becomes better after increasing N0.

ORMP_cholesky_real() is less performing than ORMP_cholesky() because the former

can only rely on real weights in sparse coding, contrarily to the latter. '''

# NOT USED HERE

def ORMP_cholesky_real(DM,N0,J,dataset) :

return AM

# NOT USED HERE

def matPlus(B) :

return Bp

# NOT USED HERE

def OMP(D_c,dataset,N0) : # columns of D_c must be preshapes

return A_c

''' PRESHAPING THE ATOMS OF D_c '''

# NOT USED HERE

def proj_S(D_c) : # columns of D_c are general configurations in C^N

return D_c

def normalize(D_c) : # columns of D_c are centered configurations

return D_c

''' DISPLAY FUNCTIONS '''

from settings import z0

def display_res(dataset,DA,k,save = False,directory = None) :

plt.show()

def display(D_c,A_c,dataset,test_k_set=test_k_set,save = False,directory = None) :

display_res(dataset,DA,k,save = save,directory = directory)

''' MAIN ALGORITHM : 2D Kendall Shape Dictionary with the Method of Optimal Directions and

Cholesky-optimized Order Recursive Matching Pursuit '''

def reciprocal(sigmas):

return sigmas_rec

def fill_diagonal(sigmas_rec,J,K):

return Sigma_rec

def KSD_optimal_directions(dataset,N0,J,init=None,Ntimes = 100,verbose=False,save=False,directory = None) :

return D_c,A_c,E

def OMRP_multiproc_helper(k,D_c,dataset,G,N0) :

return a

def KSD_optimal_directions_multiproc_ORMP(dataset,N0,J,init=None,Ntimes = 100,batch_size=1024,verbose=False,save=False,directory = None) :

return D_c,A_c,E

def KSD_RMSE_curve(dataset,J) :

return curve

if __name__ == '__main__' :

learn_dico = True

N0,J = 5,10

SAVE = True

MULTIPROC_ORMP = False

# True if you want to multiprocess ORMP

# interesting only for large datasets K > 4000

if learn_dico :

directory = 'RESULTS/' + database[choice] + '/N0_'+ str(N0) + '_J_' + str(J)

if SAVE :

if not os.path.exists(directory):

print('CREATING THE FOLDER')

os.makedirs(directory)

else :

if os.path.exists(directory + '/dico_KSD.png') :

SAVE = False

print('WILL NOT OVERWRITE PREVIOUS SAVED RESULTS')

if MULTIPROC_ORMP :

from functools import partial

KSD = partial(KSD_optimal_directions_multiproc_ORMP,

batch_size = K) # 1024 ~ 2048 ~ 4096

# you can set the batch size to the size of the dataset to

#multiprocess ORMP on the whole dataset

print('USING PARALLELIZED AND/OR BATCHED VERSION OF ORMP')

print('change the batch size if needed')

else :

KSD = KSD_optimal_directions

D_c,A_c,E_KSD = KSD(shapes,N0,J,init = None,

Ntimes = 30,verbose=False,

save=SAVE,directory=directory)

# change Ntimes as needed if you see that

# the loss curve has not finished converging (in verbose=True mode)

# and put verbose = False to speed up the process and have actual run-time