Curso Google Colab 2026 — Parte 2: Visualización, IA, APIs y Proyecto Final (Módulos 5 al 8)

📌 Nivel: Intermedio a Avanzado | 🕒 Duración: 4 horas | ⬅️ Requisito: Completar la Parte 1

📚 Contenido de esta Parte

• Módulo 5: Visualización de Datos con Matplotlib, Seaborn y Plotly
• Módulo 6: Inteligencia Artificial con Colab (ML + Hugging Face)
• Módulo 7: Automatización y Consumo de APIs REST
• Módulo 8: Proyecto Final — Dashboard Completo de Marketing

📓 MÓDULO 5: Visualización de Datos

Visualizar datos es clave para comunicar resultados y tomar decisiones. Aprenderás a crear gráficas profesionales con 3 librerías diferentes.

🔹 Paso 1 — Configurar el Entorno de Visualización

1. Abre un nuevo notebook en Google Colab
2. Agrega una celda con +Código
3. Escribe y ejecuta con Shift + Enter:

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

plt.style.use('seaborn-v0_8-darkgrid')
COLORES = ['#6C63FF', '#FF6584', '#43B89C', '#FFD166', '#EF476F', '#118AB2']

print("✅ Librerías listas")
print("Matplotlib:", plt.matplotlib.__version__)

4. Verifica que no aparezcan errores en rojo
5. El mensaje ✅ confirma que todo está listo

🔹 Paso 2 — Preparar los Datos Base

1. Agrega nueva celda
2. Crea el dataset que usaremos en todo el módulo:

data = {
    'Canal': ['SEO', 'Meta Ads', 'Email', 'WhatsApp', 'TikTok', 'Google Ads'],
    'Inversion_USD': [500, 1200, 300, 200, 800, 1500],
    'Ventas_USD': [3200, 5600, 2100, 1800, 4300, 7200],
    'Clientes_Nuevos': [45, 120, 38, 22, 95, 110]
}
df = pd.DataFrame(data)
df['ROI_Pct'] = ((df['Ventas_USD'] - df['Inversion_USD']) / df['Inversion_USD'] * 100).round(1)
df['Ganancia_USD'] = df['Ventas_USD'] - df['Inversion_USD']
df['Costo_x_Cliente'] = (df['Inversion_USD'] / df['Clientes_Nuevos']).round(2)

print("✅ Dataset listo:")
print(df[['Canal', 'Inversion_USD', 'Ventas_USD', 'ROI_Pct']].to_string(index=False))

🔹 Paso 3 — Gráfica de Barras con Matplotlib

1. Agrega nueva celda y escribe:

# PASO A: Crear el lienzo
fig, ax = plt.subplots(figsize=(11, 6))

# PASO B: Dibujar las barras
bars = ax.bar(df['Canal'], df['Ventas_USD'], color=COLORES, edgecolor='white', linewidth=0.8)

# PASO C: Etiquetas encima de cada barra
for bar, valor in zip(bars, df['Ventas_USD']):
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 80,
            f'${valor:,}', ha='center', fontweight='bold', fontsize=10)

# PASO D: Títulos y ejes
ax.set_title('Ventas por Canal de Marketing 2026', fontsize=16, fontweight='bold', pad=20)
ax.set_xlabel('Canal', fontsize=12)
ax.set_ylabel('Ventas (USD)', fontsize=12)
ax.set_ylim(0, max(df['Ventas_USD']) * 1.18)

# PASO E: Mostrar
plt.tight_layout()
plt.show()
print("✅ Gráfica generada")

2. Ejecuta — verás la gráfica directamente debajo de la celda

🔹 Paso 4 — Gráfica de ROI Horizontal

# PASO A: Ordenar por ROI
df_roi = df.sort_values('ROI_Pct', ascending=True)

# PASO B: Gráfica horizontal
fig, ax = plt.subplots(figsize=(11, 6))
bars = ax.barh(df_roi['Canal'], df_roi['ROI_Pct'], color=COLORES, height=0.6)

# PASO C: Línea de meta
ax.axvline(x=300, color='red', linestyle='--', linewidth=2, label='Meta: 300% ROI')

# PASO D: Etiquetas
for bar, valor in zip(bars, df_roi['ROI_Pct']):
    ax.text(bar.get_width() + 8, bar.get_y() + bar.get_height()/2,
            f'{valor}%', va='center', fontweight='bold', fontsize=10)

# PASO E: Personalizar
ax.set_title('ROI por Canal de Marketing', fontsize=16, fontweight='bold', pad=20)
ax.set_xlabel('ROI (%)', fontsize=12)
ax.legend(fontsize=11)
ax.set_xlim(0, max(df_roi['ROI_Pct']) * 1.2)
plt.tight_layout()
plt.show()

🔹 Paso 5 — Dashboard con 4 Gráficas Simultáneas

