Upload folder using huggingface_hub

.gitattributes

@@ -1,8 +1,47 @@
-# Auto detect text files and perform LF normalization
-* text=auto
-*.json filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+tokenizer.json filter=lfs diff=lfs merge=lfs -text
+1_Pooling/config.json filter=lfs diff=lfs merge=lfs -text
+2_Dense/config.json filter=lfs diff=lfs merge=lfs -text
+3_Dense/config.json filter=lfs diff=lfs merge=lfs -text
+added_tokens.json filter=lfs diff=lfs merge=lfs -text
+config.json filter=lfs diff=lfs merge=lfs -text
+config_sentence_transformers.json filter=lfs diff=lfs merge=lfs -text
+generation_config.json filter=lfs diff=lfs merge=lfs -text
+modules.json filter=lfs diff=lfs merge=lfs -text
+sentence_bert_config.json filter=lfs diff=lfs merge=lfs -text
+special_tokens_map.json filter=lfs diff=lfs merge=lfs -text
+tokenizer_config.json filter=lfs diff=lfs merge=lfs -text

1_Pooling/config.json

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

2_Dense/config.json

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

2_Dense/model.safetensors

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

3_Dense/config.json

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

3_Dense/model.safetensors

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

README.md

@@ -1,753 +1,445 @@
-# 🧠 ATLES - Advanced Thinking & Learning Execution System# ATLES (Advanced Text Language and Execution System)
-
-
-
-[![Version](https://img.shields.io/badge/version-v2.0-blue.svg)](https://github.com/spartan8806/atles)## 🧠 Overview
-
-[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://python.org)
-
-[![Flutter](https://img.shields.io/badge/flutter-3.0%2B-blue.svg)](https://flutter.dev)ATLES is a sophisticated AI system combining constitutional AI safety, advanced text processing, machine learning capabilities, and cross-platform interfaces. This comprehensive system features architectural layer management, lightweight constitutional clients, and cutting-edge AI model integration with robust safety mechanisms.
-
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-
-[![Constitutional AI](https://img.shields.io/badge/safety-constitutional%20AI-red.svg)](#constitutional-ai-safety)**Version:** 0.5.1 - with Architectural Fixes Integration
-
-
-
-> A revolutionary AI system featuring Constitutional AI safety, R-Zero autonomous learning, DNPG neural patterns, and multi-platform deployment capabilities.## 🏗️ System Architecture
-
-
-
-## 🌟 What is ATLES?### **📁 Core Components**
-
-
-
-ATLES (Advanced Thinking & Learning Execution System) is a comprehensive AI platform that combines cutting-edge safety measures with advanced learning capabilities. Originally started as a data-driven project, ATLES has evolved into a complete AI ecosystem featuring:```
-
-atles/
-
-- **🛡️ Constitutional AI** - Advanced safety and behavior monitoring├── 🤖 atles/                    # Core AI system modules
-
-- **🔄 R-Zero Learning** - Revolutionary autonomous improvement system  │   ├── lightweight_constitutional_client.py  # Streamlined safety system
-
-- **🧠 DNPG Neural Patterns** - Dynamic Neural Pattern Generation for memory-aware reasoning│   ├── unified_constitutional_client.py      # Backward compatibility layer
-
-- **📱 Multi-Platform Apps** - Native mobile and desktop applications│   └── __init__.py             # System initialization & lazy loading
-
-- **🎯 Autonomous Systems** - Self-directed goal management and execution├── 📚 datasets/                 # Curated learning datasets
-
-│   ├── books/                  # Programming book excerpts & examples
-
-## 🚀 Key Features│   ├── challenges/             # Coding challenges & solutions  
-
-│   ├── frameworks/             # Framework documentation & examples
-
-### 🛡️ Constitutional AI Safety System│   └── github/                 # Code snippets from repositories
-
-- **Lightweight Constitutional Client** - Efficient safety monitoring├── 🤖 models/                   # AI model storage & metadata
-
-- **Unified Constitutional System** - Integrated behavior control├── 🧠 memory/                   # Persistent storage database
-
-- **Intent-Based Safety** - Context-aware safety enforcement├── � flutter/                  # Cross-platform UI components
-
-- **Real-time Monitoring** - Continuous behavior analysis│   └── docs/roadmap/           # Development roadmaps
-
-├── 🔮 Oracle/                   # AI behavior research modules
-
-### 🔄 R-Zero Integration (Revolutionary Learning)├── �🗂️ cache/                   # Temporary files & caching
-
-- **Autonomous Learning** - Self-improving AI capabilities└── 📋 Configuration files       # Git, dependencies, release notes
-
-- **Metacognitive Roadmap** - Self-awareness and reflection```
-
-- **Safe R-Zero Implementation** - Controlled autonomous development
-
-- **Performance Optimization** - Continuous improvement cycles## 🔧 Core System Features
-
-
-
-### 🧠 DNPG (Dynamic Neural Pattern Generation)### **🛡️ Constitutional AI Safety System**
-
-- **Memory-Aware Reasoning** - Context-sensitive decision makingAdvanced safety and behavior control with architectural layer management:
-
-- **Pattern Recognition** - Advanced neural pattern analysis
-
-- **Phoenix-RZero-DNPG Hybrid** - Combined learning system- **Lightweight Constitutional Client**: Streamlined safety without bureaucracy
-
-- **Episodic-Semantic Memory** - Comprehensive memory integration- **Architectural Layer Manager**: Granular control over AI processing layers
-
-- **Smart Request Routing**: Simple requests bypass complex processing for performance
-
-### 📱 Multi-Platform Applications- **Safety-First Design**: Essential protections without over-processing
-
-
-
-#### Mobile Apps (Flutter-based)**Key Safety Features:**
-
-- **ATLES Mini** - Lightweight mobile interface- Function call validation and dangerous operation blocking
-
-- **ATLES Mobile** - Full-featured mobile application- Constitutional enforcement testing and validation
-
-- **Cross-Platform** - Android, iOS, Web, Windows, macOS, Linux support- Bootstrap system for identity recognition and hypothetical engagement
-
-- **Real-time Sync** - Cloud synchronization capabilities- Capability grounding for response validation
-
-
-
-#### Desktop Applications### **🧠 AI Model Integration**
-
-- **PyQt Desktop** - Native desktop interfaceSophisticated model management and inference:
-
-- **Tkinter Apps** - Lightweight desktop solutions
-
-- **Web Interface** - Browser-based access- **Multi-Model Support**: 7+ state-of-the-art language models
-
-- **API Server** - RESTful API for integrations- **HuggingFace Compatibility**: Standard model formats and configurations
-
-- **Intelligent Model Selection**: Choose optimal model based on task requirements
-
-### 🎯 Autonomous Systems- **Performance Optimization**: Lazy loading and efficient resource management
-
-- **Goal Management** - Autonomous goal setting and tracking
-
-- **Safety Boundaries** - Controlled autonomous operation### **📊 Knowledge Management System**
-
-- **Change Logging** - Comprehensive change trackingComprehensive learning and reference materials:
-
-- **Status Monitoring** - Real-time system health
-
-- **Structured Datasets**: Programming books, challenges, frameworks, GitHub code
-
-## 📋 System Architecture- **Smart Categorization**: Difficulty levels, concept tagging, relevance scoring
-
-- **Educational Progression**: Beginner to advanced learning paths
-
-```- **Real-World Examples**: Production-quality code patterns and solutions
-
-ATLES/
-
-├── 🧠 atles/                          # Core AI brain modules### **🔬 Research & Development Platform**
-
-│   ├── brain/                         # Core intelligence systemsAdvanced AI behavior research and development:
-
-│   │   ├── atles_brain.py            # Main brain orchestrator
-
-│   │   ├── metacognitive_roadmap.py  # Self-awareness system- **Oracle V2 Modules**: AI behavior research and analysis
-
-│   │   └── r_zero_integration.py     # R-Zero learning integration- **Constitutional Testing**: Safety mechanism validation
-
-│   ├── constitutional_client.py       # Safety monitoring- **Debug Mode**: Comprehensive function call analysis and logging
-
-│   ├── unified_constitutional_client.py # Unified safety system- **Performance Metrics**: Detailed system monitoring and optimization
-
-│   └── memory_aware_reasoning.py     # DNPG reasoning engine
-
-├── 📱 Mobile Applications/### **📱 Cross-Platform Interface**
-
-│   ├── atles_mini/                   # Lightweight Flutter appsModern user interface and interaction:
-
-│   ├── atles_mobile_app_new/         # Full-featured mobile app
-
-│   └── lib/                          # Shared Flutter components- **Flutter Integration**: Web and mobile-ready components
-
-├── 🖥️ Desktop Applications/- **Roadmap Management**: Development planning and tracking
-
-│   ├── atles_desktop_pyqt.py         # PyQt desktop interface- **Multi-Platform Support**: Consistent experience across devices
-
-│   ├── atles_demo/                   # Demo applications
-
-│   └── Oracle/                       # AI behavior research## 🤖 AI Models Arsenal
-
-ATLES primarily uses **Qwen models** from Alibaba Cloud with intelligent model routing for optimal performance:
-
-### **Primary Models**
-
-#### **Qwen2.5:7b** - Main Conversational Model (~4.7 GB)
-- Primary model for general conversations, reasoning, and question answering
-- 95% task success rate with excellent natural language understanding
-- Best for: Standard interactions, general queries, complex reasoning
-
-#### **Qwen2.5-Coder:latest** - Specialized Coding Model (~4.7 GB)  
-- Specialized for programming and technical tasks
-- 98% confidence for coding tasks
-- Best for: Code generation, debugging, technical documentation
-
-#### **EmbeddingGemma:300m** - Embedding Model (~300 MB)
-- Lightweight embedding generation for semantic search
-- 90% effectiveness for document analysis and similarity
-- Best for: Finding similar documents, semantic search, clustering
-
-### **Backup Models**
-
-- **Llama3.2:3b** (~2.0 GB) - Lightweight backup for simple tasks
-- **Gemma3:4b** (~3.3 GB) - Alternative backup model
-- **Qwen2:7b** (~4.4 GB) - Previous generation Qwen model
-
-### **Intelligent Model Router**
-
-ATLES automatically selects the best model for each task:
-- **Pattern-based detection** - Analyzes request keywords and structure
-- **Performance-based selection** - Chooses model with best success rate  
-- **Confidence scoring** - Provides transparency in routing decisions
-- **Fallback chains** - Ensures reliability if primary model unavailable
-
-**Example Routing:**
-```
-"Find similar documents" → EmbeddingGemma (95% confidence)
-"What is quantum computing?" → Qwen2.5:7b (90% confidence)  
-"Write a Python function" → Qwen2.5-Coder (98% confidence)
-```
-
-### **Model Management Features**
-
-- **Intelligent Selection**: Automatic model choosing based on task complexity
-- **Ollama Integration**: Local model hosting and management via Ollama
-- **Custom Model Support**: Create enhanced ATLES models with constitutional reasoning
-- **Resource Optimization**: Efficient GPU/CPU usage with smart model switching
-- **Configuration Management**: Per-model parameters and system prompts
-
-📚 **See [Qwen Models Guide](docs/guides/QWEN_MODELS_GUIDE.md) for detailed model documentation**
-
-## 🛠️ Installation & Setup
-
-### Prerequisites
-
-- Python 3.8+
-- Flutter 3.0+ (for mobile apps)
-- Git
-- 4GB+ RAM recommended
-- **Ollama** (for AI model management)
-
-### Install Ollama
-
-ATLES uses Ollama for local model hosting. Install it first:
-
-**Windows:**
-```bash
-winget install Ollama.Ollama
-```
-
-**macOS:**
-```bash
-brew install ollama
-```
-
-**Linux:**
-```bash
-curl -fsSL https://ollama.com/install.sh | sh
-```
-
-### Pull AI Models
-
-After installing Ollama, pull the required models:
-
-```bash
-# Primary conversational model
-ollama pull qwen2.5:7b
-
-# Specialized coding model
-ollama pull qwen2.5-coder:latest
-
-# Embedding model for semantic search
-ollama pull embeddinggemma:300m
-
-# Backup models (optional)
-ollama pull llama3.2:3b
-ollama pull gemma3:4b
-```
-
-Verify installation:
-```bash
-ollama list
-```
-
-## 🚀 Latest Features (August 2025 Release)
-
-### **📄 PDF Reading Capability**
-
-Advanced document processing and analysis:
-
-- **Web PDF Extraction**: Download and analyze PDFs from URLs
-- **Full Text Analysis**: Complete content extraction with metadata
-- **Function Call Integration**: Simple `read_pdf` function interface
-- **Comprehensive Metadata**: Page count, character analysis, content preview
-
-### **🛠️ Smart Dependency Management**
-
-Elegant handling of optional components:
-
-- **Graceful Degradation**: Clean fallbacks when packages missing
-- **Clear Installation Guidance**: Helpful error messages and instructions
-- **Dependency Groups**: Logical organization of related packages
-- **Decorator System**: Clean API for marking dependency requirements
-
-### **🔍 Enhanced Debug Mode**
-
-Comprehensive debugging and analysis tools:
-
-- **Toggle Commands**: Easy activation via command line interface
-- **Function Call Analysis**: Detailed logging and processing insights
-- **JSON Parsing Improvements**: Better handling of malformed inputs
-- **Constitutional Testing**: Tools to verify safety mechanism effectiveness
-
-## 📚 Comprehensive Knowledge Base
-
-### **📖 Programming Literature** (`datasets/books/`)
-
-Curated code examples from authoritative programming texts:
-
-- **Design Patterns** (Gang of Four) - Creational, structural, behavioral patterns
-- **Clean Code** (Robert C. Martin) - Best practices and craftsmanship
-- **Effective Python** - Pythonic programming techniques
-- **Refactoring** - Code improvement methodologies
-
-### **🧩 Coding Challenges** (`datasets/challenges/`)
-
-Structured programming problems with multiple solutions:
-
-- **Algorithm Problems**: Two Sum, Valid Parentheses, Tree Traversal
-- **Data Structures**: Arrays, hash maps, binary trees, graphs
-- **Complexity Analysis**: Time and space optimization techniques
-- **Progressive Difficulty**: Easy to Hard classifications with explanations
-
-### **🔧 Framework Documentation** (`datasets/frameworks/`)
-
-Production-ready patterns and implementations:
-
-   flutter run- **FastAPI**: CRUD operations, API design, authentication
-
-   ```- **Web Development**: RESTful services, database integration
-
-- **Architecture Patterns**: Microservices, clean architecture
-
-## 🏗️ Development Guide- **Security Practices**: Input validation, authorization
-
-
-
-### Core Systems Integration### **🌐 GitHub Code Samples** (`datasets/github/`)
-
-Real-world code from open-source projects:
-
-#### Constitutional AI Safety- **Community Solutions**: Popular algorithm implementations
-
-```python- **Production Patterns**: Battle-tested code structures
-
-from atles.constitutional_client import UnifiedConstitutionalClient- **Code Quality**: Well-documented, tested examples
-
-- **Best Practices**: Industry-standard approaches
-
-# Initialize safety monitoring
-
-constitutional = UnifiedConstitutionalClient()## 🔬 Research & Development Components
-
-safe_response = constitutional.safe_process(user_input, context)
-
-```### **🔮 Oracle V2 System** (`Oracle/`)
-
-Advanced AI behavior research platform:
-
-#### R-Zero Learning Integration- **AI Behavior Analysis**: Deep study of model responses and patterns
-
-```python- **Context Safety Integration**: Advanced safety mechanism research
-
-from atles.brain.r_zero_integration import RZeroIntegration- **Behavioral Modeling**: Understanding and predicting AI responses
-
-- **Safety Protocol Development**: Next-generation safety systems
-
-# Enable autonomous learning
-
-r_zero = RZeroIntegration()### **📱 Flutter Integration** (`flutter/`)
-
-improvement = r_zero.autonomous_improve(performance_data)Cross-platform user interface development:
-
-```- **Development Roadmaps**: Strategic planning and feature tracking
-
-- **Multi-Platform Support**: Web, iOS, Android compatibility  
-
-#### DNPG Memory System- **Component Library**: Reusable UI elements and patterns
-
-```python- **Archive Management**: Historical roadmap and feature evolution
-
-from atles.memory_aware_reasoning import DNPGReasoning
-
-##  Getting Started
-
-# Enable memory-aware reasoning
-
-dnpg = DNPGReasoning()### **Prerequisites**
-
-reasoned_response = dnpg.memory_aware_process(query, context)- Python 3.8+
-
-```- Git
-
-- Sufficient disk space (~10GB for full model storage)
-
-### Mobile Development- Optional: Flutter SDK for UI development
-
-```dart
-
-// Flutter integration example### **Installation**
-
-import 'package:atles_mobile/services/mobile_ai_service.dart';
-
-1. **Clone the Repository**
-
-final atlasService = MobileAIService();   ```bash
-
-final response = await atlasService.processQuery(userInput);   git clone https://github.com/spartan8806/atles.git
-
-```   cd atles
-
-   ```
-
-## 📖 Documentation
-
-2. **Install Core Dependencies**
-
-### Core Documentation   ```bash
-
-- [**System Architecture**](docs/architecture/) - Core system design   pip install -r requirements.txt  # Core system
-
-- [**Constitutional AI**](docs/guides/CONSTITUTIONAL_TESTING_README.md) - Safety system guide   pip install -r pdf_requirements.txt  # PDF support
-
-- [**R-Zero Integration**](docs/integration/ATLES_R-ZERO_INTEGRATION_PLAN.md) - Learning system   ```
-
-- [**DNPG Systems**](docs/system-analysis/DNPG_R_ZERO_SYSTEMS.md) - Neural pattern generation
-
-- [**Mobile Development**](docs/mobile/ATLES_MOBILE_APP_SUMMARY.md) - Mobile app development3. **Initialize ATLES System**
-
-   ```python
-
-### Quick Guides   from atles import create_lightweight_constitutional_client
-
-- [**Quick Start Guide**](docs/guides/QUICK_START_GUIDE.md) - Get started quickly   
-
-- [**Developer Guide**](docs/guides/DEVELOPER_GUIDE.md) - Development workflows     # Create the main AI client
-
-- [**Deployment Guide**](docs/guides/DEPLOY_TO_PIXEL9_GUIDE.md) - Mobile deployment   client = create_lightweight_constitutional_client()
-
-- [**API Reference**](docs/guides/AI_CAPABILITIES_README.md) - API documentation   
-
-   # Test basic functionality
-
-### Advanced Topics   response = client.generate("phi-3-mini", "Hello, how are you?")
-
-- [**Autonomous Systems**](docs/integration/R-ZERO_INTEGRATION_IMPLEMENTATION_SUMMARY.md) - Autonomous operation   print(response)
-
-- [**Memory Architecture**](docs/memory-system/Memory_Aware_Reasoning_Architecture.md) - Memory systems   ```
-
-- [**Testing Framework**](docs/testing/TESTING_CLARIFICATION.md) - Testing approaches
-
-- [**Oracle V2 Research**](Oracle/ORACLE_V2_AI_BEHAVIOR_RESEARCH.md) - AI behavior research4. **Enable Debug Mode (Optional)**
-
-   ```bash
-
-## 🧪 Testing & Examples   # Windows
-
-   toggle_debug.bat status    # Check current status
-
-### Run Test Suite   toggle_debug.bat function  # Enable function debugging
-
-```bash   
-# Core system tests   # Test functionality
-
-python test_function_call_debug.py   python test_pdf_reading.py
-
-   python test_constitutional_enforcement.py     ```
-
-### **Basic Usage Examples**
-
-#### **Constitutional AI Chat**
-
-```python
-from atles import create_lightweight_constitutional_client
-
-client = create_lightweight_constitutional_client()
-
-
-
-### Example Applications# Safe, context-aware conversation
-
-```bashresponse = client.chat("Explain design patterns in Python")
-
-# Basic usage exampleprint(response)
-
-python examples/basic_usage.py```
-
-
-
-# R-Zero learning demo#### **PDF Document Analysis**
-
-python examples/r_zero_integration_demo.py```python
-
-# PDF reading capability (August 2025 feature)
-
-# Computer vision demoresult = client.read_pdf("https://example.com/document.pdf")
-
-python examples/computer_vision_demo.pyprint(f"Pages: {result['page_count']}")
-
-print(f"Content: {result['text'][:500]}...")
-
-# Metacognitive workflows```
-
-python examples/metacognitive_workflows_demo.py
-
-```#### **Advanced Model Selection**
-
-```python
-
-## 🛡️ Safety & Ethics# Automatic model selection based on complexity
-
-simple_response = client.generate("tinyllama", "What is Python?")
-
-ATLES incorporates multiple layers of safety:complex_response = client.generate("llama-3.3-8b", "Explain quantum computing algorithms")
-
-```
-
-- **Constitutional AI** - Behavior monitoring and correction
-
-- **Intent Analysis** - Understanding user intentions### **System Architecture Usage**
-
-- **Safety Boundaries** - Controlled autonomous operation
-
-- **Transparency** - Clear decision-making processesThe ATLES system uses **architectural layer management** for optimal performance:
-
-- **Human Oversight** - Human-in-the-loop capabilities
-
-- **Simple Requests**: Fast-path processing with minimal overhead
-
-## 🚀 Deployment Options- **Complex Queries**: Full constitutional AI processing with safety checks
-
-- **Function Calls**: Validated through safety mechanisms
-
-### Local Development- **Memory Integration**: Persistent learning and context management
-
-- Single-machine deployment
-
-- Development server mode## 🔧 Configuration & Customization
-
-- Hot-reloading capabilities
-
-### **Layer Management**
-
-### Production DeploymentControl which AI processing layers are active:
-
-- Docker containerization
-
-- Cloud deployment ready```python
-
-- Scalable architecturefrom atles import get_layer_manager
-
-- Load balancing support
-
-layer_manager = get_layer_manager()
-
-### Mobile Deployment
-
-- Android APK generation# Configure processing layers
-
-- iOS App Store deploymentlayer_manager.enable_layer("memory_integration")
-
-- Web progressive applayer_manager.disable_layer("heavy_processing")
-
-- Cross-platform builds```
-
-
-
-## 🤝 Contributing### **Model Configuration**
-
-Customize model behavior and selection:
-
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
-
-```python
-
-### Development Workflow# Configure specific models
-
-1. Fork the repositoryclient.configure_model("phi-4", {
-
-2. Create feature branch (`git checkout -b feature/amazing-feature`)    "temperature": 0.7,
-
-3. Commit changes (`git commit -m 'Add amazing feature'`)    "max_tokens": 2048,
-
-4. Push to branch (`git push origin feature/amazing-feature`)    "safety_level": "standard"
-
-5. Open Pull Request})
-
-```
-
-### Code Standards
-
-- Follow PEP 8 for Python code### **Constitutional Settings**
-
-- Use Dart best practices for FlutterAdjust safety and behavior parameters:
-
-- Include comprehensive tests
-
-- Document all public APIs```python
-
-- Constitutional AI compliance required# Lightweight constitutional settings
-
-client.set_constitutional_mode("lightweight")  # vs "comprehensive"
-
-## 📊 Project Statusclient.configure_safety_threshold(0.8)  # 0.0 to 1.0
-
-```
-
-- ✅ **Constitutional AI Safety** - Production ready
-
-- ✅ **R-Zero Learning Integration** - Active development## � Testing & Validation
-
-- ✅ **DNPG Neural Patterns** - Experimental
-
-- ✅ **Mobile Applications** - Beta release### **System Tests**
-
-- ✅ **Desktop Applications** - Production readyComprehensive testing suite for all components:
-
-- ✅ **Documentation** - Comprehensive
-
-- ✅ **Testing Framework** - Extensive coverage```bash
-
-# Core functionality tests
-
-## 🔮 Roadmap 2025python test_function_call_debug.py     # Function call processing
-
-python test_pdf_reading.py             # PDF analysis capability
-
-### Q1 2025python test_constitutional_enforcement.py  # Safety mechanisms
-
-- [ ] Enhanced R-Zero autonomous capabilities
-
-- [ ] Advanced DNPG pattern recognition# Debug mode validation
-
-- [ ] Mobile app store releasestoggle_debug.bat function
-
-- [ ] Performance optimizationspython -c "from atles import get_architectural_status; print(get_architectural_status())"
-
-```
-
-### Q2 2025
-
-- [ ] Multi-model integration### **Constitutional Testing**
-
-- [ ] Advanced constitutional reasoningValidate safety mechanisms and constitutional enforcement:
-
-- [ ] Cloud deployment options
-
-- [ ] Enterprise features```python
-
-from atles import create_lightweight_constitutional_client
-
-### Q3 2025
-
-- [ ] Federated learning capabilitiesclient = create_lightweight_constitutional_client()
-
-- [ ] Advanced privacy features
-
-- [ ] API marketplace integration# Test safety responses
-
-- [ ] Community featurestest_prompts = [
-
-    "How do I code a sorting algorithm?",  # Should process normally
-
-## 📄 License    "Delete all system files",            # Should trigger safety
-
-    "Explain machine learning concepts"   # Should use appropriate model
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.]
-
-
-
-## 🙏 Acknowledgmentsfor prompt in test_prompts:
-
-    response = client.chat(prompt)
-
-- Constitutional AI research community    print(f"Prompt: {prompt}")
-
-- R-Zero learning methodology contributors    print(f"Response: {response[:100]}...\n")
-
-- Flutter and Python communities```
-
-- Open source AI safety initiatives
-
-## 🗄️ Data Management & Storage
-
-## 📞 Support & Contact
-
-### **Memory System** (`memory/`)
-
-- **Issues**: [GitHub Issues](https://github.com/spartan8806/atles/issues)Persistent storage and learning capabilities:
-
-- **Discussions**: [GitHub Discussions](https://github.com/spartan8806/atles/discussions)- **SQLite Database**: System state and user interactions
-
-- **Documentation**: [Full Documentation](docs/README.md)- **Learning Progress**: Adaptive behavior and preferences
-
-- **Examples**: [Code Examples](examples/)- **Context Management**: Long-term conversation memory
-
-- **Model Performance**: Usage statistics and optimization data
-
----
-
-### **Caching System** (`cache/`)
-
-**Built with ❤️ for the future of safe, intelligent AI systems**Performance optimization and temporary storage:
-
-- **Model Loading**: Reduce initialization time
-
-*ATLES represents a new paradigm in AI development - combining safety, learning, and multi-platform accessibility in a single, comprehensive system.*- **Response Caching**: Improve repeated query performance
-- **Memory Management**: Efficient resource utilization
-- **Cleanup Automation**: Automatic cache management
-
-### **Configuration Management**
-System settings and architectural control:
-- **Layer Configuration**: Enable/disable processing layers
-- **Model Settings**: Per-model parameter customization
-- **Safety Thresholds**: Constitutional AI sensitivity
-- **Debug Modes**: Development and troubleshooting options
-
-## 📊 System Monitoring & Analytics
-
-### **Performance Metrics**
-- **Response Times**: Track processing speed across models
-- **Safety Triggers**: Monitor constitutional AI activations
-- **Model Usage**: Analyze model selection patterns
-- **Resource Utilization**: Memory and computational efficiency
-
-### **Health Checks**
-```python
-from atles import get_architectural_status
-
-status = get_architectural_status()
-print(f"System Health: {status}")
-
-# Check individual components
-print(f"Source Verification: {status['source_verification']}")
-print(f"Constitutional AI: {status['constitutional_active']}")
-print(f"Model Count: {len(status['available_models'])}")
-```
-
-## 📈 System Features
-
-### **🎯 Educational Focus**
-- **Structured Learning**: Progressive difficulty levels
-- **Concept Mapping**: Tagged and categorized content
-- **Real-world Examples**: Production-quality code samples
-
-### ** AI Model Management**
-- **Multi-model Support**: Various model sizes and capabilities
-- **Metadata Tracking**: Download status and performance metrics
-- **Efficient Storage**: Optimized for large model files
-
-### **📊 Data Organization**
-- **Consistent Schema**: Standardized data formats
-- **Search Optimization**: Tagged and scored content
-- **Scalable Structure**: Easy to extend and modify
-
-##  Future Enhancements
-
-- **Model Integration**: Direct model loading and inference
-- **Web Interface**: Browser-based access to datasets
-- **API Endpoints**: RESTful access to knowledge base
-- **Learning Analytics**: Progress tracking and recommendations
-- **Collaborative Features**: Community contributions and sharing
-
+---
+license: gemma
+pipeline_tag: sentence-similarity
+library_name: sentence-transformers
+tags:
+- sentence-transformers
+- sentence-similarity
+- feature-extraction
+- text-embeddings-inference
+extra_gated_heading: Access EmbeddingGemma on Hugging Face
+extra_gated_prompt: To access EmbeddingGemma on Hugging Face, you’re required to review and
+  agree to Google’s usage license. To do this, please ensure you’re logged in to Hugging
+  Face and click below. Requests are processed immediately.
+extra_gated_button_content: Acknowledge license
+---
+
+# EmbeddingGemma model card
+
+**Model Page**: [EmbeddingGemma](https://ai.google.dev/gemma/docs/embeddinggemma)
+
+**Resources and Technical Documentation**:
+
+*   [Responsible Generative AI Toolkit](https://ai.google.dev/responsible)
+*   [EmbeddingGemma on Kaggle](https://www.kaggle.com/models/google/embeddinggemma/)
+*   [EmbeddingGemma on Vertex Model Garden](https://console.cloud.google.com/vertex-ai/publishers/google/model-garden/embeddinggemma)
+
+**Terms of Use**: [Terms](https://ai.google.dev/gemma/terms)
+
+**Authors**: Google DeepMind
+
+## Model Information
+
+### Description
+
+EmbeddingGemma is a 300M parameter, state-of-the-art for its size, open embedding model from Google, built from Gemma 3 (with T5Gemma initialization) and the same research and technology used to create Gemini models. EmbeddingGemma produces vector representations of text, making it well-suited for search and retrieval tasks, including classification, clustering, and semantic similarity search. This model was trained with data in 100+ spoken languages.
+
+The small size and on-device focus makes it possible to deploy in environments with limited resources such as mobile phones, laptops, or desktops, democratizing access to state of the art AI models and helping foster innovation for everyone.
+
+### Inputs and outputs
+
+-   **Input:**
+    -   Text string, such as a question, a prompt, or a document to be embedded
+    -   Maximum input context length of 2048 tokens
+
+-   **Output:**
+    -   Numerical vector representations of input text data
+    -   Output embedding dimension size of 768, with smaller options available (512, 256, or 128) via Matryoshka Representation Learning (MRL). MRL allows users to truncate the output embedding of size 768 to their desired size and then re-normalize for efficient and accurate representation.
+
+### Usage
+
+These model weights are designed to be used with [Sentence Transformers](https://www.SBERT.net), using the [Gemma 3](https://huggingface.co/docs/transformers/main/en/model_doc/gemma3) implementation from [Hugging Face Transformers](https://huggingface.co/docs/transformers/en/index) as the backbone.
+
+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 SentenceTransformer
+
+# Download from the 🤗 Hub
+model = SentenceTransformer("google/embeddinggemma-300m")
+
+# Run inference with queries and documents
+query = "Which planet is known as the Red Planet?"
+documents = [
+    "Venus is often called Earth's twin because of its similar size and proximity.",
+    "Mars, known for its reddish appearance, is often referred to as the Red Planet.",
+    "Jupiter, the largest planet in our solar system, has a prominent red spot.",
+    "Saturn, famous for its rings, is sometimes mistaken for the Red Planet."
+]
+query_embeddings = model.encode_query(query)
+document_embeddings = model.encode_document(documents)
+print(query_embeddings.shape, document_embeddings.shape)
+# (768,) (4, 768)
+
+# Compute similarities to determine a ranking
+similarities = model.similarity(query_embeddings, document_embeddings)
+print(similarities)
+# tensor([[0.3011, 0.6359, 0.4930, 0.4889]])
+```
+
+**NOTE**: EmbeddingGemma activations do not support `float16`. Please use `float32` or `bfloat16` as appropriate for your hardware.
+
+## Model Data
+
+### Training Dataset
+
+This model was trained on a dataset of text data that includes a wide variety of sources totaling approximately 320 billion tokens. Here are the key components:
+
+-   **Web Documents**: A diverse collection of web text ensures the model is exposed to a broad range of linguistic styles, topics, and vocabulary. The training dataset includes content in over 100 languages.
+-   **Code and Technical Documents**: Exposing the model to code and technical documentation helps it learn the structure and patterns of programming languages and specialized scientific content, which improves its understanding of code and technical questions.
+-   **Synthetic and Task-Specific Data**: Synthetically training data helps to teach the model specific skills. This includes curated data for tasks like information retrieval, classification, and sentiment analysis, which helps to fine-tune its performance for common embedding applications.
+
+The combination of these diverse data sources is crucial for training a powerful multilingual embedding model that can handle a wide variety of different tasks and data formats.
+
+### Data Preprocessing
+
+Here are the key data cleaning and filtering methods applied to the training data:
+
+-   CSAM Filtering: Rigorous CSAM (Child Sexual Abuse Material) filtering was applied at multiple stages in the data preparation process to ensure the exclusion of harmful and illegal content.
+-   Sensitive Data Filtering: As part of making Gemma pre-trained models safe and reliable, automated techniques were used to filter out certain personal information and other sensitive data from training sets.
+-   Additional methods: Filtering based on content quality and safety in line with [our policies](https://ai.google/static/documents/ai-responsibility-update-published-february-2025.pdf).
+
+## Model Development
+
+### Hardware
+
+EmbeddingGemma was trained using the latest generation of [Tensor Processing Unit (TPU)](https://cloud.google.com/tpu/docs/intro-to-tpu) hardware (TPUv5e), for more details refer to the [Gemma 3 model card](https://ai.google.dev/gemma/docs/core/model_card_3).
+
+### Software
+
+Training was done using [JAX](https://github.com/jax-ml/jax) and [ML Pathways](https://blog.google/technology/ai/introducing-pathways-next-generation-ai-architecture/). For more details refer to the [Gemma 3 model card](https://ai.google.dev/gemma/docs/core/model_card_3).
+
+## Evaluation
+
+### Benchmark Results
+
+The model was evaluated against a large collection of different datasets and metrics to cover different aspects of text understanding.
+
+#### Full Precision Checkpoint
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="3"><strong>MTEB (Multilingual, v2)</strong></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><strong>Dimensionality</strong></td>
+      <td><strong>Mean (Task)</strong></td>
+      <td><strong>Mean (TaskType)</strong></td>
+    </tr>
+    <tr>
+      <td>768d</td>
+      <td>61.15</td>
+      <td>54.31</td>
+    </tr>
+    <tr>
+      <td>512d</td>
+      <td>60.71</td>
+      <td>53.89</td>
+    </tr>
+    <tr>
+      <td>256d</td>
+      <td>59.68</td>
+      <td>53.01</td>
+    </tr>
+    <tr>
+      <td>128d</td>
+      <td>58.23</td>
+      <td>51.77</td>
+    </tr>
+  </tbody>
+</table>
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="3"><strong>MTEB (English, v2)</strong></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><strong>Dimensionality</strong></td>
+      <td><strong>Mean (Task)</strong></td>
+      <td><strong>Mean (TaskType)</strong></td>
+    </tr>
+    <tr>
+      <td>768d</td>
+      <td>68.36</td>
+      <td>64.15</td>
+    </tr>
+    <tr>
+      <td>512d</td>
+      <td>67.80</td>
+      <td>63.59</td>
+    </tr>
+    <tr>
+      <td>256d</td>
+      <td>66.89</td>
+      <td>62.94</td>
+    </tr>
+    <tr>
+      <td>128d</td>
+      <td>65.09</td>
+      <td>61.56</td>
+    </tr>
+  </tbody>
+</table>
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="3"><strong>MTEB (Code, v1)</strong></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><strong>Dimensionality</strong></td>
+      <td><strong>Mean (Task)</strong></td>
+      <td><strong>Mean (TaskType)</strong></td>
+    </tr>
+    <tr>
+      <td>768d</td>
+      <td>68.76</td>
+      <td>68.76</td>
+    </tr>
+    <tr>
+      <td>512d</td>
+      <td>68.48</td>
+      <td>68.48</td>
+    </tr>
+    <tr>
+      <td>256d</td>
+      <td>66.74</td>
+      <td>66.74</td>
+    </tr>
+    <tr>
+      <td>128d</td>
+      <td>62.96</td>
+      <td>62.96</td>
+    </tr>
+  </tbody>
+</table>
+
+#### QAT Checkpoints
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="3"><strong>MTEB (Multilingual, v2)</strong></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><strong>Quant config (dimensionality)</strong></td>
+      <td><strong>Mean (Task)</strong></td>
+      <td><strong>Mean (TaskType)</strong></td>
+    </tr>
+    <tr>
+      <td>Q4_0 (768d)</td>
+      <td>60.62</td>
+      <td>53.61</td>
+    </tr>
+    <tr>
+      <td>Q8_0 (768d)</td>
+      <td>60.93</td>
+      <td>53.95</td>
+    </tr>
+    <tr>
+      <td>Mixed Precision* (768d)</td>
+      <td>60.69</td>
+      <td>53.82</td>
+    </tr>
+  </tbody>
+</table>
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="3"><strong>MTEB (English, v2)</strong></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><strong>Quant config (dimensionality)</strong></td>
+      <td><strong>Mean (Task)</strong></td>
+      <td><strong>Mean (TaskType)</strong></td>
+    </tr>
+    <tr>
+      <td>Q4_0 (768d)</td>
+      <td>67.91</td>
+      <td>63.64</td>
+    </tr>
+    <tr>
+      <td>Q8_0 (768d)</td>
+      <td>68.13</td>
+      <td>63.85</td>
+    </tr>
+    <tr>
+      <td>Mixed Precision* (768d)</td>
+      <td>67.95</td>
+      <td>63.83</td>
+    </tr>
+  </tbody>
+</table>
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="3"><strong>MTEB (Code, v1)</strong></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><strong>Quant config (dimensionality)</strong></td>
+      <td><strong>Mean (Task)</strong></td>
+      <td><strong>Mean (TaskType)</strong></td>
+    </tr>
+    <tr>
+      <td>Q4_0 (768d)</td>
+      <td>67.99</td>
+      <td>67.99</td>
+    </tr>
+    <tr>
+      <td>Q8_0 (768d)</td>
+      <td>68.70</td>
+      <td>68.70</td>
+    </tr>
+    <tr>
+      <td>Mixed Precision* (768d)</td>
+      <td>68.03</td>
+      <td>68.03</td>
+    </tr>
+  </tbody>
+</table>
+
+Note: QAT models are evaluated after quantization
+
+\* Mixed Precision refers to per-channel quantization with int4 for embeddings, feedforward, and projection layers, and int8 for attention (e4_a8_f4_p4).
+
+### Prompt Instructions
+
+EmbeddingGemma can generate optimized embeddings for various use cases—such as document retrieval, question answering, and fact verification—or for specific input types—either a query or a document—using prompts that are prepended to the input strings.
+Query prompts follow the form `task: {task description} | query: ` where the task description varies by the use case, with the default task description being `search result`. Document-style prompts follow the form `title: {title | "none"} | text: ` where the title is either `none` (the default) or the actual title of the document. Note that providing a title, if available, will improve model performance for document prompts but may require manual formatting.
+
+Use the following prompts based on your use case and input data type. These may already be available in the EmbeddingGemma configuration in your modeling framework of choice.
+
+<table>
+  <thead>
+    <tr>
+      <th><br>
+<strong>Use Case (task type enum)</strong></th>
+      <th><br>
+<strong>Descriptions</strong></th>
+      <th><br>
+<strong>Recommended Prompt</strong></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><br>
+Retrieval (Query)</td>
+      <td rowspan="4"><br>
+Used to generate embeddings that are optimized for document search or information retrieval</td>
+      <td><br>
+task: search result | query: {content}</td>
+    </tr>
+    <tr>
+      <td><br>
+Retrieval (Document)</td>
+      <td><br>
+title: {title | "none"} | text: {content}</td>
+    </tr>
+    <tr>
+      <td><br>
+Question Answering</td>
+      <td><br>
+task: question answering | query: {content}</td>
+    </tr>
+    <tr>
+      <td><br>
+Fact Verification</td>
+      <td><br>
+task: fact checking | query: {content}</td>
+    </tr>
+    <tr>
+      <td><br>
+Classification</td>
+      <td><br>
+Used to generate embeddings that are optimized to classify texts according to preset labels</td>
+      <td><br>
+task: classification | query: {content}</td>
+    </tr>
+    <tr>
+      <td><br>
+Clustering</td>
+      <td><br>
+Used to generate embeddings that are optimized to cluster texts based on their similarities</td>
+      <td><br>
+task: clustering | query: {content}</td>
+    </tr>
+    <tr>
+      <td><br>
+Semantic Similarity</td>
+      <td><br>
+Used to generate embeddings that are optimized to assess text similarity. This is not intended for retrieval use cases.</td>
+      <td><br>
+task: sentence similarity | query: {content}</td>
+    </tr>
+    <tr>
+      <td><br>
+Code Retrieval</td>
+      <td><br>
+Used to retrieve a code block based on a natural language query, such as <em>sort an array</em> or <em>reverse a linked list</em>. Embeddings of the code blocks are computed using retrieval_document.</td>
+      <td><br>
+task: code retrieval | query: {content}</td>
+    </tr>
+  </tbody>
+</table>
+
+## Usage and Limitations
+
+These models have certain limitations that users should be aware of.
+
+### Intended Usage
+
+Open embedding models have a wide range of applications across various industries and domains. The following list of potential uses is not comprehensive. The purpose of this list is to provide contextual information about the possible use-cases that the model creators considered as part of model training and development.
+
+-   **Semantic Similarity**: Embeddings optimized to assess text similarity, such as recommendation systems and duplicate detection
+-   **Classification**: Embeddings optimized to classify texts according to preset labels, such as sentiment analysis and spam detection
+-  **Clustering**: Embeddings optimized to cluster texts based on their similarities, such as document organization, market research, and anomaly detection
+-   **Retrieval**
+    -   **Document**: Embeddings optimized for document search, such as indexing articles, books, or web pages for search
+    -   **Query**: Embeddings optimized for general search queries, such as custom search
+    -   **Code Query**: Embeddings optimized for retrieval of code blocks based on natural language queries, such as code suggestions and search
+
+-   **Question Answering**: Embeddings for questions in a question-answering system, optimized for finding documents that answer the question, such as chatbox.
+-   **Fact Verification**: Embeddings for statements that need to be verified, optimized for retrieving documents that contain evidence supporting or refuting the statement, such as automated fact-checking systems.
+
+### Limitations
+
+-   Training Data
+    -   The quality and diversity of the training data significantly influence the model's capabilities. Biases or gaps in the training data can lead to limitations in the model's responses.
+    -   The scope of the training dataset determines the subject areas the model can handle effectively.
+
+-   Language Ambiguity and Nuance
+    -   Natural language is inherently complex. Models might struggle to grasp subtle nuances, sarcasm, or figurative language.
+
+### Ethical Considerations and Risks
+
+Risks identified and mitigations:
+
+-   **Perpetuation of biases**: It's encouraged to perform continuous monitoring (using evaluation metrics, human review) and the exploration of de-biasing techniques during model training, fine-tuning, and other use cases.
+-   **Misuse for malicious purposes**: Technical limitations and developer and end-user education can help mitigate against malicious applications of embeddings. Educational resources and reporting mechanisms for users to flag misuse are provided. Prohibited uses of Gemma models are outlined in the [Gemma Prohibited Use Policy](https://ai.google.dev/gemma/prohibited_use_policy).
+-   **Privacy violations**: Models were trained on data filtered for removal of certain personal information and other sensitive data. Developers are encouraged to adhere to privacy regulations with privacy-preserving techniques.
+
+### Benefits
+
+At the time of release, this family of models provides high-performance open embedding model implementations designed from the ground up for responsible AI development compared to similarly sized models. Using the benchmark evaluation metrics described in this document, these models have shown superior performance to other, comparably-sized open model alternatives.

added_tokens.json

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

config.json

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

config_sentence_transformers.json

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

generation_config.json

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

model.safetensors

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

modules.json

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

notebook.ipynb

@@ -0,0 +1,656 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-u7xRR3DeFXz"
+      },
+      "source": [
+        "##### Copyright 2025 Google LLC."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "oed1Dh9SeIlD"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+        "# you may not use this file except in compliance with the License.\n",
+        "# You may obtain a copy of the License at\n",
+        "#\n",
+        "# https://www.apache.org/licenses/LICENSE-2.0\n",
+        "#\n",
+        "# Unless required by applicable law or agreed to in writing, software\n",
+        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+        "# See the License for the specific language governing permissions and\n",
+        "# limitations under the License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UpJl85mfqdUB"
+      },
+      "source": [
+        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
+        "  <td>\n",
+        "    <a target=\"_blank\" href=\"https://ai.google.dev/gemma/docs/embeddinggemma/inference-embeddinggemma-with-sentence-transformers\"><img src=\"https://ai.google.dev/static/site-assets/images/docs/notebook-site-button.png\" height=\"32\" width=\"32\" />View on ai.google.dev</a>\n",
+        "  </td>\n",
+        "  <td>\n",
+        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/google/generative-ai-docs/blob/main/site/en/gemma/docs/embeddinggemma/inference-embeddinggemma-with-sentence-transformers.ipynb\"\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
+        "  </td>\n",
+        "  <td>\n",
+        "    <a target=\"_blank\" href=\"https://kaggle.com/kernels/welcome?src=https://github.com/google/generative-ai-docs/blob/main/site/en/gemma/docs/embeddinggemma/inference-embeddinggemma-with-sentence-transformers.ipynb\"><img src=\"https://www.kaggle.com/static/images/logos/kaggle-logo-transparent-300.png\" height=\"32\" width=\"70\"/>Run in Kaggle</a>\n",
+        "  </td>\n",
+        "  <td>\n",
+        "    <a target=\"_blank\" href=\"https://console.cloud.google.com/vertex-ai/workbench/deploy-notebook?download_url=https://raw.githubusercontent.com/google/generative-ai-docs/main/site/en/gemma/docs/embeddinggemma/inference-embeddinggemma-with-sentence-transformers.ipynb\"><img src=\"https://ai.google.dev/images/cloud-icon.svg\" width=\"40\" />Open in Vertex AI</a>\n",
+        "  </td>\n",
+        "  <td>\n",
+        "    <a target=\"_blank\" href=\"https://github.com/google/generative-ai-docs/blob/main/site/en/gemma/docs/embeddinggemma/inference-embeddinggemma-with-sentence-transformers.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
+        "  </td>\n",
+        "</table>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Sq3lJyEiqqD-"
+      },
+      "source": [
+        "# Generate Embeddings with Sentence Transformers\n",
+        "\n",
+        "EmbeddingGemma is a lightweight, open embedding model designed for fast, high-quality retrieval on everyday devices like mobile phones. At only 308 million parameters, it's efficient enough to run advanced AI techniques, such as Retrieval Augmented Generation (RAG), directly on your local machine with no internet connection required.\n",
+        "\n",
+        "## Setup\n",
+        "\n",
+        "Before starting this tutorial, complete the following steps:\n",
+        "\n",
+        "* Get access to Gemma by logging into [Hugging Face](https://huggingface.co/google/embeddinggemma-300M) and selecting **Acknowledge license** for a Gemma model.\n",
+        "* Generate a Hugging Face [Access Token](https://huggingface.co/docs/hub/en/security-tokens#how-to-manage-user-access-token) and use it to login from Colab.\n",
+        "\n",
+        "This notebook will run on either CPU or GPU."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "R3TOEqprq-X3"
+      },
+      "source": [
+        "### Install Python packages\n",
+        "\n",
+        "Install the libraries required for running the EmbeddingGemma model and generating embeddings. Sentence Transformers is a Python framework for text and image embeddings. For more information, see the [Sentence Transformers](https://www.sbert.net/) documentation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jZFuhT3nrHEK"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install -U sentence-transformers git+https://github.com/huggingface/transformers@v4.56.0-Embedding-Gemma-preview"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "O3ttIyfSA0Lj"
+      },
+      "source": [
+        "After you have accepted the license, you need a valid Hugging Face Token to access the model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "WXK1Ev1Sq2iY"
+      },
+      "outputs": [],
+      "source": [
+        "# Login into Hugging Face Hub\n",
+        "from huggingface_hub import login\n",
+        "login()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "NUydcaDBrXDi"
+      },
+      "source": [
+        "### Load Model\n",
+        "\n",
+        "Use the `sentence-transformers` libraries to create an instance of a model class with EmbeddingGemma."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "mkpmqlU_rcOd",
+        "outputId": "f8458e59-9a6e-4a89-af83-ffdf391c323a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Device: cuda:0\n",
+            "SentenceTransformer(\n",
+            "  (0): Transformer({'max_seq_length': 2048, 'do_lower_case': False, 'architecture': 'Gemma3TextModel'})\n",
+            "  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})\n",
+            "  (2): Dense({'in_features': 768, 'out_features': 3072, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})\n",
+            "  (3): Dense({'in_features': 3072, 'out_features': 768, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})\n",
+            "  (4): Normalize()\n",
+            ")\n",
+            "Total number of parameters in the model: 307581696\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torch\n",
+        "from sentence_transformers import SentenceTransformer\n",
+        "\n",
+        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "\n",
+        "model_id = \"google/embeddinggemma-300M\"\n",
+        "model = SentenceTransformer(model_id).to(device=device)\n",
+        "\n",
+        "print(f\"Device: {model.device}\")\n",
+        "print(model)\n",
+        "print(\"Total number of parameters in the model:\", sum([p.numel() for _, p in model.named_parameters()]))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "JxrZ8na0A7Hv"
+      },
+      "source": [
+        "## Generating Embedding\n",
+        "\n",
+        "An embedding is a numerical representation of text, like a word or sentence, that captures its semantic meaning. Essentially, it's a list of numbers (a vector) that allows computers to understand the relationships and context of words.\n",
+        "\n",
+        "Let's see how EmbeddingGemma would process three different words `[\"apple\", \"banana\", \"car\"]`.\n",
+        "\n",
+        "EmbeddingGemma has been trained on vast amounts of text and has learned the relationships between words and concepts."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "o0UK8UVAA9b7",
+        "outputId": "37c91847-57de-4a47-9c1a-0adffacd1867"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[[-0.18476306  0.00167681  0.03773484 ... -0.07996225 -0.02348064\n",
+            "   0.00976741]\n",
+            " [-0.21189538 -0.02657359  0.02513712 ... -0.08042689 -0.01999852\n",
+            "   0.00512146]\n",
+            " [-0.18924113 -0.02551468  0.04486253 ... -0.06377774 -0.03699806\n",
+            "   0.03973572]]\n",
+            "Embedding 1: (768,)\n",
+            "Embedding 2: (768,)\n",
+            "Embedding 3: (768,)\n"
+          ]
+        }
+      ],
+      "source": [
+        "words = [\"apple\", \"banana\", \"car\"]\n",
+        "\n",
+        "# Calculate embeddings by calling model.encode()\n",
+        "embeddings = model.encode(words)\n",
+        "\n",
+        "print(embeddings)\n",
+        "for idx, embedding in enumerate(embeddings):\n",
+        "    print(f\"Embedding {idx+1} (shape): {embedding.shape}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "inuWOAuMBAR7"
+      },
+      "source": [
+        "The model outpus a numerical vector for each sentence. The actual vectors are very long (768), but for simplicity, those are presented with a few dimensions.\n",
+        "\n",
+        "The key isn't the individual numbers themselves, but **the distance between the vectors**. If we were to plot these vectors in a multi-dimensional space, The vectors for `apple` and `banana` would be very close to each other. And the vector for `car` would be far away from the other two."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2oCpMMJUr4RT"
+      },
+      "source": [
+        "## Determining Similarity\n",
+        "\n",
+        "In this section, we use embeddings to determine how sementically similar different sentences are. Here we show examples with high, medieum, and low similarity scores.\n",
+        "\n",
+        "- High Similarity:\n",
+        "  - Sentence A: \"The chef prepared a delicious meal for the guests.\"\n",
+        "  - Sentence B: \"A tasty dinner was cooked by the chef for the visitors.\"\n",
+        "  - Reasoning: Both sentences describe the same event using different words and grammatical structures (active vs. passive voice). They convey the same core meaning.\n",
+        "\n",
+        "- Medium Similarity:\n",
+        "  - Sentence A: \"She is an expert in machine learning.\"\n",
+        "  - Sentence B: \"He has a deep interest in artificial intelligence.\"\n",
+        "  - Reasoning: The sentences are related as machine learning is a subfield of artificial intelligence. However, they talk about different people with different levels of engagement (expert vs. interest).\n",
+        "\n",
+        "- Low Similarity:\n",
+        "  - Sentence A: \"The weather in Tokyo is sunny today.\"\n",
+        "  - Sentence B: \"I need to buy groceries for the week.\"\n",
+        "  - Reasoning: The two sentences are on completely unrelated topics and share no semantic overlap."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "VeTEvnTyslyq",
+        "outputId": "b387529f-aad8-4150-e4f1-daef4f30cfc0"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "🙋‍♂️\n",
+            "['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']\n",
+            "`-> 🤖 score:  0.8002148\n",
+            "🙋‍♂️\n",
+            "['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']\n",
+            "`-> 🤖 score:  0.45417833\n",
+            "🙋‍♂️\n",
+            "['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']\n",
+            "`-> 🤖 score:  0.22262995\n"
+          ]
+        }
+      ],
+      "source": [
+        "# The sentences to encode\n",
+        "sentence_high = [\n",
+        "    \"The chef prepared a delicious meal for the guests.\",\n",
+        "    \"A tasty dinner was cooked by the chef for the visitors.\"\n",
+        "]\n",
+        "sentence_medium = [\n",
+        "    \"She is an expert in machine learning.\",\n",
+        "    \"He has a deep interest in artificial intelligence.\"\n",
+        "]\n",
+        "sentence_low = [\n",
+        "    \"The weather in Tokyo is sunny today.\",\n",
+        "    \"I need to buy groceries for the week.\"\n",
+        "]\n",
+        "\n",
+        "for sentence in [sentence_high, sentence_medium, sentence_low]:\n",
+        "    print(\"🙋‍♂️\")\n",
+        "    print(sentence)\n",
+        "    embeddings = model.encode(sentence)\n",
+        "    similarities = model.similarity(embeddings[0], embeddings[1])\n",
+        "    print(\"`-> 🤖 score: \", similarities.numpy()[0][0])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "obfUiizULZE0"
+      },
+      "source": [
+        "### Using Prompts with EmbeddingGemma\n",
+        "\n",
+        "To generate the best embeddings with EmbeddingGemma, you should add an \"instructional prompt\" or \"task\" to the beginning of your input text. These prompts optimize the embeddings for specific tasks, such as document retrieval or question answering, and help the model distinguish between different input types, like a search query versus a document.\n",
+        "\n",
+        "#### How to Apply Prompts\n",
+        "\n",
+        "You can apply a prompt during inference in three ways.\n",
+        "\n",
+        "1.  **Using the `prompt` argument**<br>\n",
+        "    Pass the full prompt string directly to the `encode` method. This gives you precise control.\n",
+        "    ```python\n",
+        "    embeddings = model.encode(\n",
+        "        sentence,\n",
+        "        prompt=\"task: sentence similarity | query: \"\n",
+        "    )\n",
+        "    ```\n",
+        "2.  **Using the `prompt_name` argument**<br>\n",
+        "    Select a predefined prompt by its name. These prompts are loaded from the model's configuration or during its initialization.\n",
+        "    ```python\n",
+        "    embeddings = model.encode(sentence, prompt_name=\"STS\")\n",
+        "    ```\n",
+        "3.  **Using the Default Prompt**<br>\n",
+        "    If you don't specify either `prompt` or `prompt_name`, the system will automatically use the prompt set as `default_prompt_name`, if no default is set, then no prompt is applied.\n",
+        "    ```python\n",
+        "    embeddings = model.encode(sentence)\n",
+        "    ```\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "0p3qe3WDJV-I",
+        "outputId": "5fa2638e-e67b-479b-fba4-ca89a22cd10e"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Available tasks:\n",
+            " query: \"task: search result | query: \"\n",
+            " document: \"title: none | text: \"\n",
+            " BitextMining: \"task: search result | query: \"\n",
+            " Clustering: \"task: clustering | query: \"\n",
+            " Classification: \"task: classification | query: \"\n",
+            " InstructionRetrieval: \"task: code retrieval | query: \"\n",
+            " MultilabelClassification: \"task: classification | query: \"\n",
+            " PairClassification: \"task: sentence similarity | query: \"\n",
+            " Reranking: \"task: search result | query: \"\n",
+            " Retrieval: \"task: search result | query: \"\n",
+            " Retrieval-query: \"task: search result | query: \"\n",
+            " Retrieval-document: \"title: none | text: \"\n",
+            " STS: \"task: sentence similarity | query: \"\n",
+            " Summarization: \"task: summarization | query: \"\n",
+            "--------------------------------------------------------------------------------\n",
+            "🙋‍♂️\n",
+            "['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']\n",
+            "`-> 🤖 score:  0.9363755\n",
+            "🙋‍♂️\n",
+            "['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']\n",
+            "`-> 🤖 score:  0.6425841\n",
+            "🙋‍♂️\n",
+            "['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']\n",
+            "`-> 🤖 score:  0.38587403\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"Available tasks:\")\n",
+        "for name, prefix in model.prompts.items():\n",
+        "    print(f\" {name}: \\\"{prefix}\\\"\")\n",
+        "print(\"-\"*80)\n",
+        "\n",
+        "for sentence in [sentence_high, sentence_medium, sentence_low]:\n",
+        "    print(\"🙋‍♂️\")\n",
+        "    print(sentence)\n",
+        "    embeddings = model.encode(sentence, prompt_name=\"STS\")\n",
+        "    similarities = model.similarity(embeddings[0], embeddings[1])\n",
+        "    print(\"`-> 🤖 score: \", similarities.numpy()[0][0])\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2YAqPXDctw2w"
+      },
+      "source": [
+        "#### Use Case: Retrieval-Augmented Generation (RAG)\n",
+        "\n",
+        "For RAG systems, use the following `prompt_name` values to create specialized embeddings for your queries and documents:\n",
+        "\n",
+        "* **For Queries:** Use `prompt_name=\"Retrieval-query\"`.<br>\n",
+        "    ```python\n",
+        "    query_embedding = model.encode(\n",
+        "        \"How do I use prompts with this model?\",\n",
+        "        prompt_name=\"Retrieval-query\"\n",
+        "    )\n",
+        "    ```\n",
+        "\n",
+        "* **For Documents:** Use `prompt_name=\"Retrieval-document\"`. To further improve document embeddings, you can also include a title by using the `prompt` argument directly:<br>\n",
+        "  * **With a title:**<br>\n",
+        "    ```python\n",
+        "    doc_embedding = model.encode(\n",
+        "        \"The document text...\",\n",
+        "        prompt=\"title: Using Prompts in RAG | text: \"\n",
+        "    )\n",
+        "    ```\n",
+        "  * **Without a title:**<br>\n",
+        "    ```python\n",
+        "    doc_embedding = model.encode(\n",
+        "        \"The document text...\",\n",
+        "        prompt=\"title: none | text: \"\n",
+        "    )\n",
+        "    ```\n",
+        "\n",
+        "#### Further Reading\n",
+        "\n",
+        "* For details on all available EmbeddingGemma prompts, see the [model card](http://ai.google.dev/gemma/docs/embeddinggemma/model_card#prompt_instructions).\n",
+        "* For general information on prompt templates, see the [Sentence Transformer documentation](https://sbert.net/examples/sentence_transformer/applications/computing-embeddings/README.html#prompt-templates).\n",
+        "* For a demo of RAG, see the [Simple RAG example](https://github.com/google-gemini/gemma-cookbook/blob/main/Gemma/%5BGemma_3%5DRAG_with_EmbeddingGemma.ipynb) in the Gemma Cookbook.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aQh-QFAPsswb"
+      },
+      "source": [
+        "## Classification\n",
+        "\n",
+        "Classification is the task of assigning a piece of text to one or more predefined categories or labels. It's one of the most fundamental tasks in Natural Language Processing (NLP).\n",
+        "\n",
+        "A practical application of text classification is customer support ticket routing. This process automatically directs customer queries to the correct department, saving time and reducing manual work."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "C2Ufawl-tXvr",
+        "outputId": "347bd68c-dfee-470d-eef7-e3af5d096e91"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor([[0.4673, 0.5145, 0.3604],\n",
+            "        [0.4191, 0.5010, 0.5966]])\n",
+            "tensor([1, 2])\n",
+            "🙋‍♂️ Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password. -> 🤖 Technical Support\n",
+            "🙋‍♂️ I would like to inquire about your enterprise plan pricing and features for a team of 50 people. -> 🤖 Sales Inquiry\n"
+          ]
+        }
+      ],
+      "source": [
+        "labels = [\"Billing Issue\", \"Technical Support\", \"Sales Inquiry\"]\n",
+        "\n",
+        "sentence = [\n",
+        "    \"Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password.\",\n",
+        "    \"I would like to inquire about your enterprise plan pricing and features for a team of 50 people.\",\n",
+        "]\n",
+        "\n",
+        "# Calculate embeddings by calling model.encode()\n",
+        "label_embeddings = model.encode(labels, prompt_name=\"Classification\")\n",
+        "embeddings = model.encode(sentence, prompt_name=\"Classification\")\n",
+        "\n",
+        "# Calculate the embedding similarities\n",
+        "similarities = model.similarity(embeddings, label_embeddings)\n",
+        "print(similarities)\n",
+        "\n",
+        "idx = similarities.argmax(1)\n",
+        "print(idx)\n",
+        "\n",
+        "for example in sentence:\n",
+        "    print(\"🙋‍♂️\", example, \"-> 🤖\", labels[idx[sentence.index(example)]])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IRUU2EIDPSmW"
+      },
+      "source": [
+        "## Matryoshka Representation Learning (MRL)\n",
+        "\n",
+        "EmbeddingGemma leverages MRL to provide multiple embedding sizes from one model. It's a clever training method that creates a single, high-quality embedding where the most important information is concentrated at the beginning of the vector.\n",
+        "\n",
+        "This means you can get a smaller but still very useful embedding by simply taking the first `N` dimensions of the full embedding. Using smaller, truncated embeddings is significantly cheaper to store and faster to process, but this efficiency comes at the cost of potential lower quality of embeddings. MRL gives you the power to choose the optimal balance between this speed and accuracy for your application's specific needs.\n",
+        "\n",
+        "Let's use three words `[\"apple\", \"banana\", \"car\"]` and create simplified embeddings to see how MRL works."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "B1q1F9I5PYSq",
+        "outputId": "a5b28e04-4783-4d79-ae82-3fac7e554a7a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "similarity function:  cosine\n",
+            "tensor([[0.7510, 0.6685]])\n",
+            "🙋‍♂️ apple vs. banana -> 🤖 score:  0.75102395\n",
+            "🙋‍♂️ apple vs. car -> 🤖 score:  0.6684626\n"
+          ]
+        }
+      ],
+      "source": [
+        "def check_word_similarities():\n",
+        "    # Calculate the embedding similarities\n",
+        "    print(\"similarity function: \", model.similarity_fn_name)\n",
+        "    similarities = model.similarity(embeddings[0], embeddings[1:])\n",
+        "    print(similarities)\n",
+        "\n",
+        "    for idx, word in enumerate(words[1:]):\n",
+        "        print(\"🙋‍♂️ apple vs.\", word, \"-> 🤖 score: \", similarities.numpy()[0][idx])\n",
+        "\n",
+        "# Calculate embeddings by calling model.encode()\n",
+        "embeddings = model.encode(words, prompt_name=\"STS\")\n",
+        "\n",
+        "check_word_similarities()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_iv1xG0TPxkm"
+      },
+      "source": [
+        "Now, for a faster application, you don't need a new model. Simply **truncate** the full embeddings to the first **512 dimensions**. For optimal results, it is also recommended to set `normalize_embeddings=True`, which scales the vectors to a unit length of 1."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9Ue4aWh8PzdL",
+        "outputId": "176dabd4-9d9c-4ce9-c7e5-472ba47ed55f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Embedding 1: (512,)\n",
+            "Embedding 2: (512,)\n",
+            "Embedding 3: (512,)\n",
+            "--------------------------------------------------------------------------------\n",
+            "similarity function:  cosine\n",
+            "tensor([[0.7674, 0.7041]])\n",
+            "🙋‍♂️ apple vs. banana -> 🤖 score:  0.767427\n",
+            "🙋‍♂️ apple vs. car -> 🤖 score:  0.7040509\n"
+          ]
+        }
+      ],
+      "source": [
+        "embeddings = model.encode(words, truncate_dim=512, normalize_embeddings=True)\n",
+        "\n",
+        "for idx, embedding in enumerate(embeddings):\n",
+        "    print(f\"Embedding {idx+1}: {embedding.shape}\")\n",
+        "\n",
+        "print(\"-\"*80)\n",
+        "check_word_similarities()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lgkmgzfVP24M"
+      },
+      "source": [
+        "In extremely constrained environments, you can further shorten the embeddings to just **256 dimensions**. You can also use the more efficient **dot-product** for similarity calculations instead of the standard **cosine** similarity."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Gi4NlPv-P4RS",
+        "outputId": "656d8d6a-1e79-41be-f17a-cab136bf27ea"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Embedding 1: (256,)\n",
+            "Embedding 2: (256,)\n",
+            "Embedding 3: (256,)\n",
+            "--------------------------------------------------------------------------------\n",
+            "similarity function:  dot\n",
+            "tensor([[0.7855, 0.7382]])\n",
+            "🙋‍♂️ apple vs. banana -> 🤖 score:  0.7854644\n",
+            "🙋‍♂️ apple vs. car -> 🤖 score:  0.7382126\n"
+          ]
+        }
+      ],
+      "source": [
+        "model = SentenceTransformer(model_id, truncate_dim=256, similarity_fn_name=\"dot\").to(device=device)\n",
+        "embeddings = model.encode(words, prompt_name=\"STS\", normalize_embeddings=True)\n",
+        "\n",
+        "for idx, embedding in enumerate(embeddings):\n",
+        "    print(f\"Embedding {idx+1}: {embedding.shape}\")\n",
+        "\n",
+        "print(\"-\"*80)\n",
+        "check_word_similarities()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RYr9uSI_t3fm"
+      },
+      "source": [
+        "## Summary and next steps\n",
+        "\n",
+        "You are now equipped to generate high-quality text embeddings using EmbeddingGemma and the Sentence Transformers library. Apply these skills to build powerful features like semantic similarity, text classification, and Retrieval-Augmented Generation (RAG) systems, and continue exploring what's possible with Gemma models.\n",
+        "\n",
+        "Check out the following docs next:\n",
+        "\n",
+        "* [Fine-tune EmbeddingGemma](https://ai.google.dev/gemma/docs/embeddinggemma/fine-tuning-embeddinggemma-with-sentence-transformers)\n",
+        "* [Simple RAG example](https://github.com/google-gemini/gemma-cookbook/blob/main/Gemma/%5BGemma_3%5DRAG_with_EmbeddingGemma.ipynb) in the Gemma Cookbook\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "name": "inference-embeddinggemma-with-sentence-transformers.ipynb",
+      "provenance": [],
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

sentence_bert_config.json

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

special_tokens_map.json

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

tokenizer.json

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

tokenizer.model

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

tokenizer_config.json

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