915439_it-IT

liliconcom

Richiesta assistenza per la scrittura di script: creazione di un simulatore per gli errori di tipo 1 nei test di equivalenza

Ciao a tutti,

Sto cercando di scrivere uno script che generi un set di dati casuale (n=3 misurazioni di riferimento e di test) e poi esegua una simulazione con un numero (1000 o qualsiasi altro numero). Per ogni set eseguirò un test di equivalenza e vorrei che l'output fosse un report/tabella con la frequenza degli eventi in cui è stata dimostrata l'equivalenza. L'obiettivo di questo strumento sarà quello di fornire una probabilità di errori di tipo 1 dato un certo margine di equivalenza.

Sono arrivato al codice seguente, ma non funziona e sono praticamente bloccato. Qualsiasi consiglio o aiuto che il gruppo possa fornirmi sarà molto apprezzato.

Grazie!

Chris

// Parameters
numSimulations = 10;
nPerGroup = 3;
refMean = 99.1;
testMean = 98.8;
sd = 0.1;
equivMargin = 0.3;
type1Errors = 0;

// Critical t-value for 90% CI with df = 2n - 2
df = 2 * nPerGroup - 2;
tCrit = StudentTQuantile(0.950, df);

// Create summary table
summaryTable = New Table("Simulation Summary",
    New Column("Simulation", Numeric),
    New Column("CI_Lower", Numeric),
    New Column("CI_Upper", Numeric),
    New Column("Equivalence_Concluded", Character),
    New Column("Mean_Diff", Numeric)
);

// Loop through simulations
For(sim = 1, sim <= numSimulations, sim++,

    // Create new data table
    dt = New Table("Sim" || Char(sim),
        Add Rows(nPerGroup * 2),
        New Column("Group", Character),
        New Column("Value", Numeric)
    );

    // Simulate Reference group
    For(i = 1, i <= nPerGroup, i++,
        dt:Group[i] = "Reference";
        dt:Value[i] = Random Normal(refMean, sd);
    );

    // Simulate Test group
    For(i = nPerGroup + 1, i <= nPerGroup * 2, i++,
        dt:Group[i] = "Test";
        dt:Value[i] = Random Normal(testMean, sd);
    );

    // Extract values
    refVals = dt << Get As Matrix( :Value )[1::nPerGroup];
    testVals = dt << Get As Matrix( :Value )[nPerGroup+1::nPerGroup*2];
    meanDiff = Mean(testVals) - Mean(refVals);

    // Sample variances
    varRef = Variance(refVals);
    varTest = Variance(testVals);

    // Pooled variance
    pooledVar = ((nPerGroup - 1) * varRef + (nPerGroup - 1) * varTest) / df;
    pooledSD = Sqrt(pooledVar);

    // Standard error of difference
    seDiff = pooledSD * Sqrt(2 / nPerGroup);

    // 90% CI
    ciLower = meanDiff - tCrit * seDiff;
    ciUpper = meanDiff + tCrit * seDiff;

    // Check equivalence
    eqResult = "No";
    If(ciLower > -equivMargin & ciUpper < equivMargin,
        type1Errors++;
        eqResult = "Yes";
    );

    // Log results
    summaryTable << Add Rows(1);
    summaryTable:Simulation[sim] = sim;
    summaryTable:CI_Lower[sim] = ciLower;
    summaryTable:CI_Upper[sim] = ciUpper;
    summaryTable:Equivalence_Concluded[sim] = eqResult;
    summaryTable:Mean_Diff[sim] = meanDiff;

    // Close the table to avoid clutter
    dt << Close Window;
);

// Show results
New Window("Type I Error Summary",
    Text Box("Total Simulations: " || Char(numSimulations)),
    Text Box("Type I Errors: " || Char(type1Errors)),
    Text Box("Estimated Type I Error Rate: " || Char(Round(type1Errors / numSimulations * 100, 2)) || "%")
);

Automazione e scriptingRe: Richiesta di aiuto per la scrittura di script - Creazione di un simulatore per gli errori di tipo 1 nei test di equivalenza

Quale parte ti è rimasta bloccata?

Re: Richiesta di aiuto per la scrittura di script - Creazione di un simulatore per gli errori di tipo 1 nei test di equivalenza

H Jarmo,

Al momento, il codice non funziona quando si tenta di estrarre i valori critici di T dal report di equivalenza. Ma ci sono anche altri problemi. A volte, il codice si trova in uno stato in cui esegue la simulazione e i test di equivalenza, ma non riesce a estrarre i valori dal report.

Ho provato a usare un po' di tutto questo anche nell'intelligenza artificiale, ma credo che alcune convenzioni di sintassi e di codifica potrebbero essere errate.

Chris

Re: Richiesta di aiuto per la scrittura di script - Creazione di un simulatore per gli errori di tipo 1 nei test di equivalenza

Suggerirei queste modifiche:

Non esiste la funzione StudentTQuantile(). Dovrebbe essere t Quantile().

Variance() non è una funzione predefinita. Definiscila nel tuo script (oppure eleva al quadrato la funzione Std Dev()).

refVals = dt << Ottieni come Matrix( :Value )[1::nPerGroup] dovrebbe essere più simile a refVals = dt:Value[Where( :Group == "Reference" )];

Lo stesso vale per testVals =

Per velocizzare notevolmente le cose, imposta la visibilità per dt su "Privato".

Variance = Function( {Values},
	Return( Std Dev( Values ) ^ 2 )
);
// Parameters
numSimulations = 1000;
nPerGroup = 3;
refMean = 99.1;
testMean = 98.8;
sd = 0.1;
equivMargin = 0.3;
type1Errors = 0;

