César Antonio | Oiga Profe
¿Llevas meses intentando aprender programación y no avanzas?

No es que no seas inteligente… te enseñaron mal. Yo te ayudo a entender programación desde la lógica.

Soy docente en ingeniería… y me dedico a algo muy específico: Ayudar a personas que ya intentaron aprender programación… y no les funcionó.

Mi trabajo se basa en programación, lógica computacional, ciberseguridad, desarrollo de videojuegos y pensamiento estructurado, integrando también elementos de reflexión personal, consciencia y narrativa.

Mi formación y experiencia me permiten convertir temas complejos en experiencias de aprendizaje accesibles, profundas y prácticas. Mi misión no es solo que comprendas herramientas, sino que las entiendas con sentido, contexto y autonomía.

DESCARGA MI CV

What Clients Say

Commendations

Rainbow-Themes

Nevine Acotanza

Chief Operating Officer

Android App Development

via Upwork - Mar 4, 2015 - Aug 30, 2021 test

Maecenas finibus nec sem ut imperdiet. Ut tincidunt est ac dolor aliquam sodales. Phasellus sed mauris hendrerit, laoreet sem in, lobortis mauris hendrerit ante. Ut tincidunt est ac dolor aliquam sodales phasellus smauris test

Bound - Trolola

Jone Duone Joe

Operating Officer

Web App Development

Upwork - Mar 4, 2016 - Aug 30, 2021

Glassfisom

Nevine Dhawan

CEO Of Officer

Android App Design

Upwork - Mar 4, 2016 - Aug 30, 2021

[Código Principal]

No te pierdas mi contenido

abril 6, 2026

Optimización de consultas SQL para el rendimiento: una guía completa

En este artículo

Tabla de Contenido

Introducción

En el mundo de la gestión de bases de datos, optimizar consultas SQL para el rendimiento es una habilidad crucial. Consultas mal optimizadas pueden provocar tiempos de respuesta lentos, menor eficiencia y un mayor consumo de recursos. En esta entrada del blog, exploraremos diversas estrategias y mejores prácticas para optimizar consultas SQL y mejorar el rendimiento.

Comprendiendo la optimización de consultas SQL

La optimización de consultas SQL es el proceso de mejorar el rendimiento de una consulta seleccionando el plan de ejecución más eficiente. El objetivo es minimizar el tiempo de respuesta y el consumo de recursos de la consulta, maximizando el rendimiento. La optimización de consultas implica diversas técnicas, como la indexación, la reescritura de consultas y la reestructuración de datos.

1. Utilizar los índices con sabiduría

Los índices son una de las herramientas más potentes para optimizar consultas SQL. Permiten al motor de la base de datos localizar rápidamente filas basadas en los valores de columnas específicas. Sin embargo, usar demasiados índices puede ralentizar las operaciones de escritura y aumentar los requisitos de almacenamiento. Aquí tienes algunos consejos para usar los índices con sabiduría:

Identifica las columnas que se usan frecuentemente en , , y en las clausuras, y crea índices en estas columnas.WHEREJOINORDER BY
Utiliza índices compuestos para consultas que involucren múltiples columnas en la cláusula.WHERE
Revisa y elimina regularmente índices innecesarios para mejorar el rendimiento de escritura.

Ejemplo: Usar los índices con sabiduría

-- Creating an index on the 'email' column
CREATE INDEX idx_email ON users (email);

-- Query using the indexed column
SELECT * FROM users WHERE email = 'example@example.com';

2. Evita usar comodines al principio de las consultas LIKE

Usar comodines () al principio de una consulta puede impedir que el motor de base de datos utilice los índices de forma eficiente. En su lugar, intenta estructurar tus consultas de modo que los comodines estén al final de la cadena.%LIKELIKE

Ejemplo: Evitar comodines al principio de las consultas LIKE

-- Inefficient query with wildcard at the beginning
SELECT * FROM products WHERE name LIKE '%apple';

