Hola a todos,

Hace unos días vi a un youtuber hablando de cómo crear una red neuronal (en español)

En resumen, utiliza la red neuronal para aprender a convertir grados Celsius a grados Fahrenheit.
Grados Fahrenheit= (Grados  Celsius × 9/5) +32

En este vídeo utiliza Python para crear la red neuronal, donde crea una tabla con los valores de grados Celsius y grados Fahrenheit.
Luego hace 1000 entrenamientos al modelo que ha creado, cuando consulta la predicción a un valor que no está en la tabla que ha utilizado para entrenar, le da un valor correcto (o bastante cercano).

Hola Comunidad,

En este artículo, os demostraré los siguientes pasos para crear vuestro propio chatbot utilizando spaCy (spaCy es una biblioteca de software de código abierto para el procesamiento avanzado del lenguaje natural, escrita en los lenguajes de programación Python y Cython):

• Paso 1: Instalar las librerías necesarias

• Paso2: Crear el archivo de patrones y respuestas

• Paso 3: Entrenar el modelo

• Paso 4: Crear una aplicación ChatBot basada en el modelo entrenado

Empecemos

Hola Comunidad,

Nos complace invitaros al próximo concurso de programación online de InterSystems, ¡centrado en Python!

🏆 Concurso InterSystems Python 🏆

Duración: 15 julio - 4 agosto, 2024

Bolsa de premios: $14,000

Teoría de Colisión Confirmada

¡Hola a todos! 

Llevo muchos años trabajando con Excel y, últimamente, lo he enfocado al tratamiento de bases de datos.

Realmente mi experiencia con Excel ha sido para labores financieras, no tanto analíticas de datos en sí, pero en un proyecto reciente he podido trabajar mucho con SQL y me he interesado un poco por el tema (no soy para nada una experta, ¡aviso!)

Me he preguntado cómo podría unir varios excels en uno para, por ejemplo, entregárselo al Data Análisis utilizando la tecnología InterSystems. He recopilado la información en un pequeño artículo. Espero que sea útil y por supuesto estoy abierta a correcciones. 

Vamos a utilizar InterSystems IRIS. Lo que buscaremos es leer los archivos Excel, procesarlos y por último fusionarlos. 

La idea

Ya estamos en 2024, la version IRIS 2024.1 acaba de salir y todos estamos hablando de ello aquí. Ya tenemos muchos tutoriales sobre búsqueda vectorial y aplicaciones de chats de inteligencia artificial. Hoy quiero proponer algo diferente. Quiero presentar una idea y explorar todos sus límites, y a lo largo del texto plantearé algunas preguntas sobre la capacidad de las herramientas utilizadas, para que luego podamos comprender no solo los resultados de las nuevas funcionalidades, sino también cómo la máquina las procesa.

La idea

Ya estamos en 2024, la versión IRIS 2024.1 acaba de salir y todos estamos hablando de ello aquí. Ya tenemos muchos tutoriales sobre búsqueda vectorial y aplicaciones de chats de inteligencia artificial. Hoy quiero proponer algo diferente. Quiero presentar una idea y explorar todos sus límites, y a lo largo del texto plantearé algunas preguntas sobre la capacidad de las herramientas utilizadas, para que luego podamos comprender no solo los resultados de las nuevas funcionalidades, sino también cómo la máquina las procesa.

Buenos días a todos:

Trabajo en el sector bancario en el área de seguridad. Indagando sobre nuevas tecnologías y posibilidades, he planteado si InterSystems IRIS podría aportar algún valor en el tratamiento de datos. La respuesta es que sí; IRIS permite la centralización de datos y el análisis en tiempo real de los mismos. Además, podríamos beneficiarnos de la interoperabilidad de su tecnología. Si bien es cierto que InterSystems está muy avanzado en el ámbito sanitario, estoy convencido de que sus beneficios podrían aplicarse a otras áreas como la banca.

Principio: Tras dividir el artículo cargado por el usuario en frases mediante Python, se obtiene el valor incrustado y se almacena en la base de datos Iris. A continuación, la similitud entre las frases se compara a través de la búsqueda vectorial Iris, y finalmente se muestra en la página front-end.

Un cliente preguntó recientemente si IRIS soporta OpenTelemetry, dado que estaban buscando medir el tiempo que los servicios SOAP implementados por IRIS tardan en completarse, y  el cliente ya tenía varias otras tecnologías que soportan OpenTelemetry para el seguimiento de procesos.

Como seguramente ya sabréis la mayoría de vosotros, desde aproximadamente finales de 2022 InterSystems IRIS incluyo la funcionalidad de almacenamiento columnar a su base de datos, pues bien, en el artículo de hoy vamos a ponerla a prueba en comparación con el almacenamiento en filas habitual.

Almacenamiento columnar

¿Cuál es la principal característica de este tipo de almacenamiento? Pues bien, si consultamos la documentación oficial veremos esta fantástica tabla que nos explica las principales características de ambos tipos de almacenamiento (por filas o por columnas):

Tenemos un conjunto de datos bastante apetecible con recetas escritas por múltiples usuarios de Reddit, sin embargo, la mayor parte de la información está en texto libre en forma de título y descripción de un mensaje. Vamos a averiguar cómo podemos, de forma muy sencilla, cargar los datos, extraer algunas características y analizarlos empleando funcionalidades de LLM (Large Language Model) de OpenAI desde Python Embebido y el framework Langchain.

Cargar los datos

Lo primero es lo primero: ¿necesitamos cargar los datos o podemos sencillamente conectarnos a ellos?

Hay diferentes formas para plantearlo: por ejemplo, con el Mapeo de registros CSV que puedes utilizar en una producción de interoperabilidad o incluso instalar directamente una aplicación de OpenExchange como csvgen para que nos ayude.

