28662_it-IT

liliconcom

Distribuzioni normali e trasformazioni

Ciao a tutti,

 

Ho alcuni dati misurati e quando provo un adattamento normale continuo, posso vedere che i miei dati non sono normali. Tuttavia, dal test di bontà di adattamento posso vedere che i dati provengono dalla distribuzione Johnson Su.

 

Questa distribuzione ha due parametri di forma, una posizione e un parametro di scala. Dalla mia ricerca online, posso vedere come calcolare la varianza da questi parametri e da lì la deviazione standard. Ho usato Excel per calcolarlo, ma esiste un modo in JMP per farlo? Da quanto ho capito, la tabella Statistiche di riepilogo dell'analisi "Distribuzioni" calcola queste statistiche presupponendo che i dati provengano dalla distribuzione normale.

 

Grazie in anticipo!

 

Natalie

Ri: Distribuzioni e trasformazioni normaliGrazie per la risposta, TXNELSON. Non ci avevo pensato e non me lo aspettavo. Mi chiedo quale sia il valore di tale trasformazione se rende impossibile invertire la trasformazione con precisione. Se sviluppo un modello dai dati trasformati, devo sapere qual è l'output di quel modello nel formato dati originale. Sembra sciocco, quindi, che JMP includa questa trasformazione come opzione. Complimenti per la sceneggiatura originale. Lo conserverò per un utilizzo futuro secondo necessità.Ri: Distribuzioni e trasformazioni normali

Lo script non funzionerà per la trasformazione di Denisity.La funzione produce più valori per lo stesso valore di densità e il codice non può gestirlo.Vedi il grafico qui sotto

 

Ri: Distribuzioni e trasformazioni normali

Forse è il mio set di dati allora? In breve, stavo selezionando un valore dal mio set di dati ed estraendo il valore trasformato lognormale per testare/convalidare il codice. Il mio set di dati è di seguito. Un valore di 7 corrisponde a un valore trasformato di 0,112832236739791, quindi dovrei essere in grado di utilizzare il valore trasformato come destinazione nel codice e lo script dovrebbe restituire 7. Corretto?

 

 

Names Default to Here(1);
dt=New Table( "Test",
 Add Rows( 30 ),
 New Column("PNP3", 
  Numeric,
  "Continuous",
  Format( "Best", 10 ),
  Set Values(
   [12, 4, 12, 13, 7, 5, 5, 15, 5, 5, 5, 15, 7, 7, 16, 5, 9, 11, 18, 8, 16, 12, 7, 14, 6, 11, 7, 10, 14, 10]
  )
 ),
 New Column( "LogNormal Density PNP3",
  Numeric,
  "Continuous",
  Format( "Best", 12 ),
  Formula(
   Normal Density( Log( :PNP3 ), 2.17970974904887, 0.43804625261609 ) / :PNP3
  )
 )
);

/***********************************************************************/
/*                                                                     */
/* The getformula column retrieves the formula from the translation    */
/* column and replaces the Original Column name in the formula with    */
/* string "__value__".  The value of this variable is what will be     */
/* evaluated in the successive approximations done by the script.      */
/*                                                                     */
/***********************************************************************/

