Elysia Tools

Parcourez outils, exemples, explications visuelles et guides thématiques dans un espace clair.

Catégories populaires

Dossiers

Langue
ZHESPTRUFRDEEN

Elysia Tools

Navigation mobile

Apprentissage automatique

Exemples ML5.js

Exemples d'apprentissage automatique ML5.js pour la programmation créative, la classification d'images, la détection de poses et les réseaux neuronaux

Exemples

Entrées de cette collection

Code sourcejavascriptIntermédiaire

Classification d'Images

Classifier des images en utilisant le modèle pré-entraîné MobileNet

Difficulté

5/10

Temps estimé

20 min

Étiquettes

ml5js, image classification, mobilenet

Prérequis

Basic JavaScript, HTML5 Canvas

javascript
// Image Classification with ML5.js

// Import ML5.js
// In browser: <script src="https://unpkg.com/ml5@latest/dist/ml5.min.js"></script>
// HTML: <div id="videoContainer"></div><canvas id="canvas"></canvas>

let model;
let video;

// 1. Setup video capture
function setupVideo() {
    video = createCapture(VIDEO);
    video.size(640, 480);
    video.hide();
}

// 2. Load MobileNet model
async function loadModel() {
    console.log('Loading MobileNet model...');

    model = await ml5.imageClassifier('MobileNet', video, () => {
        console.log('Model loaded successfully!');
        classifyVideo();
    });
}

// 3. Classify video frame
function classifyVideo() {
    model.classify((error, results) => {
        if (error) {
            console.error(error);
            return;
        }

        // Display results
        displayResults(results);

        // Continue classifying
        classifyVideo();
    });
}

// 4. Display classification results
function displayResults(results) {
    console.log('Classification Results:');

    // Clear previous results
    const resultsDiv = document.getElementById('results');
    if (resultsDiv) {
        resultsDiv.innerHTML = '';

        results.forEach((result, index) => {
            const confidence = (result.confidence * 100).toFixed(2);
            const label = result.label;

            console.log(`${index + 1}. ${label}: ${confidence}%`);

            // Create HTML element for each result
            const resultElement = document.createElement('div');
            resultElement.className = 'classification-result';
            resultElement.innerHTML = `
                <span class="label">${label}</span>
                <div class="confidence-bar">
                    <div class="confidence-fill" style="width: ${confidence}%"></div>
                </div>
                <span class="confidence-text">${confidence}%</span>
            `;
            resultsDiv.appendChild(resultElement);
        });
    }
}

// 5. Alternative: Classify still image
function classifyImage(imageElement) {
    model.classify(imageElement, (error, results) => {
        if (error) {
            console.error(error);
            return;
        }

        console.log('Image Classification Results:');
        results.forEach((result, index) => {
            const confidence = (result.confidence * 100).toFixed(2);
            console.log(`${index + 1}. ${result.label}: ${confidence}%`);
        });
    });
}

// 6. Classify from canvas
function classifyCanvas() {
    const canvas = document.getElementById('canvas');
    const context = canvas.getContext('2d');

    // Draw video frame to canvas
    context.drawImage(video, 0, 0, canvas.width, canvas.height);

    // Classify canvas content
    model.classify(canvas, (error, results) => {
        if (error) {
            console.error(error);
            return;
        }

        console.log('Canvas Classification Results:', results);
    });
}

// 7. Custom classification with confidence threshold
function classifyWithThreshold(threshold = 0.5) {
    model.classify((error, results) => {
        if (error) {
            console.error(error);
            return;
        }

        const highConfidenceResults = results.filter(result => result.confidence > threshold);

        if (highConfidenceResults.length > 0) {
            console.log('High Confidence Results:');
            highConfidenceResults.forEach(result => {
                console.log(`${result.label}: ${(result.confidence * 100).toFixed(2)}%`);
            });
        } else {
            console.log('No results above confidence threshold');
        }
    });
}

// 8. Batch classification of multiple images
async function batchClassify(imageUrls) {
    console.log('Starting batch classification...');

    for (let i = 0; i < imageUrls.length; i++) {
        const imageUrl = imageUrls[i];
        console.log(`\nClassifying image ${i + 1}: ${imageUrl}`);

        try {
            const results = await new Promise((resolve, reject) => {
                const img = new Image();
                img.crossOrigin = 'anonymous';
                img.onload = () => {
                    model.classify(img, (error, results) => {
                        if (error) reject(error);
                        else resolve(results);
                    });
                };
                img.onerror = reject;
                img.src = imageUrl;
            });

            console.log('Results:');
            results.forEach((result, index) => {
                console.log(`  ${index + 1}. ${result.label}: ${(result.confidence * 100).toFixed(2)}%`);
            });

        } catch (error) {
            console.error(`Error classifying image ${i + 1}:`, error);
        }
    }
}

// 9. Classification with custom visualization
function setupVisualization() {
    function draw() {
        // Draw video
        image(video, 0, 0, width, height);

        // Get current classification
        if (model && frameCount % 30 === 0) { // Classify every 30 frames
            model.classify((error, results) => {
                if (!error && results.length > 0) {
                    // Draw top result on screen
                    fill(255, 255, 255);
                    stroke(0);
                    strokeWeight(3);
                    textSize(24);
                    textAlign(LEFT, TOP);

                    const topResult = results[0];
                    const confidence = (topResult.confidence * 100).toFixed(1);
                    const labelText = `${topResult.label} (${confidence}%)`;
                    text(labelText, 10, 10);
                }
            });
        }
    }
}