Utilizaremos en este caso las Foreign Tables. Una funcionalidad muy útil para proyectar datos físicamente almacenados en otra parte y tenerlos accesibles desde el SQL de IRIS. Podemos utilizarlo directamente para echar un primer vistazo a los ficheros del conjunto de datos.

Creamos un Foreign Server:

CREATE FOREIGN SERVER dataset FOREIGN DATA WRAPPER CSV HOST '/app/data/'

Y a continuación, creamos una Foreign Table que se conecta al fichero CSV:

CREATE FOREIGN TABLE dataset.Recipes (
  CREATEDDATE DATE,
  NUMCOMMENTS INTEGER,
  TITLE VARCHAR,
  USERNAME VARCHAR,
  COMMENT VARCHAR,
  NUMCHAR INTEGER
) SERVER dataset FILE 'Recipes.csv' USING
{
  "from": {
    "file": {
       "skip": 1
    }
  }
}

¡Y ya está!, inmediatamente podemos lanzar consultas SQL sobre dataset.Recipes:

## ¿Qué datos necesitamos? Los datos son muy interesantes y tenemos hambre. Sin embargo, si queremos decidir qué receta vamos a cocinar necesitamos algo más de información que podamos utilizar para analizar las recetas.

Vamos a trabajar con dos clases persistentes (tablas):

• yummy.data.Recipe: una clase que contiene el título y la descripción de la receta así como algunas otras propiedades que queremos extraer y analizar (por ejemplo: Score, Difficulty, Ingredients, CuisineType, PreparationTime).
• yummy.data.RecipeHistory: una clase sencilla para anotar un registro de qué estamos haciendo con la receta.

Podemos ahora cargar en nuestras tablas yummy.data* el contenido del conjunto de datos de recetas:

do ##class(yummy.Utils).LoadDataset()

Hasta aquí tiene buena pinta, pero aún debemos averiguar cómo vamos a generar los datos para los campos como: Score, Difficulty, Ingredients, PreparationTime and CuisineType.

## Analizar las recetas Queremos procesar el título y la descripción de cada receta y:

• Extraer información como Difficulty, Ingredients, CuisineType, etc.
• Construir nuestra propia puntuación de la receta basada en nuestro criterio, de forma que podamos decidir qué vamos a cocinar.

Vamos a utilizar lo siguiente:

• yummy.analysis.Analysis - una estructura genérica de análisis que vamos a re-utilizar en caso de que queramos implementar diferentes tipos de análisis.
• yummy.analysis.SimpleOpenAI - un análisis que usa Python Embebido + framework Langchain + OpenAI LLM.

Los LLM (Large Language Models) son una herramienta realmente increíble para procesar lenguaje natural.

LangChain está preparado para trabajar con Python, así que podemos utilizarlo directamente en InterSystems IRIS a través de Embedded Python.

La clase SimpleOpenAI tiene esta pinta:

/// Simple OpenAI analysis for recipes
Class yummy.analysis.SimpleOpenAI Extends Analysis
{

Property CuisineType As %String;

Property PreparationTime As %Integer;

Property Difficulty As %String;

Property Ingredients As %String;

/// Run
/// You can try this from a terminal:
/// set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8))
/// do a.Run()
/// zwrite a
Method Run()
{
    try {
        do ..RunPythonAnalysis()

        set reasons = ""

        // mis estilos de cocina favoritos
        if "spanish,french,portuguese,italian,korean,japanese"[..CuisineType {
            set ..Score = ..Score + 2
            set reasons = reasons_$lb("It seems to be a "_..CuisineType_" recipe!")
        }

        // no quiero estar el día entero cocinando :)
        if (+..PreparationTime < 120) {
            set ..Score = ..Score + 1
            set reasons = reasons_$lb("You don't need too much time to prepare it") 
        }
        
        // bonus para mis ingredientes favoritos!
        set favIngredients = $listbuild("kimchi", "truffle", "squid")
        for i=1:1:$listlength(favIngredients) {
            set favIngred = $listget(favIngredients, i)
            if ..Ingredients[favIngred {
                set ..Score = ..Score + 1
                set reasons = reasons_$lb("Favourite ingredient found: "_favIngred)
            }
        }

        set ..Reason = $listtostring(reasons, ". ")

    } catch ex {
        throw ex
    }
}

/// Update recipe with analysis results
Method UpdateRecipe()
{
    try {
        // call parent class implementation first
        do ##super()

        // add specific OpenAI analysis results
        set ..Recipe.Ingredients = ..Ingredients
        set ..Recipe.PreparationTime = ..PreparationTime
        set ..Recipe.Difficulty = ..Difficulty
        set ..Recipe.CuisineType = ..CuisineType

    } catch ex {
        throw ex
    }
}

/// Run analysis using embedded Python + Langchain
/// do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8)).RunPythonAnalysis(1)
Method RunPythonAnalysis(debug As %Boolean = 0) [ Language = python ]
{
    # load OpenAI APIKEY from env
    import os
    from dotenv import load_dotenv, find_dotenv
    _ = load_dotenv('/app/.env')

    # account for deprecation of LLM model
    import datetime
    current_date = datetime.datetime.now().date()
    # date after which the model should be set to "gpt-3.5-turbo"
    target_date = datetime.date(2024, 6, 12)
    # set the model depending on the current date
    if current_date > target_date:
        llm_model = "gpt-3.5-turbo"
    else:
        llm_model = "gpt-3.5-turbo-0301"

    from langchain.chat_models import ChatOpenAI
    from langchain.prompts import ChatPromptTemplate
    from langchain.chains import LLMChain

    from langchain.output_parsers import ResponseSchema
    from langchain.output_parsers import StructuredOutputParser

    # init llm model
    llm = ChatOpenAI(temperature=0.0, model=llm_model)

    # prepare the responses we need
    cuisine_type_schema = ResponseSchema(
        name="cuisine_type",
        description="What is the cuisine type for the recipe? \
                     Answer in 1 word max in lowercase"
    )
    preparation_time_schema = ResponseSchema(
        name="preparation_time",
        description="How much time in minutes do I need to prepare the recipe?\
                     Anwer with an integer number, or null if unknown",
        type="integer",
    )
    difficulty_schema = ResponseSchema(
        name="difficulty",
        description="How difficult is this recipe?\
                     Answer with one of these values: easy, normal, hard, very-hard"
    )
    ingredients_schema = ResponseSchema(
        name="ingredients",
        description="Give me a comma separated list of ingredients in lowercase or empty if unknown"
    )
    response_schemas = [cuisine_type_schema, preparation_time_schema, difficulty_schema, ingredients_schema]

    # get format instructions from responses
    output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
    format_instructions = output_parser.get_format_instructions()
    
    analysis_template = """\
    Interprete and evaluate a recipe which title is: {title}
    and the description is: {description}
    
    {format_instructions}
    """
    prompt = ChatPromptTemplate.from_template(template=analysis_template)

    messages = prompt.format_messages(title=self.Recipe.Title, description=self.Recipe.Description, format_instructions=format_instructions)
    response = llm(messages)

    if debug:
        print("======ACTUAL PROMPT")
        print(messages[0].content)
        print("======RESPONSE")
        print(response.content)

    # populate analysis with results
    output_dict = output_parser.parse(response.content)
    self.CuisineType = output_dict['cuisine_type']
    self.Difficulty = output_dict['difficulty']
    self.Ingredients = output_dict['ingredients']
    if type(output_dict['preparation_time']) == int:
        self.PreparationTime = output_dict['preparation_time']

    return 1
}

}

El método RunPythonAnalysis es donde sucede todo lo relativo a OpenAI :). Puedes probarlo directamente desde tu terminal utilizando una receta en particular:

do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)

