Connect Four - Juega contra IA CNN

¡Intenta conectar 4 fichas en línea antes que la IA!

Ambos niveles utilizan el modelo de ML, con diferentes configuraciones.

Estado del Juego

Tu turno

Fichas jugadas: 0

Tiempo de juego: 00:00

Acerca del Modelo de Machine Learning

Este juego utiliza una Red Neuronal Multicapa (MLP) entrenada con datos de partidas de Connect Four para predecir el mejor movimiento en cada situación.

Niveles de Dificultad
  • Normal: Utiliza el modelo con un 30% de aleatoriedad para hacerlo menos predecible.
  • Avanzado: Utiliza el modelo de forma pura para obtener sus mejores predicciones.
Estadísticas del Modelo

El modelo MLP fue entrenado con un conjunto de datos de 1 millon de partidas generadas con Negamax(4) y mas de 30 millones de jugadas.

Alcanzó una precisión del 85% en el conjunto de validación. 


from sklearn.model_selection import train_test_split
import numpy as np
np.bool = bool
np.object = object
np.int = int  

import tensorflow as tf
import pandas as pd

from tensorflow.keras import models
from tensorflow.keras import layers
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization, Activation
from tensorflow.keras.regularizers import l2


df = pd.read_csv("dataset_codificado.csv", index_col=0)

X = df.iloc[:, 0:42]  # Todas las celdas del tablero (cell_0 hasta cell_41)
y = df['column'] 

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_test, X_val, y_test, y_val = train_test_split(X_test, y_test, test_size=0.5)

y_train_prep = to_categorical(y_train)
y_test_prep = to_categorical(y_test)
y_val_prep = to_categorical(y_val)

network = Sequential([
    
    Dense(128, kernel_regularizer=l2(0.001), input_shape=(42,)),
    BatchNormalization(),
    Activation('relu'),
    Dropout(0.25),

    Dense(128, kernel_regularizer=l2(0.001)),
    BatchNormalization(),
    Activation('relu'),
    Dropout(0.25),
    
    Dense(64, kernel_regularizer=l2(0.001)),
    BatchNormalization(),
    Activation('relu'),
    Dropout(0.25),

    Dense(7, activation='softmax', kernel_regularizer=l2(0.001))
])

optimizer = Adam(learning_rate=0.0001)

network.compile(
    optimizer=optimizer,
    loss='categorical_crossentropy',
    metrics=['accuracy', 'Precision']
)

early_stop = EarlyStopping(
    monitor='val_loss',
    patience=5,
    restore_best_weights=True
)

checkpoint_cb = ModelCheckpoint(
    filepath='mejor_modelo.h5',      
    monitor='val_loss',              
    save_best_only=True,             
    save_weights_only=False,        
    mode='min',                      
    verbose=1
)

reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',      
    factor=0.5,              
    patience=5,              
    min_lr=1e-6,            
    verbose=1
)

history = network.fit(X_train, 
                      y_train_prep, 
                      epochs=100,  
                      batch_size=2048,    
                      callbacks=[early_stop,checkpoint_cb,reduce_lr],
                      validation_data=(X_val, y_val_prep))

test_loss, test_acc, test_prec = network.evaluate(X_test, y_test_prep)

import tensorflow as tf

# Cargar tu modelo entrenado
model = tf.keras.models.load_model('mejor_modelo.h5')

# Convertir a TFLite
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

# Guardar el modelo
with open('modelo_conecta4.tflite', 'wb') as f:
    f.write(tflite_model)