solve readme

Dockerfile

@@ -0,0 +1,14 @@
+FROM continuumio/miniconda3
+
+WORKDIR /home/app
+
+RUN apt-get update -y 
+RUN apt-get install nano unzip curl -y
+
+COPY requirements.txt /dependencies/requirements.txt
+RUN pip install -r /dependencies/requirements.txt
+
+COPY . /home/app
+
+CMD fastapi run app.py --port $PORT
+# CMD gunicorn app:app --bind 0.0.0.0:$PORT --worker-class uvicorn.workers.UvicornWorker 

README.md

@@ -1,12 +1,9 @@
----
-title: Fast Api Demo
-emoji: 🐠
-colorFrom: blue
-colorTo: pink
-sdk: docker
-pinned: false
-license: apache-2.0
-short_description: Demo of an API built with FastAPI
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Fast API Demo App 
+
+Welcome to [Jedha](https://jedha.co) fast api demo app. Simply `git clone` this repository to checkout how to works. You can play around with it !
+
+Check out deployed app here: 
+
+* [Jedha demo api]()
+
+Enjoy 😎

app.py

@@ -0,0 +1,164 @@
+import mlflow 
+import uvicorn
+import pandas as pd 
+from pydantic import BaseModel
+from typing import Literal, List, Union
+from fastapi import FastAPI, File, UploadFile
+import joblib
+
+description = """
+Welcome to Jedha demo API. This app is made for you to understand how FastAPI works! Try it out 🕹️
+
+## Introduction Endpoints
+
+Here are two endpoints you can try:
+* `/`: **GET** request that display a simple default message.
+* `/greetings`: **GET** request that display a "hello message"
+
+## Blog Endpoints
+
+Imagine this API deals with blog articles. With the following endpoints, you can retrieve and create blog posts 
+* `/blog-articles/{blog_id}`: **GET** request that retrieve a blog article given a `blog_id` as `int`.
+* `/create-blog-article`: POST request that creates a new article
+
+## Machine Learning
+
+This is a Machine Learning endpoint that predict salary given some years of experience. Here is the endpoint:
+
+* `/predict` that accepts `floats`
+
+
+Check out documentation below 👇 for more information on each endpoint. 
+"""
+
+tags_metadata = [
+    {
+        "name": "Introduction Endpoints",
+        "description": "Simple endpoints to try out!",
+    },
+
+    {
+        "name": "Blog Endpoints",
+        "description": "More complex endpoints that deals with actual data with **GET** and **POST** requests."
+    },
+
+    {
+        "name": "Machine Learning",
+        "description": "Prediction Endpoint."
+    }
+]
+
+app = FastAPI(
+    title="🪐 Jedha Demo API",
+    description=description,
+    version="0.1",
+    contact={
+        "name": "Jedha",
+        "url": "https://jedha.co",
+    },
+    openapi_tags=tags_metadata
+)
+
+class BlogArticles(BaseModel):
+    title: str
+    content: str
+    author: str = "Anonymous Author"
+
+class PredictionFeatures(BaseModel):
+    YearsExperience: float
+
+@app.get("/", tags=["Introduction Endpoints"])
+async def index():
+    """
+    Simply returns a welcome message!
+    """
+    message = "Hello world! This `/` is the most simple and default endpoint. If you want to learn more, check out documentation of the api at `/docs`"
+    return message
+
+@app.get("/greetings", tags=["Introduction Endpoints"])
+async def greetings(name: str="Mr (or Miss) Nobody"):
+    """
+    Say hi to anybody who's specifying their name as query parameter. 
+    """
+    greetings = {
+        "Message": f"Hello {name} How are you today?"
+    }
+    return greetings
+
+
+@app.get("/blog-articles/{blog_id}", tags=["Blog Endpoints"])
+async def read_blog_article(blog_id: int):
+    """
+    Say hi to anybody who's specifying their name as query parameter. 
+
+    >👋 Careful, if you change the file using `/create-blog-article` right before, the new dataframe is not right away available, you will access a previous version. 
+    """
+
+    articles = pd.read_csv("https://full-stack-assets.s3.eu-west-3.amazonaws.com/Deployment/articles.csv")
+    if blog_id > len(articles):
+        response = {
+            "msg": "We don't have that many articles!"
+        }
+    else:
+        article = pd.read_csv("https://full-stack-assets.s3.eu-west-3.amazonaws.com/Deployment/articles.csv").iloc[blog_id, :]
+        response = {
+            "title": article.title,
+            "content": article.content, 
+            "author": article.author
+        }
+
+    return response
+
+
+@app.post("/create-blog-article", tags=["Blog Endpoints"])
+async def create_blog_article(blog_article: BlogArticles):
+    """
+    Append a new blog article into the database which is a `.csv` file. 
+    """
+    df = pd.read_csv("https://full-stack-assets.s3.eu-west-3.amazonaws.com/Deployment/articles.csv")
+    new_article = pd.Series({
+        'id': len(df)+1,
+        'title': blog_article.title,
+        'content': blog_article.content,
+        'author': blog_article.author
+    })
+
+    df = df.append(new_article, ignore_index=True)
+    df.to_csv('s3://full-stack-assets/Deployment/articles.csv')
+
+    return df.to_json()
+
+@app.post("/post-picture", tags=["Blog Endpoints"])
+async def post_picture(file: UploadFile= File(...)):
+    """
+    Upload a picture and read its file name.
+    """
+    return {"picture": file.filename}
+
+
+@app.post("/predict", tags=["Machine Learning"])
+async def predict(predictionFeatures: PredictionFeatures):
+    """
+    Prediction of salary for a given year of experience! 
+    """
+    # Read data 
+    years_experience = pd.DataFrame({"YearsExperience": [predictionFeatures.YearsExperience]})
+
+    # Log model from mlflow 
+    logged_model = 'runs:/5e54b2ee620546b0914c9e9fbfd18875/salary_estimator'
+
+    # Load model as a PyFuncModel.
+    loaded_model = mlflow.pyfunc.load_model(logged_model)
+
+    # If you want to load model persisted locally
+    #loaded_model = joblib.load('salary_predictor/model.joblib')
+
+    prediction = loaded_model.predict(years_experience)
+
+    # Format response
+    response = {"prediction": prediction.tolist()[0]}
+    return response
+
+
+if __name__=="__main__":
+    uvicorn.run(app, host="0.0.0.0", port=4000)

data/articles.csv

@@ -0,0 +1,16 @@
+id,title,content,author
+1,API,"An application programming interface (API) is a connection between computers or between computer programs. It is a type of software interface, offering a service to other pieces of software.[1] A document or standard that describes how to build or use such a connection or interface is called an API specification. A computer system that meets this standard is said to implement or expose an API. The term API may refer either to the specification or to the implementation.
+
+In contrast to a user interface, which connects a computer to a person, an application programming interface connects computers or pieces of software to each other. It is not intended to be used directly by a person (the end user) other than a computer programmer who is incorporating it into software. An API is often made up of different parts which act as tools or services that are available to the programmer. A program or a programmer that uses one of these parts is said to call that portion of the API. The calls that make up the API are also known as subroutines, methods, requests, or endpoints. An API specification defines these calls, meaning that it explains how to use or implement them.
+
+One purpose of APIs is to hide the internal details of how a system works, exposing only those parts a programmer will find useful and keeping them consistent even if the internal details later change. An API may be custom-built for a particular pair of systems, or it may be a shared standard allowing interoperability among many systems.
+
+The term API is often used to refer to web APIs,[2] which allow communication between computers that are joined by the internet. There are also APIs for programming languages, software libraries, computer operating systems, and computer hardware. APIs originated in the 1940s, though the term did not emerge until the 1960s and 70s.",Wikipedia
+2,Data Science,"Data science is an interdisciplinary field that uses scientific methods, processes, algorithms and systems to extract knowledge and insights from noisy, structured and unstructured data,[1][2] and apply knowledge and actionable insights from data across a broad range of application domains. Data science is related to data mining, machine learning and big data.
+
+Data science is a ""concept to unify statistics, data analysis, informatics, and their related methods"" in order to ""understand and analyze actual phenomena"" with data.[3] It uses techniques and theories drawn from many fields within the context of mathematics, statistics, computer science, information science, and domain knowledge. However, data science is different from computer science and information science. Turing Award winner Jim Gray imagined data science as a ""fourth paradigm"" of science (empirical, theoretical, computational, and now data-driven) and asserted that ""everything about science is changing because of the impact of information technology"" and the data deluge.[4][5]
+
+A data scientist is someone who creates programming code, and combines it with statistical knowledge to create insights from data.",Wikipedia
+3,Cybersecurity,"Cybersecurity is the practice of protecting systems, networks, and programs from digital attacks. These cyberattacks are usually aimed at accessing, changing, or destroying sensitive information; extorting money from users; or interrupting normal business processes.
+
+Implementing effective cybersecurity measures is particularly challenging today because there are more devices than people, and attackers are becoming more innovative.",Cisco

requirements.txt

@@ -0,0 +1,13 @@
+fastapi[standard]
+#uvicorn[standard]
+pydantic 
+typing 
+pandas 
+#gunicorn 
+openpyxl 
+mlflow 
+boto3 
+scikit-learn
+python-multipart
+fsspec
+s3fs

run.sh

@@ -0,0 +1,10 @@
+docker run -it \
+-v "$(pwd):/home/app" \
+-p 7860:7860 \
+-e PORT=7860 \
+-e MLFLOW_TRACKING_URI=$MLFLOW_TRACKING_URI \
+-e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID \
+-e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY \
+-e BACKEND_STORE_URI=$BACKEND_STORE_URI \
+-e ARTIFACT_ROOT=$ARTIFACT_ROOT \
+api

salary_predictor/MLProject

@@ -0,0 +1,15 @@
+name: salary_estimator
+docker_env:
+  image: jedha/salary_estimator
+  volumes: ["$(pwd):/home/app"]
+  environment: [
+    "MLFLOW_TRACKING_URI",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY",
+    "BACKEND_STORE_URI",
+    "ARTIFACT_ROOT",
+    "MLFLOW_EXPERIMENT_NAME"
+  ]
+entry_points:
+  main:
+    command: "python train.py"

salary_predictor/data/Salary_Data.csv

@@ -0,0 +1,31 @@
+YearsExperience,Salary
+1.1,39343.00
+1.3,46205.00
+1.5,37731.00
+2.0,43525.00
+2.2,39891.00
+2.9,56642.00
+3.0,60150.00
+3.2,54445.00
+3.2,64445.00
+3.7,57189.00
+3.9,63218.00
+4.0,55794.00
+4.0,56957.00
+4.1,57081.00
+4.5,61111.00
+4.9,67938.00
+5.1,66029.00
+5.3,83088.00
+5.9,81363.00
+6.0,93940.00
+6.8,91738.00
+7.1,98273.00
+7.9,101302.00
+8.2,113812.00
+8.7,109431.00
+9.0,105582.00
+9.5,116969.00
+9.6,112635.00
+10.3,122391.00
+10.5,121872.00

salary_predictor/docker/dockerfile

@@ -0,0 +1,26 @@
+FROM continuumio/miniconda3
+
+WORKDIR /home/app
+
+RUN apt-get update
+RUN apt-get install nano unzip
+RUN apt install curl -y
+
+RUN curl -fsSL https://get.deta.dev/cli.sh | sh
+
+RUN curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
+RUN unzip awscliv2.zip
+RUN ./aws/install
+
+COPY requirements.txt /dependencies/requirements.txt
+RUN pip install -r /dependencies/requirements.txt
+
+ENV AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID
+ENV AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY
+ENV BACKEND_STORE_URI=$BACKEND_STORE_URI
+ENV ARTIFACT_ROOT=$ARTIFACT_ROOT
+
+CMD mlflow server -p $PORT \
+    --host 0.0.0.0 \
+    --backend-store-uri $BACKEND_STORE_URI \
+    --default-artifact-root $ARTIFACT_ROOT

salary_predictor/docker/requirements.txt

@@ -0,0 +1,12 @@
+boto3
+pandas 
+gunicorn 
+streamlit 
+sklearn 
+matplotlib 
+seaborn 
+plotly
+mlflow
+psycopg2-binary
+jupyter
+openpyxl

salary_predictor/run.sh

@@ -0,0 +1,10 @@
+docker run -it\
+ -v "$(pwd):/home/app"\
+ -e MLFLOW_TRACKING_URI=$MLFLOW_TRACKING_URI\
+ -e PORT=4000\
+ -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID\
+ -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY\
+ -e BACKEND_STORE_URI=$BACKEND_STORE_URI\
+ -e ARTIFACT_ROOT=$ARTIFACT_ROOT\
+ -e MLFLOW_EXPERIMENT_NAME=$MLFLOW_EXPERIMENT_NAME\
+ salary_estimator

salary_predictor/train.py

@@ -0,0 +1,43 @@
+import pandas as pd
+import time
+import mlflow
+from mlflow.models.signature import infer_signature
+from sklearn.model_selection import train_test_split 
+from sklearn.linear_model import LinearRegression
+import joblib
+
+
+if __name__ == "__main__":
+
+    print("training model...")
+    
+    # Time execution
+    start_time = time.time()
+
+    # Call mlflow autolog
+    mlflow.sklearn.autolog(log_models=False) # We won't log models right away
+
+    # Import dataset
+    df = pd.read_csv("data/Salary_Data.csv")
+
+    # X, y split 
+    X = df.loc[:, ["YearsExperience"]]
+    y = df.loc[:, ["Salary"]]
+
+    # Train / test split 
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3)
+
+    # Log experiment to MLFlow
+    with mlflow.start_run() as run:
+        model = LinearRegression()
+        model.fit(X_train, y_train)
+        predictions = model.predict(X_train)
+
+        # Log model seperately to have more flexibility on setup 
+        mlflow.sklearn.log_model(sk_model=model, artifact_path="salary_estimator")
+
+    # If you want to persist model locally
+    #joblib.dump(model, "model.joblib")
+
+    print("...Done!")
+    print(f"---Total training time: {time.time()-start_time}")

secrets.sh

@@ -0,0 +1,6 @@
+export MLFLOW_EXPERIMENT_NAME="salary_estimator";
+export MLFLOW_TRACKING_URI="MLFLOW_TRACKING_URI";
+export AWS_ACCESS_KEY_ID="AWS_ACCESS_KEY_ID";
+export AWS_SECRET_ACCESS_KEY="AWS_SECRET_ACCESS_KEY";
+export BACKEND_STORE_URI="BACKEND_STORE_URI";
+export ARTIFACT_ROOT="ARTIFACT_ROOT";

test.py

@@ -0,0 +1,10 @@
+import requests
+payload = {
+  "title": "This is my great blog title",
+   "content": "This is the body of my article",
+   "Author": "Jaskier"
+}
+r = requests.post("http://localhost:4000/predict", json={
+  "YearsExperience": 0
+})
+print(r.content)

test_heroku.py

@@ -0,0 +1,10 @@
+import requests
+payload = {
+  "title": "This is my great blog title",
+   "content": "This is the body of my article",
+   "Author": "Jaskier"
+}
+r = requests.post("https://aurelie-fast-api.herokuapp.com/predict", json={
+  "YearsExperience": 0
+})
+print(r.content)