// 10. Export classification data
function exportClassificationData() {
    model.classify((error, results) => {
        if (error) {
            console.error(error);
            return;
        }

        const data = {
            timestamp: new Date().toISOString(),
            results: results.map(result => ({
                label: result.label,
                confidence: result.confidence,
                confidencePercent: (result.confidence * 100).toFixed(2)
            }))
        };

        // Download as JSON
        const dataStr = JSON.stringify(data, null, 2);
        const dataUri = 'data:application/json;charset=utf-8,'+ encodeURIComponent(dataStr);

        const exportFileDefaultName = `classification_${Date.now()}.json`;

        const linkElement = document.createElement('a');
        linkElement.setAttribute('href', dataUri);
        linkElement.setAttribute('download', exportFileDefaultName);
        linkElement.click();

        console.log('Classification data exported');
    });
}

// Complete initialization
async function initializeImageClassification() {
    console.log('Initializing Image Classification...');

    // Create HTML elements if they don't exist
    if (!document.getElementById('results')) {
        const resultsDiv = document.createElement('div');
        resultsDiv.id = 'results';
        resultsDiv.style.position = 'absolute';
        resultsDiv.style.top = '10px';
        resultsDiv.style.right = '10px';
        resultsDiv.style.background = 'rgba(0, 0, 0, 0.7)';
        resultsDiv.style.color = 'white';
        resultsDiv.style.padding = '10px';
        resultsDiv.style.borderRadius = '5px';
        resultsDiv.style.fontFamily = 'Arial, sans-serif';
        resultsDiv.style.minWidth = '250px';
        document.body.appendChild(resultsDiv);

        // Add styles for confidence bars
        const style = document.createElement('style');
        style.textContent = `
            .classification-result {
                margin: 5px 0;
                display: flex;
                align-items: center;
            }
            .label {
                flex: 1;
                margin-right: 10px;
            }
            .confidence-bar {
                flex: 2;
                height: 20px;
                background: #333;
                border-radius: 10px;
                overflow: hidden;
                margin-right: 10px;
            }
            .confidence-fill {
                height: 100%;
                background: linear-gradient(90deg, #ff6b6b, #4ecdc4);
                transition: width 0.3s ease;
            }
            .confidence-text {
                min-width: 45px;
                text-align: right;
            }
        `;
        document.head.appendChild(style);
    }

    setupVideo();
    await loadModel();
}

// Example usage
// initializeImageClassification();

// For static image classification:
// const img = document.getElementById('myImage');
// classifyImage(img);

// For batch classification:
// const imageUrls = ['image1.jpg', 'image2.jpg', 'image3.jpg'];
// batchClassify(imageUrls);

console.log('ML5.js Image Classification module loaded');
console.log('Call initializeImageClassification() to start');
Code sourcejavascriptIntermédiaire

Détection de Poses

Détecter les poses du corps humain en utilisant le modèle PoseNet

Difficulté

6/10

Temps estimé

25 min

Étiquettes

ml5js, pose detection, posenet, body tracking

Prérequis

Basic JavaScript, p5.js

javascript
// Pose Detection with ML5.js

// Import ML5.js
// In browser: <script src="https://unpkg.com/ml5@latest/dist/ml5.min.js"></script>
// Requires p5.js for visualizations

let poseNet;
let poses = [];
let video;
let skeletons = [];

// 1. Setup video capture
function setupPoseDetection() {
    video = createCapture(VIDEO);
    video.size(640, 480);
    video.hide();
}

// 2. Load PoseNet model
async function loadPoseNet() {
    console.log('Loading PoseNet model...');

    const options = {
        architecture: 'MobileNetV1',
        imageScaleFactor: 0.3,
        outputStride: 16,
        flipHorizontal: false,
        minConfidence: 0.5,
        maxPoseDetections: 5,
        scoreThreshold: 0.5,
        nmsRadius: 20,
        detectionType: 'single',
        multiplier: 0.75
    };

    poseNet = ml5.poseNet(video, options, () => {
        console.log('PoseNet model loaded!');
    });

    // Listen for new poses
    poseNet.on('pose', (results) => {
        poses = results;
    });
}

// 3. Draw poses
function drawPoses() {
    // Draw video
    image(video, 0, 0, width, height);

    // Loop through all the poses detected
    for (let i = 0; i < poses.length; i++) {
        let pose = poses[i].pose;

        // Draw skeleton
        drawSkeleton(poses[i].skeleton);

        // Draw keypoints
        for (let j = 0; j < pose.keypoints.length; j++) {
            let keypoint = pose.keypoints[j];

            // Only draw a circle if the keypoint's confidence is high enough
            if (keypoint.score > 0.2) {
                fill(255, 0, 0);
                noStroke();
                ellipse(keypoint.position.x, keypoint.position.y, 20, 20);

                // Draw keypoint label
                fill(255);
                textAlign(CENTER, CENTER);
                textSize(10);
                text(getKeypointName(j), keypoint.position.x, keypoint.position.y - 15);
            }
        }
    }
}

// 4. Draw skeleton connections
function drawSkeleton(skeleton) {
    stroke(0, 255, 0);
    strokeWeight(5);

    for (let i = 0; i < skeleton.length; i++) {
        let partA = skeleton[i][0];
        let partB = skeleton[i][1];

        line(partA.position.x, partA.position.y, partB.position.x, partB.position.y);
    }
}

// 5. Get keypoint name by index
function getKeypointName(index) {
    const keypointNames = [
        'nose', 'leftEye', 'rightEye', 'leftEar', 'rightEar',
        'leftShoulder', 'rightShoulder', 'leftElbow', 'rightElbow',
        'leftWrist', 'rightWrist', 'leftHip', 'rightHip',
        'leftKnee', 'rightKnee', 'leftAnkle', 'rightAnkle'
    ];
    return keypointNames[index] || 'unknown';
}

