feat: Deploy latest version of Gradio app

.devcontainer/devcontainer.json

@@ -0,0 +1,13 @@
+{
+  "name": "Predictive Maintenance Environment",
+  "image": "mcr.microsoft.com/devcontainers/python:3.9",
+  "postCreateCommand": "pip install pandas scikit-learn gradio joblib huggingface_hub datasets",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-python.python",
+        "ms-toolsai.jupyter"
+      ]
+    }
+  }
+}

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/main.yaml

@@ -0,0 +1,68 @@
+# This workflow trains a model AND deploys the full Gradio app with that model.
+name: Train and Deploy Gradio App to Spaces
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  train-and-deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+      # Step 1: Checks out your GitHub repository code
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          # Fetch all history for all branches and tags
+          fetch-depth: 0
+
+      # Step 2: Set up the Python environment
+      - name: Set up Python 3.9
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'
+
+      # Step 3: Install all dependencies from your requirements.txt file
+      - name: Install Dependencies
+        run: pip install -r requirements.txt
+
+      # Step 4: Prepare the data for training
+      - name: Prepare Data
+        run: python prepare_data.py
+
+      # Step 5: Train the model to create the model.joblib file
+      - name: Train Baseline Linear Model
+        run: python train.py
+
+      # Step 6: Push the entire project to your Hugging Face Space
+      - name: Push to HF Space
+        env:
+          # Your HF token, stored as a GitHub secret
+          HF_TOKEN: ${{ secrets.HUGGING_FACE_TOKEN }}
+        run: |
+          # Clones your Hugging Face Space repository into a new folder named 'space'
+          git clone https://ashandilgith:$HF_TOKEN@huggingface.co/spaces/ashandilgith/predictive_maintenance space
+          
+          # Use rsync to copy all files from the current directory to the 'space' directory,
+          # excluding the 'space' directory itself to prevent the error.
+          rsync -av --delete --exclude='/space' --exclude='.git' ./ ./space/
+          
+          # Go into the 'space' folder to perform git operations
+          cd ./space
+          
+          # Configure git user for the commit
+          git config --global user.email "actions@github.com"
+          git config --global user.name "GitHub Actions Bot"
+          
+          # Add all the new and updated files to be committed
+          git add .
+          
+          # Commit the changes with a descriptive message
+          # The '--allow-empty' flag prevents errors if there are no changes to commit.
+          git commit -m "feat: Deploy latest version of Gradio app" --allow-empty
+          
+          # Push the changes to the Hugging Face Space repository
+          git push

LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

README.md

@@ -1,14 +1,85 @@
----
-title: Predictive Maintenance
-emoji: 🌍
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 5.34.1
-app_file: app.py
-pinned: false
-license: cc0-1.0
-short_description: 'MVP for predictive maintenance '
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+title: Predictive Maintenance for Turbofan Engines emoji: ✈️ colorFrom: blue colorTo: indigo sdk: gradio sdk_version: 4.20.0 app_file: app.py pinned: false
+
+Predictive Maintenance for Turbofan Engines
+A complete MLOps project demonstrating an end-to-end workflow for a predictive maintenance solution. This application uses a machine learning model to predict the Remaining Useful Life (RUL) of a turbofan engine based on operational settings and sensor data.
+
+The project is developed within a containerized GitHub Codespaces environment and features a CI/CD pipeline that automatically trains the model and deploys the application to a Hugging Face Space.
+
+✨ Features
+Interactive Demo: A user-friendly Gradio web interface to get real-time RUL predictions.
+
+Automated CI/CD: The model is automatically retrained and the application is redeployed on every push to the main branch using GitHub Actions.
+
+Reproducible Environment: A defined development environment using Codespaces ensures that the project can be run consistently by anyone.
+
+Extensible Framework: While this demo uses a turbofan engine dataset, the principles can be customized for any machinery that relies on sensor data to predict performance or potential faults.
+
+🛠️ Technology Stack
+Backend: Python
+
+ML Model: Scikit-learn (Linear Regression)
+
+Web App: Gradio
+
+Dev Environment: GitHub Codespaces (Docker)
+
+CI/CD & Hosting: GitHub Actions, Hugging Face Spaces
+
+🚀 How to Run Locally
+To run this project on your own machine or Codespace, follow these steps.
+
+Prerequisites
+Python 3.9 or higher
+
+Git
+
+1. Clone the Repository
+git clone [https://github.com/ashandilgith/predictivemaintenance-.git](https://github.com/ashandilgith/predictivemaintenance-.git)
+cd predictivemaintenance-
+
+2. Set Up a Virtual Environment (Recommended)
+# Create a virtual environment
+python3 -m venv venv
+
+# Activate it
+source venv/bin/activate
+
+3. Install Dependencies
+Install all the required Python libraries from the requirements.txt file.
+
+pip install -r requirements.txt
+
+4. Prepare the Data
+Run the script to process the raw dataset. This will create processed_train_data.csv in the data/ directory.
+
+python prepare_data.py
+
+5. Train the Model
+Run the training script to create the model.joblib file.
+
+python train.py
+
+6. Launch the Gradio App
+Run the application file. The app will be available at a local URL shown in your terminal.
+
+python app.py
+
+⚙️ CI/CD Pipeline
+This project uses a GitHub Actions workflow defined in .github/workflows/main.yml. The pipeline automates the following steps on every push to the main branch:
+
+Checkout Code: Clones the repository onto a fresh virtual machine.
+
+Install Dependencies: Installs all necessary libraries.
+
+Prepare Data: Runs the data preparation script.
+
+Train Model: Trains the linear model and creates the model.joblib artifact.
+
+Deploy to Space: Pushes the entire application, including the newly trained model, to the designated Hugging Face Space, making the updated app live.
+
+📊 Dataset
+This project uses the Turbofan Engine Degradation Simulation Data Set provided by NASA.
+
+Source: NASA Prognostics Data Repository
+
+Subset Used: FD001

app.py

@@ -0,0 +1,84 @@
+import gradio as gr
+import joblib
+import numpy as np
+import os
+
+# --- 1. Load the Pre-Trained Model ---
+# This script assumes 'model.joblib' exists because you've run train.py
+MODEL_PATH = "model.joblib"
+model = None
+
+try:
+    model = joblib.load(MODEL_PATH)
+    print("Model 'model.joblib' loaded successfully.")
+except FileNotFoundError:
+    print(f"ERROR: Model file not found at '{MODEL_PATH}'.")
+    print("Please run 'python train.py' in your terminal first to create the model file.")
+
+
+# --- 2. Define Feature Names ---
+# This list must be in the exact same order as the data your model was trained on.
+feature_names = [
+    'time_in_cycles', 'setting_1', 'setting_2', 's_1', 's_2', 's_3', 's_4', 's_5', 
+    's_6', 's_7', 's_8', 's_9', 's_10', 's_11', 's_12', 's_13', 's_14', 's_15', 
+    's_16', 's_17', 's_18', 's_19', 's_20', 's_21'
+]
+
+# --- 3. Create the Prediction Function ---
+def predict_rul(*args):
+    """
+    Takes all 24 slider/number inputs as arguments, arranges them into the
+    correct format, and returns the model's RUL prediction.
+    """
+    if model is None:
+        return "Model not loaded. Please run 'python train.py' and restart the app."
+
+    input_data = np.array(args).reshape(1, -1)
+    prediction = model.predict(input_data)
+    final_prediction = prediction[0]
+    
+    return f"{round(final_prediction, 2)} cycles remaining"
+
+# --- 4. Build the Gradio Interface ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Turbofan Engine Predictive Maintenance")
+    gr.Markdown(
+        """
+        This is a demo of a predictive maintenance model for a turbofan engine. 
+        However, the underlying principles can be customized for any form of machinery that uses sensor data 
+        to predict its Remaining Useful Life (RUL), performance, or time before a potential fault.
+        """
+    )
+    
+    gr.Markdown("### Engine Parameters & Sensor Readings")
+    
+    # Create a list to hold all our input components in a single column
+    inputs = []
+    # Arrange the number inputs into a 3-column grid for a more compact layout
+    num_columns = 3
+    for i in range(0, len(feature_names), num_columns):
+        with gr.Row():
+            for j in range(num_columns):
+                if i + j < len(feature_names):
+                    name = feature_names[i + j]
+                    # Create the component and add it to our list of inputs
+                    component = gr.Number(label=name, value=0.0)
+                    inputs.append(component)
+
+    # Place the prediction button below the inputs
+    predict_btn = gr.Button("Predict RUL", variant="primary")
+
+    gr.Markdown("### Prediction Result")
+    # Create the output textbox below the button
+    outputs = gr.Textbox(label="Predicted Remaining Useful Life (RUL)")
+    
+    # Connect the button's "click" event to our prediction function
+    predict_btn.click(
+        fn=predict_rul,
+        inputs=inputs,
+        outputs=outputs
+    )
+
+# --- 5. Launch the App ---
+if __name__ == "__main__":
+    demo.launch()

app_old.py

@@ -0,0 +1,89 @@
+import gradio as gr
+import joblib
+import numpy as np
+import os
+from PIL import Image 
+
+# --- 1. Load the Pre-Trained Model ---
+# This script assumes 'model.joblib' exists because you've run train.py
+MODEL_PATH = "model.joblib"
+IMAGE_PATH = "engine.jpg"
+model = None
+
+try:
+    model = joblib.load(MODEL_PATH)
+    print("Model 'model.joblib' loaded successfully.")
+except FileNotFoundError:
+    print(f"ERROR: Model file not found at '{MODEL_PATH}'.")
+    print("Please run 'python train.py' in your terminal first to create the model file.")
+
+# --- 2. Define Feature Names ---
+# This list must be in the exact same order as the data your model was trained on.
+feature_names = [
+    'time_in_cycles', 'setting_1', 'setting_2', 's_1', 's_2', 's_3', 's_4', 's_5', 
+    's_6', 's_7', 's_8', 's_9', 's_10', 's_11', 's_12', 's_13', 's_14', 's_15', 
+    's_16', 's_17', 's_18', 's_19', 's_20', 's_21'
+]
+
+# --- 3. Create the Prediction Function ---
+def predict_rul(*args):
+    """
+    Takes all 24 slider/number inputs as arguments, arranges them into the
+    correct format, and returns the model's RUL prediction.
+    """
+    # First, check if the model was loaded successfully.
+    if model is None:
+        return "Model not loaded. Please run 'python train.py' and restart the app."
+
+    # Convert the input arguments into a NumPy array for the model
+    input_data = np.array(args).reshape(1, -1)
+    
+    # Make the prediction
+    prediction = model.predict(input_data)
+    
+    # The model returns an array, so we get the first (and only) element
+    final_prediction = prediction[0]
+    
+    return f"{round(final_prediction, 2)} cycles remaining"
+
+# --- 4. Build the Gradio Interface ---
+# We use a Gradio "Blocks" layout for more control over the UI.
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Turbofan Engine Predictive Maintenance")
+    gr.Markdown("Enter the engine's current sensor readings to predict its Remaining Useful Life (RUL). This demo uses a trained Linear Regression model.")
+    
+    with gr.Row():
+        # Column for Inputs
+        with gr.Column(scale=1):
+            gr.Markdown("### Engine Parameters & Sensor Readings")
+            # Create a list to hold all our input components
+            inputs = []
+            for name in feature_names:
+                # Use a slider for each input for easy interaction
+                inputs.append(gr.Slider(minimum=0, maximum=1000, label=name, value=50))
+        
+        # Column for Image and Output
+        with gr.Column(scale=1):
+            # Using a reliable placeholder image link.
+            gr.Image(
+                "engine.jpg", 
+                label="Turbofan Engine"
+            )
+            
+            gr.Markdown("### Prediction Result")
+            # Create the output textbox
+            outputs = gr.Textbox(label="Predicted Remaining Useful Life (RUL)")
+
+    # Create the button to trigger the prediction
+    predict_btn = gr.Button("Predict RUL", variant="primary")
+    
+    # Connect the button's "click" event to our prediction function
+    predict_btn.click(
+        fn=predict_rul,
+        inputs=inputs,
+        outputs=outputs
+    )
+
+# --- 5. Launch the App ---
+if __name__ == "__main__":
+    demo.launch()

prepare_data.py

@@ -0,0 +1,71 @@
+import pandas as pd 
+import numpy as np 
+
+
+def prepare_data():
+#def prepare_data():
+
+    #load the data as a pandas dataset 
+
+    train_df = pd.read_csv('data/train_FD001.txt', sep = ' ', header=None)
+    #train_df = pd.read_csv('data/train_csv.txt', sep = ' ', header = None)
+    #train_df = pd.read_csv)'data/train_FD001.txt', sep = ' ', header = None) 
+    
+
+
+    # --- This is the crucial fix! ---
+    # The original file has trailing spaces, which pandas reads as empty columns.
+    # We drop these empty columns (usually numbered 26 and 27) before doing anything else.
+    train_df.drop(columns=[26, 27], inplace=True, errors='ignore')
+
+    #name the columns 
+    columns = ['unit_number', 'time_in_cycles', 'setting_1', 'setting_2', 'setting'] + [f's_{i}' for i in range (1,22)]
+
+    #name the columns of the new dataset
+    train_df.columns = columns 
+
+    #calculate Remaining Useful Life for each machine (unit_number on the table), by:
+    # 1. changing max cycle series to just the highest number (as it's currently a series of numbered runs)
+    # 2. simply changing max cycle to RUL by just removing the number of cycles run so far
+
+   # Calculate RUL for the training data
+
+    # 1️⃣ Group by unit_number (machine ID) and get the final cycle (maximum time_in_cycles) for each unit
+    max_cycles = train_df.groupby('unit_number')['time_in_cycles'].max()
+    #max_cycles = train_df.groupby('unit_number')['time_in_cycles'].max()
+    #max_cycles = train_df/groupby('unit_number')['time_in_cycles'].max()
+    #max_cycles = train_df.groupby('unit_number')['time_in_cycles'].max()
+
+    # 2️⃣ Merge the max_cycles back into the original dataframe, adding a 'max_cycle' column for each record based on unit_number
+    train_df = train_df.merge(max_cycles.to_frame(name='max_cycle'), left_on='unit_number', right_index=True)
+    #train_df = train_df.merge(max_cycles.to_frame(name='max_cycle'), left_on = 'unit_number', right_index=True)
+
+    # 3️⃣ Calculate RUL by subtracting current cycle from the final cycle for each record
+    train_df['RUL'] = train_df['max_cycle'] - train_df['time_in_cycles']
+    #train_df['RUL'] = train_df['max_cycle'] - train_df['time_in_cycles']
+
+    # 4️⃣ Drop the now-unnecessary 'max_cycle' column since we've already computed RUL
+    train_df.drop(columns=['max_cycle'], inplace=True)
+
+    #save the processed data 
+    train_df.to_csv('data/processed_data.csv', index=False)
+
+
+if __name__ == "__main__": 
+    prepare_data()
+
+
+
+
+
+
+   
+
+
+
+
+
+
+
+
+

push_to_hub.py

@@ -0,0 +1,68 @@
+from huggingface_hub import HfApi
+import os
+import sys
+
+def push_model_to_hub():
+    """
+    Authenticates with the Hugging Face Hub using an environment variable
+    and uploads the trained model file.
+    """
+    print("--- Starting Model Upload Process ---")
+
+    # This gets the secret token passed in from the YAML file
+    hf_token = os.environ.get("HF_TOKEN")
+    if not hf_token:
+        print("Fatal: HF_TOKEN secret not found. Make sure HF_TOKEN secret is set.")
+        sys.exit(1) # Exit with an error code
+
+    # These are standard variables provided by GitHub Actions
+    repo_owner = os.environ.get("GITHUB_REPOSITORY_OWNER")
+    repo_name_base = os.environ.get("GITHUB_REPOSITORY_NAME")
+    
+    if not repo_owner or not repo_name_base:
+        print("Fatal: Could not determine repository owner or name from GitHub environment variables.")
+        sys.exit(1)
+        
+    # --- THIS IS THE FIX ---
+    # Clean up the repo name by removing any trailing hyphens before we add our suffix.
+    repo_name_base = repo_name_base.rstrip("-")
+
+    # We will create a Hugging Face repo with a name like "your-username/your-repo-name-model"
+    repo_id = f"{repo_owner}/{repo_name_base}-model"
+    
+    print(f"Target Hugging Face repository: {repo_id}")
+
+    # Check if the model file exists before trying to upload
+    if not os.path.exists("model.joblib"):
+        print(f"Fatal: Model file 'model.joblib' not found. Please ensure train.py runs successfully first.")
+        sys.exit(1)
+
+    try:
+        # Initialize the Hugging Face API client
+        api = HfApi()
+
+        # Create the repository on the Hub. `exist_ok=True` means it won't fail if the repo is already there.
+        print(f"Ensuring repository '{repo_id}' exists on the Hub...")
+        api.create_repo(
+            repo_id=repo_id,
+            token=hf_token,
+            exist_ok=True,
+        )
+
+        # Upload the model file
+        print("Uploading 'model.joblib'...")
+        api.upload_file(
+            path_or_fileobj="model.joblib",
+            path_in_repo="model.joblib", # The name of the file on the Hub
+            repo_id=repo_id,
+            token=hf_token,
+            commit_message="Pushed baseline model from GitHub Actions"
+        )
+        print(f"✅ Model successfully pushed to https://huggingface.co/{repo_id}")
+
+    except Exception as e:
+        print(f"An error occurred during upload: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    push_model_to_hub()

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+scikit-learn
+pandas
+numpy

train.py

@@ -0,0 +1,63 @@
+#Import the libraries 
+
+import pandas as pd
+from sklearn.linear_model import LinearRegression 
+from sklearn.model_selection import train_test_split 
+from sklearn.metrics import mean_squared_error 
+import joblib
+from huggingface_hub import HfApi, HfFolder, create_repo 
+from sklearn.metrics import r2_score
+
+
+#Create a train model function 
+
+def train_model():
+
+
+#Load the data 
+
+    df = pd.read_csv("data/processed_data.csv")
+
+#Split the data into X and Y (dependent variable and parameters)
+
+    features = ['time_in_cycles','setting_1', 'setting_2'] + [f's_{i}' for i in range (1,22) if f's_{i}' in df.columns]
+
+    target = 'RUL'
+
+    X = df[features]
+    y = df[target]
+
+#Perform the train test split 
+
+    X_train, X_test, y_train, y_test = train_test_split(X,y, test_size = 0.2, random_state=42)
+
+ #Load the model - in this case from Scikit-Learn 
+
+    model = LinearRegression()
+
+
+#Train the model on the training data 
+
+    model.fit(X_train, y_train)
+
+    #evaluate the model 
+
+#Make your first prediction 
+
+    y_pred = model.predict(X_test)
+
+
+#Calculate the accuracy of the model 
+
+    r2 = r2_score(y_test, y_pred)
+
+    print(f'R_squared score is {r2}')
+
+#Save the model 
+
+    joblib.dump(model, 'model.joblib')
+
+#Ensure the function is called with the script 
+
+if __name__ == '__main__':
+    train_model()