Matlab Vectorization - indeks baris matriks none-zero ke sel

Saya bekerja dengan Matlab.

Saya memiliki matriks persegi biner. Untuk setiap baris, ada satu atau lebih entri dari 1. Saya ingin menelusuri setiap baris dari matriks ini dan mengembalikan indeks 1s tersebut dan menyimpannya di entri sel.

Saya bertanya-tanya apakah ada cara untuk melakukan ini tanpa mengulang semua baris matriks ini, karena untuk loop sangat lambat di Matlab.

Sebagai contoh, matriks saya

M = 0 1 0
    1 0 1
    1 1 1 

Kemudian akhirnya, saya ingin sesuatu seperti

A = [2]
    [1,3]
    [1,2,3]

Begitu Ajuga sel.

Apakah ada cara untuk mencapai tujuan ini tanpa menggunakan for loop, dengan tujuan menghitung hasilnya lebih cepat?

Di bagian bawah jawaban ini adalah beberapa kode pembandingan, karena Anda mengklarifikasi bahwa Anda tertarik pada kinerja daripada secara acak menghindari forloop.

Bahkan, saya pikir forloop mungkin merupakan opsi yang paling performant di sini. Karena mesin JIT "baru" (2015b) diperkenalkan ( sumber ), forloop pada dasarnya tidak lambat - bahkan mereka dioptimalkan secara internal.

Anda dapat melihat dari patokan bahwa mat2cellopsi yang ditawarkan oleh ThomasIsCoding di sini sangat lambat ...

Jika kita menyingkirkan garis itu untuk membuat skala lebih jelas, maka splitapplymetode saya cukup lambat, opsi akumulator obchardon sedikit lebih baik, tetapi opsi tercepat (dan sebanding) baik menggunakan arrayfun(seperti juga disarankan oleh Thomas) atau forloop. Perhatikan bahwa arrayfunpada dasarnya ini adalah forlingkaran yang menyamar untuk sebagian besar kasus penggunaan, jadi ini bukan ikatan yang mengejutkan!

Saya akan merekomendasikan Anda menggunakan forloop untuk meningkatkan keterbacaan kode dan kinerja terbaik.

Edit :

Jika kita menganggap bahwa perulangan adalah pendekatan tercepat, kita dapat membuat beberapa optimisasi di sekitar findperintah.

Secara khusus

• Buat Mlogis. Seperti yang ditunjukkan plot di bawah ini, ini bisa lebih cepat untuk yang relatif kecil M, tetapi lebih lambat dengan trade-off konversi tipe untuk yang besar M.

• Gunakan logis Muntuk mengindeks array 1:size(M,2)daripada menggunakan find. Ini menghindari bagian paling lambat dari loop ( findperintah) dan melebihi jenis overhead konversi, menjadikannya pilihan tercepat.

Inilah rekomendasi saya untuk kinerja terbaik:

function A = f_forlooplogicalindexing( M )
    M = logical(M);
    k = 1:size(M,2);
    N = size(M,1);
    A = cell(N,1);
    for r = 1:N
        A{r} = k(M(r,:));
    end
end

Saya telah menambahkan ini ke patokan di bawah, di sini adalah perbandingan pendekatan loop-style:

Kode pembandingan:

rng(904); % Gives OP example for randi([0,1],3)
p = 2:12; 
T = NaN( numel(p), 7 );
for ii = p
    N = 2^ii;
    M = randi([0,1],N);

    fprintf( 'N = 2^%.0f = %.0f\n', log2(N), N );

    f1 = @()f_arrayfun( M );
    f2 = @()f_mat2cell( M );
    f3 = @()f_accumarray( M );
    f4 = @()f_splitapply( M );
    f5 = @()f_forloop( M );
    f6 = @()f_forlooplogical( M );
    f7 = @()f_forlooplogicalindexing( M );

    T(ii, 1) = timeit( f1 ); 
    T(ii, 2) = timeit( f2 ); 
    T(ii, 3) = timeit( f3 ); 
    T(ii, 4) = timeit( f4 );  
    T(ii, 5) = timeit( f5 );
    T(ii, 6) = timeit( f6 );
    T(ii, 7) = timeit( f7 );