Obtendremos un resultado como el siguiente:

USER>do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)
======ACTUAL PROMPT
                    Interprete and evaluate a recipe which title is: Folded Sushi - Alaska Roll
                    and the description is: Craving for some sushi but don't have a sushi roller? Try this easy version instead. It's super easy yet equally delicious!
[Video Recipe](https://www.youtube.com/watch?v=1LJPS1lOHSM)
# Ingredients
Serving Size:  \~5 sandwiches      
* 1 cup of sushi rice
* 3/4 cups + 2 1/2 tbsp of water
* A small piece of konbu (kelp)
* 2 tbsp of rice vinegar
* 1 tbsp of sugar
* 1 tsp of salt
* 2 avocado
* 6 imitation crab sticks
* 2 tbsp of Japanese mayo
* 1/2 lb of salmon  
# Recipe     
* Place 1 cup of sushi rice into a mixing bowl and wash the rice at least 2 times or until the water becomes clear. Then transfer the rice into the rice cooker and add a small piece of kelp along with 3/4 cups plus 2 1/2 tbsp of water. Cook according to your rice cookers instruction.
* Combine 2 tbsp rice vinegar, 1 tbsp sugar, and 1 tsp salt in a medium bowl. Mix until everything is well combined.
* After the rice is cooked, remove the kelp and immediately scoop all the rice into the medium bowl with the vinegar and mix it well using the rice spatula. Make sure to use the cut motion to mix the rice to avoid mashing them. After thats done, cover it with a kitchen towel and let it cool down to room temperature.
* Cut the top of 1 avocado, then slice into the center of the avocado and rotate it along your knife. Then take each half of the avocado and twist. Afterward, take the side with the pit and carefully chop into the pit and twist to remove it. Then, using your hand, remove the peel. Repeat these steps with the other avocado. Dont forget to clean up your work station to give yourself more space. Then, place each half of the avocado facing down and thinly slice them. Once theyre sliced, slowly spread them out. Once thats done, set it aside.
* Remove the wrapper from each crab stick. Then, using your hand, peel the crab sticks vertically to get strings of crab sticks. Once all the crab sticks are peeled, rotate them sideways and chop them into small pieces, then place them in a bowl along with 2 tbsp of Japanese mayo and mix until everything is well mixed.
* Place a sharp knife at an angle and thinly slice against the grain. The thickness of the cut depends on your preference. Just make sure that all the pieces are similar in thickness.
* Grab a piece of seaweed wrap. Using a kitchen scissor, start cutting at the halfway point of seaweed wrap and cut until youre a little bit past the center of the piece. Rotate the piece vertically and start building. Dip your hand in some water to help with the sushi rice. Take a handful of sushi rice and spread it around the upper left hand quadrant of the seaweed wrap. Then carefully place a couple slices of salmon on the top right quadrant. Then place a couple slices of avocado on the bottom right quadrant. And finish it off with a couple of tsp of crab salad on the bottom left quadrant. Then, fold the top right quadrant into the bottom right quadrant, then continue by folding it into the bottom left quadrant. Well finish off the folding by folding the top left quadrant onto the rest of the sandwich. Afterward, place a piece of plastic wrap on top, cut it half, add a couple pieces of ginger and wasabi, and there you have it.
                    
                    The output should be a markdown code snippet formatted in the following schema, including the leading and trailing "```json" and "```":
json
{
        "cuisine_type": string  // What is the cuisine type for the recipe?                                  Answer in 1 word max in lowercase
        "preparation_time": integer  // How much time in minutes do I need to prepare the recipe?                                    Anwer with an integer number, or null if unknown
        "difficulty": string  // How difficult is this recipe?                               Answer with one of these values: easy, normal, hard, very-hard
        "ingredients": string  // Give me a comma separated list of ingredients in lowercase or empty if unknown
}

                    
======RESPONSE
json
{
        "cuisine_type": "japanese",
        "preparation_time": 30,
        "difficulty": "easy",
        "ingredients": "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
}

Tiene muy buena pinta. Parece que nuestro prompt o pregunta a OpenAI es capaz de devolvernos información que realmente podemos utilizar. Vamos a ejecutar el análisis completo desde el terminal:

set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12))
do a.Run()
zwrite a

