Improved efficiency

Author: CPPavithra

model/train_model.py

@@ -1,6 +1,9 @@
 import pandas as pd
 from sklearn.ensemble import RandomForestClassifier
+from sklearn.preprocessing import StandardScaler
 from sklearn.model_selection import train_test_split
+import numpy as np
+from sklearn.model_selection import cross_val_score
 from sklearn.metrics import accuracy_score
 import pickle
 
@@ -15,6 +18,15 @@
 # Label Failures (1 if CPU > 90% or Memory > 80%)
 data['failure'] = (data['value_cpu'] > 0.9) | (data['value_mem'] > 80)
 
+# Get feature importances
+importances = model.feature_importances_
+feature_names = X.columns
+
+# Select only the most important features
+important_features = np.argsort(importances)[-10:]  # Keep top 10 features
+X_train = X_train.iloc[:, important_features]
+X_test = X_test.iloc[:, important_features]
+
 # Features & Labels
 X = data[['value_cpu', 'value_mem']]
 y = data['failure'].astype(int)
@@ -23,9 +35,24 @@
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
 # Train Model
-model = RandomForestClassifier(n_estimators=100, random_state=42)
+model = RandomForestClassifier(
+    n_estimators=200,   # Increase trees for stability
+    max_depth=10,       # Limit tree depth to reduce complexity
+    min_samples_split=10,  # Minimum samples required to split an internal node
+    min_samples_leaf=5,   # Minimum samples per leaf to prevent small splits
+    max_features="sqrt",  # Use sqrt of features to reduce correlation
+    random_state=42
+)
 model.fit(X_train, y_train)
 
+
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+cv_scores = cross_val_score(model, X_train, y_train, cv=5)
+print(f"✅ Cross-Validation Accuracy: {np.mean(cv_scores):.4f}")
+
 # Evaluate Model
 y_pred = model.predict(X_test)
 print("Accuracy:", accuracy_score(y_test, y_pred))

scripts/fetch_metrics.py

@@ -1,58 +1,39 @@
-import os
 import requests
 import pandas as pd
+import os
 from datetime import datetime
 
 PROMETHEUS_URL = "http://localhost:9090/api/v1/query"
 
-def fetch_metric(metric_query, metric_name):
-    """Fetch metrics from Prometheus with error handling."""
-    try:
-        response = requests.get(PROMETHEUS_URL, params={'query': metric_query}, timeout=5)
-        response.raise_for_status()  # Raise an error if request fails
-        data = response.json()
-
-        if 'data' not in data or 'result' not in data['data']:
-            print(f"⚠️ No data found for {metric_name}")
-            return pd.DataFrame(columns=['timestamp', metric_name])  # Empty DataFrame
-
-        results = []
-        for item in data['data']['result']:
-            try:
-                timestamp = datetime.utcfromtimestamp(float(item['value'][0])).strftime('%Y-%m-%d %H:%M:%S')
-                value = float(item['value'][1])
-                results.append({'timestamp': timestamp, metric_name: value})
-            except (ValueError, IndexError):
-                print(f"⚠️ Skipping invalid data point in {metric_name}: {item}")
-
-        return pd.DataFrame(results)
-
-    except requests.exceptions.RequestException as e:
-        print(f"❌ Error fetching {metric_name}: {e}")
-        return pd.DataFrame(columns=['timestamp', metric_name])
-
-# Ensure the 'data' directory exists
-output_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../data"))
-os.makedirs(output_dir, exist_ok=True)
-
-# Fetch Metrics with correct queries
-cpu_usage = fetch_metric('rate(container_cpu_usage_seconds_total[1m])', 'cpu_usage')  # CPU as rate
-memory_usage = fetch_metric('container_memory_usage_bytes', 'memory_usage')  # Memory in bytes
-
-# Convert Memory Usage to MB
-if not memory_usage.empty:
-    memory_usage['memory_usage'] = memory_usage['memory_usage'] / (1024 * 1024)  # Convert to MB
-
-# Save to CSV if data exists
-if not cpu_usage.empty:
-    cpu_usage.to_csv(os.path.join(output_dir, "cpu_usage.csv"), index=False)
-    print("✅ CPU usage saved to data/cpu_usage.csv")
-else:
-    print("⚠️ No CPU usage data to save.")
-
-if not memory_usage.empty:
-    memory_usage.to_csv(os.path.join(output_dir, "memory_usage.csv"), index=False)
-    print("✅ Memory usage saved to data/memory_usage.csv")
-else:
-    print("⚠️ No memory usage data to save.")
+# Define metrics to fetch
+METRICS = {
+    "cpu_usage": "container_cpu_usage_seconds_total",
+    "memory_usage": "container_memory_usage_bytes",
+    "disk_io": "node_disk_io_time_seconds_total",
+    "network_rx": "node_network_receive_bytes_total",
+    "network_tx": "node_network_transmit_bytes_total",
+}
+
+SAVE_DIR = "../data"
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+def fetch_metric(metric_name):
+    """Fetches a single metric from Prometheus and returns a DataFrame."""
+    response = requests.get(PROMETHEUS_URL, params={"query": metric_name})
+    data = response.json()
+
+    results = []
+    for item in data.get("data", {}).get("result", []):
+        timestamp = datetime.utcfromtimestamp(float(item["value"][0])).strftime("%Y-%m-%d %H:%M:%S")
+        value = float(item["value"][1])
+        results.append({"timestamp": timestamp, "value": value})
+
+    return pd.DataFrame(results)
+
+# Fetch all metrics
+for metric_key, query in METRICS.items():
+    df = fetch_metric(query)
+    save_path = os.path.join(SAVE_DIR, f"{metric_key}.csv")
+    df.to_csv(save_path, index=False)
+    print(f"✅ {metric_key} data saved to {save_path}")
 

