updated 1

README.md

@@ -1,17 +1,91 @@
 # Linear Regression Model
 
-This model provides two main functions:
-1. **Retrieve Coefficients and Intercept**: Return the model's coefficients and intercept based on input column names.
-2. **Predict Values**: Given column names and data values, return predictions.
+This repository hosts a simple linear regression model. The model provides two primary functions:
+1. **Retrieve Coefficients and Intercept**: Given column names, the model will return its coefficients and intercept.
+2. **Predict Values from CSV**: Given column names and a CSV file with data, the model will use the data to predict values.
+
+## Model Files
+
+- `linear_regression_model.joblib`: The trained linear regression model, saved with joblib.
+- `model.py`: Contains the model class and custom Hugging Face pipeline for processing inputs and returning outputs.
 
 ## Usage
 
 ### 1. Retrieve Coefficients and Intercept
-Send a JSON payload with just column names:
 
+Send a JSON payload with just column names to retrieve the model’s coefficients and intercept.
+
+**Input JSON Example**:
 ```json
 {
   "inputs": {
     "columns": ["feature1", "feature2", "feature3"]
   }
 }
+```
+
+**Response JSON Example**:
+```json
+{
+  "coefficients": {"feature1": 0.5, "feature2": -1.2, "feature3": 2.3},
+  "intercept": 0.1
+}
+```
+
+### 2. Predict Values from CSV
+
+Send a request with column names and a CSV file containing data for prediction. The model will use the data in the specified columns to make predictions.
+
+- **Columns**: A JSON list of strings specifying the column names used in the model.
+- **CSV File**: A file containing the data rows, uploaded as binary content.
+
+**Python Example Using `requests`**:
+
+```python
+import requests
+
+url = "https://api-inference.huggingface.co/models/your-username/linear-regression-model"
+headers = {"Authorization": "Bearer YOUR_HUGGINGFACE_API_TOKEN"}
+
+# Define the columns and open the CSV file in binary mode
+columns = ["feature1", "feature2", "feature3"]
+files = {
+    "inputs": ("data.csv", open("path/to/your/data.csv", "rb")),
+    "columns": (None, str(columns))  # Send columns as JSON string
+}
+
+response = requests.post(url, headers=headers, files=files)
+print(response.json())
+```
+
+**curl Example**:
+
+```bash
+curl -X POST "https://api-inference.huggingface.co/models/your-username/linear-regression-model" \
+     -H "Authorization: Bearer YOUR_HUGGINGFACE_API_TOKEN" \
+     -F "columns=['feature1', 'feature2', 'feature3']" \
+     -F "inputs=@path/to/your/data.csv"
+```
+
+**Response JSON Example**:
+```json
+{
+  "predictions": [10.5, 15.8, 12.3]
+}
+```
+
+### 3. File Structure
+
+The main files in this repository:
+
+- `linear_regression_model.joblib`: Contains the trained linear regression model.
+- `model.py`: Model and pipeline definitions, handling CSV input and returning predictions or coefficients.
+- `README.md`: This file, explaining model functionality and usage.
+
+### Notes
+
+1. Ensure your CSV file includes the specified columns for accurate predictions.
+2. The CSV file is temporarily saved and used for predictions. It will not be stored permanently.
+3. Your API token is required to authenticate requests. 
+
+This setup allows users to choose between retrieving coefficients or making predictions based on CSV data for more flexibility.

model.py

@@ -1,5 +1,6 @@
 # model.py
 import joblib
+import pandas as pd
 from typing import List, Dict, Union
 from transformers import Pipeline
 
@@ -14,8 +15,9 @@ class LinearRegressionModel:
         intercept = self.model.intercept_
         return {"coefficients": coefficients, "intercept": intercept}
 
-    def predict(self, columns: List[str], data: List[List[float]]) -> List[float]:
-        # Predict values for given input data
+    def predict_from_csv(self, columns: List[str], csv_file_path: str) -> List[float]:
+        # Read the CSV file and select specified columns
+        data = pd.read_csv(csv_file_path)[columns]
         return self.model.predict(data).tolist()
 
 # Instantiate the model
@@ -27,14 +29,20 @@ class CustomLinearRegressionPipeline(Pipeline):
         super().__init__()
         self.model = model
 
-    def __call__(self, inputs: Dict[str, Union[List[str], List[List[float]]]]) -> Dict[str, Union[Dict[str, float], List[float]]]:
+    def __call__(self, inputs: Dict[str, Union[List[str], bytes]]) -> Dict[str, Union[Dict[str, float], List[float]]]:
         columns = inputs.get("columns", [])
-        data = inputs.get("data", [])
+        csv_file = inputs.get("csv_file", None)  # Expect a CSV file in binary format
         
-        if not data:  # If no data, return coefficients and intercept
+        if not csv_file:  # If no CSV file, return coefficients and intercept
             return self.model.get_coefficients(columns)
-        else:  # If data is provided, return predictions
-            return {"predictions": self.model.predict(columns, data)}
+        else:  # If CSV file is provided, save and process it for predictions
+            csv_file_path = "/tmp/input_data.csv"  # Temporary path to save the CSV file
+            with open(csv_file_path, "wb") as f:
+                f.write(csv_file)
+
+            # Make predictions from CSV file
+            predictions = self.model.predict_from_csv(columns, csv_file_path)
+            return {"predictions": predictions}
 
 # Instantiate the custom pipeline
 pipeline = CustomLinearRegressionPipeline(model)

request.py

@@ -0,0 +1,14 @@
+import requests
+
+url = "https://api-inference.huggingface.co/models/your-username/linear-regression-model"
+headers = {"Authorization": "Bearer YOUR_HUGGINGFACE_API_TOKEN"}
+
+# Define the columns and open the CSV file in binary mode
+columns = ["feature1", "feature2", "feature3"]
+files = {
+    "inputs": ("data.csv", open("path/to/your/data.csv", "rb")),
+    "columns": columns
+}
+
+response = requests.post(url, headers=headers, files=files)
+print(response.json())