Fonctions d’apprentissage automatique

evalMLMethod

La prédiction à l’aide de modèles de régression ajustés s’effectue avec la fonction evalMLMethod. Voir le lien sous linearRegression.

stochasticLinearRegression

La fonction d’agrégation stochasticLinearRegression implémente la méthode de descente de gradient stochastique à l’aide d’un modèle linéaire et de la fonction de perte MSE. Elle utilise evalMLMethod pour effectuer des prédictions sur de nouvelles données.

stochasticLogisticRegression

La fonction d’agrégation stochasticLogisticRegression implémente une méthode de descente de gradient stochastique pour un problème de classification binaire. Elle utilise evalMLMethod pour effectuer des prédictions sur de nouvelles données.

naiveBayesClassifier

Classe le texte d’entrée à l’aide d’un modèle Naive Bayes utilisant des n-grams et le lissage de Laplace. Le modèle doit être configuré dans ClickHouse avant d’être utilisé.

Syntaxe

naiveBayesClassifier(model_name, input_text);

Arguments

model_name — Nom du modèle préconfiguré. String Le modèle doit être défini dans les fichiers de configuration de ClickHouse (voir ci-dessous).
input_text — Texte à classer. String L’entrée est traitée exactement telle qu’elle est fournie (casse et ponctuation préservées).

Valeur de retour

ID de classe prédit, sous la forme d’un entier non signé. UInt32 Les ID de classe correspondent aux catégories définies lors de la création du modèle.

Exemple

Classer un texte avec un modèle de détection de langue :

SELECT naiveBayesClassifier('language', 'How are you?');

┌─naiveBayesClassifier('language', 'How are you?')─┐
│ 0                                                │
└──────────────────────────────────────────────────┘

Le résultat 0 peut correspondre à l’anglais, tandis que 1 peut correspondre au français - la signification de ces classes dépend de vos données d’entraînement.

Détails d’implémentation

Algorithme Utilise l’algorithme de classification Naive Bayes avec le lissage de Laplace pour gérer les n-grammes non observés, en s’appuyant sur des probabilités de n-grammes comme décrit ici.

Fonctionnalités clés

Prend en charge des n-grammes de toute taille
Trois modes de tokenisation :
- byte : fonctionne sur des octets bruts. Chaque octet constitue un token.
- codepoint : fonctionne sur des valeurs scalaires Unicode décodées à partir de l’UTF‑8. Chaque point de code constitue un token.
- token : découpe selon des séquences d’espaces blancs Unicode (regex \s+). Les tokens sont des sous-chaînes sans espace ; la ponctuation fait partie du token si elle est adjacente (par exemple, "you?" constitue un seul token).

Configuration du modèle

Vous trouverez ici un exemple de code source permettant de créer un modèle Naive Bayes pour la détection de langue.

En outre, des exemples de modèles ainsi que leurs fichiers de configuration associés sont disponibles ici.

Voici un exemple de configuration pour un modèle Naive Bayes dans ClickHouse :

<clickhouse>
    <nb_models>
        <model>
            <name>sentiment</name>
            <path>/etc/clickhouse-server/config.d/sentiment.bin</path>
            <n>2</n>
            <mode>token</mode>
            <alpha>1.0</alpha>
            <priors>
                <prior>
                    <class>0</class>
                    <value>0.6</value>
                </prior>
                <prior>
                    <class>1</class>
                    <value>0.4</value>
                </prior>
            </priors>
        </model>
    </nb_models>
</clickhouse>

Paramètres de configuration

Paramètre	Description	Exemple	Par défaut
name	Identifiant unique du modèle	`language_detection`	Obligatoire
path	Chemin complet vers le fichier binaire du modèle	`/etc/clickhouse-server/config.d/language_detection.bin`	Obligatoire
mode	Méthode de tokenisation : - `byte` : séquences d’octets - `codepoint` : caractères Unicode - `token` : tokens de mots	`token`	Obligatoire
n	Taille des n-gram (mode `token`) : - `1`=mot unique - `2`=paires de mots - `3`=triplets de mots	`2`	Obligatoire
alpha	Facteur de lissage de Laplace utilisé lors de la classification pour prendre en compte les n-gram absents du modèle	`0.5`	`1.0`
priors	Probabilités de classe (% de documents appartenant à une classe)	60 % classe 0, 40 % classe 1	Répartition égale

Guide d’entraînement du modèle

Format de fichier En format lisible par l’humain, pour n=1 et le mode token, le modèle peut ressembler à ceci :

