DEV Community: Ajor

Deploying Your AI/ML Models: A Practical Guide from Training to Production

Ajor — Tue, 23 Dec 2025 17:47:41 +0000

In the fast-evolving world of AI and machine learning, training models is just the beginning. To make your research impactful, you need to deploy them so others can interact with your work—whether it's for real-world applications, demos, or further experimentation. This tutorial focuses on a streamlined workflow for deploying ML/deep learning models to the cloud, wrapped in a user-friendly API. We'll keep things general so you can apply this to any AI/ML project, but I'll use my own computer vision research on fish species classification as a concrete example.

The process breaks down into these key steps:

Train your model on a platform like Kaggle.
Download the trained model.
Wrap the model in a FastAPI application for API access.
Dockerize the app for easy portability.
Deploy to the cloud.

By the end, you'll have a production-ready setup that lets users interact with your model via simple HTTP requests. Let's dive in!

Why This Workflow?

Training on Kaggle: Free GPUs/TPUs, easy dataset management, and version control for notebooks.
FastAPI: Modern, fast, and auto-generates interactive docs (Swagger UI) for your API.
Docker: Ensures consistency across environments.
Cloud Deployment: Scalable, accessible from anywhere.

This setup is ideal for researchers: Train once, deploy anywhere, and focus on innovation rather than infrastructure.

Diagram: High-Level Workflow

Here's a simple flowchart of the process:

Step 1: Training Your Model on Kaggle

Kaggle is perfect for training, especially for compute-intensive tasks like computer vision. It handles datasets, notebooks, and hardware for free.
General Steps:

Upload or Find a Dataset: Go to Kaggle Datasets and upload your data or use an existing one. Ensure it's structured (e.g., images in folders by class for classification).
Create a Notebook: Start a new notebook in Kaggle Notebooks.
Install Libraries: Use !pip install for any extras (e.g., timm for transformers).
Load and Preprocess Data: Use libraries like PyTorch or TensorFlow.
Train Models: Experiment with architectures. Save the best model using torch.save or similar.
Version and Run: Commit your notebook to save versions. Run it with GPU/TPU acceleration.
Output Artifacts: Save models, weights, and metadata (e.g., class labels as JSON).

Example: Fish Species Classification

For my research, I used a dataset of fish images (e.g., from Kaggle's "Fish Species" datasets). I trained computer vision models like DeiT (Data-efficient Image Transformer), ViT (Vision Transformer), and VGG16.

Dataset: ~12,000 images across 32 fish species
Models Trained:

DeiT: Lightweight transformer, great for efficiency.
ViT: Standard vision transformer for baseline.
VGG16: CNN classic for comparison.

Step 2: Downloading the Trained Model

Once training is done:

In your Kaggle notebook, commit and run to generate outputs.
Go to the notebook's "Output" tab and download the files (e.g., model weights and JSON).

For sharing large files, upload to Google Drive (as in my example) or GitHub.

In my case, I uploaded deit_tiny_fish_model.pth to Google Drive and used its ID for downloading in the API.

Step 3: Wrapping the Model with FastAPI

Now, turn your model into an API. FastAPI is async, type-safe, and includes auto-docs.
General Steps:

Set Up Project: Create a folder, install deps: pip install fastapi uvicorn torch timm pillow gdown.
Load Model: Handle device (CPU/GPU), download if needed.
Preprocess Inputs: Match training transforms.
Create Endpoints: /predict for inference, health checks, etc.
Add CORS: For web apps.
Run Locally: uvicorn main:app --reload.

Example Code: Generalizable API Wrapper
Here's the full code from my fish classifier, adapted to be general (replace "fish" with your domain, adjust classes/models).

import os
import io
import json
import numpy as np
import torch
import torch.nn as nn
from PIL import Image
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
import timm
import gdown

# Define device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# Model configuration (customize these)
NUM_CLASSES = 32  # Your number of classes
MODEL_PATH = os.path.join(os.path.dirname(__file__), "your_model.pth")  # e.g., deit_tiny_fish_model.pth
CLASSES_PATH = os.path.join(os.path.dirname(__file__), "classes.json")

# Download model if not exists (e.g., from Google Drive)
if not os.path.exists(MODEL_PATH):
    print("Downloading model...")
    gdown.download(id="YOUR_GOOGLE_DRIVE_ID", output=MODEL_PATH, quiet=False)

# Load class names
try:
    with open(CLASSES_PATH, "r") as f:
        class_names = json.load(f)
except Exception:
    class_names = ["class1", "class2"]  # Fallback

# Initialize model (customize for your architecture)
def create_model():
    model = timm.create_model('deit_tiny_distilled_patch16_224', pretrained=False)
    model.head = nn.Linear(model.head.in_features, NUM_CLASSES)
    model.head_dist = nn.Linear(model.head_dist.in_features, NUM_CLASSES)
    return model

# Load model
model = create_model()
model.load_state_dict(torch.load(MODEL_PATH, map_location=device, weights_only=False))
model.to(device)
model.eval()

# Preprocessing (match your training)
transform = Compose([
    Resize(224),
    CenterCrop(224),
    ToTensor(),
    Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])

# FastAPI app
app = FastAPI(title="Your ML Model API", description="API for your AI/ML model")

# CORS
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])

