import tensorflow as tf
import numpy as np

# ── Escalares, vectores, matrices, tensores ─────────────
escalar = tf.constant(7)
vector  = tf.constant([1.0, 2.0, 3.0])
matriz  = tf.constant([[1, 2], [3, 4]])
tensor  = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

for name, t in [('Escalar', escalar), ('Vector', vector), ('Matriz', matriz), ('Tensor 3D', tensor)]:
    print(f"{name:10s} | shape: {str(t.shape):12s} | dtype: {t.dtype.name:8s} | rango: {len(t.shape)}")

# ── Tensores especiales ─────────────────────────────────
print(f"\ntf.zeros((2,3)):\n{tf.zeros((2,3)).numpy()}")
print(f"\ntf.ones((2,3)):\n{tf.ones((2,3)).numpy()}")
print(f"\ntf.random.uniform((2,3)):\n{tf.random.uniform((2,3)).numpy().round(3)}")

# ── Operaciones con tensores ──────────────────────────────
a = tf.constant([1, 2, 3])
b = tf.constant([4, 5, 6])

print(f"a = {a.numpy()}")
print(f"b = {b.numpy()}")

# Suma elemento a elemento
print(f"\nSuma (a + b):           {tf.add(a, b).numpy()}")

# Multiplicación elemento a elemento
print(f"Producto Hadamard (a*b): {tf.multiply(a, b).numpy()}")

# Producto matricial
M1 = tf.constant([[1, 2], [3, 4]])
M2 = tf.constant([[5, 6], [7, 8]])
print(f"\nProducto matricial M1 @ M2:")
print(tf.matmul(M1, M2).numpy())

# Producto escalar
dot = tf.tensordot(tf.constant([1., 2., 3., 4.]), tf.constant([5., 6., 7., 8.]), axes=1)
print(f"\nProducto escalar: {dot.numpy()}")

# ── GradientTape ─────────────────────────────────────────
x = tf.Variable(3.0)

# Ejemplo 1: y = x²  →  dy/dx = 2x = 6.0
with tf.GradientTape() as tape:
    y = x ** 2
grad = tape.gradient(y, x)
print(f"y = x² en x=3.0")
print(f"dy/dx = 2x = {grad.numpy()}")

# Ejemplo 2: función más compleja  y = x³ + 2x² - 5x + 3
with tf.GradientTape() as tape:
    y = x**3 + 2*x**2 - 5*x + 3
grad = tape.gradient(y, x)
print(f"\ny = x³ + 2x² - 5x + 3 en x=3.0")
print(f"dy/dx = 3x² + 4x - 5 = {grad.numpy()}  (esperado: 34.0)")

# ── Regresión lineal con GradientTape ────────────────────
np.random.seed(42)

# Datos: y = 2x + 1 + ruido
X = np.linspace(0, 10, 100).astype(np.float32)
Y = (2 * X + 1 + np.random.randn(100).astype(np.float32) * 0.5)

X = tf.constant(X)
Y = tf.constant(Y)

# Parámetros a aprender
W = tf.Variable(tf.random.normal([1]))
b = tf.Variable(tf.random.normal([1]))

lr = 0.01
for epoch in range(100):
    with tf.GradientTape() as tape:
        Y_pred = W * X + b
        loss = tf.reduce_mean(tf.square(Y - Y_pred))
    
    grads = tape.gradient(loss, [W, b])
    W.assign_sub(lr * grads[0])
    b.assign_sub(lr * grads[1])
    
    if (epoch + 1) % 20 == 0:
        print(f"Epoch {epoch+1:>3}: loss={loss.numpy():.4f}, W={W.numpy()[0]:.3f}, b={b.numpy()[0]:.3f}")

print(f"\n✅ Modelo final: y = {W.numpy()[0]:.3f}·x + {b.numpy()[0]:.3f}  (real: y = 2x + 1)")

# ── Regresión con Keras ───────────────────────────────────
X_np = np.linspace(0, 10, 100)
Y_np = 2 * X_np + 1 + np.random.randn(100) * 0.5

model = tf.keras.Sequential([
    tf.keras.layers.Dense(1, input_shape=(1,))
])
model.compile(optimizer='sgd', loss='mse')

# Entrenar (verbose=0 para no llenar la salida)
model.fit(X_np, Y_np, epochs=100, verbose=0)

W_k, b_k = model.layers[0].get_weights()
print(f"Modelo Keras: y = {W_k[0][0]:.3f}·x + {b_k[0]:.3f}  (real: y = 2x + 1)")

import matplotlib.pyplot as plt

# ── Cargar MNIST ──────────────────────────────────────────
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0  # Normalizar [0, 1]

print(f"Train: {X_train.shape} | Test: {X_test.shape}")

# Visualizar ejemplos
fig, axes = plt.subplots(2, 5, figsize=(12, 5))
for i, ax in enumerate(axes.flat):
    ax.imshow(X_train[i], cmap='gray')
    ax.set_title(f"Label: {y_train[i]}")
    ax.axis('off')
plt.suptitle('Ejemplos de MNIST', fontsize=14)
plt.tight_layout()
plt.show()

# ── Modelo MLP ────────────────────────────────────────────
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Entrenar
model.fit(X_train, y_train, epochs=5, batch_size=64)

# Evaluar
loss, acc = model.evaluate(X_test, y_test, verbose=0)
print(f"\n✅ Test accuracy: {acc*100:.1f}%")

# ── Verificar GPU ────────────────────────────────────────
gpus = tf.config.list_physical_devices('GPU')
print(f"GPUs disponibles: {len(gpus)}")
for gpu in gpus:
    print(f"  {gpu.name}")

# Operación en GPU (si disponible)
device = '/GPU:0' if gpus else '/CPU:0'
with tf.device(device):
    A = tf.random.uniform([1000, 1000])
    B = tf.random.uniform([1000, 1000])
    C = tf.matmul(A, B)

print(f"\nMultiplicación 1000×1000 ejecutada en {device}")
print(f"Resultado shape: {C.shape}")