Spaces:

iremrit
/

FinRisk-AI

Sleeping

+{
+    "all_features": [
+        "Age",
+        "Num_Bank_Accounts",
+        "Num_Credit_Card",
+        "Delay_from_due_date",
+        "Num_of_Delayed_Payment",
+        "Num_of_Loan",
+        "Num_Credit_Inquiries",
+        "Monthly_Inhand_Salary",
+        "Interest_Rate",
+        "Outstanding_Debt",
+        "Credit_Utilization_Ratio",
+        "Monthly_Balance",
+        "Total_EMI_per_month",
+        "Amount_invested_monthly",
+        "Installment_to_Income",
+        "Delayed_Per_Loan",
+        "Debt_to_Income_Ratio",
+        "DTI_x_LoanCount",
+        "Debt_Per_Loan",
+        "Loan_Count_Calculated",
+        "Loan_Auto_Loan",
+        "Loan_Credit-Builder_Loan",
+        "Loan_Personal_Loan",
+        "Loan_Home_Equity_Loan",
+        "Loan_Mortgage_Loan",
+        "Loan_Student_Loan",
+        "Loan_Debt_Consolidation_Loan",
+        "Loan_Payday_Loan",
+        "Log_Annual_Income",
+        "Credit_Mix_Ordinal",
+        "Occupation_Architect",
+        "Occupation_Developer",
+        "Occupation_Doctor",
+        "Occupation_Engineer",
+        "Occupation_Entrepreneur",
+        "Occupation_Journalist",
+        "Occupation_Lawyer",
+        "Occupation_Manager",
+        "Occupation_Mechanic",
+        "Occupation_Media_Manager",
+        "Occupation_Musician",
+        "Occupation_Scientist",
+        "Occupation_Teacher",
+        "Occupation_Writer",
+        "Occupation________",
+        "Payment_of_Min_Amount_No",
+        "Payment_of_Min_Amount_Yes",
+        "Payment_Behaviour_High_spent_Medium_value_payments",
+        "Payment_Behaviour_High_spent_Small_value_payments",
+        "Payment_Behaviour_Low_spent_Large_value_payments",
+        "Payment_Behaviour_Low_spent_Medium_value_payments",
+        "Payment_Behaviour_Low_spent_Small_value_payments",
+        "Payment_Behaviour_Unknown"
+    ],
+    "top_10_features": [
+        "Credit_Mix_Ordinal",
+        "Outstanding_Debt",
+        "Delay_from_due_date",
+        "Payment_of_Min_Amount_Yes",
+        "Num_Credit_Card",
+        "Interest_Rate",
+        "Num_of_Delayed_Payment",
+        "Installment_to_Income",
+        "Num_Bank_Accounts",
+        "Num_Credit_Inquiries"
+    ]
+}

models/final_model.pkl ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:ca63338de468e64e8a33c22eb98663577040adb5eb014c25cbe8a62ccdb173ba
+size 37459067

templates/index.html ADDED Viewed

	@@ -0,0 +1,442 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FinRisk-AI</title>
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>💳</text></svg>">
+    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: 'Montserrat', sans-serif;
+            background: linear-gradient(135deg, #0f4c75 0%, #3282b8 25%, #bbe1fa 50%, #1b262c 75%, #0f4c75 100%);
+            background-size: 400% 400%;
+            animation: gradientShift 15s ease infinite;
+            min-height: 100vh;
+            padding: 20px;
+            position: relative;
+            overflow: hidden;
+        }
+        body::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: radial-gradient(circle at 20% 80%, rgba(0, 128, 0, 0.1) 0%, transparent 50%),
+                        radial-gradient(circle at 80% 20%, rgba(255, 69, 0, 0.1) 0%, transparent 50%),
+                        radial-gradient(circle at 40% 40%, rgba(0, 139, 139, 0.1) 0%, transparent 50%);
+            animation: float 20s ease-in-out infinite;
+            pointer-events: none;
+        }
+        @keyframes gradientShift {
+            0% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+            100% { background-position: 0% 50%; }
+        }
+        @keyframes float {
+            0%, 100% { transform: translateY(0px) rotate(0deg); }
+            33% { transform: translateY(-10px) rotate(1deg); }
+            66% { transform: translateY(10px) rotate(-1deg); }
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        .header {
+            text-align: center;
+            color: white;
+            margin-bottom: 30px;
+        }
+        .header h1 {
+            font-size: 2.8rem;
+            margin-bottom: 10px;
+            font-weight: 700;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+        .header p {
+            font-size: 1.2rem;
+            opacity: 0.9;
+            font-weight: 300;
+        }
+        .card {
+            background: white;
+            border-radius: 15px;
+            padding: 30px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+            margin-bottom: 20px;
+        }
+        .form-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
+            gap: 15px;
+            margin-bottom: 20px;
+        }
+        .form-group {
+            display: flex;
+            flex-direction: column;
+        }
+        .form-group label {
+            font-size: 0.85rem;
+            font-weight: 600;
+            margin-bottom: 5px;
+            color: #34495e;
+        }
+        .form-group input {
+            padding: 10px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            font-size: 0.95rem;
+            transition: border-color 0.3s;
+        }
+        .form-group input:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+        .button-group {
+            display: flex;
+            gap: 10px;
+            justify-content: center;
+        }
+        .btn {
+            padding: 12px 30px;
+            border: none;
+            border-radius: 8px;
+            font-size: 1rem;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.3s;
+        }
+        .btn-primary {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+        }
+        .btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+        .btn-secondary {
+            background: #f0f0f0;
+            color: #34495e;
+        }
+        .btn-secondary:hover {
+            background: #e0e0e0;
+        }
+        .result {
+            display: none;
+            padding: 20px;
+            border-radius: 10px;
+            margin-top: 20px;
+        }
+        .result.show {
+            display: block;
+            animation: fadeIn 0.5s;
+        }
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(-10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        .result-low {
+            background: #d4edda;
+            border-left: 5px solid #28a745;
+        }
+        .result-medium {
+            background: #fff3cd;
+            border-left: 5px solid #ffc107;
+        }
+        .result-high {
+            background: #f8d7da;
+            border-left: 5px solid #dc3545;
+        }
+        .result h3 {
+            margin-bottom: 10px;
+            font-size: 1.3rem;
+        }
+        .result-details {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-top: 15px;
+        }
+        .result-item {
+            padding: 10px;
+            background: rgba(255,255,255,0.5);
+            border-radius: 5px;
+        }
+        .result-item strong {
+            display: block;
+            margin-bottom: 5px;
+            font-size: 0.9rem;
+        }
+        .result-item span {
+            font-size: 1.2rem;
+            font-weight: 600;
+        }
+        .loading {
+            display: none;
+            text-align: center;
+            padding: 20px;
+        }
+        .loading.show {
+            display: block;
+        }
+        .spinner {
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            width: 40px;
+            height: 40px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        .footer {
+            text-align: center;
+            color: white;
+            margin-top: 30px;
+            opacity: 0.8;
+            font-weight: 300;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>💳 FinRisk-AI</h1>
+            <p>Intelligent Credit Risk Analysis Powered by AI</p>
+        </div>
+        <div class="card">
+            <form id="predictionForm">
+                <div class="form-grid" id="featureInputs"></div>
+                <div class="button-group">
+                    <button type="submit" class="btn btn-primary">Predict Risk</button>
+                    <button type="button" class="btn btn-secondary" onclick="fillSampleData()">Fill Sample Data</button>
+                    <button type="reset" class="btn btn-secondary">Clear Form</button>
+                </div>
+            </form>
+            <div class="loading" id="loading">
+                <div class="spinner"></div>
+                <p style="margin-top: 10px;">Calculating risk...</p>
+            </div>
+            <div class="result" id="result"></div>
+        </div>
+        <div class="footer">
+            <p>FinRisk-AI v1.0 | 50+ Features | Stacking Classifier</p>
+        </div>
+    </div>
+    <script>
+        const features = {{ features | tojson }};
+        function createFeatureInputs() {
+            const container = document.getElementById('featureInputs');
+            if (features && features.top_10_features) {
+                features.top_10_features.forEach(feature => {
+                    const div = document.createElement('div');
+                    div.className = 'form-group';
+                    div.innerHTML = `
+                        <label for="${feature}">${feature}</label>
+                        <input type="number" step="any" id="${feature}" name="${feature}" required>
+                    `;
+                    container.appendChild(div);
+                });
+            }
+        }
+        function fillSampleData() {
+            const sampleData = {
+                'Credit_Mix_Ordinal': 2,
+                'Outstanding_Debt': 15000,
+                'Delay_from_due_date': 5,
+                'Payment_of_Min_Amount_Yes': 1,
+                'Num_Credit_Card': 3,
+                'Interest_Rate': 12,
+                'Num_of_Delayed_Payment': 2,
+                'Installment_to_Income': 0.25,
+                'Num_Bank_Accounts': 4,
+                'Num_Credit_Inquiries': 1
+            };
+            features.top_10_features.forEach(feature => {
+                const input = document.getElementById(feature);
+                input.value = sampleData[feature] || 0;
+            });
+        }
+        document.getElementById('predictionForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const formData = new FormData(e.target);
+            const featuresData = {};
+            // Include all features, using form values for top_10_features and defaults for others
+            features.all_features.forEach(feature => {
+                if (features.top_10_features.includes(feature)) {
+                    featuresData[feature] = parseFloat(formData.get(feature));
+                } else {
+                    featuresData[feature] = 0; // Default value for features not in form
+                }
+            });
+            document.getElementById('loading').classList.add('show');
+            document.getElementById('result').classList.remove('show');
+            try {
+                const response = await fetch('/predict', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ features: featuresData })
+                });
+                const data = await response.json();
+                displayResult(data);
+            } catch (error) {
+                alert('Error: ' + error.message);
+            } finally {
+                document.getElementById('loading').classList.remove('show');
+            }
+        });
+        function displayResult(data) {
+            const resultDiv = document.getElementById('result');
+            // Map prediction to risk level for styling
+            const riskLevel = data.prediction.toLowerCase() === 'poor' ? 'high' :
+                             data.prediction.toLowerCase() === 'standard' ? 'medium' : 'low';
+            // Create message based on prediction
+            const message = `Your credit score is predicted to be: ${data.prediction}`;
+            resultDiv.className = `result result-${riskLevel} show`;
+            resultDiv.innerHTML = `
+                <h3>${message}</h3>
+                <div class="result-details">
+                    <div class="result-item">
+                        <strong>Credit Score</strong>
+                        <span style="text-transform: uppercase;">${data.prediction}</span>
+                    </div>
+                    <div class="result-item">
+                        <strong>Features Analyzed</strong>
+                        <span>${data.features_used}</span>
+                    </div>
+                </div>
+            `;
+        }
+        createFeatureInputs();
+        // Enable Calculator API button when all inputs are filled
+        const inputs = document.querySelectorAll('#featureInputs input');
+        const calculatorBtn = document.getElementById('calculatorBtn');
+        function checkInputs() {
+            let allFilled = true;
+            inputs.forEach(input => {
+                if (!input.value.trim()) {
+                    allFilled = false;
+                }
+            });
+            calculatorBtn.disabled = !allFilled;
+        }
+        inputs.forEach(input => {
+            input.addEventListener('input', checkInputs);
+        });
+        calculatorBtn.addEventListener('click', async () => {
+            const featuresData = {};
+            // Include all features, using form values for top_10_features and defaults for others
+            if (features && features.all_features && features.top_10_features) {
+                features.all_features.forEach(feature => {
+                    if (features.top_10_features.includes(feature)) {
+                        const input = document.getElementById(feature);
+                        featuresData[feature] = parseFloat(input.value);
+                    } else {
+                        featuresData[feature] = 0; // Default value for features not in form
+                    }
+                });
+            }
+            document.getElementById('loading').classList.add('show');
+            document.getElementById('result').classList.remove('show');
+            try {
+                const response = await fetch('/predict', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ features: featuresData })
+                });
+                const data = await response.json();
+                displayResult(data);
+            } catch (error) {
+                alert('Error: ' + error.message);
+            } finally {
+                document.getElementById('loading').classList.remove('show');
+            }
+        });
+    </script>
+</body>
+</html>

tests/__pycache__/config.cpython-312.pyc ADDED Viewed

Binary file (1.61 kB). View file

tests/__pycache__/inference.cpython-312.pyc ADDED Viewed

Binary file (3.53 kB). View file

tests/__pycache__/pipeline.cpython-312.pyc ADDED Viewed

Binary file (2.73 kB). View file

tests/_init_.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ #API KEY

tests/app.py ADDED Viewed

	@@ -0,0 +1,94 @@

+import os
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel
+from typing import Dict
+from config import API_TITLE, API_VERSION, API_DESCRIPTION
+from inference import predictor
+app = FastAPI(title=API_TITLE, version=API_VERSION, description=API_DESCRIPTION)
+templates = Jinja2Templates(directory="src/templates")
+class PredictionRequest(BaseModel):
+    features: Dict[str, float]
+class PredictionResponse(BaseModel):
+    prediction: str
+    features_used: int
+class ProbabilityResponse(BaseModel):
+    probabilities: Dict[str, float]
+    features_used: int
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    feature_names = predictor.get_feature_names()
+    # Load top 10 features from features.json
+    predictor.load_model()  # Ensure features are loaded
+    top_10_features = predictor.features['top_10_features']
+    return templates.TemplateResponse(
+        "index.html",
+        {"request": request, "features": {"all_features": feature_names, "top_10_features": top_10_features}}
+    )
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "model_loaded": predictor._model_loaded,
+        "model_ready": predictor.model is not None
+    }
+@app.get("/features")
+async def get_features():
+    return {"features": predictor.get_feature_names()}
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(request: PredictionRequest):
+    # Validate missing features
+    expected = set(predictor.get_feature_names())
+    incoming = set(request.features.keys())
+    missing = expected - incoming
+    if missing:
+        raise HTTPException(400, f"Missing features: {missing}")
+    prediction = predictor.predict(request.features)
+    return PredictionResponse(
+        prediction=prediction,
+        features_used=len(request.features)
+    )
+@app.post("/predict_proba", response_model=ProbabilityResponse)
+async def predict_proba(request: PredictionRequest):
+    # Validate missing features
+    expected = set(predictor.get_feature_names())
+    incoming = set(request.features.keys())
+    missing = expected - incoming
+    if missing:
+        raise HTTPException(400, f"Missing features: {missing}")
+    probabilities = predictor.predict_proba(request.features)
+    return ProbabilityResponse(
+        probabilities=probabilities,
+        features_used=len(request.features)
+    )
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run(app, host="0.0.0.0", port=port)

tests/config.py ADDED Viewed

	@@ -0,0 +1,38 @@

+import os
+# Paths
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DATA_PATH = os.path.join(BASE_DIR, '..', 'data')
+MODELS_PATH = os.path.join(BASE_DIR, 'models')
+MODEL_FILENAME = 'final_model.pkl'
+MODEL_PATH = os.path.join(MODELS_PATH, MODEL_FILENAME)
+FEATURES_PATH = os.path.join(MODELS_PATH, 'features.json')
+# API Configurations
+API_TITLE = "FinRisk-AI API"
+API_VERSION = "1.0.0"
+API_DESCRIPTION = (
+    "Credit Score Classification service that predicts a customer's "
+    "credit category (Good, Standard, Poor). Built using a complete ML "
+    "pipeline and the system decided to utilize the model which uses an optimized "
+    "stacked ensemble (Random Forest + XGBoost + Logistic Regression) "
+    "achieving strong accuracy and robust generalization. Suitable for "
+    "automated underwriting and risk assessment."
+)
+# Risk levels and messages (placeholders)
+RISK_LEVELS = {
+    'low': (0.0, 0.3),
+    'medium': (0.3, 0.7),
+    'high': (0.7, 1.0)
+}
+RISK_MESSAGES = {
+    'low': 'Low risk',
+    'medium': 'Medium risk',
+    'high': 'High risk'
+}

tests/inference.py ADDED Viewed

	@@ -0,0 +1,85 @@

+import json
+import joblib
+import pandas as pd
+from typing import Dict
+from config import MODEL_PATH, FEATURES_PATH
+class CreditScorePredictor:
+    def __init__(self):
+        self.model = None
+        self.features = None
+        self._model_loaded = False
+    def load_model(self):
+        if not self._model_loaded:
+            self.model = joblib.load(MODEL_PATH)
+            with open(FEATURES_PATH, 'r') as f:
+                self.features = json.load(f)
+            self._model_loaded = True
+    def predict(self, features_dict: Dict[str, float]) -> str:
+        # Ensure model is loaded
+        self.load_model()
+        df = pd.DataFrame([features_dict])
+        # Ensure correct feature order
+        df = df[
+            self.features['all_features']
+        ]
+        # Get prediction
+        pred_class = self.model.predict(df)[0]
+        # Map to credit score labels
+        credit_labels = {0: 'Poor', 1: 'Standard', 2: 'Good'}
+        prediction = credit_labels.get(pred_class, 'Unknown')
+        return prediction
+    def predict_proba(self, features_dict: Dict[str, float]) -> Dict[str, float]:
+        # Ensure model is loaded
+        self.load_model()
+        df = pd.DataFrame([features_dict])
+        # Ensure correct feature order
+        df = df[self.features['all_features']]
+        # Get prediction probabilities
+        proba = self.model.predict_proba(df)[0]
+        # Map to credit score labels
+        credit_labels = {0: 'Poor', 1: 'Standard', 2: 'Good'}
+        probabilities = {
+            credit_labels[i]: float(proba[i]) for i in range(len(proba))
+        }
+        return probabilities
+    def get_feature_names(self):
+        # Ensure model is loaded to get feature names
+        self.load_model()
+        return self.features['all_features']
+    def get_top_features(self, n=10):
+        # Ensure model is loaded
+        self.load_model()
+        # Top 10 most important features based on model evaluation
+        top_features = [
+            'Credit_Mix_Ordinal',
+            'Outstanding_Debt',
+            'Delay_from_due_date',
+            'Payment_of_Min_Amount_Yes',
+            'Changed_Credit_Limit',
+            'Credit_Utilization_Ratio',
+            'Monthly_Balance',
+            'Num_Bank_Accounts',
+            'Num_Credit_Inquiries',
+            'Annual_Income'
+        ]
+        return top_features[:n]
+predictor = CreditScorePredictor()

tests/pipeline.py ADDED Viewed

	@@ -0,0 +1,95 @@

+import json
+import pandas as pd
+from sklearn.ensemble import RandomForestClassifier, StackingClassifier
+from sklearn.linear_model import LogisticRegression
+from xgboost import XGBClassifier
+import joblib
+import os
+from config import DATA_PATH, MODELS_PATH, MODEL_FILENAME, FEATURES_PATH
+# Top 10 features for user input
+SELECTED_FEATURES = [
+    'Credit_Mix_Ordinal',
+    'Outstanding_Debt',
+    'Delay_from_due_date',
+    'Payment_of_Min_Amount_Yes',
+    'Num_Credit_Card',
+    'Interest_Rate',
+    'Num_of_Delayed_Payment',
+    'Installment_to_Income',
+    'Num_Bank_Accounts',
+    'Num_Credit_Inquiries'
+]
+def run_pipeline():
+    print("Starting pipeline...")
+    # Load processed training data
+    train_processed_path = os.path.join(DATA_PATH, 'processed', 'train_processed.csv')
+    if not os.path.exists(train_processed_path):
+        raise FileNotFoundError(f"Processed training data not found at {train_processed_path}")
+    train_processed = pd.read_csv(train_processed_path)
+    # Train model with ALL FEATURES except the target
+    target = 'Credit_Score'
+    if target not in train_processed.columns:
+        raise ValueError("Target column 'Credit_Score' is missing from processed training data.")
+    X = train_processed.drop(target, axis=1)
+    y = train_processed[target]
+    ALL_FEATURES = X.columns.tolist()
+    print(f"Training model using ALL {len(ALL_FEATURES)} features...")
+    print(f"Training data loaded: {X.shape[0]} samples, {X.shape[1]} features")
+    # Define models
+    rf_model = RandomForestClassifier(
+        n_estimators=300,
+        max_depth=12,
+        class_weight='balanced',
+        criterion='entropy',
+        random_state=1907,
+        n_jobs=-1
+    )
+    xgb_model = XGBClassifier(
+        n_estimators=300,
+        learning_rate=0.1,
+        max_depth=6,
+        random_state=1907,
+        verbosity=0
+    )
+    stacking_clf = StackingClassifier(
+        estimators=[('rf', rf_model), ('xgb', xgb_model)],
+        final_estimator=LogisticRegression(max_iter=1000, random_state=1907),
+        cv=5
+    )
+    # Train model
+    print("Training stacking classifier...")
+    stacking_clf.fit(X, y)
+    # Save model
+    os.makedirs(MODELS_PATH, exist_ok=True)
+    model_path = os.path.join(MODELS_PATH, MODEL_FILENAME)
+    joblib.dump(stacking_clf, model_path)
+    print(f"Model saved to {model_path}")
+    # Save BOTH feature lists
+    feature_data = {
+        "all_features": ALL_FEATURES,
+        "top_10_features": SELECTED_FEATURES
+    }
+    with open(FEATURES_PATH, 'w') as f:
+        json.dump(feature_data, f, indent=4)
+    print("Feature lists saved.")
+    print("Pipeline completed successfully.")
+if __name__ == "__main__":
+    run_pipeline()