28662_fr-FR

liliconcom

Distributions normales et transformations

Salut tout le monde,

 

J'ai des données mesurées et lorsque j'essaie un ajustement normal continu, je peux voir que mes données ne sont pas normales. Cependant, je peux voir à partir du test d'adéquation de l'ajustement que les données proviennent de la distribution Johnson Su.

 

Cette distribution a deux formes, un emplacement et un paramètre d'échelle. Grâce à mes recherches en ligne, je peux voir comment calculer la variance de ces paramètres et à partir de là l'écart type. J'ai utilisé Excel pour calculer cela, mais existe-t-il un moyen dans JMP de le faire ? D'après ma compréhension, le tableau Statistiques récapitulatives de l'analyse "Distributions" calcule ces statistiques en supposant que les données proviennent de la distribution normale.

 

Merci d'avance!

 

Nathalie

Re : Distributions normales et transformationsMerci pour la réponse, txnelson. Je n'y avais pas pensé et je ne m'attendais pas à ce que ce soit le cas. Je me demande quelle est alors la valeur de cette transformation si elle rend impossible d'inverser la transformation avec précision. Si je développe un modèle à partir des données transformées, j'ai besoin de savoir quel est le résultat de ce modèle sous la forme de données d'origine. Il semble donc idiot que JMP inclue même cette transformation comme option. Bravo pour le scénario original. Je le conserverai pour une utilisation future si nécessaire.Re : Distributions normales et transformations

Le script ne fonctionnera pas pour la transformation Denisity.La fonction produit plusieurs valeurs pour la même valeur de densité et le code ne peut pas gérer cela.Voir graphique ci-dessous

 

Re : Distributions normales et transformations

Peut-être que c'est mon ensemble de données alors ? En bref, je choisissais une valeur dans mon ensemble de données et extrayais la valeur transformée lognormale pour tester/valider le code. Mon ensemble de données est ci-dessous. Une valeur de 7 correspond à une valeur transformée de 0,112832236739791, je devrais donc pouvoir utiliser la valeur transformée comme cible dans le code et le script devrait cracher 7. Correct?

 

 

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>

 

Après avoir exécuté le code, voici la sortie du journal

 

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

 

La sortie de la fonction Gettrans doit être 7. La valeur de 18 générée par le code correspond à une valeur transformée de 0,0135701784925184.

Re : Distributions normales et transformations

Je ne comprends pas quel est le problème ?Puisque tout ce que le code fait, c'est prendre les valeurs de la colonne d'origine et les transmettre à travers la formule jusqu'à ce que le résultat soit égal à la valeur cible de la colonne transformée (généralement la moyenne de la nouvelle distribution).J'ai retravaillé le script à partir de mes réponses précédentes, mais cette fois, en utilisant la formule Log Normal Density déterminée par la plateforme de distribution, et le code semble fonctionner pour moi.

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>

Re : Distributions normales et transformationsSalut Txnelson,

J'ai une question sur le programme/script que vous avez lié. Cela inversera facilement une transformation de Johnson, mais cela ne fonctionne pas pour d'autres transformations. En particulier, la transformation logNormal Densité. Cela vous dérangerait-il si je vous envoie un MP pour voir s'il existe un moyen de modifier le script pour qu'il fonctionne ?Re : Distributions normales et transformations

La colonne appelée "Johnson Sl Transform X By Timepoint" correspond aux données transformées.C'est cette colonne qui contient les données normalisées.Vous exécuteriez vos analyses sur la base de cette colonne.  

Par conséquent, lorsque vous exécutez une analyse pour déterminer s’il existe une différence entre les données Timepoint1 et Timepoint2, vous l’exécutez sur la colonne de données transformée.Le problème est maintenant qu'il rapportera les valeurs à l'échelle des données transformées.Ainsi, afin de le relier à la colonne X d'origine, vous exécutez le script, en entrant la valeur du point de données de l'analyse et en récupérant quelle est la valeur en termes de X.

Re : Distributions normales et transformations

Bien sûr, le script doit être exécuté séparément, comme je l'ai déjà posté. Je viens de joindre le fichier unique (Test.jmp) pour plus de commodité.Votre script ne devrait-il pas enregistrer les données normales après la transformation Johnson SI dans la troisième colonne appelée Y (dans ce fichier de table de données) afin de l'exécuter et de voir sa forme normale ?

