基于深度学习实现跌倒检测(附源码)

https://www.youtube.com/channel/UCzgkpehSWuFTQx9E8NkBqzw

import osimport cv2import numpy as npfrom ultralytics import YOLOdef extract_keypoints_from_video(video_path: str, model, sequence_length: int = 10, save: bool = False, output_path: str = 'keypoints.npy'):    num_keypoints = 17 * 2  # Número de keypoints (17 puntos * 2 coordenadas x, y)    if not os.path.exists(video_path):        raise FileNotFoundError(f'El archivo de video {video_path} no existe')    cap = cv2.VideoCapture(video_path)    keypoints_buffer = []    while True:        ret, frame = cap.read()        if not ret:            break  # Video terminado        results = model(frame)[0]        if len(results.keypoints.xy) > 0:            keypoints = results.keypoints.xy[0].numpy().flatten()            if keypoints.shape[0] != num_keypoints:                keypoints = np.pad(keypoints, (0, num_keypoints - keypoints.shape[0]))        else:            # Si no se detectan keypoints, usar ceros            keypoints = np.zeros(num_keypoints, dtype=np.float32)        keypoints_buffer.append(keypoints)    cap.release()    # Manejar casos donde el video es más corto o más largo que sequence_length    if len(keypoints_buffer) < sequence_length:        # Si el video es más corto, repetir el último frame hasta completar sequence_length        last_frame = keypoints_buffer[-1]        while len(keypoints_buffer) < sequence_length:            keypoints_buffer.append(last_frame)    elif len(keypoints_buffer) > sequence_length:        # Si el video es más largo, tomar solo los últimos sequence_length frames        keypoints_buffer = keypoints_buffer[-sequence_length:]    keypoints_buffer = np.array(keypoints_buffer, dtype=np.float32)    if save:        np.save(output_path, keypoints_buffer)        print(f'Guardado en {output_path}')    return keypoints_buffer

import torchimport torch.nn as nnclass FallDetectionGRU(nn.Module):    def __init__(self, input_size, hidden_size, num_layers, output_size, dropout_prob=0.5):        super(FallDetectionGRU, self).__init__()        self.hidden_size = hidden_size        self.num_layers = num_layers        # Capa GRU (en vez de LSTM)        self.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True, dropout=dropout_prob if num_layers > 1 else 0)        # Batch Normalization        self.bn = nn.BatchNorm1d(hidden_size)        # Capas fully connected adicionales        self.fc1 = nn.Linear(hidden_size, hidden_size // 2)        self.fc2 = nn.Linear(hidden_size // 2, hidden_size // 4)        self.fc3 = nn.Linear(hidden_size // 4, output_size)        # Dropout para regularización        self.dropout = nn.Dropout(dropout_prob)        # Funciones de activación        self.relu = nn.ReLU()        self.sigmoid = nn.Sigmoid()        # Inicialización de pesos        self._init_weights()    def _init_weights(self):        """Inicialización de pesos para mejorar la convergencia."""        for name, param in self.gru.named_parameters():            if 'weight_ih' in name or 'weight_hh' in name:                nn.init.xavier_uniform_(param.data)            elif 'bias' in name:                param.data.fill_(0)        for m in self.modules():            if isinstance(m, nn.Linear):                nn.init.kaiming_normal_(m.weight, mode='fan_in', nonlinearity='relu')                m.bias.data.fill_(0.01)    def forward(self, x):        # Inicializar estado oculto (sin c0)        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)        # Pasar a través de la GRU        out, _ = self.gru(x, h0)        # Tomar la salida del último paso de tiempo        out = out[:, -1, :]        # Batch Normalization        out = self.bn(out)        # Capas fully connected con activaciones y dropout        out = self.fc1(out)        out = self.relu(out)        out = self.dropout(out)        out = self.fc2(out)        out = self.relu(out)        out = self.dropout(out)        out = self.fc3(out)        # Aplicar sigmoide para obtener probabilidades        out = self.sigmoid(out)        return out

