344739_it-IT

liliconcom

È possibile utilizzare Missing Data Pattern per accelerare la preparazione dei dati?

La mancanza di una qualità dei dati coerente ostacola l'analisi dei dati e scoraggia molti dall'intraprendere un viaggio di Machine Learning.

Nell'industria dei semiconduttori si prevede che i processi vengano continuamente migliorati. Sfortunatamente, uno degli effetti collaterali di tali sforzi è un cambiamento nella struttura dei dati. Uno dei motivi potrebbe essere la ridenominazione della fase del processo.

 

Di seguito è stato simulato un caso simile in cui sono stati elaborati 20 lotti attraverso 4 fasi di processo con modifiche al nome della fase.

Per l'analisi della causa principale è necessario confrontare i risultati della sonda dall'attrezzatura associata a una fase specifica. Nel caso seguente possiamo vedere che i dati si sono stratificati.

 

So che potrei continuare a utilizzare la funzione "Combine Columns" in JMP (Cols \ Utilities \ Combine columns ...) ma in realtà ho diverse centinaia di colonne che devono essere controllate e combinate.

 

Quando si utilizza la funzione Tabelle \ Pattern dati mancanti in JMP, posso vedere facilmente le strutture di dati e le potenziali colonne da combinare.

Mi chiedevo se le informazioni da Missing Data Pattern potessero essere utilizzate per scrivere il requisito di combinazione delle colonne?

 

Sarebbero necessari diversi controlli prima di automatizzare il processo come:
Le colonne rappresentano lo stesso passaggio del processo?
I contenuti di entrambi i passaggi sono simili?
Il pattern dei dati mancanti è inverso per le colonne accoppiate?

 

 

I dati interrotti hanno questo aspetto:

 

 

 

Pattern dati mancante:

 

 

 

Dati ricostruiti:

 

 

- jpol

 

Tabella datiScriptingRi: È possibile utilizzare Missing Data Pattern per accelerare la preparazione dei dati?

Penso che tu possa utilizzare il modello di dati mancanti per identificare le colonne che hanno dati senza intersezione sia per i modelli non mancanti che per i modelli mancanti.Questo script utilizza la tabella di output dalla piattaforma Missing Pattern, utilizzando una tabella dati Missing Data Pattern leggermente modificata dalle tabelle dati JMP Sample.Trova tutti i modelli con corrispondenza inversa e quindi li visualizza in una finestra di visualizzazione

names default to here(1);
dt=New Table( "example",
 Add Rows( 4 ),
 New Column( "Count",
  Numeric,
  "Continuous",
  Format( "Fixed Dec", 10, 0 ),
  Preselect Role( Freq ),
  Set Values( [1, 3, 1, 2] )
 ),
 New Column( "Number of columns missing",
  Numeric,
  "Continuous",
  Format( "Fixed Dec", 10, 0 ),
  Set Values( [1, 2, 1, 2] )
 ),
 New Column( "Patterns",
  Character,
  "Ordinal",
  List Check( {"0010", "0011", "0100", "0101"} ),
  Set Values( {"0010", "0011", "0100", "0101"} )
 ),
 New Column( "Trial 1", Numeric( 1 ), "Nominal", Set Values( [0, 0, 0, 0] ) ),
 New Column( "Trial 2", Numeric( 1 ), "Nominal", Set Values( [0, 0, 1, 1] ) ),
 New Column( "Trial 3", Numeric( 1 ), "Nominal", Set Values( [1, 1, 0, 0] ) ),
 New Column( "Trial 4", Numeric( 1 ), "Nominal", Set Values( [0, 1, 0, 1] ) )
);
cols1List = {};
cols2List = {};
For( i = 4, i <= N Cols( dt ), i++,
 comp = Associative Array( dt << get rows where( As Column( dt, i ) == 1 ) );
 compMissing = Associative Array( dt << get rows where( As Column( dt, i ) == 0 ) );
 If( N Items( comp ) > 0,
  For( k = i + 1, k <= N Cols( dt ), k++,
   comp2 = Associative Array( dt << get rows where( As Column( dt, k ) == 1 ) );
   comp2Missing = Associative Array( dt << get rows where( As Column( dt, k ) == 0 ) );
   comp2 << intersect( comp );
   comp2Missing << intersect( compMissing );
   If( N Items( comp2 << get keys ) == 0 & N Items( comp2Missing << get keys ) == 0,
    Insert Into( cols1List, Column( dt, i ) << get name );
    Insert Into( cols2List, Column( dt, k ) << get name );
   );
  )
 );
);
nw = New Window( "Results",
 Outline Box( "Columns that can be combined",
  Table Box( String Col Box( "Column", cols1List ), String Col Box( "With", cols2List ) )
 )
);

 