Le problème est qu'il n'y a pas de ligne de commande dans votre script pour enregistrer les données normales dans cette table de données. C'est pourquoi on vous a interrogé à ce sujet.

Si vous recherchez l'un de ces fichiers fractionnés et exécutez votre script, la troisième colonne Y est toujours vide. Je pensais que chaque tableau de données fractionnées pourrait être complété par les données normales après la transformation Johnson SI dans la troisième colonne Y, car après cela, j'aimerais les combiner à nouveau en un seul fichier pour procéder à mon analyse des statistiques.

 

Point temporel 1 :

JohnsonMean = -3,80945275324507e-15 ;

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

Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, myFormula) = -10.7617217296089;

 

Point temporel 2 :

JohnsonMean = 7,27196081129478e-15 ;

Col moyenne (: X) = 3,257375 ;

Gettrans("X", "Johnson Sl Transform X By Timepoint", JohnsonMean, maFormule) = 1,87687074670016;

 

Merci pour votre aide.

Re : Distributions normales et transformations

La solution de votre question doit amener une décision humaine quant à savoir si vous savez ou non avec certitude que les différents groupes de données Timepoint proviennent de distributions globales différentes ?Mon hypothèse était que la meilleure façon de déterminer si la distribution globale provenait ou non d'une distribution normale était de combiner toutes les données en une seule évaluation.La suite consiste à utiliser la transformation unique pour toutes les données, puis à effectuer des analyses ultérieures sur ces données transformées.Toute véritable différence doit être identifiée dans les données transformées.Maintenant, si vous avez une connaissance a priori indépendante des groupes Timepoint provenant de distributions distinctes, vous devrez alors regrouper les données dans les groupes Timepoint distincts et exécuter le script séparément sur les différents sous-ensembles.

Re : Distributions normales et transformations

Salut Jim,

Je pense qu'il y a un malentendu ici. Cependant, le fichier journal affiche :

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

Votre script n'enregistre pas les données normales de la colonne "Johnson SI Transformation By Timepoint" dans la colonne Y de ma table de données.

Meilleur,

Reinaldo

Re : Distributions normales et transformations

Revenez au tableau de données avec les points temporels combinés.Accédez ensuite à Distribution et exécutez-le sur les données transformées.

 

Ensuite aller à

Aide==>Livres==>Découverte de JMP

 

Vous devez en savoir plus sur le fonctionnement de JMP !

Re : Distributions normales et transformations

J'ai créé deux sous-ensembles : un par point temporel. Où puis-je utiliser les sorties du fichier journal pour obtenir et tracer les données normales ?

Re : Distributions normales et transformations

1. D'accord, je vais l'exécuter séparément.

2. J'ai les sorties que vous avez mentionnées (fichier journal) et Johnson SI Transform X By Timepoint (= distribution non normale), mais aucune donnée affectée à la colonne Y.

Re : Distributions normales et transformations

1. Si vous avez besoin d'obtenir des résultats distincts pour chaque point temporel, vous devrez sous-ensembler la table de données en tables distinctes pour chaque point temporel, puis exécuter le script sur chacun d'eux séparément.

2. Vous devez maintenant procéder à votre analyse en utilisant la colonne de données transformée, comme s'il s'agissait de votre colonne Y.

3. Lisez et digérez le document

Aide==>Livres==>Découverte de JMP

Re : Distributions normales et transformations

Désolé, je ne vous ai pas indiqué le fichier journal car je ne l'ai pas trouvé. Je suis débutant en JMP. Maintenant, je peux le trouver : Affichage -> Journal.

D'accord, j'ai ajouté cette ligne de commande et j'ai obtenu le même résultat !

Quelle est la prochaine étape ?

 

PS : le script ne considère-t-il pas deux points de temps séparément pour calculer ces paramètres ? Peut-être que le nouveau paramètre appelé "Timepoint" serait ajouté dans ces fonctions "getformula" et "gettrans".

Re : Distributions normales et transformations

