Normalverteilungen und TransformationenHallo allerseits,
Ich habe einige Messdaten und wenn ich eine kontinuierliche Normalanpassung versuche, kann ich feststellen, dass meine Daten nicht normal sind. Allerdings kann ich anhand des Goodness-of-Fit-Tests erkennen, dass die Daten aus der Johnson-Su-Verteilung stammen.
Diese Verteilung hat zwei Form-, einen Orts- und einen Skalenparameter. Anhand meiner Online-Recherche kann ich erkennen, wie ich die Varianz dieser Parameter und daraus die Standardabweichung berechnen kann. Ich habe Excel verwendet, um das zu berechnen, aber gibt es in JMP eine Möglichkeit, dies zu tun? Nach meinem Verständnis berechnet die Tabelle „Zusammenfassungsstatistik“ aus der Analyse „Verteilungen“ diese Statistiken unter der Annahme, dass die Daten aus der Normalverteilung stammen.
Dank im Voraus!
Natalie
Betreff: Normalverteilungen und TransformationenVielen Dank für die Antwort, Txnelson. Daran habe ich nicht gedacht und ich hätte auch nicht damit gerechnet, dass das der Fall sein würde. Ich frage mich, welchen Wert diese Transformation dann hat, wenn sie es unmöglich macht, die Transformation mit Genauigkeit rückgängig zu machen. Wenn ich aus den transformierten Daten ein Modell entwickle, muss ich wissen, wie die Ausgabe dieses Modells in der ursprünglichen Datenform aussieht. Es erscheint daher albern, dass JMP diese Transformation überhaupt als Option einbezieht. Ein großes Lob für das Originalskript. Ich werde es für die zukünftige Verwendung bei Bedarf aufbewahren.Betreff: Normalverteilungen und TransformationenDas Skript funktioniert nicht für die Denisity-Transformation.Die Funktion erzeugt mehrere Werte für denselben Dichtewert und der Code kann damit nicht umgehen.Siehe Grafik unten
Betreff: Normalverteilungen und TransformationenVielleicht ist es dann mein Datensatz? Kurz gesagt, ich habe einen Wert aus meinem Datensatz ausgewählt und den logarithmisch transformierten Wert zum Testen/Validieren des Codes herausgezogen. Mein Datensatz ist unten. Ein Wert von 7 entspricht einem transformierten Wert von 0,112832236739791, daher sollte ich den transformierten Wert als Ziel im Code verwenden können und das Skript sollte 7 ausspucken. Richtig?
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>
Nach dem Ausführen des Codes finden Sie hier die Protokollausgabe
MatchValue = 7;
TargetValue = 0.112832236739791;
Gettrans("PNP3", "LogNormal Density PNP3", 0.112832236739791, myFormula) = 18;
Die Ausgabe der Gettrans-Funktion sollte 7 sein. Der Wert 18, den der Code ausgibt, entspricht einem transformierten Wert von 0,0135701784925184.
Betreff: Normalverteilungen und TransformationenIch verstehe nicht, worum es geht?Da der Code lediglich Werte aus der ursprünglichen Spalte übernimmt und sie durch die Formel leitet, bis das Ergebnis dem Zielwert aus der transformierten Spalte entspricht (normalerweise dem Mittelwert der neuen Verteilung).Ich habe das Skript aus meinen vorherigen Antworten überarbeitet, diesmal jedoch mit der von der Verteilungsplattform ermittelten Log-Normaldichte-Formel, und der Code scheint für mich zu funktionieren
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>Betreff: Normalverteilungen und TransformationenHallo Txnelson,
Ich habe eine Frage zu dem Programm/Skript, das Sie verlinkt haben. Eine Johnson-Transformation lässt sich problemlos rückgängig machen, bei anderen Transformationen funktioniert es jedoch nicht. Insbesondere die logNormal-Dichtetransformation. Würde es Ihnen etwas ausmachen, wenn ich Ihnen eine PM schicke, um zu sehen, ob es eine Möglichkeit gibt, das Skript so zu ändern, dass es funktioniert?Betreff: Normalverteilungen und TransformationenDie Spalte namens „Johnson Sl Transform X By Timepoint“ sind die transformierten Daten.Diese Spalte enthält die normalisierten Daten.Sie würden Ihre Analysen basierend auf dieser Spalte durchführen.
Wenn Sie daher eine Analyse ausführen, um festzustellen, ob ein Unterschied zwischen den Daten zu Zeitpunkt 1 und Zeitpunkt 2 besteht, führen Sie diese für die transformierte Datenspalte aus.Das Problem besteht nun darin, dass Werte im Maßstab der transformierten Daten gemeldet werden.Um es also wieder mit der ursprünglichen Spalte X in Beziehung zu setzen, führen Sie das Skript aus, geben den Datenpunktwert aus der Analyse ein und erhalten den Wert in Bezug auf X zurück.
Betreff: Normalverteilungen und TransformationenNatürlich sollte das Skript separat ausgeführt werden, wie ich zuvor gepostet habe. Der Einfachheit halber habe ich nur die einzelne Datei (Test.jmp) beigefügt.Sollte Ihr Skript nicht die normalen Daten nach der Johnson SI-Transformation in der dritten Spalte namens Y (in dieser Datentabellendatei) aufzeichnen, um sie auszuführen und ihre normale Form zu sehen?
Das Problem besteht darin, dass Ihr Skript keine Befehlszeile zum Speichern der normalen Daten in dieser Datentabelle enthält. Deshalb wurde ich Sie danach gefragt.
Wenn Sie sich eine dieser geteilten Dateien ansehen und Ihr Skript ausführen, ist die dritte Spalte Y immer noch leer. Ich dachte, jede geteilte Datentabelle könnte durch die normalen Daten nach der Johnson-SI-Transformation in der dritten Spalte Y vervollständigt werden, weil ich sie danach wieder in einer Datei kombinieren möchte, um mit meiner Statistikanalyse fortzufahren.
Zeitpunkt 1:
JohnsonMean = -3,80945275324507e-15;
Col Mean(:X) = -7,4569375;
Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, myFormula) = -10.7617217296089;
Zeitpunkt 2:
JohnsonMean = 7,27196081129478e-15;
Col Mean(:X) = 3,257375;
Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, myFormula) = 1.87687074670016;
Ich danke Ihnen für Ihre Hilfe.
Betreff: Normalverteilungen und TransformationenDie Lösung Ihrer Frage muss eine menschliche Entscheidung darüber einbringen, ob Sie sicher wissen, dass die verschiedenen Zeitpunktgruppen von Daten aus unterschiedlichen Gesamtverteilungen stammen?Ich ging davon aus, dass die beste Bestimmung, ob die Gesamtverteilung von einer Normalverteilung stammt oder nicht, darin besteht, alle Daten in einer einzigen Auswertung zu kombinieren.Und die Folge davon ist, die einzelne Transformation für alle Daten zu verwenden und dann nachfolgende Analysen an diesen transformierten Daten durchzuführen.Alle echten Unterschiede sollten innerhalb der transformierten Daten identifiziert werden.Wenn Sie nun über ein unabhängiges A-priori-Wissen darüber verfügen, dass die Timepoint-Gruppen aus separaten Distributionen stammen, müssen Sie die Daten in die separaten Timepoint-Gruppen unterteilen und das Skript separat für die verschiedenen Subsets ausführen.
Betreff: Normalverteilungen und TransformationenHallo Jim,
Ich glaube, hier liegt ein Missverständnis vor. Die Protokolldatei zeigt jedoch Folgendes:
JohnsonMean = 1.72084568816899e-15;
Col Mean(:X) = -2.09978125;
Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, myFormula) = 1.1;Ihr Skript speichert die normalen Daten aus der Spalte „Johnson SI Transformation By Timepoint“ nicht in der Y-Spalte meiner Datentabelle.
Am besten,
Reinaldo
Betreff: Normalverteilungen und TransformationenGehen Sie zurück zur Datentabelle mit den kombinierten Zeitpunkten.Gehen Sie dann zu „Verteilung“ und führen Sie es mit den transformierten Daten aus.
Dann geh zu
Hilfe==>Bücher==>JMP entdecken
Sie müssen mehr über die Funktionsweise von JMP erfahren!
Betreff: Normalverteilungen und TransformationenIch habe zwei Teilmengen erstellt: eine pro Zeitpunkt. Wo verwende ich die Ausgaben der Protokolldatei, um die normalen Daten abzurufen und darzustellen?
Betreff: Normalverteilungen und Transformationen1. Okay, ich werde es separat ausführen.
2. Ich habe die von Ihnen erwähnten Ausgaben (Protokolldatei) und die Johnson SI-Transformation X nach Zeitpunkt (= Nicht-Normalverteilung), aber der Y-Spalte sind keine Daten zugewiesen.
Betreff: Normalverteilungen und Transformationen1. Wenn Sie für jeden Zeitpunkt separate Ergebnisse benötigen, müssen Sie die Datentabelle für jeden Zeitpunkt in separate Tabellen unterteilen und dann das Skript für jede dieser Tabellen separat ausführen.
2. Sie müssen nun mit Ihrer Analyse unter Verwendung der transformierten Datenspalte fortfahren, als wäre es Ihre Y-Spalte.
3. Lesen und verdauen Sie das Dokument
Hilfe==>Bücher==>JMP entdecken
Betreff: Normalverteilungen und TransformationenLeider habe ich Ihnen die Protokolldatei nicht mitgeteilt, da ich sie nicht finden konnte. Ich bin Anfänger in JMP. Jetzt kann ich es finden: Ansicht -> Protokoll.
Okay, ich habe diese Befehlszeile hinzugefügt und das gleiche Ergebnis erhalten!
Was ist der nächste Schritt? 
PS: Berücksichtigt das Skript nicht zwei Zeitpunkte getrennt, um diese Parameter zu berechnen? Möglicherweise würde der neue Parameter „Timepoint“ in den Funktionen „getformula“ und „gettrans“ hinzugefügt.
Betreff: Normalverteilungen und Transformationen1. Ich hatte in einer meiner letzten Antworten gefragt, ob Sie im Protokoll nachgesehen hätten, ob dort Fehler aufgetreten seien.Ich habe das Skript so ausgeführt, wie Sie es in der beigefügten Datentabelle Ihrer letzten Antwort angegeben hatten.Beim Durchsuchen des Protokolls wurde Folgendes angegeben:
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/*###*/
Wenn man das betrachtet und sich das Skript anschaut, findet man in der Zeile den Verweis „dt“.
JohnsonMean = Col Mean( dt:Johnson Sl Transform X By Timepoint );
dt sucht in diesem Zusammenhang nach einer Variablen namens dt, die auf die Datentabelle zeigt, aus der die Daten gelesen werden sollen.Die Korrektur am Programm besteht also darin, die folgende Zeile vor der Verwendung der Referenz im Code hinzuzufügen.
dt=current data table();
Ich habe es in meine Kopie des Codes als erste Zeile im Skript eingefügt.
Nachdem ich das getan hatte, bekam ich im Protokoll die folgenden Ergebnisse des Skripts
JohnsonMean = 1.72084568816899e-15;
Col Mean(:X) = -2.09978125;
Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, myFormula) = 1.1;
Bitte beachten Sie, dass die Ergebnisse in der Protokolldatei enthalten waren.
Betreff: Normalverteilungen und TransformationenVielen Dank für deinen Beitrag, Jim! Ich denke, jetzt ist die Fähigkeitsanalyse verstanden! 
Bezüglich der Transformation von nicht-normalen Daten zu Normalität habe ich ein Beispiel (Test.jmp) erstellt, das zwei Zeitpunkte und X als nicht-normale Variable enthält. Ich bin deiner Vorgehensweise gefolgt:
1. Analysieren -> Verteilung
2. X als „Y, Spalten“ und Zeitpunkt als „By“
3. Ich habe auf Verteilungszeitpunkt -> Stapel geklickt
4. Für jeden Zeitpunkt habe ich auf das rote Dreieck und „Continuous Fit -> Johnson SI“ geklickt.
5. Ich habe auf „Fitted Johnson SI -> Transformiert speichern“ geklickt.
Dann generierte JMP die Spalte „Johnson SI Transform X By Timepoint“
Darum geht es also: Ich habe versucht, Ihr Skript oben links in Test.jmp auszuführen, aber es ist nichts passiert.
Könnten Sie bitte erklären, was ich in diesem Skript falsch gemacht habe?
PS: Ich möchte, dass die Y-Spalte die Normalität von X nach der Johnson-SI-Transformation darstellt.
Vielen Dank!
Betreff: Normalverteilungen und TransformationenSie werden typischerweise auf Herstellungsprozesse angewendet
Betreff: Normalverteilungen und TransformationenLiege ich richtig, wenn ich annehme, dass Cp und Cpk nicht auf den Bereich Psychologie, sondern auf Ingenieurwesen, Prozesskontrolle usw. angewendet werden?
Betreff: Normalverteilungen und TransformationenDie Cp/Cpk-Analyse wird vollständig von den Spezifikationsgrenzen dominiert.Und ja, Sie können 3k-Spezifikationsgrenzen generieren lassen, allerdings scheint mir ihre Verwendung auf einem so begrenzten Messraum nur eine Übung zur Erzeugung von Zahlen zu sein und nichts von wirklicher Bedeutung.
Betreff: Normalverteilungen und TransformationenWas die Fähigkeitsanalyse betrifft, habe ich sie in einem Ihrer vorherigen Beiträge eingerichtet, als Sie mir in der URL „die Schritte zum Umwandeln von nicht-in normale Daten“ erklärt haben: https://community.jmp.com/t5/Discussions/Normal-Distributions-and-Transformations/td-p/28662/page/2?lightbox-message-images-53315=9889i529042A0AA61277A (Seite 2)
Es scheint, dass die „Fähigkeitsanalyse“ misst, ob ein System eine Reihe von Spezifikationen oder Anforderungen in einer statistischen Prozesskontrolle erfüllen kann, nicht wahr? Es trifft also nicht auf meinen Fall zu.
Betreff: Normalverteilungen und TransformationenIch werde noch einmal fragen, aber direkter: Warum müssen Sie Ihrer Meinung nach eine Fähigkeitsanalyse für die Daten durchführen?
Abgesehen davon, dass das Skript keine sichtbare Ausgabe liefert, gibt es im Protokoll Meldungen, die auf Fehler hinweisen?
Betreff: Normalverteilungen und Transformationen1. Obwohl ich gelesen habe, dass die Fähigkeitsanalyse „die Konformität eines Prozesses mit definierten Spezifikationsgrenzen misst“, habe ich leider nicht genau verstanden, was sie in der Statistik bedeutet.
2. Wenn die neue Spalte „Johnson SI“ erstellt wird, muss ich daher unbedingt Ihr Skript ausführen. (Anfangs dachte ich, dass es nicht notwendig sei, es auszuführen). Wie auch immer, ich habe versucht, es auszuführen. In meinem Fall liegt die Datentabelle im Spaltenformat vor. Ich habe versucht, Ihr Skript anzupassen, indem ich den ersten Teil gelöscht habe, der die Datentabelle erstellt hat, und die Namen der Spalten anstelle von PNP3 und „Johnson SI Transform PNP3“ eingefügt habe, und habe es im Feld oben links (unter dem Namen der Daten) gespeichert Datei) in der Datendatei. Als ich es ausführte, passierte nichts. (Ich weiß nicht, ob ich es richtig gespeichert habe oder ob beim Parsen ein Fehler in Bezug auf die Spaltennamen aufgetreten ist, da diese nicht im Skript, sondern in der Datendatei enthalten waren). Bitte, Jim ( @txnelson ), wie kann ich Ihr Skript mit einer Datendatei im Spaltenformat ausführen?
Vielen Dank!
Betreff: Normalverteilungen und Transformationen1. Sie müssen mir sagen, was Sie mit der Fähigkeitsanalyse machen möchten.Mein Hintergrund liegt sowohl in der Psychologie als auch im Ingenieurwesen.Sie könnten Cp/Cpk verwenden, um eine gewisse Schätzung der Leistungsfähigkeit zu erhalten, aber da Sie es innerhalb eines einzelnen Datensatzes verwenden und nicht auf tatsächlichen Spezifikationsgrenzen basieren, fände ich die Statistik etwas verdächtig.
2. Der Zweck der Datentransformation besteht darin, die Daten in eine normalverteilte Verteilung umzuwandeln.Der Grund dafür ist, dass viele der statistischen Tests auf normalverteilten Daten basieren.Die Wilconon-Statistik ist ein nichtparametrischer Test.Es ist keine Normalverteilung erforderlich.
Betreff: Normalverteilungen und TransformationenMir wurde klar, dass ich Ihr Skript ausführen musste. Wenn ich es nicht ausführe, kann ich sehen, dass die Spalte normalisiert ist, aber ...
1. In welcher Situation sollte ich diese Parameter aus der Fähigkeitsanalyse verwenden?
2. Als ich die nicht-normalen Daten in einem Design mit wiederholten Messungen durchführte, konnte ich anhand der Ergebnisse des nichtparametrischen Mehrfachvergleichstests (z. B. Wilcoxon Each Pair) einen signifikanten Effekt auf die Variable feststellen, die ich über die Zeitpunkte hinweg analysiert hatte. Als ich jedoch die Daten ausführte, deren Spalte mithilfe von Johnson SI transformiert worden war, verschwand dieser signifikante Effekt über alle Zeitpunkte hinweg. Welchem Ergebnis sollte ich also vertrauen?
Betreff: Normalverteilungen und TransformationenJa.....
Betreff: Normalverteilungen und TransformationenOkay. Soll ich danach Ihr Skript ausführen, um diese Johnson SI-Spalte in den Normalzustand umzuwandeln?
Betreff: Normalverteilungen und TransformationenWählen Sie „Transformiert speichern“ aus dem roten Dreieck im Umrissfeld „Fitted Johnson SI“.Mithilfe der Johnson-SI-Transformation wird eine neue Datenspalte erstellt
Betreff: Normalverteilungen und TransformationenHallo Jim ( @txnelson ),
Vielen Dank für Ihren Beitrag. Ich habe den Link gelesen, den Sie vorgeschlagen haben. Soweit ich weiß, könnte ich die Verteilung mithilfe von Johnson SI über die Fähigkeitsanalyse anpassen, indem ich „Johnson SI“ für den auswähle, oder ich könnte die Anpassungsverteilung ausführen und dann auf das rote Dreieck klicken. Fähigkeitsanalyse, als die ich die Spezifikationsgrenzen finden könnte du schlugst vor.
Ich stimme mit Ihnen überein, dass Spezifikationsgrenzwerte traditionell auf der Grundlage der Kenntnis der Messdaten ermittelt werden. Ich glaube jedoch, dass es auf den Ingenieurbereich zutrifft. Im Bereich der Psychologie ist es schwierig, eine Vorstellung von diesen Grenzen zu haben, sondern nur von den gesammelten Daten. Auf diese Weise denke ich, ich sollte die Anpassungsverteilung für Johnson SI ausführen und dann auf das rote Dreieck klicken ==> Spezifikationsgrenzen für K Sigma festlegen und K-Wert = 3 auswählen.
Wenn ich das mache, erhalte ich das Quantil-Sigma und das passende Diagramm für Johnson SI. Allerdings habe ich nicht die normale Form meiner Daten, sondern nur die Parameter (Spezifikationsgrenzen) aus der Fähigkeitsanalyse. Was ist bitte der nächste Schritt?
Danke schön.
Betreff: Normalverteilungen und Transformationen1. Ich schlage vor, dass Sie die JMP-Webseite besuchen und die Dokumentation zur Distributionsplattform lesen
JMP-Webseite==Support==>Online-Dokumentation==Grundlegende Analyse==>Verteilungen
Dadurch erhalten Sie eine sehr gute Aufklärung darüber, was das Tool für Sie tun kann.Sie haben angegeben, dass Sie JMP 10 verwenden.Die neueste JMP-Version ist 14 (wird in Kürze veröffentlicht) und die Dokumentation im Internet ist JMP 14. Sie werden jedoch feststellen, dass fast alles, worüber Sie in der Dokumentation lesen werden, in JMP 10 verfügbar war.
2. Die Bestimmung der Form Ihrer Datenverteilung (z. B. Normal, Johnson SI, Log-Normal usw.) wird nicht durch die Fähigkeitsanalyse bestimmt.Es ist tatsächlich das Gegenteil.Die Form der Verteilung bestimmt, welche Formeln zur Berechnung der Fähigkeit der Daten verwendet werden.
3. Sie scheinen die Grenzen einer Fähigkeitsanalyse nicht zu verstehen.Spezifikationsgrenzen werden üblicherweise anhand der Kenntnis der Messdaten ermittelt.Das heißt, wenn Sie die Spannung einer elektrischen Komponente messen, würde das Design des Teils vorsehen, dass die Spannung zwischen der unteren Spezifikationsgrenze (LSL) und der oberen Spezifikationsgrenze (USL) liegen muss, damit das Teil ordnungsgemäß funktioniert.Es wären diese Grenzen, die bei der Bestimmung der Leistungsfähigkeit des Prozesses verwendet würden.
4. In vielen Fällen möchten Sie mit der Distributionsplattform lediglich feststellen, ob die Daten normalverteilt sind.Dies ist wichtig, weil viele statistische Analysen davon ausgehen, dass die Daten normalverteilt sind.Der Zweck der Datentransformation besteht also darin, die Daten in eine Normalverteilung umzuwandeln, damit die statistischen Tests genauere Ergebnisse liefern können.
Betreff: Normalverteilungen und TransformationenDarüber hinaus bin ich ein Anfänger in JMP und dies ist meine erste Transformation, die ich mit einer zusätzlichen Komplexität durchzuführen versuche, die sich auf ein Design mit wiederholten Takten bezieht.
Ich konnte den Zusammenhang zwischen „Capability Analysis“ und „Fitted Johnson SI“ noch nicht herausfinden. Ich meine, wenn ich das auswähle „Fähigkeitsanalyse“ Zuerst und vorausgesetzt, ich gebe die oben genannten Parameter (mein vorheriger Beitrag) richtig ein, dann wähle ich die aus " „Kontinuierliche Anpassung==>Alle“, Auswahl von Johnson SI. Berücksichtigt JMP auf diese Weise die in der „Fähigkeitsanalyse“ eingegebenen Informationen zur Bewertung des „Fitted Johnson SI“?
PS: Meine Daten liegen im Hochformat (oder Langformat) vor: Zeilen werden durch Subjekte dargestellt; Die erste Spalte ist Zeitpunkte (T1, T2, ...) und die zweite Spalte ist OUT. Als ich für jeden Zeitpunkt auf „Fitted Johnson SI ==>Transformiert speichern“ klickte, wurde dieselbe Spalte namens „Johnson SI Transform OUT by Timepoints“ mit diesen transformierten Werten ausgefüllt. Danach habe ich versucht, die Statistikanalyse in „Fit Model“ auszuführen, indem ich die Spalte „Johnson SI Transform OUT by Timepoints“ im Feld „Rollenvariablen auswählen“ und {Timepoints, subject& Random, subject*Timepoints & Random} im Feld „Contruct Model Effects“ verwendet habe " Kasten, aber ich konnte kein relevantes Ergebnis erzielen.
Ich nehme an, ich müsste Ihr Skript sofort ausführen, nachdem ich die Spalte „Johnson SI Transform OUT by Timepoints“ (transformierte Daten) erhalten habe. Habe ich recht?
Das ist mein nächster Zweifel: Ich verstehe Ihr als Lösung beschriebenes Verfahren. Ich habe Ihr Beispiel ausgeführt und es war erstaunlich! Ich muss lernen, wie man „den Standardwert aus den transformierten Daten nimmt, die Werte über und unter dem Mittelwert für 1, 2, 3 usw. berechnet und dann die Transformation wieder auf die ursprünglichen Daten umkehrt“.
Vielen Dank für Ihre Aufmerksamkeit und wertvolle Hilfe!
Betreff: Normalverteilungen und TransformationenHallo Jim ( @txnelson ), vielen Dank für Ihre Erklärung!
Ich habe folgendes Problem:
1. Für meinen Studienfall enthält das nicht normale Ergebnis namens OUT verschiedene Zeitpunkte (T1, T2, ...), da ich ein Design mit wiederholten Messungen habe. Wenn ich also „Analyse ==> Verteilung“ ausführe, muss ich im Dialogfeld „Ausgewählte Spalten in Rollen umwandeln“ vermutlich diese Variable OUT als „Y, Spalten“ und das Zwischensubjekt (z. B. Zeitpunkte) als „Nach“ auswählen , nicht wahr?
2. Wenn ich das mache, erhalte ich eine Darstellung von OUT gegenüber jedem Zeitpunkt, z. B. OUT gegenüber T1; OUT vs. T2 und so weiter. In JMP v.10 muss ich Ihren Anweisungen für jeden Plot folgen, da dies nicht automatisch möglich ist. Es ist okay. Ich wähle „Distributions Timepoint=T1==>Stack“ aus und alle Diagramme werden auf der horizontalen Achse angezeigt.
Zweifel: Soll ich zuerst „Fähigkeitsanalyse“ oder „ Kontinuierliche Passform==>Alle“? Ich meine, wenn ich „Fähigkeitsanalyse“ auswähle, erscheint das Dialogfeld zur Eingabe der folgenden Parameter: „Untere Spezifikationsgrenze“, „Ziel“ und „Obere Spezifikationsgrenze“, und ich weiß nicht, welche Werte ich definieren muss. Basieren sie auf dem Box-Plot, ohne Ausreißer?
Danke schön.
Betreff: Normalverteilungen und TransformationenDie Verteilungsplattform ermöglicht es, die Verteilung einer bestimmten Spalte auszuwerten, und verfügt dann möglicherweise über eine Methode, um die Daten in eine Normalverteilung umzuwandeln.Hier sind die Schritte
1. Führen Sie die Distributionsplattform aus und wählen Sie die gewünschte(n) Spalte(n) aus.Mein Beispiel stammt aus der Beispieldatentabelle „Semiconductor Capability“, die bei der Installation von JMP installiert wurde.
Analysieren==>Verteilung
2. Sobald die Ausgabe angezeigt wird, wählen Sie aus
Kontinuierliche Passform==>Alle
3. Die Plattform zeigt Ihnen der Reihe nach an, welche Verteilungen am besten zu den Daten passen.In diesem Fall wird LogNormal ausgewählt.Leider ist LogNormal nicht in der Lage, eine transformierte Version der Daten zu erstellen. Deaktivieren Sie es daher und wählen Sie Johnson SI aus.
4. Klicken Sie nun auf das rote Dreieck für „Fitted Johnson SI“ und wählen Sie „Transformiert speichern“.
JMP hat nun eine transformierte Version der Daten in einer neuen Spalte gespeichert, die Sie nun für Ihre Analysen verwenden können
Betreff: Normalverteilungen und TransformationenHallo Jim ( @txnelson ),
Ich konnte nicht verstehen, wie man in JMP nichtnormale Daten in eine Normalverteilung umwandelt. Könnten Sie mir bitte die Schritte erklären, die bei der Erstellung nicht normaler Rohdaten erforderlich sind?
Danke schön.
Betreff: Normalverteilungen und TransformationenHier ist ein vollständiges Programm, das einen Wert zurückgibt, der auf einem statistischen Ergebnis aus einem transformierten Datensatz basiert.Ich hoffe, das hilft
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));
Betreff: Normalverteilungen und TransformationenVielen Dank, dass Sie dies geteilt haben.
Ich bin nur ein Skript-Anfänger, daher ist es im Moment etwas zu kompliziert und ich war mir nicht sicher, wie ich es verwenden soll!
Betreff: Normalverteilungen und TransformationenHier ist eine Funktion, die ich aus einem laufenden System entnommen habe, das sukzessive Approximationen verwendet, um die aufgelösten Werte zu erhalten
/***********************************************************************/
/* */
/* 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
Betreff: Normalverteilungen und TransformationenHallo Jim,
Ich habe das gleiche Problem. Ich habe einige mit Johnson Si transformierte Daten modelliert und ein vorhergesagtes Modell erhalten. Ich habe versucht, die Umkehrfunktion zu verwenden, um die vorhergesagten Daten zurückzutransformieren, aber es funktioniert nicht. Könnten Sie uns weitere Hinweise zum Schreiben eines Skripts geben, um dies zu erreichen? Ich stoße bei der Modellierung von Antworten aus DOE-Experimenten immer wieder auf diese Art von Verteilungen, daher wäre es wirklich nützlich zu wissen, wie man die Daten zurücküberträgt.
Vielen Dank!
Christel
Betreff: Normalverteilungen und TransformationenIch glaube, ich habe den Sinn Ihrer Frage verfehlt. Wenn Sie „Bänder“ auf der Grundlage der Wahrscheinlichkeit berechnen möchten, unterscheidet sich die Position dieser Bänder je nach der Art Ihrer Verteilung. Ihre Zahlen 68-95-99,7 sind keine Standardabweichungen, sondern Wahrscheinlichkeiten, die mit „Bändern“ verknüpft sind, die auf Abständen von 1,2,3 Standardabweichungen vom Mittelwert basierend auf einer Normalverteilung basieren. Wenn Sie keine Normalverteilung haben, liegt das Problem nicht in der Berechnung der Standardabweichung, sondern in der Umrechnung in Wahrscheinlichkeiten. Wenn Sie +/- 3 Standardabweichungsbänder haben möchten, gehen Sie davon aus, dass die Verteilung normal oder zumindest symmetrisch ist. Je nachdem, was Sie tun möchten, können Sie entweder asymmetrische Bänder berechnen (JMP verfügt nicht nur über Wahrscheinlichkeitsverteilungen für die Normalverteilungen, sondern für alle Verteilungen) oder Sie müssen eine Transformation durchführen, um die Daten zu normalisieren (und dann jederzeit Rücktransformationen durchführen). die Sie wieder in natürliche Messwerte umwandeln möchten). Ich bevorzuge die Verwendung asymmetrischer Bänder und deren Berechnung mithilfe der Funktion JOHNSON SU.
Onlinehilfe
Betreff: Normalverteilungen und TransformationenDanke für deine Antwort, Jim! Ich werde es versuchen.Betreff: Normalverteilungen und TransformationenFolgendes mache ich. Um meine Grenzwerte für meine ursprünglichen Daten auf der Grundlage der transformierten Datenwerte festzulegen, nehme ich den Standardwert aus den transformierten Daten, berechne die Werte über und unter dem Mittelwert für 1, 2, 3 usw. Standardwerte und kehre sie dann um Transformation zurück zu den Originaldaten. In manchen Fällen, wie zum Beispiel bei Johnson SU, gibt es keine einfache Möglichkeit, die Werte zurück zu transformieren. Was ich dann mache, ist, ein kleines Skript auszuführen, das einen Wert durch die ursprüngliche Transformation leitet und den Wert des Zielstandards überprüft , iteriert dann den Wert, bis eine Übereinstimmung vorliegt. Dann haben Sie in den Originaldaten den Wert gefunden, der bei der Transformation zum Zielwert der transformierten Werte führt. Denken Sie daran, dass dabei die Abstände über und unter dem Mittelwert in Ihren Originaldaten nicht gleich sind.Betreff: Normalverteilungen und TransformationenOh, ich dachte allerdings, dass es für die Standardabweichung eine Rolle spielt. Beispielsweise wird die Regel 68-95-99,7 (drei Standardabweichungen) verwendet, um die Werte innerhalb eines Bandes um den Mittelwert einer Normalverteilung zu ermitteln. Wenn meine Daten jedoch nicht normal sind, ist die Verwendung möglicherweise nicht sinnvoll. Wenn beispielsweise der Einschaltwiderstand meines Transistors nicht normal ist und ich sehen möchte, wie hoch der Wert bei 3 Standardabweichungen vom Mittelwert ist, kann es sein, dass ich einen negativen Wert oder einen sehr niedrigen Wert habe, der eigentlich keinen Sinn ergibt .
Tut mir leid, wenn ich etwas verwirre oder falsch verstehe, ich fange gerade erst wieder an, seit der Uni wieder Statistik zu lernen!
Betreff: Normalverteilungen und TransformationenDanke, ich verstehe, wie es das gemacht hat. Da ich nun sehe, dass die Daten normal sind, wie kann ich damit die Standardabweichung ermitteln? In der zusammenfassenden Statistik steht ein Wert, der aufgrund der Transformation sinnvoll ist, aber ich würde gerne wissen, wie hoch die Standardabweichung für die Originaldaten ist. Vielleicht verstehe ich den Zweck der Datentransformation nicht.
Betreff: Normalverteilungen und TransformationenNatalie
Die Formel für Varianz und Standardabweichung macht keine Annahmen über die Form der Verteilung. Es ist nur Algebra (so wie bei der Berechnung eines Durchschnittswerts keine Annahmen über die Art der Verteilung gemacht werden).
Betreff: Normalverteilungen und TransformationenNatalie,
Sie sollten die Transformation einfach in einer neuen Spalte speichern und dann die Verteilung für diese Spalte ausführen können.
Jim
Betreff: Normalverteilungen und Transformationenhallo David und alle anderen,
Ich bin neu bei JMP und interessiere mich für die Datentransformation.
was sind die Vor-/Nachteile, wenn wir mit Datenanpassung im Vergleich zur Datentransformation arbeiten, um eine Normalverteilung zu erhalten?
Sollte ich auch nach der Transformation meine Transformation berücksichtigen, wenn ich keinen guten p-Wert habe?
Danke
Betreff: Normalverteilungen und TransformationenKowa, erstmal herzlich willkommen in der Community. Deine Frage kann hier im Forum nicht ausreichend beantwortet werden. Ich schlage vor, du beginnst hier:
https://www.ime.usp.br/~abe/lista/pdfQWaCMboK68.pdf
Es gibt zwei Hauptgründe für eine Transformation:
1. Erfüllen Sie die quantitativen Annahmen von normal und unabhängig verteilten Residuen mit einem Mittelwert von 0 und einer Zustimmungsvarianz (NID(0, Varianz). Wenn diese Annahmen nicht erfüllt sind, sollten Sie das vorgeschlagene Modell in Frage stellen.
2. Dr. Box hat mir vor Jahren gesagt, dass der einzige Grund für eine Transformation darin besteht, das Modell zu vereinfachen … oder im Wesentlichen, es benutzerfreundlicher zu machen.