scripts/train_model.py

@@ -1,63 +1,96 @@
 import pandas as pd
-from sklearn.model_selection import train_test_split
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.metrics import accuracy_score, classification_report
-import os
+import numpy as np
 import joblib
 import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import classification_report, confusion_matrix
+from imblearn.over_sampling import SMOTE
+from xgboost import XGBClassifier
+
+# Load dataset
+data = pd.read_csv("data/merged_data.csv")
 
-# Load Processed Data
-df = pd.read_csv("data/processed_metrics.csv")
+# Check if target column exists
+if "target" not in data.columns:
+    raise KeyError("❌ 'target' column not found in the dataset!")
 
-# Drop unnecessary columns
-df = df.drop(columns=["timestamp"], errors="ignore")  
+# Remove non-numeric columns and separate features/target
+X = data.drop(columns=["timestamp", "target"], errors="ignore")
+y = data["target"]
 
-# Ensure "failure" column exists
-if "failure" not in df.columns:
-    raise ValueError("Error: 'failure' column not found in processed_metrics.csv!")
+# Standardize features
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
 
-# Define Features (X) and Target (y)
-X = df.drop(columns=["failure"])  
-y = df["failure"]  
+# Handle class imbalance using SMOTE
+smote = SMOTE(random_state=42)
+X_resampled, y_resampled = smote.fit_resample(X_scaled, y)
 
-# Train-Test Split
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+# Split into train & test sets
+X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42)
+
+# Train model with class weighting
+
+model = XGBClassifier(
+    n_estimators=500,
+    max_depth=10,
+    learning_rate=0.01,
+    subsample=0.8,
+    colsample_bytree=0.8,
+    scale_pos_weight=1,
+    use_label_encoder=False,
+    eval_metric="logloss"
+)
 
-# Train a Random Forest Model
-model = RandomForestClassifier(n_estimators=100, random_state=42)
 model.fit(X_train, y_train)
 
 # Predictions
 y_pred = model.predict(X_test)
 
-# Model Evaluation
-accuracy = accuracy_score(y_test, y_pred)
-print(f"✅ Model Accuracy: {accuracy:.4f}")
-print("📊 Classification Report:\n", classification_report(y_test, y_pred))
+# Evaluate model
+train_acc = model.score(X_train, y_train)
+test_acc = model.score(X_test, y_test)
+cv_acc = np.mean(cross_val_score(model, X_resampled, y_resampled, cv=5))
 
-# Ensure models directory exists
-os.makedirs("models", exist_ok=True)
+# Confusion matrix
+cm = confusion_matrix(y_test, y_pred)
 
-# Save the Model
-joblib.dump(model, "models/failure_predictor.pkl")
-print("✅ Model saved as models/failure_predictor.pkl")
+# Feature importance
+feature_importances = model.feature_importances_
+sorted_indices = np.argsort(feature_importances)[::-1]
+top_features = X.columns[sorted_indices]
 
+# Print results
+print("\n📊 MODEL PERFORMANCE METRICS")
+print("────────────────────────────────")
+print(f"🏋️ Training Accuracy: {train_acc:.4f}")
+print(f"🛠️ Test Accuracy: {test_acc:.4f}")
+print(f"🎯 Cross-Validation Accuracy: {cv_acc:.4f}")
 
-# Get feature importance
-importances = model.feature_importances_
-features = X.columns
+# Print classification report
+print("\n📜 Classification Report:\n", classification_report(y_test, y_pred))
 
-# Plot
-plt.figure(figsize=(10,5))
-plt.barh(features, importances, color="skyblue")
-plt.xlabel("Importance Score")
-plt.ylabel("Feature Name")
-plt.title("Feature Importance in Failure Prediction Model")
-plt.show()
+# Print confusion matrix
+print("\n🖼️ Confusion Matrix:")
+print(cm)
+
+# Show top features
+print("\n🔍 Top 5 Most Important Features:")
+for i in range(min(5, len(top_features))):
+    print(f"   {i+1}. {top_features[i]} ({feature_importances[sorted_indices[i]]:.4f})")
 
-# Check training accuracy
-train_pred = model.predict(X_train)
-train_acc = accuracy_score(y_train, train_pred)
+# Save trained model
+joblib.dump(model, "models/failure_predictor.pkl")
+print("\n✅ Model saved successfully!")
+
+# Plot confusion matrix
+plt.figure(figsize=(6, 5))
+sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=["No Failure", "Failure"], yticklabels=["No Failure", "Failure"])
+plt.xlabel("Predicted")
+plt.ylabel("Actual")
+plt.title("Confusion Matrix")
+plt.show()
 
-print(f"🏋️ Training Accuracy: {train_acc:.2f}")
-print(f"🛠️ Test Accuracy: {accuracy_score(y_test, y_pred):.2f}")