---
title: "Algoritmos de Regresión"
url: https://docs.catalyst.zoho.com/es/quickml/help/ml-algorithms/regression-algorithms/
description: "QuickML is a fully no-code ML pipeline builder service in the Catalyst development platform for creating machine-learning pipelines with end-to-end solutions."
last_updated: 2026-03-24T12:08:39Z
service: QuickML
type: general
---

# Algoritmos de regresión
La regresión es la tarea de predecir una cantidad continua. QuickML cuenta con los siguientes algoritmos de regresión

1. ### AdaBoost Regression

    Adaboost es un algoritmo de aprendizaje automático que construye una serie de árboles de decisión pequeños, de un solo paso (un nivel), adaptando cada árbol para predecir casos difíciles omitidos por los árboles anteriores y combinando todos los árboles en un solo modelo.

    Esta regresión comienza ajustando un regresor en el conjunto de datos original, seguido del ajuste de copias adicionales del regresor en el mismo conjunto de datos. Los pesos de estas instancias se ajustan según el error de la predicción actual. De modo que los regresores subsiguientes se centran más en los casos difíciles.

    El boosting en aprendizaje automático es una forma de combinar múltiples modelos simples en un solo modelo compuesto. Por eso el boosting se conoce como un modelo aditivo, ya que los modelos simples (también conocidos como aprendices débiles) se añaden uno a la vez, mientras se mantienen los árboles existentes en el modelo sin cambios. A medida que combinamos más y más modelos simples, el modelo final completo se convierte en un predictor más fuerte.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`base_estimator`</td>
            <td>El estimador base a partir del cual se construye el conjunto potenciado. Si es None, entonces el estimador base es DecisionTreeRegressor inicializado con max_depth=3.</td>
            <td>object</td>
            <td>Cualquier modelo de regresión</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`n_estimators` 
(number of estimators)</td>
            <td>El número máximo de estimadores en los que se termina el boosting. En caso de ajuste perfecto, el procedimiento de aprendizaje se detiene anticipadamente.</td>
            <td>int</td>
            <td>[1, 500]</td>
            <td>50</td>
        </tr>
        <tr>
            <td>`learning_rate`</td>
            <td>Peso aplicado a cada regresor en cada iteración de boosting. Una tasa de aprendizaje más alta aumenta la contribución de cada regresor.</td>
            <td>float</td>
            <td>(0.0, +Inf)</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`loss`</td>
            <td>La función de pérdida a usar cuando se actualizan los pesos después de cada iteración de boosting.</td>
            <td>string</td>
            <td>{'linear', 'square', 'exponential'}</td>
            <td>&quot;linear&quot;</td>
        </tr>
    </tbody>
    </table>

