tabularisai
/

robust-sentiment-analysis

@@ -114,6 +114,92 @@ The model demonstrates strong performance across various sentiment categories. H
 ```
 ## Training Procedure
 The model was fine-tuned on synthetic data using the `bert-base-uncased` architecture. The training process involved:

 ```
+## JS example
+```js
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Tabularis Sentiment Analysis</title>
+</head>
+<body>
+    <div id="output"></div>
+    <script type="module">
+        import { AutoTokenizer, AutoModel, env } from 'https://cdn.jsdelivr.net/npm/@xenova/[email protected]';
+        env.allowLocalModels = false;
+        env.useCDN = true;
+        const MODEL_NAME = 'tabularisai/bert-base-uncased-sentiment-five-classes';
+        function softmax(arr) {
+            const max = Math.max(...arr);
+            const exp = arr.map(x => Math.exp(x - max));
+            const sum = exp.reduce((acc, val) => acc + val);
+            return exp.map(x => x / sum);
+        }
+        async function analyzeSentiment() {
+            try {
+                const tokenizer = await AutoTokenizer.from_pretrained(MODEL_NAME);
+                const model = await AutoModel.from_pretrained(MODEL_NAME);
+                const texts = [
+                    "I absolutely loved this movie! The acting was superb and the plot was engaging.",
+                    "The service at this restaurant was terrible. I'll never go back.",
+                    "The product works as expected. Nothing special, but it gets the job done.",
+                    "I'm somewhat disappointed with my purchase. It's not as good as I hoped.",
+                    "This book changed my life! I couldn't put it down and learned so much."
+                ];
+                const output = document.getElementById('output');
+                for (const text of texts) {
+                    const inputs = await tokenizer(text, { return_tensors: 'pt' });
+                    const result = await model(inputs);
+                    console.log('Model output:', result);
+                    if (result.output && result.output.data) {
+                        const logitsArray = Array.from(result.output.data);
+                        console.log('Logits array:', logitsArray);
+                        const probabilities = softmax(logitsArray);
+                        const predicted_class = probabilities.indexOf(Math.max(...probabilities));
+                        const sentimentMap = {
+                            0: "Very Negative",
+                            1: "Negative",
+                            2: "Neutral",
+                            3: "Positive",
+                            4: "Very Positive"
+                        };
+                        const sentiment = sentimentMap[predicted_class];
+                        const score = probabilities[predicted_class];
+                        output.innerHTML += `Text: "${text}"<br>`;
+                        output.innerHTML += `Sentiment: ${sentiment}, Score: ${score.toFixed(4)}<br><br>`;
+                    } else {
+                        console.error('Unexpected model output structure:', result);
+                        output.innerHTML += `Unable to process: "${text}"<br><br>`;
+                    }
+                }
+            } catch (error) {
+                console.error('Error:', error);
+                document.getElementById('output').innerHTML = 'An error occurred. Please check the console for details.';
+            }
+        }
+        analyzeSentiment();
+    </script>
+</body>
+</html>
+```
 ## Training Procedure
 The model was fine-tuned on synthetic data using the `bert-base-uncased` architecture. The training process involved: