Tutoriel postgresml: faire l'apprentissage automatique avec SQL

La tendance dominante de l'apprentissage automatique consiste à transférer des données dans l'environnement du modèle pour la formation. Cependant, que se passe-t-il si nous inversions ce processus? Étant donné que les bases de données modernes sont nettement plus grandes que les modèles d'apprentissage automatique, ne serait-il pas plus efficace de déplacer les modèles vers les ensembles de données?

Il s'agit du concept fondamental derrière PostgreSML - les données restent à son emplacement et vous apportez votre code à la base de données. Cette approche inversée de l'apprentissage automatique offre de nombreux avantages pratiques qui remettent en question les notions conventionnelles d'une «base de données».

postgresml: un aperçu et ses avantages

PostgreSML est une plate-forme d'apprentissage automatique complète construite sur la base de données PostgreSQL largement utilisée. Il introduit une nouvelle approche appelée apprentissage automatique "en database", vous permettant d'exécuter diverses tâches ML dans SQL sans avoir besoin d'outils distincts pour chaque étape.

Malgré sa nouveauté relative, PostgreSML offre plusieurs avantages clés:

• In-Database ML: Traintes, déploie et exécute des modèles ML directement dans votre base de données PostgreSQL. Cela élimine le besoin de transfert de données constant entre la base de données et les cadres ML externes, améliorant l'efficacité et réduisant la latence.
• API SQL: exploite SQL pour les modèles de formation, de réglage fin et de déploiement d'apprentissage automatique. Cela simplifie les workflows pour les analystes de données et les scientifiques moins familiers avec plusieurs frameworks ML.
• Modèles pré-formés: intègre de manière transparente à HuggingFace, donnant accès à de nombreux modèles pré-formés comme Llama, Falcon, Bert et Mistral.
• Personnalisation et flexibilité: prend en charge une large gamme d'algorithmes de Scikit-Learn, XgBoost, LGBM, Pytorch et Tensorflow, permettant de diverses tâches d'apprentissage supervisées directement dans la base de données.
• Intégration de l'écosystème: Fonctionne avec n'importe quel environnement prenant en charge les Postgres et propose des SDK pour plusieurs langages de programmation (JavaScript, Python et Rust sont particulièrement bien soutenus).

Ce tutoriel démontrera ces fonctionnalités à l'aide d'un flux de travail d'apprentissage automatique typique:

1. Chargement des données
2. Prétraitement des données
3. Formation du modèle
4. Hyperparamètre Fineding
5. Déploiement de la production

Toutes ces étapes seront effectuées dans une base de données Postgres. Commençons!

Un flux de travail d'apprentissage supervisé complet avec postgresml

Début: PostgreSML Free Tier

1. Créez un compte gratuit à https://www.php.cn/link/3349958a3e56580d4e415da345703886 :

2. Sélectionnez le niveau gratuit, qui propose des ressources généreuses:

Après l'inscription, vous accéderez à votre console postgresml pour gérer les projets et les ressources.

La section "Gérer" vous permet d'étendre votre environnement en fonction des besoins de calcul.

1. Installation et configuration de Postgres

PostgreSML nécessite PostgreSQL. Des guides d'installation pour diverses plates-formes sont disponibles:

• Windows
• mac os
• Linux

Pour WSL2, les commandes suivantes suffisent:

sudo apt update
sudo apt install postgresql postgresql-contrib
sudo passwd postgres  # Set a new Postgres password
# Close and reopen your terminal

Vérifiez l'installation:

psql --version

Pour une expérience plus conviviale que le terminal, considérez l'extension VScode.

2. Connexion de la base de données

Utilisez les détails de la connexion à partir de votre console postgresml:

Connectez-vous en utilisant psql:

psql -h "host" -U "username" -p 6432 -d "database_name"

Alternativement, utilisez l'extension VScode comme décrit dans sa documentation.

Activer l'extension PGML:

CREATE EXTENSION IF NOT EXISTS pgml;

Vérifiez l'installation:

SELECT pgml.version();

3. Chargement des données