Ri: È possibile utilizzare Missing Data Pattern per accelerare la preparazione dei dati?

Grazie Jim per la risposta e la soluzione molto veloci.

 

Per coloro che desiderano vedere il tuo script in azione, includo lo script di creazione dei dati dell'esempio che ho fornito e il tuo JSL per riportare le colonne che potrebbero essere combinate.

 

names default to here(1);
// Construct the initial data table
New Table( "Missing data initial",
 Add Rows( 20 ),
 New Column( "LOT_ID",
  Character,
  "Nominal",
  Set Values(
   {"AA_234_xx.1", "AA_234_xx.2", "AA_234_xx.3", "AA_234_xx.4",
   "AA_234_xx.5", "AA_234_xx.6", "AA_234_xx.7", "AA_234_xx.8",
   "AA_234_xx.9", "AA_234_xx.10", "AA_234_xx.11", "AA_234_xx.12",
   "AA_234_xx.13", "AA_234_xx.14", "AA_234_xx.15", "AA_234_xx.16",
   "AA_234_xx.17", "AA_234_xx.18", "AA_234_xx.19", "AA_234_xx.20"}
  ),
  Set Display Width( 81 )
 ),
 New Column( "Step1.v1",
  Character( 6 ),
  "Nominal",
  Set Values(
   {"SRD_01", "SRD_02", "SRD_01", "SRD_04", "SRD_02", "", "", "", "", "",
   "SRD_01", "SRD_02", "SRD_01", "SRD_04", "SRD_02", "", "", "", "", ""}
  ),
  Set Display Width( 58 )
 ),
 New Column( "Step1.v2",
  Character( 16 ),
  "Nominal",
  Set Values(
   {"", "", "", "", "", "SRD_01", "SRD_02", "SRD_01", "SRD_04", "SRD_02",
   "", "", "", "", "", "SRD_02", "SRD_02", "SRD_02", "SRD_02", "SRD_02"}
  ),
  Set Display Width( 58 )
 ),
 New Column( "Step2.v2",
  Character( 16 ),
  "Nominal",
  Set Values(
   {"COATER_02", "COATER_01", "", "", "COATER_02", "COATER_01", "COATER_02",
   "COATER_02", "COATER_02", "COATER_01", "COATER_02", "COATER_02",
   "COATER_01", "COATER_01", "COATER_01", "", "", "", "COATER_01",
   "COATER_01"}
  ),
  Set Display Width( 71 )
 ),
 New Column( "Step2.v3",
  Character( 16 ),
  "Nominal",
  Set Values(
   {"", "", "COATER_01", "COATER_01", "", "", "", "", "", "", "", "", "",
   "", "", "COATER_02", "COATER_02", "COATER_02", "", ""}
  ),
  Set Display Width( 71 )
 ),
 New Column( "Step3.v5",
  Character( 16 ),
  "Nominal",
  Set Values(
   {"DRIE_03", "DRIE_04", "DRIE_03", "", "", "", "", "", "", "DRIE_04",
   "DRIE_03", "DRIE_04", "DRIE_03", "DRIE_04", "", "", "", "", "", ""}
  ),
  Set Display Width( 58 )
 ),
 New Column( "Step3.v6",
  Character( 16 ),
  "Nominal",
  Set Values(
   {"", "", "", "DRIE_04", "DRIE_03", "DRIE_04", "DRIE_03", "DRIE_04",
   "DRIE_03", "", "", "", "", "", "DRIE_03", "DRIE_04", "DRIE_03",
   "DRIE_04", "DRIE_03", "DRIE_04"}
  ),
  Set Display Width( 58 )
 ),
 New Column( "Step4.v1",
  Character( 16 ),
  "Nominal",
  Set Values(
   {"PRIME_06", "", "PRIME_07", "", "PRIME_06", "", "PRIME_07", "",
   "PRIME_06", "", "PRIME_07", "", "PRIME_06", "", "PRIME_07", "",
   "PRIME_06", "", "PRIME_07", ""}
  ),
  Set Display Width( 61 )
 ),
 New Column( "Step4.v2",
  Character( 16 ),
  "Nominal",
  Set Values(
   {"", "PRIME_06", "", "PRIME_07", "", "PRIME_06", "", "PRIME_07", "",
   "PRIME_06", "", "PRIME_07", "", "PRIME_06", "", "PRIME_07", "",
   "PRIME_06", "", "PRIME_07"}
  ),
  Set Display Width( 61 )
 )
);

