Train, build, and deploy AI/ML projects completely FREE.

This repo contains the exact tools I use to:

• Train ML/DL models
• Find datasets
• Deploy projects

No paid stuff,everything free to use.

---

Table of Contents

• Model Training (Free GPUs)
• Datasets & Pre-trained Models
• Computer Vision
• Deployment & Optimization
• YouTube / Learning Resources
• GitHub Repos
• Free AI Tools

---

Model Training

Most people know Google Colab and Kaggle, but there's hidden gem:- Marimo Molab:-

Platform	GPU (VRAM)	CPU/RAM	Session	Background Training	Runtime Disk	Persistent Storage
Marimo Molab	RTX Pro 6000 Blackwell (96 GB)	4/32 GB	Up to 12 hr	No	Not officially stated	Yes but quota not public
Kaggle	2× T4 (30 GB) / P100 (16 GB)	4/30 GB	Up to 12 hr	Yes (Save & Run / Commit )	50–60 GB	Your own Kaggle Datasets
Google Colab	T4 (15 GB)	2/12 GB	Variable	No	~100 GB	Google Drive

Extra Info

1) Marimo Molab (Powerful GPU)

Marimo is an open-source reactive Python notebook, and Molab is its free cloud notebook platform with GPU access.

• Built-in connectors for Google Drive, Amazon S3, Google Cloud Storage, Azure Blob Storage, and CoreWeave Object Storage.
• Marimo is reactive: run a cell or interact with a UI element, and it automatically re-runs dependent cells (or marks them stale), keeping code and outputs consistent.
• Notebooks are stored as pure Python (with SQL support), executable as scripts, and deployable as apps.

Best for:- Heavy LLM fine-tuning, computer vision, long runs with high VRAM needs.

2) Kaggle (A Balanced Platform)

• 30 hours/week usage, resets every Saturday.
• Kaggle Datasets can be attached directly to notebooks without downloading, making dataset loading extremely fast.
• Easily upload your own custom dataset/model and use it in a notebook.
• Supports background execution through Save Version → Save & Run All (Commit).
• Excellent community, competitions, notebooks, and discussions.

Best for: Medium-parameter model training, long runs.

3) Google Colab (Best for quick work)

• Usage hours aren't fixed and depend on system load; sessions may disconnect frequently.
• Doesn't run in the background, training stops when the tab is closed.
• Native Google Drive integration.

Best for: Testing, small experiments.

Kaggle Tip

Mistake: "I closed my tab and my training stopped!"

The Fix: You likely used an Interactive Session. Always use 'Save Version' → 'Save and Run All' for actual training.

My Thoughts

• If Molab is available, I'd choose it first because of the massive 96 GB VRAM.
• For most training jobs, I still prefer Kaggle for its stable sessions, background execution, and ecosystem.
• I mainly use Colab for quick experiments and inference.

Which GPU should you choose?

• RTX Pro 6000 (Blackwell): Currently the most powerful free cloud GPU. Ideal for LLM fine-tuning, large vision models, diffusion models, and workloads needing very high VRAM (96 GB).
• 2× T4: Strong for most computer vision and deep learning projects. Make sure your code can actually utilize both GPUs (DataParallel in PyTorch / MirroredStrategy in TensorFlow).
• P100: Capable if your model fits within 16 GB VRAM, though dual T4 is generally the better choice.
• If unsure: start with RTX Pro 6000.

---

Quick Setup

Marimo Molab:-

How to add Remote storages:-

Side Panel->Views Files->Remote Storagr

Add Remote Storage

How to Setup GPU:-

Top Middle Panel

Select GPU and Save

Utilisation

Kaggle:-

How to easily load Dataset/Model:-

From here you can load dataset/models(Add Input).Also can "Upload" Dataset/Model

Use "Add Input" for filters

Filters to access your uploaded Dataset/Model.

How to setup GPU:-

Create/open a notebook -> Settings -> Accelerator -> select GPU. Monitor usage via Draft Session panel.

For T4×2, use torch.nn.DataParallel (PyTorch) or tf.distribute.MirroredStrategy (TensorFlow) to utilize both GPUs, they won't both run automatically without this.

