Discover Computer Vision Projects Efficiently

Python/OpenCV Developer for Mobile Game Automation (macOS)

I am looking for a Python developer with experience in computer vision and automation to build a bot for a mobile mini-game.

The game runs on an iPhone that is mirrored to my Mac using iPhone Mirroring (macOS Sequoia). The bot would run on macOS and interact with the mirrored game window by detecting visual elements and triggering clicks.

There are a few mini-games in the app. Each game lasts about 30–60 seconds.

Example mini-games:

Timing Game:
A meter moves back and forth with a white indicator. When the indicator reaches a colored zone (orange or purple), the bot should click at the correct moment. The closer the click is to the center of the zone, the higher the score.

Mole Game:
Moles appear on screen and need to be tapped quickly. The bot should detect moles and click them while ignoring non-mole objects.

Requirements:

Python

Computer vision (OpenCV or similar)

Screen capture / image detection (mss, pyautogui, or similar)

Automated clicking on macOS

Script runs locally on my Mac (no cloud/server)

Preferred:

Experience building screen-based automation or game bots

Ability to add slight randomness to click timing and position so actions appear natural

Familiarity with macOS and iPhone Mirroring latency considerations

Deliverables:

Working Python script

Instructions for running the script on macOS

Configurable settings (click timing, randomness, etc.) so I can adjust without modifying code

Debug overlay or logging (optional but helpful)

I can provide screen recordings and screenshots of the mini-games to help with development.

Budget: Open to proposals — please include your estimated hours and hourly rate or fixed price

Skills: Python, Software Architecture, Objective C, C++ Programming, Debugging, Game Development, OpenCV, Computer Vision, Automation, Bot Development

Wallfeel AI Visualiser – Developer Brief (MVP)

Project Overview

Wallfeel is building an AI-powered wallpaper visualisation platform that allows customers to upload a photo of their room and preview wallpaper designs applied to their wall before purchasing.

The goal of the MVP is to create a simple and intuitive visualisation experience.

Users will be able to:
1. Upload a photo of their room
2. Automatically detect the wall surface using AI
3. See AI-curated wallpaper designs applied to the wall
4. Select a wallpaper design or generate their own design using an AI prompt
5. Enter wall measurements
6. Preview the design at real-world scale
7. Choose a wallpaper material
8. See the calculated price
9. Share a before/after transformation image
10. Proceed to checkout via Shopify integration

The AI system should be built as a standalone platform with API endpoints so it can connect to Shopify but operate independently.

⸻

System Architecture

The system should be divided into two layers.

1. Wallfeel AI Platform

Handles all AI processing and rendering.

Responsibilities include:
• image upload
• wall detection and segmentation
• wallpaper rendering
• pattern scaling
• AI design suggestions
• AI prompt-based design generation
• image enhancement and upscaling
• before/after sharing image generation
• API communication with Shopify

⸻

2. Shopify (Commerce Layer)

Shopify will handle:
• wallpaper product catalogue
• material options
• price configuration
• shopping cart
• checkout and payment

The AI platform will send configuration data to Shopify via API.

⸻

Core User Flow

Step 1 – Upload Room Photo

User uploads an image of their wall.

Supported formats:
• JPG
• PNG
• HEIC

Options:
• Upload photo
• Drag & drop
• Take photo from mobile camera

⸻

Step 2 – AI Wall Detection

The system automatically detects wall surfaces.

Requirements:
• identify wall area
• mask furniture and objects
• maintain room perspective
• generate segmentation mask

Suggested technologies:
• Segment Anything Model (SAM)
• computer vision segmentation models

⸻

Step 3 – AI Design Suggestions

Once the wall is detected, the system displays curated wallpaper designs.

These should include:
• AI-generated style concepts
• matching wallpapers from the Wallfeel catalogue

Example suggestions:
• Botanical mural
• Luxury marble
• Neutral textured wall
• Jungle green pattern
• Abstract gold

Users can click designs to preview them on their wall.

⸻

Step 4 – Custom AI Prompt Design (Optional)

Users should also have the option to generate a custom wallpaper design using an AI prompt.

Example interface:

“Create your own wallpaper”

Prompt input examples:
• “Luxury marble wallpaper with gold veins”
• “Soft pastel floral mural”
• “Minimal textured plaster wall”
• “Tropical jungle mural with large leaves”

Requirements:
• generate multiple variations (3–4 options)
• allow the user to preview these designs on their wall
• upscale generated images for high-resolution rendering
• ensure generated designs are suitable for wallpaper printing

Suggested technologies:
• Stable Diffusion
• ControlNet
• diffusion pipelines for prompt-based generation

⸻

Step 5 – Wallpaper Preview

Selected wallpaper is applied to the detected wall.

Requirements:
• correct perspective mapping
• realistic lighting
• furniture preservation
• seamless texture placement

Users should be able to switch between designs instantly.

⸻

Step 6 – Enter Wall Measurements

User enters wall dimensions.

Fields:
• wall width
• wall height

Units supported:
• metres
• centimetres
• inches

These measurements determine wallpaper scaling and price.

⸻

Step 7 – Real-World Pattern Scaling

Wallpaper must render at true scale.

Requirements:
• respect wallpaper pattern repeat size
• adjust pattern density based on wall measurements
• ensure preview accurately reflects installation appearance

⸻

Step 8 – Material Selection

User selects wallpaper material.

Example options:
• Matte wallpaper
• Linen texture
• Peel & Stick
• Vinyl

⸻

Step 9 – Price Calculation

Price updates dynamically based on:

wall area × material price per m²

Example:

Wall size: 3.5m × 2.6m
Area: 9.1m²
Material: Premium Linen (£42/m²)

Total: £382.20

⸻

Step 10 – Before / After Sharing

Users can generate a shareable transformation image.

The generated image should include:
• original room photo
• wallpaper preview
• Wallfeel watermark

Sharing options:
• Instagram
• Pinterest
• WhatsApp
• Download image

⸻

Step 11 – Checkout via Shopify

When the user clicks Add to Cart, the AI platform sends the following data to Shopify:
• wallpaper design ID
• wall measurements
• selected material
• calculated price
• preview image

User then completes checkout on the Shopify store.

⸻

Image Enhancement Requirements

Preview images should be enhanced for quality.

Requirements:
• high-resolution rendering
• AI upscaling to 8K resolution
• image sharpening
• artifact reduction

