valores - mostrar elementos de un arraylist java

Cómo detectar valores atípicos en una ArrayList

Question

Estoy tratando de pensar en algún código que me permita buscar en mi ArrayList y detectar cualquier valor fuera del rango común de "buenos valores".

Ejemplo: 100 105 102 13 104 22 101

¿Cómo podría escribir el código para detectar que (en este caso) 13 y 22 no caen dentro de los "buenos valores" de alrededor de 100?

Answer 1

Es solo una implementación muy simple que obtiene la información cuyos números no están dentro del rango:

List<Integer> notInRangeNumbers = new ArrayList<Integer>();
for (Integer number : numbers) {
if (!isInRange(number)) {
// call with a predefined factor value, here example value = 5
notInRangeNumbers.add(number, 5);
}
}

Además, dentro del método isInRange debe definir qué quiere decir con ''buenos valores'' . A continuación encontrará una implementación ejemplar.

private boolean isInRange(Integer number, int aroundFactor) {
//TODO the implementation of the ''in range condition''
// here the example implementation
return number <= 100 + aroundFactor && number >= 100 - aroundFactor;
}

Answer 2

Existen varios criterios para detectar valores atípicos. Los más simples, como el criterio de Chauvenet , usan la media y la desviación estándar calculada a partir de la muestra para determinar un rango "normal" para los valores. Cualquier valor fuera de este rango se considera un valor atípico.

Otros criterios son la prueba de Grubb y la prueba Q de Dixon, y pueden dar mejores resultados que los de Chauvenet, por ejemplo, si la muestra proviene de una distribución oblicua.

Answer 3

• encuentra el valor medio para tu lista
• crea un Map que mapea el número a la distancia de la media
• ordenar los valores por la distancia de la media
• y diferenciar el último n número, asegurándote de que no haya injusticia con la distancia

Answer 4

Usa este algoritmo. Este algoritmo usa el promedio y la desviación estándar. Estos 2 valores opcionales numéricos (2 * desviación estándar).

 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;
}

Answer 5

Una implementación de la prueba de Grubb se puede encontrar en MathUtil.java . Encontrará un valor atípico único, que puede eliminar de su lista y repetir hasta que haya eliminado todos los valores atípicos.

Depende de commons-math , así que si estás usando Gradle:

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

Answer 6

package test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Double> data = new ArrayList<Double>();
data.add((double) 20);
data.add((double) 65);
data.add((double) 72);
data.add((double) 75);
data.add((double) 77);
data.add((double) 78);
data.add((double) 80);
data.add((double) 81);
data.add((double) 82);
data.add((double) 83);
Collections.sort(data);
System.out.println(getOutliers(data));
}
public static List<Double> getOutliers(List<Double> input) {
List<Double> output = new ArrayList<Double>();
List<Double> data1 = new ArrayList<Double>();
List<Double> data2 = new ArrayList<Double>();
if (input.size() % 2 == 0) {
data1 = input.subList(0, input.size() / 2);
data2 = input.subList(input.size() / 2, input.size());
} else {
data1 = input.subList(0, input.size() / 2);
data2 = input.subList(input.size() / 2 + 1, input.size());
}
double q1 = getMedian(data1);
double q3 = getMedian(data2);
double iqr = q3 - q1;
double lowerFence = q1 - 1.5 * iqr;
double upperFence = q3 + 1.5 * iqr;
for (int i = 0; i < input.size(); i++) {
if (input.get(i) < lowerFence || input.get(i) > upperFence)
output.add(input.get(i));
}
return output;
}
private static double getMedian(List<Double> data) {
if (data.size() % 2 == 0)
return (data.get(data.size() / 2) + data.get(data.size() / 2 - 1)) / 2;
else
return data.get(data.size() / 2);
}
}

Salida: [20.0]

Explicación:

• Ordena una lista de enteros, de menor a mayor
• Divida una lista de enteros en 2 partes (por un medio) y colóquelos en 2 nuevos ArrayLists separados (llámelos "izquierda" y "derecha")
• Encuentra un número medio (mediana) en las nuevas ArrayLists
• Q1 es una mediana desde el lado izquierdo, y Q3 es la mediana desde el lado derecho
• Aplicando fórmula matemática:
• IQR = Q3 - Q1
• LowerFence = Q1 - 1.5 * IQR
• UpperFence = Q3 + 1.5 * IQR
• Más información sobre esta fórmula: http://www.mathwords.com/o/outlier.htm
• Pasa por todos mis elementos originales, y si alguno de ellos es más bajo que una valla inferior, o más alto que una valla superior, agrégalos a ArrayList de "salida".
• Esta nueva ArrayList de "salida" contiene los valores atípicos