CIAO,
Sto provando a usare JMP per aprire un file hdf5 usando uno script. Riesco ad aprirlo con successo usando il comando Open():
blobpath = "/Documents/myblob";
dtblob_lis = Open(blobpath);
ma mi appare un pop-up che mi chiede quale set di dati vorrei aprire:
La mia domanda: esiste un'opzione nel comando Open() che potrei usare per specificare quale set di dati all'interno del blob desidero aprire ed evitare il pop-up? Grazie.
Questa è stata la prima cosa che ho provato. No, non c'è alcuna registrazione apparente di azioni nel log o nella/e tabella/e che vengono create.
Questa è una supposizione, ma in base alla discussione su Automatizzare l'apertura di un file hdf5, l'integrazione Python potrebbe essere la risposta. @briancorcoran
Non devi usare l'integrazione Python di JMP per gestire l'apertura/conversione dei file con Python, crea uno script Python che puoi eseguire dalla riga di comando (usando Run Program()) che prende gli input di cui hai bisogno (almeno il percorso del file), lo salva come .csv e poi apre quel .csv in JMP. È così che ho usato Python prima di JMP18 in JMP (e lo faccio ancora di tanto in tanto). Ovviamente puoi provare a usare l'integrazione Python di JMP nelle versioni precedenti alla 18, ma io non mi preoccuperei e lo eseguirei semplicemente dalla riga di comando.
È possibile aprire singoli elementi all'interno del dataset HDF5 utilizzando un elenco JSL per specificare i membri da aprire. Ad esempio, il seguente ha funzionato per me (specificando anche l'estensione del file):
apri("d:\testdata\HDF5\hdf5data.h5", {"/g2/float"});
Nel tuo caso potrebbe apparire così:
open("/Documenti/myblob.h5", {"/CSIG_RAW_IMG_OFF/F0/NumeriFrame", "/CSIG_RAW_IMG_OFF/F0/Frame"});
Spero che questo ti sia utile.
Brian Corcoran
Sviluppo JMP
Cercavo modi più rapidi ed efficienti per trasferire dati tra Python e JMP 17, perché sia pandas che JMP sono piuttosto lenti nella lettura/scrittura di CSV, e persino la funzione GetTable() sembra usare CSV in background, almeno in JMP 17. La funzione to_hdf di Pandas non funziona perché invece di memorizzare dati stringa in un dataset compatibile con HDF, utilizza alcuni stratagemmi personalizzati per memorizzare un array Numpy come stringa, il che non solo è inefficiente in termini di spazio, ma ti costringe anche a leggerlo con Python.
Ho scritto un codice Python proof-of-concept personalizzato che salva una tabella .h5 utilizzando h5py e un codice JSL che legge la tabella e ricostruisce la tabella originale dai set di dati separati.
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);
Ho disabilitato il codice che tenta di ricostruire l'ordine originale delle colonne, perché per le tabelle di grandi dimensioni è molto, molto lento. Inoltre, tieni presente che non ho considerato il caso in cui non ci siano colonne di un tipo particolare. Ciò richiederà un po' di lavoro extra sul lato JSL, se ti interessa.
Risultati: per una tabella dati con 80 righe e 115.791 colonne, che normalmente richiederebbe 20 secondi per il salvataggio in formato CSV con Pandas e 24 secondi per l'apertura con JMP, il mio script ha impiegato 1,7 secondi per il salvataggio e 11,5 secondi per l'apertura con JMP. Inoltre, il file è passato da 88,8 MB a 24,5 MB utilizzando la compressione gzip. Si tratta di un risparmio totale del 70% in termini di tempo e del 72% in termini di spazio.