USER>zwrite a
a=37@yummy.analysis.SimpleOpenAI  ; <OREF>
+----------------- general information ---------------
|      oref value: 37
|      class name: yummy.analysis.SimpleOpenAI
| reference count: 2
+----------------- attribute values ------------------
|        CuisineType = "japanese"
|         Difficulty = "easy"
|        Ingredients = "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
|    PreparationTime = 30
|             Reason = "It seems to be a japanese recipe!. You don't need too much time to prepare it"
|              Score = 3
+----------------- swizzled references ---------------
|           i%Recipe = ""
|           r%Recipe = "30@yummy.data.Recipe"
+-----------------------------------------------------

## Analizar todas las recetas Naturalmente, querremos ejecutar el análisis para todas las recetas que hemos cargado.

Puedes analizar un rango de recetas (utilizando sus identificadores), de esta forma:

USER>do ##class(yummy.Utils).AnalyzeRange(1,10)
> Recipe 1 (1.755185s)
> Recipe 2 (2.559526s)
> Recipe 3 (1.556895s)
> Recipe 4 (1.720246s)
> Recipe 5 (1.689123s)
> Recipe 6 (2.404745s)
> Recipe 7 (1.538208s)
> Recipe 8 (1.33001s)
> Recipe 9 (1.49972s)
> Recipe 10 (1.425612s)

Después de eso, vamos a echar un vistazo de nuevo a la tabla de recetas y comprobemos los resultados:

select * from yummy_data.Recipe

Creo que podría intentar la Pizza con calabaza o el Tofu con Kimchi y cerdo al estilo coreano :). De todas formas, debo asegurarme y preguntar en casa antes de empezar a cocinar :)

Conclusión

Puedes encontrar el ejemplo completo en https://github.com/isc-afuentes/recipe-inspector

Con este ejemplo sencillo hemos aprendido cómo utilizar técnicas LLM para extraer características y analizar ciertas partes de nuestros datos en InterSystems IRIS.

Con esto como punto de partida, podrías plantearte cosas como:

• Utilizar InterSystems BI para explorar y navegar tus datos utilizando cubos y cuadros de mando.
• Crear una aplicación web y añadir una interfaz gráfica (e.g. con Angular) para esta aplicación, podrías utilizar paquetes como RESTForms2 para generar automáticamente APIs REST para tus clases persistentes.
• ¿Qué tal si almacenas si una receta te gusta o no, y después intentas determinar si una nueva receta te gustará? Podrías plantearlo con IntegratedML, o incluso con LLM pasándole algunos datos de ejemplo e implementando un caso de uso tipo RAG (Retrieval Augmented Generation).

¿Qué otras cosas se os ocurren?

La invención y popularización de LLMs (Large Language Models) como GPT-4 de OpenAI ha desencadenado una ola de soluciones innovadoras que permiten aprovechar grandes volúmenes de datos no estructurados, que eran prácticamente imposibles de procesar manualmente hasta hace poco. Estas aplicaciones pueden incluir la recuperación de datos (echad un vistazo al curso sobre ML301 de Don Woodlock, con una excelente introducción a la Generación Aumentada de Recuperación), el análisis de sentimientos, e incluso agentes de IA totalmente autónomos, por nombrar sólo algunos ejemplos!

En este artículo, quiero demostrar cómo la funcionalidad de Python Embebido de IRIS puede ser utilizada para interactuar directamente con la librería Python de OpenAI, a través de la creación de una sencilla aplicación de etiquetado de datos que asignará automáticamente palabras clave a los registros que metamos en una tabla de IRIS. Estas palabras clave pueden después ser usadas para buscar y categorizar los datos, así como para analítica de datos. Utilizaré reseñas de productos realizadas por clientes como ejemplo de caso de uso.

Al empezar el desarrollo con IRIS tenemos un kit de distribución o, en el caso de Docker, obtenemos la imagen Docker y después a menudo tenemos que iniciarla y configurar el entorno de desarrollo. Puede que necesitemos crear bases de datos, namespaces, activar/desactivar algunos servicios, crear recursos. Muchas veces necesitamos importar el código y los datos a la instancia de IRIS y ejecutar algún código personalizado para iniciar la solución.

Parece que fue ayer cuando hicimos un pequeño proyecto en Java para probar el rendimiento de IRIS, PostgreSQL y MySQL (podéis revisar el artículo que escribimos allá por Junio al final de este artículo). Si recordáis IRIS se mostró superior a PostgreSQL y claramente superior a MySQL en las inserciones, no habiendo gran diferencia en las consultas.

Poco después @Dmitry Maslennikov me dijo "¿Por qué no pruebas desde un proyecto en Python?" pues bien, aquí está la versión en Python de las pruebas que realizamos mediante las conexiones JDBC previamente.

En este artículo vas a encontrar un sencillo programa con Python en un entorno IRIS y otro sencilloprograma con ObjectScript en un entorno Python. Además, me gustaría compartir algunos de los errores que tuve cuando empecé la implementación de estos códigos.

Python en entorno IRIS

Supongamos, por ejemplo, que estás en un entorno IRIS y quieres resolver un problema que crees más fácil o más eficiente de resolver en Python.

Puedes simplemente cambiar el entorno: crea tu método como cualquier otro, y al final del nombre y sus especificaciones, añade [ Language = python ]:

¿Eres nuevo programando en InterSystems IRIS®? Haz este nuevo curso de formación, y aprende a desarrollar una aplicación con InterSystems ObjectScript, junto con el lenguaje que elijas: Java, .NET, Python o Node.js. 

