---
title: "Algoritmos de Clasificación"
url: https://docs.catalyst.zoho.com/es/quickml/help/ml-algorithms/classification-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
---

<!-- ### ML Algorithms
QuickML ML operations are categorized into multiple sections. All of these operations are available as stages in Pipeline Builder as mentioned and the main categories are:
1. **Algorithms**
     - Classification algorithms
     - Regression algorithms
2. **Encoding**
3. **Imputation**
4. **Binning**
5. **Transformers**
6. **Data type detection**
7. **DType transformation**
8. **Feature generation**

All the operations listed above have detailed categories and their own use cases in the ML pipeline environment. Those can be checked in detail in upcoming pipeline articles. -->

# Algoritmos de ML en QuickML

QuickML se centra principalmente en potenciar los Pipelines de ML con Operaciones de Machine Learning de manera sencilla para proporcionar un entorno de ejecución de pipeline fluido. Por lo tanto, se ha integrado con una amplia gama de algoritmos y características de ML para proporcionar los mejores resultados analíticos a partir de los datos. 

Los algoritmos de ML son programas que pueden aprender de los datos y mejorar con la experiencia, sin ninguna intervención externa. Los siguientes algoritmos y operaciones están todos disponibles en **QuickML como etapas** que pueden configurarse en una o más ejecuciones de pipeline.

Los algoritmos más ampliamente utilizados en el dominio de la ciencia de datos son:

1. **Algoritmos de clasificación**
2. **Algoritmos de regresión**

# Algoritmos de Clasificación

La clasificación es la tarea de predecir una etiqueta de clase discreta. QuickML cuenta con los siguientes algoritmos de clasificación

1. ### AdaBoost Classification

    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 clasificación comienza ajustando un clasificador en el conjunto de datos original, seguido de copias adicionales del clasificador 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 clasificadores subsiguientes se centran más en los casos difíciles.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
            <tr>
                <th class="w15p">Parámetro</th>
                <th class="w35p">Descripción</th>
                <th class="w15p">Tipo de Dato</th>
                <th class="w20p">Valores Posibles</th>
                <th class="w15p">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 `DecisionTreeClassifier` inicializado con **max_depth=1**.</td>
                <td>object</td>
                <td>Cualquier modelo de clasificación excepto el modelo KNN Classification</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 clasificador en cada iteración de boosting. Una tasa de aprendizaje más alta aumenta la contribución de cada clasificador.</td>
                <td>float</td>
                <td>(0.0, +Inf)</td>
                <td>1.0</td>
            </tr>
            <tr>
                <td>`algorithm`</td>
                <td>Si es 'SAMME.R' entonces usa el algoritmo de boosting real SAMME.R. base_estimator debe soportar el cálculo de probabilidades de clase. Si es 'SAMME' entonces usa el algoritmo de boosting discreto SAMME. El algoritmo SAMME.R típicamente converge más rápido que SAMME, logrando un menor error de prueba con menos iteraciones de boosting.</td>
                <td>string</td>
                <td>{'SAMME', 'SAMME.R'}</td>
                <td>'SAMME.R'</td>
            </tr>
        </tbody>
    </table>