// Check the Missings Data Patern
Data Table( "Missing data initial" ) <<
Missing Data Pattern(
 columns(
  :Step1.v1,
  :Step1.v2,
  :Step2.v2,
  :Step2.v3,
  :Step3.v5,
  :Step3.v6,
  :Step4.v1,
  :Step4.v2
 ),
 Output Table( "Missing Data Pattern" )
);

// Check for columns which could be combined
//  *** JSL written by txnelson ***
dt=Data Table( "Missing Data Pattern"); 
cols1List = {};
cols2List = {};
For( i = 4, i <= N Cols( dt ), i++,
 comp = Associative Array( dt << get rows where( As Column( dt, i ) == 1 ) );
 compMissing = Associative Array( dt << get rows where( As Column( dt, i ) == 0 ) );
 If( N Items( comp ) > 0,
  For( k = i + 1, k <= N Cols( dt ), k++,
   comp2 = Associative Array( dt << get rows where( As Column( dt, k ) == 1 ) );
   comp2Missing = Associative Array( dt << get rows where( As Column( dt, k ) == 0 ) );
   comp2 << intersect( comp );
   comp2Missing << intersect( compMissing );
   If( N Items( comp2 << get keys ) == 0 & N Items( comp2Missing << get keys ) == 0,
    Insert Into( cols1List, Column( dt, i ) << get name );
    Insert Into( cols2List, Column( dt, k ) << get name );
   );
  )
 );
);
nw = New Window( "Results",
 Outline Box( "Columns that can be combined",
  Table Box( String Col Box( "Column", cols1List ), String Col Box( "With", cols2List ) )
 )
);

 

- Filippo

Ri: È possibile utilizzare Missing Data Pattern per accelerare la preparazione dei dati?

Forse è stato un po 'troppo pesante nello scripting .. Non ho usato Missing Data Patterns in questa soluzione a causa della possibilità di avere più di 2 colonne simili (non sono sicuro che sia il caso qui). Molto probabilmente questi potrebbero essere rilevati anche con Missing Data Patterns, ma ho creato la mia soluzione.

 

Tabella dei risultati:

Vengono create nuove colonne e quelle vecchie vengono lasciate da sole (potrebbero essere facilmente eliminate). Il valore nel nome della nuova colonna tra parentesi indica quante colonne sono state combinate per creare la nuova colonna. Step5.v1 e Step5.v2 non sono combinati perché la riga 12 ha lo stesso valore due volte. Dovrebbe essere facile cambiare modificando la funzione F_checkForInversePatterns nello script per consentire le colonne che hanno dati corrispondenti sulla stessa riga.

 

Questa soluzione non tiene conto della somiglianza dei dati all'interno delle colonne (richiederebbe un controllo aggiuntivo). Anche la somiglianza del nome della colonna viene semplicemente controllata se il nome del passaggio prima del periodo è lo stesso tra le colonne.

 

Script allegato.

Ri: È possibile utilizzare Missing Data Pattern per accelerare la preparazione dei dati?

Durante la valutazione dello script di txnelson su una tabella di dati molto più grande dalla produzione, si è scoperto (Jim ha scoperto) che se alcune righe non hanno dati in tutte le colonne mirate, lo script non fornirà un elenco di output. Jim ha gentilmente fornito una correzione allo script. Vedi sotto:

 