2. ### CatBoost Regression

    CatBoost se basa en árboles de decisión con gradient boosting. Durante el entrenamiento, se construye un conjunto de árboles de decisión consecutivamente. Cada árbol sucesivo se construye con una pérdida reducida en comparación con los árboles anteriores. El número de árboles se controla mediante los parámetros iniciales.

    Tiene un tiempo de predicción mucho menor en comparación con otros.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
        <td>learning_rate</td>
        <td>La tasa de aprendizaje utilizada para el entrenamiento.</td>
        <td>float</td>
        <td>(0,1]</td>
        <td>0.03</td>
        </tr>
        <tr>
            <td>`l2_leaf_reg` (l2_leaf_regularization)</td>
            <td>Coeficiente del término de regularización L2 de la función de costo.</td>
            <td>float</td>
            <td>[0,+Inf)</td>
            <td>3.0</td>
        </tr>
        <tr>
            <td>`rsm` (random subspace method)</td>
            <td>El porcentaje de características a usar en cada selección de división, cuando las características se seleccionan nuevamente de forma aleatoria.</td>
            <td>float</td>
            <td>(0,1]</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`loss_function`</td>
            <td>La métrica a usar en el entrenamiento. El valor especificado también determina el problema de aprendizaje automático a resolver. Algunas métricas soportan parámetros opcionales.</td>
            <td>string</td>
            <td>{&#39;RMSE&#39;,  &#39;MAE&#39;,  &#39;Quantile:alpha=value, &#39;LogLinQuantile: alpha=value&#39;, &#39;Poisson&#39;,  &#39;MAPE&#39;, &#39;Lq:q=value&#39;, &#39;SurvivalAft:dist=value; scale=value&#39;}  Note : range of value = [0, 1]</td>
            <td>&#39;RMSE&#39;</td>
        </tr>
        <tr>
            <td>`nan_mode`</td>
            <td>El método para procesar valores faltantes en el conjunto de datos de entrada.</td>
            <td>string</td>
            <td>{&#39;Forbidden&#39;, &#39;Min&#39;, &#39;Max&#39;}</td>
            <td>Min</td>
        </tr>
        <tr>
            <td>`leaf_estimation_method`</td>
            <td>El método utilizado para calcular los valores en las hojas.</td>
            <td>string</td>
            <td>{&quot;Newton&quot;, &quot;Gradient&quot;}</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`score_function`</td>
            <td>El tipo de puntuación utilizado para seleccionar la siguiente división durante la construcción del árbol.</td>
            <td>string</td>
            <td>{L2, Cosine}</td>
            <td>Cosine</td>
        </tr>
        <tr>
            <td>`max_depth`</td>
            <td>Profundidad máxima del árbol.</td>
            <td>int</td>
            <td>[1,+Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`n_estimators` 
(number of estimators)</td>
            <td>El número máximo de árboles que se pueden construir al resolver problemas de aprendizaje automático. Al usar otros parámetros que limitan el número de iteraciones, el número final de árboles puede ser menor que el número especificado en este parámetro.</td>
            <td>int</td>
            <td>[1, 500]</td>
            <td>None</td>
        </tr>
        </tbody>
        </table>

3. ### Decision-Tree Regression

    El árbol de decisión construye modelos de clasificación o regresión en forma de estructura de árbol. Descompone un conjunto de datos en subconjuntos cada vez más pequeños mientras que al mismo tiempo se desarrolla incrementalmente un árbol de decisión asociado. Los árboles de decisión pueden manejar tanto datos categóricos como numéricos. Al predecir el valor de salida de un conjunto de características, predecirá la salida basándose en el subconjunto en el que cae el conjunto de características.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`criterion`</td>
            <td>La función para medir la calidad de una división.</td>
            <td>string</td>
            <td>{&quot;mse&quot;, &quot;friedman_mse&quot;, &quot;mae&quot;}</td>
            <td>&quot;mse"</td>
        </tr>
        <tr>
            <td>`splitter`</td>
            <td>La estrategia utilizada para elegir la división en cada nodo.</td>
            <td>string</td>
            <td>{"best", "random"}</td>
            <td>"best"</td>
        </tr>
        <tr>
            <td>`max_depth`</td>
            <td>La profundidad máxima del árbol. Si es None, entonces los nodos se expanden hasta que todas las hojas sean puras o hasta que todas las hojas contengan menos de min_samples_split muestras.</td>
            <td>int</td>
            <td>(0, +Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`min_samples_split`</td>
            <td>El número mínimo de muestras requeridas para dividir un nodo interno</td>
            <td>int  or float</td>
            <td>[2, +Inf) or (0, 1.0]</td>
            <td>2</td>
        </tr>
        <tr>
            <td>`min_samples_leaf`</td>
            <td>El número mínimo de muestras requeridas para estar en un nodo hoja. Un punto de división en cualquier profundidad solo se considerará si deja al menos min_samples_leaf muestras de entrenamiento en cada una de las ramas izquierda y derecha.</td>
            <td>int or float</td>
            <td>[1, +Inf) or (0, 0.5]</td>
            <td>1</td>
        </tr>
        <tr>
            <td>`min_weight_fraction_leaf`</td>
            <td>La fracción ponderada mínima de la suma total de pesos (de todas las muestras de entrada) requerida para estar en un nodo hoja.</td>
            <td>float</td>
            <td>[0, 0.5]</td>
            <td>0</td>
        </tr>
        <tr>
            <td>`max_features`</td>
            <td>El número de características a considerar cuando se busca la mejor división</td>
            <td>int, float or string</td>
            <td>(0, n_features] or { "sqrt", "log2"},</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`max_leaf_nodes`</td>
            <td>Hacer crecer un árbol con max_leaf_nodes de la mejor manera posible. Los mejores nodos se definen como la reducción relativa en impureza.</td>
            <td>int</td>
            <td>(1, +Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`min_impurity_decrease`</td>
            <td>Un nodo se dividirá si esta división induce una disminución de la impureza mayor o igual a este valor.</td>
            <td>float</td>
            <td>[0, +Inf)</td>
            <td>0.0</td>
        </tr>
        </tbody>
        </table>

4. ### ElasticNet Regression

    Elastic net es un tipo popular de regresión lineal regularizada que combina dos funciones de penalización populares, específicamente las penalizaciones L1 (Lasso Regression) y L2 (Ridge Regression). Elastic Net es una extensión de la regresión lineal que añade penalizaciones de regularización a la función de pérdida durante el entrenamiento.

    La regularización es una técnica para prevenir que el modelo se sobreajuste añadiendo información extra al mismo. En la técnica de regularización, reducimos la magnitud de las características manteniendo el mismo número de características.

    A veces, la regresión lasso puede causar un pequeño sesgo (diferencia entre el valor predicho y el real) en el modelo donde la predicción depende demasiado de una variable particular. En estos casos, elastic net demuestra un mejor rendimiento al combinar la regularización tanto de lasso como de ridge regression.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`alpha`</td>
            <td>Constante que multiplica los términos de penalización.</td>
            <td>float</td>
            <td>(0, +Inf)</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`l1_ratio`</td>
            <td>El parámetro de mezcla ElasticNet, con
0 &lt;= l1_ratio &lt;= 1.
 Para l1_ratio = 0 la penalización es una penalización L2.
 Para l1_ratio = 1 es una penalización L1.
 Para 0 &lt; l1_ratio &lt; 1, la penalización es una combinación de L1 y L2.</td>
            <td>float</td>
            <td>[0, 1]</td>
            <td>0.5</td>
        </tr>
        <tr>
            <td>`fit_intercept`</td>
            <td>Si se debe estimar el intercepto o no.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>True</td>
        </tr>
        <tr>
            <td>`normalize`</td>
            <td>Este parámetro se ignora cuando fit_intercept se establece en False. Si es True, los regresores X se normalizarán antes de la regresión restando la media y dividiendo por la norma l2.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`tol` (tolerance)</td>
            <td>La tolerancia para la optimización: si las actualizaciones son más pequeñas que tol, el código de optimización verifica el gap dual para la optimalidad y continúa hasta que sea más pequeño que tol.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1e-4</td>
        </tr>
        <tr>
            <td>`warm_start`</td>
            <td>Cuando se establece en True, reutiliza la solución de la llamada anterior a fit como inicialización, de lo contrario, simplemente borra la solución anterior.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`positive`</td>
            <td>Cuando se establece en True, fuerza a los coeficientes a ser positivos.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`selection`</td>
            <td>Si se establece en 'random', un coeficiente aleatorio se actualiza en cada iteración en lugar de recorrer las características secuencialmente por defecto.</td>
            <td>string</td>
            <td>{&quot;cyclic&quot;, &quot;random&quot;}</td>
            <td>&quot;cyclic&quot;</td>
        </tr>
        </tbody>
        </table>

5. ### GB Regression
    
    La regresión por gradient-boosting calcula la diferencia entre la predicción actual y el valor objetivo correcto conocido.

    Esta diferencia se llama residuo. Después de obtener este valor, la regresión gradient-boosting entrena un modelo débil (Árbol de Decisión) que mapea características a ese residuo. Este residuo predicho por un modelo débil se añade a la entrada del modelo existente, empujando al modelo hacia el objetivo correcto. Repetir este paso múltiples veces mejora la predicción general del modelo.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`loss`</td>
            <td>Función de pérdida a optimizar. 'ls' se refiere a la regresión de mínimos cuadrados. 'lad' (desviación absoluta mínima) es una función de pérdida altamente robusta basada únicamente en la información de orden de las variables de entrada. 'huber' es una combinación de ambas. 'quantile' permite la regresión cuantílica (use alpha para especificar el cuantil).</td>
            <td>string</td>
            <td>{&#39;ls&#39;, &#39;lad&#39;, &#39;huber&#39;, &#39;quantile&#39;}</td>
            <td>'ls'</td>
        </tr>
        <tr>
            <td>`learning_rate`</td>
            <td>La tasa de aprendizaje reduce la contribución de cada árbol por learning_rate.</td>
            <td>float</td>
            <td>(0.0, +inf)</td>
            <td>0.1</td>
        </tr>
        <tr>
            <td>`n_estimators`
 (number of estimators)</td>
            <td>El número de etapas de boosting a realizar. El gradient boosting es bastante robusto al sobreajuste, por lo que un número grande generalmente resulta en mejor rendimiento.</td>
            <td>int</td>
            <td>[1, 500)</td>
            <td>100</td>
        </tr>
        <tr>
            <td>`criterion`</td>
            <td>La función para medir la calidad de una división.</td>
            <td>string</td>
            <td>{&#39;friedman_mse&#39;, &#39;mse&#39;, &#39;mae&#39;}</td>
            <td>'friedman_mse'</td>
        </tr>
        <tr>
            <td>`subsample`</td>
            <td>La fracción de muestras a usar para ajustar los aprendices base individuales.</td>
            <td>float</td>
            <td>(0.0, 1.0]</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`max_depth`</td>
            <td>Profundidad máxima de los estimadores de regresión individuales. La profundidad máxima limita el número de nodos en el árbol.</td>
            <td>int</td>
            <td>(0, +Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`min_samples_split`</td>
            <td>El número mínimo de muestras requeridas para dividir un nodo interno</td>
            <td>int or float</td>
            <td>[2, +Inf) or (0, 1.0]</td>
            <td>2</td>
        </tr>
        <tr>
            <td>`min_samples_leaf`</td>
            <td>El número mínimo de muestras requeridas para estar en un nodo hoja. Un punto de división en cualquier profundidad solo se considerará si deja al menos min_samples_leaf muestras de entrenamiento en cada una de las ramas izquierda y derecha.</td>
            <td>int or float</td>
            <td> [1, +Inf) or (0, 0.5]</td>
            <td>1</td>
        </tr>
        <tr>
            <td>`min_weight_fraction_leaf`</td>
            <td>La fracción ponderada mínima de la suma total de pesos (de todas las muestras de entrada) requerida para estar en un nodo hoja.</td>
            <td>float</td>
            <td>[0, 0.5]</td>
            <td>0</td>
        </tr>
        <tr>
            <td>`max_features`</td>
            <td>El número de características a considerar cuando se busca la mejor división</td>
            <td>int, float or string</td>
            <td>(0, n_features] or { "sqrt", "log2"}</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`max_leaf_nodes`</td>
            <td>Hacer crecer árboles con max_leaf_nodes de la mejor manera posible. Los mejores nodos se definen como la reducción relativa en impureza.</td>
            <td>int</td>
            <td>(1, +Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`min_impurity_decrease`</td>
            <td>Un nodo se dividirá si esta división induce una disminución de la impureza mayor o igual a este valor.</td>
            <td>float</td>
            <td>[0, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`init`</td>
            <td>Un objeto estimador que se utiliza para calcular las predicciones iniciales. init debe proporcionar fit y predict. Si es 'zero', las predicciones brutas iniciales se establecen en cero.</td>
            <td>object</td>
            <td>estimador (Modelo de regresión excepto cat boost) o 'zero'</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`warm_start`</td>
            <td>Cuando se establece en True, reutiliza la solución de la llamada anterior a fit y añade más estimadores al conjunto, de lo contrario, simplemente borra la solución anterior.</td>
            <td>bool</td>
            <td>True or  False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`tol` (tolerance)</td>
            <td>Tolerancia para la parada anticipada. Cuando la pérdida no mejora en al menos tol durante n_iter_no_change iteraciones (si se establece en un número), el entrenamiento se detiene.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1e-4</td>
        </tr>
    </tbody>
    </table>

6. ### KNN Regression
    
    La Regresión KNN funciona encontrando las distancias entre una consulta (instancia de datos) y todos los ejemplos en los datos, seleccionando el número especificado de ejemplos (K) más cercanos a la consulta, y luego vota por el punto que es el promedio de las observaciones en el mismo vecindario.

    En otras palabras, aproxima la asociación entre las variables independientes (variables de entrada) y el resultado continuo (objetivo) promediando las observaciones en el mismo vecindario.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
        <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`n_neighbors` 
(number of neighbours)</td>
            <td>Número de vecinos a usar por defecto para consultas kneighbors.</td>
            <td>int</td>
            <td>[1, n]
 n = Número total de registros en el conjunto de datos</td>
            <td>5</td>
        </tr>
        <tr>
            <td>`weights`</td>
            <td>Función de peso utilizada en la predicción.<ul style="text-align: left; ;"><li><strong>'uniform'</strong>: pesos uniformes. Todos los puntos en cada vecindario se ponderan igualmente. <li><strong>'distance'</strong>: pondera los puntos por el inverso de su distancia. En este caso, los vecinos más cercanos de un punto de consulta tendrán mayor influencia que los vecinos más lejanos.</ul></td>
            <td>string</td>
            <td>{'uniform', 'distance'}</td>
            <td>'uniform'</td>
        </tr>
        <tr>
            <td>`algorithm`</td>
            <td>Algoritmo utilizado para calcular los vecinos más cercanos</td>
            <td>string</td>
            <td>{'auto', 'ball_tree', 'kd_tree', 'brute'}</td>
            <td>'auto'</td>
        </tr>
        <tr>
            <td>`leaf_size`</td>
            <td>Tamaño de hoja pasado a BallTree o KDTree. Esto puede afectar la velocidad de la construcción y la consulta, así como la memoria requerida para almacenar el árbol. El valor óptimo depende de la naturaleza del problema.</td>
            <td>int</td>
            <td> (1, +Inf)</td>
            <td>30</td>
        </tr>
        <tr>
            <td>`p`</td>
            <td>Parámetro de potencia para la métrica de Minkowski. Cuando p = 1, esto es equivalente a usar manhattan_distance (l1), y euclidean_distance (l2) 
para p = 2. Para p arbitrario, se usa minkowski_distance (l_p).</td>
            <td>int</td>
            <td>[1,3]</td>
            <td>2</td>
        </tr>
        <tr>
            <td>`metric`</td>
            <td>Métrica a usar para el cálculo de distancia. El valor predeterminado es "minkowski", que resulta en la distancia euclidiana estándar cuando p = 2.</td>
            <td>str</td>
            <td>{'cityblock', 'cosine', &#39;euclidean&#39;, &#39;l1&#39;, &#39;l2&#39;, &#39;manhattan&#39;, &#39;nan_euclidean&#39;, 'minkowski'}</td>
            <td>'minkowski'</td>
        </tr>
        </tbody>
        </table>

7. ### kernel Regression

    Esta regresión simplemente ajusta una línea a un diagrama de dispersión. Los valores del kernel se utilizan para derivar pesos para predecir salidas a partir de entradas dadas. La regresión kernel es una técnica no paramétrica para estimar la expectativa condicional de una variable aleatoria. El objetivo es encontrar una relación no lineal entre un par de variables aleatorias X e Y.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`alpha`</td>
            <td>Fuerza de regularización; debe ser un float positivo. La regularización mejora el condicionamiento del problema y reduce la varianza de las estimaciones. Valores más grandes especifican una regularización más fuerte.</td>
            <td>float</td>
            <td>[0, +Inf)</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`kernel`</td>
            <td>Mapeo del kernel utilizado internamente. Este parámetro se pasa directamente a pairwise_kernel. Si kernel es una cadena, debe ser una de las métricas en pairwise. PAIRWISE_KERNEL_FUNCTIONS o "precomputed". Si kernel es "precomputed", se asume que X es una matriz de kernel.</td>
            <td>string</td>
            <td>{'additive_chi2',&#39;chi2&#39; 'linear', 'poly', 'polynomial', 'rbf', 'laplacian', 'sigmoid', &#39;cosine'}</td>
            <td>"linear"</td>
        </tr>
        <tr>
            <td>`gamma`</td>
            <td>Parámetro gamma para los kernels RBF, laplacian, polinomial, exponencial chi2 y sigmoid. La interpretación del valor predeterminado se deja al kernel; consulte la documentación de sklearn.metrics.pairwise.</td>
            <td>float</td>
            <td>[0, +Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`degree`</td>
            <td>Grado del kernel polinomial.</td>
            <td>float</td>
            <td>[0, +Inf)</td>
            <td>3</td>
        </tr>
        <tr>
            <td>`coef0`</td>
            <td>Coeficiente cero para kernels polinomiales y sigmoid.</td>
            <td>float</td>
            <td>(-Inf, +Inf)</td>
            <td>1</td>
        </tr>
    </tbody>
    </table>

8. ### LGBM Regression

    LGBM funciona comenzando con una estimación inicial que se actualiza usando la salida de cada árbol. El parámetro de aprendizaje controla la magnitud de este cambio en las estimaciones. Se puede usar en cualquier dato y proporciona un alto grado de precisión, ya que contiene muchos pasos de preprocesamiento integrados.

    El algoritmo LightGBM crece verticalmente, lo que significa que crece por hojas, mientras que otros algoritmos crecen por niveles. LightGBM elige la hoja con la mayor pérdida para crecer. Puede reducir más la pérdida que un algoritmo por niveles al hacer crecer la misma hoja.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`boosting_type`</td>
            <td>Método de Boosting.</td>
            <td>string</td>
            <td>{'gbdt', 'dart', 'goss'}</td>
            <td>&#39;gbdt&#39;</td>
        </tr>
        <tr>
            <td>`num_leaves`</td>
            <td>Hojas máximas del árbol para aprendices base.</td>
            <td>int</td>
            <td>(1, +Inf)</td>
            <td>31</td>
        </tr>
        <tr>
            <td>`max_depth`</td>
            <td>Profundidad máxima del árbol para aprendices base, &lt;= 0 significa sin límite.</td>
            <td>int</td>
            <td>(-Inf, +Inf)</td>
            <td>-1</td>
        </tr>
        <tr>
            <td>`learning_rate`</td>
            <td>Tasa de aprendizaje de boosting.</td>
            <td>float</td>
            <td>(0.0, +Inf)</td>
            <td>0.1</td>
        </tr>
        <tr>
            <td>`n_estimators`
 (number of estimators)</td>
            <td>Número de árboles potenciados a ajustar.</td>
            <td>int</td>
            <td>[1, 500]</td>
            <td>100</td>
        </tr>
        <tr>
            <td>`subsample_for_bin`</td>
            <td>Número de muestras para construir bins.</td>
            <td>int</td>
            <td>(0, +Inf)</td>
            <td>200000</td>
        </tr>
        <tr>
            <td>`min_split_gain`</td>
            <td>Reducción mínima de pérdida requerida para hacer una partición adicional en un nodo hoja del árbol.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`min_child_weight`</td>
            <td>Suma mínima del peso de la instancia (Hessiano) necesaria en un hijo (hoja).</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1e-3</td>
        </tr>
        <tr>
            <td>`min_child_samples`</td>
            <td>Número mínimo de datos necesarios en un hijo (hoja).</td>
            <td>int</td>
            <td>[0, +Inf)</td>
            <td>20</td>
        </tr>
        <tr>
            <td>`subsample`</td>
            <td>Proporción de submuestreo de la instancia de entrenamiento.</td>
            <td>float</td>
            <td>(0.0, 1.0]</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`subsample_freq` (subsample_frequency)</td>
            <td>Frecuencia de submuestreo, &lt;= 0 significa no habilitado.</td>
            <td>int</td>
            <td>(-Inf, +Inf)</td>
            <td>0</td>
        </tr>
        <tr>
            <td>`colsample_bytree` (column sample by tree)</td>
            <td>Proporción de submuestreo de columnas al construir cada árbol.</td>
            <td>float</td>
            <td>(0.0, 1.0]</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`reg_alpha` (alpha)</td>
            <td>Término de regularización L1 en los pesos.</td>
            <td>float</td>
            <td>(0.0, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`reg_lambda` (lambda)</td>
            <td>Término de regularización L2 en los pesos.</td>
            <td>float</td>
            <td>(0.0, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`importance_type`</td>
            <td>El tipo de importancia de característica a llenar en feature<em>importances</em>. Si es 'split', el resultado contiene el número de veces que la característica se usa en un modelo. Si es 'gain', el resultado contiene las ganancias totales de las divisiones que usan la característica.</td>
            <td>string</td>
            <td>{ 'gain', &#39;split&#39;}</td>
            <td>&#39;split&#39;</td>
        </tr>
        </tbody>
        </table>

9. ### Lasso Regression
    
    La regresión Lasso es una técnica de regularización. Se utiliza sobre métodos de regresión para una predicción más precisa. La regresión Lasso es un tipo de regresión lineal que utiliza contracción. La contracción es donde los valores de los datos se contraen hacia un punto central, como la media. El procedimiento lasso fomenta modelos simples y dispersos (es decir, modelos con menos parámetros).

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`alpha`</td>
            <td>Constante que multiplica el término L1, controlando la fuerza de regularización. alpha debe ser un float no negativo</td>
            <td>float</td>
            <td>(0, +Inf)</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`fit_intercept`</td>
            <td>Si se debe calcular el intercepto para este modelo. Si se establece en False, no se usará intercepto en los cálculos</td>
            <td>bool</td>
            <td>True or False</td>
            <td>True</td>
        </tr>
        <tr>
            <td>`normalize`</td>
            <td>Este parámetro se ignora cuando fit_intercept se establece en False. Si es True, los regresores X se normalizarán antes de la regresión restando la media y dividiendo por la norma l2.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`tol` (tolerance)</td>
            <td>La tolerancia para la optimización: si las actualizaciones son más pequeñas que tol, el código de optimización verifica el gap dual para la optimalidad y continúa hasta que sea más pequeño que tol.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1e-4</td>
        </tr>
        <tr>
            <td>`warm_start`</td>
            <td>Cuando se establece en True, reutiliza la solución de la llamada anterior a fit como inicialización, de lo contrario, simplemente borra la solución anterior.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`positive`</td>
            <td>Cuando se establece en True, fuerza a los coeficientes a ser positivos.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`selection`</td>
            <td>Si se establece en 'random', un coeficiente aleatorio se actualiza en cada iteración en lugar de recorrer las características secuencialmente por defecto.</td>
            <td>string</td>
            <td>{&quot;cyclic&quot;, &quot;random&quot;}</td>
            <td>&quot;cyclic&quot;</td>
        </tr>
    </tbody>
    </table>

10. ### Linear Regression
    
    La regresión lineal es un modelo de regresión que estima la relación lineal entre la variable independiente (entrada) y la variable dependiente (objetivo) usando una línea recta. Es el algoritmo básico para problemas de tipo regresión.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`fit_intercept`</td>
            <td>Si se debe calcular el intercepto para este modelo. Si se establece en False, no se usará intercepto en los cálculos.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>True</td>
        </tr>
        <tr>
            <td>`normalize`</td>
            <td>Este parámetro se ignora cuando fit_intercept se establece en False. Si es True, los regresores X se normalizarán antes de la regresión restando la media y dividiendo por la 
norma l2.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        </tbody>
        </table>

11. ### Random-Forest Regression
    
    El bosque aleatorio es un algoritmo de clasificación y regresión que consiste en muchos árboles de decisión. Utiliza bagging y aleatoriedad de características al construir árboles individuales para intentar crear un bosque no correlacionado de árboles cuya predicción por comité es más precisa que la de cualquier árbol individual.

    Bagging es un meta-estimador de conjunto que ajusta clasificadores/regresores base en subconjuntos aleatorios del conjunto de datos original y luego agrega sus predicciones individuales (ya sea por votación o por promediado) para formar una predicción final.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`n_estimators`</td>
            <td>El número de árboles en el bosque.</td>
            <td>int</td>
            <td>[1, 500]</td>
            <td>100</td>
        </tr>
        <tr>
            <td>`criterion`</td>
            <td>La función para medir la calidad de una división. Los criterios soportados son "squared_error" para el error cuadrático medio, que es igual a la reducción de varianza como criterio de selección de características, "absolute_error" para el error absoluto medio.</td>
            <td>string</td>
            <td>{&quot;mse&quot;, &quot;mae&quot;}</td>
            <td>"mse"</td>
        </tr>
        <tr>
            <td>`max_depth`</td>
            <td>La profundidad máxima del árbol. Si es None, entonces los nodos se expanden hasta que todas las hojas sean puras o hasta que todas las hojas contengan menos de min_samples_split muestras.</td>
            <td>int</td>
            <td>(0, +Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`min_samples_split`</td>
            <td>El número mínimo de muestras requeridas para dividir un nodo interno</td>
            <td>int  or float</td>
            <td>[2, +Inf) or (0, 1.0]</td>
            <td>2</td>
        </tr>
        <tr>
            <td>`min_samples_leaf`</td>
            <td>El número mínimo de muestras requeridas para estar en un nodo hoja. Un punto de división en cualquier profundidad solo se considerará si deja al menos min_samples_leaf muestras de entrenamiento en cada una de las ramas izquierda y derecha.</td>
            <td>int or float</td>
            <td>[1, +Inf) or (0, 0.5]</td>
            <td>1</td>
        </tr>
        <tr>
            <td>`min_weight_fraction_leaf`</td>
            <td>La fracción ponderada mínima de la suma total de pesos (de todas las muestras de entrada) requerida para estar en un nodo hoja. Las muestras tienen peso igual cuando sample_weight no se proporciona.</td>
            <td>float</td>
            <td>[0, 0.5]</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`max_features`</td>
            <td>El número de características a considerar cuando se busca la mejor división</td>
            <td>int, float or string</td>
            <td>(0, n_features] or { "sqrt", "log2"}, None</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`max_leaf_nodes`</td>
            <td>Hacer crecer árboles con max_leaf_nodes de la mejor manera posible. Los mejores nodos se definen como la reducción relativa en impureza.</td>
            <td>int</td>
            <td>(1, +Inf)</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`min_impurity_decrease`</td>
            <td>Un nodo se dividirá si esta división induce una disminución de la impureza mayor o igual a este valor.</td>
            <td>float</td>
            <td>[0, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`bootstrap`</td>
            <td>Si se usan muestras bootstrap al construir árboles. Si es False, se usa el conjunto de datos completo para construir cada árbol.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>True</td>
        </tr>
        <tr>
            <td>`oob_score` (out of bag score)</td>
            <td>Si se usan muestras fuera de la bolsa para estimar la puntuación de generalización. Solo disponible si bootstrap=True.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`warm_start`</td>
            <td>Cuando se establece en True, reutiliza la solución de la llamada anterior a fit y añade más estimadores al conjunto, de lo contrario, simplemente ajusta un bosque completamente nuevo.</td>
            <td>bool</td>
            <td>True or  False</td>
            <td>False</td>
        </tr>
    </tbody>
    </table>

12. ### Ridge Regression

    La regresión Ridge es un método para estimar los coeficientes de modelos de regresión múltiple en escenarios donde las variables independientes están altamente correlacionadas. Se puede usar cuando las variables de entrada están altamente correlacionadas con el objetivo.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`alpha`</td>
            <td>Constante que multiplica el término L2, controlando la fuerza de regularización.</td>
            <td>float</td>
            <td>(0, +Inf)</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`fit_intercept`</td>
            <td>Si se debe ajustar el intercepto para este modelo. Si se establece en false, no se usará intercepto en los cálculos.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>True</td>
        </tr>
        <tr>
            <td>`normalize`</td>
            <td>Este parámetro se ignora cuando fit_intercept se establece en False. Si es True, los regresores X se normalizarán antes de la regresión restando la media y dividiendo por la
 norma l2.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`tol` (tolerance)</td>
            <td>Precisión de la solución.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1e-4</td>
        </tr>
        <tr>
            <td>`solver`</td>
            <td>Solver a usar en las rutinas computacionales:</td>
            <td>string</td>
            <td>{'auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg', 'sag', 'saga'}</td>
            <td>'auto'</td>
        </tr>
    </tbody>
    </table>

> **Nota:** Los valores del **solver** son:

    * '**auto**' elige el solver automáticamente basándose en el tipo de datos.
    * '**svd**' usa una Descomposición en Valores Singulares de X para calcular los coeficientes Ridge. Es el solver más estable, en particular más estable para matrices singulares que 'cholesky' a costa de ser más lento.
    * '**cholesky**' usa la función estándar scipy.linalg.solve para obtener una solución de forma cerrada.
    * '**sparse_cg**' usa el solver de gradiente conjugado como se encuentra en scipy.sparse.linalg.cg. Como algoritmo iterativo, este solver es más apropiado que 'cholesky' para datos a gran escala (posibilidad de establecer tol y max_iter).
    * '**lsqr**' usa la rutina de mínimos cuadrados regularizados dedicada scipy.sparse.linalg.lsqr. Es el más rápido y usa un procedimiento iterativo.
    * '**sag**' usa un descenso de gradiente promedio estocástico, y 'saga' usa su versión mejorada e imparcial llamada SAGA. Ambos métodos también usan un procedimiento iterativo, y a menudo son más rápidos que otros solvers cuando tanto n_samples como n_features son grandes. Tenga en cuenta que la convergencia rápida de 'sag' y 'saga' solo está garantizada en características con aproximadamente la misma escala. Se puede preprocesar los datos con un scaler de sklearn.preprocessing.

13. ### SVM Regression

    La regresión de vectores de soporte se utiliza para predecir valores discretos. La regresión de vectores de soporte usa el mismo principio que las SVMs. La idea básica detrás de SVM es encontrar la mejor línea de ajuste. En SVM, la mejor línea de ajuste es el hiperplano que tiene el máximo número de puntos.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`C`</td>
            <td>Parámetro de regularización. La fuerza de la regularización es inversamente proporcional a C. Debe ser estrictamente positivo.</td>
            <td>float</td>
            <td>(0.0, +Inf)</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`kernel`</td>
            <td>Especifica el tipo de kernel a utilizar en el algoritmo. Si no se proporciona ninguno, se usará `rbf`. Si se proporciona un callable, se usa para precalcular la matriz del kernel.</td>
            <td>string</td>
            <td>{'linear', 'poly', 'rbf', 'sigmoid'}</td>
            <td>'rbf'</td>
        </tr>
        <tr>
            <td>`degree`</td>
            <td>Grado de la función kernel polinómica ('poly').</td>
            <td>int</td>
            <td>[0, +Inf)</td>
            <td>3</td>
        </tr>
        <tr>
            <td>`gamma`</td>
            <td>Coeficiente del kernel para 'rbf', 'poly' y 'sigmoid'.</td>
            <td>string or float</td>
            <td>{'scale', 'auto'} or (0.0, +Inf)</td>
            <td>'scale'</td>
        </tr>
        <tr>
            <td>`coef0`</td>
            <td>Término independiente en la función kernel. Solo es significativo en 'poly' y 'sigmoid'.</td>
            <td>float</td>
            <td>(-Inf, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`shrinking`</td>
            <td>Si se debe usar la heurística de reducción.</td>
            <td>bool</td>
            <td>True or  False</td>
            <td>True</td>
        </tr>
        <tr>
            <td>`tol` (tolerance)</td>
            <td>Tolerancia para el criterio de parada.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1e-3</td>
        </tr>
        <tr>
            <td>`epsilon`</td>
            <td>Epsilon en el modelo 
epsilon-SVM. Especifica el tubo epsilon dentro del cual no se asocia ninguna penalización en la función de pérdida de entrenamiento con puntos predichos dentro de una distancia epsilon del valor real.</td>
            <td>float</td>
            <td>[0, +Inf)</td>
            <td>0.1</td>
        </tr>
    </tbody>
    </table>

14. ### XGB Regression

    XGBoost es una biblioteca de gradient boosting distribuido optimizada diseñada para ser altamente eficiente, flexible y portable. Implementa algoritmos de aprendizaje automático bajo el framework de gradient boosting. Proporciona boosting paralelo de árboles para resolver muchos problemas de ciencia de datos de forma rápida y precisa. Utiliza regularización L1 y L2 para predecir puntos y entrena rápidamente.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w30p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w25p">Valores Posibles</th>
            <th class="w20p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`booster`</td>
            <td>Decide qué booster usar.</td>
            <td>string</td> 
            <td>{'gbtree&#39;, &#39;gblinear&#39;, &#39;dart&#39; }</td>
            <td>'gbtree'</td>
        </tr>
        <tr>
            <td>`learning_rate`</td>
            <td>Reducción del tamaño del paso utilizada en la actualización para prevenir el sobreajuste. Después de cada paso de boosting, podemos obtener directamente los pesos de las nuevas características, y eta reduce los pesos de las características para hacer el proceso de boosting más conservador.</td>
            <td>float</td>
            <td>[0,1]</td>
            <td>0.1</td>
        </tr>
        <tr>
            <td>`n_estimators`
(number of estimators)</td>
            <td>Número de árboles a ajustar.</td>
            <td>int</td>
            <td>[1, 500]</td>
            <td>100</td>
        </tr>
        <tr>
            <td>`objective`</td>
            <td>Regresión logística para clasificación binaria.</td>
            <td>string</td>
            <td>Mencionado debajo de la tabla.</td>
            <td>&quot;reg:linear&quot;</td>
        </tr>
        <tr>
            <td>`subsample`</td>
            <td>Controla la proporción de la muestra.</td>
            <td>int</td>
            <td>(0,1]</td>
            <td>1</td>
        </tr>
        <tr>
            <td>`max_depth`</td>
            <td>Profundidad máxima de un árbol.</td>
            <td>int</td>
            <td>(0, +Inf)</td>
            <td>3</td>
        </tr>
        <tr>
            <td>`max_delta_step`</td>
            <td>Si el valor se establece en 0, significa que no hay restricción. Si se establece en un valor positivo, puede ayudar a hacer que el paso de actualización sea más conservador. Generalmente este parámetro no es necesario, pero podría ayudar en la regresión logística cuando la clase está extremadamente desequilibrada.</td>
            <td>int  or float</td>
            <td>[0, +Inf)</td>
            <td>0</td>
        </tr>
        <tr>
            <td>`colsample_bytree` (column sample by tree)</td>
            <td>Fracción de muestras aleatorias de columnas.</td>
            <td>float</td>
            <td>(0, 1]</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`colsample_bylevel` (column sample by level)</td>
            <td>Es la proporción de submuestreo de columnas para cada nivel. El submuestreo ocurre una vez por cada nuevo nivel de profundidad alcanzado en un árbol. Las columnas se submuestrean del conjunto de columnas elegidas para el árbol actual.</td>
            <td>float</td>
            <td>(0, 1]</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`min_child_weight`</td>
            <td>Suma mínima de pesos.</td>
            <td>int</td>
            <td>[0, +Inf)</td>
            <td>1</td>
        </tr>
        <tr>
            <td>`reg_alpha` (alpha)</td>
            <td>Término de regularización L1 en los pesos.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`reg_lambda` (lambda)</td>
            <td>Término de regularización L2 en los pesos.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>0.0</td>
        </tr>
        <tr>
            <td>`scale_pos_weight` (scale positive weight)</td>
            <td>Controla el equilibrio de pesos positivos y negativos, útil para clases desequilibradas.</td>
            <td>int</td>
            <td>[0, +Inf)</td>
            <td>1</td>
        </tr>
    </tbody>
    </table>

    **VALORES POSIBLES PARA EL PARÁMETRO "OBJECTIVE":**

    { "rank:pairwise", reg:tweedie, "reg:gamma", "reg:linear", "count:poisson"}