Historial de los últimos códigos añadidos
Listado de los últimos códigos introducidos.
Programa para generar gifs animados a partir de vídeos, que se ejecuta en la línea de comandos.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (obligatorio).
-dest/--destination: Nombre del archivo a generar (opcional).
-sz/--size: Tamaño en porcentaje del gif respecto al vídeo original (opcional).
-shw/--show: Muestra resultado en ventana emergente al finalizar el proceso de generado (opcional).
-st/--start: Segundo inicial para gif (opcional).
-e/--end: Segundo final (opcional).
-spd/--speed: Velocidad relativa de la animación (opcional)
PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.
<?php
// Función para leer los datos del grupo
function leerDatosGrupo() {
$analistas = (int) readline("Ingrese la cantidad de analistas en el grupo: ");
$coordinadores = (int) readline("Ingrese la cantidad de coordinadores en el grupo: ");
$casosPorDia = (int) readline("Ingrese la cantidad promedio de casos que llegan por día: ");
return array(
"analistas" => $analistas,
"coordinadores" => $coordinadores,
"casosPorDia" => $casosPorDia
);
}
// Función para calcular la distribución de los casos
function calcularDistribucionCasos($grupo, $casosPorDia) {
$casosPorAnalista = $casosPorDia / $grupo['analistas'];
echo "Cada analista deberá atender en promedio " . $casosPorAnalista . " casos por día." . PHP_EOL;
}
// Función para asignar los casos a cada analista
function asignarCasos($grupo, $casosPorDia) {
$casosPorAnalista = $casosPorDia / $grupo['analistas'];
$primerAnalistaCasos = floor($casosPorAnalista); // Tomar los casos enteros
$segundoAnalistaCasos = $casosPorAnalista - $primerAnalistaCasos; // Tomar los casos restantes
echo "El primer analista tomará " . $primerAnalistaCasos . " casos." . PHP_EOL;
echo "El segundo analista tomará " . $segundoAnalistaCasos . " casos." . PHP_EOL;
}
$grupo = leerDatosGrupo();
calcularDistribucionCasos($grupo, $grupo['casosPorDia']);
asignarCasos($grupo, $grupo['casosPorDia']);
?>
Programa para reproducir archivos de audio que incorpora la posibilidad de crear una lista de favoritos.
El programa necesita de un archivo "json" que se generará al ejecutarse por primera vez.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
Programa para realizar filtrado de imagen en archivos de vídeo (preferiblemente de corta duración) utilizando el algoritmo de 'filtrado bilateral' pudiendo especificar los valores sigma de espacio y color y el diámetro del vecindario para cada pixel. Los vídeos filtrados se generan, por defecto, conservando su sonido, aunque se pueden generar sin este introduciendo el argumento '-ae'/'--exclude_audio'.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (OBLIGATORIO)
-dest/--destination: Nombre del video a generar ('NewFilteredVid.mp4' por defecto)
-sgc/--sigma_color: Valor sigma para espacio de color (75 por defecto)
-sgs/--sigma_space: Valor sigma espacial (75 por defecto)
-pd/--pixel_diameter: Diámetro de la vecindad de píxeles (9 por defecto)
-ae/--exclude_audio: Excluir audio y generar video sin sonido (OPCIONAL)
PARA CUALQUIER DUDA U OBSERVACIÓN UTILIZEN LA SECCIÓN DE COMENTARIOS
Cx es un programa para Windows.
Sirve para gestionar la contabilidad.
Produce: libro diario, auxiliar,
balanzas, recapitulación, estados financieros,
balance general, estado de pérdidas y ganancias,
estado de resultados y estados de cuentas.
Servosistema que administra
la oficina sin papeles.
Multiusuario cliente/servidor, red inalámbrica.
Código abierto. Trabajo a distancia.
Adjunto Cx Guía del rey de la creación
El uso típico de pickle es para guardar objetos Python en archivos y luego recuperarlos más tarde. Sin embargo, debes tener precaución al usar pickle con datos no confiables o no seguros, ya que la deserialización de datos no confiables puede ser un riesgo de seguridad. No debes cargar archivos pickle de fuentes no confiables o desconocidas.
Alternativamente, si estás trabajando solo con datos simples y no necesitas interoperabilidad con otros lenguajes, podrías considerar otros formatos de serialización más seguros y eficientes, como JSON, que son humanamente legibles y no ejecutan código durante la deserialización.Pequeño pero util generador de contraseñas hecho en Python3
Les traigo un OCX simple, que les servirá para representar el típico estado On-Off.
Reacciona al hacer un
Click sobre el elemento, llamando al Evento
Change. Desde ahí capturan el valor (
TRUE ó
FALSE) y realizar la acción que quieran de acuerdo a éso.
Les adjunto el código fuente, junto al OCX compilado. Espero les sea de utilidad.
El presente programa se encarga de aplicar filtros sobre los fotogramas de un archivo de video empleando diferentes funciones. El programa realiza el filtrado frame a frame para a continuación generar un nuevo video con la secuencia de frames procesados (aplicando el frame rate del vídeo original). También usa el software "ffmpeg" para copiar el audio del vídeo original y añadirlo al vídeo resultante.
USO: Primeramente seleccionaremos el vídeo a filtrar mediante el botón "SEARCH". Una vez seleccionado iniciaremos el proceso con "START FILTERING" con el que empezaremos seleccionando la ubicación del nuevo vídeo, para a continuación iniciar el proceso (NOTA: La ruta del directorio de destino no deberá contener espacios en blanco). El proceso de filtrado podrá ser cancelado medinate el botón "CANCEL".
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
El siguiente código muestra un grid en pantalla por el que se puede desplazar usando los botones de dirección:
Botón de dirección derecha: Desplazamiento hacia la derecha.
Botón de dirección izquierdo: Desplazamiento a la izquierda.
Botón de dirección superior: Desplazamiento hacia adelante.
Botón de dirección inferior: Desplazamiento hacia atrás.
Botones 'o', 'p', 'k' y 'l': Desplazamientos en diagonal.
El ahorcado o Hangman es un mini juego clásico en el cual se debe adivinar la palabra, desarrollado en lenguaje kotlin, a modo de practica, Obviamente es una primera versión, se puede mejorar, compartiré el codigo fuente que esta en mi GitHub por si quieren descargar el codigo y modificarlo a su gusto
Codigo Fuente
https://github.com/x-cevh-x/ElAhorcadoKotlinPrograma para reproducir archivos de audio que incorpora la posibilidad de crear una lista de favoritos.
El programa necesita de un archivo "json" que se generará al ejecutarse por primera vez.
Esta versión incorpora la posibilidad de reproducir secuencialmente la lista de favoritos, para ello se usará el botón "PLAY ALL" (dicha reproducción se podrá finalizar igualmente con el botón "STOP").
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
import matplotlib.pyplot as plt
import numpy as np
n_values = np.arange(1, 301, 1)
a_values = (5 - 3 * n_values**2) / (1 - 2 * n_values**2)
plt.plot(n_values, a_values, label=r'$a_n = \frac{5-3n^2}{1-2n^2}$')
plt.xlabel('n')
plt.ylabel('a_n')
plt.title('Gráfico de la función $a_n$')
plt.legend()
plt.show()
Nueva versión del Juego de la Serpiente, en la que se ha incluido sonido y 3 archivos de audio (incluidos en la carpeta). Para usar el programa adecuadamente, simplemente hay que descomprimir la carpeta en la que se encuentra.
BOTONES:
Mover serpiente: Botónes de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.
Nueva versión del juego de la serpiente con caracteres ASCII. Esta versión se diferencia de las dos anteriores (que pueden verse en mi lista de códigos) en que se acompaña de un archivo (de nombre "hiScore") que irá almacenando de modo permanente, la puntuación máxima alcanzada por el jugador.
BOTONES:
Mover serpiente: Botones de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida en curso: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.
El siguiente script muestra en tiempo real las cotizaciones en bolsa, de acciones e índices bursátiles.
El programa utiliza un bucle en el que va realizando sucesivas peticiones de datos, usando 'yfinance'. Entre una petición y la siguiente, media un tiempo en segundos que viene determinado por la opción '-delay/--time_delay', teniendo un valor por defecto de 5 segundos y no pudiendo ser inferior a 0.5
Para detener la obtención de datos, pulsar la barra espaciadora. Al hacerlo, el programa mostrará el texto 'wait until application ends..' ya que tendrá que esperar el tiempo que quede restante del especificado por '-delay/--time_delay'. Finalizando definitivamente, transcurrido dicho tiempo restante.
ARGUMENTOS:
'-tick/--ticker' : Ticker o símbolo del valor cuya cotización se quiere obtener.
'-delay/--time_delay': Periodicidad, en segundos, entre una petición de datos y la siguiente.
'-clr/--color': Mostrar precio de cierre en color, en función de su fluctuación respecto del valor anterior.
'-uind/--use_index': Incluir esta opción para obtener cotizaciones de índices bursátiles (ej: ^IXIC, ^DJI..)
La petición de valores se interrumpe pulsando la barra espaciadora.
PARA CUALQUIER DUDA U OBSERVACIÓN, UTILICEN LA SECCIÓN DE COMENTARIOS.
********************************************************************************************************************
Aula_18_B.py
******************************************************************************************************************
Se trata de una sencilla red neuronal, ya resuelta en otro ejercicio,
utilizando la librería keras. Ahora lo planteamos de nuevo, utilizando
solamente las librerias numpy y matplotlib.
Se trataba de una red neuronal con este esquema:
input_size = 1
hidden_layer1_size = 8
hidden_layer2_size = 8
output_size = 1
Una neurona de entrada, con dos capas ocultas intermedias de 8 neuronas
cada una, y 1 neurona de salida.
Los datos generales y sencillos de la idea son los siguientes:
Se trata de cinco hermanos que a los 30 años median lo siguiente:
Antonio 1,70 cm. Pedrito 1,75. Juanito 1,78 . Carlitos 1,69. Ignacio 1,87.
Ramón 1,79.
Hace 6 meses ha nacido Santiaguito.
Cuales son las previsiones de estatura
cuando también tenga 30 años. Haremos graficas de salida de columnas.
También haremos gráficas de costos MSE, con salida imprimida por consola
de los valores de los mismos por cada iteración.
También se imprime en la salida la previsión que hace la red neuronal
de la estatura futura
Los hiperparámetros que adoptamos, son los siguientes:
learning_rate = 0.01
epochs = 40
Se puede jugar con los mismos con el fin de afinar los
resultados.
*************************************************************
Este ejercicio ha sido realizado en una plataforma Linux.
Ubuntu 20.04.6 LTS.
Se utiliza el editor Sublime text
*********************************************************
Ejecucion bajo consola linux con el comando:
python3 Aula_18_B.pyFormulario de Registro basico
Presentamos para nuestra aula, un sencillo ejercicio propuesto, para clasificar una serie de datos sintéticos, utilizando el sistema de regresión logística.
El ejercicio, es el siguiente:
Ejercicio_Clas_Regre_Log-Aula-28.py
La clasificación de datos por regresión logística es una técnica de aprendizaje automático que se utiliza para predecir la pertenencia de un conjunto de datos a una o más clases. Aunque el nombre "regresión" logística incluye la palabra "regresión", este enfoque se utiliza para problemas de clasificación en lugar de regresión.
La regresión logística se emplea cuando se desea predecir la probabilidad de que una observación pertenezca a una categoría o clase específica, generalmente dentro de un conjunto discreto de clases. Por lo tanto, es una técnica de clasificación que se utiliza en problemas de clasificación binaria (dos clases) y clasificación multiclase (más de dos clases). Por ejemplo, se puede usar para predecir si un correo electrónico es spam (clase positiva) o no spam (clase negativa) o para clasificar imágenes en categorías como gatos, perros o pájaros.
La regresión logística utiliza una función logística (también conocida como sigmoide) para modelar la probabilidad de pertenecer a una clase particular en función de variables de entrada (características). La función sigmoide tiene la propiedad de que produce valores entre 0 y 1, lo que es adecuado para representar probabilidades. El modelo de regresión logística utiliza coeficientes (pesos) para ponderar las características y calcular la probabilidad de pertenencia a una clase.
Durante el entrenamiento, el modelo busca ajustar los coeficientes de manera que las probabilidades predichas se ajusten lo más cerca posible a las etiquetas reales de los datos de entrenamiento. Una vez que se ha entrenado el modelo, se puede utilizar para predecir la probabilidad de pertenencia a una clase para nuevos datos y tomar decisiones basadas en esas probabilidades, como establecer un umbral para la clasificación en una clase específica.
*************************************************************************************************************
Los pasos que realizamos en el ejercicio, son los siguientes:
1-Generamos datos sintéticos donde la clase se determina por la suma de las dos características.
2-Implementamos la regresión logística desde cero sin el uso de scikit-learn, incluyendo el cálculo de 3-gradientes y la actualización de pesos.
4-Dibujamos los datos de entrada en un gráfico, junto con la línea de decisión que separa las clases.
En resumen, la regresión logística es una técnica de clasificación que modela las probabilidades de pertenencia a clases utilizando la función sigmoide y es ampliamente utilizada en una variedad de aplicaciones de aprendizaje automático.import matplotlib.pyplot as plt
from matplotlib_venn import venn2
# Conjunto de asistentes que conocen el primer lenguaje (A)
A = {1, 2, 3, 4, 5}
# Conjunto de asistentes que conocen el segundo lenguaje (B)
B = {3, 4, 5, 6, 7}
# Conjunto de asistentes que conocen exactamente dos lenguajes (C)
C = A.intersection(B)
# Crear el diagrama de Venn
venn_labels = {'100': len(A - B), '010': len(B - A), '110': len(C)}
venn2(subsets=(len(A - B), len(B - A), len(C)), set_labels=('Lenguaje 1', 'Lenguaje 2'))
# Mostrar el gráfico
plt.show()
# Imprimir la cantidad de asistentes que conocen exactamente dos lenguajes
print(f"Número de asistentes que conocen exactamente dos lenguajes: {len(C)}")
[center]
En este sencillo ejercicio:Descn_Mult_Momentun_Ejemp_Aula-28-Oct.py, tratamos de explicar como realizar un descenso de gradiente multiple, aplicando al mismo un momentum, para regular un descenso de gradiente , digamos, rápido de forma que el mismo no sea errático.
Una regresión múltiple es un tipo de análisis de regresión en el que se busca modelar la relación entre una variable de respuesta (dependiente) y múltiples variables predictoras (independientes o características). En otras palabras, en lugar de predecir una única variable de respuesta a partir de una única característica, se intenta predecir una variable de respuesta a partir de dos o más características. La regresión múltiple puede ser útil para comprender cómo varias características influyen en la variable de respuesta.
Cuando aplicas "momentum" a un algoritmo de regresión, normalmente estás utilizando una variante del descenso de gradiente llamada "descenso de gradiente con momentum." El momentum es una técnica que ayuda a acelerar la convergencia del algoritmo de descenso de gradiente, especialmente en problemas en los que el parámetro de costo es irregular, o tiene pendientes pronunciadas. En lugar de utilizar únicamente el gradiente instantáneo en cada iteración, el descenso de gradiente con momentum tiene en cuenta un promedio ponderado de los gradientes pasados, lo que le permite mantener una especie de "momentum" en la dirección de la convergencia.
A continuación, os proporcionaré un ejemplo de regresión múltiple con descenso de gradiente con momentum,y datos sintéticos en Python. En el mismo utilizamos, aparte de otras, la biblioteca NumPy para generar datos sintéticos, y aplicar el descenso de gradiente con momentum.
También se incluye en el ejercicio, una disposición de graficas, para hacerlo más didactico. El alunmno, podrá jugar, o experimentar con los parámetros iniciales e hiperparámetros, para seguir su evolución.
En resumen este es un ejercicio sencillo, que explicaremos en clase, paso a paso, para su comprensión. Como siempre utilizaremos en nuestros ordenadores la plataforma Linux, con Ubuntu 20. También realizaremos la práctica en Google Colab.
Programa para generar contraseñas de forma aleatoria, de hasta 50 caracteres. Cuenta con un campo "LENGTH" para especificar la longitud de la contraseña, un campo "MIN LOWERCASE" para especificar el número mínimo de caracteres en minúsculas, un campo "MIN UPPERCASE" para el número mínimo de caracteres en mayúsculas y un campo "MIN NUMBERS" para especificar el número mínimo de caracteres numéricos.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
python3 Ejercicio_Aula_23_Momentum.py
Sencillo ejercicio sobre un descenso de gradiente con momento, (Gradient Descent with Momentum en inglés).
Se trata de aplicar este algoritmo a una funcion parabolica del tipo: f(x) = x^2 / 6.
Cuya derivada es:x**2 / 6.
El descenso de gradiente con momento es una variante del algoritmo de descenso de gradiente utilizado en la optimización y entrenamiento de modelos de aprendizaje automático, particularmente en el contexto de redes neuronales y problemas de optimización no convexos. Su objetivo es acelerar la convergencia del descenso de gradiente y ayudar a evitar quedarse atrapado en óptimos locales.
La principal diferencia entre el descenso de gradiente con momento y el descenso de gradiente estándar es la adición de un término de "momentum" o impulso. En el descenso de gradiente estándar, en cada iteración, el gradiente actual se utiliza directamente para actualizar los parámetros del modelo. En cambio, en el descenso de gradiente con momento, se mantiene un promedio ponderado exponencial de los gradientes anteriores y se utiliza ese promedio para actualizar los parámetros.
El objetivo del término de momento es suavizar las actualizaciones de los parámetros y reducir las oscilaciones que pueden ocurrir cuando el gradiente varía significativamente en diferentes direcciones. Esto puede ayudar a acelerar la convergencia y a sortear barreras o mínimos locales en la función de costo
En este sencillo ejercicio que propongo, en vez de utilizar datos sintéticos de caráctear aleatorio de entrada, lo vamos a aplicar a una función parabólica.
Aplicación para codificar y decodificar mensajes de texto en imágenes.
La imagen se selecciona mediante el botón "SEARCH".
En el modo "Encode" el texto a ocultar se introduce en el espacio superior. (el programa generará un nuevo archivo de imagen cuyo nombre tendrá el prefijo "encoded_" delante del título del archivo original.
En el modo "Decode" el texto oculto se muestra en el espacio superior.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
Repositorio en GitHub:
https://github.com/antonioam82/Steganography
Repaso-Des-Gra-Batch-Aula-E.28-OCT-24.py
******************************************************************************************************************
Realizar un descenso de gradiente tipo Batch, en código python, desde el punto x=8.03, y=5.846. De la funcion f(x)=x**2/x+3. Cuya derivada es: f'(x)=x+3. Se incluye grafica de costos MSE, y grafica de la parábola, con los valores del descenso, marcado en puntos sobre la misma.El descenso de gradiente tipo Adam, o simplemente Adam (por Adaptive Moment Estimation), es un algoritmo de optimización utilizado en el campo del aprendizaje automático y la inteligencia artificial para ajustar los parámetros de un modelo de manera que se minimice una función de pérdida. Adam es una variante del descenso de gradiente estocástico (SGD) que combina técnicas de otros algoritmos de optimización para mejorar la convergencia y la eficiencia en la búsqueda de los mejores parámetros del modelo.
Aquí hay una explicación simplificada de cómo funciona el algoritmo Adam:
Inicialización de parámetros: Se inician los parámetros del algoritmo, como la tasa de aprendizaje (learning rate), los momentos de primer y segundo orden, y se establece un contador de iteraciones.
Cálculo del gradiente: En cada iteración, se calcula el gradiente de la función de pérdida con respecto a los parámetros del modelo. Esto indica en qué dirección deben ajustarse los parámetros para reducir la pérdida.
Cálculo de momentos de primer y segundo orden: Adam mantiene dos momentos acumulativos, uno de primer orden (media móvil de los gradientes) y otro de segundo orden (media móvil de los gradientes al cuadrado).
Actualización de parámetros: Se utilizan los momentos calculados en el paso anterior para ajustar los parámetros del modelo. Esto incluye un término de corrección de sesgo para tener en cuenta el hecho de que los momentos se inicializan en cero. La tasa de aprendizaje también se aplica en esta etapa.
Iteración y repetición: Los pasos 2-4 se repiten durante un número especificado de iteraciones o hasta que se cumpla un criterio de parada, como la convergencia.
Adam se considera una elección popular para la optimización de modelos de aprendizaje profundo debido a su capacidad para adaptar la tasa de aprendizaje a medida que se entrena el modelo, lo que lo hace efectivo en una variedad de aplicaciones y evita problemas como la convergencia lenta o la divergencia en el entrenamiento de redes neuronales. Sin embargo, es importante ajustar adecuadamente los hiperparámetros de Adam, como la tasa de aprendizaje y los momentos, para obtener un rendimiento óptimo en un problema específico.Sencillo ejemplo de un descenso de gradiente del tipo Nesterov.
Descen_Grad_Nesterov_Aula_B_28_18_OCT_github.py
----------------------------------------------------------------------------------------------------
El descenso de gradiente tipo Nesterov, también conocido como el "descenso de gradiente acelerado de Nesterov" o "NAG" por sus siglas en inglés (Nesterov Accelerated Gradient Descent), es una variante del algoritmo de optimización de descenso de gradiente utilizado en el entrenamiento de redes neuronales y en la optimización de funciones en el aprendizaje automático.
Fue propuesto por Yurii Nesterov en 1983 y es una mejora con respecto al descenso de gradiente estándar, especialmente en términos de velocidad de convergencia. El descenso de gradiente Nesterov se diferencia del descenso de gradiente tradicional en cómo se actualizan los parámetros del modelo.
En el descenso de gradiente Nesterov, en lugar de calcular el gradiente de la función de costo en la posición actual de los parámetros, se calcula el gradiente en una posición ligeramente adelantada de los parámetros. Luego, se utiliza ese gradiente para realizar la actualización de los parámetros. Esto tiene el efecto de "mirar hacia adelante" antes de dar el paso de actualización, lo que puede ayudar a reducir la oscilación y mejorar la velocidad de convergencia.
La fórmula para la actualización de los parámetros en el descenso de gradiente tipo Nesterov es la siguiente:
v = γ * v - η * ∇J(θ - γ * v)
θ = θ + v
Donde:
θ son los parámetros del modelo.
∇J(θ - γ * v) es el gradiente de la función de costo evaluado en la posición adelantada de los parámetros.
v es una especie de "momentum" que acumula la velocidad de los pasos anteriores.
η es la tasa de aprendizaje.
γ es un hiperparámetro que controla la influencia del momentum en la actualización.
En resumen, el descenso de gradiente tipo Nesterov es una técnica de optimización que tiene la ventaja de converger más rápidamente que el descenso de gradiente estándar, lo que lo hace especialmente útil en el entrenamiento de redes neuronales profundas y otros problemas de optimización en el aprendizaje automático.
CuadernoAula-B-28-OCT-18.py
-----------------------------------------------------------------------------
La clasificación de datos mediante árboles de decisiones es un método de aprendizaje automático que se utiliza para categorizar o etiquetar datos en diferentes clases o categorías. Es una técnica de modelado predictivo que se basa en la creación de un "árbol" de decisiones, donde cada nodo interno del árbol representa una pregunta o una prueba sobre una característica específica de los datos, y las ramas que salen de ese nodo conducen a diferentes resultados o decisiones basadas en el valor de esa característica. Los nodos hoja del árbol representan las categorías o clases en las que se divide el conjunto de datos.
El proceso de clasificación a través de árboles de decisión implica:
Construcción del árbol: Se inicia con un nodo raíz que representa todo el conjunto de datos. Luego, se selecciona una característica y un umbral que se utilizará para dividir los datos en dos subconjuntos. Este proceso se repite recursivamente en cada subconjunto hasta que se alcanza un criterio de parada, como un tamaño máximo de profundidad del árbol, una cantidad mínima de muestras en los nodos hoja, o una impureza mínima.
Selección de características: En cada paso de división, se elige la característica que mejor separa los datos, lo que se logra al minimizar alguna métrica de impureza, como el índice de Gini o la entropía. La característica y el umbral que minimizan la impureza se utilizan para dividir los datos en dos ramas.
Predicción: Una vez construido el árbol, se utiliza para hacer predicciones sobre datos nuevos. Los datos nuevos se introducen en el árbol, siguiendo las ramas que corresponden a las características de esos datos, hasta llegar a un nodo hoja que representa la clase predicha.
Los árboles de decisión son atractivos porque son interpretables y fáciles de visualizar. Sin embargo, pueden ser propensos al sobreajuste (overfitting), especialmente si se construyen árboles muy profundos. Para abordar este problema, se pueden utilizar técnicas como la poda (pruning) o el uso de bosques aleatorios (random forests) que combinan múltiples árboles para mejorar la precisión y reducir el sobreajuste.
En resumen, la clasificación de datos mediante árboles de decisión es una técnica poderosa y ampliamente utilizada en aprendizaje automático para tareas de clasificación, donde el objetivo es predecir la categoría o clase a la que pertenecen los datos de entrada en función de sus características.