<class_id> <n-gram> <count>
0 excellent 15
1 refund 28

Pour n=3 et le mode codepoint, on peut obtenir quelque chose comme :

<class_id> <n-gram> <count>
0 exc 15
1 ref 28

Le format human-readable n’est pas utilisé directement par ClickHouse ; il doit être converti dans le format binaire décrit ci-dessous.

Détails du format binaire Chaque n-gram est stocké comme suit :

class_id sur 4 octets (UInt, little-endian)
longueur en octets du n-gram sur 4 octets (UInt, little-endian)
octets bruts du n-gram
count sur 4 octets (UInt, little-endian)

Exigences de prétraitement Avant de créer le modèle à partir du corpus de documents, les documents doivent être prétraités afin d’extraire les n-gram selon les valeurs spécifiées de mode et n. Les étapes suivantes décrivent ce prétraitement :

Ajouter des marqueurs de début et de fin au début et à la fin de chaque document selon le mode de tokenisation :
- Byte : 0x01 (début), 0xFF (fin)
- Codepoint : U+10FFFE (début), U+10FFFF (fin)
- Token : <s> (début), </s> (fin)
Remarque : (n - 1) tokens sont ajoutés au début comme à la fin du document.
Exemple pour n=3 en mode token :
- Document : "ClickHouse is fast"
- Prétraité comme suit : <s> <s> ClickHouse is fast </s> </s>
- Trigrammes générés :
  - <s> <s> ClickHouse
  - <s> ClickHouse is
  - ClickHouse is fast
  - is fast </s>
  - fast </s> </s>

Pour simplifier la création du modèle pour les modes byte et codepoint, il peut être utile de commencer par tokeniser le document en tokens (une liste de bytes pour le mode byte et une liste de codepoints pour le mode codepoint). Ajoutez ensuite n - 1 tokens de début au début du document et n - 1 tokens de fin à la fin du document. Enfin, générez les n-grammes et enregistrez-les dans le fichier sérialisé.

evalMLMethod

Introduit dans : v20.1.0

Applique un modèle d’apprentissage automatique entraîné aux variables d’entrée afin de générer des prédictions.

Syntaxe

evalMLMethod(model, x1[, x2, ...])

Arguments

model — Le modèle d’apprentissage automatique entraîné. AggregateFunctionState
x1, x2, ... — Valeurs des caractéristiques pour la prédiction. Float* ou (U)Int*

Valeur renvoyée

Renvoie la valeur prédite à partir du modèle entraîné. Float64

Exemples

Exemple d'utilisation

CREATE TABLE trips (pickup_datetime DateTime('UTC'), trip_distance Float64, total_amount Float64) ENGINE = Memory;

-- A fare of 3, plus 2.5 for every unit of distance.
INSERT INTO trips
SELECT toDateTime('2020-01-01 00:00:00', 'UTC') + number * 60, number % 10 + 1, 2.5 * (number % 10 + 1) + 3
FROM numbers(1000);

-- One model per year of the data.
CREATE TABLE models ENGINE = Memory AS
SELECT
    toYear(pickup_datetime) AS year,
    stochasticLinearRegressionState(0.01, 0.0, 10, 'SGD')(total_amount, trip_distance) AS model
FROM trips
GROUP BY year;

SELECT
    trip_distance,
    round(evalMLMethod(model, trip_distance), 2) AS predicted,
    total_amount
FROM trips
LEFT JOIN models ON year = toYear(pickup_datetime)
ORDER BY pickup_datetime
LIMIT 5

┌─trip_distance─┬─predicted─┬─total_amount─┐
│             1 │      4.05 │          5.5 │
│             2 │      6.79 │            8 │
│             3 │      9.53 │         10.5 │
│             4 │     12.28 │           13 │
│             5 │     15.02 │         15.5 │
└───────────────┴───────────┴──────────────┘

naiveBayesClassifier

Introduit dans : v25.11.0

Classe le texte d’entrée à l’aide d’un dictionnaire NAIVE_BAYES. Renvoie la même valeur de classe prédite que dictGet(dictionary_name, class_attribute, input_text), où class_attribute est le nom de l’attribut de libellé de classe configuré dans le layout du dictionnaire. Contrairement à dictGet, le type de résultat est toujours UInt32 plutôt que le type déclaré de l’attribut de classe, et input_text doit être une String (aucune conversion de type de clé n’est appliquée).

Syntaxe

naiveBayesClassifier(dictionary_name, input_text)

Arguments

