Besseres (nicht-linear) Binning

Question

Die letzte Frage, die ich besorgt gefragt, wie Daten sind von x-Koordinate. Die Lösung war einfach und elegant, und ich schäme ich es nicht gesehen haben. Diese Frage kann schwieriger sein (oder ich kann nur blind sein).

I mit etwa 140000 Datenpunkten gestartet und spalten sie in 70 Gruppen gleichmäßig entlang der X-Achse beabstandet I nahm dann die mittlere Position (x_avg, y_avg) jeder Gruppe und sie aufgetragen; eine schöne Kurve erschien. Leider gibt es zwei Probleme. Zunächst einmal sind die Kanten viel weniger bevölkert als die Mitte des Graphen; Zweitens, ändern einige Bereiche mehr als andere, und so brauchen eine bessere Auflösung.

Ich habe also zwei spezifische Fragen und eine allgemeine Einladung Anregungen zu werfen:

Hat Matlab hat eine eingebaute Möglichkeit, eine Matrix entweder in einer festen Anzahl von kleineren Matrizes oder kleinen Matrizes einer festen Größe der Aufspaltung?

Gibt es einen Algorithmus (oder eine Matlab-Funktion, aber ich finde, dass unwahrscheinlich), die Grenzen zu Bin Regionen von Interesse feiner erforderlich, um zu bestimmen?

Generell gibt es eine bessere Art und Weise Zehntausende von Datenpunkten zu einem ordentlichen Trend Kondensieren?

Answer 1

Es klingt wie Sie Bins verwenden möchten, die auf die Dichte der x-Werte in der Größe variieren. Ich denke, dass Sie immer noch die Funktion histc wie in der Antwort auf Ihre früheren Post verwenden können, aber man würde es nur einen anderen Satz von Kanten geben müssen.

Ich weiß nicht, ob dies ist genau das, wollen Sie wollen, aber hier ist ein Vorschlag: Statt der x-Achse in 70 gleich beabstandeten Gruppen aufgeteilt, spaltete die sortierten x-Daten in 70 gleich große Gruppen und bestimmen die Randwerte. Ich denke, dass dieser Code funktionieren soll:

% 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

Das sollten Sie Bins geben, die in der Größe mit der Datendichte variieren.

---

UPDATE: Eine andere Version ...

Hier ist eine andere Idee, die ich mit nach ein paar Kommentare aufkam. Mit diesem Code, setzen Sie einen Schwellenwert (MaxDelta) für die Differenz zwischen den Datenpunkten in x Nachbarn. Etwaige x-Werte, die um einen Betrag von ihren größeren Nachbarn unterscheiden größer oder gleich MaxDelta sind gezwungen, in ihrem eigenen Fach zu sein (alle von ihrer einsamen). Sie immer noch einen Wert für nBins wählen, aber die endgültige Anzahl der Behälter wird als dieser Wert größer sein, wenn ausgebreiteten Punkte, um ihre eigenen Behälter degradiert werden.

% 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

Getestet habe ich diese auf ein paar kleine Probenmengen von Daten, und es scheint zu tun, was es soll. Hoffentlich wird es funktioniert für Ihren Datensatz zu, was auch immer es enthält! =)

Answer 2

Ich habe Matlab nie verwendet, aber von zu Ihrer vorherigen Frage suchen Ich vermute, dass Sie auf der Suche nach etwas entlang der Linien von einer Kdtree oder eine Variation.

Zur Verdeutlichung:. Da es einige Verwirrung darüber zu sein scheint, ich denke, dass ein Pseudo-Code Beispiel ist, um

// 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))