Contact person: Business Client

Phone:Show

Email:Show

Location: Yakima, United States

Budget: Recommended by industry experts

Time to start: As soon as possible

Project description:
"Overview
I’m looking for an ML/LLM engineer (or small team) to:
• Fine-tune and deploy a high-quality open-weight LLM in the cloud
• Build a simple web interface for testing
• Expose a clean API that a mobile/web app can call

Use case is a guitar lesson app with structured lesson notes and input forms.

Model / stack (preferred, but open to suggestions)
• Base model: Llama 3.1 70B Instruct (or comparable high-quality open-weight model)
• Fine-tuning method: LoRA / QLoRA
• Deployment: single-GPU cloud instance (AWS/GCP/Azure) with vLLM or similar serving stack
• Backend: Python (FastAPI or similar) preferred

User/load profile:
• Fewer than 100 users to start
• Latency matters, but this is not ultra-high traffic

Core functions the system must support
1. Lesson notes → Input form

• Input: Free-text lesson notes (I’ll provide real examples)
• Output: A structured “input form” (JSON) describing:
• Student name, date, goals, assigned material, exercises, songs, notes, etc.
• This will be consumable by a frontend or app (consistent schema).

2. Input form → Lesson notes

• Input: The structured form (JSON in the same schema as above)
• Output: Clean, natural-language lesson notes in my voice/tone (fine-tuned on my data).

3. Edited notes → Difference analysis for model iteration

• Workflow:
• The model outputs lesson notes.
• I (or another teacher) manually edit/rewrite them.
• System accepts:
• Original model output
• Human-edited version
• It then:
• Compares tone, style, vocabulary, and structure
• Categorizes differences (e.g. “more concise intros”, “less fluff”, “adjusted technical vocabulary”, etc.)
• Stores this comparison as structured data (JSON) for later training/improvement
• If there is effectively no difference, that pair should be marked “do not use for training” (or excluded).

Important:
• I do NOT need automatic continuous training online.
• I DO need the data and labels organized so future fine-tuning / iteration is straightforward (clean JSONL, etc.).

Web interface requirements
A simple internal web UI where I can:
• Paste lesson notes → see generated form
• Paste a form JSON (or fill fields) → see generated lesson notes
• Upload/paste “model output + edited version” → see:
• Diff summary (what changed)
• Categories/tags of changes
• Confirmation that the pair is stored for future training (or skipped if no meaningful difference)

API requirements
• Authenticated HTTPS JSON API with clear endpoints, for example:
• POST /notes-to-form
• body: { notes: “…” }
• returns: { form: { … } }
• POST /form-to-notes
• body: { form: { … } }
• returns: { notes: “…” }
• POST /feedback-diff
• body: { original_notes: “…”, edited_notes: “…” }
• returns: { use_for_training: bool, diff_summary: “…”, categories: […], stored_id: “…” }
• Clear OpenAPI/Swagger docs or equivalent, so my app developer can integrate easily.

Data & privacy
• I will provide historical lesson notes and example forms.
• You must keep this data private and only use it for this project.
• Please advise on any basic security best practices for the API (auth tokens, HTTPS, etc.).

Deliverables
• Fine-tuned model weights/adapters (LoRA) and training scripts
• Deployed model on a cloud instance (AWS/GCP/Azure) with:
• Running inference server (vLLM or similar)
• Backend API layer (FastAPI or similar)
• Internal web UI for testing the three functions
• Data pipeline for storing:
• Input/output pairs
• Edited vs original notes comparisons
• Infrastructure/deployment instructions:
• Dockerfiles
• Basic setup docs (how to restart, redeploy, swap adapters, etc.)
• Short handover document:
• How to run training again with new data
• How to modify prompts/system messages
• How to adjust basic scaling settings

What to include in your proposal
• Short description of your experience with:
• LLM fine-tuning (especially LoRA/QLoRA and open-weight models like Llama/Qwen, etc.)
• Deploying LLMs on cloud GPUs (vLLM, TGI, or similar)
• Building simple, production-grade APIs
• Tech stack you propose to use
• Rough approach to:
• Fine-tuning on my lesson notes
• Designing the schema for forms and diff data
• Example of a similar project, if available
• Very rough timeline and ballpark budget range

I’m technical enough to understand architecture and data formats but I’m not an ML engineer, so I want a solution that’s as turn-key as possible once delivered." (client-provided description)