Existe-t-il un moyen plus rapide de boucler ?Bonjour la communauté JMP,
J'analyse de plus grandes quantités de données, généralement 350 000 lignes.
Pour chaque ligne, le code exécute une boucle pour calculer le décalage moyen de " ID de plaquette ". Je cherche un moyen plus rapide de procéder.
Existe-t-il un moyen d'accélérer le traitement ? Le script actuel prend ~1 heure r pour boucler la boucle.
Names Default To Here( 1 );
dt1 = Data Table( "Reference Data Table.jmp" );
dt2 = Data Table("Data table");
Col_List1 = dt2 << Get Column Names( "String" );
Summation(
c = 1,
N Col( dt2 ) - 1,
values = [];
name = Column( dt2, c ) << Get Name;
If( Contains( name, "Currents" ) | Contains( name, "Voltage" ) | Contains( name, "Resistance" ),
rows = dt1 << Get Rows Where( :tests == name );
col = Column( dt2, c );
col mean = Col Mean( col );
For Each Row(
dt2,
mean = dt1:Mean[rows];
measure = mean - Col Mean( As Column( dt2, c ), :Wafer ID );
values |/= col[] + measure
;
);
col << Set Values( values );
);
0
);Modélisation statistique avancéeAutomatisation et scriptsAccès aux donnéesRe : Existe-t-il un moyen plus rapide de boucler ?Voici ma tentative, les deux tableaux en bas "stacked_table" et "summary_table_delta_by_wafer" pourraient être la bonne forme pour cela.
C'est rapide, moins d'une seconde pour l'ensemble
(HP Time() - début) / 1000000 = 0,664238 ;
Names Default To Here(1);
dt_ref = Open("$DOWNLOADS/Reference data table.jmp", invisible);
dt_dt = Open("$DOWNLOADS/Data table.jmp", invisible);
dt_dt << clear select;
dt_ref << clear select;
start = Hp Time();
curr_col_names_list = dt_dt << Get Column Names("string");
obj = dt_dt << Tabulate(
Show Control Panel( 0 ),
Add Table(
Column Table(
Analysis Columns(
eval list(curr_col_names_list)
),
Statistics( Mean )
),
Row Table( Grouping Columns( :Wafer ID ) )
)
);
my_new_table = obj << Make Into Data Table;
curr_col_names_list = my_new_table << Get Column Names("string");
transposed_table = my_new_table << Transpose(
columns(
eval list(curr_col_names_list)
),
Label( :Wafer ID ),
Output Table( "transposed_table" )
);
transposed_table << new column ("join_key"
,char
,formula(
regex(:Label,"\(([^\)]+)\)", "\1")
)
);
transposed_table_join = (
transposed_table << Join(
With( dt_ref )
,Match Columns( :join_key = :Tests),
,Merge same name columns
,output table("transposed_table_join")
)
);
// clean up
close(transposed_table,nosave);
close(my_new_table,nosave);
transposed_table_join << delete columns(:"Match Flag", :"Label","join_key");
transposed_table_join:"Mean" << Set Name( "Ref_Value" );
curr_col_names_list = transposed_table_join << Get Column Names("string");
matches_i_dont_want_to_stack = {"Tests","Ref_Value"};
clean_col_list = Associative Array(curr_col_names_list) << Remove(Associative Array(matches_i_dont_want_to_stack)) << get keys;
stacked_table = transposed_table_join << Stack(
columns( clean_col_list ),
Source Label Column( "Wafer_ID" ),
Stacked Data Column( "Measured_Value" ),
Output Table( "stacked_table" )
);
//Is this the formula you wanted on each value? A-B?
stacked_table << new column ("delta"
,numeric
,continuous
,formula(
(:Ref_Value -:Measured_Value)
)
);
//stacked table and final summary_table_delta_by_wafer seems like the useful combo here.
close(transposed_table_join,nosave);
//final output?
summary_table_delta_by_wafer = stacked_table << Transpose(
columns( :delta ),
By( :Wafer_ID ),
Label( :Tests ),
Output Table( "summary_table_delta_by_wafer" )
);
show((Hp Time() - start)/1e6);
Re : Existe-t-il un moyen plus rapide de boucler ?Merci Jarmo ! 
Re : Existe-t-il un moyen plus rapide de boucler ?Espérons que ce calcul soit correct. Ce n'est pas le script le plus simple mais il est quelque peu optimisé pour la vitesse (sur mon ordinateur portable, le calcul pour une colonne prenait 200 ms, donc au total environ 6 secondes).
Names Default To Here(1);
dt_ref = Open("$DOWNLOADS/Reference data table.jmp", invisible);
dt_dt = Open("$DOWNLOADS/Data table.jmp", invisible);
dt_dt << clear select;
dt_ref << clear select;
aa_means = Associative Array(Column(dt_ref, "Tests"), Column(dt_ref, "Mean"));
col_list = Filter Each({col_name}, dt_dt << Get Column Names("String"),
Contains({"Currents", "Voltage", "Resistance"}, Word(1, col_name));
);
dt_dt << Add Row(1, At Start);
dt_dt << Begin Data Update;
For Each({col_name, idx}, col_list,
start = Hp Time();
Eval(Eval Expr(
Column(dt_dt, col_name) << Set Each Value(
//AsColumn(col_name) + aa_means[col_name] - Col Mean(AsColumn(col_name), :Wafer ID);
//Col Mean(Expr(Name Expr(AsColumn(col_name))), :Wafer ID);
//Col Mean(:Currents A17, :Wafer ID);
Expr(Name Expr(AsColumn(col_name)))+ Expr(aa_means[col_name]) - Col Mean(Expr(Name Expr(AsColumn(col_name))), :Wafer ID);
);
));
show((Hp Time() - start)/1e6);
);
dt_dt << Delete Row(1);
dt_dt << End Data Update;
//Summarize(dt_dt, b = by(:WAFER ID), m = Mean(:Currents A17));
//show(b,m, Col Mean(:Currents A17));
J'ai dû ajouter 1 ligne au début, puis la supprimer plus tard pour éviter un problème de calcul étrange lors de l'utilisation de << Définir chaque valeur (peut-être juste mes expressions) et c'est pourquoi il y a des lignes commentées étranges dans le code. Je contacterai le support JMP à ce sujet lorsque j'aurai le temps
Edit : ticket créé TS-00036082. En fonction des réponses que je reçois, je ferai un post séparé concernant le Col Mean.
Re : Existe-t-il un moyen plus rapide de boucler ?Ah... j'ai raté le col[] dans votre script. J'écrirai bientôt une nouvelle version
Re : Existe-t-il un moyen plus rapide de boucler ?....
Re : Existe-t-il un moyen plus rapide de boucler ?L'utilisation du résumé (ou du résumé si vous n'avez pas besoin d'un tableau de données) devrait être assez rapide (vous pouvez joindre/mettre à jour le tableau récapitulatif vers des données volumineuses si nécessaire)
Names Default To Here(1);
dt_ref = Open("$DOWNLOADS/Reference data table.jmp", invisible);
dt_dt = Open("$DOWNLOADS/Data table.jmp", invisible);
dt_dt << clear select;
dt_ref << clear select;
aa_means = Associative Array(Column(dt_ref, "Tests"), Column(dt_ref, "Mean"));
col_list = Filter Each({col_name}, dt_dt << Get Column Names("String"),
Contains({"Currents", "Voltage", "Resistance"}, Word(1, col_name));
);
dt_summary = dt_dt << Summary(
Group(:Wafer ID),
Mean(Eval(col_list)),
Freq("None"),
Weight("None"),
statistics column name format("column"), // this is important here
Link to original data table(0)
);
For Each({col_name}, col_list,
Eval(EvalExpr(
Column(dt_summary, col_name) << Set Each Value(
aa_means[col_name] - AsColumn(col_name)
);
));
);
Pensez à vérifier que les valeurs sont correctes
Re : Existe-t-il un moyen plus rapide de boucler ?Oui, corrigez une moyenne par tranche. Oui, j'aimerais tout traiter en même temps car je développe un script qui sert d'outil multifonction pour mon équipe. Toute suggestion serait appréciée Jarmo
Re : Existe-t-il un moyen plus rapide de boucler ?Y a-t-il un besoin spécifique d'avoir toutes ces 350 000 lignes si au final vous vous retrouvez avec 4 valeurs dans chaque colonne (si j'ai bien compris le code), une moyenne par tranche et par colonne ? Vous pouvez éventuellement utiliser Summary pour créer un tableau beaucoup plus petit.
