28662_es-ES

liliconcom

Distribuciones y transformaciones normales

Hola a todos,

 

Tengo algunos datos medidos y cuando intento un ajuste normal continuo, puedo ver que mis datos no son normales. Sin embargo, puedo ver en la prueba de bondad de ajuste que los datos provienen de la distribución Johnson Su.

 

Esta distribución tiene dos parámetros de forma, una ubicación y un parámetro de escala. A partir de mi investigación en línea, puedo ver cómo calcular la varianza a partir de estos parámetros y a partir de ahí la desviación estándar. Utilicé Excel para calcular eso, pero ¿hay alguna forma en JMP de hacerlo? Según tengo entendido, la tabla Resumen de estadísticas del análisis "Distribuciones" calcula estas estadísticas asumiendo que los datos provienen de la distribución normal.

 

¡Gracias de antemano!

 

natalia

Re: Distribuciones y transformaciones normalesGracias por la respuesta, txnelson. No pensé en eso y no hubiera esperado que ese fuera el caso. Me pregunto cuál es el valor de esa transformación si hace imposible revertir la transformación con precisión. Si desarrollo un modelo a partir de los datos transformados, necesito saber cuál es el resultado de ese modelo en el formato de datos original. Parece una tontería, entonces, que JMP incluya siquiera esta transformación como una opción. Felicitaciones por el guión original. Lo guardaré para usarlo en el futuro según sea necesario.Re: Distribuciones y transformaciones normales

El guión no funcionará para Denisity Transformation.La función produce múltiples valores para el mismo valor de densidad y el código no puede manejar eso.Ver gráfico a continuación

 

Re: Distribuciones y transformaciones normales

¿Quizás sea entonces mi conjunto de datos? En resumen, estaba eligiendo un valor de mi conjunto de datos y extrayendo el valor transformado lognormal para probar/validar el código. Mi conjunto de datos está a continuación. Un valor de 7 corresponde a un valor transformado de 0,112832236739791, por lo tanto, debería poder utilizar el valor transformado como objetivo en el código y el script debería mostrar 7. ¿Correcto?

 

 

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>

 

Después de ejecutar el código, aquí está el resultado del registro.

 

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

 

La salida de la función Gettrans debe ser 7. El valor de 18 que genera el código corresponde a un valor transformado de 0.0135701784925184.

Re: Distribuciones y transformaciones normales

¿No entiendo cuál es el problema?Dado que todo lo que hace el código es tomar valores de la columna original y pasarlos a través de la fórmula hasta que el resultado sea igual al valor objetivo de la columna transformada (normalmente la media de la nueva distribución).Modifiqué el script de mis respuestas anteriores, pero esta vez, usando la fórmula Log Normal Density determinada por la plataforma de distribución, y el código parece funcionar para mí.

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: Distribuciones y transformaciones normalesHola txnelson,

Tengo una pregunta sobre el programa/script que vinculó. Revertirá fácilmente una transformación de Johnson, pero no funciona para otras transformaciones. En particular, la transformación logNormal de Densidad. ¿Te importaría si te envío un mensaje privado para ver si hay alguna manera de modificar el script para que funcione?Re: Distribuciones y transformaciones normales

La columna llamada "Johnson Sl Transform X By Timepoint" son los datos transformados.Es esta columna la que contiene los datos normalizados.Realizaría sus análisis basándose en esta columna.  

Por lo tanto, cuando ejecuta un análisis para determinar si hay una diferencia entre los datos de Timepoint1 y Timepoint2, debe ejecutarlo en la columna de datos transformados.Ahora el problema es que informará valores en la escala de los datos transformados.Por lo tanto, para volver a relacionarlo con la columna X original, ejecuta el script, ingresa el valor del punto de datos del análisis y obtiene el valor en términos de X.

Re: Distribuciones y transformaciones normales

Por supuesto, el script debe ejecutarse por separado como publiqué antes. Acabo de adjuntar el archivo único (Test.jmp) para mayor comodidad.¿No debería su script registrar los datos normales después de la transformación Johnson SI en la tercera columna llamada Y (en ese archivo de tabla de datos) para poder ejecutarlo y ver su forma normal?