// 6. Calculate angle between three points
function calculateAngle(a, b, c) {
    let radians = Math.atan2(c.y - b.y, c.x - b.x) - Math.atan2(a.y - b.y, a.x - b.x);
    let angle = Math.abs(radians * 180.0 / Math.PI);
    if (angle > 180.0) {
        angle = 360 - angle;
    }
    return angle;
}

// 7. Get specific body angles
function getBodyAngles(pose) {
    const keypoints = pose.keypoints;

    // Find keypoint positions
    const getKeyPoint = (name) => {
        const names = ['nose', 'leftEye', 'rightEye', 'leftEar', 'rightEar',
                      'leftShoulder', 'rightShoulder', 'leftElbow', 'rightElbow',
                      'leftWrist', 'rightWrist', 'leftHip', 'rightHip',
                      'leftKnee', 'rightKnee', 'leftAnkle', 'rightAnkle'];
        const index = names.indexOf(name);
        return index >= 0 && keypoints[index].score > 0.2 ? keypoints[index].position : null;
    };

    const leftShoulder = getKeyPoint('leftShoulder');
    const leftElbow = getKeyPoint('leftElbow');
    const leftWrist = getKeyPoint('leftWrist');
    const rightShoulder = getKeyPoint('rightShoulder');
    const rightElbow = getKeyPoint('rightElbow');
    const rightWrist = getKeyPoint('rightWrist');
    const leftHip = getKeyPoint('leftHip');
    const rightHip = getKeyPoint('rightHip');
    const leftKnee = getKeyPoint('leftKnee');
    const rightKnee = getKeyPoint('rightKnee');

    const angles = {};

    // Calculate arm angles
    if (leftShoulder && leftElbow && leftWrist) {
        angles.leftArm = calculateAngle(leftShoulder, leftElbow, leftWrist);
    }
    if (rightShoulder && rightElbow && rightWrist) {
        angles.rightArm = calculateAngle(rightShoulder, rightElbow, rightWrist);
    }

    // Calculate leg angles
    if (leftHip && leftKnee && leftWrist) {
        angles.leftLeg = calculateAngle(leftHip, leftKnee, leftWrist);
    }
    if (rightHip && rightKnee && rightWrist) {
        angles.rightLeg = calculateAngle(rightHip, rightKnee, rightWrist);
    }

    return angles;
}

// 8. Detect specific poses or gestures
function detectPose(pose) {
    const angles = getBodyAngles(pose);
    const keypoints = pose.keypoints;

    // Get keypoint positions
    const leftShoulder = keypoints.find(kp => kp.part === 'leftShoulder');
    const rightShoulder = keypoints.find(kp => kp.part === 'rightShoulder');
    const leftWrist = keypoints.find(kp => kp.part === 'leftWrist');
    const rightWrist = keypoints.find(kp => kp.part === 'rightWrist');

    const detectedPoses = [];

    // Detect "T-pose" (arms horizontal)
    if (leftShoulder && rightShoulder && leftWrist && rightWrist) {
        const shoulderY = (leftShoulder.position.y + rightShoulder.position.y) / 2;
        const wristY = (leftWrist.position.y + rightWrist.position.y) / 2;

        if (Math.abs(shoulderY - wristY) < 50) {
            detectedPoses.push('T-Pose');
        }
    }

    // Detect "hands up"
    if (leftShoulder && leftWrist && rightShoulder && rightWrist) {
        if (leftWrist.position.y < leftShoulder.position.y &&
            rightWrist.position.y < rightShoulder.position.y) {
            detectedPoses.push('Hands Up');
        }
    }

    // Detect "arms crossed" (approximate)
    if (leftWrist && rightWrist) {
        if (leftWrist.position.x > rightWrist.position.x) {
            detectedPoses.push('Arms Crossed');
        }
    }

    // Check specific angles for exercise detection
    if (angles.leftArm !== undefined) {
        if (angles.leftArm > 160) {
            detectedPoses.push('Left Arm Extended');
        }
        if (angles.leftArm < 90 && angles.leftArm > 70) {
            detectedPoses.push('Left Arm 90 Degrees');
        }
    }

    return detectedPoses;
}

// 9. Track pose over time
class PoseTracker {
    constructor() {
        this.poseHistory = [];
        this.maxHistory = 30; // Track last 30 frames
    }

    update(poses) {
        if (poses && poses.length > 0) {
            const pose = poses[0];
            const poseData = {
                timestamp: Date.now(),
                keypoints: pose.keypoints,
                angles: getBodyAngles(pose),
                detectedPoses: detectPose(pose)
            };

            this.poseHistory.push(poseData);

            if (this.poseHistory.length > this.maxHistory) {
                this.poseHistory.shift();
            }
        }
    }

    getCurrentPose() {
        return this.poseHistory.length > 0 ? this.poseHistory[this.poseHistory.length - 1] : null;
    }

    getRecentPoses(frames = 10) {
        return this.poseHistory.slice(-frames);
    }

    detectExercise() {
        const recentPoses = this.getRecentPoses(20);
        if (recentPoses.length < 10) return null;

        // Simple exercise detection: arm curl
        const armAngles = recentPoses.map(p => p.angles.leftArm).filter(a => a !== undefined);
        if (armAngles.length > 0) {
            const minAngle = Math.min(...armAngles);
            const maxAngle = Math.max(...armAngles);

            if (maxAngle - minAngle > 90) {
                return 'Arm Curl';
            }
        }

        return null;
    }
}

