Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+evaluation/similarity_matrix.png filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,66 @@
+QodoAI Open RAIL++-M License
+Last Updated: February 19, 2025
+Section I: PREAMBLE
+This Open RAIL++-M License applies to Licensor's code embedding and integrity multimodal generative AI models.  
+This License strives for both the open and responsible downstream use of the Qodo Model accompanying this License. The openness here means enabling users of the Qodo Models to generally make royalty-free and subscription fee-free use of the applicable Qodo Model, modify and creative Derivatives thereof, while complying with use-based restrictions not permitting the use of the Qodo Model in very specific to ensure responsible use. While Derivatives of the Qodo Model can be released under different licensing terms, the latter will always have to include - at minimum - the same use-based restrictions as the ones in the original License.
+This License governs the use of Qodo Models (and their Derivatives) and is informed by the model card associated with the relevant Qodo Model accompanying this License.
+NOW THEREFORE, You and Licensor agree as follows:
+1. Definitions
+(a) "License" means these terms and conditions for use, reproduction, and Distribution of the Qodo Models and their Derivatives, as defined herein. For the avoidance of doubt, Data and source code are not licensed under this License. 
+(b) "Data" means a collection of information and/or content extracted from the dataset used with the Qodo Model, including to train, pretrain, or otherwise evaluate the Qodo Model. The Data is not licensed under this License.
+(c) "Output" means the results of operating a Qodo Model as embodied in informational content resulting therefrom.
+(d) "Qodo Model" means any accompanying machine-learning based assemblies (including checkpoints), consisting of learnt weights, parameters (including optimizer states), corresponding to the model architecture as embodied in the Complementary Material, that have been trained or tuned, in whole or in part on the Data, using the Complementary Material. 
+(e) "Derivatives" means all modifications to the Qodo Model, works based on the Qodo Model, or any other model which is created or initialized by transfer of patterns of the weights, parameters, activations or output of the Qodo Model, to the other model, in order to cause the other model to perform similarly to the Qodo Model, including - but not limited to - distillation methods entailing the use of intermediate data representations or methods based on the generation of synthetic data by the Qodo Model for training the other model.
+(f) "Complementary Material" means the accompanying scripts used to define, run, load, benchmark or evaluate the Qodo Model, and used to prepare data for training or evaluation, if any. This includes any accompanying documentation, tutorials, examples, etc, if any.
+(g) "Distribution" means any transmission, reproduction, publication or other sharing of the Qodo Model or Derivatives of the Qodo Model to a third party, including providing the Qodo Model as a hosted or cloud service made available by electronic or other remote means - e.g. API-based or web-access.
+(h) "Licensor", "Qodo" or "QodoAI" means Codium Ltd. (dba Qodo), or any corporate affiliate of Qodo authorized by it that is granting this License to You. 
+(i) "You" (or "Your") means an individual or legal entity exercising permissions granted by this License and/or making use of the Qodo Model for whichever purpose and in any field of use, including commercial usage of the Qodo Model in an end-use application - e.g. chatbot, translator, code generator. If You are accepting this License on behalf of a company or another legal entity, you represent that You have the authority to bind such legal entity to this License. 
+(j) "Third Parties" means individuals or legal entities that are not under common control with Licensor or You.
+(k) "Contribution" means any work of authorship, including the original version of the Qodo Model and any modifications or additions to that Model or Derivatives of the Qodo Model thereof, that is intentionally submitted to Licensor for inclusion in the Qodo Model by the copyright owner or by an individual or legal entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Qodo Model, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+(l) "Contributor" means Licensor and any individual or legal entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Qodo Model.
+Section II: INTELLECTUAL PROPERTY RIGHTS
+Both copyright and patent grants apply to the Qodo Model, Derivatives of the Qodo Model and Complementary Material. The Qodo Model and Derivatives of the Qodo Model are subject to additional terms as described in Section III.
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, copyright license to reproduce, prepare, publicly display, publicly perform, sublicense, and distribute the Complementary Material, the Qodo Model, and Derivatives of the Qodo Model.
+3. Grant of Patent License. Subject to the terms and conditions of this License and where and as applicable, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, (except as stated in this paragraph) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Qodo Model and the Complementary Material, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Qodo Model to which such Contribution(s) was submitted. 
+4. Termination for IP Claims. If You institute litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Qodo Model and/or Complementary Material or a Contribution incorporated within the Qodo Model and/or Complementary Material constitutes direct or contributory intellectual rights (including copyright or patent) infringement, then any licenses granted to You under this License for the Qodo Model and/or Derivatives shall terminate as of the date such litigation is asserted or filed.
+       Section III: CONDITIONS OF USAGE, DISTRIBUTION AND REDISTRIBUTION
+5. Distribution and Redistribution. You may host for Third Parties remote access purposes (e.g. software-as-a-service), reproduce and distribute copies of the Qodo Model or Derivatives of the Qodo Model thereof in any medium, with or without modifications, provided that You meet the following conditions:
+a. Use-based restrictions as referenced in paragraph 5 MUST be included as an enforceable provision by You in any type of legal agreement (e.g. a license, customer or subscription agreement) governing the use and/or Distribution of the Qodo Model or Derivatives of the Qodo Model, and You shall give notice to subsequent users You Distribute to, that the Qodo Model or Derivatives of the Qodo Model are subject to paragraph 5. This provision does not apply to the use of Complementary Material.
+b. You must give any Third Party recipients of the Qodo Model or Derivatives of the Qodo Model a copy of this License;
+   c. You must cause any modified files to carry prominent notices stating that You changed the files;
+d. You must retain all copyright, patent, trademark, and attribution notices excluding those notices that do not pertain to any part of the Qodo Model, Derivatives of the Qodo Model.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions - respecting paragraph 4.a. - for use, reproduction, or Distribution of Your modifications, or for any such Derivatives of the Qodo Model as a whole, provided Your use, reproduction, and Distribution of the Qodo Model otherwise complies with the conditions stated in this License.
+6. Use-based restrictions. The restrictions set forth in Attachment A are considered use-based restrictions. Therefore You cannot use the Qodo Model and the Derivatives of the Qodo Model for the specified restricted uses. You may use the Qodo Model subject to this License, including only for lawful purposes and in accordance with the License. Use may include creating any content with, finetuning, distillation, updating, running, training, evaluating and/or reparametrizing the Qodo Model, provided that if You use the Qodo Model, the Derivatives or Complementary Materials to create, train, fine tune, or otherwise improve an AI model, which is distributed or otherwise made available, You must include "Qodo" at the beginning of any such AI model's name . You shall require all of Your users who use the Qodo Model or a Derivative of the Qodo Model to comply with the terms of this paragraph (paragraph 5).
+7. The Output You Generate. Except as set forth herein, Licensor claims no rights in the Output You generate using the Qodo Model. You are accountable for the Output you generate and its subsequent uses. No use of the output can contravene any provision as stated in the License.
+Section IV: OTHER PROVISIONS
+8. Updates and Runtime Restrictions. To the maximum extent permitted by law, Licensor reserves the right to restrict (remotely or otherwise) usage of the Qodo Model in violation of this License, update the Qodo Model through electronic means, or modify the Output of the Qodo Model based on updates. You shall undertake reasonable efforts to use the latest version of the Qodo Model.
+9. Trademarks and related. Nothing in this License permits You to make use of Licensors' trademarks, trade names, logos or to otherwise suggest endorsement or misrepresent the relationship between the parties; and any rights not expressly granted herein are reserved by the Licensors.
+10. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Qodo Model and the Complementary Material (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Qodo Model, Derivatives of the Qodo Model, and the Complementary Material and assume any risks associated with Your exercise of permissions under this License.
+11. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor (including Licensor) be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Qodo Model and the Complementary Material (including but not limited to damages for loss of goodwill, work stoppage, computer or model failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. To the extent such limitation of direct damages is restricted under the laws of Your jurisdiction, then in respect of such jurisdiction Contributor's aggregate liability under, arising out of or otherwise in connection with this License shall be capped at $100. 
+12.  Indemnity. You will indemnify, defend, and hold harmless Qodo, its affiliates, and their respective shareholders, resellers, vendors, directors, employees and agents from and against all liabilities, damages, and costs (including reasonable attorneys' fees) arising out of any claim, demand, suit or proceeding by a third party arising out of or related to your use of or distribution of the Qodo Model, the Derivatives or Output.
+13. Accepting Warranty or Additional Liability. While redistributing the Qodo Model, the Derivatives of the Qodo Model and the Complementary Material thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+14. Severability. If any provision of this License is held to be invalid, illegal or unenforceable, the remaining provisions shall be unaffected thereby and remain valid as if such provision had not been set forth herein.
+15. Amendments. Qodo may update, revise or amend this License, with or without notice, at its sole discretion, including to comply with regulatory requirements and in accordance with developments in the AI field, and will post such updated version on Qodo's website and/or 3rd party code repository website(s) and/or platform(s) where the Qodo Models are made available. Qodo encourages You to regularly review these. The last revision will be reflected in the "Last Updated" heading. Your continued use of the Qodo Models, Complementary Materials and Derivatives following any such amendment will be considered your consent to the updated License terms, and to the extent You disagree with the amendment, You must cease your use and distribution of the Qodo Models, the Complementary Materials and any Derivative thereof. 
+END OF TERMS AND CONDITIONS
+
+
+Attachment A
+Use Restrictions
+You agree not to use the Qodo Model or Derivatives of the Qodo Model:
+(a) In any way that violates any applicable national, federal, state, local or international law or regulation;
+(b) For the purpose of exploiting, harming or attempting to exploit or harm minors in any way;
+(c) To generate or disseminate verifiably false information and/or content with the purpose of harming others;
+(d) To generate or disseminate personal identifiable information that can be used to harm an individual;
+(e) To generate or disseminate information and/or content (e.g. images, code, posts, articles), and place the information and/or content in any context (e.g. bot generating tweets) without expressly and intelligibly disclaiming that the information and/or content is machine generated;
+(f) To defame, disparage or otherwise harass others;
+(g) To impersonate or attempt to impersonate (e.g. deepfakes) others without their consent;
+(h) For fully automated decision making that adversely impacts an individual's legal rights or otherwise creates or modifies a binding, enforceable obligation;
+(i) For any use intended to or which has the effect of discriminating against or harming individuals or groups based on online or offline social behavior or known or predicted personal or personality characteristics, or in a manner that is obscene, violent, hateful, racist or discriminatory, pornographic or is otherwise offensive;
+(j) To exploit any of the vulnerabilities of a specific group of persons based on their age, social, physical or mental characteristics, in order to materially distort the behavior of a person pertaining to that group in a manner that causes or is likely to cause that person or another person physical or psychological harm;
+(k) For any use intended to or which has the effect of discriminating against individuals or groups based on legally protected characteristics or categories;
+(l) To provide medical advice and medical results interpretation;
+(m) To generate or disseminate information for the purpose to be used for administration of justice, law enforcement, immigration or asylum processes, such as predicting an individual will commit fraud/crime commitment (e.g. by text profiling, drawing causal relationships between assertions made in documents, indiscriminate and arbitrarily-targeted use).
+(n) To infringe, violate or misappropriate any patent, trademark, trade secret, copyright, or other intellectual property or other proprietary rights of any other person.
+(o) To transmit or otherwise makes available any malicious code, including any virus, worm, trojan horse, time bomb, web bug, spyware, or any other malicious or harmful computer code, library, file, or program.
+

README.md

@@ -1,5 +1,155 @@
----
-license: other
-license_name: qodoai-open-rail-m
-license_link: https://www.qodo.ai/open-rail-m-license/
----
+---
+base_model: Qodo/Qodo-Embed-1-1.5B
+library_name: model2vec
+license: other
+license_name: qodoai-open-rail-m
+license_link: LICENSE
+model_name: Qodo-Embed-M-1-1.5B-M2V-Distilled
+tags:
+- sentence-transformers
+- sentence-similarity
+- feature-extraction
+- transformers
+- Qwen2
+---
+
+# Qodo-Embed-M-1-1.5B-M2V-Distilled
+
+This project optimizes the Qodo-Embed-1-1.5B model using Model2Vec, reducing its size and dramatically improving inference speed while maintaining most of its performance capabilities.
+
+## Overview
+
+[Qodo-Embed-1-1.5B](https://huggingface.co/Qodo/Qodo-Embed-1-1.5B) is a state-of-the-art code embedding model designed for retrieval tasks in the software development domain. While powerful, it can be resource-intensive for production use cases.
+
+[Model2Vec](https://github.com/MinishLab/model2vec) is a technique to distill large sentence transformer models into small, fast static embedding models. This project applies Model2Vec to create an optimized version of Qodo-Embed-1-1.5B with the following benefits:
+
+- **Smaller Size**: Reduces model size by a factor of 25x
+- **Faster Inference**: Up to 112x faster inference
+- **Low Resource Requirements**: Minimal memory footprint and dependencies
+- **Maintains Performance**: Retains most of the original model's capabilities
+
+## Model Information
+
+- **Model Name**: Qodo-Embed-M-1-1.5B-M2V-Distilled
+- **Original Model**: [Qodo-Embed-1-1.5B](https://huggingface.co/Qodo/Qodo-Embed-1-1.5B)
+- **Distillation Method**: [Model2Vec](https://github.com/MinishLab/model2vec)
+- **Original Dimensions**: 1536
+- **Distilled Dimensions**: 384
+- **Explained Variance**: ~85%
+- **Size Reduction**: 25.26x (from 5.9GB to 233MB)
+- **Speed Improvement**: 112.14x faster
+
+## Installation
+
+First, ensure you have the required dependencies:
+
+```bash
+# Install the base package
+uv add --group model2vec model2vec 'model2vec[distill]' sentence-transformers transformers
+
+# Install additional dependencies for evaluation
+uv add --group model2vec matplotlib psutil
+```
+
+## Usage
+
+### Distillation
+
+To create a distilled version of Qodo-Embed-1-1.5B:
+
+```bash
+python models/qodo_embed_m2v/distill.py --pca_dims 384
+```
+
+Options:
+- `--model_name` - Source model name (default: "Qodo/Qodo-Embed-1-1.5B")
+- `--output_dir` - Where to save the distilled model (default: "models/qodo_embed_m2v")
+- `--pca_dims` - Dimensions for PCA reduction; smaller values create faster but less accurate models (default: 384)
+- `--save_to_hub` - Push the model to HuggingFace Hub
+- `--hub_model_id` - Model ID for HuggingFace Hub (required if saving to hub)
+- `--skip_readme` - Skip generating README file (default: True)
+
+### Evaluation
+
+To evaluate the distilled model against the original:
+
+```bash
+python models/qodo_embed_m2v/evaluate.py
+```
+
+Options:
+- `--original_model` - Original model name (default: "Qodo/Qodo-Embed-1-1.5B")
+- `--distilled_model` - Path to the distilled model (default: "models/qodo_embed_m2v")
+- `--output_dir` - Where to save evaluation results (default: "models/qodo_embed_m2v/evaluation")
+
+## Example Code
+
+```python
+from model2vec import StaticModel
+from sentence_transformers import SentenceTransformer
+import time
+
+# Sample code for embedding
+code_samples = [
+    "def process_data_stream(source_iterator):",
+    "implement binary search tree",
+    "how to handle memory efficient data streaming",
+    """class LazyLoader:
+        def __init__(self, source):
+            self.generator = iter(source)
+            self._cache = []"""
+]
+
+# Load original model
+print("Loading original model...")
+original_model = SentenceTransformer("Qodo/Qodo-Embed-1-1.5B")
+
+# Load distilled model
+print("Loading distilled model...")
+distilled_model = StaticModel.from_pretrained("models/qodo_embed_m2v")
+
+# Compare embedding speed
+print("\nGenerating embeddings with original model...")
+start = time.time()
+original_embeddings = original_model.encode(code_samples)
+original_time = time.time() - start
+print(f"Original model took: {original_time:.4f} seconds")
+
+print("\nGenerating embeddings with distilled model...")
+start = time.time()
+distilled_embeddings = distilled_model.encode(code_samples)
+distilled_time = time.time() - start
+print(f"Distilled model took: {distilled_time:.4f} seconds")
+print(f"Speed improvement: {original_time/distilled_time:.2f}x faster")
+
+print(f"\nOriginal embedding dimensions: {original_embeddings.shape}")
+print(f"Distilled embedding dimensions: {distilled_embeddings.shape}")
+```
+
+## Results
+
+The distilled model achieves:
+
+- 25.26x reduction in model size (from 5.9GB to 233MB)
+- 112.14x increase in inference speed
+- 85.1% explained variance with PCA reduction to 384 dimensions
+
+Detailed evaluation results, including similarity plots and performance metrics, are saved to the evaluation output directory.
+
+## Project Structure
+
+- `distill.py` - Script to create the distilled model
+- `evaluate.py` - Script to compare performance with the original model
+- `example.py` - Example usage of the distilled model
+- `evaluation/` - Directory containing evaluation results and visualizations
+
+## Acknowledgments
+
+This project is built upon the following technologies:
+
+- [Qodo-Embed-1-1.5B](https://huggingface.co/Qodo/Qodo-Embed-1-1.5B) - The original code embedding model developed by QodoAI
+- [Model2Vec](https://github.com/MinishLab/model2vec) - The distillation technique used to optimize the model
+
+## License
+
+This model is licensed under the [QodoAI-Open-RAIL-M](https://www.qodo.ai/open-rail-m-license/) license, the same as the original Qodo-Embed-1-1.5B model. Any derivative model must include "Qodo" at the beginning of its name per the license requirements. 

config.json

@@ -0,0 +1,13 @@
+{
+    "model_type": "model2vec",
+    "architectures": [
+        "StaticModel"
+    ],
+    "tokenizer_name": "Qodo/Qodo-Embed-1-1.5B",
+    "apply_pca": 384,
+    "apply_zipf": null,
+    "sif_coefficient": 0.0001,
+    "hidden_dim": 384,
+    "seq_length": 1000000,
+    "normalize": true
+}

distill.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+"""
+Script to distill Qodo-Embed-1-1.5B using Model2Vec.
+
+This script performs the following operations:
+1. Downloads the Qodo-Embed-1-1.5B model
+2. Distills it using Model2Vec to create a smaller, faster static model
+3. Saves the distilled model for further use
+"""
+
+import argparse
+import logging
+import shutil
+import time
+from pathlib import Path
+
+from model2vec.distill import distill
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+	"""Run the distillation process for Qodo-Embed-1-1.5B."""
+	parser = argparse.ArgumentParser(description="Distill Qodo-Embed-1-1.5B using Model2Vec")
+	parser.add_argument(
+		"--model_name", default="Qodo/Qodo-Embed-1-1.5B", help="Model name or path for the source model"
+	)
+	parser.add_argument("--output_dir", default="models/qodo_embed_m2v", help="Directory to save the distilled model")
+	parser.add_argument(
+		"--pca_dims", type=int, default=384, help="Dimensions for PCA reduction (smaller = faster but less accurate)"
+	)
+	parser.add_argument("--save_to_hub", action="store_true", help="Whether to push the model to HuggingFace Hub")
+	parser.add_argument("--hub_model_id", default=None, help="Model ID for HuggingFace Hub (if saving to hub)")
+	parser.add_argument("--skip_readme", action="store_true", default=True, help="Skip generating the README file")
+
+	args = parser.parse_args()
+
+	# Create output directory if it doesn't exist
+	output_dir = Path(args.output_dir)
+	output_dir.mkdir(parents=True, exist_ok=True)
+
+	logger.info(f"Starting distillation of {args.model_name}")
+	logger.info(f"Distilled model will be saved to {output_dir}")
+	logger.info(f"Using PCA dimensions: {args.pca_dims}")
+	logger.info(f"Skipping README generation: {args.skip_readme}")
+
+	# Record start time for benchmarking
+	start_time = time.time()
+
+	# Run the distillation
+	try:
+		logger.info("Starting Model2Vec distillation...")
+		m2v_model = distill(
+			model_name=args.model_name,
+			pca_dims=args.pca_dims,
+		)
+
+		distill_time = time.time() - start_time
+		logger.info(f"Distillation completed in {distill_time:.2f} seconds")
+
+		# Save the distilled model
+		m2v_model.save_pretrained(args.output_dir)
+		logger.info(f"Model saved to {args.output_dir}")
+
+		# Remove README.md if it was created and we want to skip it
+		if args.skip_readme and (output_dir / "README.md").exists():
+			(output_dir / "README.md").unlink()
+			logger.info("Removed auto-generated README.md")
+
+		# Get model size information
+		model_size_mb = sum(
+			f.stat().st_size for f in output_dir.glob("**/*") if f.is_file() and f.name != "README.md"
+		) / (1024 * 1024)
+		logger.info(f"Distilled model size: {model_size_mb:.2f} MB")
+
+		# Push to hub if requested
+		if args.save_to_hub:
+			if args.hub_model_id:
+				logger.info(f"Pushing model to HuggingFace Hub as {args.hub_model_id}")
+
+				# Create a temporary README for Hub upload if needed
+				readme_path = output_dir / "README.md"
+				had_readme = readme_path.exists()
+
+				if args.skip_readme and had_readme:
+					# Backup the README
+					shutil.move(readme_path, output_dir / "README.md.bak")
+
+				# Push to Hub
+				m2v_model.push_to_hub(args.hub_model_id)
+
+				# Restore state
+				if args.skip_readme:
+					if had_readme:
+						# Restore the backup
+						shutil.move(output_dir / "README.md.bak", readme_path)
+					elif (output_dir / "README.md").exists():
+						# Remove README created during push_to_hub
+						(output_dir / "README.md").unlink()
+			else:
+				logger.error("--hub_model_id must be specified when using --save_to_hub")
+
+		logger.info("Distillation process completed successfully!")
+
+	except Exception:
+		logger.exception("Error during distillation")
+		raise
+
+
+if __name__ == "__main__":
+	main()

evaluate.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python
+"""
+Script to evaluate the performance of the distilled Qodo-Embed model.
+
+This script performs the following:
+1. Loads both the original Qodo-Embed-1-1.5B model and the distilled version
+2. Compares them on:
+   - Embedding similarity
+   - Inference speed
+   - Memory usage
+3. Outputs a comprehensive evaluation report
+"""
+
+import argparse
+import gc
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+import matplotlib.pyplot as plt
+import numpy as np
+import psutil
+import torch
+from model2vec import StaticModel
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# For transformer models
+from transformers.models.auto.modeling_auto import AutoModel
+from transformers.models.auto.tokenization_auto import AutoTokenizer
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# Sample texts for evaluation
+SAMPLE_TEXTS = [
+	"def process_data_stream(source_iterator):",
+	"implement binary search tree",
+	"how to handle memory efficient data streaming",
+	"""class LazyLoader:
+        def __init__(self, source):
+            self.generator = iter(source)
+            self._cache = []""",
+	"""def dfs_traversal(root):
+        if not root:
+            return []
+        visited = []
+        stack = [root]
+        while stack:
+            node = stack.pop()
+            visited.append(node.val)
+            if node.right:
+                stack.append(node.right)
+            if node.left:
+                stack.append(node.left)
+        return visited""",
+]
+
+
+def load_models(original_model_name: str, distilled_model_path: str) -> tuple[Any, StaticModel]:
+	"""Load both the original and distilled models."""
+	logger.info(f"Loading original model: {original_model_name}")
+
+	try:
+		# Try to load as a sentence transformer first
+		original_model = SentenceTransformer(original_model_name)
+		model_type = "sentence_transformer"
+	except Exception:
+		# If that fails, try loading as a Hugging Face transformer
+		AutoTokenizer.from_pretrained(original_model_name)
+		original_model = AutoModel.from_pretrained(original_model_name)
+		model_type = "huggingface"
+
+	logger.info(f"Loading distilled model from: {distilled_model_path}")
+	distilled_model = StaticModel.from_pretrained(distilled_model_path)
+
+	return (original_model, model_type), distilled_model
+
+
+def measure_memory_usage(model: Any) -> float:
+	"""Measure memory usage of a model in MB."""
+	gc.collect()
+	torch.cuda.empty_cache() if torch.cuda.is_available() else None
+
+	process = psutil.Process(os.getpid())
+	memory_before = process.memory_info().rss / (1024 * 1024)  # MB
+
+	# Force model to allocate memory if it hasn't already
+	if isinstance(model, StaticModel) or hasattr(model, "encode"):
+		_ = model.encode(["Test"])
+	else:
+		# For HF models, we need to handle differently
+		pass
+
+	gc.collect()
+	torch.cuda.empty_cache() if torch.cuda.is_available() else None
+
+	process = psutil.Process(os.getpid())
+	memory_after = process.memory_info().rss / (1024 * 1024)  # MB
+
+	return memory_after - memory_before
+
+
+def compute_embeddings(
+	original_model: Any, original_model_type: str, distilled_model: StaticModel, texts: list[str]
+) -> tuple[np.ndarray, np.ndarray]:
+	"""Compute embeddings using both models."""
+	# Original model embeddings
+	if original_model_type == "sentence_transformer":
+		original_embeddings = original_model.encode(texts)
+	else:
+		# For HF models, we need more custom code
+		# Simple mean pooling function for HF models
+		def mean_pooling(model_output, attention_mask):
+			token_embeddings = model_output[0]
+			input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+			return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(
+				input_mask_expanded.sum(1), min=1e-9
+			)
+
+		tokenizer = AutoTokenizer.from_pretrained(original_model.config._name_or_path)
+		encoded_input = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
+
+		with torch.no_grad():
+			model_output = original_model(**encoded_input)
+			original_embeddings = mean_pooling(model_output, encoded_input["attention_mask"]).numpy()
+
+	# Distilled model embeddings
+	distilled_embeddings = distilled_model.encode(texts)
+
+	return original_embeddings, distilled_embeddings
+
+
+def measure_inference_speed(model: Any, model_type: str, texts: list[str], n_runs: int = 5) -> float:
+	"""Measure inference speed in texts/second."""
+	# Warmup
+	if model_type in {"sentence_transformer", "static_model"}:
+		_ = model.encode(texts[:1])
+	else:
+		# Warmup for HF models
+		tokenizer = AutoTokenizer.from_pretrained(model.config._name_or_path)
+		encoded_input = tokenizer(texts[:1], padding=True, truncation=True, return_tensors="pt")
+		with torch.no_grad():
+			_ = model(**encoded_input)
+
+	# Measure speed
+	start_time = time.time()
+
+	if model_type in {"sentence_transformer", "static_model"}:
+		for _ in range(n_runs):
+			_ = model.encode(texts)
+	else:
+		# For HF models
+		tokenizer = AutoTokenizer.from_pretrained(model.config._name_or_path)
+		for _ in range(n_runs):
+			encoded_input = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
+			with torch.no_grad():
+				_ = model(**encoded_input)
+
+	total_time = time.time() - start_time
+	return (len(texts) * n_runs) / total_time
+
+
+def compute_cosine_similarity(embeddings1: np.ndarray, embeddings2: np.ndarray) -> np.ndarray:
+	"""Compute cosine similarity between embeddings, handling different dimensions.
+
+	For embeddings with different dimensions, we compute similarity by comparing
+	how they rank the same texts (semantically equivalent).
+	"""
+	# Ensure embeddings1 and embeddings2 are 2D arrays with shapes (n_samples, n_features)
+	if embeddings1.ndim == 1:
+		embeddings1 = embeddings1.reshape(1, -1)
+	if embeddings2.ndim == 1:
+		embeddings2 = embeddings2.reshape(1, -1)
+
+	# Check and transpose if needed to ensure samples are in rows
+	if embeddings2.shape[0] != len(SAMPLE_TEXTS) and embeddings2.shape[1] == len(SAMPLE_TEXTS):
+		embeddings2 = embeddings2.T
+
+	logger.info(f"Embeddings shapes: original={embeddings1.shape}, distilled={embeddings2.shape}")
+
+	# If dimensions differ, we compute similarity matrix based on how each model ranks text pairs
+	# This is a form of semantic similarity evaluation rather than direct vector comparison
+	similarity_matrix = np.zeros((len(SAMPLE_TEXTS), len(SAMPLE_TEXTS)))
+
+	# Compute similarity matrices within each embedding space
+	sim1 = cosine_similarity(embeddings1)
+	sim2 = cosine_similarity(embeddings2)
+
+	# The similarity between samples i and j is the correlation between how they rank other samples
+	for i in range(len(SAMPLE_TEXTS)):
+		for j in range(len(SAMPLE_TEXTS)):
+			# For diagonal elements (same sample), use a direct measure of how similar
+			# the two models rank that sample against all others
+			if i == j:
+				# Pearson correlation between the rankings (excluding self-comparison)
+				rankings1 = np.delete(sim1[i], i)
+				rankings2 = np.delete(sim2[i], i)
+				# Higher correlation means the models agree on the semantic similarity
+				similarity_matrix[i, j] = np.corrcoef(rankings1, rankings2)[0, 1]
+			else:
+				# For off-diagonal elements, compare how similarly both models relate samples i and j
+				similarity_matrix[i, j] = 1 - abs(sim1[i, j] - sim2[i, j])
+
+	return similarity_matrix
+
+
+def format_size(size_bytes: float) -> str:
+	"""Format size in bytes to human-readable format."""
+	for unit in ["B", "KB", "MB", "GB"]:
+		if size_bytes < 1024.0:
+			return f"{size_bytes:.2f} {unit}"
+		size_bytes /= 1024.0
+	return f"{size_bytes:.2f} TB"
+
+
+def plot_comparison(results: dict[str, Any], output_dir: str) -> None:
+	"""Generate comparison plots and save them."""
+	output_path = Path(output_dir)
+	output_path.mkdir(exist_ok=True, parents=True)
+
+	# Speed comparison
+	plt.figure(figsize=(10, 6))
+	models = ["Original", "Distilled"]
+	speeds = [results["original_speed"], results["distilled_speed"]]
+	plt.bar(models, speeds, color=["#1f77b4", "#ff7f0e"])
+	plt.ylabel("Texts per second")
+	plt.title("Inference Speed Comparison")
+	plt.savefig(output_path / "speed_comparison.png", dpi=300, bbox_inches="tight")
+
+	# Memory comparison
+	plt.figure(figsize=(10, 6))
+	memories = [results["original_memory"], results["distilled_memory"]]
+	plt.bar(models, memories, color=["#1f77b4", "#ff7f0e"])
+	plt.ylabel("Memory Usage (MB)")
+	plt.title("Memory Usage Comparison")
+	plt.savefig(output_path / "memory_comparison.png", dpi=300, bbox_inches="tight")
+
+	# Size comparison
+	plt.figure(figsize=(10, 6))
+	sizes = [results["original_size"], results["distilled_size"]]
+	plt.bar(models, sizes, color=["#1f77b4", "#ff7f0e"])
+	plt.ylabel("Model Size (MB)")
+	plt.title("Model Size Comparison")
+	plt.savefig(output_path / "size_comparison.png", dpi=300, bbox_inches="tight")
+
+	# Similarity matrix heatmap
+	plt.figure(figsize=(8, 6))
+	plt.imshow(results["similarity_matrix"], cmap="viridis", interpolation="nearest")
+	plt.colorbar(label="Cosine Similarity")
+	plt.title("Embedding Similarity Between Original and Distilled Models")
+	plt.xticks([])
+	plt.yticks(range(len(SAMPLE_TEXTS)), [t[:20] + "..." if len(t) > 20 else t for t in SAMPLE_TEXTS])
+	plt.savefig(output_path / "similarity_matrix.png", dpi=300, bbox_inches="tight")
+
+
+def evaluate_models(original_model_name: str, distilled_model_path: str, output_dir: str):
+	"""Evaluate the original and distilled models."""
+	# Load models
+	(original_model, original_model_type), distilled_model = load_models(original_model_name, distilled_model_path)
+
+	# Measure model sizes
+	original_model_size = sum(p.numel() * 4 for p in original_model.parameters()) / (
+		1024 * 1024
+	)  # MB (assuming float32)
+	distilled_model_size = sum(f.stat().st_size for f in Path(distilled_model_path).glob("**/*") if f.is_file()) / (
+		1024 * 1024
+	)  # MB
+
+	# Measure memory usage
+	original_memory = measure_memory_usage(original_model)
+	distilled_memory = measure_memory_usage(distilled_model)
+
+	# Compute embeddings
+	original_embeddings, distilled_embeddings = compute_embeddings(
+		original_model, original_model_type, distilled_model, SAMPLE_TEXTS
+	)
+
+	# Compute similarity between embeddings
+	similarity_matrix = compute_cosine_similarity(original_embeddings, distilled_embeddings)
+	similarity_diagonal = np.diag(similarity_matrix)
+	avg_similarity = np.mean(similarity_diagonal)
+
+	# Measure inference speed
+	original_speed = measure_inference_speed(original_model, original_model_type, SAMPLE_TEXTS, n_runs=5)
+	distilled_speed = measure_inference_speed(distilled_model, "static_model", SAMPLE_TEXTS, n_runs=5)
+
+	# Collect results
+	results = {
+		"original_size": original_model_size,
+		"distilled_size": distilled_model_size,
+		"original_memory": original_memory,
+		"distilled_memory": distilled_memory,
+		"similarity_matrix": similarity_matrix,
+		"avg_similarity": avg_similarity,
+		"original_speed": original_speed,
+		"distilled_speed": distilled_speed,
+		"speed_improvement": distilled_speed / original_speed if original_speed > 0 else float("inf"),
+		"size_reduction": original_model_size / distilled_model_size if distilled_model_size > 0 else float("inf"),
+		"memory_reduction": original_memory / distilled_memory if distilled_memory > 0 else float("inf"),
+	}
+
+	# Generate plots
+	plot_comparison(results, output_dir)
+
+	# Print results
+	logger.info("\n" + "=" * 50)
+	logger.info("Model Evaluation Results")
+	logger.info("=" * 50)
+	logger.info(f"Original Model Size: {results['original_size']:.2f} MB")
+	logger.info(f"Distilled Model Size: {results['distilled_size']:.2f} MB")
+	logger.info(f"Size Reduction Factor: {results['size_reduction']:.2f}x")
+	logger.info("\n")
+	logger.info(f"Original Model Memory: {results['original_memory']:.2f} MB")
+	logger.info(f"Distilled Model Memory: {results['distilled_memory']:.2f} MB")
+	logger.info(f"Memory Reduction Factor: {results['memory_reduction']:.2f}x")
+	logger.info("\n")
+	logger.info(f"Original Model Speed: {results['original_speed']:.2f} texts/second")
+	logger.info(f"Distilled Model Speed: {results['distilled_speed']:.2f} texts/second")
+	logger.info(f"Speed Improvement Factor: {results['speed_improvement']:.2f}x")
+	logger.info("\n")
+	logger.info(f"Average Embedding Similarity: {results['avg_similarity']:.4f}")
+	logger.info("=" * 50)
+
+	return results
+
+
+def main() -> None:
+	"""Run the evaluation process."""
+	parser = argparse.ArgumentParser(description="Evaluate the distilled model against the original")
+	parser.add_argument("--original_model", default="Qodo/Qodo-Embed-1-1.5B", help="Original model name or path")
+	parser.add_argument("--distilled_model", default="models/qodo_embed_m2v", help="Path to the distilled model")
+	parser.add_argument(
+		"--output_dir", default="models/qodo_embed_m2v/evaluation", help="Directory to save evaluation results"
+	)
+
+	args = parser.parse_args()
+
+	# Create output directory
+	output_dir = Path(args.output_dir)
+	output_dir.mkdir(parents=True, exist_ok=True)
+
+	# Run evaluation
+	try:
+		evaluate_models(args.original_model, args.distilled_model, args.output_dir)
+		logger.info(f"Evaluation completed. Results saved to {args.output_dir}")
+	except Exception:
+		logger.exception("Error during evaluation")
+		raise
+
+
+if __name__ == "__main__":
+	main()

example.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python
+"""
+Example script demonstrating how to use the distilled Qodo-Embed-M-1-1.5B-M2V-Distilled model.
+
+This script shows:
+1. Loading both original and distilled models
+2. Running performance benchmarks
+3. Example code search and similarity scenarios
+"""
+
+import argparse
+import logging
+import time
+
+import numpy as np
+from model2vec import StaticModel
+from sentence_transformers import SentenceTransformer
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# Sample code snippets for demonstration
+CODE_SAMPLES = [
+	"def process_data_stream(source_iterator):",
+	"implement binary search tree",
+	"how to handle memory efficient data streaming",
+	"""class LazyLoader:
+        def __init__(self, source):
+            self.generator = iter(source)
+            self._cache = []""",
+	"""def dfs_traversal(root):
+        if not root:
+            return []
+        visited = []
+        stack = [root]
+        while stack:
+            node = stack.pop()
+            visited.append(node.val)
+            if node.right:
+                stack.append(node.right)
+            if node.left:
+                stack.append(node.left)
+        return visited""",
+	"""def quick_sort(arr):
+        if len(arr) <= 1:
+            return arr
+        pivot = arr[len(arr) // 2]
+        left = [x for x in arr if x < pivot]
+        middle = [x for x in arr if x == pivot]
+        right = [x for x in arr if x > pivot]
+        return quick_sort(left) + middle + quick_sort(right)""",
+	"""def fibonacci(n, memo={}):
+        if n in memo:
+            return memo[n]
+        if n <= 1:
+            return n
+        memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo)
+        return memo[n]""",
+]
+
+# Example code database for search scenarios
+CODE_DATABASE = [
+	"""def binary_search(arr, target):
+        left, right = 0, len(arr) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            if arr[mid] == target:
+                return mid
+            elif arr[mid] < target:
+                left = mid + 1
+            else:
+                right = mid - 1
+        return -1""",
+	"""class BinarySearchTree:
+        def __init__(self, value=None):
+            self.value = value
+            self.left = None
+            self.right = None
+
+        def insert(self, value):
+            if self.value is None:
+                self.value = value
+                return
+            if value < self.value:
+                if self.left is None:
+                    self.left = BinarySearchTree(value)
+                else:
+                    self.left.insert(value)
+            else:
+                if self.right is None:
+                    self.right = BinarySearchTree(value)
+                else:
+                    self.right.insert(value)""",
+	"""def process_stream(source):
+        buffer = []
+        for item in source:
+            if len(buffer) >= 1000:
+                yield buffer
+                buffer = []
+            buffer.append(item)
+        if buffer:  # Don't forget the remainder
+            yield buffer""",
+	"""class StreamProcessor:
+        def __init__(self, chunk_size=1000):
+            self.chunk_size = chunk_size
+
+        def process(self, data_stream):
+            chunks = []
+            current_chunk = []
+            for item in data_stream:
+                current_chunk.append(item)
+                if len(current_chunk) >= self.chunk_size:
+                    chunks.append(current_chunk)
+                    current_chunk = []
+            if current_chunk:
+                chunks.append(current_chunk)
+            return chunks""",
+	"""def memory_efficient_generator(large_file_path):
+        with open(large_file_path, 'r') as f:
+            for line in f:
+                yield process_line(line)
+
+    def process_line(line):
+        # Process the line somehow
+        return line.strip().upper()""",
+	"""class CachedLoader:
+        def __init__(self, datasource, cache_size=100):
+            self.datasource = datasource
+            self.cache_size = cache_size
+            self.cache = {}
+
+        def get(self, key):
+            if key in self.cache:
+                return self.cache[key]
+
+            value = self.datasource.fetch(key)
+
+            # Add to cache, potentially evicting oldest item
+            if len(self.cache) >= self.cache_size:
+                oldest_key = next(iter(self.cache))
+                del self.cache[oldest_key]
+
+            self.cache[key] = value
+            return value""",
+	"""def breadth_first_search(root):
+        if not root:
+            return []
+
+        result = []
+        queue = [root]
+
+        while queue:
+            node = queue.pop(0)
+            result.append(node.value)
+
+            if node.left:
+                queue.append(node.left)
+            if node.right:
+                queue.append(node.right)
+
+        return result""",
+]
+
+
+def cosine_similarity(v1, v2):
+	"""Compute cosine similarity between two vectors."""
+	dot_product = np.dot(v1, v2)
+	norm_v1 = np.linalg.norm(v1)
+	norm_v2 = np.linalg.norm(v2)
+	return dot_product / (norm_v1 * norm_v2)
+
+
+def calculate_semantic_similarity(emb1, emb2, samples):
+	"""Calculate semantic similarity between embeddings of different dimensions.
+
+	Instead of direct vector comparison, measure how similarly they rank the same samples.
+	"""
+	# Calculate similarity matrices within each embedding space
+	sim1 = np.zeros((len(samples), len(samples)))
+	sim2 = np.zeros((len(samples), len(samples)))
+
+	# Calculate pairwise similarities within each embedding space
+	for i in range(len(samples)):
+		for j in range(len(samples)):
+			e1_i, e1_j = emb1[i], emb1[j]
+			e2_i, e2_j = emb2[i], emb2[j]
+
+			sim1[i, j] = np.dot(e1_i, e1_j) / (np.linalg.norm(e1_i) * np.linalg.norm(e1_j))
+			sim2[i, j] = np.dot(e2_i, e2_j) / (np.linalg.norm(e2_i) * np.linalg.norm(e2_j))
+
+	# Calculate correlation between similarity matrices
+	similarities = []
+	for i in range(len(samples)):
+		# Get rankings for this sample (exclude self-comparison)
+		rankings1 = np.delete(sim1[i], i)
+		rankings2 = np.delete(sim2[i], i)
+
+		# Calculate correlation
+		corr = np.corrcoef(rankings1, rankings2)[0, 1]
+		similarities.append(corr)
+
+	return similarities
+
+
+def run_speed_benchmark(original_model, distilled_model, samples):
+	"""Run speed benchmark comparing original and distilled models."""
+	logger.info("\n" + "=" * 50)
+	logger.info("SPEED BENCHMARK")
+	logger.info("=" * 50)
+
+	# Warmup
+	_ = original_model.encode(samples[:1])
+	_ = distilled_model.encode(samples[:1])
+
+	# Test original model
+	logger.info("Testing original model...")
+	start_time = time.time()
+	original_embeddings = original_model.encode(samples)
+	original_time = time.time() - start_time
+	logger.info(f"Original model took: {original_time:.4f} seconds for {len(samples)} samples")
+	logger.info(f"Speed: {len(samples) / original_time:.2f} samples/second")
+
+	# Test distilled model
+	logger.info("\nTesting distilled model...")
+	start_time = time.time()
+	distilled_embeddings = distilled_model.encode(samples)
+	distilled_time = time.time() - start_time
+	logger.info(f"Distilled model took: {distilled_time:.4f} seconds for {len(samples)} samples")
+	logger.info(f"Speed: {len(samples) / distilled_time:.2f} samples/second")
+
+	# Compare
+	speedup = original_time / distilled_time
+	logger.info(f"\nSpeedup factor: {speedup:.2f}x")
+
+	# Check embedding dimensions
+	logger.info(f"\nOriginal embedding dimensions: {original_embeddings.shape}")
+	logger.info(f"Distilled embedding dimensions: {distilled_embeddings.shape}")
+
+	return original_embeddings, distilled_embeddings
+
+
+def demonstrate_similarity(original_embeddings, distilled_embeddings, samples):
+	"""Demonstrate similarity between original and distilled embeddings."""
+	logger.info("\n" + "=" * 50)
+	logger.info("EMBEDDING SIMILARITY")
+	logger.info("=" * 50)
+
+	# Compare embeddings semantic similarity
+	similarities = calculate_semantic_similarity(original_embeddings, distilled_embeddings, samples)
+
+	for i, sim in enumerate(similarities):
+		logger.info(f"Sample {i + 1}: Semantic Similarity = {sim:.4f}")
+
+	avg_similarity = np.mean(similarities)
+	logger.info(f"\nAverage semantic similarity: {avg_similarity:.4f}")
+	logger.info("Note: Similarity is measured by how similarly both models rank the relationships between samples")
+
+	return avg_similarity
+
+
+def demonstrate_code_search(distilled_model, query, code_database) -> None:
+	"""Demonstrate code search functionality with the distilled model."""
+	logger.info("\n" + "=" * 50)
+	logger.info("CODE SEARCH DEMO")
+	logger.info("=" * 50)
+
+	logger.info(f"Query: '{query}'")
+
+	# Get query embedding
+	query_embedding = distilled_model.encode(query)
+
+	# Get database embeddings
+	database_embeddings = distilled_model.encode(code_database)
+
+	# Calculate similarities
+	similarities = []
+	for i, code_embedding in enumerate(database_embeddings):
+		sim = cosine_similarity(query_embedding, code_embedding)
+		similarities.append((i, sim))
+
+	# Sort by similarity
+	similarities.sort(key=lambda x: x[1], reverse=True)
+
+	# Display results
+	logger.info("\nTop 3 results:")
+	for i, (idx, sim) in enumerate(similarities[:3]):
+		code_snippet = code_database[idx]
+		if len(code_snippet) > 100:
+			code_snippet = code_snippet[:100] + "..."
+		logger.info(f"{i + 1}. Similarity: {sim:.4f}")
+		logger.info(f"   {code_snippet}")
+		logger.info("")
+
+
+def main() -> None:
+	"""Run the example and benchmarks."""
+	parser = argparse.ArgumentParser(description="Example usage of distilled Qodo-Embed model")
+	parser.add_argument("--original_model", default="Qodo/Qodo-Embed-1-1.5B", help="Original model name or path")
+	parser.add_argument("--distilled_model", default="models/qodo_embed_m2v", help="Path to the distilled model")
+
+	args = parser.parse_args()
+
+	logger.info(f"Using original model: {args.original_model}")
+	logger.info(f"Using distilled model: {args.distilled_model}")
+
+	# Load models
+	logger.info("\nLoading original model...")
+	original_model = SentenceTransformer(args.original_model)
+
+	logger.info("Loading distilled model (Qodo-Embed-M-1-1.5B-M2V-Distilled)...")
+	distilled_model = StaticModel.from_pretrained(args.distilled_model)
+
+	# Run benchmarks
+	original_embeddings, distilled_embeddings = run_speed_benchmark(original_model, distilled_model, CODE_SAMPLES)
+
+	# Compare embedding similarity
+	demonstrate_similarity(original_embeddings, distilled_embeddings, CODE_SAMPLES)
+
+	# Demonstrate code search
+	for query in ["binary search implementation", "memory efficient streaming", "tree traversal algorithm"]:
+		demonstrate_code_search(distilled_model, query, CODE_DATABASE)
+
+	logger.info("\n" + "=" * 50)
+	logger.info("Model Summary: Qodo-Embed-M-1-1.5B-M2V-Distilled")
+	logger.info("=" * 50)
+	logger.info("• 25.26x smaller than the original model (233MB vs 5.9GB)")
+	logger.info("• 112.14x faster inference speed")
+	logger.info("• Preserves 85.1% of the original model's explained variance")
+	logger.info("• Same semantic search capabilities in a vastly more efficient package")
+	logger.info("=" * 50)
+
+
+if __name__ == "__main__":
+	main()

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ceabf8fc5d30c1899511f7bc3b70895f575354327cebf74b6f21726bb97c63eb
+size 232928344

modules.json

@@ -0,0 +1,14 @@
+[
+    {
+        "idx": 0,
+        "name": "0",
+        "path": ".",
+        "type": "sentence_transformers.models.StaticEmbedding"
+    },
+    {
+        "idx": 1,
+        "name": "1",
+        "path": "1_Normalize",
+        "type": "sentence_transformers.models.Normalize"
+    }
+]

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8372feaa064372d176aff57e8f1e64f194814bb074519104f64c66a2825f091
+size 11419037