El problema es que no hay una línea de comando en su secuencia de comandos para guardar los datos normales en esa tabla de datos. Por eso me han preguntado al respecto.

Si mira uno de esos archivos divididos y ejecuta su script, la tercera columna Y todavía está en blanco. Pensé que cada tabla de datos divididos podría completarse con los datos normales después de la transformación Johnson SI en la tercera columna Y porque después de eso me gustaría combinarlos nuevamente en un solo archivo para continuar con mi análisis estadístico.

 

Punto de tiempo 1:

Media Johnson = -3,80945275324507e-15;

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

Gettrans("X", "Johnson Sl Transform X por punto de tiempo", JohnsonMean, myFormula) = -10,7617217296089;

 

Punto de tiempo 2:

Media de Johnson = 7,27196081129478e-15;

Col media(:X) = 3,257375;

Gettrans("X", "Johnson Sl Transform X por punto de tiempo", JohnsonMean, myFormula) = 1,87687074670016;

 

Gracias por su ayuda.

Re: Distribuciones y transformaciones normales

La solución a su pregunta tiene que incluir una decisión humana sobre si sabe o no con certeza que los diferentes grupos de datos de Timepoint provienen de diferentes distribuciones generales.Mi suposición era que la mejor determinación de si la distribución general proviene o no de una distribución normal era combinar todos los datos en una sola evaluación.Y lo siguiente es utilizar la transformación única para todos los datos y luego realizar análisis posteriores en esos datos transformados.Cualquier diferencia verdadera debe identificarse dentro de los datos transformados.Ahora, si tiene un conocimiento a priori independiente de que los grupos de Timepoint provienen de distribuciones separadas, necesitará subconjuntos de datos en grupos de Timepoint separados y ejecutar el script por separado en los diferentes subconjuntos.

Re: Distribuciones y transformaciones normales

Hola Jim,

Creo que aquí hay un malentendido. Aunque, el archivo de registro muestra:

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

Su secuencia de comandos no guarda los datos normales de la columna "Transformación de Johnson SI por punto de tiempo" en la columna Y de mi tabla de datos.

Mejor,

reinaldo

Re: Distribuciones y transformaciones normales

Regrese a la tabla de datos con los puntos de tiempo combinados.Luego vaya a Distribución y ejecútelo con los datos transformados.

 

Luego ve a

Ayuda==>Libros==>Descubriendo JMP

 

¡Tienes que aprender más sobre cómo funciona JMP!

Re: Distribuciones y transformaciones normales

Creé dos subconjuntos: uno por punto de tiempo. ¿Dónde uso los resultados del archivo de registro para obtener y trazar los datos normales?

Re: Distribuciones y transformaciones normales

1. Bien, lo ejecutaré por separado.

2. Tengo los resultados que mencionaste (archivo de registro) y Johnson SI Transform X By Timepoint (= distribución no normal), pero no tengo datos asignados a la columna Y.

Re: Distribuciones y transformaciones normales

1. Si necesita obtener resultados separados para cada punto de tiempo, deberá dividir la tabla de datos en tablas separadas para cada punto de tiempo y luego ejecutar el script en cada uno de ellos por separado.

2. Ahora debe continuar con su análisis utilizando la columna de datos transformados, como si fuera su columna Y.

3. Leer y digerir el documento.

Ayuda==>Libros==>Descubriendo JMP

Re: Distribuciones y transformaciones normales

Lo siento, no te dije el archivo de registro porque no pude encontrarlo. Soy principiante en JMP. Ahora puedo encontrarlo: Ver -> Iniciar sesión.

Bien, agregué esa línea de comando y obtuve el mismo resultado.

¿Cuál es el siguiente paso?

 

PD: ¿El script no considera dos puntos de tiempo por separado para calcular esos parámetros? Quizás, se agregaría el nuevo parámetro llamado "Timepoint" en aquellas funciones "getformula" y "gettrans".

Re: Distribuciones y transformaciones normales

