En el panorama de datos actual, las empresas enfrentan una serie de desafíos diferentes. Uno de ellos es realizar análisis sobre una capa de datos unificada y armonizada disponible para todos los consumidores. Una capa que puede ofrecer las mismas respuestas a las mismas preguntas independientemente del dialecto o herramienta que se utilice.
InterSystems IRIS Data Platform responde a esto con un complemento de Adaptive Analytics que puede ofrecer esta capa semántica unificada. Hay muchos artículos en DevCommunity sobre su uso a través de herramientas de BI. Este artículo cubrirá la parte de cómo consumirlo con IA y también cómo recuperar algunos conocimientos.
Vayamos paso a paso...

¿Qué es el Análisis Adaptativo?

Puedes encontrar fácilmente alguna definición en el sitio web de la comunidad de desarrolladores
En pocas palabras, puede entregar datos en forma estructurada y armonizada a varias herramientas de su elección para su posterior consumo y análisis. Ofrece las mismas estructuras de datos a varias herramientas de BI. Pero... ¡también puede ofrecer las mismas estructuras de datos a sus herramientas de IA/ML!

Adaptive Analytics tiene un componente adicional llamado AI-Link que construye este puente entre la IA y la BI.

¿Qué es exactamente AI-Link?

Es un componente de Python que está diseñado para permitir la interacción programática con la capa semántica con el fin de optimizar las etapas clave del flujo de trabajo de aprendizaje automático (ML) (por ejemplo, ingeniería de funciones).

Con AI-Link puedes:

• acceder mediante programación a funciones de su modelo de datos analíticos;
• realizar consultas, explorar dimensiones y medidas;
• alimenta las canalizaciones de ML; ... y devolver los resultados a su capa semántica para que otros los consuman nuevamente (por ejemplo, a través de Tableau o Excel).

Como se trata de una biblioteca de Python, se puede utilizar en cualquier entorno de Python. Incluyendo cuadernos.
Y en este artículo daré un ejemplo sencillo de cómo llegar a la solución Adaptive Analytics de Jupyter Notebook con la ayuda de AI-Link.

Aquí está el repositorio de git que tendrá el Notebook completo como ejemplo: https://github.com/v23ent/aa-hands-on

Requisitos previos

Los pasos adicionales suponen que se han completado los siguientes requisitos previos:

1. Solución de Analytics Adaptable en funcionamiento (con IRIS Data Platform como Data Warehouse)
2. Jupyter Notebook en funcionamiento
3. Se puede establecer conexión entre 1. y 2.

Paso 1: Configuración

Primero, instalemos los componentes necesarios en nuestro entorno. Esto descargará algunos paquetes necesarios para que funcionen los pasos siguientes.
'atscale': este es nuestro paquete principal para conectarnos
'profeta' - paquete que necesitaremos para hacer predicciones

pip install atscale prophet

Luego necesitaremos importar clases clave que representen algunos conceptos clave de nuestra capa semántica.
Cliente - clase que usaremos para establecer una conexión con Adaptive Analytics;
Proyecto: clase para representar proyectos dentro de Adaptive Analytics;
DataModel - clase que representará nuestro cubo virtual;

from atscale.client import Client
from atscale.data_model import DataModel
from atscale.project import Project
from prophet import Prophet
import pandas as pd 

Paso 2: Conexión

Ahora deberíamos estar listos para establecer una conexión con nuestra fuente de datos.

client = Client(server='http://adaptive.analytics.server', username='sample')
client.connect()

Continúe y especifique los detalles de conexión de su instancia de Adaptive Analytics. Una vez que se le solicite la organización, responda en el cuadro de diálogo y luego ingrese su contraseña de la instancia de AtScale.

Con la conexión establecida, deberás seleccionar tu proyecto de la lista de proyectos publicados en el servidor. Obtendrá la lista de proyectos como un mensaje interactivo y la respuesta debe ser el ID entero del proyecto. Y luego el modelo de datos se selecciona automáticamente si es el único.

