Ejercicios Prácticos de Sistemas de Análisis de Información

1. Conexión a Datos

{
  "version": "1.0",
  "connections": [
    {
      "name": "CuboVentas",
      "connectionType": "analysisServices",
      "server": "as-server",
      "database": "VentasOLAP"
    }
  ],
  "queries": [
    {
      "name": "VentasPorRegion",
      "query": "EVALUATE SUMMARIZECOLUMNS(...)"
    }
  ]
}

Pasos en Power BI Desktop:

1. Seleccionar "Obtener datos" → SQL Server Analysis Services
2. Ingresar servidor y seleccionar base de datos
3. Seleccionar cubo "Ventas"

2. Diseño de Visualizaciones

a) Scorecard de KPIs:

• Tarjetas con: Ventas totales, Margen bruto %, Crecimiento interanual
• Formato condicional (rojo/verde para tendencias)

b) Gráfico de tendencia:

• Línea temporal con ventas por mes
• Comparación año anterior

c) Distribución por categoría:

• Gráfico de árbol (treemap) por categoría → subcategoría
• Tamaño por monto ventas, color por margen

d) Tabla detallada:

• Top 10 productos por rentabilidad
• Columnas: Producto, Ventas, Costos, Margen, % Participación

3. Interactividad

{
  "visualizations": [
    {
      "name": "Filtros",
      "type": "slicer",
      "fields": ["Tiempo[Año]", "Producto[Categoría]"],
      "crossFiltering": true
    },
    {
      "name": "GraficoTendencia",
      "type": "lineChart",
      "crossFilteringBehavior": "filter"
    }
  ]
}

Pasos para configurar:

1. Agregar segmentadores (slicers) para año y categoría
2. Configurar interacciones: "Filtrar" en lugar de "Resaltar"
3. Habilitar cross-filtering en opciones de página

4. Publicación y Compartir

# Publicar a Power BI Service
Publish-PowerBIFile -Path "VentasDashboard.pbix" -WorkspaceId "12345"

# Configurar actualización programada
Set-PowerBIDatasetRefreshSchedule -DatasetId "67890" -Daily -Time "02:00"

Pasos para compartir:

1. Publicar desde Power BI Desktop al servicio en la nube
2. Configurar actualización automática de datos
3. Compartir con usuarios/grupos específicos
4. Opcional: Incrustar en portal web o SharePoint

1. Estadísticas Descriptivas

import pandas as pd
import numpy as np

# Cargar datos
ventas = pd.read_csv('ventas_2023.csv')

# Estadísticas básicas
stats = ventas[['cantidad', 'monto']].describe()
print(stats)

# Por categoría
stats_categoria = ventas.groupby('categoria')['monto'].agg(['sum', 'mean', 'std', 'count'])
print(stats_categoria)

2. Análisis de Correlación

import seaborn as sns
import matplotlib.pyplot as plt

# Matriz de correlación
corr = ventas[['cantidad', 'monto', 'descuento', 'costo']].corr()
sns.heatmap(corr, annot=True, cmap='coolwarm')
plt.title('Matriz de Correlación')
plt.show()

# Correlación cruzada
pd.plotting.scatter_matrix(ventas[['monto', 'descuento', 'costo']], figsize=(10,8))
plt.show()

3. Análisis Temporal

# Convertir a serie temporal
ventas['fecha'] = pd.to_datetime(ventas['fecha'])
ventas.set_index('fecha', inplace=True)

# Agregación mensual
mensual = ventas.resample('M')['monto'].sum()

# Gráfico de tendencia
mensual.plot(figsize=(12,6), title='Ventas Mensuales 2023')
plt.ylabel('Ventas')
plt.grid(True)
plt.show()

# Descomposición estacional
from statsmodels.tsa.seasonal import seasonal_decompose
result = seasonal_decompose(mensual, model='additive')
result.plot()
plt.show()