1. Dans l'une de mes dernières réponses, j'avais demandé si vous aviez regardé dans le journal s'il y avait des erreurs.J'ai exécuté le script tel que vous l'aviez inclus dans le tableau de données ci-joint de votre dernière réponse.En regardant dans le journal, il a précisé :

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/*###*/

En prenant cela et en regardant le script, la référence "dt" est dans la ligne

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

dt dans ce contexte recherche une variable appelée dt, qui pointe vers la table de données à partir de laquelle lire les données.La correction du programme consiste donc à ajouter la ligne suivante avant l'utilisation de la référence dans le code.

dt=current data table();

Je l'ai ajouté dans ma copie du code, comme première ligne du script.

Une fois que j'ai fait cela, dans le journal, j'ai obtenu les résultats suivants du script

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

Veuillez noter......les résultats étaient dans le fichier journal.......

 

 

Re : Distributions normales et transformations

Merci pour votre message, Jim! Je pense que maintenant l'analyse de capacité est comprise !

 

Concernant la transformation des données non normales en normalité, j'ai créé un exemple (Test.jmp) qui contient deux points temporels et X comme variable non normale. J'ai suivi ta procédure :

 

1. Analyser -> Distribution

2. X comme "Y, Colonnes" et Timepoint comme "Par"

3. J'ai cliqué sur Distributions Timepoint -> Stack

4. Pour chaque point temporel, j'ai cliqué sur le triangle rouge et "Continuous Fit -> Johnson SI"

5. J'ai cliqué sur "Fitted Johnson SI -> Save Transformed"

 

Ensuite, JMP a généré la colonne "Johnson SI Transform X By Timepoint"

 

Voilà donc le point : j'ai essayé d'exécuter votre script qui se trouve en haut à gauche du Test.jmp, mais rien ne s'est produit.

 

Pouvez-vous expliquer ce que j'ai fait de mal dans ce script, s'il vous plaît ?

 

PS : j'aimerais que la colonne Y représente la normalité de X après transformation Johnson SI.

 

Merci beaucoup!

Re : Distributions normales et transformations

Ils sont généralement appliqués aux processus de fabrication

Re : Distributions normales et transformations

Ai-je raison de penser que le Cp et le Cpk ne sont pas appliqués au domaine de la psychologie, mais à l'ingénierie, au contrôle des processus, etc. ?

Re : Distributions normales et transformations

L'analyse Cp/Cpk est complètement dominée par les limites de spécification.Et oui, vous pouvez générer des limites de spécifications de 3 000, cependant, les utiliser sur un espace de mesure aussi limité me semble être uniquement un exercice de production de nombres, sans rien avoir de réel sens.

Re : Distributions normales et transformations

Concernant l'analyse de capacité, je l'ai vue mise en place dans l'un de vos messages précédents lorsque vous m'avez expliqué "les étapes de transformation de données non normales" dans l'URL : https://community.jmp.com/t5/Discussions/Normal-Distributions-and-Transformations/td-p/28662/page/2?lightbox-message-images-53315=9889i529042A0AA61277A (page 2)

 

Il semble que « l'analyse de capacité » mesure si un système peut répondre à un ensemble de spécifications ou d'exigences dans le cadre d'un contrôle statistique de processus, n'est-ce pas ? Cela ne s'applique donc pas à mon cas.

 

 

 

Re : Distributions normales et transformations

Je vous demanderai à nouveau, mais plus directement, pourquoi pensez-vous que vous devez exécuter une analyse de capacité sur les données ?

 

Cela mis à part, étant donné que le script ne vous fournit aucune sortie visible, y a-t-il des messages dans le journal indiquant des erreurs ?

Re : Distributions normales et transformations

1. Bien que j'ai lu l'analyse de capacité "mesure la conformité d'un processus aux limites de spécification définies", malheureusement je n'ai pas compris exactement sa signification en statistiques.

 

