So erkennen Sie Ausreißer in einer ArrayList

Gibt es mehrere Kriterien für die Erkennung von Ausreißern. Den einfachsten, wie Chauvenet ' s Kriterium, verwenden Sie den Mittelwert und die Standardabweichung, berechnet aus der Probe zu bestimmen, einen "normalen" Bereich für die Werte. Jeder Wert außerhalb dieses Bereichs ist als ein Ausreißer.

Andere Kriterien sind Grubb ' s test und Dixon ' s Q-test und möglicherweise bessere Ergebnisse liefern als Chauvenet ' s zum Beispiel, wenn die Probe stammt aus einem Ungleichgewicht der Verteilung.

Einer Umsetzung der Grubb ' s test finden Sie unter MathUtil.java. Es befindet sich ein einzelner Ausreißer, die Sie entfernen aus der Liste und wiederholen Sie, bis Sie entfernt haben alle Ausreißer.

Hängt commons-math, so dass, wenn Sie mit Gradle:

dependencies {
  compile 'org.apache.commons:commons-math:2.2'
}

Verwenden Sie diesen Algorithmus. Dieser Algorithmus verwendet den Durchschnittswert und die Standardabweichung. Diese 2-Nummer optionale Werte (2 * standardDeviation).

 public static List<int> StatisticalOutLierAnalysis(List<int> allNumbers)
            {
                if (allNumbers.Count == 0)
                    return null;

                List<int> normalNumbers = new List<int>();
                List<int> outLierNumbers = new List<int>();
                double avg = allNumbers.Average();
                double standardDeviation = Math.Sqrt(allNumbers.Average(v => Math.Pow(v - avg, 2)));
                foreach (int number in allNumbers)
                {
                    if ((Math.Abs(number - avg)) > (2 * standardDeviation))
                        outLierNumbers.Add(number);
                    else
                        normalNumbers.Add(number);
                }

                return normalNumbers;
            }

Als Joni bereits erwähnt , können Sie beseitigen Ausreißer mit Hilfe von Standardabweichung und Mittelwert. Hier ist mein code, die Sie für Ihre Zwecke nutzen können.

    public static void main(String[] args) {

    List<Integer> values = new ArrayList<>();
    values.add(100);
    values.add(105);
    values.add(102);
    values.add(13);
    values.add(104);
    values.add(22);
    values.add(101);

    System.out.println("Before: " + values);
    System.out.println("After: " + eliminateOutliers(values,1.5f));

}

protected static double getMean(List<Integer> values) {
    int sum = 0;
    for (int value : values) {
        sum += value;
    }

    return (sum / values.size());
}

public static double getVariance(List<Integer> values) {
    double mean = getMean(values);
    int temp = 0;

    for (int a : values) {
        temp += (a - mean) * (a - mean);
    }

    return temp / (values.size() - 1);
}

public static double getStdDev(List<Integer> values) {
    return Math.sqrt(getVariance(values));
}

public static List<Integer> eliminateOutliers(List<Integer> values, float scaleOfElimination) {
    double mean = getMean(values);
    double stdDev = getStdDev(values);

    final List<Integer> newList = new ArrayList<>();

    for (int value : values) {
        boolean isLessThanLowerBound = value < mean - stdDev * scaleOfElimination;
        boolean isGreaterThanUpperBound = value > mean + stdDev * scaleOfElimination;
        boolean isOutOfBounds = isLessThanLowerBound || isGreaterThanUpperBound;

        if (!isOutOfBounds) {
            newList.add(value);
        }
    }

    int countOfOutliers = values.size() - newList.size();
    if (countOfOutliers == 0) {
        return values;
    }

    return eliminateOutliers(newList,scaleOfElimination);
}

• eliminateOutliers () - Methode tun all die Arbeit
• Es ist eine rekursive Methode, die ändert die Liste mit jedem rekursiven Aufruf
• scaleOfElimination variable, die Sie an die Methode übergeben, die definiert, bei welchem Umfang
  Sie entfernen möchten Ausreißer: ich gehe Normalerweise mit 1,5 f-2f, je größer die variable,
  die weniger Ausreißer entfernt werden

Die Ausgabe des Codes:

Bevor: [100, 105, 102, 13, 104, 22, 101]

Nach: [100, 105, 102, 104, 101]