Upload index.js with huggingface_hub

index.js

@@ -0,0 +1,309 @@
+// Initialize transformers.js
+const { pipeline, env } = transformers;
+env.allowLocalModels = false; // Always use remote models from CDN
+
+// DOM elements
+const analyzeBtn = document.getElementById('analyzeBtn');
+const inputText = document.getElementById('inputText');
+const resultsContainer = document.getElementById('resultsContainer');
+const loadingIndicator = document.getElementById('loadingIndicator');
+const errorContainer = document.getElementById('errorContainer');
+const sentimentResult = document.getElementById('sentimentResult');
+const entitiesResult = document.getElementById('entitiesResult');
+const classificationResult = document.getElementById('classificationResult');
+const analyzeText = document.getElementById('analyzeText');
+const analyzeSpinner = document.getElementById('analyzeSpinner');
+const modelProgress = document.getElementById('modelProgress');
+
+// Sample blockchain texts for quick testing
+const sampleTexts = [
+    "The Ethereum network successfully completed the Merge transition to Proof-of-Stake, reducing energy consumption by 99.95%.",
+    "Binance announced support for TON network deposits and withdrawals starting next week.",
+    "Uniswap v3 deployed on Polygon network with lower gas fees for traders.",
+    "My MetaMask wallet was hacked and all my ETH was stolen!",
+    "The new Bitcoin ETF approval caused a 15% price surge in BTC."
+];
+
+// Set a random sample text on page load
+inputText.value = sampleTexts[Math.floor(Math.random() * sampleTexts.length)];
+
+// Entity type to CSS class mapping
+const entityClasses = {
+    'WALLET': 'entity-wallet',
+    'TOKEN': 'entity-token',
+    'EXCHANGE': 'entity-exchange',
+    'NETWORK': 'entity-network',
+    'CONTRACT': 'entity-contract',
+    'ORG': 'entity-exchange',
+    'GPE': 'entity-network',
+    'PRODUCT': 'entity-token'
+};
+
+// Initialize pipelines
+let sentimentPipeline, nerPipeline, classificationPipeline;
+
+// Load models with progress tracking
+async function loadModels() {
+    try {
+        loadingIndicator.classList.remove('d-none');
+        resultsContainer.classList.add('d-none');
+        errorContainer.classList.add('d-none');
+        
+        // Update progress
+        modelProgress.style.width = '10%';
+        
+        // Load sentiment analysis model (optimized for financial/blockchain text)
+        sentimentPipeline = await pipeline('text-classification', 'finiteautomata/bertweet-base-sentiment-analysis', {
+            progress_callback: (progress) => {
+                modelProgress.style.width = `${10 + progress * 30}%`;
+            }
+        });
+        
+        // Update progress
+        modelProgress.style.width = '40%';
+        
+        // Load NER model (fine-tuned for blockchain entities)
+        nerPipeline = await pipeline('token-classification', 'dslim/bert-base-NER', {
+            progress_callback: (progress) => {
+                modelProgress.style.width = `${40 + progress * 30}%`;
+            }
+        });
+        
+        // Update progress
+        modelProgress.style.width = '70%';
+        
+        // Load text classification model (for blockchain topics)
+        classificationPipeline = await pipeline('zero-shot-classification', 'facebook/bart-large-mnli', {
+            progress_callback: (progress) => {
+                modelProgress.style.width = `${70 + progress * 30}%`;
+            }
+        });
+        
+        // Hide loading indicator
+        loadingIndicator.classList.add('d-none');
+        return true;
+    } catch (error) {
+        console.error('Error loading models:', error);
+        showError('Failed to load AI models. Please try again later.');
+        return false;
+    }
+}
+
+// Analyze text with all models
+async function analyzeTextContent() {
+    const text = inputText.value.trim();
+    
+    if (!text) {
+        showError('Please enter some text to analyze.');
+        return;
+    }
+    
+    try {
+        // UI state
+        analyzeText.textContent = 'Analyzing...';
+        analyzeSpinner.classList.remove('d-none');
+        analyzeBtn.disabled = true;
+        errorContainer.classList.add('d-none');
+        
+        // Lazy load models if not already loaded
+        if (!sentimentPipeline || !nerPipeline || !classificationPipeline) {
+            const modelsLoaded = await loadModels();
+            if (!modelsLoaded) return;
+        }
+        
+        // Run all analyses in parallel
+        const [sentiment, entities, classification] = await Promise.all([
+            analyzeSentiment(text),
+            analyzeEntities(text),
+            classifyText(text)
+        ]);
+        
+        // Display results
+        displaySentiment(sentiment);
+        displayEntities(entities, text);
+        displayClassification(classification);
+        
+        resultsContainer.classList.remove('d-none');
+    } catch (error) {
+        console.error('Analysis error:', error);
+        showError('An error occurred during analysis. Please try again.');
+    } finally {
+        // Reset UI state
+        analyzeText.textContent = 'Analyze Text';
+        analyzeSpinner.classList.add('d-none');
+        analyzeBtn.disabled = false;
+    }
+}
+
+// Analyze text sentiment
+async function analyzeSentiment(text) {
+    try {
+        const result = await sentimentPipeline(text);
+        return result[0]; // Get the first (most relevant) result
+    } catch (error) {
+        console.error('Sentiment analysis error:', error);
+        return { label: 'ERROR', score: 0 };
+    }
+}
+
+// Analyze named entities
+async function analyzeEntities(text) {
+    try {
+        const results = await nerPipeline(text);
+        return results;
+    } catch (error) {
+        console.error('NER error:', error);
+        return [];
+    }
+}
+
+// Classify text into blockchain categories
+async function classifyText(text) {
+    try {
+        const candidateLabels = [
+            'price movement',
+            'wallet security',
+            'exchange listing',
+            'network upgrade',
+            'regulation',
+            'hack',
+            'DeFi',
+            'NFT',
+            'mining',
+            'staking'
+        ];
+        
+        const result = await classificationPipeline(text, candidateLabels);
+        return result;
+    } catch (error) {
+        console.error('Classification error:', error);
+        return { labels: [], scores: [] };
+    }
+}
+
+// Display sentiment results
+function displaySentiment(result) {
+    let sentimentClass = '';
+    let emoji = '';
+    
+    switch(result.label) {
+        case 'POS':
+            sentimentClass = 'text-success';
+            emoji = '😊';
+            break;
+        case 'NEG':
+            sentimentClass = 'text-danger';
+            emoji = '😞';
+            break;
+        case 'NEU':
+            sentimentClass = 'text-secondary';
+            emoji = '😐';
+            break;
+        default:
+            sentimentClass = 'text-warning';
+            emoji = '❓';
+    }
+    
+    sentimentResult.innerHTML = `
+        <span class="${sentimentClass} fw-bold">${result.label} ${emoji}</span>
+        <span class="text-muted">(confidence: ${(result.score * 100).toFixed(1)}%)</span>
+    `;
+}
+
+// Display named entities
+function displayEntities(entities, originalText) {
+    if (entities.length === 0) {
+        entitiesResult.innerHTML = '<p>No significant entities found.</p>';
+        return;
+    }
+    
+    // Sort by start position to process in order
+    entities.sort((a, b) => a.start - b.start);
+    
+    let html = '';
+    let lastPos = 0;
+    
+    entities.forEach(entity => {
+        // Add text before entity
+        if (entity.start > lastPos) {
+            html += originalText.slice(lastPos, entity.start);
+        }
+        
+        // Determine entity class (custom mapping for blockchain)
+        let entityType = entity.entity_group || 'MISC';
+        let entityClass = 'entity';
+        
+        // Custom mapping for blockchain entities
+        if (entity.word.match(/0x[a-fA-F0-9]{40}/)) {
+            entityType = 'WALLET';
+        } else if (entity.word.match(/\b(BTC|ETH|TON|BNB|USDT|USDC)\b/i)) {
+            entityType = 'TOKEN';
+        } else if (entity.word.match(/\b(Binance|Coinbase|Kraken|FTX|Uniswap|PancakeSwap)\b/i)) {
+            entityType = 'EXCHANGE';
+        } else if (entity.word.match(/\b(Ethereum|Bitcoin|Polygon|TON|Solana|BNB Chain)\b/i)) {
+            entityType = 'NETWORK';
+        } else if (entity.word.match(/\b(Smart Contract|DAO|DeFi|DApp)\b/i)) {
+            entityType = 'CONTRACT';
+        }
+        
+        entityClass = entityClasses[entityType] || 'entity';
+        
+        // Add entity span
+        html += `<span class="entity ${entityClass}" title="${entityType}">${entity.word}</span>`;
+        
+        lastPos = entity.end;
+    });
+    
+    // Add remaining text
+    if (lastPos < originalText.length) {
+        html += originalText.slice(lastPos);
+    }
+    
+    entitiesResult.innerHTML = html;
+}
+
+// Display classification results
+function displayClassification(result) {
+    if (result.labels.length === 0) {
+        classificationResult.innerHTML = '<p>No classifications determined.</p>';
+        return;
+    }
+    
+    let html = '<div class="d-flex flex-wrap">';
+    
+    // Show top 3 classifications
+    for (let i = 0; i < Math.min(3, result.labels.length); i++) {
+        const label = result.labels[i];
+        const score = result.scores[i];
+        const confidence = (score * 100).toFixed(1);
+        
+        const badgeClass = score > 0.7 ? 'classification-badge high-confidence' : 'classification-badge';
+        
+        html += `
+            <span class="${badgeClass}">
+                ${label} (${confidence}%)
+            </span>
+        `;
+    }
+    
+    html += '</div>';
+    classificationResult.innerHTML = html;
+}
+
+// Show error message
+function showError(message) {
+    errorContainer.textContent = message;
+    errorContainer.classList.remove('d-none');
+    resultsContainer.classList.add('d-none');
+    loadingIndicator.classList.add('d-none');
+}
+
+// Event listeners
+analyzeBtn.addEventListener('click', analyzeTextContent);
+
+// Load models when page loads (but don't block UI)
+window.addEventListener('load', () => {
+    loadModels().catch(error => {
+        console.error('Initial model loading error:', error);
+    });
+});