Aggregazione di vettori di funzionalità generati automaticamente

Question

Ho un sistema di classificazione, che purtroppo dovrò essere vago per motivi di lavoro. Supponiamo che abbiamo 5 funzionalità da considerare, è fondamentalmente un insieme di regole:

A  B  C  D  E  Result
1  2  b  5  3  X
1  2  c  5  4  X
1  2  e  5  2  X

Prendiamo un argomento e otteniamo i suoi valori per AE, quindi proviamo a abbinare le regole in sequenza. Se uno corrisponde, restituiamo il primo risultato.

C è un valore discreto, che potrebbe essere uno qualsiasi di AE. Il resto sono solo numeri interi.

Il set delle regole è stato automaticamente generato dal nostro vecchio sistema e ha un numero estremamente elevato di regole (~ 25 milioni). Le vecchie regole erano se dichiarazioni, ad es.

result("X") if $A >= 1 && $A <= 10 && $C eq 'A';

Come puoi vedere, le vecchie regole spesso non usano nemmeno alcune funzionalità o accettano intervalli. Alcuni sono più fastidiosi:

result("Y") if ($A == 1 && $B == 2) || ($A == 2 && $B == 4);

Il set delle regole deve essere molto più piccolo in quanto deve essere mantenuto umano, quindi vorrei ridurre i set di regole in modo che il primo esempio diventasse:

A  B  C    D  E    Result
1  2  bce  5  2-4  X

Il risultato è che possiamo dividere il set di regole per colonna di risultato e ridursi in modo indipendente. Tuttavia, non riesco a pensare a un modo semplice per identificare e ridurre il set delle regole. Ho provato algoritmi di clustering ma soffocano perché alcuni dei dati sono discreti e trattarli come continui è imperfetto. Un altro esempio:

A  B  C   Result
1  2  a   X
1  2  b   X
(repeat a few hundred times)
2  4  a   X  
2  4  b   X
(ditto)

In un mondo ideale, queste sarebbero due regole:

A  B  C  Result
1  2  *  X
2  4  *  X

Cioè: non solo l'algoritmo identificherebbe la relazione tra A e B, ma dedurrebbe anche che C è rumore (non importante per la regola)

Qualcuno ha un'idea di come risolvere questo problema? Qualsiasi lingua o biblioteca è un gioco equo, poiché mi aspetto che questo sia un processo principalmente unico. Grazie in anticipo.

Answer 1

Dai un'occhiata al Weka Machine Learning Lib per Java. L'API è un po 'croccante ma è molto utile. Nel complesso, quello che sembri desideri è un algoritmo di apprendimento automatico standard, che è esattamente ciò che Weka contiene. Apparentemente stai cercando qualcosa di relativamente facile da interpretare (dici che vuoi che deduci la relazione tra A e B e per dirti che C è solo rumore.) Potresti provare un albero decisionale, come J48, come questi Di solito sono facili da visualizzare/interpretare.

Answer 2

Venticinque milioni di regole? Quante caratteristiche? Quanti valori per funzionalità? È possibile iterare attraverso tutte le combinazioni in tempo pratico? Se puoi, potresti iniziare separando le regole in gruppi per risultato.

Quindi, per ogni risultato, fai quanto segue. Considerando ogni funzionalità come una dimensione e i valori consentiti per una funzione come metrica lungo quella dimensione, costruiscono un'enorme mappa Karnaugh che rappresenta l'intero set di regole.

La mappa ha due usi. Uno: Metodi automatizzati per la ricerca per l'algoritmo Quine-McCluskey. Molto lavoro è stato svolto in questo settore. Ci sono anche alcuni programmi disponibili, anche se probabilmente nessuno di loro si occuperà di una mappa Karnaugh delle dimensioni che stai per fare.

Due: quando hai creato il set di regole ridotti finali, iterare di nuovo su tutte le combinazioni di tutti i valori per tutte le funzionalità e costruire un'altra mappa Karnaugh usando il set di regole ridotto. Se le mappe corrispondono, i set di regole sono equivalenti.

-Al.

Answer 3

Potresti provare un rete neurale approccio, addestrato via backpropagation, supponendo che tu abbia o possa generare in modo casuale (in base al vecchio set di regole) un ampio set di dati che colpiscono tutte le tue classi. L'uso di uno strato nascosto di dimensioni appropriate consentirà di approssimare le funzioni discriminanti arbitrarie nello spazio delle funzionalità. Questa è più o meno la stessa idea del clustering, ma a causa del paradigma di allenamento non dovrebbe avere problemi con i tuoi input discreti.

Questo può, tuttavia, essere un po 'troppo "scatola nera" per il tuo caso, in particolare se si ha una tolleranza zero per falsi positivi e negativi (anche se, essendo un processo unico, si ottiene un grado arbitrario di fiducia controllando un gigantesco set di convalida).