28662_ko-KR

liliconcom

정규분포와 변환

안녕하세요 여러분,

 

측정된 데이터가 있는데 연속 정규 피팅을 시도하면 데이터가 정규 피팅이 아닌 것을 알 수 있습니다. 그러나 적합도 테스트를 통해 데이터가 Johnson Su 분포에서 나온 것임을 알 수 있습니다.

 

이 분포에는 두 개의 모양, 즉 하나의 위치와 하나의 척도 매개변수가 있습니다. 온라인 조사를 통해 이러한 매개변수와 표준 편차로부터 분산을 계산하는 방법을 알 수 있습니다. Excel을 사용하여 계산했는데 JMP에서 이를 수행할 수 있는 방법이 있나요? 제가 이해한 바로는 "분포" 분석의 통계 요약 테이블은 데이터가 정규 분포에서 나온 것이라고 가정하여 이러한 통계를 계산합니다.

 

미리 감사드립니다!

 

나탈리

Re: 정규 분포 및 변환답장을 보내주셔서 감사합니다, txnelson님. 저는 그런 생각을 해본 적도 없고, 그런 일이 있을 거라고는 예상도 못했어요. 변환을 정확하게 되돌릴 수 없게 만든다면 해당 변환의 가치가 무엇인지 궁금합니다. 변환된 데이터로 모델을 개발하는 경우 해당 모델의 출력이 원래 데이터 형식으로 무엇인지 알아야 합니다. 그렇다면 JMP에 이러한 변환이 옵션으로 포함된다는 것은 어리석은 일처럼 보입니다. 원본 대본에 찬사를 보냅니다. 나중에 필요할 때 사용할 수 있도록 저장해 두겠습니다.Re: 정규 분포 및 변환

밀도 변환에는 스크립트가 작동하지 않습니다.이 함수는 동일한 밀도 값에 대해 여러 값을 생성하며 코드는 이를 처리할 수 없습니다.아래 그래프 참조

 

Re: 정규 분포 및 변환

그렇다면 그것은 아마도 내 데이터 세트일까요? 즉, 데이터 세트에서 값을 선택하고 코드 테스트/검증을 위해 로그 정규 변환 값을 가져왔습니다. 내 데이터 세트는 다음과 같습니다. 값 7은 변환된 값 0.112832236739791에 해당하므로 변환된 값을 코드의 대상으로 사용할 수 있어야 하며 스크립트는 7을 출력해야 합니다. 옳은?

 

 

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>

 

코드를 실행한 후 로그 출력은 다음과 같습니다.

 

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

 

Gettrans 함수의 출력은 7이어야 합니다. 코드가 출력하는 값 18은 변환된 값 0.0135701784925184에 해당합니다.

Re: 정규 분포 및 변환

문제가 무엇인지 이해가 안 되나요?모든 코드에서는 원래 열에서 값을 가져와 결과가 변환된 열의 대상 값(일반적으로 새 분포의 평균)과 같아질 때까지 수식을 통해 전달하는 작업을 수행합니다.이전 응답의 스크립트를 재작업했지만 이번에는 배포 플랫폼에서 결정한 로그 정규 밀도 공식을 사용했는데 코드가 제게 맞는 것 같습니다.

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: 정규 분포 및 변환안녕하십니까?

귀하가 연결한 프로그램/스크립트에 대해 질문이 있습니다. Johnson 변환을 쉽게 되돌릴 수 있지만 다른 변환에는 작동하지 않습니다. 특히, logNormal Density 변환이 있습니다. 스크립트를 수정하여 작동할 수 있는 방법이 있는지 확인해달라고 메시지를 보내도 될까요?Re: 정규 분포 및 변환

라는 열 "Johnson Sl Transform X By Timepoint"는 변환된 데이터입니다.정규화된 데이터가 포함된 열입니다.이 열을 기반으로 분석을 실행합니다.  