-- Optimized query with wildcard at the end
SELECT * FROM products WHERE name LIKE 'apple%';

3. Minimizar el uso de subconsultas

Las subconsultas pueden ser útiles para consultas complejas, pero también pueden ser cuellos de botella en el rendimiento. Siempre que sea posible, intenta reescribir las subconsultas como uniones, ya que las uniones suelen ser más eficientes.

Ejemplo: Minimizar el uso de subconsultas

-- Subquery example
SELECT * FROM orders WHERE customer_id IN (SELECT id FROM customers WHERE name = 'Alice');

-- Equivalent join example
SELECT o.* FROM orders o JOIN customers c ON o.customer_id = c.id WHERE c.name = 'Alice';

4. Utilizar EXPLAIN para analizar el rendimiento de consultas

La mayoría de los sistemas de gestión de bases de datos proporcionan un comando EXPLAIN que puede usarse para analizar el plan de ejecución de una consulta. Esto puede ayudarte a identificar posibles cuellos de botella en el rendimiento y optimizar tus consultas en consecuencia.

Ejemplo: Usar EXPLAIN para analizar el rendimiento de consultas

EXPLAIN SELECT * FROM products WHERE category_id = 1;

5. Considerar el uso de características específicas de la base de datos

Diferentes sistemas de gestión de bases de datos tienen distintas características y optimizaciones. Por ejemplo, PostgreSQL tiene opciones avanzadas de indexación como índices parciales e índices de expresión, mientras que MySQL cuenta con funciones como caché de consultas y procedimientos almacenados. Comprender y aprovechar estas funciones puede ayudarte a optimizar tus consultas para un mejor rendimiento.

Ejemplo: Uso de características específicas de la base de datos

-- PostgreSQL partial index example
CREATE INDEX idx_active_products ON products (id) WHERE active = true;

-- MySQL query caching example
SELECT SQL_CACHE * FROM products;

6. Usar LIMIT para recuperar un subconjunto de resultados

Si solo necesitas recuperar un subconjunto de resultados, considera usar la cláusula para limitar el número de filas devueltas por la consulta. Esto puede ayudar a reducir la cantidad de datos que deben procesarse y transmitirse, mejorando el rendimiento global.LIMIT

Ejemplo: Usar LIMIT para recuperar un subconjunto de resultados

-- Retrieving the first 10 active users
SELECT * FROM users WHERE active = true LIMIT 10;

7. Optimizar el diseño de bases de datos

Por último, optimizar las consultas SQL para el rendimiento también implica optimizar el diseño de tu base de datos. Esto incluye normalizar correctamente el esquema de tu base de datos, usar los tipos de datos adecuados y evitar duplicaciones innecesarias de datos.

Ejemplo: Optimización del diseño de bases de datos

-- Properly normalizing the database schema
CREATE TABLE customers (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL
);

CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    customer_id INTEGER REFERENCES customers(id),
    total_amount DECIMAL(10, 2) NOT NULL
);

Estos ejemplos demuestran cómo puedes aplicar diversas técnicas de optimización para mejorar el rendimiento de tus consultas SQL.

Conclusión

Optimizar las consultas SQL para el rendimiento es una habilidad crítica para administradores y desarrolladores de bases de datos. Siguiendo las mejores prácticas descritas en esta entrada del blog, puedes mejorar el rendimiento de tus consultas SQL y garantizar que tus aplicaciones de base de datos funcionen de forma fluida y eficiente.

Comparte tus pensamientos

¿Has utilizado técnicas avanzadas para optimizar consultas SQL? ¡Comparte tus experiencias y consejos en los comentarios abajo!

marzo 16, 2026

Introducción al aprendizaje automático

En este artículo

Tabla de Contenido

Objetivos de aprendizaje

Tras completar este capítulo, podrás:

Comprender cómo se utiliza el aprendizaje automático para resolver problemas del mundo real.
Comprender el tipo de algoritmos y marcos de aprendizaje automático que se utilizan para construir modelos de aprendizaje automático.

