# Importar bibliotecas necesarias.
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt

# Sección 1: Creación de un Grafo Simple

# Crear un grafo no dirigido y añadir nodos y aristas
G = nx.Graph()
G.add_nodes_from(["A", "B", "C", "D"])
G.add_edges_from([
    ("A", "B"), # Arista A <-> B
    ("B", "C"), # Arista B <-> C
    ("C", "D")  # Arista C <-> D
])

# Mostrar detalles del grafo
print("Nodos:", G.nodes)
print("Aristas:", G.edges)

# Visualización del grafo
nx.draw(
    G,
    with_labels=True,
    node_color='lightblue',
    edge_color='gray'
)
plt.show()

Nodos: ['A', 'B', 'C', 'D']
Aristas: [('A', 'B'), ('B', 'C'), ('C', 'D')]

# Sección 2: Crear un grafo desde una matriz de incidencia

# Crear una matriz de incidencia
inc_matrix = np.array([[0, 1, 1, 0],
                       [1, 0, 1, 0],
                       [1, 1, 0, 1],
                       [0, 0, 1, 0]])

# Crear un grafo desde la matriz de incidencia
G_from_matrix = nx.from_numpy_array(inc_matrix)

# Mostrar nodos y aristas
print("Nodos del grafo desde matriz:", G_from_matrix.nodes)
print("Aristas del grafo desde matriz:", G_from_matrix.edges)

# Visualización del grafo creado desde la matriz de incidencia
nx.draw(G_from_matrix, with_labels=True, node_color='lightblue', edge_color='gray')
plt.show()

Nodos del grafo desde matriz: [0, 1, 2, 3]
Aristas del grafo desde matriz: [(0, 1), (0, 2), (1, 2), (2, 3)]

# Sección 3: Crear un grafo ponderado desde una matriz de adyacencia

# Crear una matriz de adyacencia
adj_matrix_weighted = np.array([[0, 2, 0, 0],
                                [2, 0, 3, 0],
                                [0, 3, 0, 4],
                                [0, 0, 4, 0]])

# Crear un grafo ponderado
G_weighted = nx.from_numpy_array(adj_matrix_weighted)

# Mostrar aristas con sus pesos
print("Aristas con peso:", G_weighted.edges(data=True))

# Visualización del grafo ponderado
pos = nx.spring_layout(G_weighted, seed=123)
nx.draw(
    G_weighted,
    pos,
    with_labels=True,
    node_color='lightblue',
    edge_color='gray'
)

# Agregamos etiquetas a las aristas
labels = nx.get_edge_attributes(G_weighted, "weight")
nx.draw_networkx_edge_labels(G_weighted, pos, edge_labels=labels);

plt.show()

Aristas con peso: [(0, 1, {'weight': 2}), (1, 2, {'weight': 3}), (2, 3, {'weight': 4})]

# Sección 4: Crear un grafo dirigido desde una matriz de incidencia

# Crear una matriz de incidencia para un grafo dirigido
adj_matrix_directed = np.array([[0, 1, 0, 0],
                                [0, 0, 1, 0],
                                [0, 0, 0, 1],
                                [0, 0, 0, 0]])

# Crear un grafo dirigido
G_directed = nx.from_numpy_array(adj_matrix_directed, create_using=nx.DiGraph)

# Mostrar aristas dirigidas
print("Aristas dirigidas:", G_directed.edges)

# Visualización del grafo dirigido
nx.draw(
    G_directed,
    with_labels=True,
    node_color='lightblue',
    edge_color='gray',
    arrows=True
)
plt.show()

Aristas dirigidas: [(0, 1), (1, 2), (2, 3)]

# Sección 5: Propiedades de los Grafos

# Grado de un nodo
degree = G.degree("A")
print("Grado del nodo 'A':", degree)

# Conectividad (comprobamos si el grafo es conexo)
is_connected = nx.is_connected(G)
print("¿El grafo es conexo?", is_connected)