Ejemplo de demostración para el Gran Premio de Programación de InterSystems, sobre el uso de plantillas más complejas para probar funcionalidades de IA.

Preguntas para la entrevista

Hay documentación. Para un puesto de trabajo, una persona de recursos humanos quiere evaluar rápidamente a los candidatos con varias preguntas técnicas relevantes para el puesto.

¿Puede automatizar el trabajo haciendo una lista de preguntas y respuestas a partir de la documentación disponible?

Continuamos analizando las posibilidades de Django, y su uso con IRIS. En la primera parte de esta serie, mostramos cómo definir modelos y conectarlos con tablas ya existentes en IRIS; en la segunda parte, mostramos un Portal de Administración, con la capacidad de ver qué datos tenemos en esos modelos, con filtros, edición e incluso paginación.

Ahora es el momento de pasar a la acción real - vamos a crear algunas API Rest, en Django, basadas en los mismos datos que usamos antes, del paquete posts-and-tags.

Para hacerlo, usaremos el framework Django REST

El framework Django REST es un potente y flexible kit de herramientas para generar APIs Web.

Algunas razones por las que querrías usar el framework REST:

Planteé una pregunta durante el 3er Gran Premio de Programación.

Quería compartir una observación sobre el uso de PDFs con LangChain.

Al cargar el texto de un PDF, me di cuenta de que había un espacio en algunas de las palabras extraídas.

Por ejemplo (marcado en rojo):

Este artículo es un sencillo ejemplo para probar SqlDatabaseChain pidiéndole a OpenAI cierta información y que escriba consultas SQL sobre una base de datos IRIS.

Quizá despierte el interés de alguno de vosotros.

Muchas gracias a sqlalchemy-iris (autor @Dmitry Maslennikov). Ese proyecto ha sido indispensable para esta prueba. 

El script de este artículo usa la API de OpenAI así que tenedlo en cuenta para no compartir la información de vuestras tablas externamente en el caso de que no queráis hacerlo. Podría llegar a implementarse un modelo local en caso que lo necesitaseis.

Hoy os traigo otro ejemplo de aplicación de LangChain.

Inicialmente buscaba generar una "chain" o cadena para lograr hacer búsquedas dinámicas en la documentación en HTML, pero al final resultó más sencillo utilizar la versión en PDF de la documentación .

Crear un nuevo entorno virtual

mkdir chainpdf

cd chainpdf

python -m venv .

scripts\activate 

pip install openai
pip install langchain
pip install wget
pip install lancedb
pip install tiktoken
pip install pypdf

set OPENAI_API_KEY=[ Your OpenAI Key ]

python

Preparar los documentos

Hemos subido nuevos ejercicios prácticos al Portal de Formación, para que podáis familiarizaros con la arquitectura multi-modelo de InterSystems IRIS. ¿Os animáis a hacer alguno?

Los nuevos ejercicios están disponibles en ObjectScript, Python, Java y .NET.

¡Hola Comunidad!

Para aprender IRIS rápidamente y de forma totalmente autónoma, te ofrezco algunos enlaces que te ayudarán en este precioso paseo en bicicleta lleno de cosas por descubrir: 

¡Hola desarrolladores!

Os invitamos a un nuevo concurso de programación sobre Python:

🏆 Concurso de Programación: Python 🏆

Duración: del 4 al 24 de septiembre, 2023

Total en premios: $13,500

FHIR ha revolucionado la industria de la atención médica al proporcionar un modelo de datos estandarizado para crear aplicaciones y promocionar el intercambio de datos entre diferentes sistemas. El estándar FHIR se basa en enfoques modernos impulsados por APIs, lo que lo hace más accesible para los desarrolladores web y móviles. Sin embargo, interactuar con las API de FHIR aún puede ser un desafío, especialmente cuando se trata de consultar datos usando lenguaje natural.

InterSystems IRIS actualmente limita sus clases a 999 propiedades.

Pero, ¿qué hacer si necesita almacenar más datos por objeto?

Este artículo respondería a esta pregunta (con el apunte adicional de Community Python Gateway y cómo transferir conjuntos de datos amplios a Python).

En realidad, la respuesta es muy simple: InterSystems IRIS actualmente limita las clases a 999 propiedades, pero no a 999 primitivas. La propiedad en InterSystems IRIS puede ser un objeto con 999 propiedades y así sucesivamente; el límite se puede ignorar fácilmente.

1. Interoperability-embedded-python

Esta prueba de concepto pretende mostrar cómo el framework de interoperabilidad de IRIS puede utilizarse con Python Embebido.

1.1. Índice

• 1. Interoperability-embedded-python
  • 1.1. Índice
  • 1.2. Ejemplo
  • 1.3. Registrar un componente
• 2. Demo
• 3. Requisitos previos
• 4. Instalación con Docker
• 5. Instalación sin Docker
• 6. Cómo ejecutar la muestra
• 7. Qué hay dentro del repositorio
  • 7.1. Dockerfile
  • 7.2. .vscode/settings.json
  • 7.3. .vscode/launch.json
  • 7.4. .vscode/extensions.json
  • 7.5. src folder
• 8. Cómo añadir un nuevo componente
  • 8.1. InboundAdapter
  • 8.2. OutboundAdapter
  • 8.3. BusinessService
  • 8.4. BusinessProcess
  • 8.5. BusinessOperation
  • 8.6. Registrar un componente
  • 8.7. Uso directo de Grongier.PEX
• 9. Trabajo futuro
• 10. Créditos

1.2. Ejemplo

import grongier.pex
import iris
import MyResponse