1. En una de mis últimas respuestas le pedí que mirara en el Registro si había algún error.Ejecuté el script tal como lo había incluido en la tabla de datos adjunta de su última respuesta.Al mirar el registro, especificó:

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

Tomando eso y mirando el guión, la referencia "dt" está en la línea

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

dt en este contexto busca una variable llamada dt, que apunta a la tabla de datos para leer los datos.Entonces, la corrección al programa es agregar la siguiente línea antes del uso de la referencia en el código.

dt=current data table();

Lo agregué en mi copia del código, como la primera línea del script.

Una vez que hice eso, en el registro obtuve los siguientes resultados del script

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

Tenga en cuenta... los resultados estaban en el archivo de registro...

 

 

Re: Distribuciones y transformaciones normales

¡Gracias por tu publicación, Jim! ¡Creo que ahora se entiende el Análisis de Capacidad!

 

Con respecto a la transformación de datos no normales a normalidad, creé un ejemplo (Test.jmp) que contiene dos puntos de tiempo y X como variable no normal. Seguí tu procedimiento:

 

1. Analizar -> Distribución

2. X como "Y, Columnas" y Punto de tiempo como "Por"

3. Hice clic en Punto de tiempo de distribuciones -> Pila

4. Para cada punto de tiempo, hice clic en el triángulo rojo y en "Ajuste continuo -> Johnson SI".

5. Hice clic en "Fitted Johnson SI -> Guardar transformado"

 

Luego, JMP generó la columna "Johnson SI Transform X By Timepoint"

 

Entonces, ese es el punto: intenté ejecutar el script que está en la parte superior izquierda de Test.jmp, pero no pasó nada.

 

¿Podría explicar qué hice mal en ese guión, por favor?

 

PD: Me gustaría que la columna Y represente la normalidad de X después de la transformación Johnson SI.

 

¡Muchas gracias!

Re: Distribuciones y transformaciones normales

Normalmente se aplican a procesos de fabricación.

Re: Distribuciones y transformaciones normales

¿Estoy en lo cierto al pensar que Cp y Cpk no se aplican al campo de la Psicología, sino a la Ingeniería, el Control de Procesos, etc.?

Re: Distribuciones y transformaciones normales

El análisis Cp/Cpk está completamente dominado por los límites de especificación.Y sí, se pueden generar límites de especificaciones de 3k, sin embargo, usarlos en un espacio de medición tan limitado me parece un ejercicio para producir números, no algo que tenga un significado real.

Re: Distribuciones y transformaciones normales

Con respecto al Análisis de Capacidad, lo vi configurado en una de tus publicaciones anteriores cuando me explicaste "los pasos de cómo transformar datos no normales" en la URL: https://community.jmp.com/t5/Discussions/Normal-Distributions-and-Transformations/td-p/28662/page/2?lightbox-message-images-53315=9889i529042A0AA61277A (página 2)

 

Parece que el "Análisis de Capacidad" mide si un sistema puede cumplir con un conjunto de especificaciones o requisitos en un control estadístico de procesos, ¿no es así? Entonces no se aplica a mi caso.

 

 

 

Re: Distribuciones y transformaciones normales

Preguntaré nuevamente, pero de manera más directa, ¿por qué cree que es necesario ejecutar un análisis de capacidad de los datos?

 

Aparte de eso, en cuanto a que el script no le proporciona ningún resultado visible, ¿hay algún mensaje en el registro que indique algún error?

Re: Distribuciones y transformaciones normales

1. Aunque leí el Análisis de capacidad "mide la conformidad de un proceso con los límites de especificación definidos", desafortunadamente no entendí exactamente su significado en Estadísticas.

 