import torchimport torch.nn as nnimport torch.optim as optimdef train_model(model, train_loader, val_loader, num_epochs=200, learning_rate=0.0001,                 weight_decay=1e-4, patience=10, device="cuda" if torch.cuda.is_available() else "cpu"):    """    Entrena un modelo de detección de caídas usando GRU.    Args:        model (torch.nn.Module): Modelo a entrenar.        train_loader (DataLoader): DataLoader para los datos de entrenamiento.        val_loader (DataLoader): DataLoader para los datos de validación.        num_epochs (int): Número de épocas de entrenamiento.        learning_rate (float): Tasa de aprendizaje.        weight_decay (float): Parámetro de regularización L2.        patience (int): Número de épocas sin mejora antes de early stopping.        device (str): Dispositivo a usar ("cuda" o "cpu").    Returns:        model: Modelo entrenado.        history: Diccionario con métricas de entrenamiento y validación.    """    model.to(device)    criterion = nn.BCELoss()  # Binary Cross Entropy Loss    optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=weight_decay)    # Listas para almacenar métricas    history = {"train_loss": [], "val_loss": [], "train_acc": [], "val_acc": []}    best_val_loss = float("inf")    patience_counter = 0    best_model = None    for epoch in range(num_epochs):        model.train()        train_loss, correct, total = 0, 0, 0        for batch_X, batch_y in train_loader:            batch_X, batch_y = batch_X.to(device), batch_y.to(device)            optimizer.zero_grad()            outputs = model(batch_X).squeeze()            loss = criterion(outputs, batch_y)            loss.backward()            optimizer.step()            train_loss += loss.item()            predicted = (outputs >= 0.5).float()            correct += (predicted == batch_y).sum().item()            total += batch_y.size(0)        avg_train_loss = train_loss / len(train_loader)        train_accuracy = correct / total        history["train_loss"].append(avg_train_loss)        history["train_acc"].append(train_accuracy)        # Evaluación en validación        model.eval()        val_loss, correct, total = 0, 0, 0        with torch.no_grad():            for batch_X, batch_y in val_loader:                batch_X, batch_y = batch_X.to(device), batch_y.to(device)                outputs = model(batch_X).squeeze()                loss = criterion(outputs, batch_y)                val_loss += loss.item()                predicted = (outputs >= 0.5).float()                correct += (predicted == batch_y).sum().item()                total += batch_y.size(0)        avg_val_loss = val_loss / len(val_loader)        val_accuracy = correct / total        history["val_loss"].append(avg_val_loss)        history["val_acc"].append(val_accuracy)        # Guardar el mejor modelo        if avg_val_loss < best_val_loss:            best_val_loss = avg_val_loss            best_model = model.state_dict()            patience_counter = 0        else:            patience_counter += 1        # Early Stopping        if patience_counter >= patience:            print(f"⏹️ Early stopping en la época {epoch + 1}")            break        if (epoch + 1) % 5 == 0:            print(f'Epoch {epoch + 1}: '                  f'Train Loss: {avg_train_loss:.4f}, Train Acc: {train_accuracy:.4f} | '                  f'Val Loss: {avg_val_loss:.4f}, Val Acc: {val_accuracy:.4f}')    # Restaurar el mejor modelo    if best_model:        model.load_state_dict(best_model)        print("✔️ Modelo restaurado al mejor estado guardado.")    return model, history

from src.models import FallDetectionGRUfrom src.training import train_modelbatch_size = 8train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)model = FallDetectionGRU(    input_size=34,     hidden_size=64,     num_layers=2,     output_size=1,     dropout_prob=0.6)trained_model, history = train_model(    model,     train_loader,     val_loader,     num_epochs=300,    learning_rate=.0005,    weight_decay=1e-6,     patience=15)

https://github.com/Erik172/fall-detection-deep-learning?source=post_page-----2941db4c95a3---------------------------------------