// 10. Pose visualization with exercise tracking
const poseTracker = new PoseTracker();

function drawPoseVisualization() {
    // Draw video and poses
    drawPoses();

    // Update pose tracker
    poseTracker.update(poses);

    // Display detected poses
    if (poses.length > 0) {
        const currentPose = poseTracker.getCurrentPose();
        if (currentPose && currentPose.detectedPoses.length > 0) {
            fill(255, 255, 0);
            noStroke();
            textSize(24);
            textAlign(LEFT, TOP);
            text(`Detected: ${currentPose.detectedPoses.join(', ')}`, 10, 30);
        }

        // Display exercise
        const exercise = poseTracker.detectExercise();
        if (exercise) {
            fill(0, 255, 0);
            textSize(32);
            text(`Exercise: ${exercise}`, 10, 70);
        }

        // Display body angles
        if (currentPose && currentPose.angles) {
            fill(255);
            textSize(16);
            let y = 110;

            if (currentPose.angles.leftArm !== undefined) {
                text(`Left Arm: ${currentPose.angles.leftArm.toFixed(1)}°`, 10, y);
                y += 20;
            }
            if (currentPose.angles.rightArm !== undefined) {
                text(`Right Arm: ${currentPose.angles.rightArm.toFixed(1)}°`, 10, y);
                y += 20;
            }
        }
    }
}

// Initialize pose detection
async function initializePoseDetection() {
    console.log('Initializing Pose Detection...');
    setupPoseDetection();
    await loadPoseNet();
}

// Export functions
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        initializePoseDetection,
        PoseTracker,
        calculateAngle,
        getBodyAngles,
        detectPose
    };
}

console.log('ML5.js Pose Detection module loaded');
console.log('Call initializePoseDetection() to start');

// Example p5.js sketch structure:
/*
function setup() {
    createCanvas(640, 480);
    initializePoseDetection();
}

function draw() {
    drawPoseVisualization();
}
*/
Code sourcejavascriptComplexe

Entraînement de Réseau Neuronal

Créer et entraîner des réseaux neuronaux personnalisés pour diverses tâches

Difficulté

8/10

Temps estimé

30 min

Étiquettes

ml5js, neural network, training, deep learning

Prérequis

Advanced JavaScript, Neural network basics

javascript
// Neural Network Training with ML5.js

// Import ML5.js
// In browser: <script src="https://unpkg.com/ml5@latest/dist/ml5.min.js"></script>

let nn;
let trainingData = [];
let isTraining = false;

// 1. Create a neural network for regression
function createRegressionNetwork() {
    console.log('Creating regression neural network...');

    const options = {
        inputs: 1,
        outputs: 1,
        task: 'regression',
        debug: true,
        learningRate: 0.05
    };

    nn = ml5.neuralNetwork(options);

    // Add training data (simple y = 2x + 1 relationship)
    for (let i = 0; i < 100; i++) {
        const x = Math.random() * 10;
        const y = 2 * x + 1 + (Math.random() - 0.5) * 0.5; // Add some noise
        trainingData.push({ input: [x], output: [y] });
    }

    nn.addData(trainingData);

    return nn;
}

// 2. Create a neural network for classification
function createClassificationNetwork() {
    console.log('Creating classification neural network...');

    const options = {
        inputs: 2,
        outputs: 3,
        task: 'classification',
        debug: true,
        learningRate: 0.1
    };

    nn = ml5.neuralNetwork(options);

    // Generate classification data (3 clusters)
    for (let i = 0; i < 150; i++) {
        const cluster = Math.floor(Math.random() * 3);
        let x, y, output;

        switch(cluster) {
            case 0:
                x = Math.random() * 3 + 1;
                y = Math.random() * 3 + 1;
                output = [1, 0, 0]; // Class 0
                break;
            case 1:
                x = Math.random() * 3 + 5;
                y = Math.random() * 3 + 5;
                output = [0, 1, 0]; // Class 1
                break;
            case 2:
                x = Math.random() * 3 + 3;
                y = Math.random() * 3 + 7;
                output = [0, 0, 1]; // Class 2
                break;
        }

        trainingData.push({ input: [x, y], output: output });
    }

    nn.addData(trainingData);

    return nn;
}

// 3. Train the neural network
function trainNetwork(callback) {
    console.log('Starting training...');
    isTraining = true;

    const trainingOptions = {
        epochs: 50,
        batchSize: 16,
        validationSplit: 0.1,
        shuffle: true
    };

    nn.train(trainingOptions, (epoch, loss) => {
        console.log(`Epoch ${epoch}: Loss = ${loss.toFixed(4)}`);
    }, () => {
        console.log('Training complete!');
        isTraining = false;
        if (callback) callback();
    });
}

// 4. Make predictions
function predict(input) {
    if (isTraining) {
        console.log('Network is still training...');
        return null;
    }

    nn.classify(input, (error, results) => {
        if (error) {
            console.error(error);
            return;
        }

        console.log('Prediction results:');
        results.forEach((result, i) => {
            console.log(`Class ${i}: ${result.label} (confidence: ${(result.confidence * 100).toFixed(2)}%)`);
        });
    });
}

// 5. Save and load model
function saveModel() {
    nn.save('my-model');
    console.log('Model saved!');
}

function loadModel(path, callback) {
    const options = {
        inputs: 2,
        outputs: 3,
        task: 'classification'
    };

    nn = ml5.neuralNetwork(options);
    nn.load(path, () => {
        console.log('Model loaded successfully!');
        if (callback) callback();
    });
}