# Response model
class Prediction(BaseModel):
    filename: str
    predicted_class: str
    confidence: float
    top_3_predictions: list

# Preprocess function
def preprocess_image(image: Image.Image) -> torch.Tensor:
    image = image.convert("RGB")
    return transform(image).unsqueeze(0).to(device)

# Health check
@app.get("/")
async def root():
    return {"message": "API is running", "classes": len(class_names)}

# Prediction endpoint
@app.post("/predict", response_model=Prediction)
async def predict(file: UploadFile = File(...)):
    try:
        if not file.content_type.startswith('image/'):
            raise HTTPException(400, "Must be an image")
        image_data = await file.read()
        image = Image.open(io.BytesIO(image_data))
        input_tensor = preprocess_image(image)
        with torch.no_grad():
            outputs = model(input_tensor)
            probabilities = torch.nn.functional.softmax(outputs, dim=1)
            confidence, predicted_idx = torch.max(probabilities, 1)
            top_3_prob, top_3_idx = torch.topk(probabilities, 3, dim=1)
        predicted_class = class_names[predicted_idx.item()]
        top_3 = [{"class": class_names[top_3_idx[0][i].item()], "confidence": top_3_prob[0][i].item()} for i in range(3)]
        return Prediction(filename=file.filename, predicted_class=predicted_class, confidence=confidence.item(), top_3_predictions=top_3)
    except Exception as e:
        raise HTTPException(500, f"Error: {str(e)}")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

For my fish example, this API takes an image upload and returns the species with confidence. Test it locally: Upload an image to /predict via tools like Postman or the Swagger UI at /docs

Diagram: API Flow

Step 4: Dockerizing the API

Containerize for easy deployment.
General Steps:

Create Dockerfile and requirements.txt (list deps like fastapi, torch, etc.).
Build: docker build -t your-app .
Run Locally: docker run -p 8000:8000 your-app
Push to Registry: e.g., Docker Hub.

Example Dockerfile:

FROM python:3.9-slim

WORKDIR /app

