Entraîner un modèle ML sans GPU local

import torch
import tensorflow as tf

# Vérifier le GPU PyTorch
print(f"PyTorch — GPU disponible : {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU : {torch.cuda.get_device_name(0)}")
    print(f"Mémoire GPU : {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

# Vérifier le GPU TensorFlow
gpus = tf.config.list_physical_devices('GPU')
print(f"TensorFlow — GPUs : {gpus}")

# Infos système
import subprocess
result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
print(result.stdout)

from google.colab import drive
import os

# Monter Google Drive (demande une autorisation)
drive.mount('/content/drive')

# Créer le dossier de travail sur Drive
PROJECT_DIR = '/content/drive/MyDrive/ML_Projects/classification_cifar10'
os.makedirs(PROJECT_DIR, exist_ok=True)

MODELS_DIR = f'{PROJECT_DIR}/models'
DATA_DIR = f'{PROJECT_DIR}/data'
os.makedirs(MODELS_DIR, exist_ok=True)
os.makedirs(DATA_DIR, exist_ok=True)

print(f"Projet : {PROJECT_DIR}")
print(f"Contenu : {os.listdir(PROJECT_DIR)}")

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# ── Données ──
(X_train, y_train), (X_test, y_test) = keras.datasets.cifar10.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0
y_train = keras.utils.to_categorical(y_train)
y_test = keras.utils.to_categorical(y_test)

# ── Modèle ──
def create_model():
    return keras.Sequential([
        keras.Input(shape=(32, 32, 3)),
        layers.RandomFlip('horizontal'),
        layers.RandomRotation(0.1),

        layers.Conv2D(32, 3, padding='same', activation='relu'),
        layers.BatchNormalization(),
        layers.Conv2D(32, 3, padding='same', activation='relu'),
        layers.BatchNormalization(),
        layers.MaxPooling2D(),
        layers.Dropout(0.3),

        layers.Conv2D(64, 3, padding='same', activation='relu'),
        layers.BatchNormalization(),
        layers.MaxPooling2D(),
        layers.Dropout(0.3),

        layers.GlobalAveragePooling2D(),
        layers.Dense(256, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(10, activation='softmax')
    ])

model = create_model()
model.compile(
    optimizer=keras.optimizers.Adam(0.001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)
model.summary()

import time

MODEL_PATH = f'{MODELS_DIR}/cifar10_best.keras'
CHECKPOINT_PATH = f'{MODELS_DIR}/cifar10_checkpoint.keras'

callbacks = [
    # Sauvegarder le meilleur modèle sur Drive
    keras.callbacks.ModelCheckpoint(
        MODEL_PATH,
        monitor='val_accuracy',
        save_best_only=True,
        verbose=1
    ),
    # Sauvegarder régulièrement chaque epoch (protection contre les déconnexions)
    keras.callbacks.ModelCheckpoint(
        CHECKPOINT_PATH,
        save_freq='epoch',
        verbose=0
    ),
    keras.callbacks.EarlyStopping(patience=15, restore_best_weights=True),
    keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=7, min_lr=1e-7),
]

start = time.time()
history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=128,
    validation_split=0.15,
    callbacks=callbacks,
    verbose=1
)
elapsed = time.time() - start

test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"\nEntraînement terminé en {elapsed/60:.1f} min")
print(f"Précision test : {test_acc*100:.2f}%")
print(f"Modèle sauvegardé sur Drive : {MODEL_PATH}")

import os

# Remonter Drive après déconnexion
from google.colab import drive
drive.mount('/content/drive')

# Charger le dernier checkpoint
if os.path.exists(CHECKPOINT_PATH):
    model = keras.models.load_model(CHECKPOINT_PATH)
    print(f"✅ Modèle chargé depuis : {CHECKPOINT_PATH}")

    # Reprendre l'entraînement à partir de là
    history2 = model.fit(
        X_train, y_train,
        epochs=50,
        initial_epoch=len(history.history['loss']),  # Reprendre au bon epoch
        batch_size=128,
        validation_split=0.15,
        callbacks=callbacks
    )
else:
    print("❌ Pas de checkpoint trouvé — relancer l'entraînement")

# ── Éviter la déconnexion automatique ──
# Colab se déconnecte après 90 min d'inactivité (pas de sortie de code)
# Solution : ouvrir la console JavaScript du navigateur et exécuter :
# function KeepAlive() { document.querySelector("colab-connect-button").click(); setTimeout(KeepAlive, 60000); } KeepAlive();

# ── Vérifier l'espace disque ──
import shutil
total, used, free = shutil.disk_usage("/")
print(f"Disque : {used/1e9:.1f}GB / {total/1e9:.1f}GB utilisés")

# ── Télécharger les fichiers générés ──
from google.colab import files
# Télécharger un modèle sur votre ordinateur
files.download('/content/mon_modele.pkl')

# ── Uploader des fichiers depuis votre ordinateur ──
uploaded = files.upload()  # Ouvre un sélecteur de fichiers
for name, data in uploaded.items():
    print(f"Fichier reçu : {name} ({len(data)} bytes)")

# ── Installer des packages ──
import subprocess
subprocess.run(['pip', 'install', 'transformers', 'datasets', '-q'])