2. Par conséquent, lorsque la nouvelle colonne "Johnson SI" est créée, j'ai vraiment besoin d'exécuter votre script. (Au départ, je pensais qu'il n'était pas nécessaire de l'exécuter). Quoi qu'il en soit, j'ai essayé de l'exécuter. Dans mon cas, le tableau de données est au format colonne. J'ai tenté d'adapter votre script en supprimant la première partie, qui créait la table de données, et en insérant les noms de colonnes plutôt que PNP3 et "Johnson SI Transform PNP3", et je l'ai enregistré dans la case en haut à gauche (sous le nom des données fichier) à l’intérieur du fichier de données. Quand je l'ai exécuté, rien ne s'est passé. (Je ne sais pas si je l'ai enregistré correctement ou si j'ai eu une erreur d'analyse concernant les noms de colonnes puisqu'ils n'étaient pas dans le script, mais dans le fichier de données). S'il te plaît, Jim ( @txnelson ), comment puis-je exécuter votre script à l'aide d'un fichier de données au format colonne ?

 

Merci beaucoup!

Re : Distributions normales et transformations

1. Vous devrez me dire ce que vous souhaitez faire avec l'analyse de capacité.Mon expérience est à la fois en psychologie et en ingénierie.Vous pouvez utiliser Cp/Cpk pour obtenir une certaine estimation de la capacité, mais comme vous l'utilisez dans un seul ensemble de données et non sur la base de limites de spécifications réelles, je trouverais la statistique quelque peu suspecte.

2. Le but de la transformation des données est de transformer les données en une distribution normalement distribuée.La raison en est que de nombreux tests statistiques sont basés sur des données normalement distribuées.La statistique Wilconon est un test non paramétrique.Cela ne nécessite pas de distribution normale.

Re : Distributions normales et transformations

J'ai compris que je devais exécuter votre script. Si je ne l'exécute pas, je peux voir cette colonne normalisée, mais...

 

1. Dans quelle situation dois-je utiliser ces paramètres de Capability Analysis ?

2. Lorsque j'ai analysé les données non normales dans un plan à mesures répétées, j'ai pu trouver un effet significatif sur la variable que j'ai analysée à travers les points temporels grâce aux résultats du test de comparaison multiple non paramétrique (par exemple, Wilcoxon Each Pair). Cependant, lorsque j'ai analysé les données, dont la colonne avait été transformée à l'aide de Johnson SI, cet effet significatif a disparu au fil des points de temps. Alors, à quel résultat dois-je me fier ?

Re : Distributions normales et transformations

Oui.....

Re : Distributions normales et transformations

D'accord. Après cela, dois-je exécuter votre script pour transformer cette colonne Johnson SI en normalité ?

Re : Distributions normales et transformations

Sélectionnez "Enregistrer transformé" dans le triangle rouge dans la zone de contour Fitted Johnson SI.Il créera une nouvelle colonne de données en utilisant la transformation Johnson SI

 

Re : Distributions normales et transformations

Salut Jim ( @txnelson ),

 

Merci pour votre commentaire. J'ai lu le lien que vous aviez suggéré. Si j'ai bien compris, je pouvais ajuster la distribution en utilisant Johnson SI via Capability Analysis, en sélectionnant "Johnson SI" sur le ou je pouvais exécuter la distribution Fit, puis en cliquant sur le triangle rouge Capability Analysis, je pouvais trouver les limites de spécifications comme vous avez suggéré.

 

Je suis d'accord avec vous que les limites de spécifications sont traditionnellement déterminées à partir de la connaissance des données de mesure. Cependant, je crois que cela s'applique au domaine de l'ingénierie. Dans le domaine de la psychologie, il est difficile d'avoir une idée de ces limites, mais seulement des données collectées. De cette façon, je pense que je devrais exécuter la distribution d'ajustement pour Johnson SI, puis cliquer sur le triangle rouge ==> Définir les limites de spécifications pour K Sigma, en sélectionnant la valeur K = 3.

 

Quand je le fais, j'obtiens le Quantile Sigma et le tracé approprié pour Johnson SI. Cependant, je n'ai pas la forme normale de mes données, mais seulement les paramètres (limites de spécifications) de Capability Analysis. Quelle est la prochaine étape, s'il vous plaît ?

 

Merci.

Re : Distributions normales et transformations

1. Je vous suggère d'aller sur la page Web de JMP et de lire la documentation sur la plateforme de distribution

Page Web JMP==Support==>Documentation en ligne==Analyse de base==>Distributions