RUN apt-get update && apt-get install -y git curl && rm -rf /var/lib/apt/lists/*

RUN pip install --no-cache-dir gdown

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Step 5: Deploying to Render or Railway

Both Render and Railway are excellent for deploying ML models due to their simplicity and free tiers. I’ll outline steps for both, as they’re similar but have slight differences.

Diagram: Deployment Pipeline

Conclusion

This workflow makes deploying AI/ML models straightforward, letting you focus on research. For my fish classification, it turned a Kaggle notebook into a live API in hours. Adapt it to your project—swap models, datasets, or endpoints as needed. If you build something cool, share it!
Questions? Drop a comment below. Happy deploying! 🚀

Setting Up a Backend with Prisma, Express, and PostgreSQL

Ajor — Wed, 03 Jul 2024 19:03:33 +0000

Hi,
In this post, I will go through the steps of setting up a backend using Prisma, Express, and PostgreSQL. We will cover the installation, configuration, and implementation of a REST API and basic CRUD operations.

Prerequisites

Node.js installed on your machine
PostgreSQL installed and running
Basic understanding of JavaScript and SQL

Step 1: Initialize the Project

First, create a new directory for your project and navigate into it. Then, initialize a new Node.js project.

mkdir my-backend
cd my-backend
npm init -y

Step 2: Install Dependencies

Install the necessary dependencies for Express and other packages

npm install express bcryptjs jsonwebtoken dotenv cookie-parser
npm install -D nodemon

Step 3: Set Up Prisma

npm install prisma --save-dev
npx prisma init

Step 4: Configure PostgreSQL

Update your .env file with your PostgreSQL database connection URL.

DATABASE_URL="postgresql://postgres:jondoe@localhost:5432/backendprisma?schema=public"

Update the schema.prisma file to use PostgreSQL and define your models.

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id         Int       @id @default(autoincrement())
  name       String?
  email      String    @unique
  password   String?
  post Post[]
  comment Comment[]
  created_at DateTime  @default(now())
}

model Post {
  id            Int       @id @default(autoincrement())
  user          User      @relation(fields: [user_id], references: [id], onDelete: Cascade)
  comment       Comment[]
  user_id       Int
  title         String
  description   String
  comment_count Int       @default(0)
  created_at    DateTime  @default(now())
}

model Comment {
  id         String   @id @default(uuid())
  post       Post     @relation(fields: [post_id], references: [id], onDelete: Cascade)
  post_id    Int
  user       User     @relation(fields: [user_id], references: [id], onDelete: Cascade)
  user_id    Int
  comment    String
  created_at DateTime @default(now())
}

Step 5: Migrate the Database

Run the following command to create the database tables based on your Prisma schema.

npx prisma migrate dev --name init

Step 6: Install and generate Prisma Client

npm install @prisma/client

*Step 7: Set Up Express Server
*

Create an server.js file for your Express server.

import "dotenv/config";
import cookieParser from "cookie-parser";
import express from "express";


const app = express();
const PORT = process.env.PORT || 4000;

// * Middleware
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());

app.get("/", (req, res) => {
    return res.send("Hi Everyone.");
});

// * routes file
import userRouter from "./routes/userRoutes.js"
import postRouter from "./routes/postRoutes.js"
import commentRouter from "./routes/commentRoutes.js"

app.use("/api/user", userRouter);

app.listen(PORT, () => console.log(`Server is running on PORT ${PORT}`));

*Step 8: Implement User Authentication
*

Create authentication routes and controllers.

routes/userRoutes.js

import { Router } from "express";
import {
    createUser,
    deleteUser,
    loginUser,
    logoutUser,
    updateUser
} from "../controllers/userController.js";
import { verifyJWT } from "../middleware/auth.middleware.js";

const router = Router();

router.post("/adduser", createUser);
router.post("/login", loginUser);
router.post("/logout", verifyJWT, logoutUser);
router.put("/update", verifyJWT, updateUser);
router.delete("/delete", verifyJWT,  deleteUser);

export default router;

controllers/userController.js

import prisma from "../DB/db.config.js";
import { ApiResponse } from "../utils/ApiResponse.js";
import bcrypt from "bcryptjs";
import jwt from "jsonwebtoken";

export const createUser = async (req, res) => {
  const { name, email, password } = req.body;

  try {
    // Validate that all fields are provided
    if (
      [name, email, password].some((field) => !field || field.trim() === "")
    ) {
      return res
        .status(400)
        .json(new ApiResponse(false, 400, {}, "All fields are required"));
    }

    // Check if the user already exists
    const findUser = await prisma.user.findUnique({
      where: {
        email: email,
      },
    });

    if (findUser) {
      return res
        .status(400)
        .json(
          new ApiResponse(
            false,
            400,
            {},
            "Email already taken. Please use another email."
          )
        );
    }

    // Hash the password
    const hashedPassword = await bcrypt.hash(password, 10);

    // Create the new user
    const newUser = await prisma.user.create({
      data: {
        name: name,
        email: email,
        password: hashedPassword,
      },
    });

    // Exclude password from the response
    const { password: _, ...userWithoutPassword } = newUser;

    return res
      .status(201)
      .json(
        new ApiResponse(
          true,
          201,
          userWithoutPassword,
          "User registered successfully"
        )
      );
  } catch (error) {
    console.error(error);
    return res
      .status(500)
      .json(new ApiResponse(false, 500, null, "Internal Server Error"));
  }
};

export const loginUser = async (req, res) => {
  const { email, password } = req.body;

  try {
    // Validate that all fields are provided
    if ([email, password].some((field) => !field || field.trim() === "")) {
      return res
        .status(400)
        .json(
          new ApiResponse(false, 400, {}, "Email and password are required")
        );
    }

    // Check if the user exists
    const user = await prisma.user.findUnique({
      where: {
        email: email,
      },
    });

    if (!user) {
      return res
        .status(401)
        .json(new ApiResponse(false, 401, {}, "Invalid email or password"));
    }

    // Check if the password is correct
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      return res
        .status(401)
        .json(new ApiResponse(false, 401, {}, "Invalid email or password"));
    }

    // Generate JWT access token
    const accessToken = jwt.sign(
      { userId: user.id, email: user.email },
      process.env.JWT_SECRET,
      {
        expiresIn: "1d",
      }
    );

    // Exclude password from the response
    const { password: _, ...userWithoutPassword } = user;

    // Set the access token as a cookie
    res.cookie("accessToken", accessToken, {
      httpOnly: true,
      secure: true, // Ensure secure cookies
      maxAge: 24 * 60 * 60 * 1000, // 1 day
    });

    return res
      .status(200)
      .json(
        new ApiResponse(
          true,
          200,
          { user: userWithoutPassword, accessToken },
          "Login successful"
        )
      );
  } catch (error) {
    console.error(error);
    return res
      .status(500)
      .json(new ApiResponse(false, 500, null, "Internal Server Error"));
  }
};



// update the user
export const updateUser = async (req, res) => {
  const { name, password } = req.body;

  try {
    const userId = req.user.id;

    if (!req.user) {
      return res
        .status(401)
        .json(new ApiResponse(false, 401, null, "Unauthorized request"));
    }

    const updateData = {};

    // Only add fields to updateData if they are provided
    if (name) {
      updateData.name = name;
    }

    if (password) {
      const hashedPassword = await bcrypt.hash(password, 10);
      updateData.password = hashedPassword;
    }

    if (Object.keys(updateData).length === 0) {
      return res
        .status(400)
        .json(
          new ApiResponse(false, 400, null, "No fields provided to update")
        );
    }

    const updatedUser = await prisma.user.update({
      where: {
        id: Number(userId),
      },
      data: updateData,
    });

    return res
      .status(200)
      .json(
        new ApiResponse(true, 200, updatedUser, "User updated successfully")
      );
  } catch (error) {
    console.error(error);
    return res
      .status(500)
      .json(new ApiResponse(false, 500, {}, "Internal Server Error"));
  }
};

// * Delete user
export const deleteUser = async (req, res) => {
  try {
    const userId = req.user?.id;

    if (!req.user) {
      return res
        .status(401)
        .json(new ApiResponse(false, 401, null, "Unauthorized request"));
    }

    // Attempt to delete the user
    await prisma.user.delete({
      where: {
        id: Number(userId),
      },
    });

    return res
      .status(200)
      .json(new ApiResponse(true, 200, null, "User deleted successfully"));
  } catch (error) {
    console.error(error);
    return res
      .status(500)
      .json(new ApiResponse(false, 500, null, "Internal Server Error"));
  }
};

export const logoutUser = (req, res) => {
  try {
    // Check if user is authenticated
    if (!req.user) {
      return res
        .status(401)
        .json(new ApiResponse(false, 401, null, "Unauthorized request"));
    }

    // Clear the cookie
    res.clearCookie("accessToken", {
      httpOnly: true,
      secure: false, // Set to true if using HTTPS in production
      sameSite: "strict",
    });

    return res
      .status(200)
      .json(new ApiResponse(true, 200, null, "User logged out successfully"));
  } catch (error) {
    console.error(error);
    return res
      .status(500)
      .json(new ApiResponse(false, 500, null, "Internal Server Error"));
  }
};

middleware/authMiddleware.js

import jwt from "jsonwebtoken";
import prisma from "../DB/db.config.js";
import { ApiResponse } from "../utils/ApiResponse.js";

export const verifyJWT = async (req, res, next) => {
  try {
    const token =
      req.cookies?.accessToken ||
      req.header("Authorization")?.replace("Bearer ", "");

    if (!token) {
      return res
        .status(401)
        .json(new ApiResponse(false, 401, null, "Unauthorized request"));
    }

    const decodedToken = jwt.verify(token, process.env.JWT_SECRET);
    const user = await prisma.user.findUnique({
      where: {
        id: decodedToken.userId,
      },
      select: {
        id: true,
        name: true,
        email: true,
        post: true,
        comment: true,
      },
    });

    if (!user) {
      return res
        .status(401)
        .json(new ApiResponse(false, 401, null, "Invalid Access Token"));
    }

    req.user = user;
    next();
  } catch (error) {
    return res
      .status(401)
      .json(
        new ApiResponse(
          false,
          401,
          null,
          error.message || "Invalid access token"
        )
      );
  }
};

'utils/ApiResponse.js'

class ApiResponse {
  constructor(success, status, data, message) {
    this.success = success;
    this.status = status;
    this.data = data;
    this.message = message;
  }
}

export { ApiResponse };

Please note that there might be errors in this post and provided code, so refer to the official documentation, YouTube tutorials, and the GitHub repository for the complete and error-free version.

Prisma:

Quickstart: Prisma ORM with PostgreSQL (10 min) | Prisma Documentation

Create a new TypeScript project from scratch by connecting Prisma ORM to PostgreSQL and generating a Prisma Client for database access.

prisma.io

Youtube Tutorial:

Sample-Code :

Ajor-Saha / prisma-express-postgresql

A backend and rest api set up using expressjs, prisma and postgresql database

Prisma Express PostgreSQL API

A RESTful API built with Express.js, Prisma ORM, and PostgreSQL for managing users, posts, and comments.

🚀 Live Demo

Base URL: Live Link

⚠️ Important Notice: This API is deployed on Render.com's free tier. The first request may take 30-60 seconds to respond due to cold start (server spin-up time). Subsequent requests will be faster.

API is deployed on Render

📚 API Documentation

Authentication

This API uses JWT (JSON Web Tokens) for authentication. The JWT token is stored as an HTTP-only cookie named accessToken and is automatically included in requests to protected routes.

👤 User Management

1. Register User

Endpoint: POST /api/user/adduser
Description: Register a new user account
Authentication: Not required
Request Body:

{
  "name": "John Doe",
  "email": "john@example.com",
  "password": "securepassword123"
}

Success Response (201):

{
  "success": true
  "statusCode": 201,
  "data"

…

View on GitHub