Introducción a la analítica y al aprendizaje automático

El análisis en el aprendizaje automático se refiere al proceso de analizar e interpretar datos paraobtener información valiosa, tomar decisiones informadasy mejorar los modelos de aprendizaje automático. Este proceso implica varias técnicas y herramientas para explorar, visualizar y comprender los datos, así como para evaluar el rendimiento de los modelos de aprendizaje automático.

Analicemos cómo conceptos como la Inteligencia Artificial (IA), el Aprendizaje Automático (AA) y el Aprendizaje Profundo (AP) se relacionan con las técnicas analíticas:

Inteligencia Artificial (IA): La IA es un campo amplio de la informática centrado en la creación de máquinas inteligentes que pueden simular el comportamiento humano. En el contexto de la analítica,AI Estas técnicas pueden utilizarse para analizar datos, realizar predicciones y automatizar los procesos de toma de decisiones.Las herramientas analíticas basadas en inteligencia artificial pueden procesar grandes volúmenes de datos, identificar patrones y generar información valiosa para respaldar la toma de decisiones.
Aprendizaje automático (ML):ML es un subconjunto de la IA que se centra en el desarrollo de algoritmos y modelos estadísticos que permiten a las computadoras aprender de los datos y hacer predicciones o tomar decisiones basadas en ellos.En analítica, las técnicas de aprendizaje automático se utilizan para construir modelos predictivos que pueden analizar datos y hacer predicciones sobre resultados futuros. Las técnicas de aprendizaje automático más comunes incluyen regresión, clasificación, agrupamiento y aprendizaje por refuerzo.
Aprendizaje profundo (DL):DL es un subconjunto del aprendizaje automático que utiliza redes neuronales artificiales para modelar y procesar patrones complejos en grandes cantidades de datos.Las técnicas de DL son particularmente efectivas para tareas como el reconocimiento de imágenes y voz, el procesamiento del lenguaje natural y los sistemas de recomendación. En analítica,El aprendizaje profundo se puede utilizar para analizar datos no estructurados, como imágenes, texto y audio, y extraer información valiosa.

La relación entre AL, ML y DL se puede visualizar como se muestra en la Imagen 1.1.

**Imagen 1.1:** Relación entre inteligencia artificial, aprendizaje automático y aprendizaje profundo.

Lo importante es que todos ellos son algoritmos, que no son más que conjuntos de instrucciones utilizadas para resolver problemas del mundo real.

Los algoritmos de aprendizaje automático se dividen en cuatro categorías, tal como se define a continuación:

Algoritmos de aprendizaje supervisado

Supervisado Los algoritmos de aprendizaje aprenden de datos de entrenamiento etiquetados para hacer predicciones o tomar decisiones sobre datos nuevos.Los algoritmos comunes incluyen la regresión lineal (para predicciones continuas), la regresión logística (para clasificación binaria), los árboles de decisión (tanto para clasificación como para regresión), los bosques aleatorios (un método de conjunto para una mayor precisión), las máquinas de vectores de soporte (para clasificación binaria y regresión), los k vecinos más cercanos (tanto para clasificación como para regresión), el clasificador bayesiano ingenuo (un clasificador probabilístico) y las redes neuronales (algoritmos versátiles inspirados en la estructura del cerebro).

Aquí tienes un breve ejemplo de cómo se puede utilizar un algoritmo de aprendizaje supervisado, concretamente la regresión lineal:

Supongamos que tenemos un conjunto de datos con información sobre casas, como su tamaño (en pies cuadrados) y precio (en rupias). Queremos crear un modelo que pueda predecir el precio de una casa en función de su tamaño.

