Hola,
Estoy intentando usar JMP para abrir un archivo hdf5 mediante un script. Puedo abrirlo correctamente con el comando Open():
blobpath = "/Documents/myblob";
dtblob_lis = Open(blobpath);
pero me aparece una ventana emergente que me pregunta qué conjunto de datos me gustaría abrir:
Mi pregunta es: ¿existe alguna opción en el comando Open() que pueda usar para especificar qué conjunto de datos dentro del blob deseo abrir y evitar la ventana emergente? Gracias.
...y hay alguna manera de grabar la acción?
Como alternativa: utilice h5py.
muy suave desde JMP18 : )
Eso fue lo primero que probé. No, no hay registro aparente de acciones en el log ni en la(s) tabla(s) que se crean.
Lamentablemente mi organización aún no ha adoptado JMP18.
LearnBot: lo mismo.
refrescantemente honesto 
Esto es una suposición, pero según la discusión sobre Automatizar la apertura de un archivo hdf5, la integración de Python podría ser la respuesta. @briancorcoran
No es necesario que utilices la integración de Python de JMP para gestionar la apertura/conversión de archivos con Python, crea un script de Python que puedas ejecutar desde la línea de comandos (utilizando Run Program()) que toma las entradas que necesitas (al menos la ruta del archivo), lo guarda como .csv y luego abre ese .csv en JMP. Así es como usé Python antes de JMP18 en JMP (y todavía lo hago de vez en cuando). Por supuesto, puedes intentar usar la integración de Python de JMP en versiones anteriores a la 18, pero yo no me molestaría y simplemente lo ejecutaría desde la línea de comandos.
Puede abrir elementos individuales dentro del conjunto de datos HDF5 utilizando una lista JSL para especificar los miembros que desea abrir. Por ejemplo, lo siguiente me funcionó (especificando también la extensión del archivo):
abrir("d:\testdata\HDF5\hdf5data.h5", {"/g2/float"});
En tu caso podría verse así:
open("/Documentos/myblob.h5", {"/CSIG_RAW_IMG_OFF/F0/NúmerosDeCuadro", "/CSIG_RAW_IMG_OFF/F0/Cuadros"});
Espero que ayude.
Brian Corcoran
Desarrollo de JMP
Brian,
¿Dónde está documentada esta capacidad?
Esta es exactamente la solución que estaba buscando. Funciona. Gracias.
Estaba buscando formas más rápidas y eficientes de transferir datos entre Python y JMP 17, porque tanto pandas como JMP son bastante lentos al leer/escribir CSV, e incluso la función GetTable() parece usar CSV bajo el capó, al menos en JMP 17. La función to_hdf de Pandas no funciona porque en lugar de almacenar datos de cadena en un conjunto de datos compatible con HDF, utiliza algunas travesuras personalizadas para almacenar una matriz Numpy como una cadena, lo que no solo es ineficiente en términos de espacio sino que lo limita a leerlo con Python.
Escribí un código Python de prueba de concepto personalizado que guarda una tabla .h5 usando h5py y un código JSL que lee la tabla y reconstruye la tabla original a partir de los conjuntos de datos separados.
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);
Desactivé el código que intenta reconstruir el orden original de las columnas, ya que, en tablas anchas, es muy lento. Además, tenga en cuenta que no tuve en cuenta el caso en que no hay columnas de un tipo específico. Esto requerirá un poco de trabajo adicional en el JSL si le interesa.
Resultados: Para una tabla de datos con 80 filas y 115,791 columnas, que normalmente tardaría 20 segundos en guardarse como csv con Pandas y 24 segundos en abrirse con JMP, mi script tardó 1.7 segundos en guardarse y 11.5 segundos en abrirse con JMP. Además, el archivo se redujo de 88.8 MB a 24.5 MB al usar la compresión gzip. Esto representa un ahorro total del 70% en tiempo y del 72% en espacio.
