Funciones de aprendizaje automático

evalMLMethod

La predicción con modelos de regresión ajustados se realiza con la función evalMLMethod. Consulte el enlace en linearRegression.

stochasticLinearRegression

La stochasticLinearRegression función de agregado implementa el método de descenso de gradiente estocástico con un modelo lineal y la función de pérdida MSE. Usa evalMLMethod para hacer predicciones sobre datos nuevos.

stochasticLogisticRegression

La función de agregado stochasticLogisticRegression implementa el método de descenso de gradiente estocástico para un problema de clasificación binaria. Usa evalMLMethod para hacer predicciones sobre datos nuevos.

naiveBayesClassifier

Clasifica el texto de entrada mediante un modelo de Naive Bayes con n-gramas y suavizado de Laplace. El modelo debe configurarse en ClickHouse antes de usarlo.

Sintaxis

naiveBayesClassifier(model_name, input_text);

Argumentos

model_name — Nombre del modelo preconfigurado. String El modelo debe estar definido en los archivos de configuración de ClickHouse (ver más abajo).
input_text — Texto que se va a clasificar. String La entrada se procesa exactamente como se proporciona (se conservan las mayúsculas/minúsculas y la puntuación).

Valor devuelto

ID de la clase predicha como un entero sin signo. UInt32 Los ID de clase corresponden a las categorías definidas durante la construcción del modelo.

Ejemplo

Clasifica un texto con un modelo de detección de idioma:

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

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

El resultado 0 podría representar el inglés, mientras que 1 podría indicar el francés; el significado de las clases depende de los datos de entrenamiento.

Detalles de implementación

Algoritmo Utiliza el algoritmo de clasificación Naive Bayes con suavizado de Laplace para manejar n-gramas no observados, a partir de probabilidades de n-gramas según esto.

Características principales

Admite n-gramas de cualquier tamaño
Tres modos de tokenización:
- byte: Opera sobre bytes sin procesar. Cada byte es un token.
- codepoint: Opera sobre valores escalares Unicode decodificados de UTF‑8. Cada punto de código es un token.
- token: Divide en secuencias de espacios en blanco Unicode (regex \s+). Los tokens son subcadenas sin espacios en blanco; la puntuación forma parte del token si está adyacente (p. ej., "you?" es un solo token).

Configuración del modelo

Puede encontrar aquí código fuente de ejemplo para crear un modelo de Naive Bayes para la detección de idiomas.

Además, puede encontrar aquí modelos de ejemplo y sus archivos de configuración asociados.

A continuación se muestra una configuración de ejemplo para un modelo de Naive Bayes en 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>

Parámetros de configuración

Parámetro	Descripción	Ejemplo	Predeterminado
name	Identificador único del modelo	`language_detection`	Obligatorio
path	Ruta completa al binario del modelo	`/etc/clickhouse-server/config.d/language_detection.bin`	Obligatorio
mode	Método de tokenización: - `byte`: Secuencias de bytes - `codepoint`: Caracteres Unicode - `token`: Tokens de palabras	`token`	Obligatorio
n	Tamaño del n-grama (modo `token`): - `1`=una sola palabra - `2`=pares de palabras - `3`=tríos de palabras	`2`	Obligatorio
alpha	Factor de suavizado de Laplace utilizado durante la clasificación para tratar n-gramas que no aparecen en el modelo	`0.5`	`1.0`
priors	Probabilidades de clase (% de los documentos que pertenecen a una clase)	60 % clase 0, 40 % clase 1	Distribución uniforme

Guía de entrenamiento del modelo

Formato de archivo En formato legible para humanos, para n=1 y el modo token, el modelo podría verse así:

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

Para n=3 y en modo codepoint, podría verse así:

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

El formato legible para humanos no lo usa ClickHouse directamente; debe convertirse al formato binario descrito a continuación.

Detalles del formato binario Cada n-gram se almacena como:

