matlab - matrices - Mejor binning(no lineal)

vector matlab

Question

La última pregunta que hice se refería a cómo agrupar datos por coordenadas x. La solución fue simple y elegante, y estoy avergonzado de no haberlo visto. Esta pregunta puede ser más difícil (o simplemente puedo ser ciego).

Comencé con aproximadamente 140000 puntos de datos y los dividí en 70 grupos espaciados equitativamente a lo largo del eje x, luego tomé la posición promedio (x_avg, y_avg) de cada grupo y los tracé; una bonita curva apareció. Desafortunadamente hay dos problemas. En primer lugar, los bordes están mucho menos poblados que el centro del gráfico; En segundo lugar, algunas áreas cambian más que otras y, por lo tanto, necesitan una resolución mejor.

Por lo tanto, tengo dos preguntas específicas y una invitación general a lanzar sugerencias:

¿Matlab tiene una forma integrada de dividir una matriz en un número fijo de matrículas más pequeñas o matrículas más pequeñas de un tamaño fijo?

¿Existe un algoritmo (o una función de matlab, pero me parece poco probable) para determinar los límites requeridos para ubicar las regiones de interés más finamente?

En términos más generales, ¿hay una mejor manera de condensar decenas de miles de puntos de datos en una tendencia ordenada?

Answer 1

Nunca he usado matlab, pero al ver tu pregunta anterior sospecho que buscas algo parecido a un Kdtree o una variación.

Aclaración: dado que parece haber cierta confusión sobre esto, creo que un ejemplo de pseudocódigo está en orden.

// Some of this shamelessly borrowed from the wikipedia article
function kdtree(points, lower_bound, upper_bound) {
    // lower_bound and upper_bound are the boundaries of your bucket
    if(points is empty) {
        return nil
    }
    // It''s a trivial exercise to control the minimum size of a partition as well
    else {
        // Sort the points list and choose the median element
        select median from points.x

        node.location = median;

        node.left = kdtree(select from points where lower_bound < points.x <= median, lower_bound, median);
        node.right = kdtree(select from points where median < points.x <= upper_bound, median, upper_bound);

        return node
    }
}

kdtree(points, -inf, inf)

// or alternatively

kdtree(points, min(points.x), max(points.x))

Answer 2

Parece que quieres usar contenedores que varían en tamaño dependiendo de la densidad de los valores de x. Creo que todavía puedes usar la función HISTC como en la respuesta a tu publicación anterior, pero solo deberías darle un conjunto diferente de bordes.

No sé si esto es exactamente lo que quiere, pero aquí hay una sugerencia: en lugar de dividir el eje x en 70 grupos igualmente espaciados, divida los datos ordenados de x en 70 grupos iguales y determine los valores de borde. Creo que este código debería funcionar:

% Start by assuming x and y are vectors of data:

nBins = 70;
nValues = length(x);
[xsort,index] = sort(x);  % Sort x in ascending order
ysort = y(index);         % Sort y the same way as x
binEdges = [xsort(1:ceil(nValues/nBins):nValues) xsort(nValues)+1];

% Bin the data and get the averages as in previous post (using ysort instead of y):

[h,whichBin] = histc(xsort,binEdges);

for i = 1:nBins
    flagBinMembers = (whichBin == i);
    binMembers = ysort(flagBinMembers);
    binMean(i) = mean(binMembers);
end

Esto debería proporcionar contenedores que varían en tamaño con la densidad de datos.

ACTUALIZACIÓN: Otra versión ...

Aquí hay otra idea que surgió después de algunos comentarios. Con este código, establece un umbral (maxDelta) para la diferencia entre puntos de datos vecinos en x. Cualquier valor de x que difiera de su vecino más grande en una cantidad mayor o igual a maxDelta está forzado a estar en su propio contenedor (todo por su soledad). Aún elige un valor para nBins, pero el número final de contenedores será mayor que este valor cuando los puntos dispersos se relegan a sus propios contenedores.

% Start by assuming x and y are vectors of data:

maxDelta = 10; % Or whatever suits your data set!
nBins = 70;
nValues = length(x);
[xsort,index] = sort(x);  % Sort x in ascending order
ysort = y(index);         % Sort y the same way as x

% Create bin edges:

edgeIndex = false(1,nValues);
edgeIndex(1:ceil(nValues/nBins):nValues) = true;
edgeIndex = edgeIndex | ([0 diff(xsort)] >= maxDelta);
nBins = sum(edgeIndex);
binEdges = [xsort(edgeIndex) xsort(nValues)+1];

% Bin the data and get the y averages:

[h,whichBin] = histc(xsort,binEdges);

for i = 1:nBins
    flagBinMembers = (whichBin == i);
    binMembers = ysort(flagBinMembers);
    binMean(i) = mean(binMembers);
end

Probé esto en unos pequeños conjuntos de muestra de datos y parece hacer lo que se supone que debe hacer. Afortunadamente, también funcionará para su conjunto de datos, ¡sea lo que sea que contenga! =)