~/arindas • About

About

I am Arindam Das. I specialize in distributed systems, deep learning inference, and AI SaaS at scale.

My expertise enables me to architect and implement cloud-native software services across multiple domains. I primarily have experience in medical imaging and diagnosis, and real-time document processing.

Get in touch: Email · GitHub · LinkedIn

Skill set

Technical skills

Languages: C, C++, Java, Python, Golang, Rust, Javascript, Typescript, SQL
Frameworks and Libraries: Django, FastAPI, Tensorflow, Pytorch, Pynetdicom, React, Glommio, Tokio
Tools: Git, Vim, Neovim, Awk, Sed
DevOps: Linux, Nginx, Docker, Bash, Zsh, Github Actions, Gitlab CI, Terraform
Databases: PostgreSQL, Microsoft SQL Server, MySQL, SQLite, GCP Cloud Firestore
Cloud: AWS{S3, RDS, EC2, Lightsail}, Firebase, GCP{Instances, PubSub, Cloud Storage},
and Azure{Instances, Blob Storage, Container Apps}

Soft skills

Agile Software Development, Requirement Analysis, System Design, Technical Content Delivery

Experience

MLOps Engineer, Medical Imaging AI Services, Claritas Healthtech (06/2020 - Present)

Responsibilities

Provisioning infrastructure for researchers to train and experiment with deep learning models
Developing distributed deep learning inference services and corresponding client web applications
Deploying and maintaining said applications as Cloud services (Prev: Azure and GCP. Currently on AWS)

Projects

Event-driven API Call Gateway for Inference Services
- Supports reading medical images from different "sources" (e.g. AWS S3) processing them with configured Deep Learning Inference services, and sending them to specified "sinks" (e.g. AWS S3)
- Designed to accomodate archives containing multiple images, composite media like videos, dicom multiframe etc. even when the inference service expects single frame images.
- Designed in an event driven fashion to accomodate multiple pipelines with different stages: enqueue, archive extraction / video split, ingestion, inference, response.
- Incorporates a custom task scheduler to make incremental progress on tasks in different pipelines, including retries for failed tasks and moving tasks from one pipeline to another
- Tasks are internally modelled as state machines. This allows us to limit the number of IN_PROGRESS tasks for rate-limiting traffic to our backend enhancer services. It also allows us to prioritize or set timeouts for tasks based on which state they are in. Each state transition causes a side-effect.
- Engineered for concurrency at every level - from concurrent task state transitions to splitting and parallelizing work for individual tasks containing composite media.
- Tunable to limit concurrency based on environment constraints - including limiting concurrent API calls to inference service to prevent overload
- Accomodates sync and async API call mechanisms to Inference Services with detailed audit keeping for every API call and retries for failed API calls.
- Capable of integrating authentication at every API call boundary - from data interchange with sources and sinks to API calls to machine learning inference services.
- This solution enables rapid integration of our Machine Learning inference services with downstream user applications - including our Cloud Storage application.
- In addition to workflows with a single ML API call, we implemented multi-stage processor pipelines
- Our Processor integration implementation is network protocol agnostic, allowing us to support different processors with different protocols. We support HTTP/S as well as DICOM networking with the possibility to support other protocols like GraphQL and gRPC in the future.
- We support multiple types of pipelines, ranging from SEQUENTIAL where a batch of images is sequentially processed by multiple stages, to CUMULATIVE - where a single stage receives the original input batch as well as the outputs of all the stages before it. We also support a FANOUT stage, where we can spawn multiple oneshot tasks to process the same input batch of images in parallel, with the different processors in each pipeline stage.
- This solution will enable us to integrate our image enhancement and segmentation services with third-party image processors in the same pipeline without requiring complex code integration.
Cloud Image annotation solution with AI Image enhancement
- Supports ingesting images of various formats (DICOM, NIFTI, VIDEO, JPG, PNG) with support for compressed ZIP archives.
- Supports anonymizing images before ingestions for privacy
- Supports 2D Polygon, Ellipsoid and Rectangular ROI annotations on images
- Supports specifying labels for each 2D ROI. Different modality (CT, MRI etc.) and anatomy (kidney, brain etc.) pairs have different set if allowed labels.
- Enforces exclusive user access to same image with locking across server-client boundaries. This makes it safe in the face of multi-user concurrent access to images in the same study.
- Stores images in Cloud Object Storage (AWS S3) and maintains image metadata and catalog in the database. Images are organized by Project, Study, Series and Image records. Supports Microsoft SQL server, MySQL, PostgreSQL, SQLite
- Includes an event-driven scheduler and API call Gateway to make requests to Enhancer Machine Learning inference services, with support for retries on failures. (similar in nature to the aforementioned project)
- Images are organized in Projects. Each project can configured with an Enhancer. Images uploaded to a project configured with an enhancer are automatically enhanced. Enhanced images are placed alongside original images.
- Supports authorization and e-mail user invites for image annotators (i.e. doctors) at the project level.
- This solution enabled us to get diverse sensitive image datasets annotated by doctors from Singapore, USA and Brazil. These annotations were indispensable for in-house research and development on novel image enhancement and segmentation methods.
Cloud based file storage solution built using Object Storage platforms (GCS, AWS S3)
- Files are organized by Buckets and Objects, mirroring file organization in Object Storage platforms
- Supports bucket creation, bucket level user access authorization; object upload, download and delete.
- Initially built as a golang web service with google-cloud-sdk, Cloud Firestore database and Firebase Authentication, along with a React SPA Frontend.
- Later ported to Django to make it Cloud Agnostic. Currently supports AWS S3 backed file storage and multiple databases for maintaining user, bucket and object metadata - including PostgreSQL, Microsoft SQL Server, MySQL and SQLite.
- Records all user access requests (object upload, download, bucket object listing) for detailed audit records
- User access request records are also used for event driven processing. Includes a Framework to filter on user access request records and dispatch pre-configured actions (including API calls)
- This solution enabled us to collaborate on sensitive datasets with over 10 different medical institutions across UK, Singapore and Europe without providing access to our cloud infrastructure.
- The user access request filter dispatch action Framework makes it possible to make API calls to our Gateway for files uploaded to a specific bucket and receive processed files in the same bucket. This effectively allows automatic image processing with inference APIs for files uploaded to specific buckets.
- This solution enabled us to rapidly demonstrate our Deep Learning diagnosis solutions to third-party companies without granting access to our infrastructure.
Distributed deep-learning based diagnosis on medical images for a variety of diseases
- Designed as an event-driven suite of microservices, in golang and python.
- We employ golang for the web serving infrastructure and python for inference.
- Google Cloud PubSub is used as the messaging layer.
- Capable of integrating with dedicated inference servers like Torchserve, Nvidia Triton and Tensorflow Serving
- We provide a React Dashboard for: Visualizing medical images, Requesting AI diagnosis, Tracking inference status and Viewing AI Medical Diagnosis reports
- Reduced turnaround time for a new disease prediction service deployment by 10x, along with improved audit record keeping of all predicted reports.
Dedicated Inference services for research Proof-of-concepts
- Implemented as a Django user facing application and a inference server.
- The Django application behaves as a sidecar for the inference server
- The inference server is either implemented as a FastAPI service or a dedicated Torchserve server based on requirements.
- I productionized 15+ deep-learning models split across 6 different web services in a span of 2 years.

Solution Architect, DeepWrex Technologies (04/2018 - 06/2020)