ecobertx 1.0__tar.gz

ecobertx-1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: ecobertx
+Version: 1.0
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: shap
+Requires-Dist: matplotlib
+Dynamic: requires-dist

ecobertx-1.0/ecobertX/cli.py

@@ -0,0 +1,18 @@
+import argparse
+from ecobertx.pipeline import run_ecobertx
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="EcoBERT-X CO2 Optimization Tool"
+    )
+
+    parser.add_argument(
+        "--input",
+        required=True,
+        help="Path to input CSV file"
+    )
+
+    args = parser.parse_args()
+
+    run_ecobertx(args.input)

ecobertx-1.0/ecobertX/explain/causal_reasoning.py

@@ -0,0 +1,42 @@
+def generate_causal_reason(feature, value, impact):
+
+    direction = "increased" if impact > 0 else "reduced"
+
+    explanations = {
+
+        "batch_size":
+        f"Batch size of {value} {direction} CO₂ because batch size directly controls GPU memory usage and parallel compute load. Smaller batch sizes require fewer GPU operations, reducing energy consumption.",
+
+        "max_sequence_length":
+        f"Sequence length of {value} {direction} CO₂ because longer sequences increase transformer attention computation complexity O(n²), increasing GPU energy usage.",
+
+        "log_model_parameters":
+        f"Model parameter scale {value} {direction} CO₂ because larger models require more matrix multiplications and GPU compute.",
+
+        "compute_log":
+        f"Compute workload level {value} {direction} CO₂ because compute intensity directly correlates with GPU power draw.",
+
+        "dataset_name":
+        f"Dataset '{value}' {direction} CO₂ due to differences in training complexity and convergence efficiency.",
+
+        "total_tokens":
+        f"Token count {value} {direction} CO₂ because more tokens require more forward and backward passes.",
+
+        "model_name":
+        f"Model architecture '{value}' {direction} CO₂ due to differences in computational efficiency.",
+
+        "num_epochs":
+        f"Training epochs {value} {direction} CO₂ because more epochs require repeated training cycles.",
+
+        "learning_rate":
+        f"Learning rate {value} {direction} CO₂ because inefficient learning rates increase training duration.",
+
+        "fp16":
+        f"FP16 precision {direction} CO₂ because lower precision reduces compute and memory load."
+
+    }
+
+    if feature in explanations:
+        return explanations[feature]
+
+    return f"{feature} {direction} CO₂ due to its influence on compute workload."

ecobertx-1.0/ecobertX/explain/dual_interpreter.py

@@ -0,0 +1,29 @@
+from explain.causal_reasoning import generate_causal_reason
+
+
+def interpret_prediction_full(raw_row, explainer):
+
+    pred = explainer.predict(raw_row)
+
+    explanation = explainer.explain_prediction_detailed(raw_row)
+
+    confidence = explainer.confidence_score(raw_row)
+
+    print("\n===================================")
+    print("EcoBERT-X MECHANISTIC EXPLANATION")
+    print("===================================\n")
+
+    print(f"Predicted CO₂: {pred:.6f} kg")
+    print(f"Confidence Score: {confidence:.3f}\n")
+
+    print("Causal Explanation:\n")
+
+    for e in explanation[:10]:
+
+        reason = generate_causal_reason(
+            e["feature"],
+            e["value"],
+            e["impact"]
+        )
+
+        print("•", reason)

ecobertx-1.0/ecobertX/explain/predict_explain.py

@@ -0,0 +1,211 @@
+import joblib
+import shap
+import pandas as pd
+import numpy as np
+import os
+
+
+class PredictionExplainer:
+
+    def __init__(self, project_root):
+
+        print("EcoBERT-X Prediction Explainer initialized.")
+
+        self.models_path = os.path.join(project_root, "models")
+
+        # Load trained model
+        self.model = joblib.load(
+            os.path.join(self.models_path, "best_model.joblib")
+        )
+
+        # Load preprocessor
+        self.preprocessor = joblib.load(
+            os.path.join(self.models_path, "preprocessor.joblib")
+        )
+
+        # Load training data sample as SHAP background
+        try:
+            background = joblib.load(
+                os.path.join(self.models_path, "X_background.joblib")
+            )
+        except:
+            background = None
+
+        # Create SHAP explainer safely
+        if background is not None:
+            background_transformed = self.preprocessor.transform(background)
+            self.explainer = shap.TreeExplainer(
+                self.model,
+                data=background_transformed,
+                feature_perturbation="interventional"
+            )
+        else:
+            self.explainer = shap.TreeExplainer(
+                self.model,
+                feature_perturbation="auto"
+            )
+
+        # Load target normalization
+        self.y_mean = np.load(
+            os.path.join(self.models_path, "target_mean.npy")
+        )
+
+        self.y_std = np.load(
+            os.path.join(self.models_path, "target_std.npy")
+        )
+
+
+    # ---------------------------------------
+    # CLEAN INPUT
+    # ---------------------------------------
+
+    def clean_row(self, raw_row):
+
+        row = raw_row.copy()
+
+        row = row.drop(
+            labels=[
+                c for c in row.index
+                if "Unnamed" in str(c)
+            ],
+            errors="ignore"
+        )
+
+        return row
+
+
+    # ---------------------------------------
+    # SAFE SHAP VALUES
+    # ---------------------------------------
+
+    def get_shap_values(self, X):
+
+        return self.explainer.shap_values(
+            X,
+            check_additivity=False
+        )[0]
+
+
+    # ---------------------------------------
+    # PREDICT CO2
+    # ---------------------------------------
+
+    def predict(self, raw_row):
+
+        row = self.clean_row(raw_row)
+
+        X = self.preprocessor.transform(
+            pd.DataFrame([row])
+        )
+
+        pred_norm = self.model.predict(X)[0]
+
+        pred_log = pred_norm * self.y_std + self.y_mean
+
+        pred = np.expm1(pred_log)
+
+        return float(max(pred, 0))
+
+
+    # ---------------------------------------
+    # DETAILED EXPLANATION
+    # ---------------------------------------
+
+    def explain_prediction_detailed(self, raw_row):
+
+        row = self.clean_row(raw_row)
+
+        X = self.preprocessor.transform(
+            pd.DataFrame([row])
+        )
+
+        shap_vals = self.get_shap_values(X)
+
+        explanation = []
+
+        for feature, shap_val in zip(row.index, shap_vals):
+
+            val = row[feature]
+
+            # Handle numeric and categorical safely
+            try:
+                val = float(val)
+            except:
+                val = str(val)
+
+            explanation.append({
+
+                "feature": feature,
+
+                "value": val,
+
+                "impact": float(shap_val),
+
+                "effect":
+                    "increase"
+                    if shap_val > 0
+                    else "decrease",
+
+                "importance": abs(float(shap_val))
+
+            })
+
+        explanation.sort(
+            key=lambda x: x["importance"],
+            reverse=True
+        )
+
+        return explanation
+
+
+    # ---------------------------------------
+    # CONFIDENCE SCORE
+    # ---------------------------------------
+
+    def confidence_score(self, raw_row):
+
+        row = self.clean_row(raw_row)
+
+        X = self.preprocessor.transform(
+            pd.DataFrame([row])
+        )
+
+        shap_vals = self.get_shap_values(X)
+
+        score = np.mean(np.abs(shap_vals))
+
+        confidence = score / (score + 1)
+
+        return float(confidence)
+
+
+    # ---------------------------------------
+    # MECHANISTIC TRACE
+    # ---------------------------------------
+
+    def mechanistic_trace(self, raw_row):
+
+        explanation = self.explain_prediction_detailed(raw_row)
+
+        trace = []
+
+        cumulative = 0
+
+        for e in explanation:
+
+            cumulative += e["impact"]
+
+            trace.append({
+
+                "feature": e["feature"],
+
+                "value": e["value"],
+
+                "impact": e["impact"],
+
+                "cumulative_effect": cumulative
+
+            })
+        return trace
+    def get_model(self):
+        return self.model

ecobertx-1.0/ecobertX/observe/file_logger.py

@@ -0,0 +1,45 @@
+import json
+import os
+from datetime import datetime
+
+
+LOG_DIR = "logs"
+
+os.makedirs(LOG_DIR, exist_ok=True)
+
+
+def save_prediction_log(config, prediction, explanation, confidence, trace):
+
+    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+
+    record = {
+
+        "timestamp": timestamp,
+
+        "input": config,
+
+        "prediction": prediction,
+
+        "confidence": confidence,
+
+        "explanation": explanation,
+
+        "mechanistic_trace": trace
+
+    }
+
+    path = os.path.join(
+
+        LOG_DIR,
+
+        f"log_{timestamp}.json"
+
+    )
+
+    with open(path, "w") as f:
+
+        json.dump(record, f, indent=4)
+
+    print("Log saved:", path)
+
+    return path

ecobertx-1.0/ecobertX/observe/telemetry_Setup.py

@@ -0,0 +1,8 @@
+from traceloop.sdk import Traceloop
+from opentelemetry import trace
+
+# Initialize OpenLLMetry (built on OpenTelemetry)
+Traceloop.init(disable_batch=True)
+
+# Create tracer for EcoBERT-X
+tracer = trace.get_tracer("EcoBERT-X-Prediction")

ecobertx-1.0/ecobertX/pipeline.py

@@ -0,0 +1,82 @@
+from ecobertx.explain.predict_explain import PredictionExplainer
+from ecobertx.optimisation.optuna_optimiser import OptunaOptimizer
+from ecobertx.optimisation.advanced_optimizer import AdvancedEcoOptimizer
+
+
+class EcoBERTXPipeline:
+    def __init__(self, model_path=None):
+        print("EcoBERT-X Prediction Explainer initialized.")
+
+        self.explainer = PredictionExplainer(model_path)
+        self.predictor = self.explainer
+
+        self.feature_cols = [
+            "num_epochs",
+            "batch_size",
+            "num_train_samples",
+            "model_size",
+            "num_layers"
+        ]
+
+    def _safe_validation(self, explanation):
+        if isinstance(explanation, list):
+            explanation = explanation[0]
+
+        if not isinstance(explanation, dict):
+            return {}
+
+        return explanation.get("validation", {})
+
+    def run(self, row):
+        print("\n🚀 Running EcoBERT-X Pipeline...\n")
+
+        original_co2 = float(self.predictor.predict(row))
+        original_explanation = self.explainer.explain_prediction_detailed(row)
+
+        print("📊 ORIGINAL")
+        print("CO2:", original_co2)
+
+        print("\n⚙️ Running Optuna Optimization...")
+
+        basic_optimizer = OptunaOptimizer(self.predictor, self.explainer)
+        best_params, _ = basic_optimizer.optimize(row, n_trials=20)
+
+        print("\n⚙️ BEST CONFIG FOUND")
+        print(best_params)
+
+        print("\n🧠 Running Advanced Eco Optimization...")
+
+        real_model = self.explainer.get_model()
+
+        import pandas as pd
+        background = pd.DataFrame([row])
+
+        adv_optimizer = AdvancedEcoOptimizer(
+            model=real_model,
+            feature_cols=self.feature_cols,
+            background_data=background
+        )
+
+        adv_result = adv_optimizer.run(row)
+
+        print("\n🌱 OPTIMIZED")
+        print("CO2:", adv_result["optimized_co2"])
+
+        print("\n📉 Improvement:", adv_result["reduction"])
+
+        print("\n🧠 CAUSAL EXPLANATION:")
+        for r in adv_result["causal_explanations"]:
+            print("•", r)
+
+        print("\n🧪 VALIDATION:")
+        print(adv_result["validation"])
+
+        return adv_result
+def run_ecobertx(input_csv):
+    import pandas as pd
+
+    df = pd.read_csv(input_csv)
+    row = df.iloc[0]
+
+    pipeline = EcoBERTXPipeline("D:/EcoPredictor+")
+    return pipeline.run(row)

ecobertx-1.0/ecobertX/run_prediction_xai.py

@@ -0,0 +1,26 @@
+from explain.predict_explain import PredictionExplainer
+from explain.dual_interpreter import interpret_prediction_full
+from visualize.heatmap import plot_heatmap
+
+import pandas as pd
+
+PROJECT_ROOT = r"D:\EcoPredictor+"
+
+X_test = pd.read_csv(
+    r"D:\EcoPredictor+\data\processed\X_test_raw.csv"
+)
+
+xai = PredictionExplainer(PROJECT_ROOT)
+
+row = X_test.iloc[0]
+
+prediction = xai.predict(row)
+
+explanation = xai.explain_prediction_detailed(row)
+
+interpret_prediction_full(row, xai)
+
+plot_heatmap(
+    explanation,
+    r"D:\EcoPredictor+\ecobertX\logs\heatmap.png"
+)

ecobertx-1.0/ecobertX/use_case.py

