DEV Community: Ishwor Subedi

Your Eyes Weren't Built for an 8-Hour Stare Contest With a Monitor — Here's What the Research Actually Says

Ishwor Subedi — Fri, 21 Aug 2026 16:06:38 +0000

Digital eye strain isn't just "tired eyes." I dug into the studies, then built an open-source tool around the one part of the problem a webcam can actually fix.

Somewhere between your second cup of coffee and your fourth hour of debugging, your eyes start to feel gritty. You blame the lighting, the screen brightness, maybe your last eye exam. What you probably don't blame — because it's invisible to you while it's happening — is that you've simply stopped blinking normally.

That single fact turned out to be well-documented, mechanistically simple, and almost entirely fixable with awareness. Here's what I found while researching it, and what I ended up building because of it.

What actually happens to your eyes on a screen

A normal blink does two things: it spreads a fresh layer of tear film across the surface of your eye, and it clears debris. Under normal conditions, we blink around 15–20 times a minute without thinking about it.

Put a screen in front of a human and something measurable changes. Reviews of digital eye strain point to altered blinking behavior — specifically reduced frequency and incomplete blinks (where the eyelid doesn't fully close) — as a real, recurring factor during prolonged digital device use. The mechanism is straightforward: fewer and shallower blinks mean longer gaps where the tear film is left exposed, and it can start to break up before the next blink arrives. That breakup is what produces the dryness and burning sensation associated with digital eye strain.

This isn't a fringe theory. A randomized controlled trial specifically tested blink-reminder software against a control group of visual display terminal users and found measurable improvements in both blink rate and dry-eye symptom scores in the group that got reminders. In other words: the intervention isn't just "sit less," it's specifically "blink more, on purpose," and that alone moved the needle in a controlled study.

Why this is a genuinely hard problem to self-monitor

Here's the catch: blinking is almost entirely unconscious. You can't reliably self-report your own blink rate any more than you can self-report your own breathing rate while focused on something else — the moment you pay attention to it, you change it. That's exactly why timer-based "take a break every 20 minutes" apps miss the point. They're measuring the clock, not the actual behavior that matters.

What you actually need is passive, continuous measurement — something watching the behavior itself, not proxying for it with a countdown. That's a computer vision problem, not a scheduling problem.

The three-part loop I built around this: SitBlinkSip

That's the entire premise behind SitBlinkSip, an open-source project I built to turn this research into something you actually run while you work. It tracks three things through your webcam, entirely on-device, with nothing recorded or uploaded:

Blink rate, using eye-aspect-ratio (EAR) tracking on a real-time face mesh — the same underlying signal used in the clinical studies above.
Posture, using head-tilt angle and forward-lean detection, because slouching and eye strain tend to compound each other during long sessions.
Hydration, on an independent timer, because dehydration and screen-related fatigue often show up together and neither one waits for the other.

When your blink rate drops below a healthy minimum over the last minute, the screen blanks briefly with a short alert tone — a forced, unmissable "blink now" moment, deliberately more assertive than the other two nudges because it's the most time-sensitive. Posture drift gets a quieter sound + notification, since it's gradual rather than acute. Water reminders just ping on their own schedule.

Camera → Blink detection → Pattern monitoring → Timely reminder → More awareness → Healthier habits

That loop is the whole product philosophy: don't diagnose, don't lecture, just make an invisible behavior visible in the moment it's actually happening.

What it deliberately does not claim

I want to be precise here, because health-adjacent tools get oversold constantly, and I'd rather undersell this one. Digital eye strain has multiple contributing factors beyond blink rate — screen brightness, viewing distance, ambient lighting, uncorrected vision, individual eye health, and more. SitBlinkSip focuses on blink awareness as one measurable, fixable piece of that picture. It doesn't diagnose, treat, or cure any eye condition, and it isn't a substitute for an actual eye exam if something feels persistently wrong.

What it is good at: making a behavior you cannot consciously track — your own blink rate — visible enough that you can actually change it, with research suggesting that change alone produces measurable symptom improvement.

Two ways to run it, both free and open source

Web dashboard — Next.js + FastAPI + OpenCV/dlib, run locally via Docker, with the full research write-up and charts.
Desktop app — a native background app for Linux, Windows, and macOS built on PySide6 + MediaPipe, no server or database required, lives in your system tray.

# native desktop app, no Docker needed
git clone https://github.com/ishworrsubedii/desktop-sitblinksip.git
cd desktop-sitblinksip
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python -m sitblinksip_desktop

Both are Apache-2.0 licensed. All the detection logic — the EAR thresholds, the posture-scoring math, the alert cooldowns — is readable in the source, because I think "trust me, it works" is a bad ask for anything that touches your webcam.

Where this goes next

The roadmap is deliberately modest and clearly labeled as "not yet built": deeper analytics per session, historical trends over weeks and months, wearable integration, and personalized recommendations based on your own long-term patterns. None of it is required for the core loop to be useful today — that's already sitting in your tray, watching a problem most of us didn't know we had a measurable fix for.

If you spend most of your working day facing a screen, I'd rather you learn this from a study summary than from your own eyes at 4 p.m. Try it, read the code, and if you find a threshold that's wrong for your setup, open an issue — this is exactly the kind of project that gets better from real usage across different monitors, lighting, and webcams.

Source & docs: github.com/ishworrsubedii/SitBlinkSip · github.com/ishworrsubedii/desktop-sitblinksip
Live site: sitblinksip.oxura.dev

Tags: Health Tech, Computer Vision, Open Source, Research, Software Engineering

SitBlinkSip Desktop: A Native App That Watches Your Blinks, Posture, and Water Breaks — With No Server, No Database, No Browser Tab

Ishwor Subedi — Fri, 21 Aug 2026 16:05:59 +0000

A complete walkthrough of installing, configuring, and actually living with the open-source background app that keeps developers healthier during long screen sessions

If you read my last post, you know why SitBlinkSip exists: developers forget to blink, slouch for hours, and skip water breaks, and a webcam is a genuinely good tool for catching all three in real time.

This post is the practical one. I'm going to walk through SitBlinkSip Desktop — the native companion app — end to end: what it does differently from the web dashboard, how to install it on your OS, and how to actually configure it so the nudges help instead of annoy you.

Repo: github.com/ishworrsubedii/desktop-sitblinksip

Why a separate desktop app?

The original SitBlinkSip is a web dashboard: Next.js frontend, FastAPI backend, OpenCV + dlib for the computer vision, the whole thing running in Docker. It's great if you want the full dashboard experience with charts in your browser.

But most days, I don't want to keep a browser tab and a Docker container alive just to get blink reminders. So the desktop app strips it down to the essentials:

No server. No FastAPI process running in the background.
No database. Nothing is logged or persisted beyond your local settings file.
No browser tab. It lives in your system tray (or menu bar on macOS) and stays out of your way.
Entirely local. Just the webcam and a timer, processed on-device.

It reuses the exact same detection logic as the web app — eye-aspect-ratio for blinks, head-tilt-angle and forward-displacement for posture — but swaps dlib for MediaPipe FaceMesh/Pose, which means no giant landmark model file to download and no compiled dependency to build from source. The alert tones are shared with the web dashboard too, so it genuinely feels like the same product, just lighter.

What it does, feature by feature

Blink counter — no camera feed shown by default, just a small always-on-top widget with your blink count and blinks/minute. Press F6 (or use the tray menu) any time to reveal the live camera preview, and press it again to hide it.
"Blink now" nudge — if your blink rate over the last minute drops below a healthy minimum, your screen blanks for a couple of seconds with a short alert tone, then resumes. It's deliberately more forceful than the other two alerts, because a missed blink is the most time-sensitive of the three.
Posture corrector — the same webcam feed is periodically checked for head tilt and forward lean. When your posture score drops too low, you get a sound + notification — no screen blank, since posture drift is gradual rather than urgent.
Water break reminders — an independent timer nudges you on a configurable interval regardless of whether blink/posture tracking is paused, so you never skip hydration just because you turned off the other checks.
System tray control — pause/resume tracking, toggle the camera preview, open settings, or quit, all from one menu.

Installing it on your OS

SitBlinkSip Desktop ships as a native package for Linux, Windows, and macOS, all built from the same source tree and the same PyInstaller spec.

OS	Package	Notes
Linux	`.deb`	Any desktop with a system tray. X11 recommended (see the hotkey note below).
Windows	`setup.exe` (Inno Setup)	Windows 10/11, 64-bit. Global F6 hotkey works out of the box.
macOS	`.dmg` (`.app` bundle)	macOS 11+, Apple Silicon and Intel. Runs as a menu-bar app, no Dock icon. Needs two permission grants on first run.

Linux

./packaging/linux/build-deb.sh
sudo apt install ./dist/sitblinksip-desktop_0.1.0_amd64.deb

Launch SitBlinkSip Desktop from your applications menu, or run sitblinksip-desktop from a terminal. Uninstall any time with sudo apt remove sitblinksip-desktop.

Windows

powershell -ExecutionPolicy Bypass -File packaging\windows\build-windows.ps1

This produces a runnable frozen app directory, and — if you have Inno Setup 6.3+ installed — a full setup.exe installer. It defaults to a per-user install, so no admin/UAC prompt is required. Since the build isn't code-signed, Windows SmartScreen will flag it on first run — click More info → Run anyway.

macOS

./packaging/macos/build-macos.sh

This produces SitBlinkSip Desktop.app and a .dmg. Two things worth knowing before you try it:

The build is architecture-native (not universal2), because one of the vision dependencies (opencv-contrib-python, pulled in by MediaPipe) doesn't publish a fat binary — build on Apple Silicon for Apple Silicon, Intel for Intel.
The bundle is ad-hoc signed but not notarized, so the first launch needs right-click → Open → Open — a plain double-click will be blocked by Gatekeeper.

macOS will also ask for two permissions on first run:

Permission	Needed for	Where
Camera	Blink and posture tracking (required)	System Settings → Privacy & Security → Camera
Accessibility	Global F6 hotkey (optional)	System Settings → Privacy & Security → Accessibility

If you skip Accessibility, F6 still works while a SitBlinkSip window is focused — you just lose the global hotkey, and the app tells you once via notification rather than leaving it silently dead.

Running from source (any OS)

If you'd rather run it without building a package:

cd desktop-sitblinksip
python3 -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install -r requirements.txt
python -m sitblinksip_desktop

You'll need Python 3.9–3.12 — MediaPipe is pinned to a version range that dropped support for the older mediapipe.solutions API this app relies on above 3.12, so 3.13 isn't compatible yet. The requirements.txt handles per-platform quirks (Windows needs one MediaPipe release lower than the others) automatically via environment markers, so a plain pip install -r requirements.txt just does the right thing.

Using it day to day

Everything is driven from the tray icon (system tray on Linux, notification area on Windows, menu bar on macOS):

Action	How
Show/hide the blink counter	Tray icon → "Show/Hide counter"
Minimize the counter to just the blink count	– button on the counter widget
Show/hide the camera preview	F6, or tray icon → "Show camera preview"
Pause/resume tracking	Tray icon → "Pause tracking"
Enable/disable posture checks	Tray icon → "Posture checks" checkbox
Enable/disable water reminders	Tray icon → "Water break reminders" checkbox
Adjust sensitivity / thresholds	Tray icon → "Settings…"
Quit	Tray icon → "Quit"

Settings are organized into Blink / Posture / Water / General tabs, and persist to a local config.json:

Blink — camera device index, EAR threshold, minimum blinks/minute, break-screen duration, cooldown between breaks.
Posture — head-tilt angle threshold, forward-lean threshold, posture score alert threshold, cooldown between alerts.
Water — reminder interval.
General — sound on/off, launch on login.

My honest recommendation after running it for a while: turn the water reminder interval up slightly from the default if you already have a habit of keeping a bottle at your desk, and leave the blink threshold alone — it's tuned around the same clinical minimum blink-rate research the whole project is built on.

A note on the global F6 hotkey

This is the one feature that genuinely behaves differently per platform, because each OS decides independently whether a regular app is allowed to listen for keys system-wide:

Platform	Global F6	Why
Windows	✅ Works	Installs a Win32 low-level keyboard hook, no permission needed.
Linux (X11)	✅ Works	Hooks X11 directly.
macOS	⚠️ After granting Accessibility	See the permissions table above.
Linux (Wayland)	❌ Blocked	Wayland's security model forbids system-wide key listeners for regular apps — a platform limitation, not a bug in the app.

Wherever F6 isn't available globally, it still works while a SitBlinkSip window has focus, and the tray/menu-bar menu always has a manual toggle — you're never stuck without a way to open the camera preview.

Under the hood, briefly

The stack is PySide6 + MediaPipe + OpenCV + NumPy + pynput, and it's genuinely cross-platform — most of the codebase is shared. The platform-specific differences (settings paths, camera backend, tray behavior, launch-on-login mechanism) are deliberately concentrated into two files, platform_support.py and autostart.py, rather than scattered through the feature code as sys.platform checks. If you're curious how a cross-platform PySide6 app handles things like DirectShow vs. V4L2 vs. AVFoundation camera backends, or XDG autostart vs. registry Run keys vs. launchd agents, the source is short enough to read in an afternoon.

Try it

git clone https://github.com/ishworrsubedii/desktop-sitblinksip.git
cd desktop-sitblinksip
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python -m sitblinksip_desktop

It's Apache-2.0 licensed, actively developed, and contributions are welcome — especially around the packaging scripts, which are the trickiest part of shipping a native app on three OSes from one codebase.

Desktop app & source: github.com/ishworrsubedii/desktop-sitblinksip
Live site & web dashboard: sitblinksip.oxura.dev

If you try it, I'd genuinely like to know what default threshold felt wrong for you — those are the kind of small tuning issues that are hard to catch alone and easy to fix with a GitHub issue.

Tags: Open Source, Software Engineering, Cross Platform Development, Python, Developer Tools

I Kept Forgetting to Blink While Coding — So I Built an App That Watches My Eyes, Spine, and Water Bottle

Ishwor Subedi — Fri, 21 Aug 2026 16:05:09 +0000

How a bad habit during long debugging sessions turned into SitBlinkSip, an open-source health companion for anyone who lives behind a screen

A few months ago I noticed something strange: my eyes were burning by 3 p.m. every single day. Not from lack of sleep, not from bad lighting — from not blinking. I'd get locked into a bug, stare at a stack trace for twenty straight minutes, and forget one of the most automatic things a human body does.

Turns out I wasn't imagining it. When we focus hard on a screen, our blink rate drops and our blinks become incomplete — and that's directly linked to dry eyes and digital eye strain. On top of that, I was slouching harder the longer I coded, and my water bottle would sit untouched for six hours at a time.

So, being an ML engineer who works with computer vision every day, I did what felt obvious: I pointed my own webcam at the problem.

That's how SitBlinkSip was born — a free, open-source wellness companion that watches your posture, your blink rate, and your hydration breaks while you work, and nudges you the moment one of them slips.

The idea in one sentence

Sit better. Blink more. Sip regularly.

SitBlinkSip runs quietly in the background while you code, write, or design, using your webcam to track three simple things:

Posture — are you slouching or leaning forward?
Blinking — are you blinking often enough to keep your eyes healthy?
Hydration — how long has it been since your last water break?

When any of the three drifts out of a healthy range, you get a gentle nudge — a notification, a sound, or (for blinking specifically) a brief screen blank that forces a reset. No lectures, no guilt-trip pop-ups. Just a tap on the shoulder.

Why I built it as computer vision, not a survey app

There are plenty of "take a break" timer apps out there. Most of them are dumb clocks — they nag you every 20 minutes whether you've been slouching or sitting perfectly upright, blinking normally or staring like a gargoyle. That's not awareness, that's noise, and noise gets muted within a day.

SitBlinkSip instead measures what's actually happening:

Blink detection uses eye-aspect-ratio (EAR) tracking on your face mesh, the same technique used in academic dry-eye research, to count real blinks and calculate blinks per minute in real time.
Posture checking looks at head-tilt angle and forward lean/displacement — the two most common signs of "laptop slouch" — and scores your posture continuously instead of guessing on a timer.
Water reminders run on an independent interval so hydration nudges don't get skipped just because your posture happens to be perfect that hour.

Everything happens on-device. No video is ever recorded or uploaded — frames are analyzed instantly and discarded. If you're the type of developer who instinctively covers their laptop camera with tape (I am), that matters.

The research behind the "why"

I didn't want to build a wellness app on vibes, so before writing a line of code I went looking for the actual science. A few things stood out:

Reviews of digital eye strain consistently point to changes in blinking behavior — lower frequency, more incomplete blinks — as a real contributor to dry-eye symptoms during prolonged screen use.
Longer gaps between blinks let the tear film break up before the next blink arrives, which is a big part of why your eyes feel gritty by the afternoon.
A randomized controlled trial on blink-reminder software specifically found improvements in both blink rate and dry-eye symptom scores among visual display terminal users — which is basically the closest thing to a controlled study of "does nudging people to blink actually help," and the answer was yes.

To be clear: SitBlinkSip doesn't diagnose or treat anything. Digital eye strain has a lot of contributing factors — screen brightness, distance, ambient light, your individual eye health. Blink awareness is just one measurable, fixable piece of that puzzle, and it happens to be the piece a webcam is uniquely good at watching.

What it actually looks like day to day

You open SitBlinkSip before a work session and forget about it. In the background:

Start working — SitBlinkSip starts watching posture, blink rate, and the clock since your last break.
Stay focused — you keep coding normally. There's no camera preview shown by default, just a small always-on-top counter.
Get reminded — the moment your blink rate dips, your posture score drops, or your water timer runs out, you get a nudge — sized to the urgency. A missed blink gets a brief screen blank (urgent, immediate). Posture drift gets a quiet notification (gradual, not urgent). Water is just a friendly ping.
Build better habits — over enough sessions, the nudges become less necessary because the habit sticks.

As one early tester (a full-stack developer) put it: "SitBlinkSip has helped me maintain good posture and eye health during long coding sessions." That's the entire goal — not another dashboard to babysit, just a quiet second pair of eyes on your own eyes.

Two ways to run it

SitBlinkSip actually ships as two different things, depending on how you like to work:

The web dashboard — a Next.js + FastAPI + OpenCV/dlib stack you spin up locally with Docker. Great if you want the visual dashboard, charts, and the full research write-up in your browser.
SitBlinkSip Desktop — a native background app for Linux, Windows, and macOS. No server, no database, no browser tab to keep open — just the webcam, a tray icon, and a floating counter. This is the version built for people who want it to disappear into the OS and just work.

I'll go deep on installing and using the desktop app in the next post — it's the one I personally run all day.

It's open source, on purpose

I built this alone, out of a genuinely annoying personal habit, and I'm releasing all of it — the computer vision pipeline, the API, the desktop app — under Apache-2.0. If you've ever wanted to see how blink and posture detection actually works under the hood, the repo is fully readable. If you want to add a feature, PRs are welcome.

# clone the web dashboard
git clone https://github.com/ishworrsubedii/SitBlinkSip.git
cd SitBlinkSip
docker compose up --build

# or run the native desktop app from source
git clone https://github.com/ishworrsubedii/desktop-sitblinksip.git
cd desktop-sitblinksip
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python -m sitblinksip_desktop

What's next

I'm not trying to build another SaaS dashboard nobody opens twice. The roadmap is intentionally small and honest about what's planned vs. shipped: deeper session analytics, historical trends over weeks and months, wearable integration, and personalized recommendations based on your own patterns. All of it optional, none of it required to get value from the core loop today.

If you spend more hours looking at a monitor than at another human face most days — which, if you're reading this on a dev blog, you probably do — give it a try. Star the repo if it's useful, open an issue if something's broken, and let me know what nudging feature you'd want next.

Web dashboard & source: github.com/ishworrsubedii/SitBlinkSip
Desktop app & source: github.com/ishworrsubedii/desktop-sitblinksip
Live site: sitblinksip.oxura.dev

Next up: a full walkthrough of installing and configuring SitBlinkSip Desktop on Linux, Windows, and macOS.

Tags: Open Source, Health Tech, Computer Vision, Developer Tools, Productivity

Pose Estimation: A Simple Guide and Applications

Ishwor Subedi — Fri, 13 Sep 2024 12:09:35 +0000

1. Introduction

Pose estimation is a technique used to find and track the positions of human joints in images or videos. This is useful in applications like virtual try-ons, health apps, and fitness monitoring. The goal is to identify key points, such as the elbows, shoulders, and knees, and track their movements. In this guide, we will explore pose estimation models, training methods, and applications.

2. Models and Libraries for Pose Estimation

Here are some popular models and libraries for pose estimation:

MediaPipe: A fast, easy-to-use library by Google for real-time pose estimation.
YOLO-Pose: A version of YOLO that detects key points in addition to objects.

Code Example (Using MediaPipe)

import cv2
import mediapipe as mp

mp_pose = mp.solutions.pose
pose = mp_pose.Pose()
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = pose.process(image)

    if results.pose_landmarks:
        mp.solutions.drawing_utils.draw_landmarks(frame, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)

    cv2.imshow('Pose Estimation', frame)
    if cv2.waitKey(10) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Diagram: YOLO Training Architecture

Input: Images with labeled key points (from CVAT)
Processing: YOLO training to detect key points.
Output: A model that can detect key points in new images.

3. Applications of Pose Estimation

a. Virtual Try-On (e.g., Glasses Try-on)

Pose estimation helps apps align virtual glasses with your face.

b. Fitness Apps

Apps use pose estimation to help users correct their workout form.

c. Health Monitoring

Pose estimation can track a patient's movements during physical therapy.

4. A Simple Project Idea for Beginners

You can build a basic Yoga Pose Detection App:

Build custom logic to detect common yoga poses.
Use MediaPipe or YOLO-Pose to detect key points during yoga.
Provide feedback to users.

5. Conclusion

Pose estimation is a powerful tool used in many areas, from fitness to virtual try-on apps. Using libraries like MediaPipe and YOLO makes it easy to get started, and with tools like CVAT, you can even train your own models. This guide provides a basic overview to help you get started with pose estimation.

Dockerized deployments, CI/CD, automated workflows for production in cloud environments

Ishwor Subedi — Thu, 12 Sep 2024 12:29:23 +0000

Introduction

In this blog, we’ll learn how to deploy a FastAPI app using Docker and automate it with CI/CD. We’ll go over why Docker is better than traditional SSH-based deployment, and how it simplifies the process of running apps in the cloud.

Why Docker?

With normal file setup, you manually upload files to a server via SSH. This often leads to issues like mismatched environments (e.g., different Python versions or missing libraries). Docker eliminates this problem by packaging everything (code, libraries, configurations) into a container.

Consistency: Docker ensures the app works the same on every machine.
Simplicity: Once the container is created, you don’t have to worry about setting up environments.
Scalability: Docker makes scaling your application easier, especially in cloud environments.

Why Not Traditional SSH Deployment?

In traditional deployment, you often use scp or rsync to upload code, and manually configure environments via SSH, which can cause:

Environment issues: Different setups on local vs. server.
Manual errors: Forgetting to install dependencies.
Time-consuming: Manual steps every time you update the app.

Docker fixes this by packaging everything together. You create an image once, and then run it anywhere with Docker.

What is Docker?

Docker is a platform for running applications in containers. A Docker container is a self-contained unit that packages your code and all its dependencies. With Docker, your app works the same in development and production.

Dockerfile: Instructions to build the Docker image.
Image: Blueprint for the container.
Container: Running instance of an image.

What is CI/CD?

CI/CD (Continuous Integration/Continuous Delivery) automates testing, building, and deploying applications.

CI (Continuous Integration): Automatically test and integrate new code changes.
CD (Continuous Delivery): Automatically deploy tested code into production.

Creating a FastAPI App

We will create a simple FastAPI app and Dockerize it. Then, we'll automate the deployment using GitHub Actions.

1. FastAPI App (`main.py`)

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, Dockerized FastAPI World!"}

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

2. Dockerfile

The Dockerfile is used to create a Docker image for our FastAPI app.

# Use an official Python runtime as a parent image
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container
COPY . /app

# Install FastAPI and Uvicorn
RUN pip install fastapi uvicorn

# Expose the port FastAPI will run on
EXPOSE 8000

# Command to run the app
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

3. Build and Run Docker Container

To build and run the Docker container:

docker build -t fastapi-app .
docker run -d -p 8000:8000 fastapi-app

This will make the app accessible at http://localhost:8000.

Push to Docker Hub

To share your Docker image, push it to Docker Hub.

Tag your image:

docker tag fastapi-app yourdockerhubusername/fastapi-app:latest

Push the image to Docker Hub:

docker push yourdockerhubusername/fastapi-app:latest

CI/CD Workflow with GitHub Actions

Here’s how to automate Docker image building and deployment using GitHub Actions.

GitHub Actions Workflow (`.github/workflows/docker.yml`)

name: CI/CD for FastAPI Docker App

on:
  push:
    branches:
      - main

jobs:
  build-and-push:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v1

    - name: Login to DockerHub
      uses: docker/login-action@v2
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

    - name: Build and Push Docker image
      run: |
        docker build -t yourdockerhubusername/fastapi-app:latest .
        docker push yourdockerhubusername/fastapi-app:latest

    - name: Log out from DockerHub
      run: docker logout

This workflow builds and pushes your Docker image to Docker Hub automatically when changes are pushed to the main branch. To set up:

Add your Docker Hub credentials (DOCKER_USERNAME and DOCKER_PASSWORD) as GitHub secrets.
Create the .github/workflows/docker.yml file.

Deploying Docker on RunPod

To deploy your Docker container on RunPod:

Create an account at RunPod.
Create a new pod (choose the appropriate machine type).
** Create a new template**

Deploy the template based on your hardware requirements, such as CPU or GPU. It will automatically pull the Docker image from Docker Hub and initiate the container accordingly.

Now your FastAPI app will be running on the cloud via RunPod.

Docker Commands

Docker Installation instruction and commands

Conclusion

In this guide, we learned how to create a FastAPI app, Dockerize it, and automate its deployment using CI/CD. Docker simplifies the deployment process by ensuring the app runs consistently across environments. With tools like GitHub Actions and platforms like RunPod, you can automate the entire deployment process.

Seamless Background Removal with ISNET, SAM, and YOLOSegment Integration

Ishwor Subedi — Wed, 11 Sep 2024 12:45:59 +0000

Introduction

In this blog, we will be covering advanced and seamless background removal techniques using three different architectures: ISNET, SAM, and YOLOSegment. We'll analyze their performance in terms of speed and quality and compare them to help you decide which one suits your project best.

1. ISNET (Bria 1.4) - RmGB

Model Link:

ISNET Bria 1.4 RmGB Model

Introduction:

ISNET is a high-quality background removal model specifically designed for fine-grained edge detection. It's ideal for images where the separation between the foreground and background requires precision, such as product images or detailed portraits.

Architecture:

ISNET leverages deep learning techniques with a focus on preserving details. Its architecture consists of multiple layers of convolutions, capturing both local and global information to perform accurate background removal.

Suitable For:

Product photography
Portraits with detailed hair and edges
High-precision use cases

Performance:

Time taken on RTX A4000: ~1.2 seconds per image

2. YOLOSegment

Model Link:

YOLOSegment Model

Introduction:

YOLOSegment is a real-time object detection and segmentation model, widely known for its speed. It is capable of segmenting objects and removing backgrounds with a focus on efficiency, making it suitable for use cases requiring rapid processing.

Architecture:

YOLOSegment employs the YOLO (You Only Look Once) architecture, which balances speed and accuracy. Its segmentation head allows it to effectively separate objects from the background in a single pass, optimizing for real-time applications.

Suitable For:

Real-time applications
Video streams or live processing
Fast background removal tasks

Performance:

Time taken on RTX A4000: ~0.3 seconds per image

3. SAM (Segment Anything Model)

Model Link:

SAM Model

Introduction:

SAM is designed to handle any segmentation task with minimal input, using a generalist approach. It works across a wide variety of images, and is great for semi-automated background removal where human oversight is required for complex scenes.

Architecture:

The SAM architecture is a general-purpose segmentation model. It integrates transformer networks to analyze images and segment them based on context, making it flexible across diverse images with varying complexity.

Suitable For:

General-purpose segmentation
Use cases where human input is needed
Complex backgrounds or scenes

Performance:

Time taken on RTX A4000: ~2.0 seconds per image

Conclusion

Each model offers distinct advantages, depending on your specific needs:

ISNET: Best for high-quality and precise background removal tasks where details matter.
YOLOSegment: Best for real-time applications where speed is essential, like live video or rapid image processing.
SAM: Best for general-purpose background removal, especially where complex backgrounds or human oversight is needed.

Choose based on the priority of your task – whether it's quality, speed, or flexibility!

Guide to Image Upscaling: Exploring GANs, Diffusion Models (LDSR), and OpenCV Methods

Ishwor Subedi — Tue, 10 Sep 2024 12:35:33 +0000

Hi, hello, and welcome! In this blog, we will explore various image upscaling techniques, examining and experimenting with different methods. We’ll compare the results to understand the core concepts and effectiveness of each approach. So, let’s dive in and get started!

Here, we will be discussing different image upscaling techniques, including:

GAN-Based Image Upscaling Techniques
- ESRGAN (Enhanced Super-Resolution GAN)
- RESRGAN4+ (Residual Enhanced Super-Resolution GAN)
- NMKD (Not My Kind of Dream)
- Superscale
Diffusion Architecture Upscaling
- LDSR (Latent Diffusion Super Resolution)
OpenCV Techniques
- INTER_AREA
- INTER_LINEAR
- INTER_CUBIC

Comparision Between ESRGAN Vs RESRGAN4+ Vs NMKD vs Superscale Vs LDSR vs INTER_AREA Vs INTER_LINEAR Vs INTER_CUBIC

ESRGAN

RESRGAN4

ESRGAN

ESRGAN (Enhanced Super-Resolution GAN)

How ESRGAN Works:

ESRGAN is built on the GAN (Generative Adversarial Network) framework, designed to enhance image resolution by generating high-quality details from low-resolution inputs. It employs a deep residual network to refine the image through multiple convolutional layers, learning from a large dataset of high-resolution images.

Key Focus:

The primary focus of ESRGAN is to improve texture and detail in upscaled images. By leveraging advanced network architectures and loss functions, ESRGAN aims to produce realistic and visually appealing results with sharp textures.

Architecture:

ESRGAN’s architecture includes a series of residual blocks that help preserve image details and improve quality. The model consists of a generator that creates high-resolution images and a discriminator that ensures the generated images are realistic by comparing them to actual high-resolution images.

Loss Functions:

Perceptual Loss: Measures differences in high-level features between the generated and original high-resolution images, focusing on texture and detail.
Adversarial Loss: Ensures the generated images are realistic by training the generator to fool the discriminator into thinking the images are real.

Best For:

ESRGAN is ideal for enhancing artistic images and photographs where maintaining fine details and textures is crucial.

Time Taken on RTX 4000 GPU:

ESRGAN typically processes images in a few minutes, depending on their resolution and complexity.

RESRGAN4 (Residual Enhanced Super-Resolution GAN)

How RESRGAN4 Works:

RESRGAN4 extends the ESRGAN framework with additional layers and improved residual blocks, aimed at refining image upscaling capabilities. It builds on ESRGAN’s approach but focuses on reducing artifacts and enhancing image sharpness further.

Key Focus:

RESRGAN4’s key focus is on achieving superior detail recovery and reducing artifacts in high-resolution images, providing even finer and more accurate results compared to its predecessors.

Architecture:

This variant enhances the ESRGAN architecture by incorporating additional residual blocks and layers, which improve the network’s ability to capture and generate high-quality textures and details.

Loss Functions:

Enhanced Perceptual Loss: Provides a more refined measurement of high-level feature differences.
Advanced Adversarial Loss: Optimizes the generator to produce images that better mimic real high-resolution visuals, minimizing artifacts.

Best For:
RESRGAN4 is well-suited for applications requiring the highest level of detail and artifact reduction, such as detailed artwork or high-resolution textures.

Time Taken on RTX 4000 GPU:

Processing times are similar to ESRGAN, generally a few minutes per image.

NMKD (Not My Kind of Dream)

How NMKD Works:

NMKD uses a GAN-based approach similar to ESRGAN but incorporates unique modifications to the network architecture and training process to enhance image quality and reduce common artifacts.

Key Focus:

NMKD focuses on delivering high-resolution images with minimal distortions and artifacts, using a distinct combination of loss functions to improve overall image quality.

Architecture:

The NMKD model features a GAN architecture with modifications aimed at reducing artifacts and improving the fidelity of the generated images. It uses specialized layers and training techniques to refine image details.

Loss Functions:

Content Loss: Ensures structural accuracy by comparing generated images to original high-resolution images.
Adversarial Loss: Encourages the generator to produce images that are indistinguishable from real high-resolution images.

Best For:
NMKD is ideal for applications where reducing artifacts and enhancing image realism are priorities.

Time Taken on RTX 4000 GPU:
Typically processes images in a few minutes, depending on the resolution and model configuration.

Superscale

How Superscale Works:

Superscale employs advanced deep learning models to upscale images, using a combination of convolutional networks and interpolation methods to enhance resolution while preserving details.

Key Focus:

The main focus of Superscale is to achieve high-quality image upscaling with attention to detail preservation and noise reduction.

Architecture:

Superscale combines convolutional neural networks with advanced interpolation techniques to refine and upscale images, ensuring high fidelity and clarity in the output.

Loss Functions:

Content Loss: Ensures that the upscaled image maintains structural integrity.
Perceptual Loss: Enhances image quality by comparing high-level features.

Best For:

Superscale is suitable for applications requiring detailed and high-quality image upscaling, including professional photography and high-definition media.

Time Taken on RTX 4000 GPU:
Processing time varies but generally takes a few minutes per image, similar to other deep learning models.

LDSR (Latent Diffusion Super Resolution)

How LDSR Works:

LDSR leverages latent diffusion models to perform image upscaling. It compresses images into a lower-dimensional latent space and applies diffusion processes to enhance resolution while maintaining image details.

Key Focus:

LDSR focuses on efficient image upscaling with a strong emphasis on maintaining detail and reducing artifacts through iterative refinement in the latent space.

Architecture:

LDSR’s architecture involves a latent space representation where images are refined through iterative denoising steps, allowing for high-quality upscaling with lower computational demands.

Loss Functions:

Latent Space Loss: Measures differences within the latent space to refine image quality.
Perceptual Loss: Ensures that the upscaled image retains high-level features and details.

Best For:

LDSR is ideal for applications requiring efficient and high-quality image upscaling with a focus on detail preservation and artifact reduction.

Time Taken on RTX 4000 GPU:
Typically processes images in a few minutes, making it an efficient choice for high-resolution tasks.

OpenCV Techniques

How OpenCV Techniques Work:

OpenCV provides traditional methods for image upscaling through various interpolation techniques, each with different trade-offs in quality and performance.

Key Focus:

These methods focus on resizing images using mathematical techniques to balance quality and computational efficiency.

Techniques:

INTER_AREA: Uses pixel area relation for resampling; effective for downscaling and minimal quality loss.
INTER_LINEAR: Bilinear interpolation method; balances quality and performance by averaging pixel values.
INTER_CUBIC: Uses cubic convolution interpolation for smoother results; provides higher quality at the expense of computational time.

Best For:

OpenCV techniques are suitable for applications requiring fast and straightforward image resizing with acceptable quality, such as real-time processing and basic image adjustments.

Time Taken on RTX 4000 GPU:

Processing times are generally very fast, often taking only a few seconds per image due to the simplicity of the interpolation methods.

DEV Community: Ishwor Subedi

Your Eyes Weren't Built for an 8-Hour Stare Contest With a Monitor — Here's What the Research Actually Says

Digital eye strain isn't just "tired eyes." I dug into the studies, then built an open-source tool around the one part of the problem a webcam can actually fix.

What actually happens to your eyes on a screen

Why this is a genuinely hard problem to self-monitor

The three-part loop I built around this: SitBlinkSip

What it deliberately does not claim

Two ways to run it, both free and open source

Further reading

Where this goes next

SitBlinkSip Desktop: A Native App That Watches Your Blinks, Posture, and Water Breaks — With No Server, No Database, No Browser Tab

A complete walkthrough of installing, configuring, and actually living with the open-source background app that keeps developers healthier during long screen sessions

Why a separate desktop app?

What it does, feature by feature

Installing it on your OS

Linux

Windows

macOS

Running from source (any OS)

Using it day to day

A note on the global F6 hotkey

Under the hood, briefly

Try it

I Kept Forgetting to Blink While Coding — So I Built an App That Watches My Eyes, Spine, and Water Bottle

How a bad habit during long debugging sessions turned into SitBlinkSip, an open-source health companion for anyone who lives behind a screen

The idea in one sentence

Why I built it as computer vision, not a survey app

The research behind the "why"

What it actually looks like day to day

Two ways to run it

It's open source, on purpose

What's next

Pose Estimation: A Simple Guide and Applications

1. Introduction

2. Models and Libraries for Pose Estimation

Code Example (Using MediaPipe)

Diagram: YOLO Training Architecture

3. Applications of Pose Estimation

a. Virtual Try-On (e.g., Glasses Try-on)

b. Fitness Apps

c. Health Monitoring

4. A Simple Project Idea for Beginners

5. Conclusion

Dockerized deployments, CI/CD, automated workflows for production in cloud environments

Introduction

Why Docker?

Why Not Traditional SSH Deployment?

What is Docker?

What is CI/CD?

Creating a FastAPI App

1. FastAPI App (main.py)

2. Dockerfile

3. Build and Run Docker Container

Push to Docker Hub

CI/CD Workflow with GitHub Actions

GitHub Actions Workflow (.github/workflows/docker.yml)

Deploying Docker on RunPod

Docker Commands

Conclusion

Seamless Background Removal with ISNET, SAM, and YOLOSegment Integration

Introduction

1. ISNET (Bria 1.4) - RmGB

Model Link:

Introduction:

Architecture:

Suitable For:

Performance:

2. YOLOSegment

Model Link:

Introduction:

Architecture:

Suitable For:

Performance:

3. SAM (Segment Anything Model)

Model Link:

Introduction:

Architecture:

Suitable For:

Performance:

Conclusion

1. FastAPI App (`main.py`)

GitHub Actions Workflow (`.github/workflows/docker.yml`)