class MyBusinessOperation(grongier.pex.BusinessOperation):

    def OnInit(self):
        print("[Python] ...MyBusinessOperation:OnInit() is called")
        self.LOGINFO("Operation OnInit")
        return

    def OnTeardown(self):
        print("[Python] ...MyBusinessOperation:OnTeardown() is called")
        return

    def OnMessage(self, messageInput):
        if hasattr(messageInput,"_IsA"):
            if messageInput._IsA("Ens.StringRequest"):
                self.LOGINFO(f"[Python] ...This iris class is a Ens.StringRequest with this message {messageInput.StringValue}")
        self.LOGINFO("Operation OnMessage")
        response = MyResponse.MyResponse("...MyBusinessOperation:OnMessage() echos")
        return response

1.3. Registrar un componente

No es necesario código en ObjectScript. Gracias al método Grongier.PEX.Utils.RegisterComponent():

Inicia un Embedded Python Shell:

/usr/irissys/bin/irispython

A continuación, utiliza este método de clase para añadir un nuevo archivo py a la lista de componentes de interoperabilidad.

iris.cls("Grongier.PEX.Utils").RegisterComponent(<ModuleName>,<ClassName>,<PathToPyFile>,<OverWrite>,<NameOfTheComponent>)

por ejemplo:

iris.cls("Grongier.PEX.Utils").RegisterComponent("MyCombinedBusinessOperation","MyCombinedBusinessOperation","/irisdev/app/src/python/demo/",1,"PEX.MyCombinedBusinessOperation")

Esto es un truco, no es para producción.

2. Demo

La producción tiene cuatro componentes en Pure Python:

• Dos Business Services:
  • Grongier.PEX.MyCombinedBusinessService, que envía continuamente mensajes de sincronización a una Business Operation
    • Esos mensajes son objetos de Python en formato JSON y almacenados en Grongier.PEX.Message.
    • Código de Python: src/python/demo/MyCombinedBusinessService.py
• Grongier.PEX.MyBusinessService, que básicamente no hace nada, es un Business Service en bruto que escribe registros de mensajes
  • Código de Python: src/python/demo/MyBusinessService.py
• Dos Business Operations:
  • Grongier.PEX.BusinessOperation, que recibe el mensaje de Grongier.PEX.MyCombinedBusinessService
    • Código de Python: src/python/demo/MyBusinessOperation.py
  • Grongier.PEX.CombinedBusinessOperation, puede recibir el mensaje Ens.StringRequest y la respuesta con Ens.StringResponse
    • Código de Python: src/python/demo/MyCombinedBusinessOperation.py

Nueva traza json para los mensajes nativos de Python:

3. Requisitos previos

Asegúrate de tener instalado git y el escritorio Docker.

4. Instalación con Docker

Clona el repositorio a cualquier directorio local

git clone https://github.com/grongierisc/interpeorability-embedded-python

Abre el terminal en este directorio y ejecuta:

docker-compose build

Ejecuta el contenedor IRIS con tu proyecto:

docker-compose up -d

5. Instalación sin Docker

Instala el grongier_pex-1.0.0-py3-none-any.whl en tu instancia local de iris:

/usr/irissys/bin/irispython -m pip install grongier_pex-1.0.0-py3-none-any.whl

A continuación, carga las clases de ObjectScript:

do $System.OBJ.LoadDir("/opt/irisapp/src","cubk","*.cls",1)

6. Cómo ejecutar el ejemplo

Abre la producción y comienza a utilizarla. Se comenzará a ejecutar el código del ejemplo.

7. Qué hay dentro del repositorio

7.1. Dockerfile

Un dockerfile que instala algunas dependencias de Python (pip, venv) y sudo en el contenedor por conveniencia. Después, crea el directorio dev y copia el repositorio git.

Inicia IRIS e importa los archivos csv de Titanic, después activa %Service_CallIn para Python Shell. Utiliza el docker-compose.yml relacionado para configurar fácilmente parámetros adicionales como el número de puerto y dónde mapear contraseñas y carpetas del host.

Este dockerfile termina con la instalación de los requisitos para los módulos de python.

La última parte es sobre la instalación de Jupyter Notebook y sus kernels.

Utiliza el archivo .env/ para ajustar el dockerfile que se utiliza en docker-compose.

7.2. .vscode/settings.json

Archivo de configuración para poder codificar en VSCode con el plugin VSCode ObjectScript

7.3. .vscode/launch.json

Archivo de configuración si quieres depurar con VSCode ObjectScript

Lee sobre todos los archivos en este artículo

7.4. .vscode/extensions.json

Archivo de recomendación para añadir extensiones si quieres ejecutar VSCode en el contenedor.

Más información aquí

Esto es muy útil para trabajar con Python Embebido.

7.5. src folder

src
├── Grongier
│   └── PEX // ObjectScript classes that wrap python code
│       ├── BusinessOperation.cls
│       ├── BusinessProcess.cls
│       ├── BusinessService.cls
│       ├── Common.cls
│       ├── Director.cls
│       ├── InboundAdapter.cls
│       ├── Message.cls
│       ├── OutboundAdapter.cls
│       ├── Python.cls
│       ├── Test.cls
│       └── Utils.cls
├── PEX // Some example of wrapped classes
│   ├── MyBusinessOperationWithAdapter.cls
│   ├── MyBusinessOperationWithIrisAdapter.cls
│   ├── MyBusinessOperationWithPythonAdapter.cls
│   ├── MyBusinessService.cls
│   ├── MyOutboundAdapter.cls
│   └── Production.cls
└── python
    ├── demo // Actual python code to run this demo
    │   ├── MyBusinessOperation.py
    │   ├── MyBusinessOperationWithAdapter.py
    │   ├── MyBusinessOperationWithIrisAdapter.py
    │   ├── MyBusinessProcess.py
    │   ├── MyBusinessService.py
    │   ├── MyCombinedBusinessOperation.py
    │   ├── MyCombinedBusinessProcess.py
    │   ├── MyCombinedBusinessService.py
    │   ├── MyInboundAdapter.py
    │   ├── MyLoggingOperation.py
    │   ├── MyNonPollingStarter.py
    │   ├── MyOutboundAdapter.py
    │   ├── MyRequest.py
    │   ├── MyResponse.py
    │   ├── MySyncBusinessProcess.py
    │   └── SimpleObject.py
    ├── dist // Wheel used to implement python interoperability components
    │   └── grongier_pex-1.0.0-py3-none-any.whl
    ├── grongier
    │   └── pex // Helper classes to implement interoperability components
    │       ├── _BusinessHost.py
    │       ├── _BusinessOperation.py
    │       ├── _BusinessProcess.py
    │       ├── _BusinessService.py
    │       ├── _Common.py
    │       ├── _Director.py
    │       ├── _InboundAdapter.py
    │       ├── _Message.py
    │       ├── _OutboundAdapter.py
    │       └── __init__.py
    └── setup.py // setup to build the wheel