따라서 Timepoint1과 Timepoint2 데이터 사이에 차이가 있는지 확인하기 위해 분석을 실행할 때는 변환된 데이터 열에서 실행합니다.이제 문제는 변환된 데이터의 규모에 따라 값을 보고한다는 것입니다.따라서 원래 열 X와 다시 연결하려면 스크립트를 실행하고 분석에서 데이터 포인트 값을 입력한 다음 X에 대한 값을 가져옵니다.

Re: 정규 분포 및 변환

물론 이전에 포스팅한 것처럼 스크립트는 별도로 실행해야 합니다. 편의상 단일 파일(Test.jmp)만 동봉했습니다.스크립트를 실행하고 정상적인 모양을 확인하기 위해 Johnson SI 변환 후 Y라는 세 번째 열(해당 데이터 테이블 파일)에 일반 데이터를 기록해야 하지 않습니까?

문제는 해당 데이터 테이블에 일반 데이터를 저장하는 명령줄이 스크립트에 없다는 것입니다. 그래서 내가 당신에게 그것에 대해 질문을 한 것입니다.

분할된 파일 중 하나를 보고 스크립트를 실행하면 세 번째 열 Y가 여전히 비어 있습니다. 각 분할 데이터 테이블은 세 번째 열 Y에서 Johnson SI 변환 후 일반 데이터로 완성될 수 있다고 생각했습니다. 그 이유는 그 후 통계 분석을 진행하기 위해 다시 하나의 파일로 결합하고 싶기 때문입니다.

 

시점 1:

JohnsonMean = -3.80945275324507e-15;

열 평균(:X) = -7.4569375;

Gettrans("X", "Johnson Sl 변환 X를 시점별로", JohnsonMean, myFormula) = -10.7617217296089;

 

시점 2:

존슨평균 = 7.27196081129478e-15;

열 평균(:X) = 3.257375;

Gettrans("X", "Johnson Sl 변환 X를 시점별로", JohnsonMean, myFormula) = 1.87687074670016;

 

도움을 주셔서 감사합니다.

Re: 정규 분포 및 변환

귀하의 질문에 대한 솔루션은 서로 다른 시점 데이터 그룹이 서로 다른 전체 분포에서 나온다는 사실을 알고 있는지 여부에 대한 인간의 결정을 가져와야 합니다.내 가정은 전체 분포가 정규 분포에서 나온 것인지 여부를 가장 잘 결정하는 것은 모든 데이터를 단일 평가로 결합하는 것이라는 것이었습니다.그 다음에는 모든 데이터에 대해 단일 변환을 사용한 다음 변환된 데이터에 대한 후속 분석을 수행하는 것입니다.실제 차이점은 변환된 데이터 내에서 식별되어야 합니다.이제 별도의 분포에 있는 Timepoint 그룹에 대한 독립적인 선험적 지식이 있는 경우 데이터를 별도의 Timepoint 그룹으로 하위 집합으로 설정하고 다른 하위 집합에서 별도로 스크립트를 실행해야 합니다.

Re: 정규 분포 및 변환

안녕하세요 짐,

여기에는 오해가 있는 것 같아요. 그러나 로그 파일에는 다음이 표시됩니다.

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

귀하의 스크립트는 "Johnson SI Transformation By Timepoint" 열의 일반 데이터를 내 데이터 테이블의 Y 열에 저장하지 않습니다.

최상의,

레이날도

Re: 정규 분포 및 변환

결합된 시점이 있는 데이터 테이블로 돌아갑니다.그런 다음 분포로 이동하여 변환된 데이터에 대해 실행합니다.

 

그런 다음

도움말==>도서==>JMP 알아보기

 

JMP의 작동 방식에 대해 자세히 알아보세요!

Re: 정규 분포 및 변환

시점당 하나씩 두 개의 하위 집합을 만들었습니다. 일반 데이터를 가져오고 플롯하기 위해 로그 파일의 출력을 어디에서 사용합니까?

Re: 정규 분포 및 변환

1. 알겠습니다. 따로 실행하겠습니다.

