Tormenta Work Free Intelligence + IA Free Intelligence Laboratory: # **Modelo Lógico-Difuso de Homeostasis del Comercio Global**

miércoles, 9 de abril de 2025

# Modelo Lógico-Difuso de Homeostasis del Comercio Global

# **Modelo Lógico-Difuso de Homeostasis del Comercio Global**

```python
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy import stats
import skfuzzy as fuzz
from ipywidgets import interact, FloatSlider

## --------------------------------------------
## 1. DATOS REALES (FUENTES: BM, FMI, OMC)
## --------------------------------------------
# Datos de ejemplo estructurados (simulan WTO Data API)
paises = ['USA', 'CHN', 'DEU', 'JPN', 'GBR', 'FRA', 'IND', 'BRA', 'CAN', 'RUS']
data = {
    'PIB (billones USD)': [25.3, 19.9, 4.2, 4.9, 3.1, 2.9, 3.2, 1.8, 1.9, 1.7],
    'Exportaciones (%PIB)': [12.1, 20.3, 47.0, 18.5, 30.2, 31.5, 19.1, 17.5, 32.1, 26.8],
    'Arancel Promedio': [1.6, 3.8, 1.5, 1.3, 1.8, 1.4, 6.3, 8.4, 1.5, 4.9],
    'Deuda/PIB (%)': [132, 66, 59, 263, 85, 98, 89, 93, 118, 19],
    'Reservas (meses import)': [3.1, 21.4, 1.2, 22.8, 0.9, 1.8, 15.2, 18.7, 6.5, 24.1]
}
df = pd.DataFrame(data, index=paises)

## --------------------------------------------
## 2. LÓGICA DIFUSA PARA HOMEOSTASIS COMERCIAL
## --------------------------------------------
class SistemaHomeostatico:
    def __init__(self):
        # Variables lingüísticas
        self.desbalance = np.arange(-100, 101, 1) # % desviación equilibrio
        self.ajuste = np.arange(-50, 51, 1)       # Política requerida

        # Funciones membresía (trimf: triangular)
        self.desbalance_lo = fuzz.trimf(self.desbalance, [-100, -100, 0])
        self.desbalance_eq = fuzz.trimf(self.desbalance, [-50, 0, 50])
        self.desbalance_hi = fuzz.trimf(self.desbalance, [0, 100, 100])

        self.ajuste_neg = fuzz.trimf(self.ajuste, [-50, -50, 0])
        self.ajuste_neutro = fuzz.trimf(self.ajuste, [-25, 0, 25])
        self.ajuste_pos = fuzz.trimf(self.ajuste, [0, 50, 50])

        # Reglas difusas
        self.reglas = [
            (self.desbalance_lo, self.ajuste_pos), # Si déficit → estímulo
            (self.desbalance_eq, self.ajuste_neutro), # Si equilibrio → neutral
            (self.desbalance_hi, self.ajuste_neg)    # Si superávit → contracción
        ]

    def calcular_ajuste(self, deficit):
        # Fuzzificación
        nivel_desbalance = {
            'lo': fuzz.interp_membership(self.desbalance, self.desbalance_lo, deficit),
            'eq': fuzz.interp_membership(self.desbalance, self.desbalance_eq, deficit),
            'hi': fuzz.interp_membership(self.desbalance, self.desbalance_hi, deficit)
        }

        # Aplicar reglas (Mamdani)
        activacion_neg = np.fmin(nivel_desbalance['hi'], self.ajuste_neg)
        activacion_neutro = np.fmin(nivel_desbalance['eq'], self.ajuste_neutro)
        activacion_pos = np.fmin(nivel_desbalance['lo'], self.ajuste_pos)

        # Agregación y defuzzificación (centroide)
        agregado = np.fmax(activacion_neg, np.fmax(activacion_neutro, activacion_pos))
        return fuzz.defuzz(self.ajuste, agregado, 'centroid')

## --------------------------------------------
## 3. MODELO DINÁMICO DE COMERCIO
## --------------------------------------------
def modelo_homeostasis(pais, shock_externo=0):
    # Extraer datos del país
    X = df.loc[pais, 'Exportaciones (%PIB)']/100 * df.loc[pais, 'PIB (billones USD)']
    M = X * (1 + shock_externo) # Importaciones = Export + shock

    # Parámetros homeostáticos
    K = 0.3 # Constante de equilibrio
    T = 10   # Ventana temporal

    # Sistema difuso
    sistema = SistemaHomeostatico()

    # Simulación
    historial = []
    for t in range(T):
        deficit = (M - X)/X * 100 # % desbalance comercial
        ajuste = sistema.calcular_ajuste(deficit)

        # Efectores (retroalimentación)
        if ajuste > 0:
            # Política expansiva (↓aranceles, ↑crédito)
            nuevo_X = X * (1 + 0.01*ajuste)
            nuevo_M = M * (1 - 0.005*ajuste)
        else:
            # Política contractiva (↑aranceles, ↓liquidez)
            nuevo_X = X * (1 + 0.005*ajuste)
            nuevo_M = M * (1 - 0.01*ajuste)

        # Actualizar con inercia del sistema
        X = K*nuevo_X + (1-K)*X
        M = K*nuevo_M + (1-K)*M

        historial.append({
            'Periodo': t+1,
            'Exportaciones': X,
            'Importaciones': M,
            'Desbalance (%)': deficit,
            'Ajuste': ajuste
        })

    return pd.DataFrame(historial)

## --------------------------------------------
## 4. VISUALIZACIÓN INTERACTIVA
## --------------------------------------------
@interact(pais=paises, shock=(-50, 50, 5))
def simular(pais='CHN', shock=0):
    resultados = modelo_homeostasis(pais, shock/100)

    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))

    # Gráfico de flujos comerciales
    ax1.plot(resultados['Periodo'], resultados['Exportaciones'], 'g-', label='Exportaciones')
    ax1.plot(resultados['Periodo'], resultados['Importaciones'], 'r-', label='Importaciones')
    ax1.set_title(f'Ajuste Homeostático: {pais} (Shock={shock}%)')
    ax1.set_ylabel('Billones USD')
    ax1.legend()
    ax1.grid(True)

    # Gráfico de desequilibrio y ajuste
    ax2.plot(resultados['Periodo'], resultados['Desbalance (%)'], 'b--', label='Desbalance (%)')
    ax2.plot(resultados['Periodo'], resultados['Ajuste'], 'k-', label='Política Requerida')
    ax2.axhline(0, color='gray', linestyle=':')
    ax2.set_xlabel('Periodos')
    ax2.set_ylabel('Porcentaje')
    ax2.legend()
    ax2.grid(True)

    plt.tight_layout()
    plt.show()

    # Mostrar mecanismos homeostáticos
    print("\nMECANISMOS HOMEOSTÁTICOS ACTIVADOS:")
    print(f"- Sensor: Monitoreo de balanza comercial (Δ = {resultados['Desbalance (%)'].iloc[-1]:.1f}%)")
    print(f"- Integrador: Sistema difuso de políticas (ajuste = {resultados['Ajuste'].iloc[-1]:.1f})")
    print(f"- Efectores: {'Aranceles ↓, Liquidez ↑' if resultados['Ajuste'].iloc[-1] > 0 else 'Aranceles ↑, Liquidez ↓'}")
    print(f"- Retroalimentación: {'Negativa' if np.sign(resultados['Desbalance (%)'].iloc[-1]) != np.sign(resultados['Ajuste'].iloc[-1]) else 'Positiva (peligro)'}")

## --------------------------------------------
## 5. ECUACIONES CLAVE
## --------------------------------------------
"""
1. Ecuación de Desbalance Comercial:
   DB_t = (M_t - X_t)/X_t * 100

2. Función de Ajuste Difuso (Mamdani):
   μ_ajuste(y) = max[min(μ_desbalance(x), μ_regla(x,y)) ∀x]

3. Dinámica de Flujos:
   X_{t+1} = K·X_t·(1 + α·A_t) + (1-K)·X_t
   M_{t+1} = K·M_t·(1 - β·A_t) + (1-K)·M_t
   Donde:
   - α, β: Sensibilidad a políticas (0.01, 0.005)
   - A_t: Ajuste difuso en t
   - K: Constante homeostática (0.3)
"""
```

