دا مشروع Human Activity Recognition (HAR)
و المفروض اعمله في الموديل ادمج CNN +LSTM
الكود ال انا بعتهولك ده
عاوز اغيره و استخدم في cnn : RESnet
و انت شوف هتعمل اي للLSTM
```
!pip install opencv-python tensorflow numpy pandas matplotlib scikit-learn
import os
import cv2
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
from collections import Counter
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, TimeDistributed, LSTM, Dense, Dropout
from tensorflow.keras.utils import to_categorical
DATASET_PATH = "/kaggle/input/ucf101-action-recognition/train/"
all_actions = sorted(os.listdir(DATASET_PATH))
selected_actions = all_actions[:5] # Select only five classes
print("Selected Actions:", selected_actions)
SEQUENCE_LENGTH = 30
IMAGE_SIZE = 32
CHANNELS = 3
NUM_CLASSES = len(selected_actions)
# Video Processing Function
def process_video(file_path):
cap = cv2.VideoCapture(file_path)
frames = []
while len(frames) < SEQUENCE_LENGTH:
ret, frame = cap.read()
if not ret:
break
frame = cv2.resize(frame, (IMAGE_SIZE, IMAGE_SIZE)) / 255.0 # Resize and normalize
frames.append(frame)
cap.release()
return np.array(frames) if len(frames) == SEQUENCE_LENGTH else None
X, y = [], []
for i, action in enumerate(selected_actions):
action_path = os.path.join(DATASET_PATH, action)
for file in os.listdir(action_path):
video_data = process_video(os.path.join(action_path, file))
if video_data is not None:
X.append(video_data)
y.append(i)
X = np.array(X, dtype=np.float32)
y = to_categorical(y, num_classes=NUM_CLASSES)
print(f"Dataset Processed: {X.shape} video sequences loaded.")
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Model Definition
x = TimeDistributed(Conv2D(32, (3, 3), activation='relu'))(input_layer)
x = TimeDistributed(MaxPooling2D(pool_size=(2, 2)))(x)
x = TimeDistributed(Conv2D(64, (3, 3), activation='relu'))(x)
x = TimeDistributed(MaxPooling2D(pool_size=(2, 2)))(x)
x = TimeDistributed(Flatten())(x)
x = LSTM(64, return_sequences=True, activation='relu')(x)
x = Dropout(0.2)(x)
x = LSTM(64, return_sequences=False, activation='relu')(x)
x = Dropout(0.2)(x)
x = Dense(32, activation='relu')(x)
output_layer = Dense(NUM_CLASSES, activation='softmax')(x)
# Create Model
model = Model(inputs=input_layer, outputs=output_layer)
# Compile Model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
history = model.fit(X_train, y_train, epochs=10, batch_size=8, validation_data=(X_test, y_test))
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true_classes = np.argmax(y_test, axis=1)conf_matrix = confusion_matrix(y_true_classes, y_pred_classes)
num_classes = conf_matrix.shape[0]
for i in range(num_classes):
TP = conf_matrix[i, i] # Correct predictions for class i
FP = sum(conf_matrix[:, i]) - TP # Predicted as i but actually other classes
FN = sum(conf_matrix[i, :]) - TP # Actually class i but predicted as others
TN = conf_matrix.sum() - (TP + FP + FN) # Everything else
print(f"Class {selected_actions[i]}: TP={TP}, FP={FP}, FN={FN}, TN={TN}")
plt.figure(figsize=(6, 5))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=selected_actions, yticklabels=selected_actions)
plt.xlabel('Predicted Labels')
plt.ylabel('True Labels')
plt.title('Confusion Matrix')
plt.show()
# Classification Report
print("Classification Report:\n", classification_report(y_true_classes, y_pred_classes, target_names=selected_actions, zero_division=1))
misclassified_indices = np.where(y_pred_classes != y_true_classes)[0]
num_samples = min(10, len(misclassified_indices))
misclassified_samples = np.random.choice(misclassified_indices, num_samples, replace=False)
plt.figure(figsize=(10, 5))
for i, idx in enumerate(misclassified_samples):
plt.subplot(2, 5, i + 1)
plt.imshow(X_test[idx][0, :, :, 0], cmap='gray')
plt.title(f"True: {selected_actions[y_true_classes[idx]]}\nPred: {selected_actions[y_pred_classes[idx]]}")
plt.axis('off')
plt.tight_layout()
plt.show()
for idx in misclassified_samples[:5]:
print(f"True: {selected_actions[y_true_classes[idx]]}, Pred: {selected_actions[y_pred_classes[idx]]}")
print(f"Predicted Probabilities: {y_pred[idx]}\n")
error_counts = pd.Series(y_true_classes[misclassified_indices]).value_counts()
error_counts.index = [selected_actions[i] for i in error_counts.index]
plt.figure(figsize=(8, 5))
error_counts.sort_values().plot(kind='barh', color='red')
plt.xlabel("Number of Misclassifications")
plt.ylabel("Class")
plt.title("Class-wise Misclassification Count")
plt.show()
correct_predictions = Counter(y_true_classes[y_pred_classes == y_true_classes])
total_per_class = Counter(y_true_classes)
per_class_accuracy = {selected_actions[i]: (correct_predictions[i] / total_per_class[i]) * 100 for i in total_per_class}
plt.figure(figsize=(8, 5))
pd.Series(per_class_accuracy).sort_values().plot(kind='barh', color='green')
plt.xlabel("Accuracy (%)")
plt.ylabel("Class")
plt.title("Per-Class Accuracy")
plt.show()
```