Empowering Students Through AI & Quantum Computing

Join middle school students across the nation in exploring artificial intelligence, machine learning, and quantum computing through hands-on projects and expert mentorship.

Register Your School Learn More
AIMLSE Program
15
Week Program
6-8
Grade Levels
5
Team Leaders
Our Mission

Democratizing Technology Education

AIMLSE is a nonprofit organization dedicated to empowering middle school students (6th–8th grade) with the knowledge and skills to explore AI, machine learning, and quantum computing through collaborative, project-based learning.

πŸŽ“

Expert-Led Learning

Professional video instruction and live mentorship from experienced educators and technology professionals who guide students every step of the way.

πŸ’»

Hands-On Projects

Build real AI applications, train machine learning models, and explore quantum algorithms through engaging, practical projects.

🀝

Discord-Based Collaboration

Join a vibrant Discord community where students work together, share ideas, and learn from peers across the country in a safe, moderated environment.

πŸš€

Future-Ready Skills

Develop computational thinking, problem-solving, and innovation skills that prepare students for tomorrow's technology careers.

🎯

Structured Curriculum

Carefully designed 15-week learning path covering mathematics, programming, AI fundamentals, and quantum computing basics.

πŸ‘¨β€πŸ«

Teacher Support

Teachers supervise and provide classroom space while AIMLSE delivers all instructional content and mentorshipβ€”no prior AI experience needed.

What We Teach

Explore Cutting-Edge Technologies

Students dive deep into the most transformative technologies shaping our future, building practical skills through guided projects and real-world applications.

πŸ€–

Artificial Intelligence

Master the fundamentals of AI systems that can analyze data, recognize patterns, and make intelligent decisions. Learn to build neural networks, train models, and create AI applications that solve real-world problems.

βš›οΈ

Quantum Computing

Explore the revolutionary world of quantum mechanics applied to computation. Understand qubits, superposition, and entanglement while building quantum circuits and algorithms that unlock unprecedented processing power.

15-Week Journey

Comprehensive Curriculum

Our structured program takes students from foundational concepts to advanced applications, ensuring mastery at every step.

Weeks 1-2

Mathematical Foundations

Review essential math concepts needed for AI and machine learning. Concludes with a short assessment to ensure readiness for advanced topics.

Weeks 3-4

Machine Learning Concepts

Introduction to machine learning fundamentals, tensors, and basic ML operations that form the foundation of AI systems.

Weeks 5-6

Python Programming

Learn Python coding fundamentals and complete programming exercises to prepare for AI project development.

Weeks 7-8

AI Programming Projects

Build practical AI applications including linear regression models, learn ReLU layers and activation functions, and practice modular programming.

Weeks 9-10

Quantum Computing

Introduction to quantum computing principles, explore quantum algorithms, and discover real-world applications of quantum technology.

Weeks 11-15

Advanced Projects & Capstone

Apply your knowledge to real-world challenges, participate in hackathons, and complete a capstone project showcasing your AI and quantum computing skills.

Meet Our Team

Leadership Team

Passionate educators and technologists dedicated to empowering the next generation of innovators.

SM

Sourish Mishra

Founder & CEO

Manages the organization, develops software infrastructure, creates video lessons, and directly teaches students.

AG

Aarav Gupta

Co-Founder & COO

Coordinates meetings, monitors program progress, and supports day-to-day operations.

AG

Arnav Gupta

Co-Founder & Communication Coordinator

Contacts schools to join the program and manages external communications.

GB

Gagan Buggeneini

Co-Founder & Head of Marketing

Manages social media presence, outreach initiatives, and marketing campaigns.

SG

Siya Gupta

Volunteer Coordinator

Manages volunteers for events and program support across all AIMLSE initiatives.

Get Started

How to Join AIMLSE

Getting started is easy! Follow these simple steps to bring AI and quantum computing education to your school.

πŸ‘¨β€πŸŽ“

For Students

1. Complete the Student Interest Survey

2. Share aimlse.org with your teacher so they can register your school

πŸ‘¨β€πŸ«

For Teachers

1. Register your school's club through our registration form

2. Supervise students and provide a classroomβ€”AIMLSE handles all instructional content

🀝

For Volunteers

1. Apply through our volunteer application

2. Join our team to mentor students and support program operations

Ready to Transform Your Classroom?