// 6. Custom data generator
function generateCustomData() {
    // Generate data for XOR problem
    const xorData = [
        { input: [0, 0], output: [0] },
        { input: [0, 1], output: [1] },
        { input: [1, 0], output: [1] },
        { input: [1, 1], output: [0] }
    ];

    // Add noise and generate more samples
    for (let i = 0; i < 100; i++) {
        xorData.forEach(sample => {
            const noisyInput = sample.input.map(x => x + (Math.random() - 0.5) * 0.1);
            const noisyOutput = sample.output.map(y => y + (Math.random() - 0.5) * 0.1);
            xorData.push({ input: noisyInput, output: noisyOutput });
        });
    }

    return xorData;
}

// 7. Advanced neural network for image classification
function createImageClassificationNetwork() {
    console.log('Creating image classification network...');

    const options = {
        inputs: 64, // 8x8 grayscale images
        outputs: 2,  // 2 classes
        task: 'classification',
        debug: true,
        learningRate: 0.01,
        hiddenUnits: [32, 16] // Two hidden layers
    };

    nn = ml5.neuralNetwork(options);

    // Generate simple image data
    for (let i = 0; i < 200; i++) {
        const isClass1 = Math.random() > 0.5;
        const imageData = generateImagePattern(isClass1);
        const output = isClass1 ? [1, 0] : [0, 1];

        nn.addData({ input: imageData, output: output });
    }

    return nn;
}

// 8. Generate image patterns
function generateImagePattern(isVertical) {
    const size = 8;
    const imageData = [];

    for (let i = 0; i < size * size; i++) {
        const x = i % size;
        const y = Math.floor(i / size);

        let value = 0;

        if (isVertical) {
            // Vertical line pattern
            value = (x > 2 && x < 5) ? 1 : 0;
        } else {
            // Horizontal line pattern
            value = (y > 2 && y < 5) ? 1 : 0;
        }

        // Add some noise
        value += (Math.random() - 0.5) * 0.2;
        imageData.push(Math.max(0, Math.min(1, value)));
    }

    return imageData;
}

// 9. Real-time data collection
class DataCollector {
    constructor() {
        this.data = [];
        this.currentInput = [];
        this.isCollecting = false;
        this.currentLabel = 0;
    }

    start(label) {
        this.currentLabel = label;
        this.isCollecting = true;
        this.currentInput = [];
        console.log(`Collecting data for label ${label}...`);
    }

    addDataPoint(point) {
        if (this.isCollecting) {
            this.currentInput.push(point);
        }
    }

    stop() {
        if (this.isCollecting && this.currentInput.length > 0) {
            this.data.push({
                input: this.currentInput,
                output: [this.currentLabel]
            });
            console.log(`Added ${this.currentInput.length} data points for label ${this.currentLabel}`);
        }
        this.isCollecting = false;
        this.currentInput = [];
    }

    getData() {
        return this.data;
    }

    clear() {
        this.data = [];
        console.log('Data cleared');
    }
}

// 10. Gesture recognition network
class GestureRecognizer {
    constructor() {
        this.nn = null;
        this.dataCollector = new DataCollector();
        this.gestures = ['wave', 'swipe_left', 'swipe_right', 'circle'];
        this.currentGesture = 0;
        this.isTraining = false;
    }

    initialize() {
        const options = {
            inputs: 30, // 10 frames x 3 coordinates (x, y, z)
            outputs: this.gestures.length,
            task: 'classification',
            debug: true
        };

        this.nn = ml5.neuralNetwork(options);
        this.loadTrainingData();
    }

    startCollecting(gestureIndex) {
        this.currentGesture = gestureIndex;
        this.dataCollector.start(gestureIndex);
        console.log(`Collecting gesture: ${this.gestures[gestureIndex]}`);
    }

    addHandPosition(x, y, z = 0) {
        this.dataCollector.addDataPoint([x, y, z]);
    }

    stopCollecting() {
        this.dataCollector.stop();
        const newData = this.dataCollector.getData();
        newData.forEach(sample => {
            this.nn.addData(sample);
        });
    }

    train() {
        if (this.isTraining) return;

        this.isTraining = true;
        this.nn.normalizeData();

        const options = {
            epochs: 100,
            batchSize: 16
        };

        this.nn.train(options, (epoch, loss) => {
            console.log(`Training - Epoch ${epoch}: Loss = ${loss.toFixed(4)}`);
        }, () => {
            this.isTraining = false;
            console.log('Gesture model trained!');
        });
    }

    recognize(points) {
        if (this.isTraining) return null;

        this.nn.classify(points, (error, results) => {
            if (error) {
                console.error(error);
                return;
            }

            const topResult = results[0];
            const confidence = (topResult.confidence * 100).toFixed(2);
            console.log(`Gesture: ${topResult.label} (${confidence}% confidence)`);

            return topResult;
        });
    }

    loadTrainingData() {
        // Load pre-existing training data if available
        // This would typically load from a file or API
        console.log('Loading existing training data...');
    }

    saveModel() {
        this.nn.save('gesture-model');
        console.log('Gesture model saved!');
    }
}

// Initialize and train example
async function runNeuralNetworkExample() {
    console.log('=== Neural Network Example ===');

    // Create a classification network
    const network = createClassificationNetwork();

    // Train the network
    trainNetwork(() => {
        console.log('Making predictions...');

        // Test predictions
        predict([2, 2]);  // Should be class 0
        predict([6, 6]);  // Should be class 1
        predict([4, 8]);  // Should be class 2
    });
}

// Initialize gesture recognizer
const gestureRecognizer = new GestureRecognizer();