Names Default To Here( 1 );
dtRaw = Current Data Table();
colNamesList = dtRaw << get column names( string );
Remove From( colNamesList, 1, 1 );
dt = dtRaw << Missing Data Pattern(
 columns( Eval( colNamesList ) ),
 Output Table( "Missing Data Pattern" )
);

// Get rid of all missing and all present patterns
dt << lock data table( 0 );
dt << select where( Contains( :patterns, "0" ) & !Contains( :Patterns, "1" ) );
Try( dt << delete rows );
dt << select where( Contains( :patterns, "1" ) & !Contains( :Patterns, "0" ) );
Try( dt << delete rows );

// Check for columns which could be combined
//  *** JSL written by txnelson ***
cols1List = {};
cols2List = {};
For( i = 4, i <= N Cols( dt ), i++,
 comp = Associative Array( dt << get rows where( As Column( dt, i ) == 1 ) );
 compMissing = Associative Array( dt << get rows where( As Column( dt, i ) == 0 ) );
 If( N Items( comp ) > 0,
  For( k = i + 1, k <= N Cols( dt ), k++,
   comp2 = Associative Array( dt << get rows where( As Column( dt, k ) == 1 ) );
   comp2Missing = Associative Array( dt << get rows where( As Column( dt, k ) == 0 ) );
   comp2 << intersect( comp );
   comp2Missing << intersect( compMissing );
   If( N Items( comp2 << get keys ) == 0 & N Items( comp2Missing << get keys ) == 0,
    Insert Into( cols1List, Column( dt, i ) << get name );
    Insert Into( cols2List, Column( dt, k ) << get name );
   );
  )
 );
);
nw = New Window( "Results",
 Outline Box( "Columns that can be combined",
  Table Box( String Col Box( "Column", cols1List ), String Col Box( "With", cols2List ) )
 )
);

- Filippo

Ri: È possibile utilizzare Missing Data Pattern per accelerare la preparazione dei dati?

Ciao jthi,

 

Mi piace anche la tua soluzione alternativa. Soprattutto il modo in cui lasci intatte le colonne originali e crei nuove colonne nella tabella dei dati. Un altro problema che affronti è la possibilità di combinare da più di 2 colonne in caso di necessità. Ho avuto questa esigenza anche in alcune occasioni.

 

Sarei interessato a sviluppare ulteriormente il tuo script per includere gli altri controlli pre-combinazione che hai menzionato.

 

Grazie,

 

Filippo

 

 

Ri: È possibile utilizzare Missing Data Pattern per velocizzare la preparazione dei dati?

Salve, per quelli di voi interessati a utilizzare il modello di dati mancanti per migliorare la qualità dei dati, fornisco un breve aggiornamento qui:

 

Stavo usando la sceneggiatura di @txnelson per creare set di dati migliori, ma poi mi sono reso conto che esiste un'istanza in cui vorrei combinare le colonne nonostante il rispettivo modello di dati mancanti (e il complemento) non corrispondano. È quando entrambe le colonne hanno dati mancanti nelle stesse righe.

 

Ecco un esempio, basato sull'esempio originale:

 

 

 

Vorrei combinare le colonne associate al passaggio 6 come visto sopra.

 

Mi è quindi venuto in mente che sarebbe stato utile conoscere la corrispondenza percentuale tra le colonne prima di qualsiasi gestione dei dati. Ciò darebbe la possibilità di utilizzare tali informazioni al momento di decidere se combinare o meno.

Avendo comunicato con @txnelson ha gentilmente sviluppato la sua sceneggiatura.

 

In allegato la versione finale.

 

Includo anche di seguito alcuni esempi che utilizzano dati "reali" in cui questo metodo è stato utilizzato per migliorare la qualità dei dati:

 

Nota: le celle colorate in blu indicano i dati mancanti

 

Caso 1:

A partire dal

per

 

 

Caso 2:

A partire dal

per

 

C'è una notevole riduzione delle colonne e molte meno celle "vuote"

 

Come puoi immaginare, ciò consente analisi delle cause alla radice migliori, più rapide ed efficienti.

 

Sono allegati gli script per creare l'esempio di dati mancanti simulati e lo script finale che riporta "Percentuale combinabile" e "Colonne che possono essere combinate" in base a modelli di dati mancanti.

 

 

 

- Filippo