8. Cómo añadir un nuevo componente

8.1. InboundAdapter

Para implementar InboundAdapter en Python:

Subclase de grongier.pex.InboundAdapter en Python. Sobreescribe el método OnTask().

8.2. OutboundAdapter

Para implementar OutboundAdapter en Python:

Subclase de grongier.pex.OutboundAdapter en Python. Implementar los métodos de acción requeridos.

8.3. BusinessService

Para implementar BusinessService en Python:

Subclase de grongier.pex.BusinessService en Python. Sobreescribe el método OnProcessInput().

8.4. BusinessProcess

Para implementar BusinessProcess en Python:

Subclase de grongier.pex.BusinessProcess en Python. Sobreescribe los métodos OnRequest(), OnResponse() y OnComplete().

8.5. BusinessOperation

Para implementar BusinessOperation en Python:

Subclase de grongier.pex.BusinessOperation en Python. Sobreescribe el método OnMessage().

8.6. Registrar un componente

Iniciar un Embedded Python Shell:

/usr/irissys/bin/irispython

A continuación, utiliza este método de clase para añadir un nuevo archivo py a la lista de componentes de interoperabilidad.

iris.cls("Grongier.PEX.Utils").RegisterComponent(<ModuleName>,<ClassName>,<PathToPyFile>,<OverWrite>,<NameOfTheComponent>)

por ejemplo:

iris.cls("Grongier.PEX.Utils").RegisterComponent("MyCombinedBusinessOperation","MyCombinedBusinessOperation","/irisdev/app/src/python/demo/",1,"PEX.MyCombinedBusinessOperation")

8.7. Uso directo de Grongier.PEX

Si no quieres utilizar la utilidad RegisterComponent. Puedes añadir un componente Grongier.PEX.Business* y configurar las propiedades:

• %module :
• Nombre del módulo correspondiente a tu código de python
• %classname :
• Nombre de la clase de tu componente
• %classpaths
• Ruta donde se encuentra tu componente.
• Puede ser una o más Rutas de clase (separadas por el carácter '|') necesarias además de PYTHON_PATH

Por ejemplo:

9. Trabajo futuro

• Solo se ha probado Service y Operation.
• Trabajo en curso sobre el adaptador

10. Créditos

La mayor parte del código procede de PEX para Python, de Mo Cheng y Summer Gerry.

La parte del registro procede del formulario de características no liberado de IRIS 2021.3.

Hemos tratado de llamar desde AWS Sage Maker datos directo desde IRIS usando pyodbc pero AWS no podemos instalar el driver de IRIS en Sage Maker alguien sabe como instalarlo? o tiene el drive/libraría?

¡Hola Comunidad!

Me alegra anunciar la nueva versión de iris-pex-embedded-python (v2.3.1) con una nueva interfaz de línea de comandos.

Esta línea de comandos se llama iop por Interoperability On Python.

Primero me gustaría presentar los principales cambios del proyecto desde la versión 1.

Breve historia del proyecto

La versión 1.0 fue una prueba de concepto para mostrar cómo el framework de interoperabilidad de IRIS se puede utilizar con un enfoque python first mientras sigue siendo compatible con cualquier código existente de ObjectScript.

¿Qué significa eso? Significa que cualquier desarrollador Python puede usar el framework de interoperabilidad de IRIS sin ningún conocimiento de ObjectScript.

Ejemplo:

from grongier.pex import BusinessOperation

class MyBusinessOperation(BusinessOperation):

    def on_message(self, request):
        self.log.info("Received request")

Genial, ¿cierto?

Con la versión 1.1, añadí la posibilidad de registrar esas clases de Python en IRIS con una función auxiliar.

from grongier.pex import Utils

Utils.register_file("/src/MyBusinessOperation.py")

La versión 2.0 fue una versión major porque podías instalar el proyecto directamente con pip.

pip install iris-pex-embedded-python

Novedades de la versión 2.3.1

La versión 2.3.1 es también una versión major porque introduce una nueva interfaz de línea de comandos.

Esta interfaz de línea de comandos se puede utilizar con este proyecto de Python basado en este módulo o quizá con proyectos que no utilicen este módulo.

Permitidme presentarla y explicar por qué se puede utilizar en proyectos que no son de Python.

La interfaz de línea de comandos

La línea de comandos forma parte de este proyecto. Para instalarla, solo hay que instalar el proyecto con pip.

pip install iris-pex-embedded-python

Después, se puede usar la línea de comandos iop para iniciar el framework de interoperabilidad.

iop

salida:

usage: iop [-h] [-d DEFAULT] [-l] [-s START] [-k] [-S] [-r] [-M MIGRATE] [-e EXPORT] [-x] [-v] [-L]
optional arguments:
  -h, --help            display help and default production name
  -d DEFAULT, --default DEFAULT
                        set the default production
  -l, --lists           list productions
  -s START, --start START
                        start a production
  -k, --kill            kill a production (force stop)
  -S, --stop            stop a production
  -r, --restart         restart a production
  -M MIGRATE, --migrate MIGRATE
                        migrate production and classes with settings file
  -e EXPORT, --export EXPORT
                        export a production
  -x, --status          status a production
  -v, --version         display version
  -L, --log             display log

default production: UnitTest.Production

Vamos a ver algunos ejemplos.

help

El comando help muestra la ayuda y el nombre de producción predeterminado.

iop -h

salida:

usage: python3 -m grongier.pex [-h] [-d DEFAULT] [-l] [-s START] [-k] [-S] [-r] [-M MIGRATE] [-e EXPORT] [-x] [-v] [-L]
...
default production: PEX.Production

default

El comando default especifica la producción predeterminada.

Sin parámetros, muestra la producción predeterminada.

iop -d

salida:

default production: PEX.Production

Con un parámetro, especifica la producción predeterminada.

iop -d PEX.Production

lists

El comando lists enumera las producciones.

iop -l

salida:

{
    "PEX.Production": {
        "Status": "Stopped",
        "LastStartTime": "2023-05-31 11:13:51.000",
        "LastStopTime": "2023-05-31 11:13:54.153",
        "AutoStart": 0
    }
}

start

El comando start inicia una producción.

Para salir del comando, hay que pulsar CTRL+C.

iop -s PEX.Production

Si no se da un parámetro, el comando start inicia la producción predeterminada.

iop -s

salida:

2021-08-30 15:13:51.000 [PEX.Production] INFO: Starting production
2021-08-30 15:13:51.000 [PEX.Production] INFO: Starting item Python.FileOperation
2021-08-30 15:13:51.000 [PEX.Production] INFO: Starting item Python.EmailOperation
...

kill

El comando kill finaliza una producción (force stop).

El comando Kill es el mismo que el comando stop, pero con un force stop.

El comando Kill no utiliza parámetros porque sólo se puede estar ejecutando una producción.

iop -k 

stop

El comando stop detiene una producción.

El comando Stop no toma un parámetro porque solo se puede estar ejecutando una producción.

iop -S 

restart

El comando restart reinicia una producción.

El comando restart no utiliza parámetros porque solo se puede estar ejecutando una producción.

iop -r 

migrate

El comando migrate migra una producción y clases con el archivo de configuración.

El comando migrate debe tomar la ruta absoluta del archivo de configuración.

El archivo de configuración debe estar en la misma carpeta que el código Python.

iop -M /tmp/settings.py

export

El comando export exporta una producción.

Si no se da un parámetro, el comando export exporta la producción predeterminada.

iop -e

Si se da un parámetro, el comando export exporta la producción dada en el parámetro.

iop -e PEX.Production

salida:

{
    "Production": {
        "@Name": "PEX.Production",
        "@TestingEnabled": "true",
        "@LogGeneralTraceEvents": "false",
        "Description": "",
        "ActorPoolSize": "2",
        "Item": [
            {
                "@Name": "Python.FileOperation",
                "@Category": "",
                "@ClassName": "Python.FileOperation",
                "@PoolSize": "1",
                "@Enabled": "true",
                "@Foreground": "false",
                "@Comment": "",
                "@LogTraceEvents": "true",
                "@Schedule": "",
                "Setting": [
                    {
                        "@Target": "Adapter",
                        "@Name": "Charset",
                        "#text": "utf-8"
                    },
                    {
                        "@Target": "Adapter",
                        "@Name": "FilePath",
                        "#text": "/irisdev/app/output/"
                    },
                    {
                        "@Target": "Host",
                        "@Name": "%settings",
                        "#text": "path=/irisdev/app/output/"
                    }
                ]
            }
        ]
    }
}

status

El comando status muestra el estado de una producción.

El comando status no toma un parámetro porque solo se puede estar ejecutando una producción.

iop -x 

salida:

{
    "Production": "PEX.Production",
    "Status": "stopped"
}

Los estados pueden ser:

• stopped (parado)
• running (ejecutándose)
• suspended (suspendido)
• troubled (con problemas)

version

El comando version muestra la versión.

iop -v

salida:

2.3.0

log

El comando log muestra el log.

Para salir del comando hay que pulsar CTRL+C.

iop -L

salida:

2021-08-30 15:13:51.000 [PEX.Production] INFO: Starting production
2021-08-30 15:13:51.000 [PEX.Production] INFO: Starting item Python.FileOperation
2021-08-30 15:13:51.000 [PEX.Production] INFO: Starting item Python.EmailOperation
...

¿Se puede utilizar fuera del proyecto iris-pex-embedded-python?

Esa es vuestra elección.

Pero me gustaría explicaros por qué creo que se puede utilizar fuera del proyecto iris-pex-embedded-python.

Primero, porque puede interactuar con producción sin la necesidad de usar un iris shell. Eso significa que es más fácil de usar en un script.

En segundo lugar, porque settings.py se puede utilizar para importar producción y clases con variables de entorno.

Este es un ejemplo de settings.py :

import os

PRODUCTIONS = [
        {
            'UnitTest.Production': {
                "Item": [
                    {
                        "@Name": "Python.FileOperation",
                        "@ClassName": "Python.FileOperation",
                        "Setting": {
                            "@Target": "Host",
                            "@Name": "%settings",
                            "#text": os.environ['SETTINGS']
                        }
                    }
                ]
            }
        } 
    ]

Prestad atención al valor #text. Es una variable de entorno. Genial, ¿verdad?

¿Os gustaría usar esta herramienta de línea de comandos? ¿Merece la pena seguir desarrollándola?

Gracias por leer el artículo y espero vuestros comentarios.