2. 귀하가 언급한 출력(로그 파일)과 Johnson SI Transform X By Timepoint(= 비정규 분포)가 있지만 Y 열에 데이터가 할당되지 않았습니다.

Re: 정규 분포 및 변환

1. 각 시점에 대해 별도의 결과를 얻어야 하는 경우 데이터 테이블을 각 시점에 대한 별도의 테이블로 하위 집합한 다음 각 테이블에서 별도로 스크립트를 실행해야 합니다.

2. 이제 변환된 데이터 열을 마치 Y 열인 것처럼 사용하여 분석을 진행해야 합니다.

3. 문서를 읽고 소화하기

도움말==>도서==>JMP 알아보기

Re: 정규 분포 및 변환

죄송합니다. 로그 파일을 찾을 수 없어서 말씀드리지 못했습니다. 저는 JMP 초보자입니다. 이제 찾을 수 있습니다: 보기 -> 로그.

좋아요, 해당 명령줄을 추가했는데 같은 결과를 얻었습니다!

다음 단계는 무엇입니까? :디

 

추신: 스크립트는 해당 매개변수를 계산하기 위해 두 시점을 별도로 고려하지 않습니까? 아마도 "Timepoint"라는 새 매개변수가 "getformula" 및 "gettrans" 함수에 추가될 것입니다.

Re: 정규 분포 및 변환

1. 마지막 응답 중 하나에서 오류가 있는지 로그를 살펴보았는지 요청했습니다.귀하의 마지막 응답에서 첨부된 데이터 테이블에 포함된 대로 스크립트를 실행했습니다.로그를 보면 다음과 같이 지정되었습니다.

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

그것을 취하고 스크립트를 살펴보면 "dt" 참조가 줄에 있습니다.

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

이 맥락에서 dt는 데이터를 읽을 데이터 테이블을 가리키는 dt라는 변수를 찾고 있습니다.따라서 프로그램 수정은 코드에서 참조를 사용하기 전에 다음 줄을 추가하는 것입니다.

dt=current data table();

스크립트의 첫 번째 줄로 코드 복사본에 추가했습니다.

그렇게 하고 나면 로그에 스크립트에서 다음과 같은 결과가 표시됩니다.

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

참고하세요......결과는 로그 파일에 있었습니다......

 

 

Re: 정규 분포 및 변환

귀하의 게시물에 감사드립니다, 짐! 이제 역량분석이 이해가 된 것 같습니다!

 

비정규 데이터를 정규성으로 변환하는 것과 관련하여 두 개의 시점과 X를 비정규 변수로 포함하는 예제(Test.jmp)를 만들었습니다. 나는 당신의 절차를 따랐습니다:

 

1. 분석 -> 배포

2. X는 "Y, 열"로, 시점은 "기준"으로

3. Distributions Timepoint -> Stack을 클릭했습니다.

4. 각 시점마다 빨간색 삼각형을 클릭하고 "Continuous Fit -> Johnson SI"를 클릭했습니다.

5. "Fitting Johnson SI -> Save Transformed"를 클릭했습니다.

 

그런 다음 JMP는 "Johnson SI Transform X By Timepoint" 열을 생성했습니다.

 

이것이 요점입니다. Test.jmp의 왼쪽 상단에 있는 스크립트를 실행하려고 했지만 아무 일도 일어나지 않았습니다.

 

해당 스크립트에서 제가 뭘 잘못했는지 설명해 주시겠어요?

 

추신: Y 열은 Johnson SI 변환 후 X의 정규성을 나타내기를 바랍니다.

 

정말 감사합니다!

Re: 정규 분포 및 변환

일반적으로 제조 공정에 적용됩니다.

Re: 정규 분포 및 변환

Cp와 Cpk가 심리학 분야에는 적용되지 않고 엔지니어링, 프로세스 제어 등에 적용된다고 생각하는 것이 맞습니까?

Re: 정규 분포 및 변환