// Export classes and functions
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        createRegressionNetwork,
        createClassificationNetwork,
        DataCollector,
        GestureRecognizer,
        runNeuralNetworkExample
    };
}

console.log('ML5.js Neural Network module loaded');
console.log('Available functions:');
console.log('- createRegressionNetwork()');
console.log('- createClassificationNetwork()');
console.log('- runNeuralNetworkExample()');
console.log('- GestureRecognizer class for gesture recognition');
Code sourcejavascriptComplexe

Classification de Son

Classifier les sons et l'audio en utilisant l'apprentissage automatique

Difficulté

7/10

Temps estimé

25 min

Étiquettes

ml5js, sound classification, audio, speech

Prérequis

Advanced JavaScript, Web Audio API

javascript
// Sound Classification with ML5.js

// Import ML5.js
// In browser: <script src="https://unpkg.com/ml5@latest/dist/ml5.min.js"></script>
// Also requires p5.js and p5.sound library

let soundClassifier;
let audioContext;
let mic;
let modelReady = false;

// 1. Setup audio context and microphone
function setupAudio() {
    audioContext = new (window.AudioContext || window.webkitAudioContext)();

    // Create audio input
    mic = new p5.AudioIn();
    mic.start();

    console.log('Audio setup complete');
}

// 2. Load pre-trained sound classification model
async function loadSoundClassifier() {
    console.log('Loading sound classifier...');

    // Options for the classifier
    const options = {
        probabilityThreshold: 0.75,
        overlapFactor: 0.5
    };

    soundClassifier = ml5.soundClassifier('SpeechCommands18w', options, () => {
        console.log('Sound classifier loaded!');
        modelReady = true;

        // Start classifying
        startClassification();
    });
}

// 3. Start continuous classification
function startClassification() {
    if (!modelReady) {
        console.log('Model not ready yet...');
        return;
    }

    // Get audio classification results
    soundClassifier.classify(gotResult);
}

// 4. Handle classification results
function gotResult(error, results) {
    if (error) {
        console.error(error);
        return;
    }

    // Display results
    if (results && results.length > 0) {
        console.log('Sound Classification Results:');
        results.forEach((result, i) => {
            console.log(`${i + 1}. ${result.label}: ${(result.confidence * 100).toFixed(2)}%`);
        });

        // Visual feedback
        displaySoundResults(results);

        // Trigger actions based on sound
        handleSoundCommand(results[0]);
    }
}

// 5. Display sound classification results
function displaySoundResults(results) {
    const resultsDiv = document.getElementById('soundResults');
    if (resultsDiv) {
        resultsDiv.innerHTML = '';

        results.forEach(result => {
            const confidence = (result.confidence * 100).toFixed(1);
            const resultElement = document.createElement('div');
            resultElement.style.margin = '5px 0';
            resultElement.innerHTML = `
                <span style="display: inline-block; width: 150px;">${result.label}:</span>
                <div style="display: inline-block; width: 200px; height: 20px; background: #ddd; border-radius: 10px; overflow: hidden; position: relative;">
                    <div style="width: ${confidence}%; height: 100%; background: linear-gradient(90deg, #4ecdc4, #44a3a0);"></div>
                </div>
                <span style="margin-left: 10px;">${confidence}%</span>
            `;
            resultsDiv.appendChild(resultElement);
        });
    }
}

// 6. Handle voice commands
function handleSoundCommand(result) {
    const command = result.label.toLowerCase();
    const confidence = result.confidence;

    if (confidence < 0.7) return; // Only act on high confidence

    console.log(`Detected command: ${command} (${(confidence * 100).toFixed(1)}%)`);

    switch(command) {
        case 'yes':
            console.log('✓ Yes detected');
            document.body.style.backgroundColor = '#90EE90';
            break;

        case 'no':
            console.log('✗ No detected');
            document.body.style.backgroundColor = '#FFB6C1';
            break;

        case 'up':
            console.log('↑ Up command');
            window.scrollBy(0, -100);
            break;

        case 'down':
            console.log('↓ Down command');
            window.scrollBy(0, 100);
            break;

        case 'left':
            console.log('← Left command');
            window.scrollBy(-100, 0);
            break;

        case 'right':
            console.log('→ Right command');
            window.scrollBy(100, 0);
            break;

        case 'stop':
            console.log('⏹ Stop command');
            // Pause any ongoing action
            break;

        case 'go':
            console.log('▶ Go command');
            // Resume or start action
            break;

        case 'on':
            console.log('💡 On command');
            document.body.style.filter = 'brightness(1.2)';
            break;

        case 'off':
            console.log('🌙 Off command');
            document.body.style.filter = 'brightness(0.8)';
            break;

        case 'zero':
            console.log('0 Reset command');
            document.body.style.backgroundColor = '';
            document.body.style.filter = '';
            break;
    }
}

// 7. Custom sound classification with training data
class CustomSoundClassifier {
    constructor() {
        this.featureExtractor = ml5.featureExtractor('MobileNet');
        this.classifier = this.featureExtractor.classification();
        this.audioBuffer = [];
        this.isRecording = false;
        this.isTraining = false;
        this.labels = ['silence', 'clap', 'whistle', 'snap'];
    }

    async initialize() {
        console.log('Initializing custom sound classifier...');

        // Setup audio capture
        this.stream = await navigator.mediaDevices.getUserMedia({ audio: true });
        this.audioContext = new AudioContext();
        this.source = this.audioContext.createMediaStreamSource(this.stream);
        this.analyser = this.audioContext.createAnalyser();

        this.source.connect(this.analyser);
        this.analyser.fftSize = 2048;

        console.log('Custom classifier initialized');
    }