Conjunto de datos: Tenemos un conjunto de datos con varios ejemplos de casas, cada una con un tamaño (característica de entrada) y un precio (variable objetivo).
Entrenamiento: Utilizamos este conjunto de datos para entrenar un modelo de regresión lineal. Durante el entrenamiento, el modelo aprende la relación entre el tamaño de una casa y su precio ajustando sus parámetros.(pendiente e intersección) para minimizar el error entre sus predicciones y los precios reales en los datos de entrenamiento.
Predicción: Una vez entrenado el modelo, podemos usarlo para predecir el precio de una casa nueva en función de su tamaño.El modelo utiliza la relación aprendida para hacer predicciones sobre datos nuevos y no vistos..
Evaluación:Evaluamos el desempeño del modelo comparando sus predicciones en un conjunto de datos de prueba (datos no vistos durante el entrenamiento) con los precios reales.Las métricas de evaluación comunes para las tareas de regresión incluyen el error cuadrático medio (MSE) o el coeficiente de determinación (R cuadrado).
Aplicación: El modelo entrenado ahora se puede utilizar para predecir los precios de las viviendas en función de su tamaño en aplicaciones del mundo real.

Aquí tienes un ejemplo sencillo de regresión lineal utilizando la biblioteca scikit-learn de Python para predecir los precios de las viviendas en función de su tamaño:

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Sample dataset (house sizes in square feet and prices in rupees)
sizes = np.array([600, 800, 1000, 1200, 1500, 1800]).reshape(-1, 1)
prices = np.array([100000, 150000, 200000, 250000, 300000, 350000])

# Split the dataset into training and test sets
X_train, X_test, y_train, y_test = train_test_split(sizes, prices, test_size=0.2, random_state=42)

# Create and train the linear regression model
model = LinearRegression()
model.fit(X_train, y_train)

# Make predictions on the test set
y_pred = model.predict(X_test)

# Plot the data and the linear regression line
plt.scatter(sizes, prices, color='blue', label='Actual prices')
plt.plot(sizes, model.predict(sizes), color='red', label='Predicted prices')
plt.xlabel('Size (sq. ft)')
plt.ylabel('Price ($)')
plt.legend()
plt.show()

# Example prediction
house_size = 1400
predicted_price = model.predict([[house_size]])
print(f"Predicted price for a {house_size} sq. ft house: ${predicted_price[0]:,.2f}")

Este es un ejemplo básico para demostrar la regresión lineal. En un escenario real, normalmente se usaría un conjunto de datos más grande y diverso para el entrenamiento y las pruebas, y también se considerarían características adicionales (más allá del tamaño de la vivienda) que podrían influir en los precios de las casas.

Algoritmos de aprendizaje no supervisado

Los algoritmos de aprendizaje no supervisado se utilizan paraencontrar patrones o estructuras en los datos sin guía explícita o resultados etiquetadosExploran los datos para comprender sus propiedades y descubrir patrones o relaciones ocultas. Los algoritmos comunes incluyen agrupamiento (p. ej., K-means ), reducción de dimensionalidad (p. ej., PCA), aprendizaje de reglas de asociación (p. ej., Apriori) y modelos generativos (p. ej., GAN). El aprendizaje no supervisado se utiliza para tareas como agrupar documentos similares, detectar anomalías, reducir la dimensionalidad para la visualización y generar datos sintéticos.

Aquí tienes un breve ejemplo de cómo se puede utilizar en la práctica el clustering, un tipo de algoritmo de aprendizaje no supervisado:

Imagina que tienes un conjunto de datos con información sobre los clientes de una tienda online, incluyendo datos como edad, ingresos e historial de compras. Quieres agrupar a los clientes con características similares para comprender mejor su comportamiento y adaptar las estrategias de marketing.