Cp/Cpk 분석은 사양 한계의 영향을 완전히 받습니다.그리고 예, 3k 사양 제한을 생성할 수 있습니다. 그러나 제한된 측정 공간에서 이를 사용하는 것은 실제 의미가 없는 숫자를 생성하는 데만 사용되는 것으로 보입니다.

Re: 정규 분포 및 변환

기능 분석과 관련하여 URL에서 "비정상 데이터를 일반 데이터로 변환하는 방법의 단계"를 설명했을 때 이전 게시물 중 하나에서 해당 설정이 설정된 것을 보았습니다. https://community.jmp.com/t5/Discussions/Normal-Distributions-and-Transformations/td-p/28662/page/2?lightbox-message-images-53315=9889i529042A0AA61277A (2 쪽)

 

"능력 분석"은 시스템이 통계적 프로세스 제어에서 일련의 사양이나 요구 사항을 충족할 수 있는지 측정하는 것 같습니다. 그렇지 않습니까? 그래서 내 경우에는 적용되지 않습니다.

 

 

 

Re: 정규 분포 및 변환

다시 한번 묻겠지만, 좀 더 직접적으로 데이터에 대한 공정능력 분석을 왜 해야 한다고 생각하시나요?

 

그 외에도 스크립트가 눈에 띄는 출력을 제공하지 않는 것과 관련하여 로그에 오류를 나타내는 메시지가 있습니까?

Re: 정규 분포 및 변환

1. "정의된 사양 한계에 대한 프로세스의 적합성을 측정하는" 공정 능력 분석을 읽었지만 안타깝게도 통계에서는 그 의미를 정확히 이해하지 못했습니다.

 

2. 따라서 새 열 "Johnson SI"가 생성되면 실제로 스크립트를 실행해야 합니다. (처음에는 실행할 필요가 없다고 생각했습니다.) 어쨌든 실행해 보았습니다. 제 경우에는 데이터 테이블이 열 형식입니다. 데이터 테이블을 생성한 첫 번째 부분을 삭제하고 PNP3 및 "Johnson SI Transform PNP3" 대신 열 이름을 삽입하여 스크립트를 조정하려고 시도했으며 이를 왼쪽 상단 상자(데이터 이름 아래)에 저장했습니다. 파일) 데이터 파일 내부. 실행해보니 아무 일도 일어나지 않았습니다. (열 이름이 스크립트가 아닌 데이터 파일에 있기 때문에 올바르게 저장했는지 또는 열 이름과 관련하여 구문 분석 오류가 발생했는지 모르겠습니다.) 제발, 짐( @txnelson ), 열 형식 데이터 파일을 사용하여 스크립트를 어떻게 실행할 수 있나요?

 

매우 감사합니다!

Re: 정규 분포 및 변환

1. 능력 분석을 통해 무엇을 하고 싶은지 말해야 합니다.내 배경은 심리학과 공학에 있습니다.Cp/Cpk를 사용하여 능력에 대한 추정치를 어느 정도 얻을 수 있지만 실제 사양 한계를 기반으로 하지 않고 단일 데이터 세트 내에서 이를 사용하기 때문에 통계가 다소 의심스럽습니다.

2. 데이터 변환의 목적은 데이터를 정규 분포를 따르는 분포로 변환하는 것입니다.이에 대한 합리적인 이유는 많은 통계 테스트가 정규 분포를 따르는 데이터를 기반으로 한다는 것입니다.Wilconon 통계는 비모수 검정입니다.정규 분포가 필요하지 않습니다.

Re: 정규 분포 및 변환

스크립트를 실행해야 한다는 것을 이해했습니다. 실행하지 않으면 해당 열이 정규화된 것을 볼 수 있지만...

 

1. 어떤 상황에서 공정 능력 분석의 매개변수를 사용해야 합니까?

2. 반복 측정 설계에서 비정규 데이터를 실행했을 때 비모수적 다중 비교 테스트(예: Wilcoxon Each pair) 결과를 통해 시점에 걸쳐 분석한 변수에 유의미한 영향을 찾을 수 있었습니다. 그러나 Johnson SI를 사용하여 열을 변환한 데이터를 실행해 보니 해당 시점에 걸쳐 그 의미 있는 효과가 사라졌습니다. 그렇다면 어떤 결과를 믿어야 할까요?

