mkdir grading_prediction_service
cd grading_prediction_service

python3 -m pip install virtualenv
python3 -m virtualenv .venv
source .venv/bin/activate

scikit-learn
pandas
numpy
fastapi
uvicorn
joblib
```


* Install these dependancies in our virtual environment


```
pip install -r requirements.txt
```


* Create a main.py file and add the following code



```
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}
```


* Start the test server and in another terminal window use curl to test our endpoint


```
uvicorn main:app --reload
```




```
curl http://127.0.0.1:8000
```


We now have our hello world endpoint!
Now we'll see how to take this to where we need it to.

* We change our code adding a pydantic data class



```
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Answer(BaseModel):
    age: int
    Medu: int
    studytime: int
    failures: int
    famrel: int
    freetime: int
    goout: int
    Walc: int
    health: int
    absences: int


@app.get("/")
async def root():
    return {"message": "Hello World"}
```


Data classes are used to validate data types when receiving data, this is what we will be receiving from the client.

Move your model.mo file to this directory

* Let's create a new post endpoint that will receive our survey data



```
from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel

app = FastAPI()

class Answer(BaseModel):
    age: int
    Medu: int
    studytime: int
    failures: int
    famrel: int
    freetime: int
    goout: int
    Walc: int
    health: int
    absences: int


@app.get("/")
async def root():
    return {"message": "Hello World"}

@app.post("/grade_predict")
async def predict_student_grade(answer: Answer):
    answer_dict = jsonable_encoder(answer)
    for key, value in answer_dict.items():
        answer_dict[key] = [value]
     # answer_dict = {k:[v] for (k,v) in jsonable_encoder(answer).items()}
    return answer_dict
```


This will receive the body data, convert it into a dictionary and then convert the values in into lists. The comment is a one liner version of the same thing using a dictionary comprehension.

* Create a file in the same directory names test_prediction.json with these values


```
{
    "age": 19,
    "Medu": 1,
    "studytime": 2,
    "failures": 1,
    "famrel": 4,
    "freetime": 2,
    "goout": 4,
    "Walc": 2,
    "health": 3,
    "absences": 0
}
```


* Test your new post endpoint with curl


```
curl --request POST \
        --data @test_prediction.json \
        http://127.0.0.1:8000/grade_predict
```


* Finally we'll load our model, convert our dictionary into a Pandas DataFrame, feed our input to the model and return the predicted result.



```
import pickle

import pandas as pd

from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel

app = FastAPI()
with open("model.mo", "rb") as f:
    model = pickle.load(f)

class Answer(BaseModel):
    age: int
    Medu: int
    studytime: int
    failures: int
    famrel: int
    freetime: int
    goout: int
    Walc: int
    health: int
    absences: int


@app.get("/")
async def root():
    return {"message": "Hello World"}

@app.post("/grade_predict")
async def predict_student_grade(answer: Answer):
    answer_dict = jsonable_encoder(answer)
    for key, value in answer_dict.items():
        answer_dict[key] = [value]
     # answer_dict = {k:[v] for (k,v) in jsonable_encoder(answer).items()}
    single_instance = pd.DataFrame.from_dict(answer_dict)
    prediction = model.predict(single_instance)
    return prediction[0]
```


* Play with your brand spanking new ML API changing the different values in test_prediction.json and using curl


```
curl --request POST \
        --data @test_prediction.json \
        http://127.0.0.1:8000/grade_predict
```


This is great and all but how about we deploy this thing to the internet?
* Install the Deta CLI


```
curl -fsSL https://get.deta.dev/cli.sh | sh
```


* Login to your account


```
deta login
```


* Create a new python micro


```
deta new --python ml_grading_service
```


This will return an endpoint which is where you will be testing your new endpoint

* Deploy your app to your micro


```
deta deploy
```


* Test your endpoint with the info given the previous endpoint


```
curl --request POST \     
        --data @test_prediction.json \
        https://XXXXX.deta.dev/grade_predict
```



That is the whole CRISP-DM process. From start to finish. I hope you learned something new or at least have a new general view of what it to takes to make a data product. There are a ton of areas where this can be improved and I would love to see comments proposing improvements.

You can check out the [repo](https://github.com/GaboGomezT/grade_prediction_service), I also added a very badly written front end using React. The demo can be found [here](https://grade-ml.web.app/) and my Kaggle kernel can be found [here](https://www.kaggle.com/gabogabe/student-grade-prediction)

[![Screen Shot 2020-11-06 at 1.38.18 AM.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1604648334841/VNheZ_SnT.png)
](https://www.buymeacoffee.com/gabogomez)