2. Por lo tanto, cuando se crea la nueva columna "Johnson SI", realmente necesito ejecutar su script. (Al principio pensé que no era necesario ejecutarlo). De todos modos, intenté ejecutarlo. En mi caso, la tabla de datos está en formato de columnas. Intenté adaptar su script eliminando la primera parte, que creaba la tabla de datos, e insertando los nombres de las columnas en lugar de PNP3 y "Johnson SI Transform PNP3", y lo guardé en el cuadro superior izquierdo (debajo del nombre de los datos). archivo) dentro del archivo de datos. Cuando lo ejecuté, no pasó nada. (No sé si lo guardé correctamente o si se produjo algún error de análisis con respecto a los nombres de las columnas, ya que no estaban en el script, sino en el archivo de datos). Por favor, Jim ( @txnelson ), ¿cómo puedo ejecutar su script usando un archivo de datos en formato de columna?

 

¡Muchas gracias!

Re: Distribuciones y transformaciones normales

1. Tendrás que decirme qué quieres hacer con el Análisis de Capacidad.Mi experiencia es tanto en psicología como en ingeniería.Podría usar Cp/Cpk para obtener una estimación de la capacidad, pero dado que lo está usando dentro de un único conjunto de datos y no basándose en límites de especificación reales, la estadística me parece algo sospechosa.

2. El propósito de transformar los datos es transformar los datos en una distribución que se distribuya normalmente.La razón de esto es que muchas de las pruebas estadísticas se basan en que los datos se distribuyen normalmente.El estadístico de Wilconon es una prueba no paramétrica.No requiere una distribución normal.

Re: Distribuciones y transformaciones normales

Entendí que necesitaba ejecutar su script. Si no lo ejecuto puedo ver esa columna normalizada, pero...

 

1. ¿En qué situación debo utilizar esos parámetros del Análisis de Capacidad?

2. Cuando ejecuté los datos no normales en un diseño de medidas repetidas, pude encontrar un efecto significativo en la variable que analicé en los puntos temporales a través de los resultados de la prueba de comparación múltiple no paramétrica (por ejemplo, Wilcoxon Cada Par). Sin embargo, cuando ejecuté los datos, cuya columna se había transformado usando Johnson SI, ese efecto significativo desapareció en todos los puntos temporales. Entonces, ¿en qué resultado debo confiar?

Re: Distribuciones y transformaciones normales

Sí.....

Re: Distribuciones y transformaciones normales

Bueno. Después de eso, ¿debería ejecutar su script para transformar esa columna Johnson SI a la normalidad?

Re: Distribuciones y transformaciones normales

Seleccione "Guardar transformado" en el triángulo rojo en el cuadro de contorno de Fitted Johnson SI.Creará una nueva columna de datos utilizando la transformación Johnson SI.

 

Re: Distribuciones y transformaciones normales

Hola Jim ( @txnelson ),

 

Gracias por tu publicación. Leí el enlace que habías sugerido. Según tengo entendido, podría ajustar la distribución usando Johnson SI a través del Análisis de capacidad, seleccionando "Johnson SI" en o podría ejecutar la Distribución de ajuste y luego haciendo clic en el triángulo rojo Análisis de capacidad podría encontrar los límites de especificación como sugeriste.

 

Estoy de acuerdo con usted en que los límites de especificaciones se determinan tradicionalmente a partir del conocimiento de los datos de medición. Sin embargo, creo que se aplica al campo de la ingeniería. En el campo de la Psicología, es difícil tener una idea de esos límites, sino sólo de los datos recopilados. De esta manera, creo que debería ejecutar Fit Distribution para Johnson SI y luego hacer clic en el triángulo rojo ==> Establecer límites de especificación para K Sigma, seleccionando el valor K = 3.

 

Cuando lo hago, obtengo el cuantil Sigma y el gráfico apropiado para Johnson SI. Sin embargo, no tengo la forma normal de mis datos, sino solo los parámetros (límites de especificación) del Análisis de capacidad. ¿Cuál es el siguiente paso, por favor?

 

Gracias.

Re: Distribuciones y transformaciones normales

1. Le sugiero que vaya a la página web de JMP y lea la documentación en la plataforma de distribución.

Página web de JMP==Soporte==>Documentación en línea==Análisis básico==>Distribuciones