@@ -0,0 +1,57 @@
+import json
+import glob
+import os
+
+LOG_FOLDER = r"D:\EcoPredictor+\ecobertX\logs"
+
+# ----------------------------------------------------
+# 1. Load all prediction logs
+# ----------------------------------------------------
+files = glob.glob(os.path.join(LOG_FOLDER, "*.json"))
+
+if not files:
+    print("No logs found!")
+    exit()
+
+# ----------------------------------------------------
+# 2. Select lowest-carbon configuration
+# ----------------------------------------------------
+best = None
+
+for f in files:
+    log = json.load(open(f))
+
+    if not best or log["predicted_co2"] < best["predicted_co2"]:
+        best = log
+        best_file = f
+
+
+print("\n🌱 ECOBERT-X LOG-BASED DECISION")
+print("================================")
+print("Selected log :", best_file)
+print("Predicted CO₂:", round(best["predicted_co2"], 6), "kg")
+
+
+# ----------------------------------------------------
+# 3. Explain WHY this was low carbon
+# ----------------------------------------------------
+print("\nKey Reasons from Log:")
+
+for r in best["shap_explanation"][:5]:
+
+    direction = "reduces" if r["impact"] < 0 else "increases"
+
+    print(f"- {r['feature']} {direction} CO₂ by {abs(r['impact']):.4f} kg")
+
+
+# ----------------------------------------------------
+# 4. Practical Usage Demonstration
+# ----------------------------------------------------
+print("\nHow this log is used in practice:")
+print("""
+• Before real training begins, several candidate configs are evaluated.
+• EcoBERT-X predicts CO₂ for each and stores JSON logs.
+• This script selects the lowest-emission option.
+• SHAP reasons explain which hyperparameters caused the change.
+• The team trains only the sustainable configuration.
+""")

ecobertx-1.0/ecobertX.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: ecobertx
+Version: 1.0
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: shap
+Requires-Dist: matplotlib
+Dynamic: requires-dist

ecobertx-1.0/ecobertX.egg-info/SOURCES.txt

@@ -0,0 +1,64 @@
+pyproject.toml
+setup.py
+ecobertX/__init__.py
+ecobertX/cli.py
+ecobertX/pipeline.py
+ecobertX/run_prediction_xai.py
+ecobertX/use_case.py
+ecobertX.egg-info/PKG-INFO
+ecobertX.egg-info/SOURCES.txt
+ecobertX.egg-info/dependency_links.txt
+ecobertX.egg-info/entry_points.txt
+ecobertX.egg-info/requires.txt
+ecobertX.egg-info/top_level.txt
+ecobertX/explain/__init__.py
+ecobertX/explain/causal_reasoning.py
+ecobertX/explain/dual_interpreter.py
+ecobertX/explain/predict_explain.py
+ecobertX/observe/__init__.py
+ecobertX/observe/file_logger.py
+ecobertX/observe/telemetry_Setup.py
+ecobertx/__init__.py
+ecobertx/cli.py
+ecobertx/pipeline.py
+ecobertx/run_prediction_xai.py
+ecobertx/use_case.py
+ecobertx.egg-info/PKG-INFO
+ecobertx.egg-info/SOURCES.txt
+ecobertx.egg-info/dependency_links.txt
+ecobertx.egg-info/entry_points.txt
+ecobertx.egg-info/requires.txt
+ecobertx.egg-info/top_level.txt
+ecobertx/explain/__init__.py
+ecobertx/explain/causal_reasoning.py
+ecobertx/explain/dual_interpreter.py
+ecobertx/explain/predict_explain.py
+ecobertx/observe/__init__.py
+ecobertx/observe/file_logger.py
+ecobertx/observe/telemetry_Setup.py
+src/__init__.py
+src/data/__init__.py
+src/data/make_dataset.py
+src/data_collection/__init__.py
+src/data_collection/main.py
+src/data_collection/new.py
+src/data_collection/run_experiment.py
+src/data_collection/run_experiment_tpu.py
+src/data_collection/run_single_heavy_Exp.py
+src/modeling/__init__.py
+src/modeling/evaluate.py
+src/modeling/predict.py
+src/modeling/predict_new_model.py
+src/modeling/predict_trial.py
+src/modeling/run_prediction_on_validation.py
+src/modeling/tab_1.py
+src/modeling/train_model.py
+src/modeling/vi_test.py
+src/modeling/vi_val.py
+src/modeling/vis_table.py
+src/modeling/visualise.py
+src/modeling/visualise_all_models.py
+src/modeling/visualise_test.py
+src/modeling/visualise_validation.py
+src/preprocessing/__init__.py
+src/preprocessing/build_features.py

ecobertx-1.0/ecobertX.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ecobertx-1.0/ecobertX.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ecobertx = ecobertx.cli:main

ecobertx-1.0/ecobertX.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pandas
+numpy
+scikit-learn
+shap
+matplotlib

ecobertx-1.0/ecobertX.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+ecobertx
+src

ecobertx-1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

ecobertx-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ecobertx-1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="ecobertx",
+    version="1.0",
+    packages=find_packages(),
+    install_requires=[
+        "pandas",
+        "numpy",
+        "scikit-learn",
+        "shap",
+        "matplotlib"
+    ],
+    entry_points={
+        "console_scripts": [
+            "ecobertx=ecobertx.cli:main"
+        ]
+    }
+)