dictionary_name — Nom d'un dictionnaire avec le layout NAIVE_BAYES. String
input_text — Texte à classer. String

Valeur renvoyée

ID de la classe prédite. UInt32

Exemples

Classer un texte

-- A dictionary built from the token counts of two classes: 0 for a positive review, 1 for a negative one.
CREATE TABLE review_tokens (ngram String, class_id UInt32, count UInt64) ENGINE = Memory;
INSERT INTO review_tokens VALUES ('good', 0, 5), ('great', 0, 4), ('excellent', 0, 3), ('bad', 1, 5), ('awful', 1, 4), ('terrible', 1, 3);

CREATE DICTIONARY sentiment (ngram String, class_id UInt32 DEFAULT 0, count UInt64 DEFAULT 0)
PRIMARY KEY ngram
SOURCE(CLICKHOUSE(TABLE 'review_tokens'))
LAYOUT(NAIVE_BAYES(class_attribute 'class_id' n 1 mode 'token'))
LIFETIME(0);

SELECT naiveBayesClassifier('sentiment', 'a good and great film') AS class_id;

┌─class_id─┐
│        0 │
└──────────┘

naiveBayesClassifierWithAllProbs

Introduit dans : v26.7.0

Classe le texte d’entrée à l’aide d’un dictionnaire NAIVE_BAYES et renvoie toutes les classes avec leurs probabilités, classées de la plus probable à la moins probable.

Syntaxe

naiveBayesClassifierWithAllProbs(dictionary_name, input_text)

Arguments

dictionary_name — Nom d’un dictionnaire utilisant le layout NAIVE_BAYES. String
input_text — Texte à classer. String

Valeur renvoyée

Tableau de tuples (class_id, probability) triés du plus probable au moins probable. Array(Tuple(UInt32, Float64))

Exemples

Toutes les probabilités de classe

-- A dictionary built from the token counts of two classes: 0 for a positive review, 1 for a negative one.
CREATE TABLE review_tokens (ngram String, class_id UInt32, count UInt64) ENGINE = Memory;
INSERT INTO review_tokens VALUES ('good', 0, 5), ('great', 0, 4), ('excellent', 0, 3), ('bad', 1, 5), ('awful', 1, 4), ('terrible', 1, 3);

CREATE DICTIONARY sentiment (ngram String, class_id UInt32 DEFAULT 0, count UInt64 DEFAULT 0)
PRIMARY KEY ngram
SOURCE(CLICKHOUSE(TABLE 'review_tokens'))
LAYOUT(NAIVE_BAYES(class_attribute 'class_id' n 1 mode 'token'))
LIFETIME(0);

SELECT arrayMap(p -> (p.1, round(p.2, 4)), naiveBayesClassifierWithAllProbs('sentiment', 'a good and great film')) AS predictions;

┌─predictions─────────────┐
│ [(0,0.9677),(1,0.0323)] │
└─────────────────────────┘

naiveBayesClassifierWithProb

Introduit dans : v26.7.0

Classe le texte d’entrée à l’aide d’un dictionnaire NAIVE_BAYES et renvoie la classe prédite ainsi que sa probabilité.

Syntaxe

naiveBayesClassifierWithProb(dictionary_name, input_text)

Arguments

dictionary_name — Nom d’un dictionnaire avec le layout NAIVE_BAYES. String
input_text — Texte à classer. String

Valeur renvoyée

Tuple de (class_id, probabilité). Tuple(UInt32, Float64)

Exemples

Classer avec probabilité

-- A dictionary built from the token counts of two classes: 0 for a positive review, 1 for a negative one.
CREATE TABLE review_tokens (ngram String, class_id UInt32, count UInt64) ENGINE = Memory;
INSERT INTO review_tokens VALUES ('good', 0, 5), ('great', 0, 4), ('excellent', 0, 3), ('bad', 1, 5), ('awful', 1, 4), ('terrible', 1, 3);

CREATE DICTIONARY sentiment (ngram String, class_id UInt32 DEFAULT 0, count UInt64 DEFAULT 0)
PRIMARY KEY ngram
SOURCE(CLICKHOUSE(TABLE 'review_tokens'))
LAYOUT(NAIVE_BAYES(class_attribute 'class_id' n 1 mode 'token'))
LIFETIME(0);

WITH naiveBayesClassifierWithProb('sentiment', 'a good and great film') AS p
SELECT (p.1, round(p.2, 4)) AS prediction;

┌─prediction─┐
│ (0,0.9677) │
└────────────┘