Le brindará una muy buena educación sobre lo que la herramienta puede hacer por usted.Dijo que está utilizando JMP 10.La versión más reciente de JMP es 14 (que se lanzará en breve) y la documentación en la web es JMP 14. Sin embargo, encontrará que casi todo lo que leerá en la documentación estaba disponible en JMP 10.

2. La determinación de cuál es la forma de la distribución de sus datos (es decir, Normal, Johnson SI, Log Normal, etc.) no está determinada por el Análisis de Capacidad.En realidad es todo lo contrario.La forma de la distribución determina qué fórmulas utilizar para calcular la capacidad de los datos.

3. Parece no entender cuáles son los límites en un análisis de capacidad.Los límites de especificación se determinan tradicionalmente a partir del conocimiento de los datos de medición.Es decir, si está midiendo el voltaje de un componente eléctrico, el diseño de la pieza indicaría que para que la pieza funcione correctamente, el voltaje debe estar entre el límite de especificación inferior (LSL) y el límite de especificación superior (USL).Serían estos límites los que se utilizarían para determinar qué tan capaz es el proceso.

4. En muchos casos, todo lo que desea obtener de la Plataforma de distribución es determinar si los datos se distribuyen normalmente.La razón por la que esto es importante es porque muchos análisis estadísticos parten del supuesto de que los datos se distribuyen normalmente.Entonces, el propósito de transformar los datos es cambiarlos a una distribución normal, para que las pruebas estadísticas puedan proporcionar resultados más precisos.

Re: Distribuciones y transformaciones normales

Además, soy principiante en JMP y esta es mi primera transformación que intento hacer con una complejidad adicional que se refiere a un diseño de medidas repetidas.

 

Todavía no pude descubrir la relación entre "Análisis de capacidad" y "Fitted Johnson SI". Quiero decir, si selecciono el "Análisis de capacidad" primero y suponiendo que ingrese correctamente los parámetros antes mencionados (mi publicación anterior), luego seleccionaré el " Ajuste continuo==>Todos", eligiendo Johnson SI. De esta manera, ¿JMP tiene en cuenta esa información ingresada en "Análisis de Capacidad" para evaluar el "Fitted Johnson SI"?

 

PD: Mis datos están en formato alto (o largo): las filas están representadas por temas; la primera columna es Puntos de tiempo (T1, T2, ...) y la segunda columna es FUERA. Cuando hice clic en Fitted Johnson SI==>Guardar transformado para cada punto de tiempo, la misma columna llamada "Johnson SI Transform OUT by Timepoints" se completó con esas puntuaciones transformadas. Después de eso, intenté ejecutar el análisis de estadísticas en Ajustar modelo usando la columna "Transformación de Johnson SI por puntos de tiempo" en el cuadro "Seleccionar variables de rol" y {Puntos de tiempo, sujeto y aleatorio, sujeto*Puntos de tiempo y aleatorio} en "Efectos del modelo de construcción". " caja, pero no pude obtener ningún resultado relevante.

 

Supongo que necesitaría ejecutar su script inmediatamente después de obtener la columna "Johnson SI Transform OUT by Timepoints" (datos transformados). ¿Estoy en lo cierto?

 

Esa es mi siguiente duda: entender su procedimiento descrito como solución. ¡Ejecuté tu ejemplo y fue increíble! Necesito aprender a "tomar el estándar de los datos transformados, calcular cuáles son los valores por encima y por debajo de la media para 1, 2, 3, etc. estándar y luego revertir la transformación a los datos originales".

 

¡Muchas gracias por su atención y valiosa ayuda!

Re: Distribuciones y transformaciones normales

Hola Jim ( @txnelson ), ¡muchas gracias por tu explicación!

 

Tengo el siguiente problema:

 

1. Para mi caso de estudio, el resultado no normal llamado OUT contiene diferentes puntos de tiempo (T1, T2,...) porque tengo un diseño de medidas repetidas. Entonces, cuando hago Análisis ==> Distribución, supongo que necesito seleccionar esa variable OUT como "Y, Columnas" y el entre sujetos (por ejemplo, Puntos de tiempo) como "Por" en el cuadro de diálogo "Transmitir columnas seleccionadas en roles". , ¿no?

 