Cela vous donnera une très bonne formation sur ce que l’outil peut faire pour vous.Vous avez déclaré que vous utilisez JMP 10.La version la plus récente de JMP est la 14 (à paraître sous peu) et la documentation sur le Web est JMP 14. Cependant, vous constaterez que presque tout ce que vous lirez dans la documentation était disponible dans JMP 10.

2. La détermination de la forme de la distribution de vos données (c'est-à-dire Normal, Johnson SI, Log Normal, etc.) n'est pas déterminée par l'analyse de capacité.C'est en réalité le contraire.La forme de la distribution détermine les formules à utiliser pour calculer la capacité des données.

3. Vous semblez ne pas comprendre quelles sont les limites d’une analyse de capabilité.Les limites de spécifications sont traditionnellement déterminées à partir de la connaissance des données de mesure.Autrement dit, si vous mesurez la tension d'un composant électrique, la conception de la pièce indiquera que pour que la pièce fonctionne correctement, la tension doit être comprise entre la limite inférieure de spécification (LSL) et la limite supérieure de spécification (USL).Ce seraient ces limites qui seraient utilisées pour déterminer la capacité du processus.

4. Dans de nombreux cas, tout ce que vous souhaitez obtenir de la plate-forme de distribution est de déterminer si les données sont normalement distribuées.La raison pour laquelle cela est important est que de nombreuses analyses statistiques partent de l’hypothèse que les données sont normalement distribuées.Le but de la transformation des données est donc de transformer les données en une distribution normale, afin que les tests statistiques puissent fournir des résultats plus précis.

Re : Distributions normales et transformations

De plus, je suis débutant en JMP et c'est ma première transformation que j'essaie de faire avec une complexité supplémentaire qu'elle fait référence à une conception à mesures répétées.

 

Je n'ai pas encore pu découvrir la relation entre "Capability Analysis" et "Fitted Johnson SI". Je veux dire, si je sélectionne le "Analyse des capacités" d'abord et en supposant que j'entre correctement les paramètres susmentionnés (mon message précédent), je sélectionnerai alors le " Ajustement continu==>Tous", en choisissant Johnson SI. De cette manière, JMP prend-il en compte les informations saisies dans « Analyse de capacité » pour évaluer le « Fitted Johnson SI » ?

 

PS : Mes données sont au format haut (ou long) : les lignes sont représentées par des sujets ; la première colonne est Timepoints (T1, T2, ...) et la deuxième colonne est OUT. Lorsque j'ai cliqué sur Fitted Johnson SI==>Save Transformed pour chaque point temporel, la même colonne appelée "Johnson SI Transform OUT by Timepoints" a été complétée avec ces scores transformés. Après cela, j'ai essayé d'exécuter l'analyse des statistiques dans Fit Model en utilisant la colonne "Johnson SI Transform OUT by Timepoints" dans la zone "Choisir les variables de rôle" et {Timepoints, subject& Random, subject*Timepoints & Random} dans la zone "Contruct Model Effects". " boîte, mais je n'ai pu obtenir aucun résultat pertinent.

 

Je suppose que je devrais exécuter votre script immédiatement après avoir obtenu la colonne "Johnson SI Transform OUT by Timepoints" (données transformées). Ai-je raison?

 

C'est mon prochain doute : comprendre votre procédure décrite comme solution. J'ai exécuté votre exemple et c'était incroyable ! Je dois apprendre à "prendre la norme à partir des données transformées, calculer quelles sont les valeurs supérieures et inférieures à la moyenne pour 1, 2, 3, etc. normes, puis inverser la transformation pour revenir aux données d'origine.".

 

Merci beaucoup pour votre attention et votre aide précieuse !

Re : Distributions normales et transformations

Salut Jim ( @txnelson ), merci beaucoup pour votre explication !

 

J'ai le problème suivant :

 

1. Pour mon cas d'étude, le résultat anormal appelé OUT contient différents moments (T1, T2, ...) car j'ai une conception à mesures répétées. Ainsi, lorsque je fais Analysis==>Distribution, je suppose que je dois sélectionner cette variable OUT comme "Y, Columns" et l'entre-sujet (par exemple, Timepoints) comme "By" dans la boîte de dialogue "Transformer les colonnes sélectionnées en rôles". , n'est-ce pas ?

 

2. Si je le fais, j'aurai un tracé OUT par rapport à chaque point temporel tel que OUT par rapport à T1 ; OUT contre T2 et ainsi de suite. Dans JMP v.10, je dois suivre vos instructions pour chaque tracé car il ne peut pas le faire automatiquement. C'est bon. Je sélectionne sur Distributions Timepoint=T1==>Stack, et tous les tracés sont affichés sur l'axe horizontal.

 

Doute : dois-je d'abord sélectionner "Analyse de capacité" ou " Ajustement continu ==> Tout" ? Je veux dire, lorsque je sélectionne "Capability Analysis", la boîte de dialogue apparaît pour saisir les paramètres suivants : "Lower Spec Limit", "Target" et "Upper Spec Limit", et je ne sais pas quelles valeurs je dois définir. Sont-ils basés sur le Box Plot, à l’exclusion des valeurs aberrantes ?

 

Merci.

 

Re : Distributions normales et transformations

La plate-forme de distribution permet d'évaluer la distribution d'une colonne donnée, puis elle peut disposer d'une méthode pour transformer les données en une distribution normale.Voici les étapes

1. Exécutez la plateforme de distribution en sélectionnant la ou les colonnes souhaitées.Mon exemple provient de l'exemple de table de données Semiconductor Capability installé lors de l'installation de JMP.

Analyser==>Distribution

2. Une fois la sortie affichée, sélectionnez parmi

Ajustement continu ==> Tout

3. La plateforme vous indiquera, dans l'ordre, quelles distributions correspondent le mieux aux données.Dans ce cas, le LogNormal est sélectionné.Malheureusement, LogNormal n'a pas la capacité de créer une version transformée des données, alors désélectionnez-la et sélectionnez Johnson SI.

4. Maintenant, cliquez sur le triangle rouge pour « Fitted Johnson SI » et sélectionnez Enregistrer la transformation.

 

JMP a désormais enregistré une version transformée des données dans une nouvelle colonne, que vous pouvez désormais utiliser pour vos analyses.

Re : Distributions normales et transformations

Salut Jim ( @txnelson ),

Je ne comprenais pas comment transformer des données non normales en distribution normale dans JMP. S'il vous plaît, pouvez-vous m'expliquer les étapes à suivre pour obtenir des données brutes non normales ?

Merci.

Re : Distributions normales et transformations

Voici un programme complet qui renvoie une valeur basée sur un résultat statistique d'un ensemble de données transformé.J'espère que cette aide

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));

