Modo rapido / efficiente per scomporre i coefficienti di filtro 2D interi separabili

Vorrei essere in grado di determinare rapidamente se un dato kernel 2D di coefficienti interi è separabile in due kernel 1D con coefficienti interi. Per esempio

 2   3   2
 4   6   4
 2   3   2

è separabile in

 2   3   2

e

 1
 2
 1

Il vero test di separabilità sembra essere abbastanza semplice usando l'aritmetica intera, ma la decomposizione in filtri 1D con coefficienti interi si sta dimostrando un problema più difficile. La difficoltà sembra risiedere nel fatto che i rapporti tra righe o colonne possono essere non interi (frazioni razionali), ad esempio nell'esempio sopra abbiamo rapporti di 2, 1/2, 3/2 e 2/3.

Non voglio davvero usare un approccio pesante come SVD perché (a) è relativamente computazionalmente costoso per le mie esigenze e (b) non aiuta necessariamente a determinare i coefficienti interi .

Qualche idea ?

ULTERIORI INFORMAZIONI

I coefficienti possono essere positivi, negativi o zero e possono esserci casi patologici in cui la somma di uno o entrambi i vettori 1D è zero, ad es.

-1   2  -1
 0   0   0
 1  -2   1

è separabile in

 1  -2   1

e

-1
 0
 1

Ho preso @Phononla risposta e l'ho modificata in qualche modo in modo che utilizzi l'approccio GCD solo sulla riga superiore e sulla colonna sinistra, piuttosto che sulle somme riga / colonna. Questo sembra gestire un po 'meglio i casi patologici. Può comunque fallire se la riga superiore o la colonna sinistra sono tutte azzerate, ma è possibile verificare questi casi prima di applicare questo metodo.

function [X, Y, valid] = separate(M)    % separate 2D kernel M into X and Y vectors 
  X = M(1, :);                          % init X = top row of M
  Y = M(:, 1);                          % init Y = left column of M
  nx = numel(X);                        % nx = no of columns in M
  ny = numel(Y);                        % ny = no of rows in M
  gx = X(1);                            % gx = GCD of top row
  for i = 2:nx
    gx = gcd(gx, X(i));
  end
  gy = Y(1);                            % gy = GCD of left column
  for i = 2:ny
    gy = gcd(gy, Y(i));
  end
  X = X / gx;                           % scale X by GCD of X
  Y = Y / gy;                           % scale Y by GCD of Y
  scale = M(1, 1) / (X(1) * Y(1));      % calculate scale factor
  X = X * scale;                        % apply scale factor to X
  valid = all(all((M == Y * X)));       % result valid if we get back our original M
end

Mille grazie @Phonone @Jason Rper le idee originali per questo.

Fatto! Pubblicando il codice MATLAB, pubblicheremo una spiegazione stasera o domani

% Two original arrays
N = 3;
range = 800;
a = round( range*(rand(N,1)-0.5) )
b = round( range*(rand(1,N)-0.5) )

% Create a matrix;
M = a*b;
N = size(M,1);

% Sanity check
disp([num2str(rank(M)) ' <- this should be 1!']);

% Sum across rows and columns
Sa = M * ones(N,1);
Sb = ones(1,N) * M;

% Get rid of zeros
SSa = Sa( Sa~=0 );
SSb = Sb( Sb~=0 );

if isempty(SSa) | isempty(SSb)
    break;
end

% Sizes of array without zeros
Na = numel(SSa);
Nb = numel(SSb);

% Find Greatest Common Divisor of Sa and Sb.
Ga = SSa(1);
Gb = SSb(1);

for l=2:Na
    Ga = gcd(Ga,SSa(l));
end

for l=2:Nb
    Gb = gcd(Gb,SSb(l));
end

%Divide by the greatest common divisor
Sa = Sa / Ga;
Sb = Sb / Gb;

%Scale one of the vectors
MM = Sa * Sb;
Sa = Sa * (MM(1) / M(1));

disp('Two arrays found:')
Sa
Sb
disp('Sa * Sb = ');
Sa*Sb
disp('Original = ');
M

Forse sto banalizzando il problema, ma sembra che potresti:

• $N$$M$$\mathbf{A}$$\mathbf{a_i}$$i = 0, 1, \ldots , N-1$

• $j > 0$

  • $\mathbf{a_j}$$\mathbf{a_0}$$j$$\mathbf{r_j}$
  • $\mathbf{r_j}$
  • $\mathbf{r_j}$$\mathbf{a_j}$$\mathbf{a_0}$$j$$0$$\mathbf{x}$
  • $\mathbf{a_j}$$\mathbf{a_0}$

• $\mathbf{x}$

• $\mathbf{x_{norm}}$ $$\mathbf{x_{scaled}} = K\mathbf{x_{norm}}, K = 1, 2, \ldots, M$$ $K$$M$

Non è il metodo più elegante ed è probabile che esista un modo migliore, ma dovrebbe funzionare, è abbastanza semplice da implementare e dovrebbe essere relativamente veloce per matrici di dimensioni modeste.

$x \otimes y \otimes z$$A$$|A - x \otimes y \otimes z|$
$x\ y\ z$
$y$$z$$x$$x\ y\ z\ x\ y\ z\ ...$ a sua volta.

(Dall'approssimazione -a-convoluzione-come-una-somma-di-separabile-convoluzioni su math.stackexchange.)