In Ultralytic's YOLO, in model training code, set device =[0,1] for dual and [0] for single gpu.

Select GPU Accelerator in Settings

Monitor your VRAM and usage here

Colab :-

How to load Dataset/Model:-

Folder icon to access the files of Notebook"

• Use 'Upload' icon to Upload Dataset/Model in the temporary files of notebook server.
• OR you can save the Dataset/Model on your Google Drive and mount the drive using Drive icon.
• if you prefer running code for mounting

from google.colab import drive
drive.mount('/content/drive')

How to setup GPU:-

Open notebook -> Runtime -> Change runtime type ->T4 GPU.

Click on "Change runtime type"

Select T4 GPU from the list

Check resource usage and runtime time remaining by clicking on graph in the corner

Note:- Training pauses if the tab is closed or session times out, and it also leads to loss of data notebook generated. Save the data(in zip) locally before closing of notebook.

You can this code in cell to zip the data.

zip -r YOURZIPNAME.zip DIRECTLYOFFOLDERSTOZIP

---

Datasets & Pre-trained Models

Kaggle

Kaggle is one of the largest free dataset repositories on the internet with millions of public datasets.

What's available:

• Tabular / CSV data:- Great for classical ML (regression, classification)
• Image datasets:- For CV tasks like image classification, detection, segmentation
• Audio and video datasets:- For speech/media projects
• NLP datasets:- Text classification, sentiment, translation
• Time-series datasets:- For forecasting tasks

Why it's useful:

• Datasets are community uploaded and regularly updated.
• Most popular datasets come with community notebooks, you can see exactly how others loaded and used the data (It's one of the underrated way to learn, to see how experts/experienced people write code).
• Direct integration with Kaggle notebooks means zero download time when training on the platform.

Hugging Face

Hugging Face is the largest open-source AI platform, think of it as GitHub for ML.

Datasets Covers nearly every ML task:

• NLP:- Classification, NER, translation, summarization, Q&A
• Computer Vision:- Classification, detection, segmentation, depth, GAN, Stable Diffusion
• Audio:- ASR, speaker identification, audio classification
• Multimodal:- image-text, video-text, document understanding

Load any dataset in one line:-

from datasets import load_dataset
dataset = load_dataset("dataset-name")

Pre-trained Models This is where Hugging Face really shines. Instead of training from scratch (which costs time and compute), you can easily load a pre-trained model and fine-tune it on your specific data.

Some examples:-

• LLMs :- LLaMA, Mistral, Qwen, Gemma, Phi
• Vision :- ViT, CLIP, SAM, DETR, RT-DETR
• Audio :- Whisper, Wav2Vec 2.0, HuBERT
• Multimodal :- BLIP, LLaVA, Florence, Idefics
• Embeddings :- sentence-transformers, BGE, E5

My suggestion: Before training anything from scratch, always search Hugging Face first. Chances are a model already exists that's 80-90% of the way to what you need. You just need to fine-tune it on your data.

---

Computer Vision

Roboflow Universe is a great platform for computer vision datasets and models (classification, detection, segmentation, OBB, keypoints, and more).

Dataset Tools

• Upload, resize, and version your datasets
• Data augmentation with many options, no coding needed
• Auto-label, manual label, or professional human labeling

Model Export

• Download datasets or code snippets for YOLO, DETR, RF-DETR, GroundingDINO, and more

Deployment & Inference

• Easy model deployment with a featured workflow builder (similar to n8n)
• Use pre-trained models for quick inference and testing

---

Deployment & Optimization

Model Optimization (The "Secret" to Smooth Demos)

Don't deploy your raw training model file (.pt, .keras, .h5) directly. They are heavy and slow. Always optimize your model before deployment.

There are two things I suggest to follow:

1. Export Format (Changing the architecture)

Exporting converts your model from its training format into a format optimized for inference.

• ONNX (Open Neural Network Exchange):- A universal format that works across frameworks and hardware. Models run using onnxruntime, which is much lighter (~200 MB) than installing full PyTorch or TensorFlow (~2–4 GB) on your server.

• OpenVINO:- Intel's inference format. Only for Intel CPUs, but gives significantly faster inference on local machines compared to ONNX.

• TensorRT:- NVIDIA's inference format. Only for NVIDIA GPUs, best for maximum speed on GPU deployment.

2. Quantization (Reducing the precision)

Quantization reduces the numerical precision of your model weights, making the model smaller and faster with a small accuracy tradeoff.

Precision	Best For	Speed	Accuracy Drop
FP32	Training (default)	Slowest	None
FP16	GPU inference	Fast	~0-1%
INT8	CPU inference	Fastest	~1–3%

Rule of thumb:- Use FP16 when deploying on GPU, INT8 when deploying on CPU.

Recommended Combinations:-

Hardware	Format	Precision
Any CPU	ONNX	INT8
Intel CPU	OpenVINO	INT8
Any GPU	ONNX	FP16
NVIDIA GPU	TensorRT	FP16/INT8

Start with ONNX. Only move to TensorRT or OpenVINO if you need maximum speed.

Where to Deploy

• Hugging Face(Best for ML Demos):
• Live Demos: I suggest Gradio or Streamlit to build a web interface in pure Python easily.
• Hardware: Provides free CPU basic tiers. If your model is optimized (ONNX), it will run smoothly even without a free GPU.
• Storage: Free unlimited storage for public model weights and dataset repositories.

Render / Railway.(Best for Backends):

• Great for hosting a FastAPI or Flask web server that serves your model as an API.

Vercel / Netlify (Best for Frontends):

• Use these if you built a custom React/Vue/Next.js frontend to talk to your Hugging Face or Render backend.

---

YouTube / Learning Resources

• Campus X :- Run by Nitish Singh. Historically known as a Hindi-medium channel, but recent content (RAG, LangGraph, n8n, agentic AI) has shifted mostly to English. Covers Math for ML, classical ML, deep learning, LLMs, and Agentic AI. Best structured course channel for data science.

• Krish Naik :- Main channel is primarily English/Hinglish, covering end-to-end ML project walkthroughs and new tools/frameworks. He also runs a separate dedicated channel, Krish Naik Hindi, for the same content fully in Hindi.

• Andrej Karpathy :- Ex-OpenAI co-founder, former Tesla AI lead, and now part of Anthropic's pre-training team. Builds neural networks from scratch (GPT, tokenizers, backprop). Best channel if you want deep intuition over how things actually work.

• NeuralNine :- Run by Florian Dedov, freelance programmer and ML engineer who also authors Python/Algorithm books. Covers Python, cybersecurity, ML/DL, and general CS through practical, code-heavy tutorials with a strong "build it live" style. Very simple explanation for hands-on project-based learning.

• 3Blue1Brown :- Run by Grant Sanderson. Visual explanations of Maths behind Machine Learning algorithms, neural networks etc. Highly recommended for building intuition before diving into code.

• d2l.ai :- Dive into Deep Learning. Interactive textbook with theory with runnable code. Covers everything from linear models to transformers.

---

GitHub Repos

• CS Video Courses :— Detailed list of CS courses with video lectures
• 500 AI/ML Projects with Code
• MLOps Zoomcamp :— Free MLOps course by DataTalks.Club

---

Free AI Tools

LMArena :- Compare, test, and chat with dozens of open-source and proprietary LLMs for free side-by-side.

Gamma AI :- Generate beautiful presentation slides using simple text prompts. I use it for presenting ML projects.

I suggest using temp email. to keep your main inbox free from promotional spam.

---

My Workflow

1. Dataset :- Kaggle / Roboflow/ Hugging Face
2. Data Processing :- Roboflow (for computer vision tasks)
3. Training :- Marimo Molab/Kaggle
4. Testing :- On local CPU/T4 gpu (ONNX FP16/INT8 format)
5. Deployment :- Hugging Face Spaces

This is the pipeline I use for most of my projects.

Why this repo?

I created this to help people who:-

• Don’t have high-end laptops
• Can’t afford paid GPUs
• Still want to build real AI/ML projects

Everything here is tested and actually used by me.

If this repo helps you, consider giving it a star. ⭐