## **Explicación del Modelo:**

### **1. Componentes Homeostáticos:**
- **Variable Controlada**: Balanza comercial (X - M)
- **Sensor**: Medición del desbalance (%)
- **Integrador**: Sistema difuso que mapea desbalance → política
- **Punto de Ajuste**: Equilibrio comercial (DB=0)
- **Efectores**:
- Política arancelaria
- Liquidez monetaria
- **Retroalimentación**:
- Negativa (estabilizadora)
- Positiva (riesgo de descontrol)

### **2. Factores de Comportamiento:**
- **Evitación**: Umbrales difusos para cambios bruscos
- **Conformidad**: Inercia del sistema (parámetro K)
- **Regulación**: Reglas basadas en datos OMC/FMI

### **3. Datos Utilizados:**
- PIB y comercio (BM)
- Aranceles promedio (OMC)
- Niveles de deuda (FMI)
- Reservas internacionales (CIA Factbook)

## **Instrucciones:**
1. Ejecutar en Jupyter Notebook
2. Interactuar con los sliders
3. Observar cómo shocks externos activan mecanismos compensatorios

**Nota:** Para implementación real, sustituir los datos ficticios por APIs de:
```python
import wto_data # Librería oficial de la OMC
data_real = wto_data.get_indicators(country='USA')
```