Preprocesamiento de datos : Antes de aplicar la agrupación, normalmente se preprocesan los datos, lo que puede incluir el manejo de valores faltantes, el escalado de características y la codificación de variables categóricas.
Elección de un algoritmo de agrupamiento : En este caso, decide utilizar el algoritmo de agrupamiento K-means , un algoritmo popular que divide el conjunto de datos en K grupos, donde cada punto de datos pertenece al grupo con la media más cercana.
Determinación del número de clústeres :Uno de los desafíos en la agrupación K-means es determinar el número óptimo de clústeres (K).Puedes utilizar técnicas como el método del codo o la puntuación de la silueta para encontrar el valor K óptimo.
Aplicación del algoritmo de agrupamiento K-means : Una vez que haya determinado el número de clústeres, aplique el algoritmo K-means al conjunto de datos preprocesado.El algoritmo asigna iterativamente los puntos de datos al centro del clúster más cercano y actualiza los centros de los clústeres hasta que converge.
Análisis de los clústeres : Tras la agrupación , puede analizar los clústeres resultantes para comprender los segmentos de clientes. Por ejemplo, podría encontrar clústeres de clientes jóvenes con altos ingresos que realizan compras frecuentes y clústeres de clientes mayores y con presupuestos ajustados que realizan compras ocasionales.
Adaptación de las estrategias de marketing : Basándose en el análisis de clústeres, puede adaptar las estrategias de marketing a diferentes segmentos de clientes. Por ejemplo, podría ofrecer descuentos al segmento que busca ahorrar o promocionar nuevos productos al segmento de compradores frecuentes.
Evaluación : Es importante evaluar los resultados de la agrupación para asegurar que sean significativos y útiles. Se pueden utilizar métricas como el coeficiente de silueta o la inspección visual de las asignaciones de clústeres para evaluar la calidad de la agrupación.

Aquí tienes un ejemplo de cómo podrías implementar el algoritmo de agrupamiento K-means en Python utilizando la biblioteca scikit-learn:

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import pandas as pd
import matplotlib.pyplot as plt

# Sample customer data (age, income, purchase history)
data = {
    'Age': [25, 30, 35, 20, 45, 50, 60, 55, 70, 65],
    'Income': [50000, 60000, 75000, 40000, 90000, 100000, 95000, 110000, 150000, 140000],
    'Purchase History': [1, 2, 3, 1, 3, 2, 3, 1, 2, 3]
}

df = pd.DataFrame(data)

# Standardize the features
scaler = StandardScaler()
scaled_data = scaler.fit_transform(df)

# Apply K-means clustering
kmeans = KMeans(n_clusters=3, random_state=42)
df['Cluster'] = kmeans.fit_predict(scaled_data)

# Visualize the clusters
plt.scatter(df['Age'], df['Income'], c=df['Cluster'], cmap='viridis')
plt.xlabel('Age')
plt.ylabel('Income')
plt.title('Customer Segmentation')
plt.show()

En este ejemplo, primero estandarizamos las características StandardScalerpara asegurar que cada una contribuya por igual al proceso de agrupamiento. Luego aplicamos el algoritmo K-means n_clusters=3para agrupar a los clientes en tres clústeres según su edad, ingresos e historial de compras. Finalmente, visualizamos los clústeres mediante un diagrama de dispersión, donde cada clúster está representado por un color diferente.

Algoritmos de aprendizaje por refuerzo

Aprendizaje por refuerzo Los algoritmos de aprendizaje por refuerzo (RL) entrenan a los agentes para tomar decisiones interactuando con un entorno para lograr un objetivo o maximizar una recompensa.Entre los principales algoritmos de aprendizaje por refuerzo se incluyen el aprendizaje Q, las redes neuronales profundas Q (DQN), los métodos de gradiente de política, los métodos actor-crítico y el aprendizaje por diferencia temporal (TD). Estos algoritmos se utilizan en diversas aplicaciones, como juegos, robótica y gestión de recursos.

Aquí tienes un ejemplo sencillo de cómo podrías usar el aprendizaje Q para enseñar a un robot a navegar por un mundo cuadriculado para alcanzar un objetivo:

Configuración del entorno : Defina un mundo de cuadrícula con una posición inicial, una posición final y obstáculos.
Inicialización de la tabla Q : Inicializa una tabla Q para almacenar la utilidad esperada de realizar acciones en cada estado. Inicialmente, los valores Q se establecen en cero.
Formación del agente :
- Comience desde el estado inicial.
- Elija una acción utilizando una política epsilon-greedy (explorar con probabilidad epsilon, explotar con probabilidad 1-epsilon).
- Realiza la acción y observa la recompensa y el nuevo estado.
- Actualiza el valor Q para el par estado-acción actual utilizando la regla de actualización de aprendizaje Q.
- Repita los pasos anteriores hasta alcanzar el estado deseado o el número máximo de pasos.
Regla de actualización de Q-Learning :
- Q[estado, acción] = Q[estado, acción] + alfa (recompensa + gamma max(Q[nuevo_estado, :]) – Q[estado, acción])
  - alphaes la tasa de aprendizaje.
  - gammaes el factor de descuento.
Probando el agente :
- Utilice los valores Q aprendidos para determinar la mejor acción en cada estado.
- Mueva al agente según las mejores acciones hasta que alcance el objetivo o se alcance un número máximo de pasos.
Visualización : Visualice la trayectoria del agente y los valores Q aprendidos en el mundo de la cuadrícula.

Este ejemplo ilustra los principios básicos del aprendizaje Q. En la práctica, se utilizan algoritmos y técnicas más sofisticadas para problemas más complejos.

Aquí tenéis una implementación sencilla en Python del algoritmo Q-learning para un problema de navegación en un mundo cuadriculado:

import numpy as np

# Define the grid world
GRID_SIZE = 5
START_STATE = (0, 0)
GOAL_STATE = (GRID_SIZE - 1, GRID_SIZE - 1)
OBSTACLES = [(1, 1), (2, 2), (3, 3)]
ACTIONS = ['up', 'down', 'left', 'right']
NUM_EPISODES = 1000
MAX_STEPS = 100
EPSILON = 0.1
ALPHA = 0.1
GAMMA = 0.9

# Initialize Q-table
Q = np.zeros((GRID_SIZE, GRID_SIZE, len(ACTIONS)))

# Helper function to get valid next states
def get_next_states(state):
    x, y = state
    next_states = []
    for action in ACTIONS:
        if action == 'up' and x > 0:
            next_states.append((x - 1, y))
        elif action == 'down' and x < GRID_SIZE - 1:
            next_states.append((x + 1, y))
        elif action == 'left' and y > 0:
            next_states.append((x, y - 1))
        elif action == 'right' and y < GRID_SIZE - 1:
            next_states.append((x, y + 1))
    return next_states

# Q-learning algorithm
for _ in range(NUM_EPISODES):
    state = START_STATE
    for _ in range(MAX_STEPS):
        if state == GOAL_STATE:
            break
        if np.random.rand() < EPSILON:
            action = np.random.choice(ACTIONS)
        else:
            action = ACTIONS[np.argmax(Q[state[0], state[1]])]
        next_states = get_next_states(state)
        next_state = next_states[np.random.choice(len(next_states))]
        reward = 1 if next_state == GOAL_STATE else -1
        Q[state[0], state[1], ACTIONS.index(action)] += ALPHA * (reward + GAMMA * np.max(Q[next_state[0], next_state[1]]) - Q[state[0], state[1], ACTIONS.index(action)])
        state = next_state

# Test the learned policy
state = START_STATE
path = [state]
while state != GOAL_STATE:
    action = ACTIONS[np.argmax(Q[state[0], state[1]])]
    next_states = get_next_states(state)
    next_state = next_states[np.argmax([Q[state[0], state[1], ACTIONS.index(a)] for a in ACTIONS])]
    state = next_state
    path.append(state)

# Print the learned policy and path
print("Learned Q-values:")
print(Q)
print("Optimal path:")
for state in path:
    print(state)