Re: 정규 분포 및 변환

예.....

Re: 정규 분포 및 변환

좋아요. 그런 다음 스크립트를 실행하여 Johnson SI 열을 정규성으로 변환해야 합니까?

Re: 정규 분포 및 변환

Fitted Johnson SI 개요 상자의 빨간색 삼각형에서 "변환 저장"을 선택합니다.Johnson SI 변환을 사용하여 새로운 데이터 열을 생성합니다.

 

Re: 정규 분포 및 변환

안녕하세요 짐( @txnelson ),

 

귀하의 게시물에 감사드립니다. 당신이 제안한 링크를 읽었습니다. 제가 이해한 바와 같이 <분포 유형>에서 "Johnson SI"를 선택하여 공정 능력 분석을 통해 Johnson SI를 사용하여 분포를 적합화할 수 있습니다. 또는 적합 분포를 실행한 다음 빨간색 삼각형 공정 능력 분석을 클릭하면 다음과 같이 사양 한계를 찾을 수 있습니다. 당신이 제안했습니다.

 

저는 전통적으로 사양 한계가 측정 데이터를 바탕으로 결정된다는 점에 동의합니다. 하지만 저는 그것이 공학 분야에도 적용된다고 믿습니다. 심리학 분야에서는 이러한 한계에 대해 전혀 알기가 어렵지만 수집된 데이터만 있습니다. 이런 식으로 Johnson SI에 대한 Fit Distribution을 실행한 다음 빨간색 삼각형 ==> K Sigma에 대한 Spec Limits 설정을 클릭하고 K 값 = 3을 선택해야 한다고 생각합니다.

 

그렇게 하면 Quantile Sigma와 Johnson SI에 대한 피팅 플롯을 얻게 됩니다. 그러나 데이터의 정상적인 형태는 얻지 못하고 공정 능력 분석의 모수(사양 한계)만 얻었습니다. 다음 단계는 무엇입니까?

 

감사합니다.

Re: 정규 분포 및 변환

1. JMP 웹페이지로 이동하여 배포 플랫폼에 대한 문서를 읽어 보시기 바랍니다.

JMP 웹페이지==지원==>온라인 문서==기본 분석==>배포

이 도구가 당신을 위해 무엇을 할 수 있는지에 대해 아주 좋은 교육을 제공할 것입니다.JMP 10을 사용하고 있다고 말씀하셨습니다.가장 최신 JMP 버전은 14(곧 출시 예정)이고 웹에 있는 문서는 JMP 14입니다. 그러나 문서에서 읽을 내용의 대부분은 JMP 10에서도 사용할 수 있습니다.

2. 데이터 분포 형태(예: 정규, Johnson SI, 로그 정규 등)는 공정 능력 분석에 의해 결정되지 않습니다.실제로는 그 반대입니다.분포 형태에 따라 데이터의 공정 능력을 계산하는 데 사용할 공식이 결정됩니다.

3. 공정 능력 분석의 한계가 무엇인지 이해하지 못하는 것 같습니다.사양 한계는 전통적으로 측정 데이터에 대한 지식을 바탕으로 결정됩니다.즉, 전기 부품의 전압을 측정하는 경우 부품 설계에 따르면 부품이 제대로 작동하려면 전압이 규격 하한(LSL)과 규격 상한(USL) 사이에 있어야 합니다.프로세스의 능력을 결정하는 데 사용되는 것은 이러한 한계입니다.

4. 많은 경우 배포 플랫폼에서 벗어나고 싶은 것은 데이터가 정상적으로 배포되었는지 확인하는 것입니다.이것이 중요한 이유는 많은 통계 분석에서 데이터가 정규 분포를 따른다는 가정을 갖고 있기 때문입니다.따라서 데이터를 변환하는 목적은 데이터를 정규 분포로 변경하여 통계 검정을 통해 보다 정확한 결과를 제공할 수 있도록 하는 것입니다.