2. ### CatBoost Classification

    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. 

    Esta clasificación 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="w25p">Descripción</th>
                <th class="w15p">Tipo de Dato</th>
                <th class="w20p">Valores Posibles</th>
                <th class="w15p">Valores Predeterminados</th>
            </tr>
        </thead>
        <tbody>
        <tr>
        <td>`learning_rate`</td>
        <td>Se utiliza para reducir el paso del gradiente.</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;Logloss&#39;, &#39;CrossEntropy&#39;, &#39;MultiClass&#39;, &#39;MultiClassOneVsAll&#39;}</td>
        <td>&#39;MultiClass&#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 Classification

    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="w15p">Tipo de Dato</th>
            <th class="w20p">Valores Posibles</th>
            <th class="w10p">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>{"gini", "entropy"}</td>
            <td>"gini"</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. Si es None, entonces número ilimitado de nodos hoja.</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. ### GB Classification

    La clasificació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 encontrar este valor, el clasificador 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 y así este proceso empuja 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="w15p">Tipo de Dato</th>
            <th class="w15p">Valores Posibles</th>
            <th class="w15p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`loss`</td>
            <td>La función de pérdida a optimizar. 'deviance' se refiere a la desviación (= regresión logística) para clasificación con salidas probabilísticas.</td>
            <td>string</td>
            <td>{&#39;deviance&#39;, &#39;exponential&#39;}</td>
            <td>&#39;deviance&#39;</td>
        </tr>
        <tr>
            <td>`learning_rate`</td>
            <td>La tasa de aprendizaje reduce la contribución de cada árbol por learning_rate. Existe un equilibrio entre learning_rate y n_estimators.</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.</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>La profundidad máxima de los estimadores de regresión individuales.</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.</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.</td>
            <td>object or string</td>
            <td>estimador (Cualquier modelo de clasificación excepto SVM classification y catboost) 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>

5. ### KNN Classification

    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 votando por la etiqueta más frecuente en el vecindario.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
        <th class="w15p">Parámetro</th>
                <th class="w35p">Descripción</th>
                <th class="w15p">Tipo de Dato</th>
                <th class="w20p">Valores Posibles</th>
                <th class="w15p">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. Valores posibles</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.</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.</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>string</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>

6. ### LGBM Classification
    
    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="w20p">Valores Posibles</th>
            <th class="w15p">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. Se puede usar el parámetro callbacks del método fit para reducir/adaptar la tasa de aprendizaje en el entrenamiento usando el callback reset_parameter.</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>

7. ### Logistic Regression

    Cuando el objetivo es un **valor binario**, podemos usar la clasificación logística. Mapea el valor entre 0 y 1.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w20p">Parámetro</th>
            <th class="w35p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w20p">Valores Posibles</th>
            <th class="w15p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`penalty`</td>
            <td>Especifica la norma de la penalización:<ul style="text-align: left;"><li><strong>&#39;none&#39;</strong>: no se añade penalización;<li><strong>&#39;l2&#39;</strong>: añade un término de penalización L2 y es la opción predeterminada;<li><strong>&#39;l1&#39;</strong>: añade un término de penalización L1;<li><strong>&#39;elasticnet&#39;</strong>: se añaden tanto términos de penalización L1 como L2.</ul></td>
            <td>string</td>
            <td>{ 'l1', 'l2', 'elasticnet', 'none'}</td>
            <td>'l2'</td>
        </tr>
        <tr>
            <td>`dual`</td>
            <td>Formulación dual o primal. La formulación dual solo está implementada para la penalización l2 con el solver liblinear.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>False</td>
        </tr>
        <tr>
            <td>`tol` (tolerance)</td>
            <td>Tolerancia para los criterios de parada.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1e-4</td>
        </tr>
        <tr>
            <td>`C`</td>
            <td>Inverso de la fuerza de regularización; debe ser un float positivo.</td>
            <td>float</td>
            <td>[0.0, +Inf)</td>
            <td>1.0</td>
        </tr>
        <tr>
            <td>`solver`</td>
            <td>Algoritmo a usar en el problema de optimización.</td>
            <td>string</td>
            <td>{ 'newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga' }</td>
            <td>'lbfgs'</td>
        </tr>
        <tr>
            <td>`fit_intercept`</td>
            <td>Especifica si una constante (también conocida como sesgo o intercepto) debe añadirse a la función de decisión.</td>
            <td>bool</td>
            <td>True or False</td>
            <td>True</td>
        </tr>
        <tr>
            <td>`l1_ratio`</td>
            <td>El parámetro de mezcla Elastic-Net, con
0 &lt;= l1_ratio &lt;= 1. Solo se usa si penalty=&#39;elasticnet&#39;.</td>
            <td>float</td>
            <td>[0, 1]</td>
            <td>None</td>
        </tr>
        <tr>
            <td>`multi_class`</td>
            <td>Si la opción elegida es 'ovr', entonces se ajusta un problema binario para cada etiqueta. Para 'multinomial' la pérdida minimizada es la pérdida multinomial ajustada a toda la distribución de probabilidad, incluso cuando los datos son binarios.</td>
            <td>string</td>
            <td>{&#39;auto&#39;, &#39;ovr&#39;, &#39;multinomial&#39;}</td>
            <td>&#39;auto&#39;</td>
        </tr>
        <tr>
            <td>`intercept_scaling`</td>
            <td>Útil solo cuando se usa el solver 'liblinear' y self.fit_intercept se establece en True. El intercepto se convierte en intercept_scaling * synthetic_feature_weight.</td>
            <td>float</td>
            <td>(0, +Inf)</td>
            <td>1.0</td>
        </tr>
        </tbody>
        </table>

> **Nota:** Los valores en el parámetro "solver" soportan solo algunos de los valores del parámetro "penalty". Las penalizaciones soportadas por el solver se mencionan a continuación:

    * newton-cg' - ['l2', 'none']
    * 'lbfgs' - ['l2', 'none']
    * 'liblinear' - ['l1', 'l2']
    * 'sag' - ['l2', 'none']
    * 'saga' - ['elasticnet', 'l1', 'l2', 'none']

8. ### Naive Bayes Classification

    Naive Bayes es un clasificador que utiliza el **Teorema de Bayes**. Predice probabilidades de membresía para cada clase, como la probabilidad de que un registro o punto de datos dado pertenezca a una clase particular. La clase con la mayor probabilidad se considera como la clase más probable.

9. ### Random-Forest Classification

    El bosque aleatorio es un algoritmo de clasificació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, 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="w20p">Valores Posibles</th>
            <th class="w15p">Valores Predeterminados</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>`n_estimators`
 (number of 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.</td>
            <td>string</td>
            <td>{"gini", "entropy"}</td>
            <td>"gini"</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.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"}</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>

10. ### SVM Classification

    SVM, o Support Vector Machine, es un modelo lineal para problemas de clasificación y regresión. Puede resolver problemas lineales y no lineales y funciona bien para muchos problemas prácticos. La idea de SVM es simple: El algoritmo crea una línea o un hiperplano que separa los datos en clases.

    #### Hiperparámetros:

    <table class="content-table quickml-content-table">
        <thead>
        <tr>
            <th class="w25p">Parámetro</th>
            <th class="w35p">Descripción</th>
            <th class="w10p">Tipo de Dato</th>
            <th class="w15p">Valores Posibles</th>
            <th class="w15p">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.</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'.</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'). Ignorado por todos los demás kernels.</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>`probability`</td>    
            <td>Si se deben habilitar las estimaciones de probabilidad.</td>
            <td>bool</td>
            <td>True or  False</td>
            <td>False</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>`decision_function_shape`</td>
            <td>Si se debe devolver una función de decisión uno-contra-todos ('ovr') de forma (n_samples, n_classes) como todos los demás clasificadores, o la función de decisión original uno-contra-uno ('ovo') de libsvm que tiene forma (n_samples, n_classes * (n_classes - 1) / 2).</td>
            <td>string</td>
            <td>{'ovo', 'ovr'}</td>
            <td>'ovr'</td>
        </tr>
        <tr>
            <td>`break_ties`</td>
            <td>Si es verdadero, decision_function_shape=&#39;ovr&#39;, y el número de clases &gt; 2, predict romperá empates según los valores de confianza de decision_function; de lo contrario, se devuelve la primera clase entre las clases empatadas.</td>
            <td>bool</td>
            <td>True or  False</td>
            <td>False</td>
        </tr>
    </tbody>
    </table>

11. ### XGB Classification

    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 es rápido en el entrenamiento.

    Cada modelo tiene Fit (para entrenar el modelo), predict (para predecir nuevos datos), get metrics (para obtener la precisión del modelo y otras métricas), y feature_importances (importancias de las características de entrada para la predicción).

    Los principios de funcionamiento básicos de Adaboost, CatBoost, Decision tree, Gradient boost(GB), LGBM, RandomForest, SVM y XGB son casi idénticos tanto para regresión como para clasificació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>`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;binary:logistic&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.0, 1.0]</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.0, 1.0]</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":**

    {binary:logistic, binary:logitraw, binary:hinge, multi:softmax, multi:softprob}