Muy bien. Gracias por sintonizar hoy. Hablaré sobre JMP, por supuesto, pero específicamente sobre su uso para automatizar flujos de trabajo analíticos en Amirys, y también sobre procesos más complejos y la generalización de la automatización o la automatización de datos utilizando las plataformas nativas de JMP. Antes de empezar, me presento brevemente. Me llamo Stefan. Soy Director Asociado de Ciencia de Datos en Amirys y tengo 15 años de experiencia en la industria de las ciencias de la vida, con una amplia variedad de trayectorias. He trabajado en numerosos laboratorios de química, laboratorios de fermentación y equipos de cribado de alto rendimiento. He trabajado en calidad, estadística, análisis de datos y, ahora, por supuesto, ciencia de datos. Me apasiona todo lo relacionado con los datos, desde cómo se almacenan hasta cómo se consumen y acceden a ellos. Actualmente, apoyo a la comunidad científica de AMRA con sus propias herramientas y metodologías de análisis. Hoy abordaré tres aspectos principales. Voy a dar un poco de contexto sobre el caso práctico que vamos a usar para explicar algunos de estos ejemplos de automatización. Empezaremos con algo muy sencillo.
¿Cómo usamos JMP para automatizar los flujos de trabajo de análisis de datos? Estos pueden ser análisis que realizas a diario y que deseas optimizar. En la última parte, abordaremos la automatización avanzada, donde analizaremos flujos de trabajo más complejos. Podríamos estar analizando cómo se analizan estos flujos de trabajo utilizados por un equipo técnico más amplio. ¿Cómo se generaliza esto para que sea compatible tanto con el procesamiento y la ingesta de datos como con el análisis? Nuestro caso práctico de hoy proviene de la empresa donde trabajo, Amirys. Amirys es una empresa de biología sintética. Nos especializamos en la programación de levaduras y en la fermentación industrial, alimentando a esas levaduras con azúcar y convirtiéndola en ingredientes puros o productos químicos. Tenemos nuestra sede en Emeryville, California, y la mayor parte de nuestra producción se realiza en Brasil. Nuestro caso práctico de hoy no se centrará en la producción, sino en la investigación. En Emeryville, contamos con varios laboratorios altamente automatizados, que llamamos nuestros laboratorios de análisis y selección, donde analizamos cientos de miles de cepas por mes en estas 96 placas de pared.
Ahí pueden ver una imagen de un código de barras de placas. Eso es lo que usamos como fermentadores a escala reducida. Es nuestro primer punto de prueba para ver cuánto producen estas cepas y qué producen. Buscamos fenotipos específicos de esas cepas. Las cultivamos en placas de 96 pocillos y luego usamos un conjunto completo de análisis para generar mediciones, a menudo multidimensionales, en estos pocillos. También tenemos muchas bases de datos internas; gran parte de la información, así como los metadatos relacionados, se almacena en bases de datos de aplicaciones y un almacén de datos al que podemos acceder con herramientas como JMP. Ahí es donde entra en juego JMP. Por supuesto, en el paso final de esta selección, analizamos muchas cepas y generamos una gran cantidad de datos. Ahora necesitamos interpretar esos datos, tomar una decisión y decidir qué cepa vamos a promover para la compra de un reactor de fermentación y, potencialmente, para la fabricación en Brasil.
Comenzaremos con la automatización básica en JMP. Hoy quiero presentártela de forma accesible y con poco código a quienes nunca hayan automatizado tareas en JMP o utilizado estas plataformas. Te explicaré los conceptos básicos de su estructura y lo que he aprendido tanto por mi cuenta como de otros usuarios.
Me gusta decir que si haces algo más de 10 veces, probablemente valga la pena automatizarlo. Creo que el punto de partida ideal, si eres nuevo en la automatización, es tu propio análisis. Lo bueno de estos análisis, o si ya los conoces bien, es que puedes darte retroalimentación. Por supuesto, suelen ser más sencillos que intentar realizar un análisis más amplio para un equipo grande. En nuestro ejemplo, se trata de una medición muy simple: una sola medición en una placa. Tenemos esta propagación seriada de placas desde el precultivo hasta lo que llamamos producción. En esa segunda placa, tomamos una sola medición. En este ejemplo de prueba, diríamos: "Estamos realizando este mismo tipo de experimento una y otra vez". Cada vez que lo hacemos, importamos los datos a JMP. Añadimos una columna calculada. Luego filtramos por esa columna y generamos algunas pruebas visuales y estadísticas que nos ayudan a tomar una decisión. Hacerlo una sola vez no lleva mucho tiempo, pero si lo haces una y otra vez todos los días, repetidamente, empieza a acumularse.
Antes de adentrarnos en la automatización, quiero mencionar brevemente los datos estructurados, un requisito indispensable. La estandarización y estructuración se simplificará considerablemente si se realiza en la etapa inicial, al recopilar e importar los datos a una base de datos o archivos CSV. En nuestro caso, la base de datos ya viene estructurada. Si bien JMP permite procesar muchos datos, a menudo dependerá de la aplicación o el análisis que se desee realizar. Pero es fundamental preguntarse: ¿cuál es la fuente de los datos? Cuanto antes se pueda acceder a ella, mejor. Si se utilizan datos de bases de datos, recomiendo usar el Generador de Consultas. No profundizaremos en este tema hoy; esta es mi recomendación general. El registro es la base fundamental de la programación en JMP. Tanto si lo sabes como si no, JMP registra automáticamente tus acciones, el código JSL y el script que se ejecuta para generar el código que utilizas al navegar por la interfaz. Si vas al menú Ver, haces clic en Registro y se abre el archivo de registro, verás la mayoría de los pasos que has realizado.
Si haces clic en cualquier paso, verás el JSL utilizado para ejecutarlo. En este ejemplo, estamos realizando el primer paso: agregar una columna calculada. He hecho clic en ella y resaltado el JSL correspondiente. Es una forma rápida de ver qué JSL se está ejecutando en un paso. Desde el registro, puedes ejecutar directamente ese código o volver a ejecutar código anterior. Dicho esto, no recomiendo usar el registro para automatizar procesos. Simplemente contiene gran parte del código fuente. Una forma de extraer información del registro e integrarla, por ejemplo, en una tabla de datos, es mediante scripts de tabla de datos. Durante mucho tiempo, este fue el método para automatizar procesos paso a paso en JMP. En este ejemplo, fui a esta tabla de datos, hice clic en el pequeño punto rojo interactivo, generé un nuevo script, que simplemente me dio una ventana vacía, y lo pegué directamente desde el registro: dos pasos de código, uno creando la nueva columna y el segundo estableciendo una fórmula para esa columna.
Podrías ir más allá y optimizar el código. Es completamente opcional. Pero en secciones posteriores, cuando comencemos a hablar de ejemplos más complejos, te conviene pensar en cómo lograr que tu código sea lo más mantenible y limpio posible. En este caso, hemos realizado una optimización en dos pasos: primero, eliminamos la referencia redundante a la tabla de datos; segundo, lo comprimimos aún más al no renombrar la columna 21 y luego renombrarla. Simplemente le asignamos el nombre correcto desde el principio. Cada una de estas casillas funcionará y hará exactamente lo mismo. En este caso, no notarás ninguna diferencia en el rendimiento, pero puede resultar en un código más limpio y fácil de mantener. Si eres nuevo en JSL y ves este código, te preguntarás: ¿qué hace esto? Puedes pegar estos fragmentos en tu gestor de lenguaje preferido. Nosotros usamos Copilot, ChatGPT, o el que sea. Si tienes acceso al bot de aprendizaje de JMP, puedes pedirle una explicación del tipo: "¿Qué hace este código?". Generalmente te dará una buena idea de lo que está haciendo.
Extraímos datos del registro, o mejor dicho, extrajimos código del registro y lo pegamos en los scripts de la tabla de datos. Esta es la forma más manual de autogenerar JSL. Puedes verlo aquí. Lo tenemos como lo hemos llamado: paso uno, agregar columna calculada. En la mayoría de las plataformas, existen formas más sencillas de generar estos scripts de tabla y guardar el script que generó una salida específica. Muchas plataformas tienen estas opciones en el menú desplegable rojo. Allí, puedes buscar hasta el final. Hay una opción para guardar el script que te ofrece varias alternativas. Puedes guardarlo directamente en el portapapeles, en la tabla de datos (que es lo que haremos), entre otras. Esto se convierte en una forma muy sencilla de autogenerar JSL directamente desde la interfaz de usuario. Lo guardamos en la tabla de datos. En este caso, simplemente cambiamos el nombre del script (paso dos, filtro de datos) y continuamos con el análisis. Podemos hacerlo aquí, en nuestro paso final, que consiste en generar un gráfico Y por X, y también estamos aplicando una prueba de Dunnett con un grupo de referencia.
De nuevo, vamos al punto rojo, seleccionamos "Guardar script" y lo guardamos en la tabla de datos. Hemos creado un pseudoflujo de trabajo con una automatización de tres pasos: añadimos una columna calculada a la tabla, aplicamos un filtro de datos y realizamos un análisis unidireccional con la prueba de Dunnett. Esto nos lleva al uso de scripts de tabla, una práctica común hasta la versión JMP 16 o 17, cuando surgió el flujo de trabajo. Este flujo de trabajo permitió ampliar las funcionalidades de los scripts de tabla. Se trata de una plataforma independiente en JMP, accesible desde Archivo > Nuevo > Flujo de trabajo. Ofrece diversas características que facilitan el desarrollo y mejoran la experiencia del usuario. Por ejemplo, un botón ejecuta todos los pasos del flujo de trabajo. Existe la función de grabación de pasos, que registra lo que haces en JMP y lo añade automáticamente al flujo de trabajo. Puedes anotar scripts directamente en el flujo de trabajo y añadir elementos como puertas lógicas, interactividad, avisos al usuario y mucho más, pero no tenemos tiempo de explicarlo todo hoy.
Pero les mostraré algunos ejemplos, especialmente en la versión más avanzada. Ahora podemos tomar estos scripts de tabla para crear un pseudo-flujo de trabajo. Imaginemos que lo creamos antes de que existieran los flujos de trabajo, que JMP añadió la plataforma de flujos de trabajo y que ahora lo hemos incorporado al creador de flujos de trabajo. Aquí solo he añadido tres pasos. He copiado el JSL de cada paso y, como pueden ver, tenemos los mismos tres pasos en el flujo de trabajo que en los scripts de tabla de datos. Les mostraré una breve demostración de cómo se ven con nuestros datos reales o de demostración. En este primer ejemplo, tenemos nuestros datos estructurados. Tenemos varias mediciones y sus valores. Lo que queremos hacer es repetir estos tres pasos. Como pueden ver en este enfoque de script de tabla de datos, solo hay que pulsar uno por uno. Pulso esto. Ahora hemos añadido esta columna calculada. Aplicamos un filtro de datos, que aparece y aplica el filtro, y luego generamos un análisis unidireccional para este experimento específico.
Muy sencillo, ¿verdad? Esto funciona bien. Funciona de maravilla para algo tan simple. ¿Necesitas usar un flujo de trabajo? ¿Necesitas algo más sofisticado? No necesariamente. Si esto funciona, genial. Podríamos reiniciarlo, y verás que aquí tengo que hacerlo manualmente. Vamos a borrar el estado de la fila, asegurarnos de que el filtro de datos esté cerrado y luego podemos ver el flujo de trabajo. De nuevo, son tres pasos. Lo bueno es que ahora puedo ver el código automáticamente. Aquí no puedo hacerlo. Aquí tendría que hacer clic derecho, ir a Editar y ver la definición en una ventana nueva. En cambio, en esta otra opción, veo el código de cada paso. Aquí puedo pulsar Reproducir y se ejecutarán los tres pasos juntos. Me aparecen estas pequeñas marcas de verificación verdes que indican que se ejecutó sin errores. Verás que tenemos nuestra nueva columna. Hemos aplicado un filtro y se ha abierto el mismo análisis. Es un poco más limpio. En la siguiente sección, profundizaremos un poco más en las otras funciones adicionales que obtendrá al usar este flujo de trabajo.
Una cosa que quiero mencionar brevemente en la demo es el botón de grabación, que es genial, sobre todo si no estás familiarizado con JSL, o incluso si no tienes experiencia en programación. Esta es la forma más sencilla de empezar a crear tu propia automatización. Simplemente pulsas grabar y todo lo que hagas en esta plataforma quedará registrado en el flujo de trabajo. Veremos un ejemplo sencillo: dibujaré una distribución de mis mediciones que genera una distribución aquí. Supongamos que tiene un significado importante. Al volver al flujo de trabajo, verás un nuevo paso. Aquí tenemos nuestro script JSL. Puedo cambiarle el nombre, añadir notas, modificarlo, etcétera. Una función muy útil del creador de flujos de trabajo es este botón de grabación. Subamos un nivel más, ¿de acuerdo? Quizás hayas automatizado algo para tu sofá o una aplicación muy específica. Quizás funcione para un tipo de experimento. ¿Cómo pasamos de eso a aplicarlo a procesos más complejos? Esa es la pregunta que nos planteamos.
En Amirys, la realidad es que tenemos muchos tipos de aplicaciones experimentales diferentes, y queremos poder darles soporte con la menor cantidad de flujos de trabajo posible. No queremos crear un flujo de trabajo único para cada iteración posible, ya que eso se vuelve imposible de mantener y muy difícil de desarrollar. Cuando se trata de desarrollo más avanzado, algo que sugiero (y lo encontré en un video de la comunidad de JMP) es usar proyectos de JMP para organizar lo que yo llamaría el entorno de desarrollo. Uno de los problemas al empezar a automatizar estas tareas complejas es que aparecen muchas tablas de datos, ventanas y otros elementos que pueden ser difíciles de gestionar. Si usas proyectos, puedes usarlos como una interfaz para tu desarrollo, así como para el uso posterior de esa herramienta.
Aquí tengo abiertas algunas de las plataformas de proyecto predeterminadas, como Espacio de trabajo y Contenido. He añadido un diario como marcador de posición. Aquí es donde todo lo que abra el flujo de trabajo, cualquier ventana nueva, se abrirá como una pestaña nueva en lugar de como una ventana nueva en mi escritorio. También puedes usar este diario, por supuesto, para documentación o instrucciones. A la derecha, tengo mi flujo de trabajo propiamente dicho. Abajo, también he añadido mi registro.
Si necesito solucionar algún problema o consultar más detalles sobre los mensajes de error, tengo el registro a mano y puedo hacerlo directamente desde una sola ventana. Así es como también demuestro este flujo de trabajo dentro del proyecto. Los comentarios generales de los usuarios que he recibido son muy positivos respecto a la ausencia de esa proliferación de tablas y elementos visuales. Cuando hablamos de generalizar la automatización, nos centramos en aplicaciones de alto impacto, ya que no es tarea fácil, ya sea automatización de datos o automatización física (si alguna vez la has implementado en un laboratorio o en una planta de producción, ¿verdad?). Requiere mucho esfuerzo, dinero, trabajo y tiempo. En general, si buscas automatizar flujos de trabajo de datos, prioriza su aplicación para estandarizar flujos de trabajo o úsala como una forma de impulsar la estandarización. Por ejemplo: "Si estandarizamos esto, también podemos automatizar este tedioso procesamiento de datos que realizas a diario".
A menudo, los flujos de trabajo de datos requieren cierta flexibilidad, ya sea por el proceso en sí o por la forma en que se visualizan los datos. Ahí es donde entra en juego la automatización paso a paso. Esta es la gran ventaja de JMP, porque me han preguntado: si se va a automatizar, ¿por qué no usar Python? ¿Por qué no usar una plataforma puramente basada en código para esa automatización? El problema es que, en cuanto algo se basa exclusivamente en código, se crea una gran barrera de entrada. A menos que se pueda automatizar de principio a fin, si se llega a cierto punto y el usuario tiene que intervenir, y entonces se le exige que domine Python, se convierte en una enorme barrera de entrada, incluso en comunidades muy técnicas como la de los científicos con los que trabajo.
JMP es genial porque permite automatizar solo el primer paso, y luego el usuario final trabaja directamente en JMP. Tiene la interfaz de usuario y puede trabajar con ella. Puede hacer lo que quiera, tiene esa libertad y aprovecha la automatización. Claro que queremos identificar oportunidades de alto impacto, porque requiere esfuerzo. En nuestro caso, estábamos analizando estos experimentos con placas de Petri y hablamos con los científicos preguntándoles: "¿Cuánto tiempo les lleva obtener estos datos?". Observamos que lo hacían de forma muy manual, copiando y pegando pasos repetitivos.
Éramos 17 científicos en el equipo. Hicimos una pequeña encuesta y calculamos que dedicábamos el tiempo de una persona entera, un tiempo bastante valioso, a todo esto. Esto nos dio la oportunidad de decir: «Oigan, gran parte de esto parece manual, repetitivo y automatizable». Intentémoslo. El mayor desafío que sin duda encontrarán es la complejidad. Al pensar en la automatización, hay dos ejes. Por un lado, el número total de pasos en el flujo de trabajo, y por otro, el número de variaciones en cada paso. Una variación es, en realidad, una bifurcación en el camino. Me gusta este diagrama de la derecha porque puede convertirse rápidamente en un problema exponencial al intentar resolver demasiadas iteraciones o variaciones posibles de un proceso determinado. Hay que ponerse en la piel del usuario y preguntarse: ¿es manejable? Y si no lo es, ¿qué se puede hacer para que lo sea? Se pueden eliminar las variaciones mediante la estandarización, como ya mencionamos, o diciendo: "Oye, este caso extremo no va a estar respaldado por este análisis de datos".
Incluso puedes añadir un mensaje de error, como verás en tu flujo de trabajo. También puedes eliminar pasos con la automatización. A esto me refería: a que el usuario tome el control. Si hay un paso de control de calidad muy artesanal y único, puedes pausar el flujo de trabajo, dejar que el usuario haga lo que necesite y luego reanudarlo. Tienes varias opciones para considerar, pero sin duda, planificar te beneficiará al pensar en la automatización. En nuestro caso, estábamos analizando estos procesos de placas, y este es el ejemplo original que di. Si tenemos una sola propagación de placa, tomamos una sola medición, y llamaremos a este proceso "propagación uno".
Cuando empezamos a analizar las diferencias entre los distintos experimentos, nos dimos cuenta de que, a veces, tomábamos dos medidas de esta placa, no solo una. En ocasiones, también medíamos de la primera placa en la propagación en serie. A veces, realizábamos dos mediciones en ambas. Incluso, en ocasiones, separábamos las placas. No se trataba de una relación uno a uno, sino de una a dos o a muchas.
Estamos tomando medidas de esos datos. A veces los dividimos y tomamos medidas diferentes de cada uno. No espero que lleven un registro de esto, pero lo que intento demostrar es que nuestro proceso es muy variable. Aquí solo muestro algunos ejemplos. Tenemos docenas de variaciones diferentes de nuestro proceso. Estábamos analizando la complejidad del proceso en sí, el proceso en nuestros laboratorios que genera los datos. Ni siquiera habíamos empezado a pensar en cuán estandarizado es el método que se utiliza para analizar los datos. ¿Qué pruebas estadísticas se emplean? ¿Se utilizan métricas de resumen o la mediana o la media?
La complejidad puede resultar abrumadora rápidamente, por lo que es importante realizar una investigación exhaustiva de antemano. En lo que hemos estado trabajando, y esto aún está en desarrollo, ya está implementado, pero lo estamos mejorando continuamente. Otra recomendación es determinar cuál es el mínimo indispensable para ser útil y luego obtener retroalimentación frecuente del usuario final. Desarrollamos este enfoque generalizado para nuestro análisis de planos.
Este es un flujo de trabajo más complejo. Ajustamos los datos directamente desde nuestra base de datos y le pedimos al usuario que los filtre según el experimento específico que busca. Procesamos los datos, corregimos tipos de datos, convenciones de nomenclatura y garantizamos la coherencia. Dividimos los datos según este proceso. Observamos la propagación serial. Necesitamos saber qué medición corresponde a cada placa. Realizamos comprobaciones para determinar si se trata de un proceso que no admitimos o de una medición que no es compatible con esta automatización. Si es así, generamos un error y mostramos un mensaje al usuario. Procesamos más datos mediante la creación de tablas dinámicas. Incluso ofrecemos al usuario la opción de agregar datos sin conexión. Es posible que los usuarios tengan anotaciones manuales de sus genotipos. Finalmente, generamos un conjunto de visualizaciones y análisis predeterminados.
Para explicarlo mejor, les mostraré cómo se ve. Aquí, como les mostré, estamos en el proyecto. Tenemos el contenido de nuestro espacio de trabajo. Tenemos nuestro diario. Tenemos nuestro registro aquí abajo. Voy a cerrar el registro porque no lo necesitamos para la demostración y está ocupando espacio valioso en la pantalla.
Pero aquí tenemos nuestro flujo de trabajo. He intentado que estos pasos sean lo más fáciles de entender posible, para que comprendan la función de cada uno. También pueden ver que pueden activar o desactivar pasos, en este caso, para esta conferencia. Solo importamos datos estáticos porque no nos conectaremos a las bases de datos de nuestra empresa para obtener datos experimentales reales. Aquí tenemos los datos sin procesar. También verán algunas de estas puertas lógicas, ¿verdad? Son estas instrucciones condicionales (if/out) que permiten tener interruptores lógicos o diferentes rutas, diferentes bifurcaciones en la fila para indicar: si los datos tienen este formato, hacer esto; si no, hacer aquello.
Voy a ejecutarlo. Estamos importando los datos. Tengo aquí una observación un tanto indirecta, que es solo un poco... Se pueden mostrar pequeñas ventanas emergentes para dar retroalimentación al usuario. Dije: «Genial. Solo tienes medidas de la medida B para tus placas de PC, ¿verdad? Es lo único que permitimos. Buen trabajo». Hicieron clic en «Aceptar». El proceso continúa. Ahora les mostramos una pregunta: «¿Te gustaría unir metadatos creados manualmente?».
Normalmente, estos son datos de genotipo para este conjunto de datos. En la primera ejecución, simplemente pulso "no". En realidad, no tengo ningún dato ahí. Es como decir: "Vale, vamos a procesarlo". Ahora que hemos generado los datos y hemos procesado todo, tenemos todas las marcas de verificación verdes. Aquí a la izquierda, verás varias tablas de datos, así como algunas visualizaciones predeterminadas del rendimiento y la normalización que estamos realizando en las placas para la selección de cepas.
Ahora, lo realmente interesante aquí es que, al pulsar este botón de reinicio, se cierra todo lo que el flujo de trabajo había abierto y se reinicia al principio. Ya lo he reiniciado. Como ven, hemos vuelto al diario y a las flechitas del principio. Puedo volver a ejecutarlo. En la misma ventana emergente, voy a decir que sí. Esto me llevará por un camino ligeramente diferente. Voy a decir que sí, que quiero añadir datos manualmente. Ahora aparece otra ventana emergente que pregunta qué columna quiero usar para unir los datos. Voy a usar este número X, que es un identificador único.
Usamos cuatro cepas. Pulsamos Aceptar. El sistema indicará: "No encuentro esto en tu conjunto de datos". Claro, no está, porque son mis propios datos sin conexión. Voy a buscarlos en mi ordenador. En este caso, los he guardado en un archivo CSV, y vamos a unirlos, y se ejecutará el script. Como puedes ver, llegamos al mismo resultado. Tenemos esta normalización. Tenemos esta visualización de diagrama de caja del Generador de gráficos de la medición. Pero además, hemos añadido información adicional... Están estas columnas, Mutaciones del Promotor, otra información que estaba en los datos sin conexión y que hemos unido a los datos principales, algo que no se había hecho antes.
Estos flujos de trabajo generalizados pueden ser muy potentes. Al publicarlos, también los guardo en un proyecto. Es el flujo de trabajo del proyecto. Aquí incluyo la documentación para el usuario, así como cualquier enlace a otra documentación interna relevante. Un usuario accedería aquí, pulsaría el botón de reproducción, se le solicitaría que introdujera el ID del experimento, lo que modificaría dinámicamente los datos que se cargan, y luego el proceso se ejecutaría.
Como verán, también incluyo algunas opciones para generar errores. Esto se aplica a casos específicos donde no lo admitimos, o quizás se trate de un tipo de experimento inesperado. Otro consejo: si buscan generalizar, tengan en cuenta que, por defecto, muchas de las referencias a tablas y columnas se generan automáticamente. Ya sea que usen un botón de registro o el menú desplegable rojo de la plataforma, estas referencias suelen ser explícitas: indicarán la tabla de datos y la columna. Esto no siempre se adapta bien a la generalización.
Una de las cosas que probablemente tendrás que aprender y modificar manualmente en JSL es sobre las referencias a columnas y tablas de datos: cómo gestionarlas y cómo hacerlas dinámicas. El número de columnas que importo puede variar según los datos que introduzca el usuario, y debo poder gestionarlo. Una vez que te adentres en este ámbito, casi con seguridad tendrás que escribir código JSL. Pero, de nuevo, JMP hará el 90 % del trabajo por ti con gran parte del registro del flujo de trabajo, el registro de eventos, así como con todas las opciones para guardar scripts y los puntos críticos.
Si necesitas escribir código JSL, ¿qué recursos te convienen? He trabajado con muchas herramientas y software de datos, además de varios lenguajes de programación. Los recursos de aprendizaje de JMP son excelentes. De forma nativa, incluye un índice de scripts. Actualmente, puedes usar la ayuda de LLM para solucionar problemas de JSL e incluso para generar código. No creo que sea tan bueno como Python, en parte porque el conjunto de datos de entrenamiento es mucho más pequeño, pero aun así te puede servir para empezar.
Lo realmente incomparable de la comunidad JMP es su participación en los foros. Les comparto un ejemplo de principios de este año. Publiqué una pregunta, y lo que más me llamó la atención fue la hora. La envié a las 7:15 p. m. Jim, un verdadero experto, respondió a las 9:45 p. m. del mismo día. A la mañana siguiente, Mark respondió unas 12 horas después. Recibí dos respuestas de expertos a mis preguntas en menos de 24 horas. Esa ha sido mi experiencia cada vez que publico en el foro.
Un saludo a todos, especialmente a Mark y Jim. Veo sus nombres constantemente, pero la verdad es que todos en los foros los usan. Son invaluables para el aprendizaje. Dicho esto, quiero concluir y animarlos a que busquen dentro de su organización, sus equipos, sus laboratorios, sea cual sea su trabajo, oportunidades de alto impacto donde puedan aplicar la automatización generalizada. En nuestro caso, vimos un área donde dedicábamos horas por experimento, ejecutando más de 50 experimentos de ese tipo durante un mes. Eso representaba todo el tiempo de una persona procesando esos datos.
Una vez que te comprometes con eso, gestionas y planificas la complejidad, nos encontramos con mucha variabilidad en nuestro diseño experimental y en nuestro proceso de selección de placas. Abordamos esto ofreciendo opciones al usuario, restringiendo la información que admitimos en los informes y aprovechando la interfaz de usuario de JMP para decir: "A partir de aquí, la decisión es tuya". Puedes visualizarlo como quieras. Esto lleva a implementar flujos de trabajo avanzados, lo que puede eliminar tareas repetitivas y también servir para estandarizar el análisis. Creo que lo que he visto a menudo es que nos gusta estandarizar las cosas, pero cuando se trata de análisis de datos, lo consideramos un proceso artesanal.
Hay algo de cierto en eso, pero también existen oportunidades para establecer buenas prácticas. ¿Cómo deberíamos analizar estos datos? ¿Cuál es la prueba estadística adecuada para las características que presentan? Esto nos permite codificarlas en un flujo de trabajo como el de JMP.