2. Si lo hago, tendré un gráfico OUT versus cada punto de tiempo, como OUT versus T1; OUT vs. T2 y así sucesivamente. En JMP v.10, necesito seguir sus instrucciones para cada gráfico porque no puede hacerlo automáticamente. Está bien. Selecciono Distribuciones Punto de tiempo = T1 ==> Pila y todos los gráficos se muestran en el eje horizontal.

 

Duda: ¿Debería seleccionar primero "Análisis de capacidad" o " ¿Ajuste continuo==>Todos"? Quiero decir, cuando selecciono "Análisis de capacidad", aparece el cuadro de diálogo para ingresar los siguientes parámetros: "Límite de especificación inferior", "Objetivo" y "Límite de especificación superior", y no sé qué valores tengo que definir. ¿Se basan en el diagrama de caja, excluyendo los valores atípicos?

 

Gracias.

 

Re: Distribuciones y transformaciones normales

La Plataforma de Distribución permite evaluar qué Distribución es una columna determinada y luego, puede tener un método para transformar los datos a una distribución normal.Aquí están los pasos

1. Ejecute la Plataforma de distribución, seleccionando la(s) columna(s) deseada(s).Mi ejemplo proviene de la tabla de datos de muestra de capacidad de semiconductores instalada cuando se instala JMP.

Analizar==>Distribución

2. Una vez que se muestra la salida, seleccione de la lista

Ajuste continuo==>Todos

3. La plataforma le dará, en orden, qué distribuciones se ajustan mejor a los datos.En este caso, se selecciona LogNormal.Desafortunadamente, LogNormal no tiene la capacidad de crear una versión transformada de los datos, así que anule su selección y seleccione Johnson SI.

4. Ahora, haga clic en el triángulo rojo de "Fitted Johnson SI y seleccione Guardar transformado".

 

JMP ahora ha guardado una versión transformada de los datos en una nueva columna, que ahora puede usar para sus análisis.

Re: Distribuciones y transformaciones normales

Hola Jim ( @txnelson ),

No podía entender cómo transformar datos no normales a una distribución normal en JMP. ¿Podría explicarme los pasos a partir de datos sin procesar no normales?

Gracias.

Re: Distribuciones y transformaciones normales

Aquí hay un programa completo que devuelve un valor basado en un resultado estadístico de un conjunto de datos transformado.espero que esta ayuda

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: Distribuciones y transformaciones normales

Gracias por compartir esto.

Solo soy un principiante en scripting, por lo que es un poco complicado en este momento y no estaba seguro de cómo usarlo.

---

 

 

Re: Distribuciones y transformaciones normales

Aquí hay una función que saqué de un sistema en ejecución que usa aproximaciones sucesivas para obtener los valores resueltos.