# Componentes conexas
components = list(nx.connected_components(G))
print("Componentes conexas:", components)

Grado del nodo 'A': 1
¿El grafo es conexo? True
Componentes conexas: [{'B', 'A', 'D', 'C'}]

# Sección 6: Algoritmo de Dijkstra

# Grafo ponderado para Dijkstra
G_weighted.add_edge("A", "D", weight=5)
G_weighted.add_edge("B", "D", weight=3)

# Encontrar el camino más corto usando el algoritmo de Dijkstra
shortest_path = nx.shortest_path(G_weighted, source="A", target="D", weight="weight")
print("Camino más corto de A a D:", shortest_path)

Camino más corto de A a D: ['A', 'D']

# Sección 7: Flujo Máximo

# Crear un grafo de flujo con capacidades
G_flow = nx.DiGraph()
G_flow.add_edge("A", "B", capacity=4)
G_flow.add_edge("A", "C", capacity=5)
G_flow.add_edge("B", "C", capacity=3)
G_flow.add_edge("B", "D", capacity=2)
G_flow.add_edge("C", "D", capacity=3)

# Calcular el flujo máximo entre A y D
flow_value, flow_dict = nx.maximum_flow(G_flow, "A", "D")
print("Flujo máximo de A a D:", flow_value)
print("Distribución del flujo:", flow_dict)

Flujo máximo de A a D: 5
Distribución del flujo: {'A': {'B': 4, 'C': 1}, 'B': {'C': 2, 'D': 2}, 'C': {'D': 3}, 'D': {}}

# Crear una matriz de adyacencia
adj_matrix = np.array([[0, 1, 1, 0],
                       [1, 0, 1, 0],
                       [1, 1, 0, 1],
                       [0, 0, 1, 0]])

# Crear un grafo desde la matriz de adyacencia
G_from_matrix = nx.from_numpy_array(adj_matrix)
pos_G = nx.spring_layout(G_from_matrix, seed=123)

# Aplicamos remapeo de etiquetas
mapping = {0: "A", 1: "B", 2: "C", 3: "D"}
H = nx.relabel_nodes(G_from_matrix, mapping)
pos_H = nx.spring_layout(H, seed=123)

# Graficamos G
nx.draw(
    G_from_matrix,
    pos_G,
    with_labels=True,
    node_color="tomato",
    edge_color="gray"
)

# Graficamos H
nx.draw(
    H,
    pos_H,
    with_labels=True,
    node_color="tomato",
    edge_color="gray"
)

from pprint import pprint

# Se puede obtener una representaicón plana
pos = nx.planar_layout(H)
print("Diccionario de posiciones:")
pprint(pos)

# Desplegamos representación plana con posiciones dadas
nx.draw(H, pos)

Diccionario de posiciones:
{'A': array([-1.        , -0.33333333]),
 'B': array([ 0.77777778, -0.33333333]),
 'C': array([0.33333333, 0.11111111]),
 'D': array([-0.11111111,  0.55555556])}

# Con la estructura anterior se pueden especificar
# las posiciones (x, y) de los nodos en un grafo

# Crear una matriz de adyacencia
adj_matrix = np.array([
    [0, 6, 4, 0, 0, 0],
    [6, 0, 2, 2, 0, 0],
    [4, 2, 0, 1, 2, 0],
    [0, 2, 1, 0, 1, 7],
    [0, 0, 2, 1, 0, 3],
    [0, 0, 0, 7, 3, 0]
])

# Crear un grafo desde la matriz de adyacencia
G = nx.from_numpy_array(adj_matrix)

# Aplicamos remapeo de etiquetas
mapping = {item: item + 1 for item in range(7)}
G = nx.relabel_nodes(G, mapping)

# Desplegamos G antes del repocisionamiento
nx.draw(G, with_labels=True, node_color="tomato", edge_color="gray")

