{"id":509778,"date":"2024-09-19T09:59:08","date_gmt":"2024-09-19T08:59:08","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=pycharm&p=509778"},"modified":"2026-03-11T15:57:19","modified_gmt":"2026-03-11T14:57:19","slug":"how-to-use-fastapi-for-machine-learning","status":"publish","type":"pycharm","link":"https:\/\/blog.jetbrains.com\/es\/pycharm\/2024\/09\/how-to-use-fastapi-for-machine-learning","title":{"rendered":"How to Use FastAPI for Machine Learning"},"content":{"rendered":"\n
\"How<\/figure>\n\n\n\n

FastAPI provides a quick way to build a backend service with Python. With a few decorators, you can turn your Python function into an API application. <\/p>\n\n\n\n

It is widely used by many companies including Microsoft, Uber, and Netflix. According to the Python Developers Survey<\/a>, FastAPI usage has grown from 21% in 2021 to 29% in 2023. For data scientists, it’s the second most popular framework, with 31% using it. <\/p>\n\n\n\n

In this blog post, we will cover the basics of FastAPI for data scientists who may want to build a quick prototype for their project. <\/p>\n\n\n\n

What is FastAPI?<\/h2>\n\n\n\n

FastAPI is a popular web framework for building APIs with Python, based on standard Python type hints. It is intuitive and easy to use, and it can provide a production-ready application in a short period of time. It is fully compatible with OpenAPI<\/a> and JSON Schema<\/a>.<\/p>\n\n\n\n

Why use FastAPI for machine learning?<\/h2>\n\n\n\n

Most teams working on machine learning projects consist of data scientists whose domains and professions lie on the statistics side of things. They may not have experience developing software or applications to ship their machine learning projects. FastAPI enables data scientists to easily create APIs for the following projects:<\/p>\n\n\n\n

Deploying prediction models<\/strong><\/p>\n\n\n\n

The data science team may have trained a model for the prediction of the sales demand in a warehouse. To make it useful, they have to provide an API interface so other parts of the stock management system can use this new prediction functionality.<\/p>\n\n\n\n

Suggestion engines<\/strong><\/p>\n\n\n\n

One of the very common uses of machine learning is as a system that provides suggestions based on the users’ choices. For example, if someone puts certain products in their shopping cart, more items can be suggested to that user. Such an e-commerce system requires an API call to the suggestion engine that takes input parameters.<\/p>\n\n\n\n

Dynamic dashboards and reporting systems<\/strong><\/p>\n\n\n\n

Sometimes, reports for data science projects need to be presented as dashboards so users can inspect the results themselves. One possible approach is to have the data model provide an API. Frontend developers can use this API to create applications that allow users to interact with the data.<\/p>\n\n\n\n

Advantages of using FastAPI<\/h2>\n\n\n\n

Compared to other Python web frameworks<\/a>, FastAPI is simple yet fully functional. Mainly using decorators and type hints, it allows you to build a web application without the complexity of building a whole ORM (object-relational mapping<\/a>) model and with the flexibility of using any database<\/a>, including any SQL and NoSQL databases. FastAPI also provides automatic documentation generation, support for additional information and validation for query parameters, and good async support.<\/p>\n\n\n\n

Fast development<\/strong><\/p>\n\n\n\n

Creating API calls in FastAPI is as easy as adding decorators in the Python code. Little to no backend experience is needed for anyone who wants to turn a Python function into an application that will respond to API calls.<\/p>\n\n\n\n

Fast documentation<\/strong><\/p>\n\n\n\n

FastAPI provides automatic interactive API documentation using Swagger UI<\/a>, which is an industry standard. No extra effort is required to build clear documentation with API call examples. This creates an advantage for busy data science teams who may not have the energy and expertise to write technical specifications and documentation.<\/p>\n\n\n\n

Easy testing<\/strong><\/p>\n\n\n\n

Writing tests is one of the most important steps in software development, but it can also be one of the most tedious, especially when the time of the data science team is valuable. Testing FastAPI is made simple thanks to Starlette<\/a> and HTTPX<\/a>. Most of the time no monkey patching is needed and tests are easy to write and understand.<\/p>\n\n\n\n

Fast deployment<\/strong><\/p>\n\n\n\n

FastAPI comes with a CLI tool<\/a> that can bridge development and deployment<\/a> smoothly. It allows you to switch between development mode and production mode easily. Once development is completed, the code can be easily deployed using a Docker container<\/a> with images that have Python prebuilt.<\/p>\n\n\n\n

How to use FastAPI for a machine learning project<\/h2>\n\n\n\n

In this example, we will turn a classification prediction model that uses the Nearest Neighbors algorithm<\/a> to predict the species of various penguins based on their bill and flipper length into a backend application. We will provide an API that takes parameters from the query parameters of a URL and gives back the prediction. This shows how a prototype can be made quickly by any data scientist with no backend development experience.<\/p>\n\n\n\n

We will use a simple `KNeighborsClassifier<\/a>` on the penguin data set<\/a> as an example. Details of how to build the model will be omitted, but feel free to check out the relevant notebook here<\/a>. In the following tutorial, we will focus on the usage of FastAPI and explain some fundamental concepts. We will be building a prototype to do so. <\/p>\n\n\n\n

1. Start a FastAPI project with PyCharm
<\/strong><\/h3>\n\n\n\n

In this blog post, we will be using PyCharm Professional 2024.1. The best way to start using FastAPI is to create a FastAPI project with PyCharm<\/a>. When you click New Project<\/em> in PyCharm, you will be presented with a large selection of projects to choose from. Select the FastAPI<\/em> tab:



From here, you can put in the name of your project and take advantage of other options such as initializing Git and the virtual environment that you want to use.

After doing so, you will see the basic structure of a FastAPI project set up for you.



There is also a `test_main.http<\/code>` file set up for you to quickly test all the endpoints.


<\/p>\n\n\n\n

2. Set up environment dependencies<\/strong><\/h3>\n\n\n\n

Next, set up our environment dependency with `requirements.txt<\/code>` by selecting \u200b\u200bSync Python Requirements<\/em><\/a> under PyCarm\u2019s Tool<\/em> menu.



Then you can select the `requirements.txt<\/code>` file to be used.



You can copy and use this `requirements.txt<\/a>` file. We will be using pandas and scikit-learn for the machine learning part of the project. Also, add the `penguins.csv<\/a>` file to your project directory.<\/p>\n\n\n\n

3. Set up your machine learning model<\/strong><\/h3>\n\n\n\n

Arrange your machine learning code in the `main.py<\/code>` file. We will start with a script that trains our model:<\/p>\n\n\n\n

import pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import preprocessing\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import StandardScaler\n\ndata = pd.read_csv('penguins.csv')\ndata = data.dropna()\n\nle = preprocessing.LabelEncoder()\nX = data[[\"bill_length_mm\", \"flipper_length_mm\"]]\nle.fit(data[\"species\"])\ny = le.transform(data[\"species\"])\nX_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=0)\nclf = Pipeline(\n    steps=[(\"scaler\", StandardScaler()), (\"knn\", KNeighborsClassifier(n_neighbors=11))]\n)\nclf.set_params().fit(X_train, y_train)<\/pre>\n\n\n\n
We can place the above code after `app = FastAPI()<\/code>`. All of it will be run when we start the application.



However, there is a better way to run the start-up code we used to set up our model. We will cover that in a later part of the blog post<\/a>.<\/p>\n\n\n\n
4. Request a response<\/strong><\/h3>\n\n\n\n
Next we will look at how to add our model to FastAPI functionality. As a first step, we will add a response to the root of the URL and just simply return a message about our model in JSON format. Change the code in `async def root():<\/code>` from \u201cHello world\u201d to our message like this:<\/p>\n\n\n\n
@app.get(\"\/\")\nasync def root():\n    return {\n        \"Name\": \"Penguins Prediction\",\n        \"description\": \"This is a penguins prediction model based on the bill length and flipper length of the bird.\",\n    }<\/pre>\n\n\n\n
Now, test our application. First, we will start our application, which is easy in PyCharm. Just press the arrow button () next to your project name at the top.



If you are using the default settings, your application will run on http:\/\/127.0.0.1:8000<\/a>. You can double-check that by looking at the prompt from the Run <\/em>window.

<\/p>\n\n\n\n
Once the process has started, let\u2019s go to `test_main.http<\/code>` and press the first arrow button () next to `GET<\/code>`. From the HTTP Client<\/a> in the Services <\/em>window, you will see the response message that we put in.



The response JSON file is also saved for future inspection.<\/p>\n\n\n\n
5. Request with query parameters<\/strong><\/h3>\n\n\n\n
Next, we would like to let users make predictions by providing query parameters<\/a> in the URL. Let\u2019s add the code below after the `root<\/code>` function.<\/p>\n\n\n\n
@app.get(\"\/predict\/\")\nasync def predict(bill_length_mm: float = 0.0, flipper_length_mm: float = 0.0):\n    param = {\n                \"bill_length_mm\": bill_length_mm,\n                \"flipper_length_mm\": flipper_length_mm\n            }\n    if bill_length_mm <=0.0 or flipper_length_mm <=0.0:\n        return {\n            \"parameters\": param,\n            \"error message\": \"Invalid input values\",\n        }\n    else:\n        result = clf.predict([[bill_length_mm, flipper_length_mm]])\n        return {\n            \"parameters\": param,\n            \"result\": le.inverse_transform(result)[0],\n        }<\/pre>\n\n\n\n
Here we set the default value of the `bill_length_mm<\/code>` and `flipper_length_mm<\/code>` to be 0 if the user didn\u2019t input a value. We also add a check to see if either of the values is 0 and return an error message instead of trying to predict which penguin the input refers to.

If the inputs are not 0, we will use the model to make a prediction and use the encoder to do an inverse transformation to get the label of the predicted target, i.e. the name of the penguin species.

This is not the only way you can verify inputs. You can also consider using Pydantic<\/a> for input verification.<\/p>\n\n\n\n
If you are using the same version of FastAPI as stated in `requirements.txt<\/code>`, FastAPI automatically refreshes the service and applies changes on save. Now put in a new URL in `test_main.http<\/code>` to test (separated from the URL before with ###):<\/p>\n\n\n\n
###\n\nGET http:\/\/127.0.0.1:8000\/predict\/?bill_length_mm=40.3&flipper_length_mm=195\nAccept: application\/json<\/pre>\n\n\n\n
Press the arrow button () next to our new URL and see the output.



Next you can try a URL with one or both of the parameters removed to see the error message:<\/p>\n\n\n\n
###\n\nGET http:\/\/127.0.0.1:8000\/predict\/?bill_length_mm=40.3\nAccept: application\/json<\/pre>\n\n\n\n

<\/p>\n\n\n\n
6. Set up a machine learning model with lifespan events<\/strong><\/h3>\n\n\n\n
Last, let\u2019s look at how we can set up our model with FastAPI lifespan events<\/a>. The advantage of doing that is we can make sure no request will be accepted while the model is still being set up and the memory used will be cleaned up afterward. To do that, we will use an `asynccontextmanager<\/a>`. Before `app = FastAPI()<\/code>` we will add:<\/p>\n\n\n\n
from contextlib import asynccontextmanager\n\nml_models = {}\n\n@asynccontextmanager\nasync def lifespan(app: FastAPI):\n    # Set up the ML model here\n    \n    yield\n    # Clean up the models and release resources\n\n\n    ml_models.clear()<\/pre>\n\n\n\n
Now we will move the import of pandas and scikit-learn to be alongside the other imports. We will also move our setup code inside the `lifespan<\/code>` function, setting the machine learning model and LabelEncoder<\/em> inside `ml_models<\/code>` like this:<\/p>\n\n\n\n
from fastapi import FastAPI\nfrom contextlib import asynccontextmanager\n\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import preprocessing\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import StandardScaler\n\nml_models = {}\n\n@asynccontextmanager\nasync def lifespan(app: FastAPI):\n    # Set up the ML model here\n\n    data = pd.read_csv('penguins.csv')\n    data = data.dropna()\n\n    le = preprocessing.LabelEncoder()\n    X = data[[\"bill_length_mm\", \"flipper_length_mm\"]]\n    le.fit(data[\"species\"])\n    y = le.transform(data[\"species\"])\n    X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=0)\n    clf = Pipeline(\n        steps=[(\"scaler\", StandardScaler()), (\"knn\", KNeighborsClassifier(n_neighbors=11))]\n    )\n    clf.set_params().fit(X_train, y_train)\n\n    ml_models[\"clf\"] = clf\n    ml_models[\"le\"] = le\n\n    yield\n    # Clean up the models and release resources\n\n    ml_models.clear()<\/pre>\n\n\n\n
After that we will add the `lifespan=lifespan<\/code>` parameter in `app = FastAPI()<\/code>`:<\/p>\n\n\n\n
app = FastAPI(lifespan=lifespan)<\/pre>\n\n\n\n
Now save and test again. Everything should work and we should see the same result as before.<\/p>\n\n\n\n
Afterthought: When to train the model?<\/h3>\n\n\n\n
From our example, you may wonder when the model is trained. Since `clf<\/code>` is trained at the beginning, i.e. when the service is launched, you may wonder why we do not train the model every time someone makes a prediction.<\/p>\n\n\n\n
We do not want the model to be trained every time someone makes a call, because it costs way more resources to re-train everything. Additionally, it may cause race conditions since our FastAPI application is working concurrently. This is especially the case if we use live data that changes all the time.<\/p>\n\n\n\n
Technically, we can set up an API to collect data and re-train the model (which we will demonstrate in the next example). Other options would be to schedule a re-train at a certain time when a certain amount of new data has been collected or to let a super user upload new data and trigger the re-training.<\/p>\n\n\n\n
So far, we are aiming to build a prototype that runs locally. Check out this article on deploying a FastAPI project<\/a> on a cloud service for more information.<\/p>\n\n\n\n
What is concurrency?<\/h4>\n\n\n\n
To put it simply, concurrency is like when you are cooking in the kitchen, and while waiting for the water to boil, you go ahead and chop the vegetables. Since, in the web service world, the server is talking to many terminals, and the communication between the server and the terminals is slower than most internal applications, so the server will not talk to and serve the terminals one by one. Instead, it will talk to and serve many of them at the same time while fulfilling their requests. You may want to check out this explanation<\/a> in the FastAPI documentation.<\/p>\n\n\n\n
In Python, this is achieved by using async code. In our FastAPI code, the use of `async def<\/code>` instead of `def<\/code>` is obvious evidence that FastAPI is working concurrently. There are other keywords used in Python async code, like `await<\/code>` and `asyncio.get_event_loop<\/code>`, but we won\u2019t be able to cover them in this blog post. <\/p>\n\n\n\n
How to use FastAPI for an image classification project<\/h2>\n\n\n\n
To discover more FastAPI functionality, we will add an image classification model based on the MNIST example<\/a> in Keras to our application as well (we are using the TensorFlow backend). If you installed the `requirements.txt<\/code>` provided, you should have Keras and Pillow installed for image processing and building a convolutional neural network (CNN)<\/a>.<\/p>\n\n\n\n
1. Refactoring<\/strong><\/h3>\n\n\n\n
Before we start, let\u2019s refactor our code. To make the code more organized, we will put the model setup for the penguins prediction in a function:<\/p>\n\n\n\n
def penguins_pipeline():\n    data = pd.read_csv('penguins.csv')\n    data = data.dropna()\n\n    le = preprocessing.LabelEncoder()\n    X = data[[\"bill_length_mm\", \"flipper_length_mm\"]]\n    le.fit(data[\"species\"])\n    y = le.transform(data[\"species\"])\n    X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=0)\n    clf = Pipeline(\n        steps=[(\"scaler\", StandardScaler()), (\"knn\", KNeighborsClassifier(n_neighbors=11))]\n    )\n    clf.set_params().fit(X_train, y_train)\n\n    return clf, le<\/pre>\n\n\n\n
Then we rewrite the lifespan function. With full-line code completion<\/a> in PyCharm, it is very easy:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
2. Set up a CNN model for MNIST prediction<\/strong><\/h3>\n\n\n\n
In similar fashion as the penguin prediction model, we create a function for MNIST<\/a> prediction (and we will store the meta parameters globally):<\/p>\n\n\n\n
# MNIST model meta parameters\nnum_classes = 10\ninput_shape = (28, 28, 1)\nbatch_size = 128\nepochs = 15\n\ndef mnist_pipeline():\n    # Load the data and split it between train and test sets\n    (x_train, y_train), _ = keras.datasets.mnist.load_data()\n\n    # Scale images to the [0, 1] range\n    x_train = x_train.astype(\"float32\") \/ 255\n\n    # Make sure images have shape (28, 28, 1)\n    x_train = np.expand_dims(x_train, -1)\n\n    # convert class vectors to binary class matrices\n    y_train = keras.utils.to_categorical(y_train, num_classes)\n\n    model = keras.Sequential(\n        [\n            keras.Input(shape=input_shape),\n            layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\"),\n            layers.MaxPooling2D(pool_size=(2, 2)),\n            layers.Conv2D(64, kernel_size=(3, 3), activation=\"relu\"),\n            layers.MaxPooling2D(pool_size=(2, 2)),\n            layers.Flatten(),\n            layers.Dropout(0.5),\n            layers.Dense(num_classes, activation=\"softmax\"),\n        ]\n    )\n\n    model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n\n    model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)\n\n    return model<\/pre>\n\n\n\n
Then add the model setup in the lifespan function:<\/p>\n\n\n\n
ml_models[\"cnn\"] = mnist_pipeline()<\/pre>\n\n\n\n
Note that since this is added, every time you make changes to `main.py<\/code>` and save, the model will be trained again. It can take a bit of time. So in development you may want to use a dummy model that requires no training time at all or a pre-trained model instead. After training, the CNN model will be ready to go.<\/p>\n\n\n\n
3. Set up a POST<\/code> endpoint for uploading an image file for prediction<\/strong><\/h3>\n\n\n\n
To set up an endpoint that takes an upload file, we have to use UploadFile in FastAPI<\/a>:<\/p>\n\n\n\n
@app.post(\"\/predict-image\/\")\nasync def predicct_upload_file(file: UploadFile):\n    img = await file.read()\n    \n    # process image for prediction\n    img = Image.open(BytesIO(img)).convert('L')\n    img = np.array(img).astype(\"float32\") \/ 255\n    img = np.expand_dims(img, (0, -1))\n    \n    # predict the result\n    result = ml_models[\"cnn\"].predict(img).argmax(axis=-1)[0]\n    return {\"filename\": file.filename,\n            \"result\": str(result)}<\/pre>\n\n\n\n
Please note that this is a POST<\/code> endpoint (so far we have only set up GET<\/code> endpoints).<\/p>\n\n\n\n
Don\u2019t forget to import `UploadFile<\/code>` from `fastapi<\/code>`:<\/p>\n\n\n\n
from fastapi import FastAPI, UploadFile<\/pre>\n\n\n\n
And `Image<\/code>` from Pillow. We are also using `BytesIO<\/code>` from the `io<\/code>` module:<\/p>\n\n\n\n
from PIL import Image\nfrom io import BytesIO<\/pre>\n\n\n\n
To test this using the PyCharm HTTP Client with a test image file<\/a>, we will make use of the `multipart\/form-data<\/code>` encoding. You can check out the HTTP request syntax here<\/a>. This is what you will put in the `test_in.http<\/code>` file:<\/p>\n\n\n\n
###\n\nPOST http:\/\/127.0.0.1:8000\/predict-image\/ HTTP\/1.1\nContent-Type: multipart\/form-data; boundary=boundary\n\n--boundary\nContent-Disposition: form-data; name=\"file\"; filename=\"test_img0.png\"\n\n< .\/test_img0.png\n\n--boundary\u2013<\/pre>\n\n\n\n
4. Add an API to collect data and trigger retraining<\/strong><\/h3>\n\n\n\n
Now, here comes the retraining. We set up a POST<\/code> endpoint like above to accept a zip file which contains training images and labels. The zip file will then be processed and the training data will be prepared. After that we will fit the CNN model again:<\/p>\n\n\n\n
@app.post(\"\/upload-images\/\")\nasync def retrain_upload_file(file: UploadFile):\n\n    img_files = []\n    labels_file = None\n    train_img = None\n\n    with ZipFile(BytesIO(await file.read()), 'r') as zfile:\n        for fname in zfile.namelist():\n            if fname[-4:] == '.txt' and fname[:2] != '__':\n                labels_file = fname\n            elif fname[-4:] == '.png':\n                img_files.append(fname)\n\n        if len(img_files) == 0:\n            return {\"error\": \"No training images (png files) found.\"}\n        else:\n            for fname in sorted(img_files):\n                with zfile.open(fname) as img_file:\n                    img = img_file.read()\n\n                    # process image\n                    img = Image.open(BytesIO(img)).convert('L')\n                    img = np.array(img).astype(\"float32\") \/ 255\n                    img = np.expand_dims(img, (0, -1))\n\n                    if train_img is None:\n                        train_img = img\n                    else:\n                        train_img = np.vstack((train_img, img))\n\n        if labels_file is None:\n            return {\"error\": \"No training labels file (txt file) found.\"}\n        else:\n            with zfile.open(labels_file) as labels:\n                labels_data = labels.read()\n                labels_data = labels_data.decode(\"utf-8\").split()\n                labels_data = np.array(labels_data).astype(\"int\")\n                labels_data = keras.utils.to_categorical(labels_data, num_classes)\n\n    # retrain model\n    ml_models[\"cnn\"].fit(train_img, labels_data, batch_size=batch_size, epochs=epochs, validation_split=0.1)\n\n    return {\"message\": \"Model trained successfully.\"}<\/pre>\n\n\n\n
Remember to import `ZipFile<\/code>`:<\/p>\n\n\n\n
from zipfile import ZipFile<\/pre>\n\n\n\n
If we now try the endpoint with this zip file of 1000 retraining images and labels, <\/a>you will see that it takes a moment for the response to come, as the training is taking a while:<\/p>\n\n\n\n
POST http:\/\/127.0.0.1:8000\/upload-images\/ HTTP\/1.1\nContent-Type: multipart\/form-data; boundary=boundary\n\n--boundary\nContent-Disposition: form-data; name=\"file\"; filename=\"training_data.zip\"\n\n< .\/retrain_img.zip\n\n--boundary--<\/pre>\n\n\n\n
Imagine the zip files contain more training data or you\u2019re retraining a more complicated model. The user would then have to wait for a long time and it would seem like things are not working for them.<\/p>\n\n\n\n
5. Retrain the model with BackgroundTasks<\/code><\/strong><\/h3>\n\n\n\n
A better way to handle retraining is, after receiving the training data, we process it and check if the data is in the right format, then give a response saying that the retraining has restarted and train the model in `BackgroundTasks<\/a>`. Here is how to do it. First, we will add `BackgroundTasks<\/code>` to our `upload-images` endpoint:<\/p>\n\n\n\n
@app.post(\"\/upload-image\/\")\nasync def retrain_upload_file(file: UploadFile, background_tasks: BackgroundTasks):\n\t...<\/pre>\n\n\n\n
Remember to import it from `fastapi<\/code>`:<\/p>\n\n\n\n
from fastapi import FastAPI, UploadFile, BackgroundTasks<\/pre>\n\n\n\n
Then, we will put the fitting of the model into the `background_tasks<\/code>`:<\/p>\n\n\n\n
# retrain model\n    background_tasks.add_task(\n        ml_models[\"cnn\"].fit,\n        train_img,\n        labels_data,\n        batch_size=batch_size,\n        epochs=epochs,\n        validation_split=0.1\n    )<\/pre>\n\n\n\n
Also, we will update the message in the response:<\/p>\n\n\n\n
return {\"message\": \"Data received successfully, model training has started.\"}<\/pre>\n\n\n\n
Now test the endpoint again. You will see that the response has arrived much quicker, and if you look at the Run <\/em>window, you\u2019ll see that the training is running after the response has arrived.

At this point, more functionality can be added, for example, an option to notify the user later (e.g. via email) when the training is finished or track the training progress in a dashboard when a full application is built.<\/p>\n\n\n\n
Conclusion and next steps<\/h2>\n\n\n\n
In this tutorial, we walked through how FastAPI can be used to turn machine learning models into usable APIs with minimal overhead. Starting from a simple classification model, we built GET and POST endpoints, handled input validation, managed model lifecycles with lifespan events, and explored more advanced workflows like image classification and background retraining tasks.<\/p>\n\n\n\n
This approach shows why FastAPI is such a strong fit for data science teams. It allows you to move quickly from experimentation to a working prototype, without needing deep backend expertise, while still following production-ready patterns.<\/p>\n\n\n\n
If you want to take this prototype further, here are some logical next steps:<\/p>\n\n\n\n