Suggested tools:
• Real-ESRGAN
• diffusion upscaling models

⸻

Performance & Cost Considerations

To minimise infrastructure costs:
• separate lightweight computer vision tasks from generative AI tasks
• cache generated previews
• use GPU only when necessary
• run 8K upscaling as background jobs
• limit AI prompt generation to selected requests

⸻

Suggested Technology Stack

Frontend
React or Next.js

Backend
Python (FastAPI or Flask)

AI / Computer Vision
Segment Anything Model (SAM)
Stable Diffusion / ControlNet

Upscaling
Real-ESRGAN or equivalent

Infrastructure
AWS / RunPod / GCP GPU instances

Storage
Cloud storage for uploaded images and generated previews

⸻

Deliverables

Developer should provide:
• wall detection system
• wallpaper rendering engine
• AI design suggestion system
• prompt-based wallpaper generator
• measurement-based scaling
• material selection and price calculation
• image upscaling and sharpening pipeline
• before/after sharing feature
• API endpoints for Shopify integration
• deployment documentation

We are hiring freelancers or agencies for a Paper Mask Face Video Data Collection Project for machine learning.

Participant Requirements:

* Print their own face photo on high-quality paper.
* Cut only the eyes or the mouth area(as assigned).
* Use the cutout as a paper mask.
* Ready-made or reused masks are not allowed.

**Video Requirements:**