Re : Distributions normales et transformations

Merci d'avoir partagé cela.

Je ne suis qu'un débutant en script, donc c'est un peu trop compliqué pour le moment et je ne savais pas trop comment l'utiliser !

---

 

 

Re : Distributions normales et transformations

Voici une fonction que j'ai extraite d'un système en cours d'exécution qui utilise des approximations successives pour obtenir les valeurs résolues

/***********************************************************************/
/*                                                                     */
/* 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

 

 

Re : Distributions normales et transformations

Salut Jim,

J'ai le même problème. J'ai modélisé certaines données transformées Johnson Si et j'ai obtenu un modèle prédit. J'ai essayé d'utiliser la fonction inverse pour retransformer les données prédites, mais cela ne fonctionne pas. Seriez-vous en mesure de fournir plus de conseils sur l'écriture d'un script pour ce faire ? Je continue de rencontrer ces types de distributions lors de la modélisation des réponses des expériences du DOE, il serait donc très utile de savoir comment retransférer les données.
Merci beaucoup!

Christelle

Re : Distributions normales et transformations

Je pense que j'ai raté le point de votre question. Si vous souhaitez calculer des « bandes » basées sur la probabilité, l'emplacement de ces bandes différera selon le type de distribution dont vous disposez. Vos numéros 68-95-99,7 ne sont pas des écarts types, mais sont des probabilités associées à des « bandes » basées sur des distances de 1,2,3 écarts types par rapport à la moyenne basées sur une distribution normale. Si vous n'avez pas de distribution normale, le problème ne vient pas du calcul de l'écart type, mais de la conversion en probabilités. Si vous souhaitez avoir +/- 3 bandes d'écart type, vous supposez que la distribution est normale, ou au moins symétrique. En fonction de ce que vous voulez faire, vous pouvez soit calculer des bandes asymétriques (JMP a des distributions de probabilité non seulement pour les distributions normales, mais pour toutes les distributions), soit effectuer une transformation pour normaliser les données (puis des rétro-transformations à chaque fois). vous souhaitez reconvertir en métriques naturelles). Ma préférence serait d'utiliser des bandes asymétriques et d'utiliser la fonction JOHNSON SU pour les calculer.

aide en ligne

Re : Distributions normales et transformationsMerci pour votre réponse Jim! J'essaierai.Re : Distributions normales et transformationsVoici ce que je fais. Pour définir mes limites sur mes données d'origine, en fonction des valeurs de données transformées, je prends la norme à partir des données transformées, je calcule quelles sont les valeurs au-dessus et en dessous de la moyenne pour 1, 2, 3, etc., puis j'inverse la transformation vers les données originales. Dans certains cas, comme le Johnson SU, il n'existe pas de moyen simple de retransformer les valeurs. Ce que je fais alors, c'est d'exécuter un petit script qui transmet une valeur via la transformation d'origine, vérifie la valeur du std ciblé. , puis itère la valeur jusqu'à ce qu'il y ait une correspondance. Ensuite, vous avez trouvé la valeur dans les données d'origine qui, une fois transformées, aboutit à la valeur ciblée des valeurs transformées. N'oubliez pas que lorsque vous effectuez cette opération, les distances au-dessus et en dessous de la moyenne dans vos données d'origine ne seront pas les mêmes.Re : Distributions normales et transformations

Oh, je pensais que c'était important pour l'écart type, cependant. Par exemple, la règle 68-95-99,7 (trois écarts types) est utilisée pour trouver les valeurs dans une bande autour de la moyenne dans une distribution normale. Cependant, si mes données ne sont pas normales, cela n’a peut-être pas de sens de les utiliser. Par exemple, si la résistance à l'état passant de mon transistor n'est pas normale et que je veux voir quelle est la valeur à 3 écarts types de la moyenne, je pourrais avoir une valeur négative ou une valeur très faible qui n'a aucun sens. .

 

Désolé si je me trompe ou si je comprends mal quelque chose, je commence tout juste à me remettre à l'apprentissage des statistiques depuis l'université !

Re : Distributions normales et transformations

Merci, je vois comment ça a fait ça. Maintenant que je vois que les données sont normales, comment puis-je les utiliser pour trouver l’écart type ? Il indique dans les statistiques récapitulatives une valeur qui a du sens en fonction de la transformation, mais j'aimerais savoir quel est l'écart type pour les données d'origine. Peut-être que je ne comprends pas le but de transformer les données.

 

Re : Distributions normales et transformations

Nathalie

La formule de variance et d'écart type ne fait aucune hypothèse sur la forme de la distribution. C'est juste de l'algèbre (de la même manière que le calcul d'une valeur moyenne ne fait aucune hypothèse sur le type de distribution).

Re : Distributions normales et transformations

Nathalie,

Vous devriez pouvoir simplement enregistrer la transformation dans une nouvelle colonne, puis exécuter la distribution sur cette colonne.

 

Jim

Ré: Distributions et transformations normales

Bonjour David et tout le monde,

Je suis nouveau sur JMP et je m'interroge sur la transformation des données.
Quels sont les avantages/inconvénients si nous travaillons avec un ajustement des données par rapport à une transformation des données pour obtenir une distribution normale ?

Même après la transformation, si je n'ai pas une bonne valeur p, dois-je envisager ma transformation ?

merci

Ré: Distributions et transformations normales

Kowa, tout d'abord bienvenue dans la communauté. Votre question ne peut pas trouver de réponse suffisante dans ce forum. Je vous suggère de commencer ici :

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

Il y a deux raisons principales pour lesquelles il faut procéder à une transformation :

1. Respecter les hypothèses quantitatives de résidus distribués normalement et indépendamment avec une moyenne de 0 et une variance de consentement (NID(0, variance). Si ces hypothèses ne sont pas respectées, vous devez alors remettre en question le modèle proposé.

2. Ce que le Dr Box m'a dit il y a des années, la seule raison de transformer, c'est de simplifier le modèle... en substance, de rendre le modèle plus utilisable.