Upload Group E fine-tuned verifier (LmArena)

Browse files

Files changed (8) hide show

README.md +401 -0
config.json +36 -0
config_sentence_transformers.json +11 -0
model.safetensors +3 -0
modules.json +8 -0
sentence_bert_config.json +10 -0
tokenizer.json +0 -0
tokenizer_config.json +18 -0

README.md ADDED Viewed

	@@ -0,0 +1,401 @@

+---
+tags:
+- sentence-transformers
+- cross-encoder
+- reranker
+- generated_from_trainer
+- dataset_size:11271
+- loss:BinaryCrossEntropyLoss
+base_model: cross-encoder/ms-marco-MiniLM-L6-v2
+pipeline_tag: text-ranking
+library_name: sentence-transformers
+license: other
+license_name: all-rights-reserved
+license_link: https://github.com/imxinchengyou/CacheVerifier/blob/main/LICENSE
+---
+Fine-tuned verifier (Group E, LmArena) from ["Synchronous Online Verification
+Gating in Semantic Caches"](https://github.com/imxinchengyou/CacheVerifier).
+Published for reproducibility of the paper's results only — see the LICENSE
+link above; no license is granted for reuse, modification, or
+redistribution.
+# CrossEncoder based on cross-encoder/ms-marco-MiniLM-L6-v2
+This is a [Cross Encoder](https://www.sbert.net/docs/cross_encoder/usage/usage.html) model finetuned from [cross-encoder/ms-marco-MiniLM-L6-v2](https://huggingface.co/cross-encoder/ms-marco-MiniLM-L6-v2) using the [sentence-transformers](https://www.SBERT.net) library. It computes scores for pairs of texts, which can be used for text reranking and semantic search.
+## Model Details
+### Model Description
+- **Model Type:** Cross Encoder
+- **Base model:** [cross-encoder/ms-marco-MiniLM-L6-v2](https://huggingface.co/cross-encoder/ms-marco-MiniLM-L6-v2) <!-- at revision c5ee24cb16019beea0893ab7796b1df96625c6b8 -->
+- **Maximum Sequence Length:** 512 tokens
+- **Number of Output Labels:** 1 label
+- **Supported Modality:** Text
+<!-- - **Training Dataset:** Unknown -->
+<!-- - **Language:** Unknown -->
+<!-- - **License:** Unknown -->
+### Model Sources
+- **Documentation:** [Sentence Transformers Documentation](https://sbert.net)
+- **Documentation:** [Cross Encoder Documentation](https://www.sbert.net/docs/cross_encoder/usage/usage.html)
+- **Repository:** [Sentence Transformers on GitHub](https://github.com/huggingface/sentence-transformers)
+- **Hugging Face:** [Cross Encoders on Hugging Face](https://huggingface.co/models?library=sentence-transformers&other=cross-encoder)
+### Full Model Architecture
+```
+CrossEncoder(
+  (0): Transformer({'transformer_task': 'sequence-classification', 'modality_config': {'text': {'method': 'forward', 'method_output_name': 'logits'}}, 'module_output_name': 'scores', 'architecture': 'BertForSequenceClassification'})
+)
+```
+## Usage
+### Direct Usage (Sentence Transformers)
+First install the Sentence Transformers library:
+```bash
+pip install -U sentence-transformers
+```
+Then you can load this model and run inference.
+```python
+from sentence_transformers import CrossEncoder
+# Download from the 🤗 Hub
+model = CrossEncoder("cross_encoder_model_id")
+# Get scores for pairs of inputs
+pairs = [
+    [">\n        I've reached the PICO-8 cartridge token limit, but I still have essential code to implement to complete my game. What are my options to overcome this restriction?", 'Yes, there are instances where SI prefixes deviate from strictly representing powers of 10, particularly when they are applied outside the context of pure decimal scaling or when used in specialized fields. While the standard SI prefixes (like kilo-, mega-, giga-, etc.) are defined to denote powers of 10 (e.g., kilo- = 10³, mega- = 10^6), some exceptions and nuances exist:\n\n1. **Use in Binary Contexts (Non-SI Usage):**  \n   Although not officially part of SI, prefixes like **kibi- (Ki), mebi- (Mi), gibi- (Gi),** etc., are used to denote binary multiples (2^10, 2^20, 2^30, etc.). These are standardized by the IEC (International Electrotechnical Commission) to avoid confusion, but they are not SI prefixes and do not represent powers of 10.\n\n2. **Historical and Commercial Usage:**  \n   In some cases, prefixes like **megabyte** or **gigabyte** have been used inconsistently, sometimes representing 10^6 bytes and other times 2^20 bytes, especially in computing. This is a deviation from the SI standard, which strictly defines prefixes as powers of 10.\n\n3. **Non-Standard or Context-Specific Deviations:**  \n   Certain fields or industries may adopt prefixes in ways that do not align with SI definitions, either for convenience or tradition. For example, in chemistry or physics, prefixes are generally consistent with SI, but in other contexts, they might be used loosely.\n\n**In summary:**  \nWhile SI prefixes are designed to denote powers of 10, their application outside pure SI units—such as in computing with binary prefixes or in colloquial usage—can lead to deviations from the standard. These deviations are often clarified by adopting standardized binary prefixes (kibi-, mebi-, gibi-) to distinguish from SI-based decimal prefixes.'],
+    ['>\n        What educational path should I pursue to pursue a career in drug discovery?', "In PICO-8, the cartridge token limit (typically 8192 tokens) is a core constraint designed to encourage efficient coding and creativity. If you've reached this limit but still need to add essential code, here are some strategies to help you overcome or work around the restriction:\n\n1. **Optimize and Minimize Your Code:**\n   - **Remove Redundancies:** Eliminate duplicate code, unused variables, and unnecessary comments.\n   - **Use Shorter Variable Names:** Shorter identifiers consume fewer tokens.\n   - **Compress Logic:** Simplify complex expressions and combine statements where possible.\n   - **Use Tables and Data Structures:** Store repeated data in tables instead of multiple variables or functions.\n\n2. **Split Your Game into Multiple Cartidges:**\n   - **Modular Approach:** Divide your game into separate parts or levels, each in its own cartridge.\n   - **Loading External Data:** Use the `load()` function to load code or data from external files (if your workflow allows), effectively splitting code across multiple cartridges.\n   - **Linking Multiple Cartridges:** Implement a system where one cartridge acts as a launcher or menu, then loads other parts as needed.\n\n3. **Use External Tools and Preprocessing:**\n   - **Code Generators:** Write scripts to generate repetitive code or data, reducing manual token usage.\n   - **Preprocessing:** Use external tools to compress or encode data, then decode at runtime.\n\n4. **Leverage PICO-8's Cartridge Features:**\n   - **Data Storage:** Store large static data in the cart's data section and load it at runtime.\n   - **Use the `load()` Function:** Load code snippets or data dynamically if your workflow supports it.\n\n5. **Consider Alternative Approaches:**\n   - **Simplify Game Mechanics:** Reduce features or graphics complexity to free up space.\n   - **Use External Storage (if available):** Though limited, some workflows allow external data loading.\n\n**Important Note:**  \nPICO-8's design intentionally limits code size to promote concise coding. While splitting into multiple cartridges is a practical solution, it also adds complexity to your project management. Always weigh the benefits of splitting against the added complexity.\n\n**Summary:**  \n- Optimize your code for size.\n- Split your game into multiple cartridges and load parts dynamically.\n- Use external tools to generate or compress code/data.\n- Simplify your game to fit within the token limit.\n\nIf you provide specific code snippets or details about what you're trying to implement, I can offer more targeted advice!"],
+    ["Create Matlab illustrations for visualizing Maxwell's equations.", 'Certainly! Here\'s a complete example of a realistic 2D simulation of Newton\'s Cradle using HTML, CSS, and JavaScript. This implementation features five metallic spheres suspended from a simple frame, and allows you to click and drag the leftmost sphere to set it in motion. When released, the spheres swing naturally, demonstrating the conservation of momentum and energy.\n\n---\n\n### Features:\n- Five aligned spheres suspended by strings.\n- Click-and-drag to pull back the first sphere.\n- Smooth swinging motion with realistic physics.\n- Lifelike animation mimicking a real Newton\'s Cradle.\n\n---\n\n### Complete Code:\n\n```html\n<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="UTF-8" />\n<meta name="viewport" content="width=device-width, initial-scale=1.0" />\n<title>Newton\'s Cradle Simulation</title>\n<style>\n  body {\n    background-color: #222;\n    margin: 0;\n    overflow: hidden;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    height: 100vh;\n  }\n\n  svg {\n    background-color: #444;\n  }\n\n  /* Optional: Style for the draggable sphere cursor */\n  circle.draggable {\n    cursor: grab;\n  }\n</style>\n</head>\n<body>\n\n<svg id="cradle" width="800" height="400"></svg>\n\n<script>\n  const svg = document.getElementById(\'cradle\');\n\n  // Configuration\n  const NUM_SPHERES = 5;\n  const SPHERE_RADIUS = 20;\n  const SPACING = 50; // space between spheres\n  const STRING_LENGTH = 150; // length of suspension strings\n  const FRAME_WIDTH = 800;\n  const FRAME_HEIGHT = 400;\n\n  // Positions\n  const cradleX = (FRAME_WIDTH - (NUM_SPHERES - 1) * SPACING) / 2;\n  const cradleY = 50; // top position of the frame\n\n  // Arrays to hold spheres and strings\n  const spheres = [];\n  const strings = [];\n\n  // State variables for dragging\n  let isDragging = false;\n  let dragSphereIndex = 0; // index of the sphere being dragged\n  let dragStart = { x: 0, y: 0 };\n  let currentMouse = { x: 0, y: 0 };\n\n  // Physics parameters\n  const gravity = 0.98; // gravity acceleration\n  const damping = 0.999; // damping factor for energy loss\n  const timeStep = 0.016; // ~60 FPS\n\n  // Initialize spheres and strings\n  for (let i = 0; i < NUM_SPHERES; i++) {\n    const x = cradleX + i * SPACING;\n    const y = cradleY + STRING_LENGTH;\n\n    // Create sphere\n    const sphere = {\n      index: i,\n      x: x,\n      y: y,\n      vx: 0,\n      vy: 0,\n      radius: SPHERE_RADIUS,\n      fixed: false, // only the first sphere is draggable\n    };\n    spheres.push(sphere);\n\n    // Create string (line)\n    const line = {\n      x1: x,\n      y1: cradleY,\n      x2: x,\n      y2: y,\n    };\n    strings.push(line);\n  }\n\n  // Draw the frame\n  const frame = document.createElementNS("http://www.w3.org/2000/svg", "rect");\n  frame.setAttribute("x", FRAME_WIDTH / 2 - 100);\n  frame.setAttribute("y", cradleY - 20);\n  frame.setAttribute("width", 200);\n  frame.setAttribute("height", 20);\n  frame.setAttribute("fill", "#888");\n  svg.appendChild(frame);\n\n  // Draw strings and spheres\n  for (let i = 0; i < NUM_SPHERES; i++) {\n    // String\n    const line = document.createElementNS("http://www.w3.org/2000/svg", "line");\n    line.setAttribute("stroke", "#ccc");\n    line.setAttribute("stroke-width", "2");\n    svg.appendChild(line);\n    strings[i].element = line;\n\n    // Sphere\n    const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");\n    circle.setAttribute("cx", spheres[i].x);\n    circle.setAttribute("cy", spheres[i].y);\n    circle.setAttribute("r", SPHERE_RADIUS);\n    circle.setAttribute("fill", "#bbb");\n    circle.setAttribute("stroke", "#999");\n    circle.setAttribute("stroke-width", "2");\n    if (i === 0) {\n      circle.classList.add("draggable");\n    }\n    svg.appendChild(circle);\n    spheres[i].element = circle;\n  }\n\n  // Helper function to update the SVG elements\n  function updateGraphics() {\n    for (let i = 0; i < NUM_SPHERES; i++) {\n      const s = spheres[i];\n      // Update string\n      const line = strings[i].element;\n      line.setAttribute("x1", cradleX + i * SPACING);\n      line.setAttribute("y1", cradleY);\n      line.setAttribute("x2", s.x);\n      line.setAttribute("y2", s.y);\n\n      // Update sphere position\n      s.element.setAttribute("cx", s.x);\n      s.element.setAttribute("cy", s.y);\n    }\n  }\n\n  // Physics simulation: constrain spheres to pendulum motion\n  function simulate() {\n    for (let i = 0; i < NUM_SPHERES; i++) {\n      const s = spheres[i];\n\n      if (i === 0 && isDragging) {\n        // During dragging, position is controlled by mouse\n        continue;\n      }\n\n      // Calculate the vector from the pivot point to the sphere\n      const dx = s.x - (cradleX + i * SPACING);\n      const dy = s.y - cradleY;\n      const dist = Math.sqrt(dx * dx + dy * dy);\n      const diff = dist - STRING_LENGTH;\n\n      if (dist !== 0) {\n        // Correct position to maintain string length\n        const correction = (diff / dist) * 0.2; // correction factor\n        s.x -= dx * correction;\n        s.y -= dy * correction;\n      }\n\n      // Apply physics: simple pendulum physics\n      // Calculate the angle\n      const angle = Math.atan2(s.x - (cradleX + i * SPACING), s.y - cradleY);\n      // For small angles, approximate motion\n      // Here, for simplicity, we simulate swinging with basic physics\n\n      // Update velocities\n      s.vx *= damping;\n      s.vy += gravity * timeStep;\n\n      // Update positions\n      s.x += s.vx;\n      s.y += s.vy;\n\n      // Constrain to the circle path (simulate pendulum swing)\n      const dx2 = s.x - (cradleX + i * SPACING);\n      const dy2 = s.y - cradleY;\n      const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);\n      if (dist2 !== 0) {\n        const correction2 = (dist2 - STRING_LENGTH) / dist2;\n        s.x -= dx2 * correction2;\n        s.y -= dy2 * correction2;\n      }\n    }\n\n    // Handle collisions (simple elastic collisions between spheres)\n    for (let i = 0; i < NUM_SPHERES - 1; i++) {\n      const s1 = spheres[i];\n      const s2 = spheres[i + 1];\n\n      const dx = s2.x - s1.x;\n      const dy = s2.y - s1.y;\n      const dist = Math.sqrt(dx * dx + dy * dy);\n      if (dist < s1.radius + s2.radius && dist !== 0) {\n        // Overlap detected, resolve collision\n        const overlap = 0.5 * (dist - s1.radius - s2.radius);\n        const nx = dx / dist;\n        const ny = dy / dist;\n\n        s1.x -= overlap * nx;\n        s1.y -= overlap * ny;\n        s2.x += overlap * nx;\n        s2.y += overlap * ny;\n\n        // Exchange velocities (elastic collision)\n        const v1 = s1.vx * nx + s1.vy * ny;\n        const v2 = s2.vx * nx + s2.vy * ny;\n\n        const m1 = 1; // mass\n        const m2 = 1;\n\n        const v1After = v2;\n        const v2After = v1;\n\n        s1.vx += (v1After - v1) * nx;\n        s1.vy += (v1After - v1) * ny;\n        s2.vx += (v2After - v2) * nx;\n        s2.vy += (v2After - v2) * ny;\n      }\n    }\n  }\n\n  // Animation loop\n  function animate() {\n    simulate();\n    updateGraphics();\n    requestAnimationFrame(animate);\n  }\n\n  // Event listeners for dragging\n  svg.addEventListener(\'mousedown\', (e) => {\n    const rect = svg.getBoundingClientRect();\n    const mouseX = e.clientX - rect.left;\n    const mouseY = e.clientY - rect.top;\n\n    // Check if clicked on the first sphere\n    const s = spheres[0];\n    const dx = mouseX - s.x;\n    const dy = mouseY - s.y;\n    if (dx * dx + dy * dy <= s.radius * s.radius) {\n      isDragging = true;\n      dragSphereIndex = 0;\n      dragStart.x = mouseX;\n      dragStart.y = mouseY;\n      currentMouse.x = mouseX;\n      currentMouse.y = mouseY;\n    }\n  });\n\n  svg.addEventListener(\'mousemove\', (e) => {\n    if (isDragging) {\n      const rect = svg.getBoundingClientRect();\n      currentMouse.x = e.clientX - rect.left;\n      currentMouse.y = e.clientY - rect.top;\n\n      // Update sphere position directly\n      const s = spheres[dragSphereIndex];\n      s.x = currentMouse.x;\n      s.y = currentMouse.y;\n\n      // Calculate velocity based on movement\n      s.vx = (s.x - dragStart.x) / timeStep;\n      s.vy = (s.y - dragStart.y) / timeStep;\n\n      dragStart.x = s.x;\n      dragStart.y = s.y;\n    }\n  });\n\n  svg.addEventListener(\'mouseup\', () => {\n    if (isDragging) {\n      isDragging = false;\n    }\n  });\n\n  // Optional: release sphere with physics\n  document.addEventListener(\'mouseup\', () => {\n    if (isDragging) {\n      isDragging = false;\n    }\n  });\n\n  // Start animation\n  animate();\n\n</script>\n</body>\n</html>\n```\n\n---\n\n### How it works:\n- The five spheres are aligned horizontally and suspended from a frame.\n- You can click and drag the leftmost sphere to set it in motion.\n- When released, the sphere swings naturally, transferring momentum to the others.\n- The simulation includes simple physics for pendulum motion, collision detection, and elastic collisions.\n- The animation runs smoothly with `requestAnimationFrame`.\n\n### Customization:\n- Adjust `NUM_SPHERES`, `SPHERE_RADIUS`, `STRING_LENGTH`, and other parameters to customize the appearance and behavior.\n- You can add controls to reset the simulation or pull back other spheres.\n\n---\n\nFeel free to copy and modify this code to suit your needs!'],
+    ['What is the count of the letter "r" in the words "strawberry" and "programmer"? What is the count of the letter "b" in the word "bubble"?', "Let's analyze the problem step by step:\n\n- Sally is a girl, so she has at least one sister: herself.\n- She has 3 brothers.\n- Each brother has 2 sisters.\n\nSince each brother has 2 sisters, and Sally is one of those sisters, the other sister must be the other girl(s) in the family.\n\nBecause all brothers share the same sisters, the total number of sisters is the number of girls in the family.\n\nGiven that Sally is a girl, and each brother has 2 sisters, the total number of sisters is 2.\n\nBut one of those sisters is Sally herself, so the total number of sisters Sally has **excluding herself** is:\n\n**Total sisters = 2 - 1 = 1**\n\n**Answer:**\n\n\\(\\boxed{1}\\)\n\nSally has **1 sister** in total."],
+    ['>\n        Spell the word Silk three consecutive times, then tell me the beverage cows consume.', 'Let\'s count the occurrences:\n\n- In "strawberry": the letter "r" appears 2 times.\n- In "programmer": the letter "r" appears 3 times.\n- In "bubble": the letter "b" appears 2 times.\n\n**Summary:**\n- "r" in "strawberry": 2\n- "r" in "programmer": 3\n- "b" in "bubble": 2'],
+]
+scores = model.predict(pairs)
+print(scores)
+# [-9.8512 -9.9604 -7.3734 -8.6995 -7.0944]
+# Or rank different texts based on similarity to a single text
+ranks = model.rank(
+    ">\n        I've reached the PICO-8 cartridge token limit, but I still have essential code to implement to complete my game. What are my options to overcome this restriction?",
+    [
+        'Yes, there are instances where SI prefixes deviate from strictly representing powers of 10, particularly when they are applied outside the context of pure decimal scaling or when used in specialized fields. While the standard SI prefixes (like kilo-, mega-, giga-, etc.) are defined to denote powers of 10 (e.g., kilo- = 10³, mega- = 10^6), some exceptions and nuances exist:\n\n1. **Use in Binary Contexts (Non-SI Usage):**  \n   Although not officially part of SI, prefixes like **kibi- (Ki), mebi- (Mi), gibi- (Gi),** etc., are used to denote binary multiples (2^10, 2^20, 2^30, etc.). These are standardized by the IEC (International Electrotechnical Commission) to avoid confusion, but they are not SI prefixes and do not represent powers of 10.\n\n2. **Historical and Commercial Usage:**  \n   In some cases, prefixes like **megabyte** or **gigabyte** have been used inconsistently, sometimes representing 10^6 bytes and other times 2^20 bytes, especially in computing. This is a deviation from the SI standard, which strictly defines prefixes as powers of 10.\n\n3. **Non-Standard or Context-Specific Deviations:**  \n   Certain fields or industries may adopt prefixes in ways that do not align with SI definitions, either for convenience or tradition. For example, in chemistry or physics, prefixes are generally consistent with SI, but in other contexts, they might be used loosely.\n\n**In summary:**  \nWhile SI prefixes are designed to denote powers of 10, their application outside pure SI units—such as in computing with binary prefixes or in colloquial usage—can lead to deviations from the standard. These deviations are often clarified by adopting standardized binary prefixes (kibi-, mebi-, gibi-) to distinguish from SI-based decimal prefixes.',
+        "In PICO-8, the cartridge token limit (typically 8192 tokens) is a core constraint designed to encourage efficient coding and creativity. If you've reached this limit but still need to add essential code, here are some strategies to help you overcome or work around the restriction:\n\n1. **Optimize and Minimize Your Code:**\n   - **Remove Redundancies:** Eliminate duplicate code, unused variables, and unnecessary comments.\n   - **Use Shorter Variable Names:** Shorter identifiers consume fewer tokens.\n   - **Compress Logic:** Simplify complex expressions and combine statements where possible.\n   - **Use Tables and Data Structures:** Store repeated data in tables instead of multiple variables or functions.\n\n2. **Split Your Game into Multiple Cartidges:**\n   - **Modular Approach:** Divide your game into separate parts or levels, each in its own cartridge.\n   - **Loading External Data:** Use the `load()` function to load code or data from external files (if your workflow allows), effectively splitting code across multiple cartridges.\n   - **Linking Multiple Cartridges:** Implement a system where one cartridge acts as a launcher or menu, then loads other parts as needed.\n\n3. **Use External Tools and Preprocessing:**\n   - **Code Generators:** Write scripts to generate repetitive code or data, reducing manual token usage.\n   - **Preprocessing:** Use external tools to compress or encode data, then decode at runtime.\n\n4. **Leverage PICO-8's Cartridge Features:**\n   - **Data Storage:** Store large static data in the cart's data section and load it at runtime.\n   - **Use the `load()` Function:** Load code snippets or data dynamically if your workflow supports it.\n\n5. **Consider Alternative Approaches:**\n   - **Simplify Game Mechanics:** Reduce features or graphics complexity to free up space.\n   - **Use External Storage (if available):** Though limited, some workflows allow external data loading.\n\n**Important Note:**  \nPICO-8's design intentionally limits code size to promote concise coding. While splitting into multiple cartridges is a practical solution, it also adds complexity to your project management. Always weigh the benefits of splitting against the added complexity.\n\n**Summary:**  \n- Optimize your code for size.\n- Split your game into multiple cartridges and load parts dynamically.\n- Use external tools to generate or compress code/data.\n- Simplify your game to fit within the token limit.\n\nIf you provide specific code snippets or details about what you're trying to implement, I can offer more targeted advice!",
+        'Certainly! Here\'s a complete example of a realistic 2D simulation of Newton\'s Cradle using HTML, CSS, and JavaScript. This implementation features five metallic spheres suspended from a simple frame, and allows you to click and drag the leftmost sphere to set it in motion. When released, the spheres swing naturally, demonstrating the conservation of momentum and energy.\n\n---\n\n### Features:\n- Five aligned spheres suspended by strings.\n- Click-and-drag to pull back the first sphere.\n- Smooth swinging motion with realistic physics.\n- Lifelike animation mimicking a real Newton\'s Cradle.\n\n---\n\n### Complete Code:\n\n```html\n<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="UTF-8" />\n<meta name="viewport" content="width=device-width, initial-scale=1.0" />\n<title>Newton\'s Cradle Simulation</title>\n<style>\n  body {\n    background-color: #222;\n    margin: 0;\n    overflow: hidden;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    height: 100vh;\n  }\n\n  svg {\n    background-color: #444;\n  }\n\n  /* Optional: Style for the draggable sphere cursor */\n  circle.draggable {\n    cursor: grab;\n  }\n</style>\n</head>\n<body>\n\n<svg id="cradle" width="800" height="400"></svg>\n\n<script>\n  const svg = document.getElementById(\'cradle\');\n\n  // Configuration\n  const NUM_SPHERES = 5;\n  const SPHERE_RADIUS = 20;\n  const SPACING = 50; // space between spheres\n  const STRING_LENGTH = 150; // length of suspension strings\n  const FRAME_WIDTH = 800;\n  const FRAME_HEIGHT = 400;\n\n  // Positions\n  const cradleX = (FRAME_WIDTH - (NUM_SPHERES - 1) * SPACING) / 2;\n  const cradleY = 50; // top position of the frame\n\n  // Arrays to hold spheres and strings\n  const spheres = [];\n  const strings = [];\n\n  // State variables for dragging\n  let isDragging = false;\n  let dragSphereIndex = 0; // index of the sphere being dragged\n  let dragStart = { x: 0, y: 0 };\n  let currentMouse = { x: 0, y: 0 };\n\n  // Physics parameters\n  const gravity = 0.98; // gravity acceleration\n  const damping = 0.999; // damping factor for energy loss\n  const timeStep = 0.016; // ~60 FPS\n\n  // Initialize spheres and strings\n  for (let i = 0; i < NUM_SPHERES; i++) {\n    const x = cradleX + i * SPACING;\n    const y = cradleY + STRING_LENGTH;\n\n    // Create sphere\n    const sphere = {\n      index: i,\n      x: x,\n      y: y,\n      vx: 0,\n      vy: 0,\n      radius: SPHERE_RADIUS,\n      fixed: false, // only the first sphere is draggable\n    };\n    spheres.push(sphere);\n\n    // Create string (line)\n    const line = {\n      x1: x,\n      y1: cradleY,\n      x2: x,\n      y2: y,\n    };\n    strings.push(line);\n  }\n\n  // Draw the frame\n  const frame = document.createElementNS("http://www.w3.org/2000/svg", "rect");\n  frame.setAttribute("x", FRAME_WIDTH / 2 - 100);\n  frame.setAttribute("y", cradleY - 20);\n  frame.setAttribute("width", 200);\n  frame.setAttribute("height", 20);\n  frame.setAttribute("fill", "#888");\n  svg.appendChild(frame);\n\n  // Draw strings and spheres\n  for (let i = 0; i < NUM_SPHERES; i++) {\n    // String\n    const line = document.createElementNS("http://www.w3.org/2000/svg", "line");\n    line.setAttribute("stroke", "#ccc");\n    line.setAttribute("stroke-width", "2");\n    svg.appendChild(line);\n    strings[i].element = line;\n\n    // Sphere\n    const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");\n    circle.setAttribute("cx", spheres[i].x);\n    circle.setAttribute("cy", spheres[i].y);\n    circle.setAttribute("r", SPHERE_RADIUS);\n    circle.setAttribute("fill", "#bbb");\n    circle.setAttribute("stroke", "#999");\n    circle.setAttribute("stroke-width", "2");\n    if (i === 0) {\n      circle.classList.add("draggable");\n    }\n    svg.appendChild(circle);\n    spheres[i].element = circle;\n  }\n\n  // Helper function to update the SVG elements\n  function updateGraphics() {\n    for (let i = 0; i < NUM_SPHERES; i++) {\n      const s = spheres[i];\n      // Update string\n      const line = strings[i].element;\n      line.setAttribute("x1", cradleX + i * SPACING);\n      line.setAttribute("y1", cradleY);\n      line.setAttribute("x2", s.x);\n      line.setAttribute("y2", s.y);\n\n      // Update sphere position\n      s.element.setAttribute("cx", s.x);\n      s.element.setAttribute("cy", s.y);\n    }\n  }\n\n  // Physics simulation: constrain spheres to pendulum motion\n  function simulate() {\n    for (let i = 0; i < NUM_SPHERES; i++) {\n      const s = spheres[i];\n\n      if (i === 0 && isDragging) {\n        // During dragging, position is controlled by mouse\n        continue;\n      }\n\n      // Calculate the vector from the pivot point to the sphere\n      const dx = s.x - (cradleX + i * SPACING);\n      const dy = s.y - cradleY;\n      const dist = Math.sqrt(dx * dx + dy * dy);\n      const diff = dist - STRING_LENGTH;\n\n      if (dist !== 0) {\n        // Correct position to maintain string length\n        const correction = (diff / dist) * 0.2; // correction factor\n        s.x -= dx * correction;\n        s.y -= dy * correction;\n      }\n\n      // Apply physics: simple pendulum physics\n      // Calculate the angle\n      const angle = Math.atan2(s.x - (cradleX + i * SPACING), s.y - cradleY);\n      // For small angles, approximate motion\n      // Here, for simplicity, we simulate swinging with basic physics\n\n      // Update velocities\n      s.vx *= damping;\n      s.vy += gravity * timeStep;\n\n      // Update positions\n      s.x += s.vx;\n      s.y += s.vy;\n\n      // Constrain to the circle path (simulate pendulum swing)\n      const dx2 = s.x - (cradleX + i * SPACING);\n      const dy2 = s.y - cradleY;\n      const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);\n      if (dist2 !== 0) {\n        const correction2 = (dist2 - STRING_LENGTH) / dist2;\n        s.x -= dx2 * correction2;\n        s.y -= dy2 * correction2;\n      }\n    }\n\n    // Handle collisions (simple elastic collisions between spheres)\n    for (let i = 0; i < NUM_SPHERES - 1; i++) {\n      const s1 = spheres[i];\n      const s2 = spheres[i + 1];\n\n      const dx = s2.x - s1.x;\n      const dy = s2.y - s1.y;\n      const dist = Math.sqrt(dx * dx + dy * dy);\n      if (dist < s1.radius + s2.radius && dist !== 0) {\n        // Overlap detected, resolve collision\n        const overlap = 0.5 * (dist - s1.radius - s2.radius);\n        const nx = dx / dist;\n        const ny = dy / dist;\n\n        s1.x -= overlap * nx;\n        s1.y -= overlap * ny;\n        s2.x += overlap * nx;\n        s2.y += overlap * ny;\n\n        // Exchange velocities (elastic collision)\n        const v1 = s1.vx * nx + s1.vy * ny;\n        const v2 = s2.vx * nx + s2.vy * ny;\n\n        const m1 = 1; // mass\n        const m2 = 1;\n\n        const v1After = v2;\n        const v2After = v1;\n\n        s1.vx += (v1After - v1) * nx;\n        s1.vy += (v1After - v1) * ny;\n        s2.vx += (v2After - v2) * nx;\n        s2.vy += (v2After - v2) * ny;\n      }\n    }\n  }\n\n  // Animation loop\n  function animate() {\n    simulate();\n    updateGraphics();\n    requestAnimationFrame(animate);\n  }\n\n  // Event listeners for dragging\n  svg.addEventListener(\'mousedown\', (e) => {\n    const rect = svg.getBoundingClientRect();\n    const mouseX = e.clientX - rect.left;\n    const mouseY = e.clientY - rect.top;\n\n    // Check if clicked on the first sphere\n    const s = spheres[0];\n    const dx = mouseX - s.x;\n    const dy = mouseY - s.y;\n    if (dx * dx + dy * dy <= s.radius * s.radius) {\n      isDragging = true;\n      dragSphereIndex = 0;\n      dragStart.x = mouseX;\n      dragStart.y = mouseY;\n      currentMouse.x = mouseX;\n      currentMouse.y = mouseY;\n    }\n  });\n\n  svg.addEventListener(\'mousemove\', (e) => {\n    if (isDragging) {\n      const rect = svg.getBoundingClientRect();\n      currentMouse.x = e.clientX - rect.left;\n      currentMouse.y = e.clientY - rect.top;\n\n      // Update sphere position directly\n      const s = spheres[dragSphereIndex];\n      s.x = currentMouse.x;\n      s.y = currentMouse.y;\n\n      // Calculate velocity based on movement\n      s.vx = (s.x - dragStart.x) / timeStep;\n      s.vy = (s.y - dragStart.y) / timeStep;\n\n      dragStart.x = s.x;\n      dragStart.y = s.y;\n    }\n  });\n\n  svg.addEventListener(\'mouseup\', () => {\n    if (isDragging) {\n      isDragging = false;\n    }\n  });\n\n  // Optional: release sphere with physics\n  document.addEventListener(\'mouseup\', () => {\n    if (isDragging) {\n      isDragging = false;\n    }\n  });\n\n  // Start animation\n  animate();\n\n</script>\n</body>\n</html>\n```\n\n---\n\n### How it works:\n- The five spheres are aligned horizontally and suspended from a frame.\n- You can click and drag the leftmost sphere to set it in motion.\n- When released, the sphere swings naturally, transferring momentum to the others.\n- The simulation includes simple physics for pendulum motion, collision detection, and elastic collisions.\n- The animation runs smoothly with `requestAnimationFrame`.\n\n### Customization:\n- Adjust `NUM_SPHERES`, `SPHERE_RADIUS`, `STRING_LENGTH`, and other parameters to customize the appearance and behavior.\n- You can add controls to reset the simulation or pull back other spheres.\n\n---\n\nFeel free to copy and modify this code to suit your needs!',
+        "Let's analyze the problem step by step:\n\n- Sally is a girl, so she has at least one sister: herself.\n- She has 3 brothers.\n- Each brother has 2 sisters.\n\nSince each brother has 2 sisters, and Sally is one of those sisters, the other sister must be the other girl(s) in the family.\n\nBecause all brothers share the same sisters, the total number of sisters is the number of girls in the family.\n\nGiven that Sally is a girl, and each brother has 2 sisters, the total number of sisters is 2.\n\nBut one of those sisters is Sally herself, so the total number of sisters Sally has **excluding herself** is:\n\n**Total sisters = 2 - 1 = 1**\n\n**Answer:**\n\n\\(\\boxed{1}\\)\n\nSally has **1 sister** in total.",
+        'Let\'s count the occurrences:\n\n- In "strawberry": the letter "r" appears 2 times.\n- In "programmer": the letter "r" appears 3 times.\n- In "bubble": the letter "b" appears 2 times.\n\n**Summary:**\n- "r" in "strawberry": 2\n- "r" in "programmer": 3\n- "b" in "bubble": 2',
+    ]
+)
+# [{'corpus_id': ..., 'score': ...}, {'corpus_id': ..., 'score': ...}, ...]
+```
+<!--
+### Direct Usage (Transformers)
+<details><summary>Click to see the direct usage in Transformers</summary>
+</details>
+-->
+<!--
+### Downstream Usage (Sentence Transformers)
+You can finetune this model on your own dataset.
+<details><summary>Click to expand</summary>
+</details>
+-->
+<!--
+### Out-of-Scope Use
+*List how the model may foreseeably be misused and address what users ought not to do with the model.*
+-->
+<!--
+## Bias, Risks and Limitations
+*What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model.*
+-->
+<!--
+### Recommendations
+*What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.*
+-->
+## Training Details
+### Training Dataset
+#### Unnamed Dataset
+* Size: 11,271 training samples
+* Columns: <code>query</code>, <code>response</code>, and <code>label</code>
+* Approximate statistics based on the first 100 samples:
+  |          | query                                                                               | response                                                                             | label                                                          |
+  |:---------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:---------------------------------------------------------------|
+  | type     | string                                                                              | string                                                                               | float                                                          |
+  | modality | text                                                                                | text                                                                                 |                                                                |
+  | details  | <ul><li>min: 11 tokens</li><li>mean: 42.12 tokens</li><li>max: 117 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 346.26 tokens</li><li>max: 512 tokens</li></ul> | <ul><li>min: 0.0</li><li>mean: 0.03</li><li>max: 1.0</li></ul> |
+* Samples:
+  | query                                                                                                                                                                                        | response                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | label            |
+  |:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------|
+  | <code>><br>        I've reached the PICO-8 cartridge token limit, but I still have essential code to implement to complete my game. What are my options to overcome this restriction?</code> | <code>Yes, there are instances where SI prefixes deviate from strictly representing powers of 10, particularly when they are applied outside the context of pure decimal scaling or when used in specialized fields. While the standard SI prefixes (like kilo-, mega-, giga-, etc.) are defined to denote powers of 10 (e.g., kilo- = 10³, mega- = 10^6), some exceptions and nuances exist:<br><br>1. **Use in Binary Contexts (Non-SI Usage):**  <br>   Although not officially part of SI, prefixes like **kibi- (Ki), mebi- (Mi), gibi- (Gi),** etc., are used to denote binary multiples (2^10, 2^20, 2^30, etc.). These are standardized by the IEC (International Electrotechnical Commission) to avoid confusion, but they are not SI prefixes and do not represent powers of 10.<br><br>2. **Historical and Commercial Usage:**  <br>   In some cases, prefixes like **megabyte** or **gigabyte** have been used inconsistently, sometimes representing 10^6 bytes and other times 2^20 bytes, especially in computing. This is a deviation from the S...</code>                                                                                  | <code>0.0</code> |
+  | <code>><br>        What educational path should I pursue to pursue a career in drug discovery?</code>                                                                                        | <code>In PICO-8, the cartridge token limit (typically 8192 tokens) is a core constraint designed to encourage efficient coding and creativity. If you've reached this limit but still need to add essential code, here are some strategies to help you overcome or work around the restriction:<br><br>1. **Optimize and Minimize Your Code:**<br>   - **Remove Redundancies:** Eliminate duplicate code, unused variables, and unnecessary comments.<br>   - **Use Shorter Variable Names:** Shorter identifiers consume fewer tokens.<br>   - **Compress Logic:** Simplify complex expressions and combine statements where possible.<br>   - **Use Tables and Data Structures:** Store repeated data in tables instead of multiple variables or functions.<br><br>2. **Split Your Game into Multiple Cartidges:**<br>   - **Modular Approach:** Divide your game into separate parts or levels, each in its own cartridge.<br>   - **Loading External Data:** Use the `load()` function to load code or data from external files (if your workflow allows), effectively s...</code>                                                                      | <code>0.0</code> |
+  | <code>Create Matlab illustrations for visualizing Maxwell's equations.</code>                                                                                                                | <code>Certainly! Here's a complete example of a realistic 2D simulation of Newton's Cradle using HTML, CSS, and JavaScript. This implementation features five metallic spheres suspended from a simple frame, and allows you to click and drag the leftmost sphere to set it in motion. When released, the spheres swing naturally, demonstrating the conservation of momentum and energy.<br><br>---<br><br>### Features:<br>- Five aligned spheres suspended by strings.<br>- Click-and-drag to pull back the first sphere.<br>- Smooth swinging motion with realistic physics.<br>- Lifelike animation mimicking a real Newton's Cradle.<br><br>---<br><br>### Complete Code:<br><br>```html<br><!DOCTYPE html><br><html lang="en"><br><head><br><meta charset="UTF-8" /><br><meta name="viewport" content="width=device-width, initial-scale=1.0" /><br><title>Newton's Cradle Simulation</title><br><style><br>  body {<br>    background-color: #222;<br>    margin: 0;<br>    overflow: hidden;<br>    display: flex;<br>    justify-content: center;<br>    align-items: center;<br>    height: 100vh;<br>  }<br><br>  svg {<br>    backg...</code> | <code>0.0</code> |
+* Loss: [<code>BinaryCrossEntropyLoss</code>](https://sbert.net/docs/package_reference/cross_encoder/losses.html#binarycrossentropyloss) with these parameters:
+  ```json
+  {
+      "activation_fn": "torch.nn.modules.linear.Identity",
+      "pos_weight": null
+  }
+  ```
+### Training Hyperparameters
+#### Non-Default Hyperparameters
+- `per_device_train_batch_size`: 16
+- `num_train_epochs`: 1
+- `disable_tqdm`: True
+- `use_cpu`: True
+- `dataloader_pin_memory`: False
+#### All Hyperparameters
+<details><summary>Click to expand</summary>
+- `per_device_train_batch_size`: 16
+- `num_train_epochs`: 1
+- `max_steps`: -1
+- `learning_rate`: 5e-05
+- `lr_scheduler_type`: linear
+- `lr_scheduler_kwargs`: None
+- `warmup_steps`: 0
+- `optim`: adamw_torch_fused
+- `optim_args`: None
+- `weight_decay`: 0.0
+- `adam_beta1`: 0.9
+- `adam_beta2`: 0.999
+- `adam_epsilon`: 1e-08
+- `optim_target_modules`: None
+- `gradient_accumulation_steps`: 1
+- `average_tokens_across_devices`: True
+- `max_grad_norm`: 1.0
+- `label_smoothing_factor`: 0.0
+- `bf16`: False
+- `fp16`: False
+- `bf16_full_eval`: False
+- `fp16_full_eval`: False
+- `tf32`: None
+- `gradient_checkpointing`: False
+- `gradient_checkpointing_kwargs`: None
+- `torch_compile`: False
+- `torch_compile_backend`: None
+- `torch_compile_mode`: None
+- `use_liger_kernel`: False
+- `liger_kernel_config`: None
+- `use_cache`: False
+- `neftune_noise_alpha`: None
+- `torch_empty_cache_steps`: None
+- `auto_find_batch_size`: False
+- `log_on_each_node`: True
+- `logging_nan_inf_filter`: True
+- `include_num_input_tokens_seen`: no
+- `log_level`: passive
+- `log_level_replica`: warning
+- `disable_tqdm`: True
+- `project`: huggingface
+- `trackio_space_id`: None
+- `trackio_bucket_id`: None
+- `trackio_static_space_id`: None
+- `per_device_eval_batch_size`: 8
+- `prediction_loss_only`: True
+- `eval_on_start`: False
+- `eval_do_concat_batches`: True
+- `eval_use_gather_object`: False
+- `eval_accumulation_steps`: None
+- `include_for_metrics`: []
+- `batch_eval_metrics`: False
+- `save_only_model`: False
+- `save_on_each_node`: False
+- `enable_jit_checkpoint`: False
+- `push_to_hub`: False
+- `hub_private_repo`: None
+- `hub_model_id`: None
+- `hub_strategy`: every_save
+- `hub_always_push`: False
+- `hub_revision`: None
+- `load_best_model_at_end`: False
+- `ignore_data_skip`: False
+- `restore_callback_states_from_checkpoint`: False
+- `full_determinism`: False
+- `seed`: 42
+- `data_seed`: None
+- `use_cpu`: True
+- `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
+- `parallelism_config`: None
+- `dataloader_drop_last`: False
+- `dataloader_num_workers`: 0
+- `dataloader_pin_memory`: False
+- `dataloader_persistent_workers`: False
+- `dataloader_prefetch_factor`: None
+- `remove_unused_columns`: True
+- `label_names`: None
+- `train_sampling_strategy`: random
+- `length_column_name`: length
+- `ddp_find_unused_parameters`: None
+- `ddp_bucket_cap_mb`: None
+- `ddp_broadcast_buffers`: False
+- `ddp_static_graph`: None
+- `ddp_backend`: None
+- `ddp_timeout`: 1800
+- `fsdp`: None
+- `fsdp_config`: None
+- `deepspeed`: None
+- `debug`: []
+- `skip_memory_metrics`: True
+- `do_predict`: False
+- `resume_from_checkpoint`: None
+- `warmup_ratio`: None
+- `local_rank`: -1
+- `prompts`: None
+- `batch_sampler`: batch_sampler
+- `multi_dataset_batch_sampler`: proportional
+- `router_mapping`: {}
+- `learning_rate_mapping`: {}
+</details>
+### Training Logs
+| Epoch  | Step | Training Loss |
+|:------:|:----:|:-------------:|
+| 0.0014 | 1    | 1.7589        |
+| 0.0142 | 10   | 0.7247        |
+| 0.0284 | 20   | 0.5189        |
+| 0.0426 | 30   | 0.4005        |
+| 0.0567 | 40   | 0.2951        |
+| 0.0709 | 50   | 0.3512        |
+| 0.0851 | 60   | 0.3036        |
+| 0.0993 | 70   | 0.4066        |
+| 0.1135 | 80   | 0.2312        |
+| 0.1277 | 90   | 0.2853        |
+| 0.1418 | 100  | 0.4700        |
+| 0.1560 | 110  | 0.3224        |
+| 0.1702 | 120  | 0.2299        |
+| 0.1844 | 130  | 0.2821        |
+| 0.1986 | 140  | 0.2797        |
+| 0.2128 | 150  | 0.2947        |
+| 0.2270 | 160  | 0.3521        |
+| 0.2411 | 170  | 0.2829        |
+| 0.2553 | 180  | 0.3016        |
+| 0.2695 | 190  | 0.2234        |
+| 0.2837 | 200  | 0.2994        |
+| 0.2979 | 210  | 0.2335        |
+| 0.3121 | 220  | 0.2349        |
+| 0.3262 | 230  | 0.2979        |
+| 0.3404 | 240  | 0.2734        |
+| 0.3546 | 250  | 0.3042        |
+| 0.3688 | 260  | 0.2363        |
+| 0.3830 | 270  | 0.1922        |
+| 0.3972 | 280  | 0.2754        |
+| 0.4113 | 290  | 0.2362        |
+| 0.4255 | 300  | 0.2816        |
+| 0.4397 | 310  | 0.2817        |
+| 0.4539 | 320  | 0.2295        |
+| 0.4681 | 330  | 0.2632        |
+| 0.4823 | 340  | 0.3445        |
+| 0.4965 | 350  | 0.2628        |
+| 0.5106 | 360  | 0.2045        |
+| 0.5248 | 370  | 0.2248        |
+| 0.5390 | 380  | 0.2457        |
+| 0.5532 | 390  | 0.1711        |
+| 0.5674 | 400  | 0.1769        |
+| 0.5816 | 410  | 0.1659        |
+| 0.5957 | 420  | 0.2287        |
+| 0.6099 | 430  | 0.2872        |
+| 0.6241 | 440  | 0.2694        |
+| 0.6383 | 450  | 0.2780        |
+| 0.6525 | 460  | 0.2891        |
+| 0.6667 | 470  | 0.2256        |
+| 0.6809 | 480  | 0.2170        |
+| 0.6950 | 490  | 0.2348        |
+| 0.7092 | 500  | 0.1746        |
+| 0.7234 | 510  | 0.1982        |
+| 0.7376 | 520  | 0.1707        |
+| 0.7518 | 530  | 0.2627        |
+| 0.7660 | 540  | 0.3044        |
+| 0.7801 | 550  | 0.2399        |
+| 0.7943 | 560  | 0.1909        |
+| 0.8085 | 570  | 0.2009        |
+| 0.8227 | 580  | 0.2445        |
+| 0.8369 | 590  | 0.2160        |
+| 0.8511 | 600  | 0.2534        |
+| 0.8652 | 610  | 0.1833        |
+| 0.8794 | 620  | 0.2560        |
+| 0.8936 | 630  | 0.1496        |
+| 0.9078 | 640  | 0.2143        |
+| 0.9220 | 650  | 0.3094        |
+| 0.9362 | 660  | 0.2049        |
+| 0.9504 | 670  | 0.2383        |
+| 0.9645 | 680  | 0.2916        |
+| 0.9787 | 690  | 0.1812        |
+| 0.9929 | 700  | 0.3707        |
+### Training Time
+- **Training**: 43.3 minutes
+### Framework Versions
+- Python: 3.11.6
+- Sentence Transformers: 5.6.1
+- Transformers: 5.14.1
+- PyTorch: 2.13.0+cu130
+- Accelerate: 1.14.0
+- Datasets: 5.0.0
+- Tokenizers: 0.22.2
+## Additional Resources
+- [Training and Finetuning Reranker Models with Sentence Transformers](https://huggingface.co/blog/train-reranker): the end-to-end guide for training or finetuning Cross Encoder (reranker) models.
+- [Multimodal Embedding & Reranker Models with Sentence Transformers](https://huggingface.co/blog/multimodal-sentence-transformers): use text, image, audio, and video reranker models through the same API.
+- [Training and Finetuning Multimodal Embedding & Reranker Models with Sentence Transformers](https://huggingface.co/blog/train-multimodal-sentence-transformers): training multimodal Cross Encoders.
+## Citation
+### BibTeX
+#### Sentence Transformers
+```bibtex
+@inproceedings{reimers-2019-sentence-bert,
+    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
+    author = "Reimers, Nils and Gurevych, Iryna",
+    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
+    month = "11",
+    year = "2019",
+    publisher = "Association for Computational Linguistics",
+    url = "https://arxiv.org/abs/1908.10084",
+}
+```
+<!--
+## Glossary
+*Clearly define terms in order to be accessible across audiences.*
+-->
+<!--
+## Model Card Authors
+*Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction.*
+-->
+<!--
+## Model Card Contact
+*Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors.*
+-->

config.json ADDED Viewed

	@@ -0,0 +1,36 @@

+{
+  "add_cross_attention": false,
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": null,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "id2label": {
+    "0": "LABEL_0"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "is_decoder": false,
+  "label2id": {
+    "LABEL_0": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.14.1",
+  "type_vocab_size": 2,
+  "use_cache": false,
+  "vocab_size": 30522
+}

config_sentence_transformers.json ADDED Viewed

	@@ -0,0 +1,11 @@

+{
+  "__version__": {
+    "pytorch": "2.13.0+cu130",
+    "sentence_transformers": "5.6.1",
+    "transformers": "5.14.1"
+  },
+  "activation_fn": "torch.nn.modules.linear.Identity",
+  "default_prompt_name": null,
+  "model_type": "CrossEncoder",
+  "prompts": {}
+}

model.safetensors ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:6fd221e492f95fe0360746f8a0e89716cbb9864f92b0955ce12b4c041866e8e9
+size 90866412

modules.json ADDED Viewed

	@@ -0,0 +1,8 @@

+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.base.modules.transformer.Transformer"
+  }
+]

sentence_bert_config.json ADDED Viewed

	@@ -0,0 +1,10 @@

+{
+    "transformer_task": "sequence-classification",
+    "modality_config": {
+        "text": {
+            "method": "forward",
+            "method_output_name": "logits"
+        }
+    },
+    "module_output_name": "scores"
+}

tokenizer.json ADDED Viewed

The diff for this file is too large to render. See raw diff

tokenizer_config.json ADDED Viewed

	@@ -0,0 +1,18 @@

+{
+  "backend": "tokenizers",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}