# PASO A: Crear figura 2x2
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
fig.suptitle('Dashboard Marketing Digital 2026 — Ciberclicks', fontsize=16, fontweight='bold')

# PASO B: Gráfica 1 — Ventas
axes[0,0].bar(df['Canal'], df['Ventas_USD'], color=COLORES)
axes[0,0].set_title('Ventas por Canal ($)', fontweight='bold')
axes[0,0].tick_params(axis='x', rotation=30)

# PASO C: Gráfica 2 — ROI
axes[0,1].barh(df['Canal'], df['ROI_Pct'], color=COLORES)
axes[0,1].axvline(x=300, color='red', linestyle='--', label='Meta 300%')
axes[0,1].set_title('ROI por Canal (%)', fontweight='bold')
axes[0,1].legend(fontsize=9)

# PASO D: Gráfica 3 — Dispersión
axes[1,0].scatter(df['Inversion_USD'], df['Ventas_USD'],
                  s=df['Clientes_Nuevos']*6, c=COLORES[:len(df)], alpha=0.8)
for _, row in df.iterrows():
    axes[1,0].annotate(row['Canal'], (row['Inversion_USD'], row['Ventas_USD']),
                       xytext=(5,5), textcoords='offset points', fontsize=8)
axes[1,0].set_title('Inversión vs Ventas', fontweight='bold')
axes[1,0].set_xlabel('Inversión ($)')
axes[1,0].set_ylabel('Ventas ($)')

# PASO E: Gráfica 4 — Costo por cliente
axes[1,1].bar(df['Canal'], df['Costo_x_Cliente'], color=COLORES)
axes[1,1].set_title('Costo por Cliente ($)', fontweight='bold')
axes[1,1].tick_params(axis='x', rotation=30)

# PASO F: Guardar y mostrar
plt.tight_layout()
plt.savefig('/content/dashboard_marketing.png', dpi=150, bbox_inches='tight')
plt.show()
print("✅ Dashboard guardado como dashboard_marketing.png")

🔹 Paso 6 — Gráficas Interactivas con Plotly

import plotly.express as px

# PASO A: Gráfica de burbujas interactiva
fig = px.scatter(
    df, x='Inversion_USD', y='Ventas_USD',
    size='Clientes_Nuevos', color='Canal', text='Canal',
    title='Inversión vs Ventas (tamaño = clientes nuevos)',
    labels={'Inversion_USD': 'Inversión (USD)', 'Ventas_USD': 'Ventas (USD)'},
    hover_data=['ROI_Pct', 'Ganancia_USD']
)

# PASO B: Personalizar
fig.update_traces(textposition='top center', marker=dict(opacity=0.85))
fig.update_layout(height=500, title_font_size=16)

# PASO C: Mostrar
fig.show()
print("✅ Gráfica interactiva lista — pasa el cursor para ver detalles")

📔 MÓDULO 6: Inteligencia Artificial con Colab

Google Colab es la plataforma ideal para IA gracias a su GPU gratuita. Aplicarás Machine Learning y modelos de lenguaje a casos reales de marketing.

🔹 Paso 1 — Activar la GPU Gratuita

1. En el menú superior haz clic en "Entorno de ejecución"
2. Selecciona "Cambiar tipo de entorno de ejecución"
3. En "Acelerador de hardware" selecciona GPU T4
4. Haz clic en "Guardar"
5. El notebook se reinicia automáticamente (es normal)
6. Verifica ejecutando:

import torch

if torch.cuda.is_available():
    nombre_gpu = torch.cuda.get_device_name(0)
    memoria = round(torch.cuda.get_device_properties(0).total_memory / 1e9, 1)
    print(f"✅ GPU activa: {nombre_gpu}")
    print(f"💾 Memoria: {memoria} GB")
else:
    print("⚠️ GPU no disponible. Usando CPU")
    print("Tip: Entorno de ejecución > Cambiar tipo > GPU T4")

🔹 Paso 2 — Importar Librerías de ML

1. Agrega nueva celda y ejecuta:

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_absolute_error
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import numpy as np
import pandas as pd

print("✅ Scikit-learn listo para Machine Learning")

🔹 Paso 3 — Predecir Ventas con Regresión Lineal

1. Agrega nueva celda
2. Prepara los datos históricos:

# PASO A: Dataset histórico de inversión vs ventas
data_ml = {
    'Inversion': [200, 300, 500, 800, 1000, 1200, 1500, 2000, 2500, 3000],
    'Ventas':    [1200, 1800, 3200, 4100, 5000, 5600, 7200, 9500, 11000, 14000]
}
df_ml = pd.DataFrame(data_ml)

X = df_ml[['Inversion']].values
y = df_ml['Ventas'].values

# PASO B: Dividir 80% entrenamiento / 20% prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print(f"Entrenamiento: {len(X_train)} registros")
print(f"Prueba: {len(X_test)} registros")

# PASO C: Entrenar el modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)
print("✅ Modelo entrenado")

# PASO D: Evaluar
y_pred = modelo.predict(X_test)
r2 = r2_score(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
print(f"\nPrecisión (R²): {r2:.2%}")
print(f"Error promedio: ${mae:,.0f}")
print(f"Por cada $1 invertido, ventas aumentan ${modelo.coef_[0]:.2f}")

3. Haz predicciones con diferentes presupuestos:

# PASO E: Proyecciones
print("=== Proyección de Ventas ===")
for presupuesto in [500, 1000, 2000, 3000, 5000, 10000]:
    venta = modelo.predict([[presupuesto]])[0]
    ganancia = venta - presupuesto
    roi = (ganancia / presupuesto) * 100
    print(f"  ${presupuesto:,} → Ventas: ${venta:,.0f} | ROI: {roi:.0f}%")

🔹 Paso 4 — Visualizar el Modelo Predictivo

# PASO A: Generar línea de predicción
X_linea = np.linspace(0, 3500, 100).reshape(-1, 1)
y_linea = modelo.predict(X_linea)

# PASO B: Graficar
fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(X, y, color='#6C63FF', s=80, zorder=5, label='Datos reales')
ax.plot(X_linea, y_linea, color='#FF6584', linewidth=2.5,
        linestyle='--', label='Modelo predictivo')

# PASO C: Personalizar
ax.set_title('Modelo de Predicción de Ventas', fontsize=16, fontweight='bold')
ax.set_xlabel('Inversión (USD)', fontsize=12)
ax.set_ylabel('Ventas (USD)', fontsize=12)
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
print("✅ Gráfica del modelo generada")

🔹 Paso 5 — Análisis de Sentimientos con IA

1. Instala la librería (solo la primera vez):

!pip install transformers -q
print("✅ Transformers instalado")

2. Carga el modelo y analiza reseñas:

from transformers import pipeline

# PASO A: Cargar modelo
print("Cargando modelo... (puede tardar 30 seg la primera vez)")
analisis = pipeline("sentiment-analysis")
print("✅ Modelo de IA listo")

# PASO B: Reseñas de clientes
resenas = [
    "Excelente servicio, muy rápido y profesional. Totalmente recomendado",
    "El producto llegó dañado y el soporte no respondió. Pésima experiencia",
    "Buena calidad, precio justo. Volvería a comprar sin duda",
    "Demoró más de lo esperado pero el producto está bien",
    "Increíble, superó mis expectativas. El mejor del mercado",
    "No funciona como dicen. Muy decepcionante"
]

# PASO C: Analizar cada reseña
print("\n=== Análisis de Reseñas ===")
positivas = negativas = 0
for resena in resenas:
    r = analisis(resena)[0]
    if r['label'] == 'POSITIVE':
        emoji = "🟢"
        positivas += 1
    else:
        emoji = "🔴"
        negativas += 1
    print(f"{emoji} ({r['score']:.0%}) '{resena[:50]}...'")

# PASO D: Resumen
print(f"\n📊 {positivas} positivas | {negativas} negativas")
print(f"Satisfacción: {positivas/(positivas+negativas):.0%}")

🔹 Paso 6 — Segmentación de Clientes con K-Means

# PASO A: Crear dataset de clientes
np.random.seed(42)
n = 100
df_cli = pd.DataFrame({
    'Compras_Anuales': np.random.randint(1, 20, n),
    'Gasto_Total_USD': np.random.randint(50, 5000, n),
    'Dias_Ultimo_Pedido': np.random.randint(1, 365, n)
})

# PASO B: Normalizar
scaler = StandardScaler()
X_scaled = scaler.fit_transform(df_cli)

# PASO C: Aplicar K-Means (3 segmentos)
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
df_cli['Segmento'] = kmeans.fit_predict(X_scaled)

# PASO D: Etiquetar segmentos
nombres = {0: '🏆 VIP', 1: '🟡 Regular', 2: '🔴 Inactivo'}
df_cli['Tipo'] = df_cli['Segmento'].map(nombres)

# PASO E: Resultados
print("=== Segmentación de Clientes ===")
print(df_cli.groupby('Tipo')[['Compras_Anuales','Gasto_Total_USD']].mean().round(1))
print(f"\nTotal: {len(df_cli)} clientes")
print(df_cli['Tipo'].value_counts())

👉 Continúa en la siguiente sección con los Módulos 7 y 8: Automatización con APIs y el Proyecto Final Dashboard de Marketing.

¿Quieres Aprender Más con Ciberclicks?

En Ciberclicks ofrecemos cursos, consultorías y planes de marketing digital para PYMEs en LATAM.

👉 Agenda tu consultoría gratuita y transforma tu negocio en 2026.