# Ajustamos posiciones
pos = {
    1: np.array([-1.5, 0.5]),
    2: np.array([ 0.0, 0.0]),
    3: np.array([ 0.0, 1.0]),
    4: np.array([ 3.0, 0.0]),
    5: np.array([ 3.0, 1.0]),
    6: np.array([ 4.5, 0.5]),
}

# Desplegamos G con posiciones
plt.figure(figsize=(3, 2), dpi=300)
nx.draw(G, pos, with_labels=True, node_color="lightgreen", edge_color="gray")

# Agregamos etiquetas a las aristas
labels = nx.get_edge_attributes(G, "weight")
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels);

Rodolfo Ferro

Munchkin Level Tracker

Modelando estrategias de mill en Commander mediante simulación de Montecarlo (parte II)

Planteando el experimento para simular múltiples veces

SOBRE EL USO DE INFORMACIÓN TOTAL O PARCIAL: 🔐

Modelando estrategias de mill en Commander mediante simulación de Montecarlo (parte I)

Motivación

El caso base: Altar of the Brood + Zellix en campo

¿Qué es una simulación de Montecarlo?

SPOILER:

Referencias

SOBRE EL USO DE INFORMACIÓN TOTAL O PARCIAL: 🔐

Calculadora de tierras: Un enfoque probabilístico en MTG

🎛️ Calculadora de probabilidades

¿Cómo usar la calculadora?

🌀 Resultados

Exactamente 3 tierras

Mano jugable (2-4 tierras)

Mana screw (≤1 tierras)

Mana flood (≥5 tierras)

📊 Tabla de probabilidades

Me quedo… ¿O no? (Introducción)

Un experimento aleatorio bien definido

El modelo ideal para robo de tierras

“Probabilidad” es diferente de resultados en un experimento

La distribución hipergeométrica

El caso de commander

¿Qué probabilidades nos interesan realmente?

Interpretación de resultados (más allá de los números)

Conclusiones

SOBRE EL USO DE INFORMACIÓN TOTAL O PARCIAL: 🔐

[Taller práctico] Introducción a las neuronas artificiales

👾 Neuronas artificiales: idea general, perceptrón

Modelo del perceptrón (neurona artificial)

Slides

SOBRE EL USO DE INFORMACIÓN TOTAL O PARCIAL: 🔐

[Curso Intensivo] Fundamentos de la Inteligencia Artificial

Módulo 1. Introducción a la Inteligencia Artificial

¿Qué es Inteligencia Artificial (IA)? Definiciones y mitos comunes

Ejemplos de tareas típicas de IA

Definiciones clásicas de IA

Mitos comunes sobre IA

Historia y evolución de la Inteligencia Artificial

Paradigmas de la IA

Paradigma simbólico (IA clásica)

Paradigma conexionista (aprendizaje basado en datos)

Paradigma evolutivo

Paradigma híbrido

Diferencia entre IA débil y fuerte

IA Débil (Narrow AI)

IA Fuerte (General AI)

Módulo 2. Representación de problemas y búsqueda

Agentes inteligentes y concepto de problema de búsqueda

Agente inteligente

Problema de búsqueda

Espacios de estados y estrategias básicas de búsqueda

Búsqueda en anchura (Breadth-First Search, BFS)

Búsqueda en profundidad (Depth-First Search, DFS)

Búsqueda heurística: glotones/voraces y A$^*$

Búsqueda Greedy (glotona o voraz)

Búsqueda A$^*$ (A estrella)

Juegos y toma de decisiones simples

Modelo de juegos

Algoritmo Minimax

Poda alfa-beta

Módulo 3. Introducción al Aprendizaje Automático

Paradigma basado en datos

Definición general

Formalización básica

Redes neuronales artificiales: idea general, perceptrón

Modelo del perceptrón (neurona artificial)

Concepto de aprendizaje supervisado y no supervisado

Aprendizaje supervisado

Aprendizaje no supervisado

Módulo 4. Aplicaciones y perspectivas de la IA

Aplicaciones principales de la IA

Procesamiento de Lenguaje Natural (PLN)

Visión Artificial

Robótica

Sistemas Expertos