project = client.select_project()   
data_model = project.select_data_model()

Paso 3: Explora tu conjunto de datos

Hay varios métodos preparados por AtScale en la biblioteca de componentes AI-Link. Permiten explorar el catálogo de datos que tiene, consultar datos e incluso recuperar algunos datos. La documentación de AtScale tiene una extensa referencia de API que describe todo lo que está disponible.
Primero veamos cuál es nuestro conjunto de datos llamando a algunos métodos de data_model:

data_model.get_features()
data_model.get_all_categorical_feature_names()
data_model.get_all_numeric_feature_names()

La salida debería verse así

Una vez que hayamos mirado un poco a nuestro alrededor, podemos consultar los datos reales que nos interesan utilizando el método 'get_data'. Devolverá un DataFrame de pandas que contiene los resultados de la consulta.

df = data_model.get_data(feature_list = ['Country','Region','m_AmountOfSale_sum'])
df = df.sort_values(by='m_AmountOfSale_sum')
df.head()

Que mostrará tu datadrame:

Preparemos un conjunto de datos y mostrémoslo rápidamente en el gráfico

import matplotlib.pyplot as plt

# We're taking sales for each date
dataframe = data_model.get_data(feature_list = ['Date','m_AmountOfSale_sum'])

# Create a line chart
plt.plot(dataframe['Date'], dataframe['m_AmountOfSale_sum'])

# Add labels and a title
plt.xlabel('Days')
plt.ylabel('Sales')
plt.title('Daily Sales Data')

# Display the chart
plt.show()

Producción:

Paso 4: Predicción

El siguiente paso sería obtener algo de valor del puente AI-Link. ¡Hagamos una predicción simple!

# Load the historical data to train the model
data_train = data_model.get_data(
    feature_list = ['Date','m_AmountOfSale_sum'],
    filter_less = {'Date':'2021-01-01'}
    )
data_test = data_model.get_data(
    feature_list = ['Date','m_AmountOfSale_sum'],
    filter_greater = {'Date':'2021-01-01'}
    )

Aquí obtenemos 2 conjuntos de datos diferentes: para entrenar nuestro modelo y probarlo.

# For the tool we've chosen to do the prediction 'Prophet', we'll need to specify 2 columns: 'ds' and 'y'
data_train['ds'] = pd.to_datetime(data_train['Date'])
data_train.rename(columns={'m_AmountOfSale_sum': 'y'}, inplace=True)
data_test['ds'] = pd.to_datetime(data_test['Date'])
data_test.rename(columns={'m_AmountOfSale_sum': 'y'}, inplace=True)

# Initialize and fit the Prophet model
model = Prophet()
model.fit(data_train)

Y luego creamos otro marco de datos para acomodar nuestra predicción y mostrarla en el gráfico

# Create a future dataframe for forecasting
future = pd.DataFrame()
future['ds'] = pd.date_range(start='2021-01-01', end='2021-12-31', freq='D')

# Make predictions
forecast = model.predict(future)
fig = model.plot(forecast)
fig.show()

Producción:

Paso 5: Reescritura

Una vez que tengamos nuestra predicción en su lugar, podemos volver a colocarla en el almacén de datos y agregar un agregado a nuestro modelo semántico para reflejarlo para otros consumidores. La predicción estaría disponible a través de cualquier otra herramienta de BI para analistas de BI y usuarios empresariales.
La predicción en sí se colocará en nuestro almacén de datos y se almacenará allí.

from atscale.db.connections import Iris

db = Iris(

    username,

    host,

    namespace,

    driver,

    schema, 

    port=1972,

    password=None, 

    warehouse_id=None

    )

data_model.writeback(dbconn=db,

                    table_name= 'SalesPrediction',

                    DataFrame = forecast)

data_model.create_aggregate_feature(dataset_name='SalesPrediction',

                                    column_name='SalesForecasted',

                                    name='sum_sales_forecasted',

                                    aggregation_type='SUM')

Aleta

¡Eso es!
¡Buena suerte con tus predicciones!