Join educators and students across the nation in exploring AI and quantum computing. Register your school today and bring cutting-edge technology education to your students.

Register Your School Student Interest Survey
import React, { useState } from 'react'; import { Trash2, Play, Download, Database, RotateCcw } from 'lucide-react'; const PyTorchBlockBuilder = () => { const [blocks, setBlocks] = useState([]); const [draggedBlock, setDraggedBlock] = useState(null); const [generatedCode, setGeneratedCode] = useState(''); const [showCode, setShowCode] = useState(false); const [selectedDataset, setSelectedDataset] = useState('mnist'); const datasets = { mnist: { name: 'MNIST Digits', description: 'Handwritten digits (28x28 grayscale)', inputShape: '1x28x28', outputClasses: 10, color: 'bg-cyan-600' }, cifar10: { name: 'CIFAR-10', description: 'Color images (32x32 RGB)', inputShape: '3x32x32', outputClasses: 10, color: 'bg-teal-600' }, fashion: { name: 'Fashion-MNIST', description: 'Fashion items (28x28 grayscale)', inputShape: '1x28x28', outputClasses: 10, color: 'bg-indigo-600' }, iris: { name: 'Iris Dataset', description: 'Flower measurements (4 features)', inputShape: '4', outputClasses: 3, color: 'bg-pink-600' } }; const blockTypes = { input: [ { id: 'input', name: 'Input', icon: 'πŸ“₯', color: 'bg-gradient-to-br from-cyan-500 to-blue-500', params: ['size'], shape: 'hexagon' } ], conv: [ { id: 'conv2d', name: 'Conv2D', icon: 'πŸ”²', color: 'bg-gradient-to-br from-blue-500 to-blue-600', params: ['out_channels', 'kernel_size', 'stride', 'padding'], shape: 'puzzle-top' }, { id: 'conv2d_3x3', name: 'Conv2D 3Γ—3', icon: '⊞', color: 'bg-gradient-to-br from-blue-400 to-blue-500', params: ['out_channels'], shape: 'puzzle-top' }, { id: 'conv2d_5x5', name: 'Conv2D 5Γ—5', icon: '⊑', color: 'bg-gradient-to-br from-blue-600 to-blue-700', params: ['out_channels'], shape: 'puzzle-top' }, ], pooling: [ { id: 'maxpool2d', name: 'MaxPool2D', icon: '⬇️', color: 'bg-gradient-to-br from-purple-500 to-purple-600', params: ['kernel_size', 'stride'], shape: 'puzzle-mid' }, { id: 'avgpool2d', name: 'AvgPool2D', icon: 'πŸ“Š', color: 'bg-gradient-to-br from-purple-400 to-purple-500', params: ['kernel_size'], shape: 'puzzle-mid' }, { id: 'adaptiveavg', name: 'AdaptiveAvg', icon: '🎯', color: 'bg-gradient-to-br from-purple-600 to-purple-700', params: ['output_size'], shape: 'puzzle-mid' }, ], linear: [ { id: 'flatten', name: 'Flatten', icon: 'β–­', color: 'bg-gradient-to-br from-orange-500 to-orange-600', params: [], shape: 'puzzle-mid' }, { id: 'linear', name: 'Linear', icon: '➑️', color: 'bg-gradient-to-br from-green-500 to-green-600', params: ['out_features'], shape: 'puzzle-mid' }, { id: 'linear_small', name: 'Linear 128', icon: 'β†’', color: 'bg-gradient-to-br from-green-400 to-green-500', params: [], shape: 'puzzle-mid' }, { id: 'linear_large', name: 'Linear 512', icon: 'β‡’', color: 'bg-gradient-to-br from-green-600 to-green-700', params: [], shape: 'puzzle-mid' }, ], activation: [ { id: 'relu', name: 'ReLU', icon: 'πŸ“ˆ', color: 'bg-gradient-to-br from-lime-500 to-lime-600', params: [], shape: 'puzzle-mid' }, { id: 'leakyrelu', name: 'LeakyReLU', icon: 'πŸ“‰', color: 'bg-gradient-to-br from-lime-400 to-lime-500', params: ['negative_slope'], shape: 'puzzle-mid' }, { id: 'sigmoid', name: 'Sigmoid', icon: '〰️', color: 'bg-gradient-to-br from-lime-600 to-lime-700', params: [], shape: 'puzzle-mid' }, { id: 'tanh', name: 'Tanh', icon: '∿', color: 'bg-gradient-to-br from-lime-500 to-green-600', params: [], shape: 'puzzle-mid' }, { id: 'softmax', name: 'Softmax', icon: '🎲', color: 'bg-gradient-to-br from-lime-700 to-green-700', params: ['dim'], shape: 'puzzle-mid' }, ], regularization: [ { id: 'dropout', name: 'Dropout', icon: 'πŸ’§', color: 'bg-gradient-to-br from-red-500 to-red-600', params: ['p'], shape: 'puzzle-mid' }, { id: 'dropout2d', name: 'Dropout2D', icon: 'πŸ’¦', color: 'bg-gradient-to-br from-red-400 to-red-500', params: ['p'], shape: 'puzzle-mid' }, { id: 'batchnorm1d', name: 'BatchNorm1D', icon: 'πŸ“', color: 'bg-gradient-to-br from-yellow-500 to-yellow-600', params: ['num_features'], shape: 'puzzle-mid' }, { id: 'batchnorm2d', name: 'BatchNorm2D', icon: 'πŸ“', color: 'bg-gradient-to-br from-yellow-600 to-yellow-700', params: ['num_features'], shape: 'puzzle-mid' }, ], output: [ { id: 'output', name: 'Output', icon: 'πŸ“€', color: 'bg-gradient-to-br from-pink-500 to-red-500', params: ['classes'], shape: 'puzzle-bottom' } ], }; const handleDragStart = (e, blockType, category) => { setDraggedBlock({ ...blockType, category }); e.dataTransfer.effectAllowed = 'copy'; }; const handleDrop = (e) => { e.preventDefault(); if (draggedBlock) { const newBlock = { ...draggedBlock, id: ${draggedBlock.id}_${Date.now()}, values: {} }; draggedBlock.params.forEach(param => { newBlock.values[param] = getDefaultValue(param, draggedBlock.id); }); setBlocks([...blocks, newBlock]); setDraggedBlock(null); } }; const getDefaultValue = (param, blockId) => { const defaults = { 'size': datasets[selectedDataset].inputShape, 'out_channels': 32, 'kernel_size': 3, 'stride': 1, 'padding': 1, 'out_features': 128, 'num_features': 64, 'p': 0.5, 'negative_slope': 0.01, 'dim': 1, 'output_size': 1, 'classes': datasets[selectedDataset].outputClasses }; if (blockId === 'linear_small') return 128; if (blockId === 'linear_large') return 512; if (blockId === 'conv2d_3x3') return 32; if (blockId === 'conv2d_5x5') return 64; return defaults[param] || 1; }; const handleDragOver = (e) => { e.preventDefault(); e.dataTransfer.dropEffect = 'copy'; }; const removeBlock = (blockId) => { setBlocks(blocks.filter(b => b.id !== blockId)); }; const updateBlockValue = (blockId, param, value) => { setBlocks(blocks.map(block => block.id === blockId ? { ...block, values: { ...block.values, [param]: value } } : block )); }; const generateCode = () => { let code = import torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torchvision\nimport torchvision.transforms as transforms\n\n; code += # Load ${datasets[selectedDataset].name}\n; if (selectedDataset === 'mnist') { code += transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n; code += trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n; code += testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n; } else if (selectedDataset === 'cifar10') { code += transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n; code += trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n; code += testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)\n; } else if (selectedDataset === 'fashion') { code += transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n; code += trainset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform)\n; code += testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform)\n; } code += trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)\n; code += testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)\n\n; code += class MyModel(nn.Module):\n; code += def __init__(self):\n; code += super(MyModel, self).__init__()\n; const layerBlocks = blocks.filter(b => !['input', 'output'].includes(b.id.split('_')[0])); layerBlocks.forEach((block, idx) => { const blockType = block.id.split('_')[0]; if (blockType === 'conv2d') { const inChannels = idx === 0 ? (selectedDataset === 'cifar10' ? 3 : 1) : 32; if (block.params.length > 1) { code += self.layer${idx + 1} = nn.Conv2d(${inChannels}, ${block.values.out_channels}, kernel_size=${block.values.kernel_size}, stride=${block.values.stride}, padding=${block.values.padding})\n; } else { const kernel = block.id.includes('3x3') ? 3 : 5; code += self.layer${idx + 1} = nn.Conv2d(${inChannels}, ${block.values.out_channels}, kernel_size=${kernel}, padding=${Math.floor(kernel/2)})\n; } } else if (blockType === 'maxpool2d') { code += self.layer${idx + 1} = nn.MaxPool2d(kernel_size=${block.values.kernel_size}, stride=${block.values.stride})\n; } else if (blockType === 'avgpool2d') { code += self.layer${idx + 1} = nn.AvgPool2d(kernel_size=${block.values.kernel_size})\n; } else if (blockType === 'adaptiveavg') { code += self.layer${idx + 1} = nn.AdaptiveAvgPool2d(${block.values.output_size})\n; } else if (blockType === 'linear') { const outFeatures = block.params.length > 0 ? block.values.out_features : (block.id.includes('small') ? 128 : 512); code += self.layer${idx + 1} = nn.Linear(512, ${outFeatures}) # Adjust input size based on previous layers\n; } else if (blockType === 'dropout') { code += self.layer${idx + 1} = nn.Dropout(p=${block.values.p})\n; } else if (blockType === 'dropout2d') { code += self.layer${idx + 1} = nn.Dropout2d(p=${block.values.p})\n; } else if (blockType === 'batchnorm1d') { code += self.layer${idx + 1} = nn.BatchNorm1d(${block.values.num_features})\n; } else if (blockType === 'batchnorm2d') { code += self.layer${idx + 1} = nn.BatchNorm2d(${block.values.num_features})\n; } else if (blockType === 'flatten') { code += self.layer${idx + 1} = nn.Flatten()\n; } }); const outputBlock = blocks.find(b => b.id.startsWith('output')); if (outputBlock) { code += self.output = nn.Linear(128, ${outputBlock.values.classes})\n; } code += \n def forward(self, x):\n; blocks.filter(b => !['input', 'output'].includes(b.id.split('_')[0])).forEach((block, idx) => { const blockType = block.id.split('_')[0]; if (['conv2d', 'maxpool2d', 'avgpool2d', 'adaptiveavg', 'linear', 'dropout', 'dropout2d', 'batchnorm1d', 'batchnorm2d', 'flatten'].includes(blockType)) { code += x = self.layer${idx + 1}(x)\n; } else if (blockType === 'relu') { code += x = torch.relu(x)\n; } else if (blockType === 'leakyrelu') { code += x = torch.nn.functional.leaky_relu(x, negative_slope=${block.values.negative_slope})\n; } else if (blockType === 'sigmoid') { code += x = torch.sigmoid(x)\n; } else if (blockType === 'tanh') { code += x = torch.tanh(x)\n; } else if (blockType === 'softmax') { code += x = torch.softmax(x, dim=${block.values.dim})\n; } }); if (outputBlock) { code += x = self.output(x)\n; } code += return x\n\n; code += # Initialize model\n; code += model = MyModel()\n; code += criterion = nn.CrossEntropyLoss()\n; code += optimizer = optim.Adam(model.parameters(), lr=0.001)\n\n; code += # Training loop\n; code += for epoch in range(10):\n; code += running_loss = 0.0\n; code += for i, data in enumerate(trainloader, 0):\n; code += inputs, labels = data\n; code += optimizer.zero_grad()\n; code += outputs = model(inputs)\n; code += loss = criterion(outputs, labels)\n; code += loss.backward()\n; code += optimizer.step()\n; code += running_loss += loss.item()\n; code += print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')\n; setGeneratedCode(code); setShowCode(true); }; const downloadCode = () => { const blob = new Blob([generatedCode], { type: 'text/plain' }); const url = URL.createObjectURL(blob); const a = document.createElement('a'); a.href = url; a.download = 'pytorch_model.py'; a.click(); }; const getPuzzleStyle = (shape) => { const base = "relative"; return base; }; return ( 🧩 PyTorch Puzzle Builder Snap blocks together like puzzle pieces! {/* Dataset Selector */} Choose Your Dataset {Object.entries(datasets).map(([key, dataset]) => ( setSelectedDataset(key)} className={${dataset.color} ${selectedDataset === key ? 'ring-4 ring-white scale-105' : 'opacity-60 hover:opacity-80'} text-white p-4 rounded-lg transition-all transform} > {dataset.name} {dataset.description} Input: {dataset.inputShape} | Classes: {dataset.outputClasses} ))} {/* Block Palette */} {Object.entries(blockTypes).map(([category, items]) => ( {category} {items.map((block) => ( handleDragStart(e, block, category)} className={${block.color} ${getPuzzleStyle(block.shape)} text-white p-3 rounded-lg cursor-move hover:scale-105 transition-transform shadow-lg border-2 border-white border-opacity-30} > {block.icon} {block.name} {block.params.length > 0 && ( {block.params.join(', ')} )} ))} ))} {/* Build Area */} πŸ—οΈ Build Your Network Generate Code setBlocks([])} disabled={blocks.length === 0} className="flex items-center gap-2 bg-gradient-to-r from-red-500 to-pink-600 hover:from-red-600 hover:to-pink-700 disabled:from-slate-600 disabled:to-slate-700 text-white px-4 py-2 rounded-lg transition-all shadow-lg font-semibold" > Reset {blocks.length === 0 ? ( 🧩 Drag puzzle pieces here! Start with an Input block ) : ( {blocks.map((block, idx) => ( {idx + 1} {block.icon} {block.name} {block.params.length > 0 && ( {block.params.map(param => ( {param}: updateBlockValue(block.id, param, parseFloat(e.target.value) || 0)} className="bg-white text-slate-900 px-2 py-1 rounded w-16 text-sm font-bold" /> ))} )} removeBlock(block.id)} className="bg-red-500 hover:bg-red-600 p-2 rounded-lg transition-colors opacity-0 group-hover:opacity-100 shadow-lg" > ))} )} {/* Generated Code */} {showCode && ( πŸ’» Your PyTorch Code Download .py {generatedCode} )} ); }; export default PyTorchBlockBuilder; run this code Show less I'll create this PyTorch Puzzle Builder for you! This is a fun, visual way to build neural networks by dragging and dropping blocks. PyTorch Puzzle Builder Interactive artifact I've created the PyTorch Puzzle Builder! This interactive tool lets you visually construct neural networks by dragging and dropping blocks. Here's what you can do: Features: 🎯 Choose a dataset (MNIST, CIFAR-10, Fashion-MNIST, Iris) 🧩 Drag blocks from the palette to build your network βš™οΈ Customize parameters for each layer πŸ”₯ Generate PyTorch code automatically πŸ’Ύ Download the complete Python script Available blocks: Input/Output layers Convolutional layers (Conv2D variants) Pooling layers (MaxPool, AvgPool, Adaptive) Linear/Dense layers Activation functions (ReLU, LeakyReLU, Sigmoid, Tanh, Softmax) Regularization (Dropout, BatchNorm) Just drag blocks into the build area, adjust their parameters, and click "Generate Code" to get a complete, ready-to-run PyTorch training script! he torch package contains data structures for multi-dimensional tensors and defines mathematical operations over these tensors. Additionally, it provides many utilities for efficient serialization of Tensors and arbitrary types, and other useful utilities. It has a CUDA counterpart, that enables yo pasted add these functions and some numpy funtions I'll enhance the PyTorch Puzzle Builder with additional PyTorch functions and NumPy operations! PyTorch Puzzle Builder Interactive artifactβ€‚βˆ™β€‚Version 2 PyTorch Puzzle Builder Interactive artifactβ€‚βˆ™β€‚Version 5 Perfect! I've enhanced the PyTorch Puzzle Builder with many new features: New Additions: Additional PyTorch Layers: Conv1D - 1D convolutions for sequence data MaxPool1D - 1D max pooling LayerNorm - Layer normalization More Activation Functions: ELU (Exponential Linear Unit) GELU (Gaussian Error Linear Unit) - popular in transformers SELU (Scaled Exponential Linear Unit) Tensor Operations: Reshape - Change tensor shape Transpose - Swap dimensions Squeeze - Remove dimensions of size 1 Unsqueeze - Add dimension of size 1 Concatenate - Join tensors along a dimension Math Operations: Add - Add scalar to tensor Multiply - Multiply tensor by scalar Clamp - Limit values to a range Normalize - L2 normalization NumPy-style Operations: Mean - Average along axis Std Dev - Standard deviation Sum - Sum along axis Max - Maximum along axis Min - Minimum along axis All new blocks are color-coded and organized into logical categories. They generate proper PyTorch code when you click "Generate Code"! The blocks now cover a much wider range of deep learning operations. πŸš€ AIMLSE - Empowering Students Through AI & Quantum Computing