end

plot( (2.^p).', T(2:end,:) );
legend( {'arrayfun','mat2cell','accumarray','splitapply','for loop',...
         'for loop logical', 'for loop logical + indexing'} );
grid on;
xlabel( 'N, where M = random N*N matrix of 1 or 0' );
ylabel( 'Execution time (s)' );

disp( 'Done' );

function A = f_arrayfun( M )
    A = arrayfun(@(r) find(M(r,:)),1:size(M,1),'UniformOutput',false);
end
function A = f_mat2cell( M )
    [i,j] = find(M.');
    A = mat2cell(i,arrayfun(@(r) sum(j==r),min(j):max(j)));
end
function A = f_accumarray( M )
    [val,ind] = ind2sub(size(M),find(M.'));
    A = accumarray(ind,val,[],@(x) {x});
end
function A = f_splitapply( M )
    [r,c] = find(M);
    A = splitapply( @(x) {x}, c, r );
end
function A = f_forloop( M )
    N = size(M,1);
    A = cell(N,1);
    for r = 1:N
        A{r} = find(M(r,:));
    end
end
function A = f_forlooplogical( M )
    M = logical(M);
    N = size(M,1);
    A = cell(N,1);
    for r = 1:N
        A{r} = find(M(r,:));
    end
end
function A = f_forlooplogicalindexing( M )
    M = logical(M);
    k = 1:size(M,2);
    N = size(M,1);
    A = cell(N,1);
    for r = 1:N
        A{r} = k(M(r,:));
    end
end

Anda dapat mencoba arrayfunseperti di bawah ini, yang menyapu barisM

A = arrayfun(@(r) find(M(r,:)),1:size(M,1),'UniformOutput',false)

A =
{
  [1,1] =  2
  [1,2] =

     1   3

  [1,3] =

     1   2   3

}

atau (pendekatan yang lebih lambat oleh mat2cell )

[i,j] = find(M.');
A = mat2cell(i,arrayfun(@(r) sum(j==r),min(j):max(j)))

A =
{
  [1,1] =  2
  [2,1] =

     1
     3

  [3,1] =

     1
     2
     3

}

Sunting : Saya menambahkan patokan, hasilnya menunjukkan itu perulangan for lebih efisien daripadaaccumarray .

Anda dapat menggunakan finddan accumarray:

[c, r] = find(A');
C = accumarray(r, c, [], @(v) {v'});

Matriks dipindahkan (A' ) karena finddikelompokkan berdasarkan kolom.

Contoh:

A = [1 0 0 1 0
     0 1 0 0 0
     0 0 1 1 0
     1 0 1 0 1];

%  Find nonzero rows and colums
[c, r] = find(A');

%  Group row indices for each columns
C = accumarray(r, c, [], @(v) {v'});

% Display cell array contents
celldisp(C)

Keluaran:

C{1} = 
     1     4

C{2} = 
     2

C{3} =
     3     4

C{4} = 
     1     3     5

Benchmark:

m = 10000;
n = 10000;

A = randi([0 1], m,n);

disp('accumarray:')
tic
[c, r] = find(A');
C = accumarray(r, c, [], @(v) {v'});
toc
disp(' ')

disp('For loop:')
tic
C = cell([size(A,1) 1]);
for i = 1:size(A,1)
    C{i} = find(A(i,:));
end
toc

Hasil:

accumarray:
Elapsed time is 2.407773 seconds.

For loop:
Elapsed time is 1.671387 seconds.

A for loop lebih efisien daripada accumarray...

Menggunakan diakarray :

M = [0 1 0
     1 0 1
     1 1 1];

[val,ind] = find(M.');

A = accumarray(ind,val,[],@(x) {x});

Anda dapat menggunakan strfind :

A = strfind(cellstr(char(M)), char(1));