Este código define un mundo cuadriculado simple de 5×5 con obstáculos, donde el agente (representado por un robot) aprende a navegar desde el estado inicial hasta el estado objetivo mediante el aprendizaje Q. El agente actualiza sus valores Q en función de las recompensas recibidas y utiliza una política epsilon-greedy para explorar el entorno. Finalmente, la política aprendida se utiliza para encontrar la ruta óptima desde el estado inicial hasta el estado objetivo.

Algoritmos de aprendizaje evolutivo

Los algoritmos evolutivos (AE) son algoritmos de optimización inspirados en la evolución natural.Mejoran iterativamente las soluciones candidatas a problemas de optimización utilizando operadores de selección, cruce y mutación.Entre los principales algoritmos evolutivos se incluyen los algoritmos genéticos (AG), la programación genética (PG), la evolución diferencial (ED), las estrategias evolutivas (EE), la optimización por enjambre de partículas (PSO) y la optimización por colonia de hormigas (ACO). Estos algoritmos se utilizan en diversas aplicaciones para resolver problemas complejos de optimización y búsqueda.

Aquí tienes un ejemplo sencillo de cómo se puede utilizar un algoritmo evolutivo para resolver un problema de optimización básico, como encontrar el valor máximo de una función:

Inicialización : Crea una población de soluciones aleatorias, donde cada solución representa un posible orden de las ciudades a visitar. Por ejemplo, si hay 5 ciudades, una solución podría representarse como [1, 3, 2, 4, 5], indicando el orden en que se deben visitar las ciudades.
Evaluación : Evaluar la aptitud de cada solución en la población. La aptitud podría ser la distancia total recorrida para el orden de ciudades dado.
Selección : Se seleccionan individuos de la población para que sirvan como progenitores de la siguiente generación. Los individuos se seleccionan con una probabilidad proporcional a su aptitud, por lo que las soluciones con distancias totales más cortas tienen más probabilidades de ser seleccionadas.
Cruce : Realiza un cruce para crear descendencia a partir de los padres seleccionados. Un método común de cruce para el problema del viajante es el cruce ordenado (OX), que conserva el orden relativo de las ciudades entre los dos padres.
Mutación : En ocasiones, se aplica una mutación a la descendencia para introducir diversidad. Por ejemplo, se podrían intercambiar dos ciudades en el orden.
Reemplazo : Reemplazar la población actual con la nueva población de descendientes.
Terminación : Repita los pasos de selección, cruce, mutación y reemplazo durante un número fijo de generaciones o hasta que se cumpla una condición de terminación (por ejemplo, se alcance el número máximo de generaciones o se logre el nivel de aptitud deseado).

A lo largo de sucesivas generaciones, la población debería evolucionar hasta contener individuos con distancias totales recorridas más cortas, convergiendo finalmente hacia la solución óptima para el problema del viajante.

Aquí se muestra una implementación básica en Python de un algoritmo evolutivo para resolver el Problema del Viajante (TSP) utilizando un método de cruce ordenado (OX) simple para el cruce y una mutación de intercambio:

import random

# Define the cities and their coordinates
cities = {
    1: (0, 0),
    2: (1, 2),
    3: (3, 1),
    4: (5, 2),
    5: (6, 0)
}

# Calculate the distance between two cities
def distance(city1, city2):
    x1, y1 = cities[city1]
    x2, y2 = cities[city2]
    return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

# Calculate the total distance of a route
def total_distance(route):
    return sum(distance(route[i], route[i + 1]) for i in range(len(route) - 1)) + distance(route[-1], route[0])

# Initialize population
def init_population(population_size, city_count):
    return [[city for city in range(1, city_count + 1)] for _ in range(population_size)]

# Perform ordered crossover (OX) between two parent routes
def crossover(parent1, parent2):
    start = random.randint(0, len(parent1) - 1)
    end = random.randint(start + 1, len(parent1))
    offspring = [-1] * len(parent1)
    offspring[start:end] = parent1[start:end]
    for city in parent2:
        if city not in offspring:
            for i in range(len(offspring)):
                if offspring[i] == -1:
                    offspring[i] = city
                    break
    return offspring

