Vetorização Matlab - índices de linha da matriz zero na célula

Estou trabalhando com o Matlab.

Eu tenho uma matriz quadrada binária. Para cada linha, há uma ou mais entradas de 1. Quero passar por cada linha dessa matriz e retornar o índice desses 1s e armazená-los na entrada de uma célula.

Eu queria saber se existe uma maneira de fazer isso sem fazer loop em todas as linhas desta matriz, pois o loop for é realmente lento no Matlab.

Por exemplo, minha matriz

M = 0 1 0
    1 0 1
    1 1 1 

Então, eventualmente, eu quero algo como

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

Então Aé uma célula.

Existe uma maneira de atingir esse objetivo sem usar o loop for, com o objetivo de calcular o resultado mais rapidamente?

Na parte inferior desta resposta está um código de benchmarking, pois você esclareceu que está interessado em desempenho, em vez de evitar arbitrariamente forloops.

Na verdade, acho que os forloops são provavelmente a opção de melhor desempenho aqui. Desde que o "novo" (2015b) mecanismo JIT foi introduzido ( fonte ), os forloops não são inerentemente lentos - na verdade, eles são otimizados internamente.

Você pode ver no benchmark que a mat2cellopção oferecida por ThomasIsCoding aqui é muito lenta ...

Se nos livrarmos dessa linha para tornar a escala mais clara, meu splitapplymétodo é bastante lento, a opção accumarray do obchardon é um pouco melhor, mas as opções mais rápidas (e comparáveis) estão usando arrayfun(como também sugerido por Thomas) ou um forloop. Observe que arrayfuné basicamente um forloop disfarçado para a maioria dos casos de uso, portanto, este não é um empate surpreendente!

Eu recomendo que você use um forloop para aumentar a legibilidade do código e o melhor desempenho.

Editar :

Se assumirmos que o loop é a abordagem mais rápida, podemos fazer algumas otimizações em torno do findcomando.

Especificamente

• Faça Mlógica. Como mostra o gráfico abaixo, isso pode ser mais rápido para relativamente pequeno M, mas mais lento com a troca de conversão de tipo para grande M.

• Use um lógico Mpara indexar uma matriz em 1:size(M,2)vez de usar find. Isso evita a parte mais lenta do loop (o findcomando) e supera a sobrecarga de conversão de tipo, tornando-a a opção mais rápida.

Aqui está a minha recomendação para o melhor desempenho:

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

Adicionei isso à referência abaixo, eis a comparação de abordagens no estilo de loop:

Código de benchmarking:

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

Você pode tentar arrayfuncomo abaixo, que varre as linhas deM

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

}

ou (uma abordagem mais lenta por 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

}

Edit : Eu adicionei uma referência, os resultados mostram que um loop for é mais eficiente do queaccumarray .

Você pode usar finde accumarray:

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

A matriz é transposta ( A') porque findagrupa por coluna.

Exemplo:

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)

Resultado:

C{1} = 
     1     4

C{2} = 
     2

C{3} =
     3     4

C{4} = 
     1     3     5

Referência:

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

Resultado:

accumarray:
Elapsed time is 2.407773 seconds.

For loop:
Elapsed time is 1.671387 seconds.

Um loop for é mais eficiente que accumarray...

Usando accumarray :

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

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

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

Você pode usar strfind :

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