Hallo,
Ich versuche, mithilfe von JMP eine HDF5-Datei mithilfe eines Skripts zu öffnen. Ich kann sie erfolgreich mit dem Befehl Open() öffnen:
blobpath = "/Documents/myblob";
dtblob_lis = Open(blobpath);
aber ich erhalte ein Popup mit der Frage, welchen Datensatz ich öffnen möchte:
Meine Frage: Gibt es im Open()-Befehl eine Option, mit der ich angeben kann, welchen Datensatz innerhalb des Blobs ich öffnen möchte, und das Popup vermeiden kann? Danke.
Das war das Erste, was ich versucht habe. Nein, es gibt keine offensichtliche Aufzeichnung von Aktionen im Protokoll oder in den erstellten Tabellen.
Dies ist eine Vermutung, aber basierend auf der Diskussion zum automatischen Öffnen einer HDF5-Datei könnte die Python-Integration die Antwort sein. @briancorcoran
Sie müssen die Python-Integration von JMP nicht verwenden, um das Öffnen/Konvertieren von Dateien mit Python zu verwalten. Erstellen Sie ein Python-Skript, das Sie über die Befehlszeile ausführen können (mit „Programm ausführen()“), das die erforderlichen Eingaben (zumindest den Dateipfad) entgegennimmt, es als CSV speichert und diese CSV-Datei dann in JMP öffnet. So habe ich Python vor JMP18 in JMP verwendet (und tue dies von Zeit zu Zeit immer noch). Sie können natürlich versuchen, die Python-Integration von JMP in Versionen vor 18 zu verwenden, aber ich würde mir die Mühe nicht machen und es einfach über die Befehlszeile ausführen.
Sie können einzelne Elemente im HDF5-Datensatz öffnen, indem Sie eine JSL-Liste verwenden, um die zu öffnenden Mitglieder anzugeben. Bei mir hat beispielsweise Folgendes funktioniert (auch unter Angabe der Dateierweiterung):
öffnen("d:\testdata\HDF5\hdf5data.h5", {"/g2/float"});
In Ihrem Fall könnte es so aussehen:
öffnen("/Dokumente/myblob.h5", {"/CSIG_RAW_IMG_OFF/F0/FrameNumbers", "/CSIG_RAW_IMG_OFF/F0/Frames"});
Ich hoffe, das hilft.
Brian Corcoran
JMP-Entwicklung
Ich habe nach schnelleren und effizienteren Möglichkeiten zum Übertragen von Daten zwischen Python und JMP 17 gesucht, da sowohl Pandas als auch JMP beim Lesen/Schreiben von CSV recht langsam sind und sogar die Funktion GetTable() im Hintergrund CSV zu verwenden scheint, zumindest in JMP 17. Die Funktion to_hdf von Pandas funktioniert nicht, da sie statt der Speicherung von String-Daten in einem HDF-kompatiblen Datensatz einige benutzerdefinierte Spielereien verwendet, um ein Numpy-Array als String zu speichern, was nicht nur platzsparend ist, sondern Sie auch dazu zwingt, es mit Python zu lesen.
Ich habe einen benutzerdefinierten Proof-of-Concept-Python-Code geschrieben, der eine .h5-Tabelle mit h5py speichert, und JSL-Code, der die Tabelle liest und die Originaltabelle aus den separaten Datensätzen rekonstruiert.
import pandas as pd
import numpy as np
from pathlib import Path
import h5py
from time import perf_counter
last_time = perf_counter()
compression = "gzip"
def log_time(msg):
global last_time
current_time = perf_counter()
elapsed_time = current_time - last_time
print(f"{elapsed_time:1.3f} s: {msg}")
last_time = current_time
# read dataframe (just for the development example)
df = pd.read_csv(Path(__file__).parent / "my_table.csv")
log_time("Read df")
string_columns = df.select_dtypes(include=["object"]).columns
# min_itemsize = {col: df[col].str.len().max() for col in string_columns}
max_string_length = np.max([df[col].str.len().max() for col in string_columns]) if len(string_columns) > 0 else 1
max_string_column_length = np.max([len(col) for col in string_columns]) if len(string_columns) > 0 else 1
log_time("max_string_length =" + str(max_string_length))
float_columns = df.select_dtypes(include=["float"]).columns
max_float_column_length = np.max([len(col) for col in float_columns]) if len(float_columns) > 0 else 1
log_time("max_float_column_length =" + str(max_float_column_length))
int_columns = df.select_dtypes(include=["int"]).columns
max_int_column_length = np.max([len(col) for col in int_columns]) if len(int_columns) > 0 else 1
log_time("max_int_column_length =" + str(max_int_column_length))
max_column_length = np.max(
[max_float_column_length, max_int_column_length, max_string_column_length]
)
log_time("max_column_length =" + str(max_column_length))
file = h5py.File(Path(__file__).parent / "sample.h5", "w")
log_time("Opened h5 file")
string_data = df[string_columns].astype(str).values
log_time("Converted string data to str")
string_data_ascii = np.array(
[[s.encode("ascii", "ignore") for s in row] for row in string_data]
)
log_time("Converted string data to ascii")
file.create_dataset(
"string_data",
data=string_data_ascii,
dtype=f"S{max_string_length}",
compression=compression,
)
log_time("Created string_data dataset")
file.create_dataset(
"string_columns",
data=np.array(string_columns, dtype=f"S{max_string_column_length}"),
compression=compression,
)
log_time("Created string_columns dataset")
file.create_dataset(
"float_data", data=df[float_columns].values, dtype="f4", compression=compression
)
log_time("Created float_data dataset")
file.create_dataset(
"float_columns",
data=np.array(float_columns, dtype=f"S{max_float_column_length}"),
compression=compression,
)
log_time("Created float_columns dataset")
file.create_dataset(
"int_data", data=df[int_columns].values, dtype="i4", compression=compression
)
log_time("Created int_data dataset")
file.create_dataset(
"int_columns",
data=np.array(int_columns, dtype=f"S{max_int_column_length}"),
compression=compression,
)
log_time("Created int_columns dataset")
file.create_dataset(
"column_order",
data=np.array(
df.columns,
dtype=f"S{max_column_length}",
),
compression=compression,
)
log_time("Created column_order dataset")
file.flush()
file.close
CloseAll(datatables, nosave);
last_time = TickSeconds();
log_time = Function({msg},
now = TickSeconds();
print(Char(now - last_time) || " - " || Char(msg));
last_time = now;
);
hdf5_file_path = "my_table.h5";
dataset_names = {
// "/column_order",
"/float_columns",
"/float_data",
"/int_columns",
"/int_data",
"/string_columns",
"/string_data"
};
// Open the hdf file
hdf5_file = Open(hdf5_file_path, dataset_names, invisible);
log_time("Opened HDF5 file: " || hdf5_file_path);
// Get list
// columns = As Column(DataTable("-column_order"), "Column 1"n) << get as matrix;
string_columns = As Column(DataTable("-string_columns"), "Column 1"n) << get as matrix;
float_columns = As Column(DataTable("-float_columns"), "Column 1"n) << get as matrix;
int_columns = As Column(DataTable("-int_columns"), "Column 1"n) << get as matrix;
Close(DataTable("-string_columns"), nosave);
Close(DataTable("-float_columns"), nosave);
Close(DataTable("-int_columns"), nosave);
log_time("Got columns");
dt_int = DataTable("-int_data");
ForEach({cname, i}, int_columns,
Column(dt_int, "Column " || Char(i)) << SetName(cname)
);
log_time("Assembled int table");
dt_float = DataTable("-float_data");
ForEach({cname, i}, float_columns,
Column(dt_float, "Column " || Char(i)) << SetName(cname)
);
log_time("Assembled float table");
dt_string = DataTable("-string_data");
ForEach({cname, i}, string_columns,
Column(dt_string, "Column " || Char(i)) << SetName(cname)
);
log_time("Assembled string table");
dt_string << Update(
With( dt_int ),
Replace Columns in Main Table( None )
);
Close(dt_int, nosave);
dt_string << Update(
With( dt_float ),
Replace Columns in Main Table( None )
);
Close(dt_float, nosave);
log_time("Combined table");
// For( i = N Items( columns ), i >= 1, i--,
// Eval( Parse( "combined_dt << Move Selected Columns(\!"" || columns[i] || "\!"n, To first )" ) )
// );
// log_time("Moved columns");
dt_string << SetName("my_table");
dt_string << ShowWindow(1);
Ich habe den Code deaktiviert, der versucht, die ursprüngliche Spaltenreihenfolge wiederherzustellen, da dies bei breiten Tabellen sehr, sehr langsam ist. Bitte beachten Sie außerdem, dass ich den Fall, dass es keine Spalten eines bestimmten Typs gibt, nicht berücksichtigt habe. Das erfordert etwas zusätzliche Arbeit auf der JSL-Seite, falls Ihnen das wichtig ist.
Ergebnisse: Für eine Datentabelle mit 80 Zeilen und 115.791 Spalten, die in Pandas normalerweise 20 Sekunden zum Speichern als CSV und 24 Sekunden zum Öffnen als JMP benötigt, benötigte mein Skript 1,7 Sekunden zum Speichern und 11,5 Sekunden zum Öffnen als JMP. Zusätzlich reduzierte sich die Dateigröße durch die GZIP-Komprimierung von 88,8 MB auf 24,5 MB. Das entspricht einer Gesamtersparnis von 70 % Zeit und 72 % Speicherplatz.