Nous utiliserons l'ensemble de données Diamonds de Kaggle. Téléchargez-le en CSV ou utilisez cet extrait Python:

import seaborn as sns
diamonds = sns.load_dataset("diamonds")
diamonds.to_csv("diamonds.csv", index=False)

Créez le tableau:

CREATE TABLE IF NOT EXISTS diamonds (
   index SERIAL PRIMARY KEY,
   carat FLOAT,
   cut VARCHAR(255),
   color VARCHAR(255),
   clarity VARCHAR(255),
   depth FLOAT,
   table_ FLOAT,
   price INT,
   x FLOAT,
   y FLOAT,
   z FLOAT
);

remplir la table:

INSERT INTO diamonds
   (carat, cut, color, clarity, depth, table_, price, x, y, z)
   FROM '~/full/path/to/diamonds.csv'
   DELIMITER ','
   CSV HEADER;

Vérifiez les données:

SELECT * FROM diamonds LIMIT 10;

4. Formation du modèle

Formation de base

former un régresseur XGBOost:

SELECT pgml.train(
 project_name => 'Diamond prices prediction',
 task => 'regression',
 relation_name => 'diamonds',
 y_column_name => 'price',
 algorithm => 'xgboost'
);

former un classificateur multi-classes:

SELECT pgml.train(
 project_name => 'Diamond cut quality prediction',
 task => 'classification',
 relation_name => 'diamonds',
 y_column_name => 'cut',
 algorithm => 'xgboost',
 test_size => 0.1
);

Prétraitement

entraîner un modèle forestier aléatoire avec le prétraitement:

SELECT pgml.train(
   project_name => 'Diamond prices prediction',
   task => 'regression',
   relation_name => 'diamonds',
   y_column_name => 'price',
   algorithm => 'random_forest',
   preprocess => '{
       "carat": {"scale": "standard"},
       "depth": {"scale": "standard"},
       "table_": {"scale": "standard"},
       "cut": {"encode": "target", "scale": "standard"},
       "color": {"encode": "target", "scale": "standard"},
       "clarity": {"encode": "target", "scale": "standard"}
   }'::JSONB
);

postgresml fournit diverses options de prétraitement (codage, imputé, échelle).

Spécification des hyperparamètres

Former un régresseur XGBOost avec des hyperparamètres personnalisés:

sudo apt update
sudo apt install postgresql postgresql-contrib
sudo passwd postgres  # Set a new Postgres password
# Close and reopen your terminal

Tuning hyperparamètre

Effectuer une recherche sur la grille:

psql --version

5. Évaluation du modèle

Utiliser pgml.predict pour les prédictions:

psql -h "host" -U "username" -p 6432 -d "database_name"

Pour utiliser un modèle spécifique, spécifiez son identifiant:

CREATE EXTENSION IF NOT EXISTS pgml;

Récupérer les ID du modèle:

SELECT pgml.version();

6. Déploiement du modèle

PostgreSML déploie automatiquement le modèle le mieux performant. Pour un contrôle plus fin, utilisez pgml.deploy:

import seaborn as sns
diamonds = sns.load_dataset("diamonds")
diamonds.to_csv("diamonds.csv", index=False)

Les stratégies de déploiement incluent best_score, most_recent et rollback.

Exploration plus approfondie du postgresml

postgresml s'étend au-delà de l'apprentissage supervisé. La page d'accueil présente un éditeur SQL pour l'expérimentation. La construction d'un service ML orienté consommateur pourrait impliquer:

1. Création d'une interface utilisateur (par exemple, en utilisant Streamlit ou Taipy).
2. Développer un backend (python, node.js).
3. Utilisation de bibliothèques comme psycopg2 ou pg-promise pour l'interaction de la base de données.
4. Données de prétraitement dans le backend.
5. déclencher pgml.predict lors de l'interaction utilisateur.

Conclusion

PostgreSML offre une nouvelle approche de l'apprentissage automatique. Pour approfondir votre compréhension, explorez la documentation PostgreSML et envisagez des ressources comme les cours SQL de DataCamp et les tutoriels fondamentaux de l'IA.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!