Cette balise regroupe les discussions sur le développement de solutions analytiques et de Business Intelligence, la visualisation, la gestion des KPI et autres métriques d'entreprise.
InterSystems est à l'avant-garde de la technologie des bases de données depuis sa création, en étant à l'origine d'innovations qui surpassent régulièrement ses concurrents comme Oracle, IBM et Microsoft. En se concentrant sur une conception de noyau efficace et en adoptant une approche sans compromis des performances des données, InterSystems s'est taillé une place de choix dans les applications critiques, garantissant fiabilité, rapidité et évolutivité.
Une histoire d'excellence technique
L'essor des projets Big Data, des analyses en libre-service en temps réel, des services de recherche en ligne et des réseaux sociaux, entre autres, a donné naissance à des scénarios de requête de données massives et très performantes. En réponse à ce défi, la technologie MPP (base de données de traitement hautement parallèle) a été créée et s'est rapidement imposée. Parmi les options MPP open-source, Presto (https://prestodb.io/) est la plus connue. Cette solution a vu le jour au sein de Facebook et a été utilisée pour l'analyse de données, avant d'être mise à disposition en libre accès. Cependant, depuis que Teradata a rejoint la communauté Presto, elle offre désormais un support.
Presto se connecte aux sources de données transactionnelles (Oracle, DB2, MySQL, PostgreSQL, MongoDB et autres bases de données SQL et NoSQL) et fournit un traitement de données SQL distribué et en mémoire, combiné à des optimisations automatiques des plans d'exécution. Son objectif est avant tout d'exécuter des requêtes rapides, que vous traitiez des gigaoctets ou des téraoctets de données, en mettant à l'échelle et en parallélisant les charges de travail.
Presto n'avait pas à l'origine de connecteur natif pour la base de données IRIS, mais heureusement, ce problème a été résolu avec un projet communautaire d'InterSystems "presto-iris"(https://openexchange.intersystems.com/package/presto-iris). C'est pourquoi nous pouvons maintenant exposer une couche MPP devant les référentiels IRIS d'InterSystems pour permettre des requêtes, des rapports et des tableaux de bord de haute performance à partir de données transactionnelles dans IRIS.
Dans cet article, nous suivrons un guide étape par étape pour configurer Presto, le connecter à IRIS et établir une couche MPP pour vos clients. Nous démontrerons également les principales fonctionnalités de Presto, ses commandes et outils principaux, toujours avec IRIS en tant que base de données source.
Les caractéristiques de Presto comprennent les fonctionnalités suivantes:
Vous trouverez ci-dessous une liste des avantages offerts par Apache Presto:
Opérations SQL spécialisées;
Installation et débogage faciles;
Abstraction de stockage simple;
Évolutivité rapide des données en pétaoctets avec une faible latence.
InterSystems IRIS et Presto offrent ensemble les possibilités d'utilisation suivantes:
InterSystems IRIS est un partenaire idéal pour Presto. Comme il s'agit d'un référentiel de données à haute performance qui supporte le traitement distribué à l'aide de shards et associé aux opérateurs Presto, n'importe quel volume de données peut être interrogé en seulement quelques millisecondes.
Il y a plusieurs options (Docker et Java JAR) pour l'installation de Presto. Vous pouvez trouver plus de détails à ce sujet sur https://prestodb.io/docs/current/installation/deployment.html. Dans cet article, nous utiliserons Docker. Pour faciliter la connaissance et permettre un démarrage rapide, nous avons mis à disposition un exemple d'application sur Open Exchange (il a été dérivé d'un autre logiciel https://openexchange.intersystems.com/package/presto-iris). Suivez les étapes suivantes pour vous en faire une idée:
docker-compose up -d --buildCi-dessus, vous pouvez voir l'interface web de Presto pour surveiller et gérer les requêtes. On peut y accéder à partir du numéro de port spécifié dans les propriétés de configuration du coordinateur (pour cet article, le numéro de port est 8080).
Le fichier Dockerfile est utilisé pour créer une image Docker PrestoDB avec le plugin presto-iris et le fichier JDBC InterSystems IRIS inclus:
# Image officielle de PrestoDB sur Docker HubFROM prestodb/presto
# À partir de https://github.com/caretdev/presto-iris/releases# Ajout du plugin presto-iris dans l'image DockerADDhttps://github.com/caretdev/presto-iris/releases/download/0.1/presto-iris-0.1-plugin.tar.gz /tmp/presto-iris/presto-iris-0.1-plugin.tar.gz
# À partir de https://github.com/intersystems-community/iris-driver-distribution# Ajout du pilote IRIS JDBC dans l'image DockerADDhttps://raw.githubusercontent.com/intersystems-community/iris-driver-distribution/refs/heads/main/JDBC/JDK18/com/intersystems/intersystems-jdbc/3.8.4/intersystems-jdbc-3.8.4.jar /opt/presto-server/plugin/iris/intersystems-jdbc-3.8.4.jar
RUN --mount=type=bind,src=.,dst=/tmp/presto-iris
tar -zxvf /tmp/presto-iris/presto-iris-0.1-plugin.tar.gz -C /opt/presto-server/plugin/iris/ --strip-components=1
Ce fichier crée 3 instances de conteneurs : une instance pour InterSystems IRIS (service IRIS), une instance pour PrestoDB (service Presto) et une instance pour Superset (service Superset). Le Superset est un outil de visualisation analytique utilisé pour afficher des données dans des tableaux de bord.
# à partir du projet https://github.com/caretdev/presto-irisservices:# création d'une instance de conteneur InterSystems IRIS iris: image:intersystemsdc/iris-community ports: -1972 -52773 environment: IRIS_USERNAME:_SYSTEM IRIS_PASSWORD:SYS# création d'une instance de conteneur PrestoDB qui utilise la base de données IRIS presto: build:. volumes:# PrestoDB utilisera iris.properties pour obtenir des informations sur la connexion -./iris.properties:/opt/presto-server/etc/catalog/iris.properties ports: -8080:8080# création d'une instance de conteneur Superset (Outil d'analyse du tableau de bord) superset: image:apache/superset:3.0.2 platform:linux/amd64 environment: SUPERSET_SECRET_KEY:supersecret# création d'une connexion InterSystems IRIS pour le chargement des échantillons de données SUPERSET_SQLALCHEMY_EXAMPLES_URI:iris://_SYSTEM:SYS@iris:1972/USER volumes: -./superset_entrypoint.sh:/superset_entrypoint.sh -./superset_config.py:/app/pythonpath/superset_config.py ports: -8088:8088 entrypoint:/superset_entrypoint.shCe fichier contient les informations nécessaires pour connecter PrestoDB à InterSystems IRIS DB et créer une couche MPP pour des requêtes performantes et évolutives à partir des tableaux de bord Superset.
# from the project https://github.com/caretdev/presto-iris
connector.name=iris
connection-url=jdbc:IRIS://iris:1972/USER
connection-user=_SYSTEM
connection-password=SYSCe script installe la bibliothèque superset-iris (pour le support d'IRIS par Superset), démarre l'instance Superset et charge des échantillons de données dans la base de données InterSystems IRIS. Au moment de l'exécution, les données consommées par Superset proviendront de PrestoDB, qui sera une couche MPP pour IRIS DB.
#!/bin/bash
# Installation de l'extension InterSystems IRIS Superset
pip install superset-iris
superset db upgrade
superset fab create-admin
--username admin
--firstname Superset
--lastname Admin
--email admin@superset.com
--password ${ADMIN_PASSWORD:-admin}
superset init
# Téléchargement d'échantillons dans IRIS
superset load-examples
# Modification de l'URI de la base de données d'échantillons en Presto
superset set-database-uri -d examples -u presto://presto:8080/iris
/usr/bin/run-server.sh
Il s'agit d'une plateforme moderne d'exploration et de visualisation des données qui peut remplacer ou renforcer les outils propriétaires de veille stratégique pour de nombreuses équipes.Superset s'intègre parfaitement à une grande variété de sources de données.
Superset offre les avantages suivants:
Préférez-vous ne pas lire? Regardez la vidéo de démonstration que j'ai créée:
<iframe allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/-OwOAHC5b3s" width="640"></iframe>
En tant que développeur d'interfaces, je reçois souvent des questions qui nécessitent d'étudier de grandes quantités de messages. Par exemple, lors d'une réunion récente, notre chef de projet m'a demandé combien de sites utilisaient réellement notre nouvelle interface de commandement.
D'habitude, j'essaie de copier la sortie de la visionneuse de messages pour la coller dans Excel ou simplement d'exécuter un rapport de messages pour chaque site qui passe des commandes et d'utiliser le nombre de messages renvoyés…
Cette fois-ci, en utilisant l'extension de navigateur Iris Whiz browser extension j'avais des options.
Option 1 - Simple: Exportation de CSV
Une idée mise en œuvre à partir du portail InterSystems Ideas, il suffit de cliquer sur le bouton Export (Exporter) en tant que CSV dans la barre de boutons d'IRIS Whiz pour télécharger la recherche en cours en tant que fichier CSV pour une manipulation facile d'Excel/Sheets.
Option 2 - Chic: Analyse
Dans ce cas, je venais de compléter l'outil d'analyse dans mon extension de navigateur Iris Whiz.
En ajoutant la valeur PV1-3.2 à mes critères de recherche de messages dans la visionneuse de messages (Message Viewer), j'ai pu facilement exécuter le rapport, cliquer sur Analyse et avoir instantanément les renseignements sous la forme d'un simple diagramme en forme de beignet - aucune exportation n'a été nécessaire.
Ensuite, le chef de projet a voulu savoir quels types d'examens étaient commandés par ces sites. J'ai ajouté la valeur OBR-4.2 à mes critères de recherche et j'ai relancé le rapport. En cliquant sur le bouton d'analyse, j'ai pu voir les sites qui passaient commande et les examens commandés. (Chaque critère de recherche de message est présenté sous la forme d'un graphique en anneau, étiqueté à la fin de la partie graphique de la page d'analyse)
La troisième question se pose.
Quelles commandes sont passées par quels sites?
En cliquant sur le site voulu dans le graphique interactif en anneau, j'ai pu visualiser les données dans la visionneuse de données de la page d'analyse. Un autre clic sur le bouton de filtrage à l'intérieur de cette boîte applique cette sélection de données comme filtre à tous les graphiques - ce qui signifie que le graphique en anneau des examens ne montre plus que les examens commandés pour ce site.
Graphique de site et graphique d'examen filtré par site:
Et enfin, la question la plus difficile.
Quand tout cela se produit-il?
Passer en revue les messages dans la page de visualisation des messages pour voir quand les commandes sont passées n'est pas une bonne idée...
Heureusement, j'ai ajouté une chronologie à la page d'analyse.
J'ai supprimé le filtre et cliqué sur le bouton 'Show on Line Graph' (Affichage du graphique linéaire) (activé pour le graphique PV1-3 dans la capture d'écran ci-dessus) afin d'afficher les données du site sur le graphique chronologique en haut de la page.
Une rapide capture d'écran nous a permis d'envoyer ce rapport à nos sites afin qu'ils puissent confirmer le nombre de commandes pour chaque jour et s'assurer que tout fonctionnait comme prévu.
Ces rapports devaient être exécutés chaque semaine, mais heureusement pour moi, cette tâche avait été simplifiée, notamment grâce à la fonction de recherche sauvegardée dans la page de visualisation des messages, qui me permettait de ne jamais avoir à me soucier des critères de recherche à ajouter.
Conclusions
1. Données sensibles:
Les données de votre recherche dans la visionneuse de messages (Message Viewer) sont envoyées dans un nouvel onglet du navigateur et disparaissent dès que l'onglet est fermé - vous n'avez donc pas à vous soucier de l'enregistrement de données sensibles dans le navigateur. Si vous souhaitez enregistrer un rapport utilisez la fonctionnalité par défaut d'InterSystems pour les recherches enregistrées et exécutez simplement le rapport à nouveau à une date ultérieure. J'avais prévu un mécanisme d'enregistrement des recherches à partir de la page d'analyse, mais il n'a pas été retenu dans cette version.
2. Vitesse:
La page d'analyse est alimentée par la recherche de messages et je n'ai pas mis de limites strictes à la quantité de données pouvant être affichées. Plus vous ajoutez de messages et de critères de recherche, plus la page d'analyse ralentira. C'est pourquoi j'ai ajouté une fenêtre contextuelle si vous essayez de charger plus de 200 messages, ce qui vous permet de choisir de charger ou non le diagramme à barres en haut de la page.
Le diagramme à barres présente chaque message sous la forme d'une case à sélectionner. En cliquant sur une case du diagramme, le message est ajouté à la liste des messages sélectionnés dans la fenêtre de visualisation des données (à gauche de la page). Vous pouvez alors cliquer sur le bouton 'View Selected Messages' (Voir les messages sélectionnés) pour ouvrir ces messages dans une nouvelle page et profiter des fonctionnalités de comparaison des messages de l'extension.
Lorsque vous cliquez sur ce bouton, essayez de ne pas sélectionner trop de messages. Un maximum de 10 devrait suffire.
Si vous téléchargez le diagramme à barres avec de grands ensembles de données (10 000), cela ne sera certainement pas bon pour votre navigateur, mais je vous laisse le soin de choisir.
Dans le paysage actuel des données, les activités commerciales sont confrontées à différents défis. L'un d'entre eux consiste à réaliser des analyses à partir d'une couche de données unifiée et harmonisée, accessible à tous les utilisateurs. Une couche capable de fournir les mêmes réponses aux mêmes questions, indépendamment du dialecte ou de l'outil utilisé. La plate-forme de données InterSystems IRIS répond à cette question en ajoutant la solution 'Adaptive Analytics' (Analyse adaptative) qui peut fournir cette couche sémantique unifiée. Il y a beaucoup d'articles dans DevCommunity sur l'utilisation de cette couche sémantique via des outils décisionnels. Cet article couvrira la partie concernant la façon de l'utiliser avec l'IA et également la façon d'obtenir des informations en retour. Allons-y étape par étape...
Vous pouvez facilement trouver une définition sur le site web de la Communauté de développeurs. En quelques mots, elle peut fournir des données sous une forme structurée et harmonisée à divers outils de votre choix pour une utilisation et une analyse ultérieures. Elle fournit les mêmes structures de données à différents outils décisionnels. Mais... elle peut également fournir les mêmes structures de données à vos outils IA/ML!
Adaptive Analytics a un composant supplémentaire appelé AI-Link qui construit ce pont entre l'IA et d'informatique décisionnelle.
Il s'agit d'un composant Python conçu pour permettre une interaction programmatique avec la couche sémantique dans le but de rationaliser les étapes clés du flux de travail de l'apprentissage automatique (ML) (par exemple, l'ingénierie des fonctionnalités).
Avec AI-Link, vous pouvez:
Comme il s'agit d'une bibliothèque Python, elle peut être utilisée dans n'importe quel environnement Python. Y compris les Notebooks. Dans cet article, je vais donner un exemple simple pour atteindre une solution d'analyse adaptative à partir d'un Notebook Jupyter avec l'aide d'AI-Link.
Voici le référentiel git qui aura le Notebook complet à titre d'exemple : https://github.com/v23ent/aa-hands-on
Les étapes suivantes supposent que vous ayez rempli les conditions préalables ci-dessous:
Tout d'abord, installons les composants nécessaires dans notre environnement. Ainsi, nous téléchargerons quelques paquets nécessaires au bon déroulement des étapes suivantes. 'atscale' - c'est notre paquetage principal pour se connecter 'prophet' - c'est le paquet dont nous aurons besoin pour faire des prédictions.
pip install atscale prophet
Ensuite, nous devons importer des classes clés représentant certains concepts clés de notre couche sémantique. Client - c'est la classe que nous utiliserons pour établir une connexion avec Adaptive Analytics; Project - c'est la classe qui représente les projets à l'intérieur d'Adaptive Analytics; DataModel - c'est la classe qui représentera notre cube virtuel;
from atscale.client import Client
from atscale.data_model import DataModel
from atscale.project import Project
from prophet import Prophet
import pandas as pd
Maintenant, nous devrions être prêts à établir une connexion avec notre source de données.
client = Client(server='http://adaptive.analytics.server', username='sample')
client.connect()
Continuez et spécifiez les détails de connexion de votre instance d'Adaptive Analytics. Lorsque l'on vous demande l'organisation, répondez dans la boîte de dialogue et entrez votre mot de passe de l'instance AtScale.
Une fois la connexion établie, vous devrez sélectionner votre projet dans la liste des projets publiés au serveur. Vous obtiendrez la liste des projets sous la forme d'une invite interactive et la réponse devrait être l'identifiant entier du projet. Le modèle de données est ensuite sélectionné automatiquement s'il est le seul.
project = client.select_project()
data_model = project.select_data_model()
Il existe un certain nombre de méthodes préparées par AtScale dans la bibliothèque de composants AI-Link. Elles permettent d'explorer votre catalogue de données, d'interroger les données et même d'ingérer des données en retour. La documentation d'AtScale a une référence API complète décrivant tout ce qui est disponible. Voyons d'abord quel est notre jeu de données en appelant quelques méthodes de data_model :
data_model.get_features()
data_model.get_all_categorical_feature_names()
data_model.get_all_numeric_feature_names()
Le résultat devrait ressembler à ceci
Après avoir examiné un peu la situation, nous pouvons interroger les données qui nous intéressent à l'aide de la méthode 'get_data'. Elle renverra un pandas DataFrame contenant les résultats de la requête.
df = data_model.get_data(feature_list = ['Country','Region','m_AmountOfSale_sum'])
df = df.sort_values(by='m_AmountOfSale_sum')
df.head()
Ce qui affichera votre trame de données:
Préparons un ensemble de données et affichons-le rapidement sur le graphique
import matplotlib.pyplot as plt
# Nous enregistrons des ventes pour chaque date
dataframe = data_model.get_data(feature_list = ['Date','m_AmountOfSale_sum'])
# Création d'un graphique linéaire
plt.plot(dataframe['Date'], dataframe['m_AmountOfSale_sum'])
# Ajout des étiquettes et d'un titre
plt.xlabel('Days')
plt.ylabel('Sales')
plt.title('Daily Sales Data')
# Affichage du graphique
plt.show()
Résultat:
La prochaine étape consistera à tirer profit du pont AI-Link - faisons quelques prédictions simples!
# Chargement des données historiques pour l'entraînement du modèle
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'}
)
Nous disposons ici de 2 jeux de données différents: pour entraîner notre modèle et pour le tester.
# Pour l'outil que nous avons choisi pour faire la prédiction 'Prophète' ,nous devrons spécifier 2 colonnes: 'ds' et '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)
# Initialisation et ajustement du modèle Prophet
model = Prophet()
model.fit(data_train)
Et puis nous créons une autre trame de données pour accueillir notre prédiction et l'afficher sur le graphique
# Création d'une trame de données prochaine pour la prévision
future = pd.DataFrame()
future['ds'] = pd.date_range(start='2021-01-01', end='2021-12-31', freq='D')
# Prédictions
forecast = model.predict(future)
fig = model.plot(forecast)
fig.show()
Résultat:
Une fois notre prédiction en place, nous pouvons la renvoyer à l'entrepôt de données et ajouter un agrégat à notre modèle sémantique afin de la refléter pour d'autres utilisateurs. La prédiction serait disponible via n'importe quel autre outil décisionnel pour les analystes décisionnels et les utilisateurs commerciaux. La prédiction elle-même sera placée dans notre entrepôt de données et y sera stockée.
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')
C'est ça! Bonne chance avec vos prédictions!
Imaginons la scène. Vous travaillez tranquillement au sein de Widgets Direct, le premier détaillant de Widgets et d'accessoires pour Widgets sur Internet. Votre patron vous annonce une nouvelle désastreuse : certains clients ne sont peut-être pas satisfaits de leurs widgets et nous avons besoin d'une application d'assistance pour assurer le suivi de ces réclamations. Pour rendre les choses plus intéressantes, il veut que cette application ait une très faible empreinte de code et vous demande de livrer une application en moins de 150 lignes de code à l'aide d'InterSystems IRIS. Est-ce possible?
Avertissement : cet article présente la construction d'une application très basique et omet, par souci de concision, des éléments de détail tels que la Sécurité et la Gestion des erreurs. Cette application ne doit être utilisée qu'à titre de référence ni pour une application de production. Cet article utilise IRIS 2023.1 comme plate-forme de données, certaines fonctionnalités décrites ne sont pas disponibles dans les versions antérieures
Nous commençons par définir un nouvel espace de noms propre - avec une base de données de codes et de données. Bien que tout soit regroupé dans une seule base de données, il est utile de diviser ces bases pour permettre l'actualisation des données.
.png)
Notre système d'assistance a besoin de 3 classes de base : un objet Ticket qui peut contenir des actions pour documenter les interactions entre un conseiller du personnel UserAccount et un contact client UserAccount. Définissons ces classes avec quelques propriétés de base:
.png)
.png)
.png)
19 lignes de code – et nous avons notre modèle de données complet! Nous avons défini 2 classes comme Persistent afin qu'elles puissent être sauvegardées dans la base de données, et nous héritons également de %JSON.Adapter, ce qui nous permet d'importer et d'exporter très facilement nos objets au format JSON. En guise de test, nous configurons notre premier utilisateur dans Terminal, nous le sauvegardons et nous vérifions que l'application JSONExport fonctionne correctement
.png)
Tout cela semble bon. Le patron nous a laissé un fichier csv avec une liste d'employés et de clients. Nous pourrions écrire un code pour analyser ce fichier et le charger, mais y a-t-il un moyen plus simple?
InterSystems IRIS fournit une instruction de chargement de données (LOAD DATA) simple à utiliser en SQL qui permet de télécharger facilement des données à partir d'un fichier CSV, y compris les options permettant d'analyser les en-têtes et de renommer les champs. Utilisons-la pour télécharger notre table d'utilisateurs:
.png)
Nous pouvons utiliser les étiquettes d'en-tête pour extraire ces données et les télécharger dans la base de données de la manière suivante:
.png)
Les 300 lignes ont été importées en une seule commande. Les 4 lignes supplémentaires de code portent notre compte courant à 23 lignes de code écrites. Nous pouvons rapidement vérifier que ces enregistrements sont corrects avec une sélection SQL de base
.png)
Nous avons maintenant nos données de départ, construisons donc quelques API de base pour permettre à un front-end d'être connecté. Nous construirons notre API comme un service REST qui sert et accepte JSON.
InterSystems IRIS fournit un support REST natif par le biais de l'héritage de la classe %CSP.REST, nous allons donc créer une classe REST.Dispatch et hériter de %CSP.REST. Cette classe est composée de deux sections: une UrlMap XData qui associe les URL et les Verbes aux méthodes, et les méthodes qui sont appelées par ces Urls.
Notre Produit minimum viable nécessite 4 opérations: la récupération de la liste des utilisateurs pour le personnel ou les clients, la récupération des derniers tickets collectés, la récupération d'un ticket unique par son numéro d'identification, et enfin la création d'un nouveau ticket. Nous définissons nos verbes, et puis les méthodes.
.png)
GetUserList est un Curseur de base SQL intégré qui fournit les données directement en JSON. Nous pouvons alors analyser ces données avec la fonctionnalité JSON native, les placer dans un tableau JSON et les servir en tant que corps de la réponse. Nous passons la variable "staff" de l'URL directement à la requête pour modifier le contexte des données.
.png)
TicketSummary est presque identique, mais la requête accède alors à la table des tickets
.png)
TicketSummary est le service le plus simple. Nous ouvrons l'objet par ID, et écrivons le %JSONExport intégré à la sortie. Si l'objet ne se charge pas, alors nous écrivons un paquet d'erreurs
.png)
Enfin, notre méthode d'UploadTicket est la plus complexe. Nous devons lire le payload de l'objet de la requête, l'analyser en JSON, puis l'appliquer à une nouvelle instance de Ticket en utilisant %JSONImport. Nous définissons également l'OpenDate et l'OpenTime à partir de l'heure actuelle, au lieu de les attendre en entrée. Après une sauvegarde réussie, nous renvoyons la représentation JSON de l'objet, ou si l'objet ne se télécharge pas, nous renvoyons une erreur.
.png)
Avec ces services, nous ajoutons 60 lignes de code supplémentaires à notre total. Nous atteignons maintenant un total de 89 lignes de code pour cette application
Nous devons maintenant créer une application Web sous Sécurité>Applications. Celle-ci doit être définie comme une application de type REST, et le NOMCLASSE (Classname) doit être défini comme la classe de répartition (Dispatch) que nous venons de créer (Remarque: vous devrez accorder un rôle de sécurité approprié à cette application afin qu'elle puisse accéder au code et aux données). Après avoir sauvegardé, les services REST peuvent maintenant être appelés à partir de l'URL que vous avez définie
.png)
Nous pouvons appeler l'UserList pour vérifier
.png)
Nous sommes maintenant prêts à créer des données. Utilisons notre client REST pour envoyer un payload au service de création de tickets. Nous fournissons un mot-clé, une description, un conseiller (Advisor) et un contact (Contact), et nous recevons en retour le fichier JSON du ticket que nous avons créé, y compris l'OpenDate et le TicketId
.png)
.png)
Nous avons maintenant notre Produit minimum viable. En utilisant un constructeur de formulaire frontal de notre choix, nous pouvons maintenant envoyer et recevoir des informations sur les tickets via nos services REST.
Vous avez maintenant construit une application de ticketing de base en seulement 89 lignes de code écrites. Votre patron doit être impressionné? Oui, mais il a de mauvaises nouvelles. Vous avez oublié une exigence. Widgets Direct a un contrat spécial avec les régions francophones et tous les billets rédigés en français doivent être envoyés à Mme Bettie Francis pour un premier examen. Heureusement, vous avez un collègue qui a suivi l'excellent article de Robert Luman "Sur la prise en charge du langage naturel par Python" ("Python Natural Language Support") et qui a créé un service REST capable d'accepter un échantillon de texte et d'en identifier la langue. Pouvons-nous utiliser l'Interopérabilité d'InterSystems IRIS pour appeler ce service et mettre automatiquement à jour le conseiller de Mme Francis lorsque le texte est en français?
Nous devons commencer par la création de Classes de messages afin d'avoir un moyen d'envoyer et de recevoir nos demandes. Nous avons besoin d'une requête qui contiendra l'identifiant du ticket et le texte de l'échantillon, et d'une réponse qui renverra le Code de la langue et la Description. Ceux-ci hériteront d' Ens. Request et d'Ens. Response
.png)
.png)
6 autres lignes de code écrites nous permettent d'atteindre 95 LOC. Nous devons maintenant créer notre opération, qui enverra la requête au service de votre collègue et récupérera la réponse. Nous définissons une opération Outbound, avec des propriétés pour le serveur et l'URL, et nous les exposons à la configuration de l'utilisateur en les incluant dans le paramètre SETTINGS. Cela nous permettra de mettre facilement à jour la requête si le chemin d'accès au serveur change. Nous créons une méthode d'aide pour configurer une requête HTTPRequest, puis nous l'utilisons pour appeler le service et remplir notre réponse
.png)
.png)
27 lignes de code supplémentaires nous amènent à plus de 100, nous avons maintenant 122 lignes écrites. Nous devons maintenant configurer cette classe dans notre production Ensemble. Nous devons maintenant configurer cette classe dans notre production Ensemble. Accédez à la configuration de la production sous Interopérabilité, et cliquez sur Ajouter (Add) sous l'En-tête Opérations (Operations Header). Configurez votre opération avec le nom de la classe et un nom d'affichage
.png)
Nous pouvons ensuite cliquer dessus pour accéder aux paramètres (Settings), entrer le nom du serveur et l'URL et activer l'Opération.
.png)
Nous avons maintenant besoin d'une deuxième opération qui prend l'identifiant d'un ticket et associe le conseiller à l'identifiant d'un compte d'utilisateur fourni. Nous avons besoin à la fois d'un message et d'une classe d'opération, mais dans ce cas, nous ne renverrons pas de réponse, l'opération exécutera la tâche sans feedback
.png)
Les 12 lignes de code supplémentaires nous amènent à 134 lignes écrites. Nous pouvons ajouter cette Opération à la Production de la même manière que nous avons ajouté le Service linguistique (Language Service), mais dans ce cas, nous n'avons pas de configuration à définir.
Nous avons ensuite besoin d'un routeur capable d'appeler le service, d'évaluer la réponse et, éventuellement, d'appeler l'Opération du conseiller français (French Advisor Operation). Nous allons vers Interoperability>Build>BusinessProcess et accédons à l'outil de création de règles visuelles. Nous définissons d'abord nos contextes pour la requête (Request) et la réponse (Response) et nous ajoutons un élément d'appel (Call). Nous définissons nos entrées et nos sorties sur les classes de messages que nous avons créées, puis nous mappons les entrées à l'aide du générateur de requêtes. Assurez-vous que l'option "Asynchrone" (Asynchronous) n'est pas cochée, car nous voulons attendre la réponse avant de continuer.
.png)
.png)
Nous ajoutons ensuite un élément "Si" (If) pour évaluer le code de langue renvoyé. S'il s'agit de "fr", nous voulons faire appel à l'opération de FrenchAdvisor
.png)
Mme Francis est l'utilisateur ID 11, nous configurons donc notre objet d'appel (Call object) pour qu'il fournisse notre message AdvisorUpdate au service FrenchAdvisor, et nous utilisons le constructeur de requêtes pour transmettre le TicketID et une valeur fixe de 11 au paramètre Advisor
.png)
.png)
Nous pouvons maintenant l'ajouter à la Production en cliquant sur Ajouter (Add) sous l'en-tête Processus, en sélectionnant la classe et en lui donnant un nom d'affichage "FrenchRouter".
Nous avons maintenant notre routage en place. Nous avons juste besoin d'un service pour rechercher les nouveaux tickets et les envoyer au routeur pour traitement. Nous définissons une classe de service basée sur un adaptateur SQL de la manière suivante (en ajoutant 8 lignes de code supplémentaires à notre compte):
.png)
Nous l'ajoutons ensuite à notre production comme nous l'avons fait avec les objets Operation et Process. Nous devons configurer l'adaptateur SQL. Nous fournissons les détails de connexion via un DSN de type ODBC à la base de données locale, ainsi qu'une requête SQL de base que le Service utilisera pour interroger les tickets sur un minuteur défini dans le paramètre d'intervalle d'appel CallInterval. Cette requête est associée au paramètre Key Field Name qui définit la clé unique de la requête et empêche le renvoi d'enregistrements déjà envoyés
.png)
Avec ceci en place, nous avons maintenant une production complète qui va scanner les nouveaux tickets, passer le texte à un service externe pour analyser la langue, et éventuellement réinitialiser le conseiller en fonction de la réponse. Essayons cela! Nous commençons par envoyer une requête en anglais, qui nous est retournée sous la forme TicketId 70. Nous attendons une seconde, et accédons à cet enregistrement via le service GetTicket REST, ici le conseiller est inchangé par rapport à la requête originale
.png)
.png)
Répétons l'opération avec le texte en français (French Text)
.png)
Lorsque nous réclamons le ticket 71, notre conseiller a été changé en Mme Francis, comme nous nous y attendions! Nous pouvons le vérifier dans l'Interoperability en localisant le message dans Visual Trace, et en vérifiant que les Opérations ont été appelées comme prévu.
.png)
.png)
Nous en sommes maintenant à 142 lignes de code écrites, et nous avons une application d'InterSystems IRIS qui persiste les données, les a chargées en utilisant LOAD DATA, fournit une API REST de base pour la visualisation et l'édition des données, et un moteur d'intégration avancé fournissant un Support de décision basé sur des appels à un service REST externe. Assurément, personne ne peut demander mieux?
Votre application est un succès retentissant et les données affluent. L'accès à ces données précieuses nécessite une certaine expertise, et la direction de Widgets Direct souhaite obtenir des informations. Est-il possible de fournir un accès interactif aux données?
Grâce à InterSystems IRIS Analytics, nous pouvons fournir un accès facile et rapide à des outils de manipulation de données évolués. Nous devons d'abord activer le support Analytics sur notre application web interne:
.png)
Cela nous permet d'utiliser la section Analytics par rapport à notre Espace de noms. Commencez par ouvrir Analytics>Architect. Sélectionnez Nouveau (New) et remplissez le formulaire pour créer un Cube d'analyse pour la classe de tickets.
.png)
Ensuite, nous pouvons configurer nos dimensions et une liste déroulante Drilldown à l'aide du constructeur Visual Builder. Cette vue est accessible par glisser-déposer. Une liste peut également être créée à l'aide d'un constructeur visuel simple, afin de personnaliser ce que l'utilisateur voit lorsqu'il interroge un point de données
.png)
.png)
Une fois la configuration de base établie, nous pouvons Sauvegarder, Compiler et Construire le Cube. Cela permettra de configurer tous les indices et d'activer le Cube pour l'analyse dans le logiciel Analyzer. Ouvrez l'Analyzer pour commencer à jouer avec les données. Dans l'exemple présenté, nous pouvons facilement comparer les conseillers par rapport à une hiérarchie d'années et de trimestres filtrés par le contact en question. Une fois que vous avez cliqué sur une cellule, vous pouvez appuyer sur l'icône des jumelles pour appeler la liste Drilldown que vous avez créée en vue d'une analyse et d'une exportation plus approfondies
.png)
.png)
Avec seulement 142 lignes de code, nous disposons d'une application BackEnd moderne, simple mais fonctionnelle, avec des outils permettant la communication inter-applications et l'analyse avancée. Il s'agit d'une mise en œuvre simplifiée à l'extrême qui ne doit être utilisée que comme exemple des éléments de base nécessaires à la construction d'une application de base de données dans IRIS. Comme il a été mentionné au début de l'article, ce code n'est pas prêt pour la production et, dans le cadre d'une utilisation réelle, les développeurs doivent se référer à la documentation et aux meilleures pratiques d'InterSystems IRIS pour s'assurer que leur code est robuste, sécurisé et évolutif (aucune de ces caractéristiques ne s'applique à cette base de code). Bon codage!
Salut la Communauté!
Profitez de regarder la nouvelle vidéo sur la chaîne Youtube d'InterSystems France.
L'invention et la vulgarisation des grands modèles de langage (tels que GPT-4 d'OpenAI) ont lancé une vague de solutions innovantes capables d'exploiter de grands volumes de données non structurées qui étaient peu pratiques, voire impossibles, à traiter manuellement jusqu'à récemment. Ces applications peuvent inclure la récupération de données (voir le cours ML301 de Don Woodlock pour une excellente introduction à Retrieval Augmented Generation), l'analyse des sentiments, et même des agents d'IA entièrement autonomes, pour n'en nommer que quelques-uns !
AnalyzeThis est un outil permettant d'obtenir un aperçu personnalisé de vos propres données dans InterSystems BI. Cela vous permet d'acquérir une expérience directe d'InterSystems BI et de comprendre la puissance et la valeur qu'elle peut apporter à votre organisation. En plus d'obtenir un aperçu personnalisé d'InterSystems BI grâce à l'importation d'un fichier CSV avec vos données, les classes et les requêtes SQL sont désormais prises en charge comme sources de données dans la v1.1.0 !
Nous avons récemment publié un nouveau livre blanc sur l'utilisation de nœuds de reporting (« membres miroir de reporting asynchrone ») dans un environnement miroir. De plus en plus de clients considèrent ce mécanisme comme un moyen simple et rapide de configurer une copie de leurs données de production qui reste à jour, tout en pouvant être utilisée pour des requêtes analytiques ou des charges de travail de reporting lourdes sans impact sur le système source. Lisez le livre blanc ici.
Comme toujours, nous sommes curieux de connaître vos propres commentaires sur la manière dont vous avez utilisé cette option de mise en miroir dans votre organisation et si vous avez des idées sur la façon dont nous pouvons la rendre encore plus productive.
Bonjour La Communauté,
toute personne ayant (de près ou de loin, avec une préférence pour la 1ère option), une connaissance de l'utilisation d'Amazon QuickSight avec IRIS, est invitée à faire part de son expérience dans cette discussion.
En vous remerciant par avance.
Bonjour la communauté,
Je suis heureux de partager avec vous la nouvelle qu'InterSystems est reconnu comme Strong Performer dans le rapport Forrester Wave ™ Data Management for Analytics, Q1 2023 qui classe les meilleurs fournisseurs de technologies de gestion des données pour l’analytique (DMA).
Apache Superset est une plate-forme moderne d'exploration et de visualisation des données. Superset peut remplacer ou augmenter les outils de business intelligence propriétaires pour de nombreuses équipes. Superset s'intègre bien à une variété de sources de données.
Désormais, il est également possible de l'utiliser avec InterSystems IRIS.
Une démo en ligne est disponible et elle utilise SQL d'IRIS Cloud comme source de données.
.png)
Le support d'IRIS est implémenté avec un paquetage Python nommé superset-iris, qui peut être installé manuellement dans Superset.
Superset utilise SQLAlchemy comme moteur de base de données, tandis que le paquet superset-iris utilise sqlalchemy-iris.
Lorsque le paquet est installé dans l'environnement Superset, il devient possible de sélectionner InterSystems IRIS dans la liste des bases de données prises en charge.
.png)
.png)
Pour se connecter à la base de données IRIS, il faut un URI SQLAlchemy sous la forme suivante: iris://{login}:{password}@{hostname}:{port}/{namespace}
La connexion de test doit vérifier la disponibilité du serveur. Cliquez ensuite sur Connecter pour terminer l'ajout de la base de données.
Dans le même formulaire d'édition de base de données, dans l'onglet avancé Advanced Tab, et dans le bloc de sécurité Security, l'option nommée
Autoriser le téléchargement de fichiers vers la base de données, qui permettra de télécharger des fichiers CSV et de construire des tableaux avec des données dans IRIS en se basant sur ces derniers.
Le Labo SQL, qui permet d'effectuer des requêtes SQL
.png)
Il permet également de collecter et d'afficher des renseignements sur les schémas et les tableaux existants, de prévisualiser ces tableaux et de proposer la construction d'une simple requête SQL avec toutes les colonnes.
.png)
Pour l'essayer localement, clonez le dépôt
git clone https://github.com/caretdev/superset-iris.git superset-iris
cd superset-irisLancez Superset avec Docker-Compose
docker-compose pull
docker-compose up -dLancez Superset avec Docker-Compose Pendant le démarrage, il importe les données d'exemple dans la base de données IRIS, cela prendra un certain temps, pour attendre que ce soit fait, exécutez la commande suivante
docker-compose logs -f superset-initLorsque la commande ci-dessus a fini de fonctionner, allez à http://localhost:8088/dashboard/list/. Les panneaux de bord sont disponibles sans autorisation. Pour accéder au Labo SQL, utilisez admin/admin comme login et mot de passe.
Veuillez voter sur le concours
Voici mon introduction à une série d'articles expliquant comment créer un système d'apprentissage automatique de bout en bout.
Notre communauté de développement d'IRIS a plusieurs messages sans balise ou mal balisés. Au fur et à mesure que le nombre de messages augmente, l'organisation de chaque balise et l'expérience d'un membre de la communauté qui parcourt les sujets tendent à diminuer.
Nous pouvons envisager quelques solutions habituelles pour ce scénario, comme par exemple :
Nous avons beaucoup d'exemples de dessins animés, d'anime ou de films pour nous rappeler ce qui peut se passer lorsqu'on enseigne à une machine...
L'apprentissage automatique est un sujet très vaste et je vais faire de mon mieux pour expliquer ma vision du sujet. Revenons au problème que nous devons encore résoudre : Si l'on examine les solutions habituelles, elles prennent toutes en compte l'interprétation d'un texte. Comment apprendre à une machine à lire un texte, à comprendre la corrélation entre un texte et une balise ? Tout d'abord, nous devons explorer les données et en tirer des conclusions.
Lorsque vous commencez à étudier l'apprentissage automatique, les deux termes ci-dessus sont toujours utilisés. Mais comment savoir ce qu'il faut approfondir ?
-Classification : Un algorithme d'apprentissage automatique de classification prédit des valeurs discrètes.
-Régression : Un algorithme d'apprentissage automatique de régression prédit des valeurs continues.
Si l'on considère notre problème, nous devons prédire des valeurs discrètes (toutes les baises existent).
Toutes les données relatives aux articles ont été fournies ici.
SELECT
id, Name, Tags, Text
FROM Community.Post
Where
not text is null
order by id
| id | Nom | Balises | Texte |
|---|---|---|---|
| 1946 | Introduction aux services web | Web Development,Web Services | Cette vidéo est une introduction aux services web. Elle explique ce que sont les services web, leur utilisation et comment les administrer. Les services web sont également connus sous le nom de "SOAP". Cette session comprend des informations sur la sécurité et la politique de sécurité. |
| 1951 | Les outils pour Caché | Caché | Cette astuce technique (Tech Tip) passe en revue les différents outils disponibles à partir du Caché dans la barre d'état système de Windows. Vous verrez comment accéder à Studio IDE, au terminal, au portail de gestion du système, à SQL, aux globales, à la documentation, à la référence de classe et à l'accès au système à distance. |
| 1956 | Démarrage avec Caché | Caché | Démarrage avec Caché présentera Caché et son architecture. Nous examinerons également les outils de développement, la documentation et les exemples disponibles. |
| ID | Description |
|---|---|
| .NET | NET Framework (prononcé dot net) est un cadre logiciel développé par Microsoft qui fonctionne principalement sur Microsoft Windows. Site officiel. Support .NET dans InterSystems Data Platform. |
| .NET Experience | InterSystems .NET Experience révèle les possibilités d'interopérabilité entre .NET et InterSystems IRIS Data Platform. Pour plus de détails, cliquez ici. Site officiel de .NET |
| IA | L'intelligence artificielle (IA) est la simulation des processus de l'intelligence humaine par des machines, en particulier par des systèmes informatiques. Ces processus comprennent l'apprentissage (l'acquisition d'informations et de règles d'utilisation de ces informations), le raisonnement (l'utilisation de règles pour parvenir à des conclusions approximatives ou définitives) et l'autocorrection. Apprenez-en plus. |
| API | L'interface de programmation d'applications (API) est un ensemble de définitions de sous-programmes, de protocoles et d'outils permettant de créer des logiciels d'application. En termes généraux, il s'agit d'un ensemble de méthodes de communication clairement définies entre divers composants logiciels. Apprenez-en plus. |
Nous savons maintenant à quoi ressemblent les données. Mais il ne suffit pas de connaître la conception des données pour créer un modèle d'apprentissage automatique.
Un modèle d'apprentissage automatique est une combinaison d'un algorithme d'apprentissage automatique et de données. Après avoir combiné une technique avec des données un modèle peut commencer à prédire.
Si vous pensez que les modèles ML ne font jamais d'erreurs, vous devriez mieux comprendre la précision du modèle. En quelques mots, la précision correspond aux performances du modèle en matière de prédiction. En général, la précision est exprimée en pourcentage, sous forme de chiffres. Ainsi, quelqu'un dira : "J'ai créé un modèle dont la précision est de 70 %". Cela signifie que pour 70 % des prédictions, le modèle prédit correctement. Les 30 % restants seront des prédictions erronées.
Le NLP est un domaine de l'apprentissage automatique qui travaille sur la capacité d'un ordinateur à comprendre et à analyser le langage humain. Et oui, notre problème peut être résolu grâce au NLP.
La plupart des algorithmes d'apprentissage automatique ont une chose en commun : ils utilisent en entrée des NOMBRES. Oui, je sais... c'est le point le plus difficile à comprendre pour créer des modèles d'apprentissage automatique.
Une bonne partie du travail dans une solution de ML consiste à transformer les données en quelque chose qui peut être utilisé dans un algorithme.
Ce travail est appelé "ingénierie des fonctionnalités" (Feature Engineering). Dans ce cas, c'est plus compliqué car les données ne sont pas structurées. Mais voici une brève explication*:
J'ai transformé chaque mot du texte en un identifiant unique représenté par un nombre. SKLearn et d'autres librairies python devraient vous aider
de le faire facilement.
J'ai déployé le modèle formé en tant que démonstration ici : http://iris-ml-suite.eastus.cloudapp.azure.com/
Dans mon prochain article, je montrerai le code et les moyens de faire toute la modélisation. A ne pas manquer !
Cette application est au concours actuel sur l'échange ouvert, vous pouvez voter ici: https://openexchange.intersystems.com/contest/current ou dans mon application iris-ml-suite
Suite à la partie précédente, il est temps de tirer parti de l'instruction de VALIDATION DU MODÈLE IntegratedML, qui fournit des informations permettant de surveiller vos modèles ML. Vous pouvez la voir en action ici
Le code présenté ici est dérivé d'exemples fournis par le modèle InterSystems IntegratedML ou la documentation IRIS, documentation
Remarque: Le code présenté ici n'a qu'une valeur explicative. Si vous souhaitez l'essayer, j'ai développé une application modèle - iris-integratedml-monitor-example, qui participe au concours IA d'InterSystems IRIS (InterSystems IRIS AI Contest). S'il vous plaît, après avoir lu cet article, vous pouvez le consulter et, si vous l'aimez, votez pour moi! :)
Pour surveiller votre modèle ML, vous aurez besoin d'au moins deux fonctions :
Heureusement, IRIS nous fournit ces deux caractéristiques nécessaires.
Comme nous l'avons vu dans la partie précédente, IntegratedML fournit l'instruction VALIDER LE MODÈLE pour calculer les paramètres de performance suivants :
Remarque: ces définitions ne sont pas formelles, elles sont même assez superficielles ! Je vous encourage à prendre le temps de les interpréter.
Ce qui est intéressant, c'est qu'à chaque fois que vous appelez VALIDER LE MODÈLE (VALIDATE MODEL), IntegrateML enregistre sa mesure de performance, et nous pouvons tirer parti de cette fonctionnalité pour la surveiller.
InterSystems IRIS fournit le framework du Moniteur de Système pour traiter les tâches de surveillance. Il vous permet également de définir des règles personnalisées afin de déclencher des notifications basées sur des prédicats appliqués à ces mesures.
Par défaut, un ensemble de mesures est fourni pour le disque, la mémoire, les processus, le réseau, etc. En outre, le Moniteur de Système vous permet également d'étendre les moniteurs pour couvrir une infinité de possibilités. De tels moniteurs personnalisés sont appelés une application de moniteur (Application Monitor) dans la terminologie de moniteur de système (System Monitor).
Vous pouvez obtenir plus d'informations sur le Moniteur de Système ici.
Jusqu'à présent, nous avons un moyen d'obtenir les valeurs des métriques de performance de chaque validation du modèle et, un outil qui pourrait déclencher des alertes basées sur des règles personnalisées appliquées à des sources de métriques personnalisées... Bien, il est temps de les combiner.
Tout d'abord, nous devons créer une classe de moniteur d'application personnalisée, en étendant la classe %Monitor.Abstract et en implémentant les méthodes Initialize et GetSample.
Class MyMetric.IntegratedMLModelsValidation Extends %Monitor.Adaptor
{
/// Initialiser la liste des métriques de validation des modèles.
Method Initialize() As %Status
{
Return $$$OK
}
/// Obtenir un échantillon métrique de routine.
/// Un code de retour de $$$OK indique qu'il y a une nouvelle instance d'échantillon.
/// Tout autre code de retour indique qu'il n'y a pas d'échantillon.
Method GetSample() As %Status
{
Return $$$OK
}
}
Les moniteurs système émettent des appels réguliers aux classes de moniteurs afin d'obtenir un ensemble de mesures appelées échantillons. Ces échantillons peuvent être simplement surveillés ou utilisés pour vérifier si des règles d'alerte doivent être levées. Vous définissez la structure de ces échantillons en définissant des propriétés standard non internes dans la classe monitior. Il est important de souligner ici que vous devez spécifier, dans le paramètre INDEX, l'une de ces propriétés comme clé primaire de chaque échantillon - sinon une erreur de clé dupliquée sera générée.
Class MyMetric.IntegratedMLModelsValidation1 Extends %Monitor.Adaptor
{
Parameter INDEX = "ModelTrainedName";
/// Nom de la définition du modèle
Property ModelName As %Monitor.String;
/// Nom du modèle formé en cours de validation
Property ModelTrainedName As %Monitor.String;
/// Erreur de validation (le cas échéant)
Property StatusCode As %Monitor.String;
/// Précision
Property ModelMetricPrecision As %Monitor.Numeric;
/// Rappel
Property ModelMetricRecall As %Monitor.Numeric;
/// Mesure F
Property ModelMetricFMeasure As %Monitor.Numeric;
/// Exactitude
Property ModelMetricAccuracy As %Monitor.Numeric;
...
}
La méthode Initialize est appelée une fois pour chaque appel de moniteur et la méthode GetSample est appelée jusqu'à ce qu'elle renvoie 0.
Ainsi, nous pourrions mettre en place un SQL sur l'historique de validation d'IntegrateML pour fournir des informations de métriques au moniteur, en implémentant les méthodes Initialize et GetSample :
/// Initialiser la liste des métriques de validation des modèles.
Method Initialize() As %Status
{
// Obtenir la dernière validation pour chaque modèle validé par l'instruction VALIDATION DU MODÈLE
Set sql =
"SELECT MODEL_NAME, TRAINED_MODEL_NAME, STATUS_CODE, %DLIST(pair) AS METRICS_LIST FROM ("_
"SELECT m.*, $LISTBUILD(m.METRIC_NAME, m.METRIC_VALUE) pair, r.STATUS_CODE "_
"FROM INFORMATION_SCHEMA.ML_VALIDATION_RUNS r "_
"JOIN INFORMATION_SCHEMA.ML_VALIDATION_METRICS m "_
"ON m.MODEL_NAME = r.MODEL_NAME "_
"AND m.TRAINED_MODEL_NAME = r.TRAINED_MODEL_NAME "_
"AND m.VALIDATION_RUN_NAME = r.VALIDATION_RUN_NAME "_
"GROUP BY m.MODEL_NAME, m.METRIC_NAME "_
"HAVING r.COMPLETED_TIMESTAMP = MAX(r.COMPLETED_TIMESTAMP)"_
") "_
"GROUP BY MODEL_NAME"
Set stmt = ##class(%SQL.Statement).%New()
$$$THROWONERROR(status, stmt.%Prepare(sql))
Set ..Rspec = stmt.%Execute()
Return $$$OK
}
/// Obtenir un échantillon métrique de routine.
/// Un code de retour de $$$OK indique qu'il y a une nouvelle instance d'échantillon.
/// Tout autre code de retour indique qu'il n'y a pas d'échantillon.
Method GetSample() As %Status
{
Set stat = ..Rspec.%Next(.sc)
$$$THROWONERROR(sc, sc)
// Quitter si nous avons fait tous les jeux de données
If 'stat {
Quit 0
}
// remplir cette instance
Set ..ModelName = ..Rspec.%Get("MODEL_NAME")
Set ..ModelTrainedName = ..Rspec.%Get("TRAINED_MODEL_NAME")_" ["_$zdt($zts,3)_"]"
Set ..StatusCode = ..Rspec.%Get("STATUS_CODE")
Set metricsList = ..Rspec.%Get("METRICS_LIST")
Set len = $LL(metricsList)
For iMetric = 1:1:len {
Set metric = $LG(metricsList, iMetric)
Set metricName = $LG(metric, 1)
Set metricValue = $LG(metric, 2)
Set:(metricName = "PRECISION") ..ModelMetricPrecision = metricValue
Set:(metricName = "RECALL") ..ModelMetricRecall = metricValue
Set:(metricName = "F-MEASURE") ..ModelMetricFMeasure = metricValue
Set:(metricName = "ACCURACY") ..ModelMetricAccuracy = metricValue
}
// quitter avec une valeur de retour indiquant que les données de l'échantillon sont prêtes
Return $$$OK
}
Après avoir compilé la classe de moniteur, vous devez redémarrer le moniteur de système System Monitor afin que le système comprenne qu'un nouveau moniteur a été créé et qu'il est prêt à être utilisé. Pour ce faire, vous pouvez utiliser la routine ^%SYSMONMGR ou la classe %SYS.Monitor.
Jusqu'à présent, nous disposons des outils nécessaires pour collecter, surveiller et émettre des alertes sur les mesures de performance du ML. Il est maintenant temps de définir une règle d'alerte personnalisée et de simuler un scénario dans lequel un modèle ML déployé commence à affecter négativement vos performances.
Tout d'abord, nous devons configurer une alerte par courriel et sa règle de déclenchement. Cela peut être fait à l'aide de la routine ^%SYSMONMGR. Cependant, afin de rendre les choses plus faciles, j'ai créé une méthode d'installation qui définit toute la configuration de l'e-mail et de la règle d'alerte. Vous devez remplacer les valeurs entre <> ; par les paramètres de votre serveur de messagerie et de votre compte.
ClassMethod NotificationSetup()
{
// Régler les paramètres de l'e-mail
Set sender = "<your e-mail address>"
Set password = "<your e-mail password>"
Set server = "<SMTP server>"
Set port = "<SMTP server port>"
Set sslConfig = "default"
Set useTLS = 1
Set recipients = $LB("<comma-separated receivers for alerts>")
Do ##class(%Monitor.Manager).AppEmailSender(sender)
Do ##class(%Monitor.Manager).AppSmtpServer(server, port, sslConfig, useTLS)
Do ##class(%Monitor.Manager).AppSmtpUserName(sender)
Do ##class(%Monitor.Manager).AppSmtpPassword(password)
Do ##class(%Monitor.Manager).AppRecipients(recipients)
// La messagerie électronique comme méthode de notification par défaut
Do ##class(%Monitor.Manager).AppNotify(1)
// Activer les notifications par messagerie électronique
Do ##class(%Monitor.Manager).AppEnableEmail(1)
Set name = "perf-model-appointments-prediction"
Set appname = $namespace
Set action = 1
Set nmethod = ""
Set nclass = ""
Set mclass = "MyMetric.IntegratedMLModelsValidation"
Set prop = "ModelMetricAccuracy"
Set expr = "%1 < .8"
Set once = 0
Set evalmethod = ""
// Créer une alerte
Set st = ##class(%Monitor.Alert).Create(name, appname, action, nmethod, nclass, mclass, prop, expr, once, evalmethod)
$$$THROWONERROR(st, st)
// Relancer le moniteur
Do ##class(MyMetric.Install).RestartMonitor()
}
Dans la méthode précédente, une alerte sera émise si le moniteur obtient des valeurs de précision inférieures à 90 %.
Maintenant que notre règle d'alerte est configurée, créons, formons et validons un modèle de prédiction show/no-show avec les 500 premiers enregistrements et validons-le avec les 600 premiers enregistrements.
Remarque : Le paramètre seed sert uniquement à garantir la reproductibilité (c.-à-d. pas de valeurs aléatoires) et doit normalement être évité en production.
-- Création du modèle
CREATE MODEL AppointmentsPredection PREDICTING (Show) FROM MedicalAppointments USING {\"seed\": 3}
-- Formation à l'aide des 500 premiers enregistrements du jeu de données
TRAIN MODEL AppointmentsPredection FROM MedicalAppointments WHERE ID <= 500 USING {\"seed\": 3}
-- Affichage des informations sur le modèle
SELECT * FROM INFORMATION_SCHEMA.ML_TRAINED_MODELS
| | NOM_DU_MODÈLE | NOM_DU_MODÈLE_FORMÉ | FOURNISSEUR | HORODATAGE_FORMÉ | TYPE_DU_MODÈLE | INFOS_MODÈLE |
|---|------------------------|-------------------------|----------|-------------------------|----------------|---------------------------------------------------|
| 0 | AppointmentsPredection | AppointmentsPredection2 | AutoML | 2020-07-12 04:46:00.615 | classification | ModelType:Logistic Regression, Package:sklearn... |
Notez que IntegrateML, en utilisant AutoML comme fournisseur (colonne FOURNISSEUR), déduit du jeu de données fourni, un modèle de classification (colonne TYPE_DU_MODÈLE), avec l'algorithme de régression logistique, à partir de la bibliothèque scikit-learn (colonne INFOS_MODÈLE). Il est important de souligner ici la règle "Garbage In, Garbage Out" ("à données inexactes, résultats erronés") - c'est-à-dire que la qualité du modèle est directement liée à la qualité des données.
Poursuivons maintenant avec la validation du modèle.
-- CCalculer les performances du modèle en utilisant les 600 premiers enregistrements (500 de l'ensemble formé + 100 pour le test).
VALIDATE MODEL AppointmentsPredection FROM MedicalAppointments WHERE ID < 600 USING {\"seed\": 3}
-- Afficher les mesures de validation
SELECT * FROM INFORMATION_SCHEMA.ML_VALIDATION_METRICS WHERE MODEL_NAME = '%s'
| NOM_MÉTRIQUE | Exactitude | Mesure F | Précision | Rappel |
|--------------------------|----------|-------------|-----------|--------|
| AppointmentsPredection21 | 0.9 | 0.94 | 0.98 | 0.91 |
Le modèle peut être utilisé pour effectuer des prédictions à l'aide de l'instruction PREDICT :
SELECT PREDICT(AppointmentsPredection) As Predicted, Show FROM MedicalAppointments WHERE ID <= 500
| | Prédit | Affiché|
|-----|-----------|-------|
| 0 | 0 | Faux |
| 1 | 0 | Faux |
| 2 | 0 | Faux |
| 3 | 0 | Faux |
| 4 | 0 | Faux |
| ... | ... | ... |
| 495 | 1 | Vrai |
| 496 | 0 | Vrai |
| 497 | 1 | Vrai |
| 498 | 1 | Vrai |
| 499 | 1 | Vrai |
Ensuite, simulons l'ajout de 200 nouveaux enregistrements (pour un total de 800 enregistrements) au modèle de manière à ce que sa précision soit ramenée à 87 %.
-- Calculer les performances du modèle en utilisant les 800 premiers enregistrements.
VALIDATE MODEL AppointmentsPredection FROM MedicalAppointments WHERE ID < **800** USING {\"seed\": 3}
-- Afficher les mesures de validation
SELECT * FROM INFORMATION_SCHEMA.ML_VALIDATION_METRICS WHERE MODEL_NAME = '%s'
| NOM_MÉTRIQUE | Exactitude | Mesure F | Précision | Rappel |
|--------------------------|----------|-----------|-----------|--------|
| AppointmentsPredection21 | 0.9 | 0.94 | 0.98 | 0.91 |
| AppointmentsPredection22 | 0.87 | 0.93 | 0.98 | 0.88 |
Comme nous avons mis en place une règle pour envoyer une notification par messagerie électronique si la précision est inférieure à 90%, le moniteur de système System Monitor comprend qu'il est temps de déclencher une telle alerte vers le(s) compte(s) de messagerie électronique concerné(s).
Dans le corps du message, vous pouvez trouver des informations sur l'alerte, telles que son nom, le moniteur d'application et ses valeurs métriques qui ont déclenché l'alerte.
Ainsi, une telle situation sera notifiée aux personnes qui pourront prendre des mesures pour y remédier. Par exemple, une action pourrait consister simplement à réentraîner le modèle, mais dans certains cas, une approche plus élaborée peut s'avérer nécessaire.
Il est certainement possible d'approfondir les mesures de surveillance et de créer de meilleures alertes. Par exemple, imaginez que vous ayez plusieurs modèles ML en cours d'exécution et que différentes personnes soient responsables de chacun d'entre eux. Vous pourriez utiliser la métrique du nom du modèle et définir des règles d'alerte spécifiques, pour des destinataires d'e-mails spécifiques.
Le moniteur System Monitor vous permet également de déclencher une ClassMethod au lieu d'envoyer un courriel. Ainsi, vous pouvez exécuter une logique complexe lorsqu'une alerte est déclenchée, comme entraîner automatiquement le modèle, par exemple.
Notez que, comme System Monitor exécutera régulièrement les méthodes "Initialize" et "GetSample", ces méthodes doivent être soigneusement conçues afin de ne pas demander trop de ressources au système.
Comme le souligne Benjamin De BoeIRIS introduit une nouvelle façon de personnaliser votre tâche de surveillance - l' outil SAM. Ma première impression a été très positive, SAM est intégré avec les technologies de surveillance des standards du marché comme Grafana et Prometheus. Alors, pourquoi ne pas aller de l'avant et tester comment améliorer ce travail avec de telles nouvelles fonctionnalités ? Mais il s'agit là d'une matière pour un futur travail.... :)
Voilà, c'est fait ! J'espère que cela pourra vous être utile d'une manière ou d'une autre. A bientôt !
Il y a quelques mois, j'ai lu cet article intéressant de la MIT Technology Review, qui explique comment la pandémie de COVID-19 pose des défis aux équipes informatiques du monde entier en ce qui concerne leurs systèmes d'apprentissage automatique (ML).
Cet article m'a incité à réfléchir à la manière de traiter les problèmes de performance après le déploiement d'un modèle de ML.
J'ai simulé un simple scénario de problème de performance dans une application modèle de la technologie Open Exchange - iris-integratedml-monitor-example, qui participe au concours IA d'InterSystems IRIS (InterSystems IRIS AI Contest). S'il vous plaît, après avoir lu cet article, vous pouvez le consulter et, si vous l'aimez, votez pour moi! :)
Avant de parler de COVID-19 et de son impact sur les systèmes ML dans le monde entier, parlons rapidement d'InterSystems IRIS IntegratedML.
En automatisant des tâches telles que la sélection des caractéristiques et en s'intégrant au langage de manipulation de données SQL standard, IntegratedML pourrait nous aider à développer et à déployer une solution de ML.
Par exemple, après avoir manipulé et analysé correctement des données provenant de rendez-vous médicaux, vous pouvez configurer un modèle de ML pour prédire la présence ou l'absence des patients à l'aide de ces instructions SQL :
CREATE MODEL AppointmentsPredection PREDICTING (Show) FROM MedicalAppointments
TRAIN MODEL AppointmentsPredection FROM MedicalAppointments
VALIDATE MODEL AppointmentsPredection FROM MedicalAppointments
Le fournisseur AutoML choisira l'ensemble de caractéristiques et l'algorithme ML le plus performant. Dans ce cas, le fournisseur AutoML a sélectionné le modèle de régression logistique utilisant la bibliothèque scikit-learn, obtenant ainsi une exactitude de 90 %.
| | NOM_DU_MODÈLE | NOM_DU_MODÈLE_FORMÉ | FOURNISSEUR | HORODATAGE_FORMÉ | TYPE_DU_MODÈLE | INFOS_MODÈLE |
|---|------------------------|-------------------------|----------|-------------------------|----------------|---------------------------------------------------|
| 0 | AppointmentsPredection | AppointmentsPredection2 | AutoML | 2020-07-12 04:46:00.615 | classification | ModelType:Logistic Regression, Package:sklearn... |
| NOM_MÉTRIQUE | Exactitude | Mesure F | Précision | Rappel |
|--------------------------|----------|-----------|-----------|--------|
| AppointmentsPredection21 | 0.9 | 0.94 | 0.98 | 0.91 |
Une fois que votre modèle de ML est déjà intégré à SQL, vous pouvez l'intégrer de manière transparente à votre système de réservation existant afin d'améliorer ses performances, en utilisant des estimations sur les patients qui seront présents et ceux qui ne le seront pas :
SELECT PREDICT(AppointmentsPredection) As Predicted FROM MedicalAppointments WHERE ID = ?
Vous pouvez en savoir plus sur IntegrateML ici. Si vous souhaitez obtenir un peu plus de détails sur ce modèle de prédiction simple, vous pouvez vous référer à.
Toutefois, comme les modèles d'IA/ML sont conçus pour s'adapter au comportement de la société, directement ou non, ils seront probablement très affectés lorsque ce comportement changera rapidement. Récemment, nous avons (malheureusement) pu expérimenter un tel scénario en raison de la pandémie de COVID-19.
Comme l'explique l'article de MIT Technology Review, la pandémie de COVID-19 a modifié remarquablement et rapidement le comportement de la société. J'ai effectué des recherches dans Google Trends pour des termes cités dans l'article, tels que masque N95, papier toilette et désinfectant pour les mains, afin de confirmer l'augmentation de leur popularité, à mesure que la pandémie se propageait dans le monde :
Tel que cité dans l'article :
"Mais ils [les changements apportés par COVID-19] ont également affecté l'intelligence artificielle, causant des problèmes aux algorithmes qui fonctionnent dans les coulisses de la gestion des stocks, de la détection des fraudes, du marketing, et bien d'autres choses encore. Les modèles d'apprentissage automatique formés sur la base du comportement humain normal découvrent aujourd'hui que la normalité elle-même a changé, et certains d'entre eux ne fonctionnent plus comme ils le devraient."
En d'autres termes, entre l'"ancienne normalité" et la "nouvelle normalité", nous vivons une "nouvelle anormalité".
Une autre citation intéressante, également tirée de l'article :
"Les modèles d'apprentissage automatique sont conçus pour s'adapter aux changements. Mais la plupart d'entre eux sont également fragiles ; ils donnent de mauvais résultats lorsque les données d'entrée diffèrent trop de celles sur lesquelles ils ont été formés. (...) L'IA est un moteur vivant, qui respire."
Cet article présente ensuite des exemples de modèles d'IA/ML dont les performances commencent soudainement à être affectées négativement, ou qui doivent être modifiés de toute urgence. Quelques exemples :
Nous devons donc surveiller nos modèles d'IA/ML afin de garantir leur fiabilité et de continuer à aider nos clients.
Jusqu'à présent, j'espère vous avoir montré que la création, la formation et le déploiement de votre modèle de ML ne sont pas tout - vous devez en assurer le suivi. Dans le prochain article, je vous montrerai comment utiliser le framework %Monitor.Abstract d'IRIS pour surveiller les performances de votre système de ML et définir des alertes basées sur les métriques du moniteur.
En attendant, j'aimerais savoir si vous avez été confronté à l'un ou l'autre des problèmes soulevés par ces périodes de pandémie, et comment vous y faites face dans la section des commentaires !
Restez à l'écoute (et en sécurité 😊)!
Avec InterSystems IRIS 2022.2, nous avons introduit le stockage en colonne comme une nouvelle option pour la persistance de vos tables IRIS SQL qui peut booster vos requêtes analytiques d'un ordre de grandeur. La capacité est marquée comme expérimentale dans les versions 2022.2 et 2022.3, mais passera à une capacité de production entièrement prise en charge dans la prochaine version 2023.1.
La documentation du produit et cette vidéo d'introduction, décrivent déjà les différences entre le stockage en ligne, toujours la valeur par défaut sur IRIS et utilisé dans l'ensemble de notre clientèle, et le stockage en table en colonnes et fournissent des conseils de haut niveau sur le choix de la disposition de stockage appropriée pour votre cas d'utilisation. Dans cet article, nous développerons ce sujet et partagerons quelques recommandations basées sur les principes de modélisation des pratiques de l'industrie, les tests internes et les commentaires des participants au Early Access Program.
Suite de tests d’E/S PerfTools #Analytics #Caché #HealthShare #InterSystems IRIS #Open Exchange #TrakCare But Cette paire d’outils (RanRead et RanWrite) est utilisée pour générer des événements de lecture et d’écriture aléatoires dans une base de données (ou une paire de bases de données) afin de tester les opérations d’entrée/sortie par seconde (IOPS). Ils peuvent être utilisés conjointement ou séparément pour tester la capacité matérielle des E/S, valider les IOPS cibles et garantir des temps de réponse disque acceptables. Les résultats recueillis à partir des tests d’E/S varient d’une configuration à l’autre en fonction du sous-système d’E/S. Avant d’exécuter ces tests, assurez-vous que la surveillance correspondante du système d’exploitation et du niveau de stockage est configurée pour capturer les mesures de performances des E/S en vue d’une analyse ultérieure. La méthode suggérée consiste à exécuter l’outil Performance du système fourni avec IRIS. Veuillez noter qu’il s’agit d’une mise à jour d’une version précédente, qui peut être trouvée ici. Installation Téléchargez les outils PerfTools.RanRead.xml et PerfTools.RanWrite.xml depuis GitHub ici. Importez des outils dans l’espace de noms USER. UTILISATEUR> faire $system. OBJ. Load(« /tmp/PerfTools.RanRead.xml »,"ckf ») UTILISATEUR> faire $system. OBJ. Load(« /tmp/PerfTools.RanWrite.xml »,"ckf ») Exécutez la méthode Help pour afficher tous les points d’entrée. Toutes les commandes sont exécutées dans USER. USER> do ##class(PerfTools.RanRead). Aide() • do ##class(PerfTools.RanRead). Setup(Répertoire,DatabaseName,SizeGB,LogLevel) Crée une base de données et un espace de noms portant le même nom. Le niveau logarithmique doit être compris entre 0 et 3, où 0 correspond à « aucun » et 3 à « verbeux ». • do ##class(PerfTools.RanRead). Exécuter(Répertoire,Processus,Dénombrement,Mode) Exécutez le test d’E/S en lecture aléatoire. Le mode est 1 (par défaut) pour le temps en secondes, 2 pour les itérations, en référence au paramètre Count précédent • do ##class(PerfTools.RanRead). Stop() Termine toutes les tâches en arrière-plan. • do ##class(PerfTools.RanRead). Reset() Supprime les statistiques des exécutions précédentes. Ceci est important pour l’exécution entre les tests, sinon les statistiques des exécutions précédentes sont moyennées dans la version actuelle. • do ##class(PerfTools.RanRead). Purger(Répertoire) Supprime l’espace de noms et la base de données du même nom. • do ##class(PerfTools.RanRead). Export(Répertoire) Exporte un résumé de tous les tests de lecture aléatoire dans un fichier texte délimité par des virgules. USER> do ##class(PerfTools.RanWrite). Aide() • do ##class(PerfTools.RanWrite). Setup(Répertoire,NomBase de données) Crée une base de données et un espace de noms portant le même nom. • do ##class(PerfTools.RanWrite). Run(Répertoire,NumProcs,RunTime,HangTime,HangVariationPct,Longueur du nom global,Profondeur globale du nœud,Longueur globale du sous-nœud) Exécutez le test d’E/S en écriture aléatoire. Tous les paramètres autres que le répertoire ont des valeurs par défaut. • do ##class(PerfTools.RanWrite). Stop() Termine toutes les tâches en arrière-plan. • do ##class(PerfTools.RanWrite). Reset() Supprime les statistiques des exécutions précédentes. • do ##class(PerfTools.RanWrite). Purger(Répertoire) Supprime l’espace de noms et la base de données du même nom. • do ##class(PerfTools.RanWrite). Export(Directory) Exporte un résumé de tout l’historique des tests d’écriture aléatoire dans un fichier texte délimité par des virgules. Coup monté Créez une base de données vide (pré-développée) appelée RAN au moins deux fois la taille de la mémoire de l’hôte physique à tester. Assurez-vous que la taille du cache du contrôleur de stockage de la base de données vide est au moins quatre fois supérieure à celle du contrôleur de stockage. La base de données doit être plus grande que la mémoire pour garantir que les lectures ne sont pas mises en cache dans le cache du système de fichiers. Vous pouvez créer manuellement ou utiliser la méthode suivante pour créer automatiquement un espace de noms et une base de données. USER> do ##class(PerfTools.RanRead). Configuration(« /ISC/tests/TMP »,"RAN »,200,1) Répertoire créé /ISC/tests/TMP/ Création d’une base de données de 200 Go dans /ISC/tests/TMP/ Base de données créée dans /ISC/tests/TMP/ Remarque : On peut utiliser la même base de données pour RanRead et RanWrite, ou utiliser des bases séparées si l’intention de tester plusieurs disques à la fois ou à des fins spécifiques. Le code RanRead permet de spécifier la taille de la base de données, mais pas le code RanWrite, il est donc probablement préférable d’utiliser la commande RanRead Setup pour créer des bases de données prédimensionnées souhaitées, même si l’on utilisera la base de données avec RanWrite. Méthodologie Commencez avec un petit nombre de processus et des temps d’exécution de 30 à 60 secondes. Ensuite, augmentez le nombre de processus, par exemple commencez à 10 tâches et augmentez de 10, 20, 40, etc. Continuez à exécuter les tests individuels jusqu’à ce que le temps de réponse soit constamment supérieur à 10 ms ou que les IOPS calculées n’augmentent plus de manière linéaire. L’outil utilise la commande ObjectScript VIEW qui lit les blocs de base de données en mémoire , donc si vous n’obtenez pas les résultats attendus, tous les blocs de base de données sont peut-être déjà en mémoire. À titre indicatif, les temps de réponse suivants pour les lectures aléatoires de base de données de 8 Ko et 64 Ko (non mises en cache) sont généralement acceptables pour les baies entièrement flash : • Moyenne <= 2ms • Ne pas dépasser <= 5ms Courir Pour RanRead, exécutez la méthode Run en augmentant le nombre de processus et en prenant note du temps de réponse au fur et à mesure. Le principal moteur des IOPS pour RanRead est le nombre de processus. USER> do ##class(PerfTools.RanRead). Exécuter(« /ISC/tests/TMP »,5,60) Outil de performance d’E/S à lecture aléatoire InterSystems Processus RanRead 11742 créant 5 processus de travail en arrière-plan. RanReadJob préparé 11768 pour le parent 11742 RanReadJob préparé 11769 pour le parent 11742 RanReadJob préparé 11770 pour le parent 11742 RanReadJob préparé 11771 pour le parent 11742
RanReadJob préparé 11772 pour le parent 11742
Démarrer 5 processus pour le numéro de tâche RanRead 11742 maintenant!
Pour terminer l’exécution : faites ##class(PerfTools.RanRead). Stop()
En attente de finir..................
Tâches en arrière-plan de lecture aléatoire terminées pour le parent 11742 Travail RanRead
5 processus de 11742 (62,856814 secondes) Temps de réponse moyen = 1,23 ms
IOPS calculé pour la tâche RanRead 11742 = 4065
Le paramètre Mode de la commande Run utilise par défaut le mode 1, qui utilise le paramètre Count (60 dans l’exemple ci-dessus) comme secondes. Si vous définissez Mode sur 2, le paramètre Count est défini sur un nombre d’itérations par processus, donc s’il est défini sur 100 000, chacune des 5 tâches lira 100 000 fois dans la base de données. C’est le mode utilisé à l’origine par ce logiciel, mais les exécutions chronométrées permettent une coordination plus précise avec des outils de surveillance tels que System Performance, qui sont également chronométrés, et l’outil RanWrite .
Pour RanWrite, exécutez la méthode Run en diminuant le paramètre Hangtime. Ce paramètre indique le temps d’attente entre les écritures en secondes et constitue le principal moteur d’IOPS pour RanWrite. On peut également augmenter le nombre de processus en tant que moteur pour IOPS.
USER> do ##class(PerfTools.RanWrite). Exécuter(« /ISC/tests/TMP »,1,60,.001)
Processus RanWrite 11742 créant 1 processus de travail en arrière-plan.
Préparé RanWriteJob 12100 pour parent 11742
Démarrer 1 processus pour le numéro de tâche RanWrite 11742 maintenant!
Pour terminer l’exécution : faites ##class(PerfTools.RanWrite). Stop()
En attente de finir..................
Travaux d’écriture aléatoire en arrière-plan terminés pour le parent 11742 Les processus 1 de la tâche RanWrite 11742
(60 secondes) avaient un temps de réponse moyen = 0,912 ms
IOPS calculé pour la tâche RanWrite 11742 = 1096
Les autres paramètres de RanWrite peuvent généralement être laissés à leurs valeurs par défaut en dehors de circonstances inhabituelles. Ces paramètres sont les suivants : - HangVariationPct : variance sur le paramètre hangtime, utilisée pour imiter l’incertitude ; c’est un pourcentage du paramètre précédent
La semaine dernière, nous avons annoncé la Plate-forme de données InterSystems IRIS, notre nouvelle plate-forme complète pour toutes vos activités liées aux données, qu'elles soient transactionnelles, analytiques ou les deux. Nous avons inclus un grand nombre des fonctionnalités que nos clients connaissent et apprécient de Caché et Ensemble, mais dans cet article, nous allons mettre un peu plus en lumière l'une des nouvelles capacités de la plate-forme : SQL Sharding, une nouvelle fonctionnalité puissante dans notre histoire de scalability.
Si vous avez exactement 4 minutes et 41 secondes, jetez un coup d'œil à cette vidéo astucieuse sur le scalability. Si vous ne trouvez pas vos écouteurs et ne croyez pas que notre voix apaisante plaira à vos collègues, continuez à lire !
Qu'il s'agisse de traiter des millions d'opérations boursières par jour ou de soigner des dizaines de milliers de patients par jour, une plateforme de données prenant en charge ces activités doit être capable de faire face à ces grandes échelles de manière transparente. La manière transparente signifie que les développeurs et les utilisateurs ne doivent pas se préoccuper de ces chiffres et qu'ils peuvent se concentrer sur leurs activités et applications principales, la plate-forme se chargeant de l'aspect de l'échelle.
Depuis des années, Caché prend en charge le vertical scalability, où les progrès du matériel sont exploités de manière transparente par le logiciel, en exploitant efficacement un nombre très élevé de cœurs et de grandes quantités de RAM. C'est ce qu'on appelle la mise à l'échelle vers le haut, et bien qu'un bon effort de dimensionnement initial puisse vous permettre d'obtenir un système parfaitement équilibré, il y a une limite inhérente à ce que vous pouvez réaliser sur un seul système de manière rentable.
C'est là qu'intervient le horizontal scalability, qui consiste à répartir la charge de travail sur un certain nombre de serveurs distincts travaillant en cluster, plutôt que sur un seul. Caché prend en charge les serveurs d'application ECP comme moyen de horizontal scalability depuis un certain temps déjà, mais InterSystems IRIS ajoute désormais le sharding SQL.
Quelle est donc la différence entre les serveurs d'application ECP et la nouvelle fonctionnalité de sharding ? Pour comprendre cette différence, examinons de plus près les charges de travail. Une charge de travail peut consister en des dizaines de milliers de petits dispositifs écrivant continuellement de petits lots de données dans la base de données, ou juste une poignée d'analystes émettant des requêtes analytiques couvrant chacune des Go de données à la fois. Lequel des deux a la plus grande échelle ? Difficile à dire, tout comme il est difficile de dire si une canne à pêche ou un tonneau de bière est le plus grand. Les charges de travail ont plus d'une dimension et, par conséquent, la mise à l'échelle pour les prendre en charge nécessite également un peu plus de subtilité.
En simplifiant grossièrement, considérons les composants suivants dans une charge de travail d'application : N représente la charge de travail de l'utilisateur et Q représente la taille de la requête. Dans nos exemples précédents, la première charge de travail a un N élevé mais un Q faible et la seconde est caractérisée par un N faible mais un Q élevé. Les serveurs d'application ECP sont très efficaces pour aider à supporter un grand N, car ils permettent de répartir les utilisateurs de l'application sur différents serveurs. Cependant, ils ne sont pas nécessairement aussi utiles si l'ensemble de données devient très grand et que l'ensemble de travail ne tient pas dans la mémoire d'une seule machine. Le sharding s'occupe des grands Q, en vous permettant de partitionner l'ensemble de données entre les serveurs, le travail étant également poussé vers ces serveurs shard autant que possible.
Alors, à quoi sert réellement le sharding ? Il s'agit d'une fonctionnalité SQL qui divise les données d'une table partagée en ensembles disjoints de lignes qui sont stockés sur les serveurs shard. Lorsque vous vous connectez au maître du shard, vous voyez toujours cette table comme s'il s'agissait d'une table unique contenant toutes les données, mais les requêtes sont divisées en requêtes locales au shard qui sont envoyées à tous les serveurs shard. Là, les serveurs shard calculent les résultats en fonction des données qu'ils ont stockées localement et renvoient leurs résultats au shard master. Ce dernier agrège ces résultats, exécute toute combinaison logique pertinente et renvoie les résultats à l'application.
Bien que ce système soit trivial pour un simple SELECT * FROM table, il y a beaucoup de logique intelligente au niveau de l'interface qui garantit que vous pouvez utiliser (presque) n'importe quelle requête SQL et qu'un maximum de travail est poussé vers les shards pour maximiser le parallélisme. La "clé du shard", qui définit quelles lignes vont où, est l'endroit où vous anticipez les modèles de requête typiques. Plus important encore, si vous pouvez vous assurer que les tables souvent reliés entre eux sont répartis selon les mêmes clés, les jointures peuvent être entièrement résolues au niveau du shard, ce qui vous donne les hautes performances que vous recherchez.
Bien sûr, ce n'est qu'un avant-goût et il y a beaucoup plus à explorer, mais l'essentiel est ce qui est illustré ci-dessus : Le sharding SQL est une nouvelle recette dans le livre des plats hautement évolutifs que vous pouvez concocter avec InterSystems IRIS. Il s'agit d'un complément aux serveurs d'applications ECP, qui se concentre sur les ensembles de données de taille importante, ce qui en fait une solution idéale pour de nombreux cas d'utilisation analytique. Comme les serveurs d'applications ECP, il est entièrement transparent pour l'application et présente quelques variations architecturales plus créatives pour des scénarios très spécifiques.
Les enregistrements des sessions suivantes du Global Summit 2017 sur le sujet sont disponibles ici : http://learning.intersystems.com:
Consultez également le présent guide de ressources sur InterSystems IRIS sur learning.intersystems.com pour en savoir plus sur les autres capacités de la nouvelle plate-forme. Si vous souhaitez essayer le sharding sur votre cas d'utilisation particulier, consultez http://www.intersystems.com/iris et remplissez le formulaire en bas de page pour vous inscrire à notre programme d'adoption initiale, ou surveillez la version de test sur le terrain prévue plus tard cette année.
IRIS External Table est un projet Open Source de la communauté InterSystems, qui vous permet d'utiliser des fichiers stockés dans le système de fichiers local et le stockage d'objets en nuage comme AWS S3, en tant que tables SQL.
Il peut être trouvé sur Github https://github.com/intersystems-community/IRIS-ExternalTable Open Exchange https://openexchange.intersystems.com/package/IRIS-External-Table et est inclus dans InterSystems Package Manager ZPM.
Pour installer External Table depuis GitHub, utilisez :
git clone https://github.com/antonum/IRIS-ExternalTable.git
iris session iris
USER>set sc = ##class(%SYSTEM.OBJ).LoadDir("<path-to>/IRIS-ExternalTable/src", "ck",,1)
Pour installer avec ZPM Package Manager, utilisez :
USER>zpm "install external-table"
Créons un fichier simple qui ressemble à ceci :
a1,b1
a2,b2
Ouvrez votre éditeur préféré et créez le fichier ou utilisez simplement une ligne de commande sous linux/mac :
echo $'a1,b1\na2,b2' > /tmp/test.txt
Dans IRIS SQL, créez une table pour représenter ce fichier :
create table test (col1 char(10),col2 char(10))
Convertissez la table pour utiliser le stockage externe :
CALL EXT.ConvertToExternal(
'test',
'{
"adapter":"EXT.LocalFile",
"location":"/tmp/test.txt",
"delimiter": ","
}')
Et enfin - interrogez la table :
select * from test
Si tout fonctionne comme prévu, vous devriez voir un résultat comme celui-ci :
col1 col2
a1 b1
a2 b2
Retournez maintenant dans l'éditeur, modifiez le contenu du fichier et réexécutez la requête SQL. Ta-Da !!! Vous lisez les nouvelles valeurs de votre fichier local en SQL.
col1 col2
a1 b1
a2 b99
Sur <https://covid19-lake.s3.amazonaws.com/index.html >, vous pouvez avoir accès à des données constamment mises à jour sur le COVID, stockées par AWS dans la réserve publique de données.
Essayons d'accéder à l'une des sources de données de cette réserve de données : s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states
Si vous avez installé l'outil de ligne de commande AWS, vous pouvez répéter les étapes ci-dessous. Sinon, passez directement à la partie SQL. Vous n'avez pas besoin d'installer quoi que ce soit de spécifique à AWS sur votre machine pour suivre la partie SQL.
$ aws s3 ls s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/
2020-12-04 17:19:10 510572 us-states.csv
$ aws s3 cp s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/us-states.csv .
download: s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/us-states.csv to ./us-states.csv
$ head us-states.csv
date,state,fips,cases,deaths
2020-01-21,Washington,53,1,0
2020-01-22,Washington,53,1,0
2020-01-23,Washington,53,1,0
2020-01-24,Illinois,17,1,0
2020-01-24,Washington,53,1,0
2020-01-25,California,06,1,0
2020-01-25,Illinois,17,1,0
2020-01-25,Washington,53,1,0
2020-01-26,Arizona,04,1,0
Nous avons donc un fichier avec une structure assez simple. Cinq champs délimités.
Pour exposer ce dossier S3 en tant que table externe - d'abord, nous devons créer une table "normal" avec la structure désirée :
-- create external table
create table covid_by_state (
"date" DATE,
"state" VARCHAR(20),
fips INT,
cases INT,
deaths INT
)
Notez que certains noms de champs comme "Date" sont des mots réservés dans IRIS SQL et doivent être entourés de guillemets doubles.
Ensuite - nous devons convertir cette table "régulière" en table "externe", basé sur le godet AWS S3 et le type de CSV.
-- convertissez le tableau en stockage externe
call EXT.ConvertToExternal(
'covid_by_state',
'{
"adapter":"EXT.AWSS3",
"location":"s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/",
"type": "csv",
"delimiter": ",",
"skipHeaders": 1
}'
)
Si vous regardez de près - les arguments des procédures EXT.ExternalTable sont le nom de la table et ensuite une chaîne JSON, contenant plusieurs paramètres, tels que l'emplacement pour rechercher les fichiers, l'adaptateur à utiliser, le délimiteur, etc. En plus de AWS S3 External Table supporte le stockage Azure BLOB, Google Cloud Buckets et le système de fichiers local. GitHub Repo contient des références pour la syntaxe et les options supportées pour tous les formats.
Et enfin - faites une requête sur le tableau :
-- faites une requête sur le tableau :
select top 10 * from covid_by_state order by "date" desc
[SQL]USER>>select top 10 * from covid_by_state order by "date" desc
2. select top 10 * from covid_by_state order by "date" desc
date état fips cas morts
2020-12-06 Alabama 01 269877 3889
2020-12-06 Alaska 02 36847 136
2020-12-06 Arizona 04 364276 6950
2020-12-06 Arkansas 05 170924 2660
2020-12-06 California 06 1371940 19937
2020-12-06 Colorado 08 262460 3437
2020-12-06 Connecticut 09 127715 5146
2020-12-06 Delaware 10 39912 793
2020-12-06 District of Columbia 11 23136 697
2020-12-06 Florida 12 1058066 19176
L'interrogation des données de la tableau distant prend naturellement plus de temps que celle de la table "IRIS natif" ou global, mais ces données sont entièrement stockées et mises à jour sur le nuage et sont introduites dans IRIS en coulisse.
Explorons quelques autres caractéristiques de la table externe.
Dans notre exemple, le dossier du godet ne contient qu'un seul fichier. Le plus souvent, il contient plusieurs fichiers de la même structure, où le nom de fichier identifie soit l'horodatage, soit le numéro de périphérique, soit un autre attribut que nous voulons utiliser dans nos requêtes.
Le champ %PATH est automatiquement ajouté à chaque table externe et contient le chemin d'accès complet au fichier à partir duquel la ligne a été récupérée.
select top 5 %PATH, * from covid_by_state
%PATH date state fips cases deaths
s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/us-states.csv 2020-01-21 Washington 53 1 0
s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/us-states.csv 2020-01-22 Washington 53 1 0
s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/us-states.csv 2020-01-23 Washington 53 1 0
s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/us-states.csv 2020-01-24 Illinois 17 1 0
s3://covid19-lake/rearc-covid-19-nyt-data-in-usa/csv/us-states/us-states.csv 2020-01-24 Washington 53 1 0
Vous pouvez utiliser ce champ %PATH dans vos requêtes SQL comme n'importe quel autre champ.
Si votre tâche consiste à charger des données de S3 dans une table IRIS - vous pouvez utiliser l'External Table comme un outil ETL. Il suffit de le faire :
INSERT INTO internal_table SELECT * FROM external_table
Dans notre cas, si nous voulons copier les données COVID de S3 dans la table local :
--create local table
create table covid_by_state_local (
"date" DATE,
"state" VARCHAR(100),
fips INT,
cases INT,
deaths INT
)
--ETL from External to Local table
INSERT INTO covid_by_state_local SELECT TO_DATE("date",'YYYY-MM-DD'),state,fips,cases,deaths FROM covid_by_state
External Table est une table SQL. Il peut être joint à d'autres tables, utilisé dans des sous-sélections et des UNIONs. Vous pouvez même combiner la table IRIS "Régulier" et deux ou plusieurs tables externes provenant de sources différentes dans la même requête SQL.
Essayez de créer une table régulier, par exemple en faisant correspondre les noms d'État aux codes d'État, comme Washington - WA. Et joignez-la à notre table basé sur S3.
create table state_codes (name varchar(100), code char(2))
insert into state_codes values ('Washington','WA')
insert into state_codes values ('Illinois','IL')
select top 10 "date", state, code, cases from covid_by_state join state_codes on state=name
Remplacez 'join' par 'left join' pour inclure les lignes pour lesquelles le code d'état n'est pas défini. Comme vous pouvez le constater, le résultat est une combinaison de données provenant de S3 et de votre table IRIS natif.
La réserve de données AWS Covid est publique. N'importe qui peut y lire des données sans aucune authentification ou autorisation. Dans la vie réelle, vous souhaitez accéder à vos données de manière sécurisée, afin d'empêcher les étrangers de jeter un coup d'œil à vos fichiers. Les détails complets de la gestion des identités et des accès (IAM) d'AWS n'entrent pas dans le cadre de cet article. Mais le minimum, vous devez savoir que vous avez besoin au moins de la clé d'accès au compte AWS et du secret afin d'accéder aux données privées de votre compte. <https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys >
AWS utilise l'authentification par clé de compte/secrète autentification pour signer les demandes. https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys
Si vous exécutez IRIS External Table sur une instance EC2, la méthode recommandée pour gérer l'authentification est d'utiliser les rôles d'instance EC2 https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html IRIS External Table sera en mesure d'utiliser les permissions de ce rôle. Aucune configuration supplémentaire n'est requise.
Sur une instance locale/non EC2, vous devez spécifier AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY en spécifiant des variables d'environnement ou en installant et en configurant le client AWS CLI.
export AWS_ACCESS_KEY_ID=AKIAEXAMPLEKEY
export AWS_SECRET_ACCESS_KEY=111222333abcdefghigklmnopqrst
Assurez-vous que la variable d'environnement est visible dans votre processus IRIS. Vous pouvez le vérifier en exécutant :
USER>write $system.Util.GetEnviron("AWS_ACCESS_KEY_ID")
Il doit renvoi la valeur de clé.
ou installer AWS CLI, en suivant les instructions ici https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2-linux.html et exécuter :
aws configure
External Table sera alors en mesure de lire les informations d'identification à partir des fichiers de configuration aws cli. Votre shell interactif et votre processus IRIS peuvent être exécutés sous différents comptes - assurez-vous d'exécuter aws configure sous le même compte que votre processus IRIS.