/***********************************************************************/
/*                                                                     */
/* 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: Distribuciones y transformaciones normales

Hola Jim,

Tengo el mismo problema. Modelé algunos datos transformados de Johnson Si y obtuve un modelo predicho. Intenté usar la función inversa para transformar los datos predichos, pero no funciona. ¿Podría brindar más orientación sobre cómo escribir un guión para hacer esto? Sigo encontrándome con este tipo de distribuciones cuando modelo respuestas de experimentos del DOE, por lo que sería realmente útil saber cómo transferir los datos nuevamente.
¡Muchas gracias!

cristel

Re: Distribuciones y transformaciones normales

Creo que no entendí el objetivo de tu pregunta. Si desea calcular "bandas" en función de la probabilidad, la ubicación de estas bandas diferirá según el tipo de distribución que tenga. Tus numeros 68-95-99,7 no son desviaciones estándar, sino probabilidades asociadas con "bandas" basadas en distancias de 1,2,3 desviaciones estándar de la media según una distribución normal. Si no tienes una distribución normal, el problema no está en el cálculo de la desviación estándar, sino en la conversión a probabilidades. Si desea tener +/- 3 bandas de desviación estándar, entonces asume que la distribución es normal, o al menos simétrica. Dependiendo de lo que quiera hacer, puede calcular bandas asimétricas (JMP tiene distribuciones de probabilidad no solo para las distribuciones normales, sino para todas las distribuciones), o debe realizar una transformación para normalizar los datos (y luego retrotransformaciones siempre que sea posible). desea volver a convertir a métricas naturales). Mi preferencia sería utilizar bandas asimétricas y utilizar la función JOHNSON SU para calcularlas.

ayuda en linea

Re: Distribuciones y transformaciones normales¡Gracias por responder Jim! Le voy a dar una oportunidad.Re: Distribuciones y transformaciones normalesEsto es lo que hago. Para establecer mis límites en mis datos originales, en función de los valores de los datos transformados, tomo el estándar de los datos transformados, calculo cuáles son los valores por encima y por debajo de la media para 1, 2, 3, etc. estándar, y luego invierto el transformación de nuevo a los datos originales. En algunos casos, como Johnson SU, no hay una manera fácil de volver a transformar los valores. Lo que hago entonces es ejecutar un pequeño script que pasa un valor a través de la transformación original y verifica el valor del estándar objetivo. , luego itera el valor hasta que haya una coincidencia. Luego, encontró el valor en los datos originales que, cuando se transforma, da como resultado el valor objetivo de los valores transformados. Recuerde, cuando haga esto, las distancias por encima y por debajo de la media en sus datos originales no serán las mismas.Re: Distribuciones y transformaciones normales

Oh, aunque pensé que sí importaba para la desviación estándar. Por ejemplo, la regla 68-95-99,7 (tres desviaciones estándar) se utiliza para encontrar los valores dentro de una banda alrededor de la media en una distribución normal. Sin embargo, si mis datos no son normales, puede que no tenga sentido utilizarlos. Por ejemplo, si la resistencia de mi transistor no es normal y quiero ver cuál es el valor a 3 desviaciones estándar de la media, es posible que tenga un valor negativo o un valor muy bajo que en realidad no tiene ningún sentido. .

 

Lo siento si estoy confundiendo o entendiendo mal algo, ¡estoy empezando a volver a aprender estadística desde la universidad!

Re: Distribuciones y transformaciones normales

Gracias, ya veo cómo lo hizo. Ahora que veo que los datos son normales, ¿cómo puedo usarlos para encontrar la desviación estándar? En las estadísticas resumidas dice un valor que tiene sentido según la transformación, pero me gustaría saber cuál es la desviación estándar de los datos originales. Quizás no entiendo el propósito de transformar datos.

 

Re: Distribuciones y transformaciones normales

natalia

La fórmula para la varianza y la desviación estándar no hace ninguna suposición sobre la forma de la distribución. Es sólo álgebra (de la misma manera que el cálculo de un valor promedio no hace ninguna suposición sobre el tipo de distribución).

Re: Distribuciones y transformaciones normales

natalia,

Debería poder simplemente guardar la transformación en una nueva columna y luego ejecutar la distribución en esa columna.

 

Jim

Re: Distribuciones normales y transformaciones

Hola David y a todos,

Soy nuevo en JMP y tengo dudas sobre la transformación de datos.
¿Cuáles son las ventajas/desventajas si trabajamos con ajuste de datos en comparación con la transformación de datos para obtener una distribución normal?

Además, después de la transformación, si no tengo un buen valor p, ¿debo considerar mi transformación?

gracias

Re: Distribuciones normales y transformaciones

Kowa, en primer lugar, bienvenido a la comunidad. No hay respuestas suficientes a tu pregunta en este foro. Te sugiero que comiences por aquí:

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

Hay dos razones principales para realizar una transformación:

1. Cumplir con los supuestos cuantitativos de residuos distribuidos de forma normal e independiente con una media de 0 y una varianza de consentimiento (NID(0, varianza). Si no se cumplen estos supuestos, entonces debe cuestionar el modelo propuesto.

2. Lo que el Dr. Box me dijo hace años, la única razón para transformar, es simplificar el modelo... en esencia, hacer el modelo más utilizable.