Re: 정규 분포 및 변환

게다가 저는 JMP 초보자인데, 이것은 반복 측정 설계를 의미하는 추가적인 복잡성을 가지고 시도하는 첫 번째 변환입니다.

 

아직 "Capability Analysis"와 "Fitting Johnson SI"의 관계를 알 수 없었습니다. 즉, 내가 선택하면 "능력분석" 먼저 위에서 언급한 매개변수(이전 게시물)를 올바르게 입력했다고 가정하고 " Continuous Fit==>All", Johnson SI 선택. 이런 식으로 JMP는 "Fitted Johnson SI"를 평가하기 위해 "능력 분석"에 입력된 정보를 고려합니까?

 

추신: 내 데이터는 긴(또는 긴) 형식입니다. 행은 주제로 표시됩니다. 첫 번째 열은 시점(T1, T2, ...)이고 두 번째 열은 OUT입니다. 각 시점에 대해 Fitted Johnson SI==>Save Transformed를 클릭하면 "Johnson SI Transform OUT by Timepoints"라는 동일한 열이 변환된 점수로 완성되었습니다. 그 후 "Pick Role Variables" 상자의 "Johnson SI Transform OUT by Timepoints" 열과 "Contruct Model Effects"의 {Timepoints, subject& Random, subject*Timepoints & Random}을 사용하여 적합 모델에서 통계 분석을 실행하려고 했습니다. " 상자, 하지만 관련 결과를 얻을 수 없었습니다.

 

"Johnson SI Transform OUT by Timepoints"(변환된 데이터) 열을 얻은 후 즉시 스크립트를 실행해야 한다고 가정합니다. 내가 맞나요?

 

이것이 내 다음 의심입니다. 솔루션으로 설명된 절차를 이해하는 것입니다. 나는 당신의 예를 실행했고 그것은 놀라웠습니다! "변환된 데이터에서 표준값을 가져와 1, 2, 3 등의 표준값에 대한 평균 위와 아래의 값을 계산한 다음 다시 원래 데이터로 변환하는 방법"을 배워야 합니다.

 

여러분의 관심과 귀중한 도움에 진심으로 감사드립니다!

Re: 정규 분포 및 변환

안녕하세요 짐( @txnelson ), 설명해주셔서 정말 감사합니다!

 

다음과 같은 문제가 있습니다.

 

1. 내 연구 사례의 경우 반복 측정 설계가 있기 때문에 OUT이라는 비정규 결과에 다른 시점(T1, T2, ...)이 포함됩니다. 따라서 분석==>분포를 수행할 때 "선택한 열을 역할로 캐스팅" 대화 상자에서 해당 변수 OUT을 "Y, 열"로 선택하고 대상 간(예: 시점)을 "기준"으로 선택해야 한다고 가정합니다. , 그렇지 않나요?

 

2. 그렇게 하면 OUT 대 T1과 같은 각 시점에 대한 플롯이 생성됩니다. OUT 대 T2 등등. JMP v.10에서는 자동으로 수행할 수 없기 때문에 각 플롯에 대해 귀하의 지시를 따라야 합니다. 괜찮아요. Distributions Timepoint=T1==>Stack을 선택하면 모든 플롯이 가로 축에 표시됩니다.

 

의심: 먼저 '능력 분석'을 선택해야 할까요? 연속맞춤==>모두'? 즉, "능력 분석"을 선택하면 "하위 사양 한계", "목표" 및 "상위 사양 한계" 매개변수를 입력하라는 대화 상자가 나타나는데 어떤 값을 정의해야 할지 모르겠습니다. 특이치를 제외하고 상자 그림을 기반으로 합니까?

 

감사합니다.

 

Re: 정규 분포 및 변환

배포 플랫폼을 사용하면 특정 열이 어떤 배포인지 평가한 다음 데이터를 정규 분포로 변환하는 방법을 가질 수 있습니다.단계는 다음과 같습니다.