getformula = Function( {ColName, FormulaColName},
 {ColName, FormulaColName, TheFormula, coloncolname}, 
 //__value__ = .;
 // Get the transformed data columns formula as a literal string
 TheFormula=Column( FormulaColName ) << Get Formula ;
 
 // Check to see that a formula was found
 If( Is Empty( TheFormula ) == 1 ,
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "      not contain a formula. ",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula=char( Column( FormulaColName ) << Get Formula );

 // Get the actual name of the orignal column since
 // the upper,lower case and spacing is critical in determining
 // where in the formula the column name actually occurs
 ColName = Column( ColName ) << Get Name;
 

 // Determine if the reference to the column name in the 
 // formula is a simple :colname reference or a complex
 // reference :Name(\!"colname\!")
 // If the column name isn't found set the return code to -1
 If(
  Contains( TheFormula, ":" || ColName ), ColonColName = ":" || ColName, // Else
  Contains( TheFormula, ":Name(\!"" || ColName || "\!")" ), ColonColName = ":Name(\!"" || ColName || "\!")", // Else
  rc = -1
 );
  
 // Replace all of the column references in the formula with
 // the string "(__value__)" so that when the formula is 
 // evaluated later, it will take the then value of the memory
 // variable called __value__ and use it in the formula
 If( Contains( TheFormula, ColonColName ) > 0,
  While( Contains( TheFormula, ColonColName ) > 0, TheFormula = Munger( TheFormula, 1, ColonColName, "(__Value__)" ) ),
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "     not contain a reference",
   "      to the original column.",
   "           in it's formula.",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula;
);

/***********************************************************************/
/*                                                                     */
/* The gettrans function evaluates the formula in the transformed      */
/* and converts the formula into a generic form for repeated use in    */
/* running of the script.                                              */
/*                                                                     */
/***********************************************************************/

gettrans = Function( {ColName, FormulaColName, TheTarget, Theformula},
//colname="PNP3";formulacolname="Johnson Sl Transform PNP3"; Thetarget=johnsonmean;theformula=myformula;
 {ColName, FormulaColName, TheFormula, High, Low, TheTarget, TheMax, Themin, __value__}, 

 // The program uses successive approximations to determine the different 
 // parametrics.  The way it works is that it calculates the needed parameter
 // such as Mean, or Standard Deviation, and then by using successive 
 // approximations from the original column's values, and passing those
 // values through the columns formula, when the approximation value matches
 // the calculated value from the transformed column, the retransformed value
 // has been found

 // Set the extreem values
 High = Col Maximum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 Low = Col Minimum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 
 // Make a guess at the first value 
 __value__ = Mean( High, Low );

 // Iterate the guessing for up to 100 times, adjusting by 1/2 on each loop
 For( i = 1, i <= 100, i++,
  TheResult = Eval( Parse( theformula ) );

  If(
   TheResult > TheTarget, High = __value__,
   TheResult < TheTarget, Low = __value__,
   Break()
  );
  If( High == Low, Break() );
  __value__ = Mean( High, Low );
 );
 
 __value__; // Expose the return value
); // End of function gettrans

myFormula = getformula( "PNP3","LogNormal Density PNP3" );

MatchValue = 7;

TargetValue = 0.112832236739791;

dt<<RUN formulas=""></RUN>

 

Dopo aver eseguito il codice, ecco l'output del registro

 

MatchValue = 7;
TargetValue = 0.112832236739791;
Gettrans("PNP3", "LogNormal Density PNP3", 0.112832236739791, myFormula) = 18;

 

L'output della funzione Gettrans dovrebbe essere 7. Il valore 18 emesso dal codice corrisponde a un valore trasformato di 0,0135701784925184.

Ri: Distribuzioni e trasformazioni normali

Non capisco qual è il problema?Poiché tutto ciò che il codice fa è prendere i valori dalla colonna originale e passarli attraverso la formula finché il risultato non è uguale al valore target della colonna trasformata (tipicamente la media della nuova distribuzione).Ho rielaborato lo script dalle mie risposte precedenti, ma questa volta, utilizzando la formula Log Normal Density determinata dalla piattaforma di distribuzione, e il codice sembra funzionare per me

Names Default to Here(1);
dt=New Table( "Test",
 Add Rows( 100 ),
 New Column("PNP3", 
  Numeric,
  "Continuous",
  Format( "Best", 10 ),
  Set Values(
   [130.378809500886, 132.736937590235, 136.831952164704, 136.969154239163,
   136.622623419893, 137.480356512481, 138.094011176166, 142.10586919757,
   134.750041237898, 129.719685093372, 136.520172900026, 134.778624216716,
   136.991131754497, 140.420940666186, 143.257827228986, 132.213765487819,
   144.671172276421, 134.703176752174, 136.744212473486, 137.187637284245,
   139.788226018039, 139.372617199359, 136.112484488985, 142.809097034809,
   137.799370430979, 138.482493403385, 135.236982575217, 136.251777781494,
   130.768356509183, 138.248554728086, 139.77894292052, 134.25405167366,
   147.680687116943, 131.351711991517, 132.84274608728, 129.925216236015,
   133.47206414316, 143.339607103893, 145.341236691691, 139.200187547183,
   142.775409342827, 140.276696563388, 130.623979847275, 140.899814366103,
   136.839389290019, 137.239125319, 133.5265281641, 139.356927352471,
   130.278640163464, 144.604061001983, 135.286715550332, 134.465744849174,
   131.37612790407, 131.830655714309, 140.69724979219, 142.88152043774,
   135.253839945611, 127.349434776131, 129.499730399113, 128.447533754611,
   130.916853702805, 134.599575929218, 140.761701916093, 136.870661473033,
   138.253066182015, 140.403627077024, 134.522643679098, 124.842978178703,
   131.803059455053, 125.886786494664, 133.013566701611, 136.940299158936,
   133.263913979648, 144.695171321015, 149.541020434399, 144.503845528521,
   136.086324063453, 139.530943158798, 138.421460162451, 133.180943784947,
   142.166796633818, 142.676541730822, 135.723943440339, 143.957996114985,
   145.712158558794, 138.38937502716, 140.535304753392, 142.140619481175,
   131.379414509756, 144.949299702964, 133.349854687882, 139.470639804255,
   140.160558367008, 137.130662662612, 145.692632562344, 131.870848869966,
   136.391733804566, 134.219740661271, 139.021827550389, 147.958038547157]
  )
 ),
 New Column( "LogNormal Density PNP3",
  Numeric,
  "Continuous",
  Format( "Best", 12 ),
  Formula(
   Normal Density( Log( :PNP3 ), 4.92072961984847, 0.0370684539915594 ) / :PNP3
  )
 )
);

/***********************************************************************/
/*                                                                     */
/* The getformula column retrieves the formula from the translation    */
/* column and replaces the Original Column name in the formula with    */
/* string "__value__".  The value of this variable is what will be     */
/* evaluated in the successive approximations done by the script.      */
/*                                                                     */
/***********************************************************************/

getformula = Function( {ColName, FormulaColName},
 {ColName, FormulaColName, TheFormula, coloncolname}, 
 //__value__ = .;
 // Get the transformed data columns formula as a literal string
 TheFormula=Column( FormulaColName ) << Get Formula ;
 
 // Check to see that a formula was found
 If( Is Empty( TheFormula ) == 1 ,
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "      not contain a formula. ",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula=char( Column( FormulaColName ) << Get Formula );

 // Get the actual name of the orignal column since
 // the upper,lower case and spacing is critical in determining
 // where in the formula the column name actually occurs
 ColName = Column( ColName ) << Get Name;
 

 // Determine if the reference to the column name in the 
 // formula is a simple :colname reference or a complex
 // reference :Name(\!"colname\!")
 // If the column name isn't found set the return code to -1
 If(
  Contains( TheFormula, ":" || ColName ), ColonColName = ":" || ColName, // Else
  Contains( TheFormula, ":Name(\!"" || ColName || "\!")" ), ColonColName = ":Name(\!"" || ColName || "\!")", // Else
  rc = -1
 );
  
 // Replace all of the column references in the formula with
 // the string "(__value__)" so that when the formula is 
 // evaluated later, it will take the then value of the memory
 // variable called __value__ and use it in the formula
 If( Contains( TheFormula, ColonColName ) > 0,
  While( Contains( TheFormula, ColonColName ) > 0, TheFormula = Munger( TheFormula, 1, ColonColName, "(__Value__)" ) ),
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "     not contain a reference",
   "      to the original column.",
   "           in it's formula.",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula;
);

/***********************************************************************/
/*                                                                     */
/* The gettrans function evaluates the formula in the transformed      */
/* and converts the formula into a generic form for repeated use in    */
/* running of the script.                                              */
/*                                                                     */
/***********************************************************************/

gettrans = Function( {ColName, FormulaColName, TheTarget, Theformula},
//colname="PNP3";formulacolname="Johnson Sl Transform PNP3"; Thetarget=johnsonmean;theformula=myformula;
 {ColName, FormulaColName, TheFormula, High, Low, TheTarget, TheMax, Themin, __value__}, 

 // The program uses successive approximations to determine the different 
 // parametrics.  The way it works is that it calculates the needed parameter
 // such as Mean, or Standard Deviation, and then by using successive 
 // approximations from the original column's values, and passing those
 // values through the columns formula, when the approximation value matches
 // the calculated value from the transformed column, the retransformed value
 // has been found

 // Set the extreem values
 High = Col Maximum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 Low = Col Minimum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 
 // Make a guess at the first value 
 __value__ = Mean( High, Low );

 // Iterate the guessing for up to 100 times, adjusting by 1/2 on each loop
 For( i = 1, i <= 100, i++,
  TheResult = Eval( Parse( theformula ) );

  If(
   TheResult > TheTarget, High = __value__,
   TheResult < TheTarget, Low = __value__,
   Break()
  );
  If( High == Low, Break() );
  __value__ = Mean( High, Low );
 );
 
 __value__; // Expose the return value
); // End of function gettrans

myFormula = getformula( "PNP3","LogNormal Density PNP3" );

dt<<RUN formulas=""></RUN>

Ri: Distribuzioni e trasformazioni normaliCiao TXNELSON,

Ho una domanda sul programma/script che hai collegato. Invertirà facilmente una trasformazione di Johnson, ma non funziona per altre trasformazioni. In particolare, la trasformazione logNormal Density. Ti dispiacerebbe se ti mandassi un messaggio privato per vedere se esiste un modo per modificare lo script affinché funzioni?Ri: Distribuzioni e trasformazioni normali

La colonna ha chiamato "Johnson Sl Transform X By Timepoint" sono i dati trasformati.È questa colonna che contiene i dati normalizzati.Eseguiresti le tue analisi in base a questa colonna.  

Pertanto, quando si esegue un'analisi per determinare se esiste una differenza tra i dati Timepoint1 e Timepoint2, la si eseguirà sulla colonna di dati trasformata.Ora il problema è che riporterà i valori nella scala dei dati trasformati.Pertanto, per ricollegarlo alla colonna originale X, si esegue lo script, inserendo il valore del punto dati dall'analisi e ottenendo il valore in termini di X.

Ri: Distribuzioni e trasformazioni normali

Ovviamente lo script dovrebbe essere eseguito separatamente come ho postato prima. Ho semplicemente allegato il singolo file (Test.jmp) per comodità.Il tuo script non dovrebbe registrare i dati normali dopo la trasformazione Johnson SI nella terza colonna chiamata Y (in quel file della tabella dati) per eseguirlo e vedere la sua forma normale?

Il problema è che nello script non è presente alcuna riga di comando per salvare i dati normali in quella tabella dati. Ecco perché te l'ho chiesto.

Se guardi uno di quei file divisi ed esegui lo script, la terza colonna Y è ancora vuota. Ho pensato che ogni tabella di dati suddivisi potesse essere completata con i dati normali dopo la trasformazione Johnson SI nella terza colonna Y perché dopo vorrei combinarli nuovamente in un unico file per procedere con l'analisi delle statistiche.

 

Punto temporale 1:

JohnsonMean = -3,80945275324507e-15;

Col Media(:X) = -7,4569375;

Gettrans("X", "Johnson Sl Trasforma X per punto temporale", JohnsonMean, miaFormula) = -10,7617217296089;

 

Punto temporale 2:

JohnsonMean = 7,27196081129478e-15;

Col Media(:X) = 3,257375;

Gettrans("X", "Johnson Sl Trasforma X per punto temporale", JohnsonMean, miaFormula) = 1.87687074670016;

 

Grazie per l'aiuto.

Ri: Distribuzioni e trasformazioni normali

La soluzione alla tua domanda deve portare a una decisione umana sul fatto che tu sappia o meno per certo che i diversi gruppi di dati Timepoint provengono da distribuzioni complessive diverse?La mia ipotesi era che la migliore determinazione per stabilire se la distribuzione complessiva provenisse o meno da una distribuzione normale fosse combinare tutti i dati in un'unica valutazione.La conseguenza successiva è utilizzare la singola trasformazione per tutti i dati e quindi eseguire analisi successive sui dati trasformati.Eventuali differenze reali dovrebbero essere identificate all'interno dei dati trasformati.Ora, se disponi di una conoscenza a priori indipendente dei gruppi Timepoint provenienti da distribuzioni separate, dovrai creare sottoinsiemi di dati nei gruppi Timepoint separati ed eseguire lo script separatamente sui diversi sottoinsiemi.

Ri: Distribuzioni e trasformazioni normali

Ciao Jim,

Penso che qui ci sia un malinteso. Tuttavia, il file di registro mostra:

JohnsonMean = 1.72084568816899e-15;
Col Mean(:X) = -2.09978125;
Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, myFormula) = 1.1;

Il tuo script non salva i dati normali dalla colonna "Johnson SI Transformation By Timepoint" nella colonna Y nella mia tabella dati.

Migliore,

Reinaldo

Ri: Distribuzioni e trasformazioni normali

Torna alla tabella dei dati con i punti temporali combinati.Quindi vai su Distribuzione ed eseguilo sui dati trasformati.

 

Quindi vai a

Guida==>Libri==>Alla scoperta di JMP

 

Devi imparare di più su come funziona JMP!

Ri: Distribuzioni e trasformazioni normali

Ho creato due sottoinsiemi: uno per timepoint. Dove utilizzo gli output del file di registro per ottenere e tracciare i dati normali?

Ri: Distribuzioni e trasformazioni normali

1. Ok, lo eseguirò separatamente.

2. Ho gli output che hai menzionato (file di registro) e Johnson SI Transform X By Timepoint (= distribuzione non normale), ma nessun dato assegnato alla colonna Y.

Ri: Distribuzioni e trasformazioni normali

1. Se è necessario ottenere risultati separati per ciascun punto temporale, sarà necessario suddividere la tabella dei dati in tabelle separate per ciascun punto temporale, quindi eseguire lo script su ciascuna di esse separatamente.

2. Ora devi procedere con la tua analisi utilizzando la colonna dei dati trasformati, come se fosse la tua colonna Y.

3. Leggi e assimila il documento

Guida==>Libri==>Alla scoperta di JMP

Ri: Distribuzioni e trasformazioni normali

Mi dispiace, non ti ho detto il file di registro perché non sono riuscito a trovarlo. Sono principiante in JMP. Ora posso trovarlo: Visualizza -> Log.

Ok, ho aggiunto quella riga di comando e ho ottenuto lo stesso risultato!

Qual è il prossimo passo?

 

PS: lo script non considera due punti temporali separatamente per calcolare tali parametri? Forse il nuovo parametro chiamato "Timepoint" verrebbe aggiunto alle funzioni "getformula" e "gettrans".

Ri: Distribuzioni e trasformazioni normali

1. In una delle mie ultime risposte avevo chiesto se aveste guardato nel registro per vedere se c'erano errori.Ho eseguito lo script come hai incluso nella tabella dati allegata dalla tua ultima risposta.Cercando nel registro, è specificato:

The namespace "dt" is not defined in access or evaluation of 'dt:Johnson Sl Transform X By Timepoint' , 
dt:Johnson Sl Transform X By Timepoint/*###*/

Prendendo questo, ed esaminando la sceneggiatura, il riferimento "dt" è nella riga

JohnsonMean = Col Mean( dt:Johnson Sl Transform X By Timepoint );

dt in questo contesto sta cercando una variabile chiamata dt, che punta alla tabella dati da cui leggere i dati.Quindi la correzione al programma consiste nell'aggiungere la riga seguente prima dell'utilizzo del riferimento nel codice.

dt=current data table();

L'ho aggiunto nella mia copia del codice, come prima riga nello script.

Una volta fatto ciò, nel registro ho ottenuto i seguenti risultati dallo script

JohnsonMean = 1.72084568816899e-15;
Col Mean(:X) = -2.09978125;
Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, myFormula) = 1.1;

Nota... i risultati erano nel file di registro.......

 

 

Ri: Distribuzioni e trasformazioni normali

Grazie per il tuo post, Jim! Penso che ora l'analisi delle capacità sia compresa!

 

Per quanto riguarda la trasformazione da dati non normali alla normalità, ho creato un esempio (Test.jmp) che contiene due punti temporali e X come variabile non normale. ho seguito la tua procedura:

 

1. Analizza -> Distribuzione

2. X come "Y, Colonne" e Timepoint come "Per"

3. Ho fatto clic su Distribuzioni Timepoint -> Stack

4. Per ogni punto temporale, ho fatto clic sul triangolo rosso e su "Continuous Fit -> Johnson SI"

5. Ho cliccato su "Fitted Johnson SI -> Salva trasformato"

 

Quindi JMP ha generato la colonna "Johnson SI Transform X By Timepoint"

 

Quindi, questo è il punto: ho provato a eseguire il tuo script che si trova in alto a sinistra nel Test.jmp, ma non è successo nulla.

 

Potresti spiegare cosa ho fatto di sbagliato in quello script, per favore?

 

PS: vorrei che la colonna Y rappresentasse la normalità di X dopo la trasformazione Johnson SI.

 

Grazie molto!

Ri: Distribuzioni e trasformazioni normali

Solitamente vengono applicati ai processi di produzione

Ri: Distribuzioni e trasformazioni normali

Ho ragione a pensare che Cp e Cpk non siano applicati al campo della Psicologia, ma all'Ingegneria, al Controllo di Processo e così via?

Ri: Distribuzioni e trasformazioni normali

L'analisi Cp/Cpk è completamente dominata dai limiti delle specifiche.E sì, è possibile generare limiti di specifica di 3k, tuttavia, utilizzarli su uno spazio di misurazione così limitato mi sembra essere solo ed esercizio nel produrre numeri, non qualcosa di reale significato.

Ri: Distribuzioni e trasformazioni normali

Per quanto riguarda l'analisi di capacità, l'ho vista impostata in uno dei tuoi post precedenti quando mi hai spiegato "i passaggi su come trasformare i dati non in normali" nell'URL: https://community.jmp.com/t5/Discussions/Normal-Distributions-and-Transformations/td-p/28662/page/2?lightbox-message-images-53315=9889i529042A0AA61277A (pagina 2)

 

Sembra che l'"analisi delle capacità" misuri se un sistema può soddisfare una serie di specifiche o requisiti in un controllo statistico del processo, non è vero? Quindi non si applica al mio caso.

 

 

 

Ri: Distribuzioni e trasformazioni normali

Lo chiederò di nuovo, ma in modo più diretto, perché pensi di dover eseguire un'analisi di capacità sui dati?

 

A parte questo, per quanto riguarda lo script che non fornisce alcun output visibile, ci sono messaggi nel registro che indicano eventuali errori?

Ri: Distribuzioni e trasformazioni normali

1. Anche se ho letto l'Analisi di Capacità "misura la conformità di un processo ai limiti di specifica definiti", purtroppo non ho capito esattamente il suo significato in Statistica.

 

2. Pertanto, quando viene creata la nuova colonna "Johnson SI", ho davvero bisogno di eseguire il tuo script. (Inizialmente pensavo che non fosse necessario eseguirlo). Ad ogni modo, ho provato a eseguirlo. Nel mio caso, la tabella dati è in formato colonna. Ho provato ad adattare il tuo script cancellando la prima parte, che creava la tabella dati, e inserendo i nomi delle colonne anziché PNP3 e "Johnson SI Transform PNP3", e l'ho salvato nel riquadro in alto a sinistra (sotto il nome dei dati file) all'interno del file di dati. Quando l'ho eseguito, non è successo nulla. (Non so se l'ho salvato correttamente o se si è verificato un errore di analisi riguardo ai nomi delle colonne poiché non erano nello script, ma nel file di dati). Per favore, Jim ( @txnelson ), come posso eseguire lo script utilizzando un file di dati in formato colonna?

 

Grazie mille!

Ri: Distribuzioni e trasformazioni normali

1. Dovrai dirmi cosa vuoi fare con l'analisi delle capacità.Il mio background è sia in psicologia che in ingegneria.È possibile utilizzare Cp/Cpk per ottenere una stima della capacità, ma poiché lo si utilizza all'interno di un singolo set di dati e non in base a limiti di specifica reali, troverei la statistica alquanto sospetta.

2. Lo scopo della trasformazione dei dati è trasformare i dati in una distribuzione distribuita normalmente.La ragione di ciò è che molti dei test statistici si basano su dati distribuiti normalmente.La statistica Wilconon è un test non parametrico.Non richiede una distribuzione normale.

Ri: Distribuzioni e trasformazioni normali

Ho capito che dovevo eseguire il tuo script. Se non lo eseguo posso vedere quella colonna normalizzata, ma...

 

1. In quale situazione dovrei utilizzare i parametri di Capability Analysis?

2. Quando ho eseguito i dati non normali in un disegno a misure ripetute ho potuto trovare un effetto significativo sulla variabile che ho analizzato nei punti temporali attraverso i risultati del test di confronto multiplo non parametrico (ad esempio, Wilcoxon ogni coppia). Tuttavia, quando ho eseguito i dati, indicando quale colonna era stata trasformata utilizzando Johnson SI, l'effetto significativo è scomparso nei punti temporali. Quindi, di quale risultato dovrei fidarmi?

Ri: Distribuzioni e trasformazioni normali

SÌ.....

Ri: Distribuzioni e trasformazioni normali

Va bene. Dopodiché dovrei eseguire il tuo script per trasformare la colonna Johnson SI nella normalità?

Ri: Distribuzioni e trasformazioni normali

Seleziona "Salva trasformato" dal triangolo rosso nella casella di contorno Fitted Johnson SI.Creerà una nuova colonna di dati utilizzando la trasformazione Johnson SI

 

Ri: Distribuzioni e trasformazioni normali

Ciao Jim ( @txnelson ),

 

Grazie per il tuo post. Ho letto il link che mi avevi suggerito. Come ho capito, potrei adattare la distribuzione utilizzando Johnson SI tramite Capability Analysis, selezionando "Johnson SI" su oppure potrei eseguire Fit Distribution e quindi facendo clic sul triangolo rosso Capability Analysis potrei trovare i limiti delle specifiche come hai suggerito.

 

Sono d'accordo con te sul fatto che i limiti delle specifiche sono tradizionalmente determinati dalla conoscenza dei dati di misurazione. Tuttavia, credo che si applichi al campo dell'ingegneria. Nel campo della psicologia, è difficile avere un'idea di questi limiti, ma solo dei dati raccolti. In questo modo, penso che dovrei eseguire Fit Distribution for Johnson SI e quindi fare clic sul triangolo rosso ==> Set Spec Limits for K Sigma, selezionando K value = 3.

 

Quando lo faccio, ottengo il quantile Sigma e il diagramma appropriato per Johnson SI. Tuttavia, non ho la forma normale dei miei dati, ma solo i parametri (limiti delle specifiche) dall'analisi di capacità. Qual è il prossimo passo, per favore?

 

Grazie.

Ri: Distribuzioni e trasformazioni normali

1. Ti suggerisco di andare alla pagina Web JMP e leggere la documentazione sulla piattaforma di distribuzione

Pagina Web JMP==Supporto==>Documentazione in linea==Analisi di base==>Distribuzioni

Ti fornirà un'ottima formazione su ciò che lo strumento può fare per te.Hai dichiarato che stai utilizzando JMP 10.La versione più recente di JMP è la 14 (che verrà rilasciata a breve) e la documentazione sul Web è JMP 14. Tuttavia, scoprirai che quasi tutto ciò di cui leggerai nella documentazione era disponibile in JMP 10.

2. La determinazione della forma della distribuzione dei dati (ovvero Normale, Johnson SI, Log Normale, ecc.) non è determinata dall'Analisi di Capacità.In realtà è il contrario.La forma della distribuzione determina quali formule utilizzare per calcolare la capacità dei dati.

3. Sembra che tu non capisca quali siano i limiti in un'analisi delle capacità.I limiti delle specifiche sono tradizionalmente determinati dalla conoscenza dei dati di misurazione.Cioè, se si misura la tensione di un componente elettrico, il progetto della parte indicherebbe che affinché la parte funzioni correttamente, la tensione deve essere compresa tra il limite inferiore delle specifiche (LSL) e il limite superiore delle specifiche (USL).Sarebbero questi limiti ad essere utilizzati per determinare la capacità del processo.

4. In molti casi tutto ciò che si desidera ottenere dalla piattaforma di distribuzione è ottenere la determinazione se i dati sono distribuiti normalmente.Ciò è importante perché molte analisi statistiche presuppongono che i dati siano distribuiti normalmente.Quindi lo scopo della trasformazione dei dati è trasformarli in una distribuzione normale, in modo che i test statistici possano fornire risultati più accurati.

Ri: Distribuzioni e trasformazioni normali

Inoltre, sono un principiante in JMP e questa è la prima trasformazione che provo a fare con una complessità aggiuntiva che si riferisce a un disegno a misure ripetute.

 

Non sono ancora riuscito a scoprire la relazione tra "Analisi delle capacità" e "Fitted Johnson SI". Voglio dire, se seleziono il "Analisi delle capacità" prima e supponendo di inserire correttamente i parametri sopra menzionati (il mio post precedente), selezionerò il file " Adattamento continuo==>Tutto", scegliendo Johnson SI. In questo modo, JMP tiene conto delle informazioni immesse in "Analisi di capacità" per valutare il "Fitted Johnson SI"?

 

PS: i miei dati sono in formato alto (o lungo): le righe sono rappresentate dai soggetti; la prima colonna è Timepoints (T1, T2, ...) e la seconda colonna è OUT. Quando ho fatto clic su Fitted Johnson SI==>Save Transformed per ciascun timepoint, la stessa colonna denominata "Johnson SI Transform OUT by Timepoints" è stata completata con i punteggi trasformati. Successivamente ho provato a eseguire l'analisi delle statistiche in Fit Model utilizzando la colonna "Johnson SI Transform OUT by Timepoints" nella casella "Seleziona variabili di ruolo" e {Timepoints, soggetto e casuale, soggetto*Timepoint e casuale} in "Effetti del modello di costruzione" " scatola, ma non sono riuscito a ottenere alcun risultato rilevante.

 

Suppongo che avrei bisogno di eseguire il tuo script immediatamente dopo aver ottenuto la colonna "Johnson SI Transform OUT by Timepoints" (dati trasformati). Ho ragione?

 

Questo è il mio prossimo dubbio: comprendere la procedura descritta come soluzione. Ho eseguito il tuo esempio ed è stato fantastico! Devo imparare come "prendere lo standard dai dati trasformati, calcolare quali sono i valori sopra e sotto la media per 1, 2, 3, ecc. standard, quindi invertire la trasformazione riportando ai dati originali".

 

Grazie mille per l'attenzione e il prezioso aiuto!

Ri: Distribuzioni e trasformazioni normali

Ciao Jim ( @txnelson ), grazie mille per la tua spiegazione!

 

Ho il seguente problema:

 

1. Per il mio caso di studio, il risultato non normale chiamato OUT contiene diversi punti temporali (T1, T2, ...) perché ho un disegno a misure ripetute. Quindi, quando eseguo Analisi==>Distribuzione, suppongo di dover selezionare la variabile OUT come "Y, Colonne" e il tra soggetti (ad esempio, Punti temporali) come "Per" nella finestra di dialogo "Trasmetti colonne selezionate in ruoli" , non è vero?

 

2. Se lo faccio, avrò un grafico OUT rispetto a ciascun punto temporale come OUT rispetto a T1; OUT contro T2 e così via. In JMP v.10, devo seguire le tue istruzioni per ogni grafico perché non può farlo automaticamente. Va bene. Seleziono Distribuzioni Timepoint=T1==>Stack e tutti i grafici vengono visualizzati sull'asse orizzontale.

 

Dubbio: devo prima selezionare "Analisi delle capacità" oppure " Adattamento continuo==>Tutto"? Voglio dire, quando seleziono "Analisi delle capacità" viene visualizzata la finestra di dialogo per inserire i seguenti parametri: "Limite inferiore delle specifiche", "Target" e "Limite superiore delle specifiche" e non so quali valori devo definire. Si basano sul Box plot, escludendo i valori anomali?

 

Grazie.

 

Ri: Distribuzioni e trasformazioni normali

La piattaforma di distribuzione consente di valutare quale sia la distribuzione di una determinata colonna e quindi potrebbe avere un metodo per trasformare i dati in una distribuzione normale.Ecco i passaggi

1. Eseguire la piattaforma di distribuzione, selezionando le colonne desiderate.Il mio esempio proviene dalla tabella dei dati di esempio Semiconductor Capability installata quando è installato JMP.

Analizza==>Distribuzione

2. Una volta visualizzato l'output, selezionare da

Adattamento continuo==>Tutto

3. La piattaforma ti fornirà, in ordine, quali distribuzioni si adattano meglio ai dati.In questo caso, viene selezionato LogNormal.Sfortunatamente, LogNormal non ha la capacità di creare una versione trasformata dei dati, quindi deselezionalo e seleziona Johnson SI.

4. Ora fai clic sul triangolo rosso per "Fitted Johnson SI" e seleziona Salva trasformato

 

JMP ha ora salvato una versione trasformata dei dati in una nuova colonna, che ora puoi utilizzare per le tue analisi

Ri: Distribuzioni e trasformazioni normali

Ciao Jim ( @txnelson ),

Non riuscivo a capire come trasformare un dato non normale in una distribuzione normale in JMP. Per favore, potresti spiegarmi i passaggi da un dato grezzo non normale?

Grazie.

Ri: Distribuzioni e trasformazioni normali

Ecco un programma completo che restituisce un valore basato su un risultato statistico da un insieme di dati trasformato.Spero che questo aiuti

Names Default to Here(1);
dt=New Table( "Test",
 Add Rows( 100 ),
 New Column("PNP3", 
  Numeric,
  "Continuous",
  Format( "Best", 10 ),
  Set Values(
   [130.378809500886, 132.736937590235, 136.831952164704, 136.969154239163,
   136.622623419893, 137.480356512481, 138.094011176166, 142.10586919757,
   134.750041237898, 129.719685093372, 136.520172900026, 134.778624216716,
   136.991131754497, 140.420940666186, 143.257827228986, 132.213765487819,
   144.671172276421, 134.703176752174, 136.744212473486, 137.187637284245,
   139.788226018039, 139.372617199359, 136.112484488985, 142.809097034809,
   137.799370430979, 138.482493403385, 135.236982575217, 136.251777781494,
   130.768356509183, 138.248554728086, 139.77894292052, 134.25405167366,
   147.680687116943, 131.351711991517, 132.84274608728, 129.925216236015,
   133.47206414316, 143.339607103893, 145.341236691691, 139.200187547183,
   142.775409342827, 140.276696563388, 130.623979847275, 140.899814366103,
   136.839389290019, 137.239125319, 133.5265281641, 139.356927352471,
   130.278640163464, 144.604061001983, 135.286715550332, 134.465744849174,
   131.37612790407, 131.830655714309, 140.69724979219, 142.88152043774,
   135.253839945611, 127.349434776131, 129.499730399113, 128.447533754611,
   130.916853702805, 134.599575929218, 140.761701916093, 136.870661473033,
   138.253066182015, 140.403627077024, 134.522643679098, 124.842978178703,
   131.803059455053, 125.886786494664, 133.013566701611, 136.940299158936,
   133.263913979648, 144.695171321015, 149.541020434399, 144.503845528521,
   136.086324063453, 139.530943158798, 138.421460162451, 133.180943784947,
   142.166796633818, 142.676541730822, 135.723943440339, 143.957996114985,
   145.712158558794, 138.38937502716, 140.535304753392, 142.140619481175,
   131.379414509756, 144.949299702964, 133.349854687882, 139.470639804255,
   140.160558367008, 137.130662662612, 145.692632562344, 131.870848869966,
   136.391733804566, 134.219740661271, 139.021827550389, 147.958038547157]
  )
 ),
 New Column( "Johnson Sl Transform PNP3",
  Numeric,
  "Continuous",
  Format( "Best", 12 ),
  Set Property( "Notes", "Fitted Johnson Sl" ),
  Formula(
   (Log( (:PNP3 - 44.6529505888426) / 1 ) * 15.3554291860315 + (
   -69.5611150866502)) * 1
  )
 )
);

/***********************************************************************/
/*                                                                     */
/* The getformula column retrieves the formula from the translation    */
/* column and replaces the Original Column name in the formula with    */
/* string "__value__".  The value of this variable is what will be     */
/* evaluated in the successive approximations done by the script.      */
/*                                                                     */
/***********************************************************************/

getformula = Function( {ColName, FormulaColName},
 {ColName, FormulaColName, TheFormula, coloncolname}, 
 //__value__ = .;
 // Get the transformed data columns formula as a literal string
 TheFormula=Column( FormulaColName ) << Get Formula ;
 
 // Check to see that a formula was found
 If( Is Empty( TheFormula ) == 1 ,
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "      not contain a formula. ",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula=char( Column( FormulaColName ) << Get Formula );

 // Get the actual name of the orignal column since
 // the upper,lower case and spacing is critical in determining
 // where in the formula the column name actually occurs
 ColName = Column( ColName ) << Get Name;
 

 // Determine if the reference to the column name in the 
 // formula is a simple :colname reference or a complex
 // reference :Name(\!"colname\!")
 // If the column name isn't found set the return code to -1
 If(
  Contains( TheFormula, ":" || ColName ), ColonColName = ":" || ColName, // Else
  Contains( TheFormula, ":Name(\!"" || ColName || "\!")" ), ColonColName = ":Name(\!"" || ColName || "\!")", // Else
  rc = -1
 );
  
 // Replace all of the column references in the formula with
 // the string "(__value__)" so that when the formula is 
 // evaluated later, it will take the then value of the memory
 // variable called __value__ and use it in the formula
 If( Contains( TheFormula, ColonColName ) > 0,
  While( Contains( TheFormula, ColonColName ) > 0, TheFormula = Munger( TheFormula, 1, ColonColName, "(__Value__)" ) ),
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "     not contain a reference",
   "      to the original column.",
   "           in it's formula.",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula;
);

/***********************************************************************/
/*                                                                     */
/* The gettrans function evaluates the formula in the transformed      */
/* and converts the formula into a generic form for repeated use in    */
/* running of the script.                                              */
/*                                                                     */
/***********************************************************************/

gettrans = Function( {ColName, FormulaColName, TheTarget, Theformula},
//colname="PNP3";formulacolname="Johnson Sl Transform PNP3"; Thetarget=johnsonmean;theformula=myformula;
 {ColName, FormulaColName, TheFormula, High, Low, TheTarget, TheMax, Themin, __value__}, 

 // The program uses successive approximations to determine the different 
 // parametrics.  The way it works is that it calculates the needed parameter
 // such as Mean, or Standard Deviation, and then by using successive 
 // approximations from the original column's values, and passing those
 // values through the columns formula, when the approximation value matches
 // the calculated value from the transformed column, the retransformed value
 // has been found

 // Set the extreem values
 High = Col Maximum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 Low = Col Minimum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 
 // Make a guess at the first value 
 __value__ = Mean( High, Low );

 // Iterate the guessing for up to 100 times, adjusting by 1/2 on each loop
 For( i = 1, i <= 100, i++,
  TheResult = Eval( Parse( theformula ) );

  If(
   TheResult > TheTarget, High = __value__,
   TheResult < TheTarget, Low = __value__,
   Break()
  );
  If( High == Low, Break() );
  __value__ = Mean( High, Low );
 );
 
 __value__; // Expose the return value
); // End of function gettrans

myFormula = getformula( "PNP3","Johnson Sl Transform PNP3" );

JohnsonMean = Col Mean(dt:Johnson Sl Transform PNP3);

show(JohnsonMean,colMean(:PNP3),Gettrans("PNP3","Johnson Sl Transform PNP3",JohnsonMean,myFormula));

Ri: Distribuzioni e trasformazioni normali

Grazie per aver condiviso questo.

Sono solo un principiante nello scripting, quindi è un po' troppo complicato al momento e non ero sicuro di come usarlo!

---

 

 

Ri: Distribuzioni e trasformazioni normali

Ecco una funzione che ho estratto da un sistema in esecuzione che utilizza approssimazioni successive per ottenere i valori risolti

/***********************************************************************/
/*                                                                     */
/* The getformula column retrieves the formula from the translation    */
/* column and replaces the Original Column name in the formula with    */
/* string "__value__".  The value of this variable is what will be     */
/* evaluated in the successive approximations done by the script.      */
/*                                                                     */
/***********************************************************************/

getformula = Function( {ColName, FormulaColName},
 {ColName, FormulaColName, TheFormula, coloncolname}, 
 //__value__ = .;
 // Get the transformed data columns formula as a literal string
 TheFormula=Column( FormulaColName ) << Get Formula ;
 
 // Check to see that a formula was found
 If( Is Empty( TheFormula ) == 1 ,
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "      not contain a formula. ",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula=char( Column( FormulaColName ) << Get Formula );

 // Get the actual name of the orignal column since
 // the upper,lower case and spacing is critical in determining
 // where in the formula the column name actually occurs
 ColName = Column( ColName ) << Get Name;
 

 // Determine if the reference to the column name in the 
 // formula is a simple :colname reference or a complex
 // reference :Name(\!"colname\!")
 // If the column name isn't found set the return code to -1
 If(
  Contains( TheFormula, ":" || ColName ), ColonColName = ":" || ColName, // Else
  Contains( TheFormula, ":Name(\!"" || ColName || "\!")" ), ColonColName = ":Name(\!"" || ColName || "\!")", // Else
  rc = -1
 );
  
 // Replace all of the column references in the formula with
 // the string "(__value__)" so that when the formula is 
 // evaluated later, it will take the then value of the memory
 // variable called __value__ and use it in the formula
 If( Contains( TheFormula, ColonColName ) > 0,
  While( Contains( TheFormula, ColonColName ) > 0, TheFormula = Munger( TheFormula, 1, ColonColName, "(__Value__)" ) ),
  Dialog(
   "   The column specified as",
   "the Transformed Column does",
   "     not contain a reference",
   "      to the original column.",
   "           in it's formula.",
   " ",
   "    Please rerun and select",
   "       the correct column"
  );
  Throw();
 );
 TheFormula;
);

.

/***********************************************************************/
/*                                                                     */
/* The gettrans function evaluates the formula in the transformed      */
/* and converts the formula into a generic form for repeated use in    */
/* running of the script.                                              */
/*                                                                     */
/***********************************************************************/

gettrans = Function( {ColName, FormulaColName, TheTarget, Theformula},
 {ColName, FormulaColName, TheFormula, High, Low, TheTarget, TheMax, Themin, __value__}, 

 // The program uses successive approximations to determine the different 
 // parametrics.  The way it works is that it calculates the needed parameter
 // such as Mean, or Standard Deviation, and then by using successive 
 // approximations from the original column's values, and passing those
 // values through the columns formula, when the approximation value matches
 // the calculated value from the transformed column, the retransformed value
 // has been found

 // Set the extreem values
 High = Col Maximum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 Low = Col Minimum( If( Excluded( Row State( Empty() ) ) == 0, Column( ColName ), . ) );
 Highm = 999999999999999999999999;
 Lowm = -999999999999999999999999;
 If( Highm > High,
  High = Highm
 );
 If( Lowm < Low, low = lowm );
 
 // Make a guess at the first value 
 __value__ = Mean( High, Low );

 // Iterate the guessing for up to 100 times, adjusting by 1/2 on each loop
 For( i = 1, i <= 100, i++,
  TheResult = Eval( Parse( theformula ) );
  If(
   TheResult > TheTarget, High = __value__,
   TheResult < TheTarget, Low = __value__,
   Break()
  );
  If( High == Low, Break() );
  __value__ = Mean( High, Low );
 );
 
 __value__; // Expose the return value
); // End of function gettrans

 

 

Ri: Distribuzioni e trasformazioni normali

Ciao Jim,

Ho lo stesso problema. Ho modellato alcuni dati trasformati di Johnson Si e ho ottenuto un modello previsto. Ho provato a utilizzare la funzione inversa per trasformare nuovamente i dati previsti, ma non funziona. Saresti in grado di fornire ulteriori indicazioni sulla scrittura di una sceneggiatura per farlo? Continuo a imbattermi in questi tipi di distribuzioni durante la modellazione delle risposte degli esperimenti DOE, quindi sarebbe davvero utile sapere come trasferire nuovamente i dati.
Grazie molto!

Christel

Ri: Distribuzioni e trasformazioni normali

Penso di aver mancato il punto della tua domanda. Se vuoi calcolare le "bande" in base alla probabilità, la posizione di queste bande sarà diversa a seconda del tipo di distribuzione che hai. I tuoi numeri 68-95-99.7 non sono deviazioni standard, ma sono probabilità associate a “bande” basate su distanze di 1,2,3 deviazioni standard dalla media basata su una distribuzione normale. Se non hai una distribuzione normale, il problema non è nel calcolo della deviazione standard, ma nella conversione in probabilità. Se si desidera avere +/- 3 bande di deviazione standard, si presuppone che la distribuzione sia normale o almeno simmetrica. A seconda di ciò che si vuole fare, è possibile calcolare le bande asimmetriche (JMP ha distribuzioni di probabilità non solo per le distribuzioni normali, ma per tutte le distribuzioni), oppure è necessario eseguire una trasformazione per normalizzare i dati (e quindi effettuare trasformazioni all'indietro ogni volta che che desideri riconvertire alle metriche naturali). La mia preferenza sarebbe quella di utilizzare bande asimmetriche e utilizzare la funzione JOHNSON SU per calcolarle.

aiuto online

Ri: Distribuzioni e trasformazioni normaliGrazie per la risposta Jim! Ci proverò.Ri: Distribuzioni e trasformazioni normaliEcco cosa faccio. Per impostare i limiti sui miei dati originali, in base ai valori dei dati trasformati, prendo lo std dai dati trasformati, calcolo quali sono i valori sopra e sotto la media per 1, 2, 3, ecc. std, quindi inverto il valore trasformazione dei dati originali. In alcuni casi, come Johnson SU, non esiste un modo semplice per trasformare nuovamente i valori. Quello che faccio allora è eseguire un piccolo script che passa un valore attraverso la trasformazione originale, controlla il valore dello std target , quindi ripete il valore finché non viene trovata una corrispondenza. Quindi hai trovato il valore nei dati originali che, una volta trasformato, risulta nel valore target dei valori trasformati. Ricorda, quando lo fai, le distanze sopra e sotto la media nei dati originali non saranno le stesse.Ri: Distribuzioni e trasformazioni normali

Oh, però pensavo che fosse importante per la deviazione standard. Ad esempio, la regola 68-95-99,7 (tre deviazioni standard) viene utilizzata per trovare i valori all'interno di una fascia attorno alla media in una distribuzione normale. Tuttavia, se i miei dati non sono normali, potrebbe non avere senso utilizzarli. Ad esempio, se la resistenza on del mio transistor non è normale e voglio vedere qual è il valore a 3 deviazioni standard dalla media, potrei avere un valore negativo o un valore molto basso che in realtà non ha alcun senso .

 

Scusate se ho fatto confusione o ho frainteso qualcosa, sto appena iniziando a riprendere l'apprendimento delle statistiche dai tempi dell'università!

Ri: Distribuzioni e trasformazioni normali

Grazie, ho visto come è andata. Ora che vedo che i dati sono normali, come posso utilizzarli per trovare la deviazione standard? Nelle statistiche riassuntive è indicato un valore che ha senso in base alla trasformazione, ma vorrei sapere qual è la deviazione standard per i dati originali. Forse non capisco lo scopo della trasformazione dei dati.

 

Ri: Distribuzioni e trasformazioni normali

Natalie

La formula per la varianza e la deviazione standard non fa alcuna ipotesi sulla forma della distribuzione. È solo algebra (allo stesso modo in cui il calcolo di un valore medio non fa alcuna ipotesi sul tipo di distribuzione).

Ri: Distribuzioni e trasformazioni normali

Natalie,

Dovresti essere in grado di salvare semplicemente la trasformazione in una nuova colonna e quindi eseguire la distribuzione su quella colonna.

 

Jim

Re: Distribuzioni normali e trasformazioni

Ciao David e a tutti,

Sono nuovo di JMP e ho qualche domanda sulla trasformazione dei dati.
Quali sono i vantaggi/svantaggi se lavoriamo con l'adattamento dei dati rispetto alla trasformazione dei dati per ottenere una distribuzione normale?

Inoltre, se dopo la trasformazione non ho un buon valore p, dovrei considerare la mia trasformazione?

Grazie

Re: Distribuzioni normali e trasformazioni

Kowa, innanzitutto benvenuto nella community. La tua domanda non può trovare una risposta soddisfacente in questo forum. Ti suggerisco di iniziare da qui:

https://www.ime.usp.br/~abe/lista/pdfQWaCMboK68.pdf

Ci sono due motivi principali per effettuare una trasformazione:

1. Soddisfare le ipotesi quantitative di residui distribuiti normalmente e indipendentemente con una media di 0 e una varianza di consenso (NID(0, varianza). Se queste ipotesi non vengono soddisfatte, allora dovresti mettere in discussione il modello proposto.

2. Ciò che il dottor Box mi disse anni fa è che l'unica ragione per trasformare è semplificare il modello... in sostanza, renderlo più utilizzabile.