class_id de 4 bytes (UInt, little-endian)
Longitud en bytes de n-gram de 4 bytes (UInt, little-endian)
Bytes sin procesar de n-gram
count de 4 bytes (UInt, little-endian)

Requisitos de preprocesamiento Antes de crear el model a partir del corpus de documentos, estos deben preprocesarse para extraer n-gramas según los valores especificados de mode y n. Los siguientes pasos describen este preprocesamiento:

Añada marcadores de límite al inicio y al final de cada documento según el modo de tokenización:
- Byte: 0x01 (inicio), 0xFF (fin)
- Codepoint: U+10FFFE (inicio), U+10FFFF (fin)
- Token: <s> (inicio), </s> (fin)
Nota: Se añaden (n - 1) tokens tanto al principio como al final del documento.
Example para n=3 en modo token:
- Documento: "ClickHouse is fast"
- Se procesa como: <s> <s> ClickHouse is fast </s> </s>
- Trigramas generados:
  - <s> <s> ClickHouse
  - <s> ClickHouse is
  - ClickHouse is fast
  - is fast </s>
  - fast </s> </s>

Para simplificar la creación del modelo para los modos byte y codepoint, puede resultar conveniente tokenizar primero el documento en tokens (una lista de bytes para el modo byte y una lista de puntos de código para el modo codepoint). Luego, añada n - 1 tokens de inicio al principio y n - 1 tokens de fin al final del documento. Por último, genere los n-gramas y escríbalos en el archivo serializado.

evalMLMethod

Introducido en: v20.1.0

Aplica un modelo de aprendizaje automático entrenado a las variables de entrada para generar predicciones.

Sintaxis

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

Argumentos

model — El modelo de aprendizaje automático entrenado. AggregateFunctionState
x1, x2, ... — Valores de las características para la predicción. Float* o (U)Int*

Valor devuelto

Devuelve el valor predicho en función del modelo entrenado. Float64

Ejemplos

Ejemplo de uso

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

Introducido en: v25.11.0

Clasifica el texto de entrada mediante un diccionario NAIVE_BAYES. Devuelve el mismo valor de clase predicho que dictGet(dictionary_name, class_attribute, input_text), donde class_attribute es el nombre del atributo de etiqueta de clase configurado en el layout del diccionario. A diferencia de dictGet, el tipo del resultado siempre es UInt32 en lugar del tipo declarado del atributo de clase, y input_text debe ser un String (no se aplica ninguna conversión del tipo de clave).

Sintaxis

naiveBayesClassifier(dictionary_name, input_text)

Argumentos

dictionary_name — Nombre de un diccionario con el layout NAIVE_BAYES. String
input_text — Texto que se va a clasificar. String

Valor devuelto

ID de la clase predicha. UInt32

Ejemplos

Clasificar texto

-- 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

Introducido en: v26.7.0

Clasifica el texto de entrada mediante un diccionario NAIVE_BAYES y devuelve todas las clases con sus probabilidades, ordenadas de mayor a menor probabilidad.

Sintaxis

naiveBayesClassifierWithAllProbs(dictionary_name, input_text)

Argumentos

dictionary_name — Nombre de un diccionario con el layout NAIVE_BAYES. String
input_text — Texto que se va a clasificar. String

Valor devuelto

Array de tuplas (class_id, probability), ordenadas de la más probable a la menos probable. Array(Tuple(UInt32, Float64))

Ejemplos

Todas las probabilidades de clase

-- 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

Introducido en: v26.7.0

Clasifica el texto de entrada mediante un diccionario NAIVE_BAYES y devuelve la clase predicha junto con su probabilidad.

Sintaxis

naiveBayesClassifierWithProb(dictionary_name, input_text)

Argumentos

dictionary_name — Nombre de un diccionario con el layout NAIVE_BAYES. String
input_text — Texto que se va a clasificar. String

Valor devuelto

Tuple de (class_id, probability). Tuple(UInt32, Float64)

Ejemplos

Clasificación con probabilidad

-- 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) │
└────────────┘