1. 원하는 열을 선택하여 배포 플랫폼을 실행합니다.제 예는 JMP를 설치할 때 설치된 반도체 성능 샘플 데이터 테이블에서 나온 것입니다.

분석==>분포

2. 출력이 표시되면 다음 중에서 선택합니다.

연속맞춤==>모두

3. 플랫폼은 데이터에 가장 적합한 분포를 순서대로 제공합니다.이 경우 LogNormal이 선택됩니다.불행히도 LogNormal에는 데이터의 변환된 버전을 생성하는 기능이 없으므로 선택을 취소하고 Johnson SI를 선택하십시오.

4. 이제 "Fitting Johnson SI"에 대한 빨간색 삼각형을 클릭하고 변환된 저장을 선택합니다.

 

이제 JMP는 변환된 데이터 버전을 새 열에 저장하여 분석에 사용할 수 있습니다.

Re: 정규 분포 및 변환

안녕하세요 짐( @txnelson ),

JMP에서 비정규 데이터를 정규 분포로 변환하는 방법을 이해할 수 없었습니다. 원시 비정규 데이터의 단계를 나에게 설명해 주시겠습니까?

감사합니다.

Re: 정규 분포 및 변환

다음은 변환된 데이터 세트의 통계 결과를 기반으로 값을 반환하는 완전한 프로그램입니다.이 도움이 되길 바랍니다

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: 정규 분포 및 변환

공유해 주셔서 감사합니다.

저는 스크립팅 초보자일 뿐이라 지금은 너무 복잡해서 어떻게 사용해야 할지 잘 모르겠습니다!

---

 

 

Re: 정규 분포 및 변환

다음은 해결된 값을 얻기 위해 연속 근사치를 사용하는 실행 중인 시스템에서 가져온 함수입니다.

