Gibt es eine schnellere Möglichkeit zum Schleifen?Hallo JMP-Community,
Ich analysiere größere Datenmengen, normalerweise 350.000 Zeilen.
Für jede Zeile führt der Code eine Schleife aus, um den mittleren Versatz um „zu berechnen. Wafer-ID ". Ich suche nach einer schnelleren Möglichkeit, dies zu tun.
Gibt es eine Möglichkeit, die Verarbeitung zu beschleunigen? Das aktuelle Skript dauert ~1 Stunde r, um die Schleife abzuschließen.
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
);Erweiterte statistische ModellierungAutomatisierung und SkripterstellungDatenzugriffBetreff: Gibt es eine schnellere Möglichkeit zum Schleifen?Hier ist mein Versuch, die beiden Tabellen unten „stacked_table“ und „summary_table_delta_by_wafer“ könnten dafür die richtige Form haben.
Es ist die ganze Zeit über schnell und beträgt weniger als 1 Sekunde
(HP Time() - Start) / 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);
Betreff: Gibt es eine schnellere Möglichkeit zum Schleifen?Danke Jarmo!<3 
Betreff: Gibt es eine schnellere Möglichkeit zum Schleifen?Hoffentlich ist die Berechnung korrekt. Es ist nicht das einfachste Skript, aber es ist etwas auf Geschwindigkeit optimiert (auf meinem Laptop dauerte die Berechnung für eine Spalte 200 ms, also insgesamt etwa 6 s).
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));
Ich musste am Anfang eine Zeile hinzufügen und sie später entfernen, um seltsame Berechnungsprobleme bei der Verwendung von << Set Each Value zu vermeiden (möglicherweise nur meine Ausdrücke), und deshalb enthält der Code einige seltsame kommentierte Zeilen. Ich werde den JMP-Support diesbezüglich kontaktieren, wenn ich Zeit habe
Bearbeiten: Ticket erstellt TS-00036082. Abhängig von der Antwort, die ich bekomme, werde ich einen separaten Beitrag zu Col Mean verfassen
Betreff: Gibt es eine schnellere Möglichkeit zum Schleifen?Ah ... ich habe die Spalte [] in Ihrem Skript verpasst. Ich werde bald eine neue Version schreiben
Betreff: Gibt es eine schnellere Möglichkeit zum Schleifen?....
Betreff: Gibt es eine schnellere Möglichkeit zum Schleifen?Die Verwendung von „Zusammenfassung“ (oder „Zusammenfassen“, wenn Sie keine Datentabelle benötigen) sollte ziemlich schnell gehen (Sie können die Zusammenfassungstabelle bei Bedarf wieder mit großen Datenmengen verbinden/aktualisieren).
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)
);
));
);
Denken Sie daran, zu überprüfen, ob die Werte korrekt sind
Betreff: Gibt es eine schnellere Möglichkeit zum Schleifen?Ja, korrigieren Sie einen Mittelwert pro Wafer. Ja, ich möchte alles auf einmal verarbeiten, da ich ein Skript entwickle, das als Multifunktionstool für mein Team dient. Jeder Vorschlag wäre willkommen, Jarmo
Betreff: Gibt es eine schnellere Möglichkeit zum Schleifen?Besteht ein besonderer Bedarf an all diesen 350.000 Zeilen, wenn Sie am Ende 4 Werte pro Spalte haben (wenn ich den Code richtig verstanden habe), einen Mittelwert pro Wafer und Spalte? Sie könnten möglicherweise Zusammenfassung verwenden, um eine viel kleinere Tabelle zu erstellen.
