Upload 2 files

predict_model.py

@@ -0,0 +1,87 @@
+import pandas as pd
+import numpy as np
+import joblib
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Load saved model, encoder, and training columns
+model = joblib.load('random_forest_model.pkl')
+le = joblib.load('label_encoder.pkl')
+training_columns = joblib.load('training_columns.pkl')
+
+# Mapping helper
+def map_and_prepare_input_data(input_df):
+    from difflib import get_close_matches
+
+    column_aliases = {
+        "App Tech Stack": ["app tech stack", "technology stack", "application stack"],
+        "Operating System": ["os", "operating system", "platform"],
+        "DB Details": ["db info", "database", "database information", "db"],
+        "Authentication Model": ["auth model", "authentication", "authentication type"],
+        "Application Components": ["components", "app components", "application parts"],
+        "Licence Renewal": ["license", "license renewal", "renewal"],
+    }
+
+    reverse_aliases = {}
+    for std_col, aliases in column_aliases.items():
+        for alias in aliases:
+            reverse_aliases[alias.lower()] = std_col
+
+    mapping = {}
+    for col in input_df.columns:
+        col_lower = col.lower()
+        if col_lower in reverse_aliases:
+            mapping[col] = reverse_aliases[col_lower]
+        else:
+            match = get_close_matches(col_lower, reverse_aliases.keys(), n=1, cutoff=0.8)
+            if match:
+                mapping[col] = reverse_aliases[match[0]]
+
+    input_df_renamed = input_df.rename(columns=mapping)
+    input_df_filtered = input_df_renamed[[col for col in input_df_renamed.columns if col in list(column_aliases.keys())]]
+
+    missing_columns = set(list(column_aliases.keys())) - set(input_df_filtered.columns)
+    if missing_columns:
+        raise ValueError(f"Missing required columns: {missing_columns}")
+
+    return input_df_filtered
+
+# Load new input data
+try:
+    new_data = pd.read_csv('input.csv')
+except FileNotFoundError:
+    print("Error: 'input.csv' not found.")
+    exit()
+
+new_data = map_and_prepare_input_data(new_data)
+new_data.fillna('Unknown', inplace=True)
+
+# One-hot encode and align with training columns
+encoded_data = pd.get_dummies(new_data, columns=[
+    'App Tech Stack', 'Operating System', 'DB Details',
+    'Authentication Model', 'Application Components', 'Licence Renewal'
+])
+encoded_data = encoded_data.reindex(columns=training_columns, fill_value=0)
+
+# Predict
+predicted_labels_encoded = model.predict(encoded_data)
+predicted_labels = le.inverse_transform(predicted_labels_encoded)
+new_data['Predicted Modernization Strategy'] = predicted_labels
+
+# Save to CSV
+new_data.to_csv('output.csv', index=False)
+print("✅ Predictions saved to 'output.csv'")
+
+# Visualize
+counts = new_data['Predicted Modernization Strategy'].value_counts()
+plt.figure(figsize=(10, 6))
+counts.plot(kind='bar', color=['skyblue', 'lightgreen', 'salmon', 'plum', 'gold'])
+plt.title('Distribution of Predicted Modernization Strategies')
+plt.ylabel('Count')
+plt.xticks(rotation=45, ha='right')
+plt.tight_layout()
+plt.show()
+
+print("\n Count of Predicted Modernization Strategies:")
+for strategy, count in counts.items():
+    print(f"{strategy}: {count}")

train_model.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import numpy as np
+import joblib
+from sklearn.preprocessing import LabelEncoder
+from sklearn.model_selection import train_test_split, RandomizedSearchCV
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.ensemble import GradientBoostingClassifier
+import xgboost as xgb
+from scipy.stats import randint, uniform
+
+# Load dataset
+try:
+    df = pd.read_csv('Dataset.csv')
+except FileNotFoundError:
+    print("Error: 'Dataset.csv' not found.")
+    exit()
+
+# Fill missing values
+df.fillna('Unknown', inplace=True)
+
+# Encode categorical features
+df_encoded = pd.get_dummies(df, columns=[
+    'App Tech Stack', 'Operating System', 'DB Details',
+    'Authentication Model', 'Application Components', 'Licence Renewal'
+], dummy_na=False)
+
+# Encode target
+le = LabelEncoder()
+y_encoded = le.fit_transform(df_encoded['Modernization Strategy'])
+X = df_encoded.drop(columns=['Modernization Strategy'])
+
+# Train-validation-test split
+X_train, X_temp, y_train, y_temp = train_test_split(X, y_encoded, test_size=0.2, stratify=y_encoded, random_state=42)
+X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
+
+# Models
+models = {
+    'RandomForest': RandomForestClassifier(random_state=42),
+    'LogisticRegression': LogisticRegression(random_state=42, max_iter=1000),
+    'SVM': SVC(random_state=42),
+    'GradientBoosting': GradientBoostingClassifier(random_state=42),
+    'XGBoost': xgb.XGBClassifier(random_state=42, use_label_encoder=False, eval_metric='logloss')
+}
+
+# Hyperparameters
+param_grids = {
+    'RandomForest': {'n_estimators': randint(50, 200), 'max_depth': randint(10, 50),
+                     'min_samples_split': randint(2, 10), 'min_samples_leaf': randint(1, 5)},
+    'LogisticRegression': {'C': uniform(0.1, 10)},
+    'SVM': {'C': uniform(0.1, 10), 'kernel': ['linear', 'rbf', 'poly']},
+    'GradientBoosting': {'n_estimators': randint(50, 200), 'learning_rate': uniform(0.01, 0.3),
+                         'max_depth': randint(3, 10)},
+    'XGBoost': {'n_estimators': randint(50, 200), 'learning_rate': uniform(0.01, 0.3),
+                'max_depth': randint(3, 10), 'subsample': uniform(0.5, 0.5), 'colsample_bytree': uniform(0.5, 0.5)}
+}
+
+# Randomized search and select best models
+best_models = {}
+for name in models:
+    print(f"Tuning {name}...")
+    search = RandomizedSearchCV(models[name], param_grids[name], n_iter=30, cv=5,
+                                scoring='accuracy', n_jobs=-1, random_state=42)
+    search.fit(X_val, y_val)
+    best_models[name] = search.best_estimator_
+    print(f"Best score for {name}: {search.best_score_:.4f}")
+
+# Save the best RandomForest model and encoder
+joblib.dump(best_models['RandomForest'], 'random_forest_model.pkl')
+joblib.dump(le, 'label_encoder.pkl')
+joblib.dump(X.columns.tolist(), 'training_columns.pkl')
+
+print("\n✅ Model and encoders saved successfully.")