/***********************************************************************/
/*                                                                     */
/* 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: 정규 분포 및 변환

안녕하세요 짐,

나는 같은 문제가 있습니다. 저는 Johnson Si가 변환한 데이터 중 일부를 모델링하여 예측 모델을 얻었습니다. 역함수를 사용하여 예측된 데이터를 다시 변환하려고 시도했지만 작동하지 않습니다. 이를 위한 스크립트 작성에 대한 추가 지침을 제공할 수 있습니까? DOE 실험의 반응을 모델링할 때 이러한 유형의 분포를 계속 접하게 되므로 데이터를 다시 전송하는 방법을 아는 것이 정말 유용할 것입니다.
정말 감사합니다!

크리스텔

Re: 정규 분포 및 변환

제가 질문의 요점을 놓친 것 같습니다. 확률을 기반으로 "밴드"를 계산하려는 경우 이러한 밴드의 위치는 분포 유형에 따라 달라집니다. 당신의 전화번호 68-95-99.7은 표준 편차가 아니지만 정규 분포를 기반으로 한 평균에서 1,2,3 표준 편차 거리를 기반으로 한 "밴드"와 관련된 확률입니다. 정규분포가 없으면 표준편차를 계산하는 것이 문제가 아니라 확률로 변환하는 것이 문제입니다. +/- 3 표준 편차 대역을 갖고 싶다면 분포가 정규이거나 적어도 대칭이라고 가정합니다. 수행하려는 작업에 따라 비대칭 밴드를 계산하거나(JMP에는 정규 분포뿐만 아니라 모든 분포에 대한 확률 분포가 있음) 데이터를 정규화하기 위해 변환을 수행해야 합니다(그런 다음 언제든지 역변환을 수행해야 함). 자연 측정항목으로 다시 변환하려는 경우) 내가 선호하는 것은 비대칭 밴드를 사용하고 이를 계산하기 위해 JOHNSON SU 함수를 사용하는 것입니다.

온라인 도움말

Re: 정규 분포 및 변환짐님 답변 감사드립니다! 나는 이것을 한번 시도해 볼 것이다.Re: 정규 분포 및 변환내가하는 일은 다음과 같습니다. 변환된 데이터 값을 기반으로 원본 데이터에 한계를 설정하기 위해 변환된 데이터에서 표준값을 가져와서 표준값 1, 2, 3 등에 대한 평균 위와 아래의 값을 계산한 다음 역방향으로 계산합니다. 원래 데이터로 다시 변환합니다. Johnson SU와 같은 일부 경우에는 값을 다시 변환하는 쉬운 방법이 없습니다. 그러면 제가 하는 일은 원래 변환을 통해 값을 전달하는 작은 스크립트를 실행하고 대상 표준의 값을 확인하는 것입니다. , 일치하는 항목이 있을 때까지 값을 반복합니다. 그런 다음 변환 시 변환된 값의 목표 값이 되는 원본 데이터의 값을 찾았습니다. 이렇게 하면 원본 데이터의 평균 위아래의 거리는 동일하지 않습니다.Re: 정규 분포 및 변환

아, 그래도 표준편차가 중요하다고 생각했어요. 예를 들어, 68-95-99.7(3개의 표준 편차) 규칙은 정규 분포에서 평균 주변 대역 내의 값을 찾는 데 사용됩니다. 하지만 내 데이터가 정상적이지 않다면 이것을 사용하는 것이 의미가 없을 수도 있습니다. 예를 들어, 내 트랜지스터의 온 저항이 정상이 아니고 평균에서 3 표준 편차의 값이 무엇인지 확인하려는 경우 실제로는 의미가 없는 음수 값 또는 매우 낮은 값을 가질 수 있습니다. .

 

제가 뭔가 혼란스럽거나 오해하고 있었다면 죄송합니다. 대학교 이후로 다시 통계를 배우기 시작했습니다!

Re: 정규 분포 및 변환

감사합니다. 어떻게 되었는지 알겠습니다. 이제 데이터가 정규 분포를 따르는 것을 확인했습니다. 이를 사용하여 표준 편차를 어떻게 찾을 수 있습니까? 요약 통계에는 변환을 기반으로 의미가 있는 값이 나와 있지만 원본 데이터의 표준 편차가 무엇인지 알고 싶습니다. 아마도 데이터 변환의 목적을 이해하지 못하는 것 같습니다.

 

Re: 정규 분포 및 변환

나탈리

분산 및 표준 편차 공식은 분포 형태에 대해 어떤 가정도 하지 않습니다. 이는 단지 대수학일 뿐입니다(평균값 계산에서 분포 유형에 대해 어떤 가정도 하지 않는 것과 같은 방식으로).

Re: 정규 분포 및 변환

나탈리,

변환을 새 열에 저장한 다음 해당 열에서 배포를 실행할 수 있어야 합니다.

 

짐

Re: 정규 분포 및 변환

안녕하세요 데이비드와 여러분,

저는 JMP를 처음 사용하는데 데이터 변환에 대해 궁금합니다.
정규 분포를 얻기 위해 데이터 변환을 사용하는 것과 비교하여 데이터 피팅을 사용하는 경우의 장단점은 무엇입니까?

또한 변환 후에 좋은 p-값이 없는 경우에도 변환을 고려해야 합니까?

감사합니다

Re: 정규분포와 변환

코와, 커뮤니티에 오신 것을 환영합니다. 귀하의 질문은 이 포럼에서 충분히 답변할 수 없습니다. 여기서 시작하는 것이 좋습니다.

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

변형을 수행하는 데에는 두 가지 주요 이유가 있습니다.

1. 평균 0과 동의 분산(NID(0, 분산))을 갖는 정규 및 독립적으로 분포된 잔차의 양적 가정을 충족합니다. 이러한 가정이 충족되지 않으면 제안된 모델에 의문을 제기해야 합니다.

2. 박스 박사가 몇 년 전에 저에게 말씀하신, 변형의 유일한 이유는 모델을 단순화하는 것입니다... 본질적으로 모델을 더 사용하기 쉽게 만드는 것입니다.