Upload 6 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+model.None filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,95 @@
+import pickle
+import pandas as pd
+import numpy as np
+import xgboost as xgb
+import gradio as gr
+import pathlib
+plt = platform.system()
+if plt == 'Linux': pathlib.WindowsPath = pathlib.PosixPath
+
+model_path = "model.None"
+model = xgb.Booster()
+model.load_model(model_path)
+
+dv_path = "dv.bin"
+with open(dv_path, 'rb') as f_out:
+    dv = pickle.load(f_out)
+    
+scaler_path = "scaler.bin"
+with open(scaler_path, 'rb') as f_out:
+    scaler = pickle.load(f_out)
+    
+def preprocess(data):
+    """Preprocessing of the data"""
+    # turn json input to dataframe
+    data = pd.DataFrame([data])
+
+    # define numerical and categorical features
+    numerical = ["X1", "X2", "X3", "X4", "X5", "X7"]
+    categorical = ["X6", "X8"]
+
+    # preprocess numerical features
+    X_num = scaler.transform(data[numerical])
+    # preprocess categorical features
+    data[categorical] = data[categorical].astype("string")
+    X_dicts = data[categorical].to_dict(orient="records")
+    X_cat = dv.transform(X_dicts)
+    # concatenate both
+    X = np.concatenate((X_num, X_cat), axis=1)
+
+    return X
+
+
+def predict(X):
+    """make predictions"""
+    pred = model.predict(X)
+    print('prediction', pred[0])
+    return float(pred[0])
+
+def main(X1,X2,X3,X4,X5,X6,X7,X8):
+    """request input, preprocess it and make prediction"""
+    input_data = {
+    "X1": X1,
+    "X2": X2,
+    "X3": X3,
+    "X4": X4,
+    "X5": X5,
+    "X6": X6,
+    "X7": X7,
+    "X8": X8
+    }
+    features = preprocess(input_data)
+    features_2 = xgb.DMatrix(features)
+    pred = predict(features_2)
+
+    result = {'heat load': pred}
+
+    return pred
+
+def classify_image(img):
+    pred,idx,probs = learn.predict(img)
+    return dict(zip(categories,map(float,probs)))
+
+#create input and output objects
+#input
+input1 = gr.inputs.Number()
+input2 = gr.inputs.Number()
+input3 = gr.inputs.Number()
+input4 = gr.inputs.Number()
+input5 = gr.inputs.Number()
+input6 = gr.inputs.Number()
+input7 = gr.inputs.Number()
+input8 = gr.inputs.Number()
+
+#output object
+output = gr.outputs.Textbox() 
+
+intf = gr.Interface(title = "Energy Efficiency",
+                    description = "The objective of this project is to predict the Heating Load based on various building features.",
+                    fn=main, 
+                    inputs=[input1,input2,input3,input4,input5,input6,input7,input8], 
+                    outputs=[output], 
+                    live=True,
+                    enable_queue=True
+                    )
+intf.launch()

dv.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eef98b808540e1d26b0de3b99d3fec1014b2086de88e3b89687974be202df9a1
+size 323

model.None

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8291f264931fb723654a8aa531e560b9f8e9a617dc0726beebcc32a93751cce9
+size 2764170

predict.ipynb

@@ -0,0 +1,160 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "import pandas as pd\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import xgboost as xgb\n",
+    "model_path = \"model.None\"\n",
+    "model = xgb.Booster()\n",
+    "model.load_model(model_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dv_path = \"dv.bin\"\n",
+    "with open(dv_path, 'rb') as f_out:\n",
+    "    dv = pickle.load(f_out)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scaler_path = \"scaler.bin\"\n",
+    "with open(scaler_path, 'rb') as f_out:\n",
+    "    scaler = pickle.load(f_out)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def preprocess(data):\n",
+    "    \"\"\"Preprocessing of the data\"\"\"\n",
+    "    # turn json input to dataframe\n",
+    "    data = pd.DataFrame([data])\n",
+    "\n",
+    "    # define numerical and categorical features\n",
+    "    numerical = [\"X1\", \"X2\", \"X3\", \"X4\", \"X5\", \"X7\"]\n",
+    "    categorical = [\"X6\", \"X8\"]\n",
+    "\n",
+    "    # preprocess numerical features\n",
+    "    X_num = scaler.transform(data[numerical])\n",
+    "    # preprocess categorical features\n",
+    "    data[categorical] = data[categorical].astype(\"string\")\n",
+    "    X_dicts = data[categorical].to_dict(orient=\"records\")\n",
+    "    X_cat = dv.transform(X_dicts)\n",
+    "    # concatenate both\n",
+    "    X = np.concatenate((X_num, X_cat), axis=1)\n",
+    "\n",
+    "    return X\n",
+    "\n",
+    "\n",
+    "def predict(X):\n",
+    "    \"\"\"make predictions\"\"\"\n",
+    "    pred = model.predict(X)\n",
+    "    print('prediction', pred[0])\n",
+    "    return float(pred[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def main(input_data):\n",
+    "    \"\"\"request input, preprocess it and make prediction\"\"\"\n",
+    "    features = preprocess(input_data)\n",
+    "    features_2 = xgb.DMatrix(features)\n",
+    "    pred = predict(features_2)\n",
+    "\n",
+    "    result = {'heat load': pred}\n",
+    "\n",
+    "    return result\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "prediction 15.648413\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'heat load': 15.648412704467773}"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "input_example = {\n",
+    "    \"X1\": 0.98,\n",
+    "    \"X2\": 514.50,\n",
+    "    \"X3\": 294.00,\n",
+    "    \"X4\": 110.25,\n",
+    "    \"X5\": 7.00,\n",
+    "    \"X6\": 2,\n",
+    "    \"X7\": 0.00,\n",
+    "    \"X8\": 0,\n",
+    "}\n",
+    "\n",
+    "main(input_example)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "mlops",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,5 @@
+mlflow<3,>=2.1
+pandas==1.5.2
+scikit-learn==1.2.0
+xgboost==1.7.2
+pickle

scaler.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0acf51e56ef2b71f5fab9f24d0c36e0d246b5832c597bdd86e2094c543a3a87
+size 710