    startRecording(label) {
        this.currentLabel = label;
        this.isRecording = true;
        this.audioBuffer = [];

        console.log(`Recording for label: ${label}`);

        this.captureAudioData();
    }

    captureAudioData() {
        if (!this.isRecording) return;

        const bufferLength = this.analyser.frequencyBinCount;
        const dataArray = new Uint8Array(bufferLength);
        this.analyser.getByteFrequencyData(dataArray);

        // Convert to normalized features
        const features = Array.from(dataArray).map(x => x / 255);
        this.audioBuffer.push(...features);

        requestAnimationFrame(() => this.captureAudioData());
    }

    stopRecording() {
        this.isRecording = false;
        console.log(`Stopped recording. Captured ${this.audioBuffer.length} features`);

        // Add to training data
        this.classifier.addExample(this.audioBuffer, this.currentLabel);
    }

    async train() {
        if (this.isTraining) return;

        this.isTraining = true;
        console.log('Training custom sound classifier...');

        const options = {
            epochs: 50,
            batchSize: 32
        };

        this.classifier.train(options, (epoch, loss) => {
            console.log(`Training - Epoch ${epoch}: Loss = ${loss.toFixed(4)}`);
        }, () => {
            this.isTraining = false;
            console.log('Training complete!');
            this.startPrediction();
        });
    }

    startPrediction() {
        if (this.isTraining) return;

        this.isPredicting = true;
        this.predictContinuously();
    }

    predictContinuously() {
        if (!this.isPredicting) return;

        const bufferLength = this.analyser.frequencyBinCount;
        const dataArray = new Uint8Array(bufferLength);
        this.analyser.getByteFrequencyData(dataArray);

        const features = Array.from(dataArray).map(x => x / 255);

        this.classifier.classify(features, (error, results) => {
            if (!error && results.length > 0) {
                const topResult = results[0];
                if (topResult.confidence > 0.7) {
                    console.log(`Detected: ${topResult.label} (${(topResult.confidence * 100).toFixed(1)}%)`);
                    this.handleCustomSound(topResult);
                }
            }
        });

        requestAnimationFrame(() => this.predictContinuously());
    }

    handleCustomSound(result) {
        // Custom actions for different sounds
        switch(result.label) {
            case 'clap':
                console.log('👏 Clap detected!');
                document.body.style.animation = 'pulse 0.5s';
                setTimeout(() => {
                    document.body.style.animation = '';
                }, 500);
                break;

            case 'whistle':
                console.log('🎵 Whistle detected!');
                document.body.style.color = '#FF6B6B';
                setTimeout(() => {
                    document.body.style.color = '';
                }, 1000);
                break;

            case 'snap':
                console.log('🤏 Snap detected!');
                document.body.style.transform = 'scale(1.05)';
                setTimeout(() => {
                    document.body.style.transform = '';
                }, 200);
                break;
        }
    }

    saveModel() {
        this.classifier.save('custom-sound-model');
        console.log('Custom sound model saved!');
    }

    async loadModel(path) {
        await this.classifier.load(path);
        console.log('Custom sound model loaded!');
        this.startPrediction();
    }
}

// 8. Audio visualization
function visualizeAudio() {
    if (!mic || !modelReady) return;

    push();
    translate(width/2, height/2);

    // Get audio level
    const level = mic.getLevel();
    const diameter = map(level, 0, 1, 50, 300);

    // Draw visual representation
    noFill();
    stroke(255, 100);
    strokeWeight(2);

    for (let i = 0; i < 10; i++) {
        const offset = i * 10;
        ellipse(0, 0, diameter + offset, diameter + offset);
    }

    // Center circle reacts to audio
    fill(255, 150);
    noStroke();
    ellipse(0, 0, level * 200, level * 200);

    pop();
}

// 9. Volume-based interaction
function volumeBasedControl() {
    if (!mic || !modelReady) return;

    const level = mic.getLevel();
    const threshold = 0.1;

    if (level > threshold) {
        // Loud sound detected
        console.log(`Loud sound detected: ${(level * 100).toFixed(1)}%`);

        // Trigger action based on volume level
        if (level > 0.3) {
            // Very loud - dramatic action
            document.body.style.transition = 'transform 0.1s';
            document.body.style.transform = 'scale(1.1)';
        } else if (level > 0.2) {
            // Moderate - subtle action
            document.body.style.transition = 'background-color 0.3s';
            document.body.style.backgroundColor = '#E8F4FF';
        }
    } else {
        // Reset to normal
        document.body.style.transform = '';
        document.body.style.backgroundColor = '';
    }
}

// 10. Initialize everything
async function initializeSoundClassification() {
    console.log('Initializing Sound Classification...');

    // Create HTML elements for results
    if (!document.getElementById('soundResults')) {
        const resultsDiv = document.createElement('div');
        resultsDiv.id = 'soundResults';
        resultsDiv.style.position = 'fixed';
        resultsDiv.style.top = '10px';
        resultsDiv.style.right = '10px';
        resultsDiv.style.background = 'rgba(0, 0, 0, 0.8)';
        resultsDiv.style.color = 'white';
        resultsDiv.style.padding = '15px';
        resultsDiv.style.borderRadius = '5px';
        resultsDiv.style.fontFamily = 'monospace';
        resultsDiv.style.minWidth = '300px';
        document.body.appendChild(resultsDiv);

        // Add title
        const title = document.createElement('h3');
        title.textContent = 'Sound Classification';
        title.style.margin = '0 0 10px 0';
        title.style.fontSize = '16px';
        resultsDiv.insertBefore(title, resultsDiv.firstChild);
    }

    // Add pulse animation for claps
    const style = document.createElement('style');
    style.textContent = `
        @keyframes pulse {
            0% { transform: scale(1); }
            50% { transform: scale(1.05); }
            100% { transform: scale(1); }
        }
    `;
    document.head.appendChild(style);

    setupAudio();
    await loadSoundClassifier();
}