# Perform swap mutation on a route
def mutate(route):
    index1, index2 = random.sample(range(len(route)), 2)
    route[index1], route[index2] = route[index2], route[index1]

# Evolutionary algorithm
def evolutionary_algorithm(population_size, city_count, generations):
    population = init_population(population_size, city_count)
    for _ in range(generations):
        offspring = []
        for _ in range(population_size // 2):
            parent1, parent2 = random.sample(population, 2)
            child1 = crossover(parent1, parent2)
            child2 = crossover(parent2, parent1)
            mutate(child1)
            mutate(child2)
            offspring.extend([child1, child2])
        population = offspring
    best_route = min(population, key=total_distance)
    return best_route, total_distance(best_route)

# Example usage
population_size = 50
city_count = 5
generations = 1000
best_route, best_distance = evolutionary_algorithm(population_size, city_count, generations)
print("Best Route:", best_route, "Total Distance:", best_distance)

Este código proporciona un marco básico para resolver el problema del viajante mediante un algoritmo evolutivo. Cabe destacar que esta implementación utiliza una representación simple de las rutas como permutaciones de ciudades y podría no ser adecuada para problemas de gran escala.

En conclusión, este capítulo sirve como introducción fundamental al fascinante mundo del aprendizaje automático, guiando a los principiantes a través de los conceptos y técnicas esenciales que sustentan esta tecnología transformadora. Desde comprender el papel crucial de la analítica en el aprendizaje automático hasta explorar los diversos algoritmos que impulsan los modelos predictivos, y destacar la importancia de Python en el desarrollo de estos modelos, nos hemos embarcado en un viaje integral al ámbito de la inteligencia artificial. Al familiarizarnos con los tipos de algoritmos de aprendizaje automático —supervisado, no supervisado, por refuerzo y evolutivo— y sus aplicaciones prácticas, hemos sentado las bases para una exploración e innovación más profundas en los capítulos siguientes. Esta exploración no solo desmitifica las complejas interrelaciones entre IA, ML y DL, sino que también capacita a los estudiantes con el conocimiento necesario para iniciar sus proyectos utilizando la plataforma Anaconda y el rico ecosistema de bibliotecas de Python. A medida que continuamos profundizando en las capacidades y aplicaciones del aprendizaje automático, el potencial para crear soluciones inteligentes e impactantes a problemas del mundo real se vuelve cada vez más tangible.

César Antonio | Oiga Profe
¿Llevas meses intentando aprender programación y no avanzas?

Soy docente en ingeniería… y me dedico a algo muy específico: Ayudar a personas que ya intentaron aprender programación… y no les funcionó.

Commendations

Nevine Acotanza

Android App Development

Jone Duone Joe

Web App Development

Nevine Dhawan

Android App Design

No te pierdas mi contenido

Sígueme

¿Requieres una asesoría?

César Antonio | Oiga Profe ¿Llevas meses intentando aprender programación y no avanzas?

Soy docente en ingeniería… y me dedico a algo muy específico: Ayudar a personas que ya intentaron aprender programación… y no les funcionó.

Commendations

Nevine Acotanza

Android App Development

Jone Duone Joe

Web App Development

Nevine Dhawan

Android App Design

No te pierdas mi contenido

Optimización de consultas SQL para el rendimiento: una guía completa

Microsoft mejora PowerShell: el cambio de enfoque que redefine la automatización en 2026

¿Qué es la Programación?

¿QUÉ ES CÓDIGO FUENTE?

Introducción al aprendizaje automático

Las 5 mejores maneras de detectar y eliminar programas espía de tu sistema

Sígueme

¿Requieres una asesoría?

César Antonio | Oiga Profe
¿Llevas meses intentando aprender programación y no avanzas?