Reglas de asociación de puntos de acceso en minería de datos
Entre ellos. , Los parámetros en el cuadro rojo son configuraciones, como se muestra a continuación:
-El último dígito de -c indica la columna de destino donde se encuentra el objetivo, el último dígito indica la última columna, que también es una valor numérico, que indica la primera columna;
-V es el primer bit, representa el valor de subíndice de un determinado valor de estado de la columna de destino (se puede ver aquí que la columna de destino debe ser discreta), el primer bit representa el bit 0, que puede ser un valor numérico;
-S 0,13, soporte mínimo, multiplíquelo por el número total de muestras para obtener un soporte numérico
-M 2; índice de puntuación máxima;
-I 0.01, interpretado en weka como la mejora mínima del valor objetivo, no sé si Igual que el nivel de confianza tradicional;
Notas relacionadas: este código relacionado hace referencia Para la implementación específica del algoritmo HotSpot en weka, aquí solo se analizan datos discretos. El código se puede descargar en (/detail/fansy1990/8488971).
1.Datos:
@atributo edad {joven, prepresbicia, presbicia}
@atributo espectáculo-prescrip {miope, hipermetrope}
@attribute astigmatismo {no, sí}
@attribute tasa de producción de lágrimas {reducida, normal}
@attribute lentes de contacto {suaves, duras, ninguna}
Joven, miope, ninguno, debilitado, ninguno
Joven, miope, ninguno, normal, blando
Joven, miope, con, disminuido, ninguno
.
presbicia, hipermétrope, sí, normal, ninguno
Este formato de datos es una referencia interna en weka. Las 5 líneas superiores se agregan porque cada atributo debe codificarse, así que obtenga el. estado de cada atributo por adelantado para facilitar operaciones posteriores;
2. Definición de nodo único:
public class HSNode {
private int splitAttrIndex // Subíndice de atributo;
private int attrStateIndex; // subíndice del estado del atributo
private int allCount; // número del conjunto de datos actual
private int stateCount //Número del estado del atributo
soporte doble privado //soporte de atributo
listlt privado;HSNodegt.chidren;
HSNode público(){}}
splitAttrIndex es el subíndice correspondiente al atributo de astigmatismo (debe ser el segundo subíndice a partir de 0); attrStateIndex corresponde al subíndice de este atributo, que es el subíndice de no (aquí debe ser 0, allCount es 12, stateCount); es 5, el soporte corresponde a 41,57 (es decir, el valor es 5/12, los niños son nodos secundarios (los subíndices aquí están codificados desde las primeras líneas de código del archivo, por ejemplo, el atributo edad es la primera); atributo, codificado como 0, joven es el primer estado, codificado como 0);
3. Pseudocódigo del algoritmo (descripción del texto, demasiado poco profesional, ¿solo léelo si quieres?)
1. Crear un nodo raíz;
2. Cree un nodo secundario
2.1 Para todos los datos, calcule el soporte de "soporte" de cada atributo en cada columna,
if supportgt;= MINSUPPORT
Agregue los atributos actuales de la columna a la lista de nodos secundarios potenciales
end
2.2 Recorra los nodos secundarios potenciales contra el; list Lista de nodos secundarios
if (! Secuencia de reglas generadas por el nodo actual en la secuencia de reglas global)
Agrega el nodo actual a la lista de nodos secundarios;
Agregue las reglas generadas por el nodo actual a las reglas globales;
end
2.3 Recorra la lista de nodos secundarios
Para el nodo actual, regrese a 2 para recursividad;
4. Pasos clave en la implementación del código:
4.1 Lectura e inicialización de datos:
1) Lea las primeras líneas del archivo e inicialícelo. dos variables: atributos y atributosStates, que corresponden a todos los atributos y estados individuales de los atributos respectivamente;
while ((tempString = lector.readLine())! = null) {
// La primera fila de datos es el título
if(tempString.indexOf(HSUtils.FILEFORMAT)==0){
Atributo de cadena = tempString.substring(HSUtils.FILEFORMAT.length)==0){
St
ring[] tempStrings = tempString.split(splitter);
lists.add(strArr2IntArr(tempStrings));
}
2) Este último es El Los siguientes datos se convierten en una matriz numérica.
La función strArr2IntArr es la siguiente:
/**
* Matriz de cadenas a matriz int
* @param sArr
* @ return
* @throws Exception
*/
private int[] strArr2IntArr(String[] sArr) throws Exception{
int [] iArr = new int[sArr.length];
for(int i=0; ilt; sArr.length; i ) {
iArr[i]= getAttrCode(sArr [i] , i);
}
Devuelve iArr
}
/**
* Obtener attrIndex La codificación del atributo attrState
* @ param attrState
* @param attrIndex
* @return
* @ lanza una excepción
*/
private int getAttrCode(String attrState, int attrIndex) lanza una excepción {
String[] attrStates = atributoStates.get(atributos[attrIndex ]);
for(int i=0; ilt.attrStates.length; i ){
if(attrState.equals(attrStates[i])){
return i;
}
}
Genera una nueva excepción ("¡Error de codificación!") )
// return -1; // Si lo ejecuta aquí, se debe informar un error
}
La lectura de datos aquí convierte principalmente datos de tipo cadena discreta en datos numéricos. de la siguiente manera:
El estado del atributo edad: [joven--gt; 0, pre-presbicia--gt; estado del atributo espectáculo-prescripción: [miopía --gt; 0, hipermetropía --gt; 1,]
Estado del atributo astigmatismo: [sin --gt; sí --gt; ]
Estado del atributo de tasa de lágrima: [inferior--gt; 0, normal--gt; 1,]
Estado del atributo de la lente de contacto: [suave--gt; --gt; 1, none--gt ;2,]
4.2 Inicializar el nodo raíz
// ReadFileAndInitialize
Listlt; intData = readFileAndInitial(HSUtils.FEPATH, HSUtils.SPLITTER);;
int splitAttributeIndex = atributos.length-1 // El subíndice debe disminuirse en 1
int stateIndex =; HSUtils.LABELSTATE;
int numInstances = intData.size(); //Número total de datos
int[] labelStateCount = attrStateCount(intData, atributos.length-1);
HSUtils.setMinSupportCount(numInstances) );
double targetValue=1.0*labelStateCount[HSUtils.LABELSTATE]/2LABELSTATE]/numInstances;
// Crear nodo raíz
HSNode root = nuevo HSNode(splitAttributeIndex, stateIndex, labelStateCount[stateIndex], numInstances);
double[] splitVals=new double[attributes.length];
byte[] pruebas = nuevo byte [atributos .length];
root.setChidren(constructChildrenNodes(intData, targetValue, splitVals, tests));
labelStateCount es el número de cada estado del atributo de destino, por ejemplo , aquí El estado objetivo es suave, A tiene 5 valores y A tiene 24 muestras, por lo que admite 5/25 = 20.
82;
La función constructChildrenNodes se utiliza para crear todos los nodos secundarios y los parámetros recibidos son: intData: todos los datos (codificados); targetValue: se utilizan principalmente los splitVals y las matrices de pruebas; para generar reglas para nodos;
4.3 Crear nodos secundarios:
1) Calcular nodos secundarios potenciales:
private List lt;HSNodegt; constructChildrenNodes(Listlt;int []gt; intData, double targetValue,
double[] splitVals,
byte[] pruebas) {
// Establecer nodos secundarios
/ /Obtener subconjunto de datos
//
// Calcular el soporte de cada valor de estado de cada atributo (debe coincidir con la confianza)
PriorityQueuelt; AttrStateSupgt; pq = nuevo PriorityQueuelt; AttrStateSupgt ();
para (int i=0; ilt; atributos.
para (int i=0; ilt; atributos . length-1;i){//No es necesario calcular el último atributo (es Etiqueta)
evaluaAttr(pq, intData, i, targetValue);
}
La función de EvaluateAttr aquí es determinar si los estados respectivos de cada atributo cumplen con los requisitos. Si es así, agréguelos a pq
, agréguelos a pq
. /**
* Si se debe agregar el estado del primer atributo del atributo attrIndex a pq como nodo de reemplazo<
* @param pq
* @ paramintData
* @param attrIndex
* @param targetValue
* @param stateIndex
* @param labelStateCount
*/
private void evaluaAttr(PriorityQueuelt; AttrStateSupgt; pq,
Listlt; int[]gt; intData, int attrIndex, double targetValue) {
int[] counts = attrStateCount(intData, attrIndex);
boolean ok = false;
// Solo considera los valores de atributos que resulten en cumplir o exceder el mínimo admitido subconjunto
p>for (int i = 0; i lt; counts.length; i ) {
if (counts[i] gt; = HSUtils.getMinSupportCount()) {
ok = verdadero;
romper
}
}
if(ok){
doble subconjuntoMatriz
= 0.0;
for( int stateIndex=0; stateIndexlt; counts.length;
stateIndex ){
subsetMatrix =attrStateCount(intData, attrIndex, stateIndex, atributos.length-1, HSUtils.LABELSTATE);
if (counts[stateIndex]gt;=HSUtils.LABELSTATE);
if (counts[stateIndex]gt;=HSUtils. getMinSupportCount){