// Create custom classifier instance
const customSoundClassifier = new CustomSoundClassifier();

// Export classes and functions
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        initializeSoundClassification,
        CustomSoundClassifier,
        customSoundClassifier
    };
}

console.log('ML5.js Sound Classification module loaded');
console.log('Available functions:');
console.log('- initializeSoundClassification()');
console.log('- CustomSoundClassifier class for custom training');

// Usage examples:
/*
// Initialize sound classification
initializeSoundClassification();

// Train custom classifier
customSoundClassifier.initialize().then(() => {
    customSoundClassifier.startRecording('clap');
    // Record clap sound...
    customSoundClassifier.stopRecording();

    customSoundClassifier.startRecording('whistle');
    // Record whistle...
    customSoundClassifier.stopRecording();

    // Train and start predicting
    customSoundClassifier.train();
});
*/

Outils

Outils souvent utilisés avec cet exemple

Associé

Collections d’exemples associées

Guide d'utilisation de l'outil

Contexte pour comprendre cette collection d’exemples

Titre

Exemples ML5.js

Description

Exemples d'apprentissage automatique ML5.js pour la programmation créative, la classification d'images, la détection de poses et les réseaux neuronaux

Aperçu

Exemples d'apprentissage automatique ML5.js pour la programmation créative, la classification d'images, la détection de poses et les réseaux neuronaux

Quand l’utiliser

  • Use this sample set when you want reference inputs for Exemples ML5.js.
  • Use it to preview output formats and compare related sample variants.

Fonctionnement

  1. 1Open a sample entry to inspect the prepared example payload or asset.
  2. 2Compare it with related tools to understand how the workflow connects.

Cas d’usage

  • Classification d'Images
  • Détection de Poses
  • Entraînement de Réseau Neuronal
  • Classification de Son

FAQ

What is included in Exemples ML5.js?

This page includes curated sample entries, related tools, and neighboring sample collections for Exemples ML5.js.

Accueil
Outils3197
Exemples593
Visualisations461
Visionneuses de fichiers103
Dossiers229
Étiquettes333
Images, audio et vidéo655

Outils de traitement, conversion et optimisation d’images, d’audio et de vidéo

Maths, dates et finance644

Calculateurs, outils numériques, logique de dates, statistiques et finance

Design et couleur296

Outils de couleur, mise en page, graphisme, style visuel et assistance design

Texte et rédaction209

Outils de rédaction, nettoyage, formatage, extraction et analyse de texte

Développement et Web193

Utilitaires développeur, réseau, débogage Web et assistants d’automatisation

Conversion et encodage175

Outils de conversion de formats, fichiers, archives, unités et encodages

Structurer une capture d'interface, la relire et la transmettre au développement
Esquisse au piano, contrôle MIDI et livraison d'une maquette d'écoute
Revue de textures rétro et remise des ressources
Revue et remise d’un guide opératoire illustré par captures
Revue visuelle d’une refonte responsive et remise des preuves

© 2026 Elysia Tools. Tous droits réservés.

DocumentationTarifsÀ proposConditions d'utilisationPolitique de confidentialitéCookiesContact

Media

Ajouter Pochette

Ajouter ou changer la pochette d’un audio

Media

Extracteur de Pochette

Extraire la pochette d’un fichier audio

Media

Générateur de Spectrogramme

Générer une image de spectrogramme

Media

Générateur de Forme d’Onde

Génère une image de forme d’onde depuis un audio

Development

Générateur de Data URI

Convertit les fichiers en Data URI (Base64 ou pourcentage-encodé) pour intégrer images, polices et ressources directement dans HTML, CSS ou Markdown

Media

Séquence d'Images en Vidéo

Convertir des images ou une archive ZIP de frames en vidéo avec tri naturel par nom

Media

Pack de publication podcast par lots

Normalise des épisodes, ajoute métadonnées et chapitres, puis crée une archive ZIP prête à livrer.

Media

Packager de sortie numérique

Prépare un album pour la distribution numérique : vérifications par profil de distributeur, validation de la pochette, aperçus MP3, copies FLAC et ZIP de livraison avec README et manifeste.

Technologies web

Exemples de Communication Temps Réel WebRTC

Exemples complets WebRTC pour communication audio/vidéo P2P, canaux de données, partage d'écran et serveur de signalisation

IA et apprentissage automatique

Exemples OpenAI API

Exemples complets de l'API OpenAI incluant les modèles GPT, la génération d'images DALL-E, le traitement audio Whisper et les appels de fonctions

Go

Exemples de Fonctionnalités Web Web Go

Exemples de fonctionnalités spécifiques Web Go incluant le gestionnaire de routes, middleware et service de fichiers statiques

Médias

Échantillons Audio AAC Libres de Droits

Collection audio AAC de haute qualité pour tests et développement, incluant sons de la nature et musique de méditation

Médias

Échantillons Audio FLAC Libres de Droits

Collection audio FLAC sans perte pour tests et développement, incluant sons de la nature et musique de méditation

Médias

Échantillons Audio M4A Libres de Droits

Collection audio M4A compatible Apple iTunes, optimisée pour équilibre qualité-taille de fichier