4. Segmentación de Clientes (Clustering)

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Preparar datos
clientes = ventas.groupby('cliente_id').agg({
    'monto': 'sum',
    'cantidad': 'sum',
    'fecha': lambda x: (pd.to_datetime('2023-12-31') - x.max()).days
}).rename(columns={'fecha': 'dias_desde_ultima_compra'})

# Estandarizar
scaler = StandardScaler()
clientes_scaled = scaler.fit_transform(clientes)

# Determinar número óptimo de clusters (método del codo)
inertia = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(clientes_scaled)
    inertia.append(kmeans.inertia_)

plt.plot(range(1,11), inertia, marker='o')
plt.xlabel('Número de clusters')
plt.ylabel('Inercia')
plt.title('Método del Codo')
plt.show()

# Aplicar K-Means con k=3
kmeans = KMeans(n_clusters=3, random_state=42)
clientes['cluster'] = kmeans.fit_predict(clientes_scaled)

# Analizar clusters
cluster_stats = clientes.groupby('cluster').mean()
print(cluster_stats)

1. Inventario de Objetos

-- Consulta SQL para inventario en SQL Server
SELECT 
    t.name AS table_name,
    s.name AS schema_name,
    p.rows AS row_count,
    SUM(a.total_pages) * 8 AS total_space_kb
FROM sys.tables t
INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
INNER JOIN sys.partitions p ON t.object_id = p.object_id
INNER JOIN sys.allocation_units a ON p.partition_id = a.container_id
GROUP BY t.name, s.name, p.rows
ORDER BY total_space_kb DESC;

-- Documentar:
-- * 15 tablas dimensionales (~50GB)
-- * 3 procesos SSIS (ETL diario)
-- * 12 reportes Power BI
-- * 5 stored procedures analíticos

2. Diseño en Snowflake

-- Configuración de warehouses
CREATE WAREHOUSE analytics_wh
  WITH WAREHOUSE_SIZE = 'X-LARGE'
  AUTO_SUSPEND = 300
  AUTO_RESUME = TRUE;

-- Esquema dimensional en Snowflake
CREATE DATABASE analytics_prod;
CREATE SCHEMA dw;

-- Tabla de hechos (ejemplo)
CREATE TABLE fact_ventas (
    venta_id INTEGER,
    fecha_id DATE,
    producto_id INTEGER,
    cliente_id INTEGER,
    cantidad INTEGER,
    monto NUMBER(10,2),
    costo NUMBER(10,2),
    -- Particionamiento por fecha
    PARTITION BY (DATE_TRUNC('MONTH', fecha_id))
  CLUSTER BY (producto_id);

-- Tablas de dimensiones
CREATE TABLE dim_producto (
    producto_id INTEGER PRIMARY KEY,
    nombre VARCHAR(100),
    categoria VARCHAR(50),
    subcategoria VARCHAR(50),
    -- Snowflake permite semiestructurado
    atributos VARIANT
);

3. Scripts de Migración Automatizados

# Script Python para migración incremental
import snowflake.connector
import pyodbc
from tqdm import tqdm

def migrate_table(source_conn, target_conn, table_name, batch_size=10000):
    # Conexión origen
    source_cursor = source_conn.cursor()
    source_cursor.execute(f"SELECT * FROM {table_name}")
    
    # Conexión destino
    target_cursor = target_conn.cursor()
    
    # Obtener columnas
    columns = [column[0] for column in source_cursor.description]
    placeholders = ', '.join(['%s'] * len(columns))
    insert_sql = f"INSERT INTO {table_name} VALUES ({placeholders})"
    
    # Migración por lotes
    while True:
        batch = source_cursor.fetchmany(batch_size)
        if not batch:
            break
        target_cursor.executemany(insert_sql, batch)
    
    target_conn.commit()

# Configurar conexiones
source = pyodbc.connect(...) # SQL Server
target = snowflake.connector.connect(...)

# Migrar tablas
tables = ['dim_producto', 'dim_cliente', 'fact_ventas']
for table in tqdm(tables):
    migrate_table(source, target, table)

4. Plan de Validación y Corte