Spaces:

lorien-danger
/

I-JEPA_Keypoint_Matching

Running

App Files Files Community

lorien-danger commited on Sep 16, 2025

Commit

48416d0

verified ·

1 Parent(s): f42a3e0

Update index.html

Browse files

Files changed (1) hide show

index.html +824 -19

index.html CHANGED Viewed

@@ -1,19 +1,824 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>I-JEPA Patch Correspondence Analyzer</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            color: #333;
+        }
+```
+    .container {
+        max-width: 1400px;
+        margin: 0 auto;
+        background: rgba(255, 255, 255, 0.95);
+        border-radius: 20px;
+        padding: 30px;
+        box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+    }
+    h1 {
+        text-align: center;
+        color: #4a5568;
+        margin-bottom: 10px;
+        font-size: 2.5em;
+        font-weight: 300;
+    }
+    .subtitle {
+        text-align: center;
+        color: #718096;
+        margin-bottom: 30px;
+        font-size: 1.1em;
+    }
+    .upload-section {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 30px;
+        margin-bottom: 30px;
+    }
+    .upload-box {
+        border: 3px dashed #cbd5e0;
+        border-radius: 15px;
+        padding: 40px;
+        text-align: center;
+        transition: all 0.3s ease;
+        background: #f7fafc;
+        position: relative;
+        overflow: hidden;
+    }
+    .upload-box:hover {
+        border-color: #667eea;
+        background: #edf2f7;
+        transform: translateY(-2px);
+    }
+    .upload-box.has-image {
+        border-color: #48bb78;
+        background: #f0fff4;
+    }
+    .upload-input {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        opacity: 0;
+        cursor: pointer;
+    }
+    .upload-content {
+        pointer-events: none;
+    }
+    .upload-icon {
+        font-size: 3em;
+        margin-bottom: 15px;
+        color: #a0aec0;
+    }
+    .upload-text {
+        font-size: 1.1em;
+        color: #4a5568;
+        margin-bottom: 10px;
+    }
+    .upload-hint {
+        font-size: 0.9em;
+        color: #718096;
+    }
+    .preview-image {
+        max-width: 100%;
+        max-height: 200px;
+        border-radius: 10px;
+        margin-top: 15px;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    }
+    .controls {
+        display: flex;
+        justify-content: center;
+        gap: 20px;
+        margin-bottom: 30px;
+        flex-wrap: wrap;
+    }
+    .btn {
+        padding: 12px 30px;
+        border: none;
+        border-radius: 25px;
+        cursor: pointer;
+        font-size: 1em;
+        font-weight: 600;
+        transition: all 0.3s ease;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+    }
+    .btn-primary {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+    }
+    .btn-primary:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 8px 20px rgba(102, 126, 234, 0.4);
+    }
+    .btn-secondary {
+        background: #e2e8f0;
+        color: #4a5568;
+    }
+    .btn-secondary:hover {
+        background: #cbd5e0;
+        transform: translateY(-2px);
+    }
+    .btn:disabled {
+        background: #e2e8f0;
+        color: #a0aec0;
+        cursor: not-allowed;
+        transform: none;
+    }
+    .loading {
+        text-align: center;
+        padding: 40px;
+        display: none;
+    }
+    .spinner {
+        width: 50px;
+        height: 50px;
+        border: 4px solid #e2e8f0;
+        border-top: 4px solid #667eea;
+        border-radius: 50%;
+        animation: spin 1s linear infinite;
+        margin: 0 auto 20px;
+    }
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+    .results {
+        display: none;
+    }
+    .visualization {
+        background: white;
+        border-radius: 15px;
+        padding: 20px;
+        margin-bottom: 20px;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
+    }
+    .images-container {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 30px;
+        margin-bottom: 30px;
+    }
+    .image-analysis {
+        text-align: center;
+    }
+    .analysis-image {
+        max-width: 100%;
+        height: 300px;
+        object-fit: contain;
+        border-radius: 10px;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    }
+    .patch-grid {
+        display: inline-block;
+        position: relative;
+        margin-top: 15px;
+    }
+    .patch {
+        position: absolute;
+        border: 2px solid transparent;
+        cursor: pointer;
+        transition: all 0.3s ease;
+    }
+    .patch:hover {
+        border-color: #667eea;
+        background: rgba(102, 126, 234, 0.2);
+        z-index: 10;
+    }
+    .patch.highlighted {
+        border-color: #e53e3e;
+        background: rgba(229, 62, 62, 0.3);
+        z-index: 20;
+    }
+    .patch.corresponding {
+        border-color: #38a169;
+        background: rgba(56, 161, 105, 0.3);
+        z-index: 15;
+    }
+    .correspondences {
+        margin-top: 20px;
+    }
+    .correspondence-line {
+        position: absolute;
+        height: 2px;
+        background: linear-gradient(90deg, #e53e3e, #38a169);
+        z-index: 5;
+        opacity: 0.8;
+        transform-origin: left center;
+    }
+    .stats {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+        gap: 15px;
+        margin-top: 20px;
+    }
+    .stat-card {
+        background: #f7fafc;
+        padding: 20px;
+        border-radius: 10px;
+        text-align: center;
+        border-left: 4px solid #667eea;
+    }
+    .stat-value {
+        font-size: 2em;
+        font-weight: bold;
+        color: #4a5568;
+    }
+    .stat-label {
+        color: #718096;
+        margin-top: 5px;
+    }
+    .similarity-threshold {
+        margin: 20px 0;
+        text-align: center;
+    }
+    .threshold-slider {
+        width: 300px;
+        margin: 0 10px;
+    }
+    .error {
+        background: #fed7d7;
+        color: #c53030;
+        padding: 15px;
+        border-radius: 10px;
+        margin: 20px 0;
+        text-align: center;
+        display: none;
+    }
+    @media (max-width: 768px) {
+        .upload-section {
+            grid-template-columns: 1fr;
+        }
+        .images-container {
+            grid-template-columns: 1fr;
+        }
+        .controls {
+            flex-direction: column;
+            align-items: center;
+        }
+    }
+</style>
+```
+</head>
+<body>
+    <div class="container">
+        <h1>I-JEPA Patch Correspondence Analyzer</h1>
+        <p class="subtitle">Upload two images to analyze patch-level correspondences using I-JEPA embeddings</p>
+```
+    <div class="upload-section">
+        <div class="upload-box" id="upload1">
+            <input type="file" class="upload-input" accept="image/*" id="file1">
+            <div class="upload-content">
+                <div class="upload-icon">📸</div>
+                <div class="upload-text">Upload Image 1</div>
+                <div class="upload-hint">Click or drag image here</div>
+            </div>
+        </div>
+        <div class="upload-box" id="upload2">
+            <input type="file" class="upload-input" accept="image/*" id="file2">
+            <div class="upload-content">
+                <div class="upload-icon">📸</div>
+                <div class="upload-text">Upload Image 2</div>
+                <div class="upload-hint">Click or drag image here</div>
+            </div>
+        </div>
+    </div>
+    <div class="controls">
+        <button class="btn btn-primary" id="analyzeBtn" disabled>
+            🔍 Analyze Patch Correspondences
+        </button>
+        <button class="btn btn-secondary" id="clearBtn">
+            🗑️ Clear Images
+        </button>
+    </div>
+    <div class="error" id="errorMsg"></div>
+    <div class="loading" id="loading">
+        <div class="spinner"></div>
+        <p>Loading I-JEPA model and analyzing images...</p>
+        <p><small>This may take a moment on first load as the model downloads</small></p>
+    </div>
+    <div class="results" id="results">
+        <div class="visualization">
+            <div class="similarity-threshold">
+                <label>Similarity Threshold: </label>
+                <input type="range" class="threshold-slider" id="thresholdSlider"
+                       min="0" max="1" step="0.01" value="0.7">
+                <span id="thresholdValue">0.70</span>
+            </div>
+            <div class="images-container">
+                <div class="image-analysis">
+                    <h3>Image 1</h3>
+                    <div class="patch-grid" id="grid1">
+                        <img class="analysis-image" id="img1" alt="Image 1">
+                    </div>
+                </div>
+                <div class="image-analysis">
+                    <h3>Image 2</h3>
+                    <div class="patch-grid" id="grid2">
+                        <img class="analysis-image" id="img2" alt="Image 2">
+                    </div>
+                </div>
+            </div>
+            <div class="stats">
+                <div class="stat-card">
+                    <div class="stat-value" id="totalPatches">0</div>
+                    <div class="stat-label">Total Patches per Image</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value" id="strongCorrespondences">0</div>
+                    <div class="stat-label">Strong Correspondences</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value" id="avgSimilarity">0.00</div>
+                    <div class="stat-label">Average Similarity</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value" id="maxSimilarity">0.00</div>
+                    <div class="stat-label">Max Similarity</div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+<script type="module">
+    import { pipeline, env } from 'https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.7.3';
+    // Configure environment
+    env.allowRemoteModels = true;
+    env.allowLocalModels = false;
+    let model = null;
+    let processor = null;
+    let image1Data = null;
+    let image2Data = null;
+    let patchEmbeddings1 = null;
+    let patchEmbeddings2 = null;
+    let similarities = null;
+    // Model configuration - using smallest I-JEPA model
+    const MODEL_ID = "facebook/ijepa_vith14_1k";
+    const PATCH_SIZE = 14;
+    const IMAGE_SIZE = 224;
+    // DOM elements
+    const file1Input = document.getElementById('file1');
+    const file2Input = document.getElementById('file2');
+    const upload1 = document.getElementById('upload1');
+    const upload2 = document.getElementById('upload2');
+    const analyzeBtn = document.getElementById('analyzeBtn');
+    const clearBtn = document.getElementById('clearBtn');
+    const loading = document.getElementById('loading');
+    const results = document.getElementById('results');
+    const errorMsg = document.getElementById('errorMsg');
+    const thresholdSlider = document.getElementById('thresholdSlider');
+    const thresholdValue = document.getElementById('thresholdValue');
+    // Utility functions
+    function showError(message) {
+        errorMsg.textContent = message;
+        errorMsg.style.display = 'block';
+        setTimeout(() => {
+            errorMsg.style.display = 'none';
+        }, 5000);
+    }
+    function showLoading(show) {
+        loading.style.display = show ? 'block' : 'none';
+        analyzeBtn.disabled = show;
+    }
+    function showResults(show) {
+        results.style.display = show ? 'block' : 'none';
+    }
+    function updateAnalyzeButton() {
+        analyzeBtn.disabled = !image1Data || !image2Data;
+    }
+    // File handling
+    function handleFileUpload(fileInput, uploadBox, imageData, imageNum) {
+        const file = fileInput.files[0];
+        if (!file) return;
+        const reader = new FileReader();
+        reader.onload = function(e) {
+            const img = new Image();
+            img.onload = function() {
+                // Store image data
+                if (imageNum === 1) {
+                    image1Data = {
+                        url: e.target.result,
+                        width: img.width,
+                        height: img.height
+                    };
+                } else {
+                    image2Data = {
+                        url: e.target.result,
+                        width: img.width,
+                        height: img.height
+                    };
+                }
+                // Update UI
+                uploadBox.classList.add('has-image');
+                const content = uploadBox.querySelector('.upload-content');
+                content.innerHTML = `
+                    <img src="${e.target.result}" class="preview-image" alt="Preview ${imageNum}">
+                    <div style="margin-top: 10px; color: #48bb78; font-weight: 600;">✓ Image ${imageNum} loaded</div>
+                `;
+                updateAnalyzeButton();
+            };
+            img.src = e.target.result;
+        };
+        reader.readAsDataURL(file);
+    }
+    // Event listeners
+    file1Input.addEventListener('change', () => handleFileUpload(file1Input, upload1, image1Data, 1));
+    file2Input.addEventListener('change', () => handleFileUpload(file2Input, upload2, image2Data, 2));
+    clearBtn.addEventListener('click', () => {
+        // Reset all data
+        image1Data = null;
+        image2Data = null;
+        patchEmbeddings1 = null;
+        patchEmbeddings2 = null;
+        similarities = null;
+        // Reset UI
+        file1Input.value = '';
+        file2Input.value = '';
+        upload1.classList.remove('has-image');
+        upload2.classList.remove('has-image');
+        upload1.querySelector('.upload-content').innerHTML = `
+            <div class="upload-icon">📸</div>
+            <div class="upload-text">Upload Image 1</div>
+            <div class="upload-hint">Click or drag image here</div>
+        `;
+        upload2.querySelector('.upload-content').innerHTML = `
+            <div class="upload-icon">📸</div>
+            <div class="upload-text">Upload Image 2</div>
+            <div class="upload-hint">Click or drag image here</div>
+        `;
+        showResults(false);
+        updateAnalyzeButton();
+    });
+    thresholdSlider.addEventListener('input', () => {
+        const threshold = parseFloat(thresholdSlider.value);
+        thresholdValue.textContent = threshold.toFixed(2);
+        if (similarities) {
+            updateVisualization();
+        }
+    });
+    // Model loading and processing
+    async function loadModel() {
+        try {
+            if (!model) {
+                model = await pipeline('feature-extraction', MODEL_ID);
+            }
+            return true;
+        } catch (error) {
+            console.error('Error loading model:', error);
+            showError('Failed to load I-JEPA model. Please check your connection and try again.');
+            return false;
+        }
+    }
+    // Cosine similarity calculation
+    function cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    // Extract patch embeddings from I-JEPA
+    async function extractPatchEmbeddings(imageUrl) {
+        try {
+            // Create image element
+            const img = new Image();
+            img.crossOrigin = 'anonymous';
+            return new Promise((resolve, reject) => {
+                img.onload = async () => {
+                    try {
+                        // Extract features using the model
+                        const features = await model(img);
+                        // The features tensor should be [1, num_patches + 1, hidden_size]
+                        // We skip the first token (CLS token) to get just patch tokens
+                        const patchTokens = features.slice(null, [1, null], null).squeeze(0);
+                        // Convert to regular arrays for easier processing
+                        const embeddings = [];
+                        for (let i = 0; i < patchTokens.dims[0]; i++) {
+                            const embedding = [];
+                            for (let j = 0; j < patchTokens.dims[1]; j++) {
+                                embedding.push(patchTokens.data[i * patchTokens.dims[1] + j]);
+                            }
+                            embeddings.push(embedding);
+                        }
+                        resolve(embeddings);
+                    } catch (error) {
+                        reject(error);
+                    }
+                };
+                img.onerror = reject;
+                img.src = imageUrl;
+            });
+        } catch (error) {
+            console.error('Error extracting embeddings:', error);
+            throw error;
+        }
+    }
+    // Calculate patch correspondences
+    function calculateCorrespondences() {
+        const numPatches1 = patchEmbeddings1.length;
+        const numPatches2 = patchEmbeddings2.length;
+        similarities = [];
+        for (let i = 0; i < numPatches1; i++) {
+            similarities[i] = [];
+            for (let j = 0; j < numPatches2; j++) {
+                const sim = cosineSimilarity(patchEmbeddings1[i], patchEmbeddings2[j]);
+                similarities[i][j] = sim;
+            }
+        }
+    }
+    // Create patch grid visualization
+    function createPatchGrid(container, imageUrl, imageNum) {
+        container.innerHTML = '';
+        const img = document.createElement('img');
+        img.className = 'analysis-image';
+        img.src = imageUrl;
+        img.alt = `Image ${imageNum}`;
+        img.onload = () => {
+            const imgRect = img.getBoundingClientRect();
+            const patchesPerSide = Math.floor(IMAGE_SIZE / PATCH_SIZE); // 16 patches per side for 224/14
+            const patchWidth = imgRect.width / patchesPerSide;
+            const patchHeight = imgRect.height / patchesPerSide;
+            // Create patch overlay divs
+            for (let row = 0; row < patchesPerSide; row++) {
+                for (let col = 0; col < patchesPerSide; col++) {
+                    const patchIndex = row * patchesPerSide + col;
+                    const patch = document.createElement('div');
+                    patch.className = 'patch';
+                    patch.style.left = `${col * patchWidth}px`;
+                    patch.style.top = `${row * patchHeight}px`;
+                    patch.style.width = `${patchWidth}px`;
+                    patch.style.height = `${patchHeight}px`;
+                    patch.dataset.patchIndex = patchIndex;
+                    patch.dataset.imageNum = imageNum;
+                    patch.addEventListener('mouseenter', () => highlightCorrespondingPatches(patchIndex, imageNum));
+                    patch.addEventListener('mouseleave', () => clearHighlights());
+                    container.appendChild(patch);
+                }
+            }
+        };
+        container.appendChild(img);
+    }
+    // Highlight corresponding patches
+    function highlightCorrespondingPatches(patchIndex, imageNum) {
+        clearHighlights();
+        const threshold = parseFloat(thresholdSlider.value);
+        // Highlight the hovered patch
+        const hoveredPatch = document.querySelector(`[data-patch-index="${patchIndex}"][data-image-num="${imageNum}"]`);
+        if (hoveredPatch) {
+            hoveredPatch.classList.add('highlighted');
+        }
+        // Find and highlight corresponding patches in the other image
+        const otherImageNum = imageNum === 1 ? 2 : 1;
+        if (similarities) {
+            const sims = imageNum === 1 ? similarities[patchIndex] : similarities.map(row => row[patchIndex]);
+            sims.forEach((sim, otherPatchIndex) => {
+                if (sim >= threshold) {
+                    const correspondingPatch = document.querySelector(`[data-patch-index="${otherPatchIndex}"][data-image-num="${otherImageNum}"]`);
+                    if (correspondingPatch) {
+                        correspondingPatch.classList.add('corresponding');
+                    }
+                }
+            });
+        }
+    }
+    // Clear all highlights
+    function clearHighlights() {
+        document.querySelectorAll('.patch.highlighted, .patch.corresponding').forEach(patch => {
+            patch.classList.remove('highlighted', 'corresponding');
+        });
+    }
+    // Update statistics
+    function updateStatistics() {
+        if (!similarities) return;
+        const threshold = parseFloat(thresholdSlider.value);
+        const totalPatches = similarities.length;
+        let strongCorrespondences = 0;
+        let totalSimilarity = 0;
+        let maxSim = 0;
+        let count = 0;
+        for (let i = 0; i < similarities.length; i++) {
+            for (let j = 0; j < similarities[i].length; j++) {
+                const sim = similarities[i][j];
+                totalSimilarity += sim;
+                maxSim = Math.max(maxSim, sim);
+                count++;
+                if (sim >= threshold) {
+                    strongCorrespondences++;
+                }
+            }
+        }
+        document.getElementById('totalPatches').textContent = totalPatches;
+        document.getElementById('strongCorrespondences').textContent = strongCorrespondences;
+        document.getElementById('avgSimilarity').textContent = (totalSimilarity / count).toFixed(3);
+        document.getElementById('maxSimilarity').textContent = maxSim.toFixed(3);
+    }
+    // Update visualization based on current threshold
+    function updateVisualization() {
+        updateStatistics();
+        // Patch highlighting is handled by mouse events
+    }
+    // Main analysis function
+    analyzeBtn.addEventListener('click', async () => {
+        if (!image1Data || !image2Data) return;
+        showLoading(true);
+        showResults(false);
+        try {
+            // Load model if not already loaded
+            const modelLoaded = await loadModel();
+            if (!modelLoaded) {
+                showLoading(false);
+                return;
+            }
+            // Extract patch embeddings for both images
+            patchEmbeddings1 = await extractPatchEmbeddings(image1Data.url);
+            patchEmbeddings2 = await extractPatchEmbeddings(image2Data.url);
+            // Calculate correspondences
+            calculateCorrespondences();
+            // Create visualizations
+            const grid1 = document.getElementById('grid1');
+            const grid2 = document.getElementById('grid2');
+            createPatchGrid(grid1, image1Data.url, 1);
+            createPatchGrid(grid2, image2Data.url, 2);
+            // Update statistics
+            updateStatistics();
+            // Show results
+            showResults(true);
+            showLoading(false);
+        } catch (error) {
+            console.error('Analysis error:', error);
+            showError('Failed to analyze images. Please try again with different images.');
+            showLoading(false);
+        }
+    });
+    // Drag and drop support
+    ['upload1', 'upload2'].forEach((id, index) => {
+        const uploadBox = document.getElementById(id);
+        const fileInput = document.getElementById(`file${index + 1}`);
+        uploadBox.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadBox.style.borderColor = '#667eea';
+            uploadBox.style.background = '#edf2f7';
+        });
+        uploadBox.addEventListener('dragleave', (e) => {
+            e.preventDefault();
+            uploadBox.style.borderColor = '#cbd5e0';
+            uploadBox.style.background = '#f7fafc';
+        });
+        uploadBox.addEventListener('drop', (e) => {
+            e.preventDefault();
+            uploadBox.style.borderColor = '#cbd5e0';
+            uploadBox.style.background = '#f7fafc';
+            const files = e.dataTransfer.files;
+            if (files.length > 0 && files[0].type.startsWith('image/')) {
+                fileInput.files = files;
+                handleFileUpload(fileInput, uploadBox, null, index + 1);
+            }
+        });
+    });
+    // Initial setup
+    console.log('I-JEPA Patch Correspondence Analyzer initialized');
+    console.log(`Using model: ${MODEL_ID}`);
+    console.log(`Patch size: ${PATCH_SIZE}x${PATCH_SIZE}, Image size: ${IMAGE_SIZE}x${IMAGE_SIZE}`);
+</script>
+```
+</body>
+</html>