*Length:15–30 seconds
*Resolution: 1920 × 1080, minimum 30 FPS
* Format:MP4 or AVI
* Movements:Face straight, then slow left / right / up / down.
* Lighting: Indoor and outdoor (normal, dim, bright, and backlight.
* Background: Each video must have a different background.

*🔹 Compensation
Competitive payment will be provided per participant.

computer vision project with Halcon . The project involves recognizing, classifying, and counting 3D-printed flower models using an inexpensive webcam.

I am building a custom DIY UAV drone and looking for an experienced drone engineer to help design and integrate the flight control system. The project may involve flight controller setup, hardware integration, and testing.

Technical Requirements

Experience with at least one of the following:
• ArduPilot
• PX4 Autopilot
• Pixhawk

Tasks may include:
• UAV system architecture
• Flight controller configuration and tuning
• Integration of sensors (GPS, IMU, telemetry)
• Hardware selection (motors, ESCs, batteries)
• Simulation and flight testing
• Optional: AI / computer vision integration

• UAV / Drone Engineer Needed – Pixhawk, ArduPilot or PX4 Autopilot for DIY Drone Project
• Describe your recent experience with similar projects
• Please list any certifications related to this project
• How do you collaborate with all the parties on a design/construction project?
• What experience do you have working with different project types?

I’m preparing a full-length research article that applies neural-network models, coded in Python, to detect fabric defects in an industrial setting. The goal is not only to craft a solid, data-driven manuscript but to shepherd it all the way to acceptance in a Q2-ranked Scopus journal.

Scope of work
The study must cover end-to-end experimentation: sourcing or curating an open or proprietary fabric-image dataset, implementing and tuning the model, analysing results against relevant baselines, and articulating the implications for real-world textile quality control. Once the research is solid, the manuscript needs structuring to meet the target journal’s author guidelines, followed by submission, peer-review revisions, and final proof corrections until the paper receives an online-first DOI.

Key expectations
• Strong, reproducible Python code (TensorFlow/PyTorch preferred) and a concise repository or supplemental ZIP.
• Clear methodology, statistically sound evaluation, and visuals (confusion matrices, heatmaps, sample detections).
• Proper referencing in the journal’s citation style and compliance with originality checks (≤10 % similarity).
• Active liaison with the editorial office and prompt turnaround on reviewer comments.
• Final deliverables: accepted manuscript PDF, proofs, DOI link, source code, and any auxiliary data that can be publicly shared.

Acceptance criteria
The engagement is complete once the article is live on the journal’s site with an assigned DOI and indexing confirmation in Scopus.

If you have recent experience publishing in engineering or computer-vision venues indexed by Scopus and can manage both the technical research and the publishing workflow, let’s move forward.

Skills: Python, Statistics, Research Writing, Machine Learning (ML), Statistical Analysis, SPSS Statistics, Data Science, Neural Networks

Summary
Deploy a prototype edge-AI warehouse safety system using NVIDIA Jetson Orin Nano and YOLO to detect PPE breaches, proximity risks, and zone violations, with uploads to AWS S3 and Supabase.

Responsibilities:
• Configure Jetson Orin Nano (JetPack, multi-camera input, ~15–20 FPS inference)
• Implement and optimise YOLO detection pipeline across 3 camera streams
• Upload detection clips to S3 and log metadata to Supabase
• Build simple deployment scripts for multi-site rollout
• Provide setup, troubleshooting, and handover documentation

Tech:
Python, OpenCV, YOLO, NVIDIA Jetson, AWS S3, Supabase
Nice to have: Docker, TensorRT/ONNX, RTSP/IP cameras, React context

Deliverables:
• Working Jetson safety detection prototype
• Automated S3 + Supabase data pipeline
• Replicable deployment scripts (10+ sites)
• Documentation and 2–4 hour handover session

This has been posted both hourly and as a complete piece of work.

We are starting the development of a swarm robot based agricultural monitoring simulation system. The goal of this project is to simulate multiple robots (min 5)monitoring crops, detecting plant diseases, and estimating weed density using deep learning models, with results displayed on a live dashboard.

Project Overview
The simulation will run in Webots with 5 robots. Each robot will have a camera that captures images of the crop environment. Every 2 seconds, the system should capture the camera image and process it using two AI models.

AI Models

1. ResNet50 model (resnet50_disease.pth) for plant disease classification. The output should include the disease name and confidence score.
2. U-Net model (unet_weed.pth) for weed segmentation. The output should be a mask identifying weed pixels in the image.

Weed Density Calculation
Using the segmentation mask, weed density should be calculated as:

weed_density = (weed_pixels / total_pixels) * 100

Based on this percentage, the severity should be classified as:

* Low: 0–10%
* Moderate: 10–30%
* High: above 30%

Dashboard
We need a live dashboard built with Flask that automatically refreshes and displays the following for each robot:

* Live camera image with weed mask overlay
* Detected disease name
* Confidence score displayed as a bar
* Weed percentage
* Severity badge (Green for Low, Amber for Moderate, Red for High)
* Soil pH value

All 5 robots should appear as separate cards on the same dashboard page and update in real time.

Main Components

1. Webots robot controllers to capture images from each robot camera.
2. AI inference module to run ResNet50 and U-Net models.
3. Image processing module to calculate weed density and overlay masks.
4. Flask server to host the live dashboard.
5. Frontend dashboard to display results and auto-update.

Update Frequency
The system should process and update data every 2 seconds.

Expected Outcome
A fully working simulation where robots analyze crop images in real time and display disease detection and weed severity on a live monitoring dashboard.

Skills: Robotics, Image Processing, Flask, Data Visualization, Computer Vision, Deep Learning, Simulation

Deploy a prototype edge-AI warehouse safety system using NVIDIA Jetson Orin Nano and YOLO to detect PPE breaches, proximity risks, and zone violations, with uploads to AWS S3 and Supabase.

Responsibilities:
• Configure Jetson Orin Nano (JetPack, multi-camera input, ~15–20 FPS inference)
• Implement and optimise YOLO detection pipeline across 3 camera streams
• Upload detection clips to S3 and log metadata to Supabase
• Build simple deployment scripts for multi-site rollout
• Provide setup, troubleshooting, and handover documentation

Tech:
Python, OpenCV, YOLO, NVIDIA Jetson, AWS S3, Supabase
Nice to have: Docker, TensorRT/ONNX, RTSP/IP cameras, React context

Deliverables:
• Working Jetson safety detection prototype
• Automated S3 + Supabase data pipeline
• Replicable deployment scripts (10+ sites)
• Documentation and 2–4 hour handover session

We are seeking an experienced AI Developer to create a real-time coaching application for CS2/Faceit. The ideal candidate should be proficient in Python, computer vision, and text-to-speech (TTS) technologies. Your role will involve developing algorithms for real-time data analysis and providing actionable insights to players during gameplay. A strong understanding of gaming mechanics and user experience in esports is essential. If you are passionate about leveraging AI to enhance gaming performance, we want to hear from you!

Project Title: AI Fashion Stylist Mobile App Development

Project Overview

I am looking for a developer or small development team to build an AI-powered fashion stylist mobile application for iOS and Android. The goal of the app is to help users (primarily women) quickly decide what to wear by using artificial intelligence to analyze their wardrobe, suggest outfit combinations, and recommend accessories.

The application should function as a personal AI stylist that can analyze clothing items, generate outfit combinations, and suggest additional items that may complete the look.

⸻

Core Features
1. Digital Wardrobe Creation
Users will be able to upload photos of their clothing items (shirts, pants, dresses, shoes, bags, accessories).
The AI system should recognize and categorize these items automatically.
2. AI Outfit Recommendations
The app should generate outfit combinations based on the user’s wardrobe.
For example:

• White shirt
• Black pants
• Brown shoes
Suggested accessories:
• Gold necklace
• Small handbag

3. Compatibility Score (Outfit Matching Score)
Each outfit suggestion should include a compatibility score such as:

• Overall match: 92%
• Color harmony: 88%
• Body type compatibility: 90%

This helps users make faster decisions.
4. Virtual Try-On Feature (Optional / Advanced Feature)
Users can upload a photo of themselves and see how suggested outfits may look on their body.
5. Missing Item Recommendations
If the AI detects that an outfit is missing an item (for example a belt, jacket, or bag), the app should recommend products that complete the outfit.
6. Shopping Integration
The app may include links to external retailers such as Amazon, Zara, or ASOS so users can purchase suggested items.

⸻

Monetization Model
• Freemium app model
• Free version with limited features
• Premium subscription for unlimited outfit recommendations and advanced AI styling

⸻

Target Platform
• iOS
• Android

⸻

Technology Expectations

Developers experienced with the following are preferred:
• AI image recognition
• Computer vision
• Mobile app development
• Recommendation systems

⸻

First Version (MVP)

The first version should focus on:
• Clothing photo upload
• Clothing categorization
• AI outfit recommendations
• Compatibility scoring
• Basic shopping links

More advanced features (such as virtual try-on) can be added in later versions.

⸻

Goal

The goal is to create a simple, clean, and scalable AI stylist application that helps users quickly decide what to wear and discover new fashion combinations.

Please include examples of similar work, AI projects, or mobile applications you have developed.

Thank you.

I need a senior Azure OpenAI engineer to build Phase 1 of a vision‑based wound assessment tool for my wound‑care education platform. The tool will allow users to upload a wound image, send it to an Azure OpenAI Vision model, and return a structured JSON evaluation based on a rubric and schema I provide. This is an educational tool only—no clinical decision‑making.
The project includes:
• A secure backend using Azure OpenAI (GPT‑4 Vision or Azure Vision models)
• An image‑upload endpoint and processing workflow
• A structured evaluator that outputs JSON following my schema
• A clean, responsive UI for users to upload images and view results
• The ability to embed the tool in Moodle, on my website, and on social platforms
• Logging, error handling, and basic analytics
• Documentation for handoff
I will provide everything needed to begin immediately, including the rubric, JSON schema, system prompt, user prompt, API response contract, and UI layout.
This is a medium‑scope, 1–3 month, expert‑level project for someone with strong experience in Azure OpenAI, computer vision, backend API development (Python/FastAPI or Node/Express), and structured LLM outputs.Full rubric, JSON schema, prompts, and UI layout will be provided to shortlisted candidates.

Computer Vision Engineer (TensorFlow Preferred) — 6-Month Contract (Lahore or Remote)

Title: Computer Vision Engineer (TensorFlow/Keras) | Deep Learning + Production ML | 6-Month Contract
Project Length: 6 months
Hours: 20–40 hrs/week (flexible based on fit)
Location: Lahore (preferred) or Remote
Start: Immediately
Industry: Healthcare / Medical Imaging (computer vision)

Description

We are looking for an experienced Computer Vision Engineer for a 6-month contract to help us build and productionize modern deep learning models for real-world imaging workflows. This role requires strong hands-on TensorFlow (TF 2.x / Keras) experience and solid software engineering best practices (clean architecture, testing, Git discipline, production readiness).

What You’ll Do

Develop and improve computer vision models for:

Classification, detection, and segmentation

Implement and fine-tune modern architectures:

EfficientNet, ConvNeXt, ViT/Swin

Build image quality assessment pipelines (blur, illumination/exposure, artifacts, field-of-view, contrast/sharpness) and integrate into ingestion flows.

Apply advanced techniques:

Transfer learning, fine-tuning, robust augmentation

Self-supervised learning (MAE/DINO/SimCLR-style) when applicable

Domain adaptation/generalization for camera/device variability

Uncertainty estimation & calibration for safe thresholds

Create strong evaluation and reporting:

F1, AUROC, sensitivity/specificity, error analysis, ablations

Productionize models:

Packaging and deployment with TensorFlow Serving / TFLite / TF-TRT (as needed)

Optimize performance (latency/throughput/cost), reliability, and monitoring signals

Collaborate with product + engineering to ship tested, maintainable deliverables.

Required Skills

TensorFlow 2.x / Keras (preferred) + strong Python

Proven experience in at least one:

Segmentation (U-Net variants, DeepLab, Mask R-CNN)

Detection (YOLO-family, RetinaNet/Faster R-CNN, DETR-style)

Classification (multi-class/multi-label, multi-task)

Strong understanding of training best practices:

Losses, augmentation, imbalance handling, validation strategy

Strong software engineering habits:

Clean code, modular design, code reviews

Unit/integration testing

Git workflows, documentation, reproducibility

Nice to Have

TensorFlow deployment: TF Serving, TFLite, TF-TRT

MLOps & cloud: experiment tracking, model registry, AWS

Medical imaging familiarity (bonus): DICOM/DICOMWeb, clinical workflows

Explainability methods (Grad-CAM/saliency/attention maps)

Deliverables / Outcomes (Examples)

Baseline + improved model(s) with documented training/evaluation

Image quality gating module integrated into pipeline

Exported/served model (TF Serving / TFLite) with performance benchmarks

Reproducible training scripts + evaluation reports + tests

How to Apply (Please Include)

Resume / LinkedIn

GitHub or portfolio (if available)

A brief note: best TensorFlow CV model you shipped + where it ran (cloud/edge)

Your weekly availability + timezone

Multi-Sensor Fusion & Time-Series Thermal Analysis

We are rapid-prototyping a non-contact, IoT-connected monitoring device. The device uses a single multi-sensor array to track a dynamic subject's 3D spatial position, monitor localized movements, capture audio, and perform real-time, high-precision frequency analysis on specific localized thermal fluctuations.

The primary challenge of this project is applying sub-pixel micro-fluctuation analysis (such as Eulerian Video Magnification) and advanced bandpass filtering to thermal imaging data running entirely on a local hardware stack.

The Hardware Stack
Sensor: Luxonis OAK-T (Integrated RGB, Stereo Depth, and Thermal camera with onboard Myriad X VPU).

Host/Relay: Raspberry Pi 4/5 (or similar SBC) to handle external IoT communications and audio processing.

Audio: Standard USB Omni-directional microphone.

Core Responsibilities & Technical Requirements
We need a Python script/pipeline that successfully executes the following steps in real-time:

1. Sensor Fusion & Dynamic Tracking (DepthAI)

Utilize the OAK-T’s RGB and Depth sensors to detect a specific moving target, track its X/Y/Z spatial coordinates, and monitor general displacement/movement.

Detect specific landmarks/nodes on the target (using standard object tracking or landmark models) and accurately map those exact bounding boxes/ROIs onto the synchronized thermal video stream.

2. Low-Frequency Thermal Analysis

Isolate a specific thermal ROI based on the mapped coordinates.

Track low-frequency cyclical temperature fluctuations (approx. 0.2 Hz – 0.5 Hz) and calculate the cycle rate using peak detection algorithms.

3. High-Frequency Micro-Fluctuation Analysis (The Core Challenge)

Isolate a secondary thermal ROI on the moving target.

Extract the raw radiometric thermal data over time. Apply robust bandpass filters (approx. 0.8 Hz – 3.0 Hz) and FFT or EVM (Eulerian Video Magnification) techniques to isolate and extract a dominant micro-frequency from the thermal noise.

Note: The system must dynamically keep this ROI locked onto the correct part of the target even if the target shifts position.

4. Audio Capture

Integrate a basic continuous audio capture or acoustic anomaly trigger logging via the attached USB microphone.

5. IoT Connectivity (Bluetooth & WiFi)

Configure a BLE GATT server on the host SBC to accept WiFi network credentials from a mobile app.

Format the final processed data streams (Low-Frequency Rate, High-Frequency Rate, 3D Position, Movement Status) and push it via MQTT/HTTP to a cloud dashboard.

Ideal Candidate Profile
Proven experience with the Luxonis DepthAI API and mapping spatial coordinates across different sensor lenses.

Strong background in OpenCV, NumPy, and time-series signal processing (e.g., scipy.signal, FFT, bandpass filtering).

Prior experience with extracting micro-signals from video feeds (like EVM or similar academic frameworks) is highly preferred.

Experience with IoT deployments, BLE provisioning, and MQTT.

Deliverables
Fully commented, clean Python codebase that runs on the target hardware.

Documentation detailing how to install dependencies, run the pipeline, and adjust variables (like filter frequencies or ROI bounding box sizes).

A brief demonstration of the code successfully running and extracting the required frequencies from a test subject.

Budget & Structure: We are hiring on an hourly basis, ideally between $50 - $90/hr depending on experience.

Phase 1 (Feasibility): We will begin with a strict cap of 15 hours/week for the first 2 weeks. Your sole objective in Phase 1 is to run the raw thermal data through your DSP/EVM pipeline to prove that extracting the high-frequency micro-fluctuation (0.8 Hz – 3.0 Hz) is mathematically feasible with our hardware's signal-to-noise ratio.

Phase 2 (Integration): If Phase 1 yields a clean frequency output, we will lift the cap and proceed with integrating the DepthAI tracking, audio, and IoT connectivity.

I’m searching for a data scientist who can work directly with my collection of brain-tumor image data (MRI scans) and turn it into actionable insights that assist diagnosis. The raw DICOM files are already anonymised and sorted by patient, so you can dive straight into exploration, preprocessing, and model building.

Your task is to design and train a robust computer-vision pipeline—segmentation and/or classification—that highlights tumour regions and outputs clear metrics a radiologist can understand. I’m entirely open to your preferred stack; Python with PyTorch or TensorFlow is perfectly fine, and you can host experiments on Colab, a local GPU, or any cloud service you prefer. What matters most is transparent, reproducible code and well-explained results.

Please include:

• The full, well-commented source code and notebooks
• A brief technical report explaining methodology, performance scores, and limitations
• Inference instructions so I can run the model on new images without extra setup

If you have prior experience with medical imaging, all the better, but I value clarity and rigor above all. Let me know the approach you intend to take, the evaluation metrics you’ll target, and the approximate timeline you’ll need once you’ve reviewed a sample of the data.

Skills: Python, Software Architecture, Machine Learning (ML), Data Science, Image Processing, Data Visualization, Data Analysis, Computer Vision, Deep Learning, Classification

Key Points are:
1. Prompt Engineering: Design, test, and iterate on complex system instructions to ensure Gemini accurately categorizes lead quality based on unstructured data.
2. API Architecture: Configure and maintain the Google AI Studio API integration, including managing Temperature, Top-P, and Safety Settings to ensure consistent, structured (JSON) responses.
3. Quality Control: Establish a "ground truth" feedback loop to audit AI decisions and minimize false positives/negatives.
4. Data Enrichment: Implement logic to clean and format raw lead inputs before they reach the AI to improve processing accuracy.

Responsibilities
• Design system architecture for multi-sensor ingest and fusion
• Define backend, API, and event-driven architecture
• Lead development team and review code
• Design data model for events, tracks, alerts, incidents
• Define AI / analytics pipeline integration
• Design edge runtime and multi-node deployment model
• Ensure system is scalable and production-ready
• Work with product owner to define milestones

Required Skills
• Strong experience with distributed systems
• Experience with real-time data processing
• Experience with Linux-based systems
• Experience with containerization (Docker, etc.)
• Experience with APIs / microservices
• Experience with event-driven architecture
• Experience with GPU / AI pipelines is a plus
• Experience with robotics / drone / sensor systems is a plus

Preferred Experience
• Computer vision systems
• Drone / UAV software
• LiDAR / radar integration
• ISR / autonomy / robotics platforms
• Edge computing platforms
• Defense / security / surveillance systems

Work Type: Remote (U.S. only)
Employment Type: Contract
Compensation: $30–$50 per hour (depending on experience)
Start Date: Immediate — Project begins next week

We are looking for a skilled AI / ML Engineer to join our team and help build a high-accuracy biometric authentication system for a smart lock platform.

The goal of this project is to develop a facial recognition system with extremely low False Acceptance Rate (FAR < 0.01%), capable of identifying users accurately—even in challenging cases such as distinguishing identical twins.

Project Environment

- Training with large-scale biometric datasets such as MegaFace and mobile face recognition datasets
- Deployment architecture will be hybrid, supporting both edge devices (smart lock hardware) and cloud systems

Responsibilities
- Develop and train machine learning / deep learning models for face recognition
- Build and improve computer vision pipelines for identity verification
- Work with large-scale datasets to improve accuracy and reliability
- Optimize models for real-world deployment on edge devices and cloud systems

Requirements
- Strong experience in Machine Learning / Deep Learning
- Hands-on experience with Computer Vision
- Proficiency in Python and ML frameworks such as PyTorch or TensorFlow
- Experience working with large datasets and model training

Preferred
- Experience with face recognition systems
- Familiarity with models such as ArcFace, FaceNet, or similar
- Experience withLLMs or multimodal AI systems

Application
Please send:
- Your resume
- A short summary of your past Computer Vision or LLM projects
- Any GitHub, portfolio, or relevant work (if available)

We are prioritizing candidates who are available to start immediately, as the project will begin next week.

Skills: Java, Python, Software Architecture, Machine Learning (ML), Data Analysis, Computer Vision, Deep Learning, MERN Stack, Facial Recognition, AI Model Integration

We are looking for an experienced Python developer to build an AI tool that replaces wall and floor tiles in interior photos.
The tool must:

Accept inputs: room photo + reference tile photo + tile dimensions in cm
Replace wall or floor tiles with the reference tile texture photorealistically
Scale tiles mathematically correct using OpenCV (not estimated by AI)
Support laying patterns: straight, brick bond, herringbone, opus romain
Work on real photos AND 3D architectural renders
Process time max 60 seconds

We have a working prototype using Google Gemini API (gemini-3.1-flash-image-preview) that produces good color and texture results but inconsistent tile scaling. Ideal solution combines Gemini for texture replacement + mathematical OpenCV grid overlay for exact sizing.
Target use cases: bathrooms, living rooms, kitchens, new construction apartments where buyers want to visualize their chosen tile before purchasing.
Deliverable: Working Python script (Google Colab or standalone) or simple web interface. Clean documented code

.Please contact me before placing a bid. I will share example images including the original room photo, reference tile photos, and our best render result so far so you can fully understand the project scope.
Budget: fixed price preferred. Timeline: within 2 weeks.

Selam Alleikum,

We are looking for a senior react native developer, who will support us in developing a mobile application.

Job Title: Senior Computer Vision Engineer: Real-Time Ball Tracking for Tennis & Padel (Mobile)
Job Description:
We are developing SmashIt, a cutting-edge mobile app designed to provide professional-grade analytics for Padel and Tennis players. We are looking for an expert Computer Vision developer to build a high-performance, on-device tracking engine that works seamlessly across both sports.

The app uses a smartphone camera (mounted on a tripod) to analyze live gameplay. The goal is to provide instant feedback on ball trajectory, speed, and court logic.

Core Technical Challenges:
Dual-Sport Object Tracking: Robust tracking of high-speed balls (Tennis & Padel) in diverse lighting and backgrounds.

Complex Game Logic: Identifying line touches (In/Out), net hits, and sport-specific bounces (e.g., glass/wall bounces in Padel vs. standard Tennis court boundaries).

Mobile Optimization: Achieving 30+ FPS on modern iOS/Android devices while maintaining thermal stability (preventing CPU/GPU throttling).

Auto-Calibration: Seamless court detection and perspective correction for different court types and surfaces.

Requirements:
Expertise in Mobile AI: Deep experience with TensorFlow Lite, CoreML, or MediaPipe.

OpenCV & Video Pipelines: Strong background in C++ / Native modules for performance-critical tasks.

Mathematical Foundation: Experience with homography, camera calibration, and 3D-to-2D projection.

Proven Track Record: You must demonstrate previous work in motion analysis, sports tech, or real-time object detection on mobile.

Deliverables:
A cross-platform (C++/Native) library or optimized module for ball and court detection.

High-accuracy logic for "In/Out" and "Bounce Type" detection.

Performance benchmarks for mid-to-high-end mobile devices.

• Motion Blur: How will you handle motion blur for a high-speed ball on a 30fps mobile sensor to ensure accurate tracking?
• Thermal Stability: How do you plan to optimize the CV engine to prevent mobile overheating during a 60-minute match?
• Padel Logic: How would you distinguish between a valid court bounce and a wall/glass touch using a single-camera setup?
• Portfolio: Please share a link to a specific mobile project you’ve built involving real-time motion or sports tracking.

COMMONS CLIPPER
Hiring: ML Engineer
Real-Time Speaker Identification System (UK Parliament)

The Job
Build a real-time speaker identification system for UK Parliament TV. The system watches a live video stream of the House of Commons and identifies which of ~650 MPs is speaking, outputting speaker-labelled speech blocks (name, timestamps, transcript) as speeches happen.

Context
We run a working product that clips and delivers MP speech videos to parliamentary offices. Currently next-day delivery via an automated pipeline. We need to move to real-time delivery. A competitor has already solved this problem using face and voice recognition, so we know it’s achievable.
We have 3 months of correctly labelled training data: Parliament TV video + audio + confirmed speaker identity from official transcripts. We have a working downstream pipeline (clipping, rendering, delivery). We just need the speaker identification layer.

What You’d Build
A system that processes the Parliament TV stream and identifies who is speaking in real-time. It plugs into our existing infrastructure. We’re open on approach — face recognition, voice recognition, combined, black-box ML, or something else. We want your recommendation and reasoning.

We’re Looking For
Experience with speaker identification, face recognition, or speaker diarisation at scale
Comfortable with video/audio streams in Python
Experience with real-time ML inference
Delivers working, documented systems — not research prototypes

Details
Contract: Fixed-price or milestone-based
Location: Remote (UK timezone preferred)
Duration: 2–4 weeks estimated
Budget: Open — send your approach and quote
Full technical spec available for serious candidates. Get in touch with your relevant experience and how you’d approach the problem.

We are starting the development of a swarm robot based agricultural monitoring simulation system. The goal of this project is to simulate multiple robots (min 5)monitoring crops, detecting plant diseases, and estimating weed density using deep learning models, with results displayed on a live dashboard.

Project Overview
The simulation will run in Webots with 5 robots. Each robot will have a camera that captures images of the crop environment. Every 2 seconds, the system should capture the camera image and process it using two AI models.

AI Models

1. ResNet50 model (resnet50_disease.pth) for plant disease classification. The output should include the disease name and confidence score.
2. U-Net model (unet_weed.pth) for weed segmentation. The output should be a mask identifying weed pixels in the image.

Weed Density Calculation
Using the segmentation mask, weed density should be calculated as:

weed_density = (weed_pixels / total_pixels) * 100

Based on this percentage, the severity should be classified as:

* Low: 0–10%
* Moderate: 10–30%
* High: above 30%

Dashboard
We need a live dashboard built with Flask that automatically refreshes and displays the following for each robot:

* Live camera image with weed mask overlay
* Detected disease name
* Confidence score displayed as a bar
* Weed percentage
* Severity badge (Green for Low, Amber for Moderate, Red for High)
* Soil pH value

All 5 robots should appear as separate cards on the same dashboard page and update in real time.

Main Components

1. Webots robot controllers to capture images from each robot camera.
2. AI inference module to run ResNet50 and U-Net models.
3. Image processing module to calculate weed density and overlay masks.
4. Flask server to host the live dashboard.
5. Frontend dashboard to display results and auto-update.

Update Frequency
The system should process and update data every 2 seconds.

Expected Outcome
A fully working simulation where robots analyze crop images in real time and display disease detection and weed severity on a live monitoring dashboard.

Skills: Python, Statistics, Machine Learning (ML), Robotics, Frontend Development, Data Visualization, Computer Vision, Deep Learning, Simulation, AI Model Development

I am looking for an experienced AI/ML professional for a paid 1-hour consultation to discuss building and launching an AI product.

The ideal person should have hands-on experience with LLM development, quantization, and deployment, and should understand how to turn ML capabilities into real startup products.

Topics I want to discuss during the session:

Practical process of building AI products using existing LLMs (OpenAI, Hugging Face, open-source models, etc.)

Model quantization and optimization for cost-efficient deployment

Hosting and deployment options (cloud, APIs, inference servers)

Dataset creation and data annotation pipelines

How small teams can build AI startups using existing models

Monetization strategies (APIs, SaaS, datasets, AI services)

Guidance on building MVPs and scaling AI products

Preferred Background

Experience working with LLMs (LLaMA, Mistral, HuggingFace models, etc.)

Knowledge of model quantization, inference optimization, and deployment

Experience with ML/Deep Learning product development

Familiar with AI startup ecosystem

Preferably based in India or familiar with the Indian AI market

Technical Areas of Interest

Hugging Face ecosystem

Transformers and model fine-tuning

LLM inference frameworks (vLLM, TGI, Ollama, etc.)

Data annotation and dataset building

AI product architecture

Deliverable

1-hour video call consultation

High-level guidance and recommended roadmap

If possible, please share:

Your relevant AI/ML experience

Projects involving LLMs or ML deployment

GitHub or portfolio links

This consultation may lead to future collaboration for building an AI product.
Please start your proposal with the word LLM so I know you have read the full description.

Skills: Engineering, Machine Learning (ML), Mathematics, Data Science, Computer Vision, AI Development

AI Image and Video Generation Platform (Web Application)

Project Description

I am looking for an experienced full-stack developer or small development team to help build a web-based AI platform for advanced image and video generation.

The goal is to create a modern web application where users can generate images and videos using prompts and customize visual characteristics such as appearance, style, hair, body features, clothing, and scene settings. The system should also support transforming images into short videos.

Main Features

• AI image generation from prompts
• Image-to-video generation
• Character customization (hair, body features, appearance, style, etc.)
• High-quality video generation (1080p and potentially 4K)
• Web platform with user accounts and dashboard
• Prompt-based generation interface
• Cloud-based processing using GPU infrastructure
• Media storage and user library
• Scalable architecture for future expansion

Technical Requirements

The developer should have experience with:

• Python
• AI / Machine Learning frameworks
• Image generation models (Stable Diffusion or similar)
• Video generation models
• Backend development (Python / Node.js)
• Frontend development (React or similar framework)
• Cloud infrastructure (AWS, GCP or similar)
• GPU based model deployment
• Databa

I need someone to analyse whether an image is AI generated / fake of myself. I have sent someone a real image which they are sharing they have found images of me online of a sexual nature which I also have and want this analysed please

More details:

Is this project for business or personal use? Personal
What information should successful freelancers include in their application? Experience
How soon do you need your project completed? ASAP

Skills: Image Processing, Data Analysis, Computer Vision, AI Consulting, AI Image-to-text, Image Analysis, AI Image Editing, AI Model Development, AI Research, AI Development

Search: Computer Vision / Generative AI Engineer Needed

Project Brief: Wallfeel AI Wallpaper Visualizer & Design Generator

Project Overview

We are building an AI-powered wallpaper visualization tool for our brand Wallfeel.

The goal is to allow customers to:
1. Upload a photo of their room or wall
2. Automatically detect the wall surface
3. Generate AI wallpaper designs
4. Preview those designs applied realistically to their room
5. Select a material finish
6. Purchase the wallpaper via Shopify

The AI system should be built as a separate application and integrated with our Shopify website wallfeel.com via API.

⸻

Core Features

1. Room Image Upload

Users should be able to upload an image of a room or wall.

Supported formats:
• JPG
• PNG
• HEIC

The image will be used for wall detection and visualization.

⸻

2. AI Wall Detection (Segmentation)

The system must automatically detect the wall surfaces in the uploaded image.

Requirements:
• Segment the wall area using computer vision
• Preserve furniture, windows, and room perspective
• Generate a mask that allows wallpaper to be applied only to the wall

Suggested approaches:
• Segment Anything Model (SAM)
• semantic segmentation models

⸻

3. Theme-Based Wallpaper Design Generator (with Upscaling)

The system should allow users to generate wallpaper designs based on themes.

Example themes:
• Luxury marble
• Neutral textures
• Botanical / tropical
• Abstract modern art
• Kids murals
• Scandinavian minimal
• Geometric contemporary

Design Output

When a theme is selected, the AI should generate:

• 3 wallpaper designs within the selected theme
• 3 completely different wall style concepts for inspiration

Example output:

Theme designs:
• Gold marble wall
• Soft luxury plaster texture
• Neutral luxury stone texture

Alternative styles:
• Botanical mural
• Abstract art wall
• Minimal textured wall

Total outputs: 6 design options

⸻

High-Resolution Upscaling Requirement

All generated wallpaper designs must be upscaled for print quality.

Minimum requirements:
• Output resolution 8K or higher
• Suitable for large wall printing
• Avoid pixelation

Possible approaches:
• AI super-resolution
• tiled diffusion
• models such as Real-ESRGAN

The system should produce a high-resolution printable wallpaper file.

⸻

4. Wallpaper Visualization

Once the wall is detected:
• AI-generated designs should be applied to the wall
• Maintain perspective and lighting
• Provide realistic rendering

Users should be able to:
• switch between design options
• zoom into previews
• compare designs

⸻

5. Buy Button + Material Finish Selection

Each design preview should include an “Order This Wallpaper” option.

Before ordering, users should select a material finish.

Example material finishes:
• Smooth matte wallpaper
• Textured linen finish
• Peel & stick wallpaper
• Commercial vinyl wallpaper
• Premium mural finish

User flow:

Upload room
↓
Choose design theme
↓
Preview wallpaper designs
↓
Select material finish
↓
Click Order This Wallpaper
↓
Redirect to Shopify checkout

⸻

System Architecture

The system should be built as two connected platforms:

1. Shopify (Commerce Layer)

Shopify will handle:
• product catalogue
• material finish options
• cart and checkout
• payment processing
• customer orders

2. Wallfeel AI Application

The AI platform will handle:
• image upload
• wall detection
• AI wallpaper generation
• high-resolution upscaling
• room visualization
• preview rendering
• design storage

⸻

API Integration

The AI application must provide API endpoints so it can communicate with Shopify.

Example flow:

User uploads image → AI generates previews → user selects design + material → configuration is sent to Shopify cart → user completes purchase.

⸻

Suggested Technology Stack (Open to Suggestions)

Frontend:
• React / Next.js

Backend:
• Python (FastAPI or Flask)

AI / Computer Vision:
• Stable Diffusion
• ControlNet
• Segment Anything Model (SAM)

Upscaling:
• AI super-resolution models

Infrastructure:
• AWS / GCP / RunPod / GPU inference servers

Storage:
• cloud object storage for images and generated designs

⸻

Deliverables

The developer should provide:

• AI wallpaper generation engine
• wall segmentation system
• high-resolution upscaling pipeline
• room visualization rendering
• testing interface
• API endpoints for Shopify integration
• documentation for deployment and maintenance

⸻

Proposal Requirements

Please include in your proposal:
• examples of similar AI / computer vision projects
• suggested architecture for this system
• timeline estimate
• cost estimate
• recommended infrastructure

END

Need a clean, fast automation to scrape specific numbers visible on my trading screen every 2–5 seconds (high-speed live updates).
Task:
• Use OCR/computer vision to read numbers directly from the screen (no API).
• Calculate simple differences (current value vs previous read).
• Apply color coding and symbols based on positive/negative changes.
• Output everything live to Google Sheets or Excel (timestamp + raw values + diffs + colors).
• Add basic stale-data alert if numbers stop updating.
Must run smoothly during full trading hours with zero lag or freezing.
Required Skills:
• Power Automate Desktop or UiPath Studio (strong experience required)
• Screen OCR / computer vision for live apps
• Real-time loops & timing (every 2–5 seconds)
• Simple math + conditional formatting in Excel/Google Sheets
• Error handling and auto-retry logic
Fixed price. Deliver a ready-to-run flow I can use on my machine.
DM with “Screen Scrape” + recent RPA examples. Start ASAP.

I am looking for a Python developer with experience in computer vision and automation to build a bot for a mobile mini game.

The game runs on an iPhone that is mirrored to my Mac, and I control the game from the Mac. The bot would run on macOS and interact with the mirrored game window by detecting visual elements and triggering clicks.

There are a few mini games in the app. Each game lasts about 30 60 seconds.

Example mini games:

Timing Game:
A meter moves back and forth with a white line. When the line reaches a colored zone (orange or purple), the bot should trigger a click at the correct moment. The closer the timing is to the center of the zone, the higher the score.

Mole Game:
Moles appear on the screen and need to be tapped quickly to score points. The bot should detect Moles and click them while avoiding non-mole objects.

Requirements:

Python

Computer vision (OpenCV or similar)

Screen capture / image detection

Automated clicking

Script must run on macOS

Preferred:

Experience building screen based automation or game bots

Ability to add slight randomness to click timing/position so actions appear natural

Deliverables:

Working Python script

Instructions for running the script on macOS

Ability for me to run the bot locally on my machine

I can provide screen recordings or screenshots of the mini games to help with development.

I am focused on understanding the research foundations behind vision–language models rather than their applied aspects.

I enjoy learning about LLMs and vision–language models through applied problem solving, but problem solving itself is not the goal. My aim is to understand how to build AI models from the ground up at a research level.

If this is something you are interested in and feel you could help with, please let me know.

Poker Vision and GTO Analysis Tool — Developer Specification

Objective

Develop an offline application that analyzes recorded poker footage, screenshots, or manually entered hand data to detect the game state and generate GTO-based recommendations for post-session review and training.

The system is intended for study and hand analysis only. It must not provide live in-game assistance.

Scope

The application should:
• Detect hole cards, community cards, player positions, pot size, bet sizing, and approximate stack sizes from recorded media.
• Reconstruct the full hand state in a structured format.
• Pass the reconstructed state into a GTO analysis module or solver-based recommendation engine.
• Display recommendations, alternative lines, and relevant metrics in a simple user interface.
• Include testing, performance optimization, and documentation for long-term maintainability.

Recommended Technologies
• Python for rapid prototyping and backend development
• OpenCV for image and video processing
• PyTorch for model training and inference
• YOLO or a similar object detection model for card and chip recognition
• NumPy / Pandas for data processing
• PySide6 or Tkinter for the desktop interface
• Optional solver integration if precomputed strategy outputs are available

Development Plan

1. Define requirements and architecture
Before implementation, define the exact project goals, constraints, and module boundaries. The developer should specify:
• supported input types
• poker format(s)
• expected accuracy targets
• acceptable processing time
• target operating system(s)
• internal module interfaces

The system should be split into the following components:
• media input and frame extraction
• visual detection
• state reconstruction
• strategy analysis
• user interface
• testing and logging

2. Prepare and annotate datasets
Create or collect annotated datasets for:
• hole cards
• board cards
• chips or stack indicators
• table regions
• action areas
• pot and numeric displays

Tasks include:
• defining annotation rules
• labeling training images consistently
• creating train, validation, and test splits
• ensuring examples cover different lighting, resolutions, and layouts
• versioning the dataset for reproducibility

3. Build the media input module
Develop the media input layer to handle:
• recorded video files
• screenshots
• screen captures
• manually entered hand states for testing

This module should:
• extract frames at configurable intervals
• support cropping and region-of-interest selection
• normalize images before inference
• assign timestamps and frame identifiers for debugging

4. Implement card and stack detection
Train and deploy a visual detection model to identify:
• card ranks and suits
• community cards
• chip stacks or stack indicators
• relevant UI areas and seat locations

Tasks:
• train an object detection model such as YOLO
• add post-processing to reject invalid detections
• estimate stack sizes using visual chip counts or numerical overlays
• improve robustness against blur, occlusion, and inconsistent lighting

5. Reconstruct the poker state
Convert the detection outputs into a structured hand-state representation.

The output schema should include:
• hero cards
• board cards
• seat positions
• stack sizes
• pot size
• current street
• action history
• bet sizes
• effective stack
• frame or timestamp reference

This layer should also:
• combine detections across multiple frames
• resolve conflicting information
• validate impossible game states
• support manual correction in the interface when confidence is low

6. Integrate the GTO analysis module
Once the hand state is reconstructed, feed it into a strategy engine.

Input fields should include:
• position
• stack depth
• action sequence
• board texture
• hand combination
• betting context

The analysis module should return:
• recommended action
• strategy frequency
• EV or decision quality metrics
• optional alternative actions for comparison

This module may use:
• precomputed solver outputs
• lookup tables
• a trained policy approximation model
• a hybrid rules-plus-model architecture

7. Build the user interface
Create a simple interface that allows the user to:
• upload media
• inspect detected cards and stacks
• review reconstructed hand states
• correct detection mistakes manually
• view solver recommendations clearly

The UI should prioritize:
• readability
• fast correction workflows
• traceability between frames and detected states
• easy debugging for developers

8. Perform end-to-end testing
After the interface is functional, run full pipeline tests.

Validation should include:
• detection accuracy under different lighting and camera angles
• state reconstruction consistency
• reliability of the strategy output
• stability across different input sources
• acceptable processing time for offline review

9. Optimize performance
Once the pipeline works correctly, optimize:
• frame extraction speed
• inference time
• memory usage
• model size
• error recovery logic

The goal is to make the application stable, efficient, and usable on standard hardware.

10. Ensure continuous integration between modules
All modules must exchange data using clearly defined formats and interfaces. Add integration tests to ensure that changes in one component do not silently break another.

11. Run stress tests in different environments
Test the application on:
• different operating systems
• different screen resolutions
• different video qualities
• different table layouts
• longer sessions with many hands

This will improve robustness and reduce environment-specific failures.

12. Plan for long-term model maintenance
The system should support future retraining and improvement. This includes:
• collecting new annotated examples
• retraining detection models on updated layouts
• maintaining versioned datasets and models
• documenting retraining procedures
• tracking model performance over time

Documentation Requirements

Every module must be documented so another developer can understand and maintain the project. Documentation should include:
• module purpose
• inputs and outputs
• dependencies
• known limitations
• test procedures
• setup instructions
• deployment notes

Delivery Checklist
1. Requirements definition and technology selection
2. Dataset preparation and annotation
3. Media capture and input pipeline
4. Card and stack detection model
5. State reconstruction layer
6. GTO analysis integration
7. User interface
8. Accuracy and latency testing
9. Performance optimization
10. Cross-module integration checks
11. Stress testing across environments
12. Model maintenance and retraining plan
13. Full technical documentation and handoff

Skills: Python, Testing / QA, User Interface / IA, Machine Learning (ML), Software Development, Image Processing, OpenCV, Computer Vision, Object Detection, YOLO