// Critical t-value for 90% CI with df = 2n - 2
df = 2 * nPerGroup - 2;
tCrit = t Quantile( 0.950, df );

// Create summary table
summaryTable = New Table( "Simulation Summary",
	New Column( "Simulation", Numeric ),
	New Column( "CI_Lower", Numeric ),
	New Column( "CI_Upper", Numeric ),
	New Column( "Equivalence_Concluded", Character ),
	New Column( "Mean_Diff", Numeric )
);

// Loop through simulations
For( sim = 1, sim <= numSimulations, sim++, 

    // Create new data table
	dt = New Table( "Sim" || Char( sim ), "Private", Add Rows( nPerGroup * 2 ), New Column( "Group", Character ), New Column( "Value", Numeric ) );

    // Simulate Reference group
	For( i = 1, i <= nPerGroup, i++,
		dt:Group[i] = "Reference";
		dt:Value[i] = Random Normal( refMean, sd );
	);

    // Simulate Test group
	For( i = nPerGroup + 1, i <= nPerGroup * 2, i++,
		dt:Group[i] = "Test";
		dt:Value[i] = Random Normal( testMean, sd );
	);

    // Extract values
	refVals = dt:Value[Where( :Group == "Reference" )];
	testVals = dt:Value[Where( :Group == "Test" )];
	meanDiff = Mean( testVals ) - Mean( refVals );

    // Sample variances
	varRef = Variance( refVals );
	varTest = Variance( testVals );

    // Pooled variance
	pooledVar = ((nPerGroup - 1) * varRef + (nPerGroup - 1) * varTest) / df;
	pooledSD = Sqrt( pooledVar );

    // Standard error of difference
	seDiff = pooledSD * Sqrt( 2 / nPerGroup );

    // 90% CI
	ciLower = meanDiff - tCrit * seDiff;
	ciUpper = meanDiff + tCrit * seDiff;

    // Check equivalence
	eqResult = "No";
	If( ciLower > -equivMargin & ciUpper < equivMargin,
		type1Errors++;
		eqResult = "Yes";
	);

    // Log results
	summaryTable << Add Rows( 1 );
	summaryTable:Simulation[sim] = sim;
	summaryTable:CI_Lower[sim] = ciLower;
	summaryTable:CI_Upper[sim] = ciUpper;
	summaryTable:Equivalence_Concluded[sim] = eqResult;
	summaryTable:Mean_Diff[sim] = meanDiff;

    // Close the table to avoid clutter
	dt << Close Window;
);

// Show results
New Window( "Type I Error Summary",
	Text Box( "Total Simulations: " || Char( numSimulations ) ),
	Text Box( "Type I Errors: " || Char( type1Errors ) ),
	Text Box( "Estimated Type I Error Rate: " || Char( Round( type1Errors / numSimulations * 100, 2 ) ) || "%" )
);

Re: Richiesta di aiuto per la scrittura di script - Creazione di un simulatore per gli errori di tipo 1 nei test di equivalenza

Jarmo,

Grazie per il suggerimento e la spiegazione. Funziona sicuramente!

Lavorerò sul codice per cercare di interiorizzare il funzionamento del tutto... Apprezzo il tuo aiuto!

Chris

Re: Richiesta di aiuto per la scrittura di script - Creazione di un simulatore per gli errori di tipo 1 nei test di equivalenza

Il codice originale sembra essere stato creato da LLM (a causa degli errori evidenti che commettono se si conosce un po' di JSL).

Una versione funzionante è già stata fornita, ma ecco come la affronterei. Questa è una versione leggermente più complicata che utilizza le matrici (generalmente sono più veloci) e non ho verificato i calcoli.

Names Default To Here(1);

numSimulations = 1000;
nPerGroup = 3;
refMean = 99.1;
testMean = 98.8;
sd = 0.1;
equivMargin = 0.3;
type1Errors = 0;

df = 2 * nPerGroup - 2;
tCrit = t Quantile(0.950, df);


dt = New Table("Simulation Summary",
    New Column("Simulation", Numeric),
    New Column("CI_Lower", Numeric),
    New Column("CI_Upper", Numeric),
    New Column("Equivalence_Concluded", Character),
    New Column("Mean_Diff", Numeric),
    Invisible
);


For(sim = 1, sim <= numSimulations, sim++,
	m_ref = J(nperGroup, 1, Random Normal(refMean, sd));
	m_test = J(nperGroup, 1, Random Normal(testMean, sd));

	avgdiff = Mean(m_test) - Mean(m_ref);
	
	var_ref = Std Dev(m_ref)^2;
	var_test = Std Dev(m_test)^2;

    pooledVar = ((nPerGroup - 1) * var_ref + (nPerGroup - 1) * var_test) / df;
    pooledSD = Sqrt(pooledVar);

    seDiff = pooledSD * Sqrt(2 / nPerGroup);

    ciLower = avgdiff - tCrit * seDiff;
    ciUpper = avgdiff + tCrit * seDiff;

    eqResult = "No";
    If(ciLower > -equivMargin & ciUpper < equivMargin,
        type1Errors++;
        eqResult = "Yes";
    );

	dt << Add Rows(
		{Simulation = sim, CI_Lower = ciLower, CI_Upper = ciUpper, Equivalence_Concluded = eqResult, Mean_Diff = avgdiff}
	);
);


dt << Show Window(1);

nw = New Window("Type I Error Summary",
    Text Box("Total Simulations: " || Char(numSimulations)),
    Text Box("Type I Errors: " || Char(type1Errors)),
    Text Box("Estimated Type I Error Rate: " || Char(Round(type1Errors / numSimulations * 100, 2)) || "%")
);