# Раздел 3: Основи на семейството Gemma

Моделното семейство Gemma представлява цялостния подход на Google към отворените големи езикови модели и мултимодалния AI, демонстрирайки, че достъпните модели могат да постигнат впечатляваща производителност, като същевременно са приложими в различни сценарии – от мобилни устройства до работни станции в предприятия. Важно е да разберем как семейството Gemma предоставя мощни AI възможности с гъвкави опции за внедряване, като същевременно поддържа конкурентна производителност и отговорни AI практики.

## Въведение

В този урок ще разгледаме семейството модели Gemma на Google и неговите основни концепции. Ще обхванем еволюцията на семейството Gemma, иновативните методологии за обучение, които правят моделите Gemma ефективни, ключовите варианти в семейството и практическите приложения в различни сценарии за внедряване.

## Цели на обучението

До края на този урок ще можете:

- Да разберете философията на дизайна и еволюцията на семейството модели Gemma на Google
- Да идентифицирате ключовите иновации, които позволяват на моделите Gemma да постигат висока производителност при различни размери параметри
- Да разпознаете предимствата и ограниченията на различните варианти на моделите Gemma
- Да приложите знанията за моделите Gemma, за да изберете подходящи варианти за реални сценарии

## Разбиране на съвременния пейзаж на AI модели

Пейзажът на AI се е развил значително, като различни организации преследват различни подходи към разработването на езикови модели. Докато някои се фокусират върху затворени модели, достъпни само чрез API, други акцентират върху отвореността и прозрачността. Традиционният подход включва или масивни затворени модели с постоянни разходи, или отворени модели, които може да изискват значителна техническа експертиза за внедряване.

Тази парадигма създава предизвикателства за организациите, които търсят мощни AI възможности, като същевременно поддържат контрол върху своите данни, разходи и гъвкавост на внедряване. Традиционният подход често изисква избор между авангардна производителност и практически съображения за внедряване.

## Предизвикателството за достъпно AI съвършенство

Необходимостта от висококачествен, достъпен AI става все по-важна в различни сценарии. Помислете за приложения, които изискват гъвкави опции за внедряване за различни организационни нужди, икономически ефективни реализации, където разходите за API могат да станат значителни, мултимодални възможности за цялостно разбиране или специализирано внедряване на мобилни и крайни устройства.

### Основни изисквания за внедряване

Съвременните AI внедрения се сблъскват с няколко основни изисквания, които ограничават практическата приложимост:

- **Достъпност**: Отвореност за прозрачност и персонализация
- **Икономическа ефективност**: Разумни изчислителни изисквания за различни бюджети
- **Гъвкавост**: Различни размери модели за различни сценарии на внедряване
- **Мултимодално разбиране**: Възможности за обработка на визия, текст и аудио
- **Крайно внедряване**: Оптимизирана производителност на мобилни и ограничени ресурси устройства

## Философията на моделите Gemma

Семейството модели Gemma представлява цялостния подход на Google към разработването на AI модели, като приоритизира отвореността, мултимодалните възможности и практическото внедряване, като същевременно поддържа конкурентни характеристики на производителност. Моделите Gemma постигат това чрез разнообразни размери модели, висококачествени методологии за обучение, извлечени от изследванията на Gemini, и специализирани варианти за различни домейни и сценарии на внедряване.

Семейството Gemma обхваща различни подходи, предназначени да предоставят опции в спектъра на производителност-ефективност, позволявайки внедряване от мобилни устройства до сървъри в предприятия, като същевременно предоставя значими AI възможности. Целта е да се демократизира достъпът до висококачествени AI технологии, като се предоставя гъвкавост в избора на внедряване.

### Основни принципи на дизайна на Gemma

Моделите Gemma са изградени върху няколко основни принципа, които ги отличават от други семейства езикови модели:

- **Отвореност на първо място**: Пълна прозрачност и достъпност за изследвания и търговска употреба
- **Развитие, водено от изследвания**: Изградени с помощта на същите изследвания и технологии, които захранват моделите Gemini
- **Мащабируема архитектура**: Различни размери модели, които отговарят на различни изчислителни изисквания
- **Отговорен AI**: Интегрирани мерки за безопасност и отговорни практики за разработка

## Ключови технологии, които позволяват семейството Gemma

### Напреднали методологии за обучение

Една от определящите характеристики на семейството Gemma е усъвършенстваният подход към обучението, извлечен от изследванията на Google Gemini. Моделите Gemma използват дистилация от по-големи модели, обучение чрез обратна връзка от хора (RLHF) и техники за сливане на модели, за да постигнат подобрена производителност в математика, кодиране и следване на инструкции.

Процесът на обучение включва дистилация от по-големи модели за инструкции, обучение чрез обратна връзка от хора (RLHF) за съгласуване с човешките предпочитания, обучение чрез обратна връзка от машини (RLMF) за математическо разсъждение и обучение чрез обратна връзка от изпълнение (RLEF) за способности за кодиране.

### Мултимодална интеграция и разбиране

Последните модели Gemma включват усъвършенствани мултимодални възможности, които позволяват цялостно разбиране на различни типове входни данни:

**Интеграция на визия и език (Gemma 3)**: Gemma 3 може да обработва текст и изображения едновременно, позволявайки анализ на изображения, отговаряне на въпроси за визуално съдържание, извличане на текст от изображения и разбиране на сложни визуални данни.

**Обработка на аудио (Gemma 3n)**: Gemma 3n включва усъвършенствани аудио възможности, включително автоматично разпознаване на реч (ASR) и автоматичен превод на реч (AST), с особено силна производителност за превод между английски и испански, френски, италиански и португалски.

**Обработка на смесени входни данни**: Моделите Gemma поддържат смесени входни данни от различни модалности, позволявайки разбиране на сложни мултимодални взаимодействия, където текст, изображения и аудио могат да се обработват заедно.

### Архитектурни иновации

Семейството Gemma включва няколко архитектурни оптимизации, предназначени както за производителност, така и за ефективност:

**Разширение на контекстния прозорец**: Моделите Gemma 3 разполагат с контекстен прозорец от 128K токена, 16 пъти по-голям от предишните модели Gemma, позволявайки обработка на огромни количества информация, включително множество документи или стотици изображения.

**Архитектура, ориентирана към мобилни устройства (Gemma 3n)**: Gemma 3n използва технологията Per-Layer Embeddings (PLE) и архитектурата MatFormer, позволявайки на по-големи модели да работят с памет, сравнима с по-малки традиционни модели.

**Възможности за извикване на функции**: Gemma 3 поддържа извикване на функции, позволявайки на разработчиците да създават интерфейси за програмиране на естествен език и да създават интелигентни автоматизационни системи.

## Размер на модела и опции за внедряване

Съвременните среди за внедряване се възползват от гъвкавостта на моделите Gemma при различни изчислителни изисквания:

### Малки модели (0.6B-4B)

Gemma предоставя ефективни малки модели, подходящи за крайно внедряване, мобилни приложения и среди с ограничени ресурси, като същевременно поддържа впечатляващи възможности. Моделът 1B е идеален за малки приложения, докато моделът 4B предлага балансирана производителност и гъвкавост с мултимодална поддръжка.

### Средни модели (8B-14B)

Средните модели предлагат подобрени възможности за професионални приложения, осигурявайки отличен баланс между производителност и изчислителни изисквания за работни станции и сървъри.

### Големи модели (27B+)

Моделите в пълен мащаб предоставят авангардна производителност за взискателни приложения, изследвания и внедрения в предприятия, изискващи максимални възможности. Моделът 27B представлява най-способния вариант, който все още може да работи на един GPU.

### Модели, оптимизирани за мобилни устройства (Gemma 3n)

Моделите Gemma 3n E2B и E4B са специално проектирани за внедряване на мобилни и крайни устройства, с ефективен брой параметри от 2B и 4B съответно, като използват иновативна архитектура за минимизиране на паметта до само 2GB за E2B и 3GB за E4B.

## Предимства на семейството модели Gemma

### Достъпност на отворен код

Моделите Gemma предоставят пълна прозрачност и възможности за персонализация с отворени тегла, които позволяват отговорна търговска употреба, позволявайки на организациите да ги настройват и внедряват в свои проекти и приложения.

### Гъвкавост на внедряване

Разнообразието от размери модели позволява внедряване на различни хардуерни конфигурации – от мобилни устройства до високопроизводителни сървъри, с оптимизация за различни платформи, включително Google Cloud TPUs, NVIDIA GPUs, AMD GPUs чрез ROCm и CPU изпълнение чрез Gemma.cpp.

### Многоезично съвършенство

Моделите Gemma се отличават в многоезичното разбиране и генериране, поддържайки над 140 езика с несравними многоезични възможности, което ги прави подходящи за глобални приложения.

### Конкурентна производителност

Моделите Gemma последователно постигат конкурентни резултати в бенчмаркове, като Gemma 3 се нарежда високо сред популярните затворени и отворени модели в оценките на потребителските предпочитания.

### Специализирани възможности

Приложенията за специфични домейни се възползват от мултимодалното разбиране на Gemma, възможностите за извикване на функции и оптимизираната производителност на различни хардуерни платформи.

## Практически примери и случаи на употреба

Преди да се потопим в техническите детайли, нека разгледаме някои конкретни примери за това, какво могат да постигнат моделите Gemma:

### Пример за мултимодално разбиране

Gemma 3 може да обработва текст и изображения едновременно за цялостен анализ:

```
User: [Image of a complex chart showing financial data] 
What trends can you identify in this quarterly revenue chart, and what might be causing the fluctuation in Q3?

Gemma 3: Looking at this quarterly revenue chart, I can identify several key patterns:

**Revenue Trends:**
1. **Steady Growth Pattern**: Q1 and Q2 show consistent upward trajectory with approximately 15% quarter-over-quarter growth
2. **Q3 Anomaly**: Notable dip of roughly 8% compared to Q2, breaking the growth pattern
3. **Q4 Recovery**: Strong rebound with 22% growth, reaching new highs

**Potential Q3 Factors:**
- **Seasonal Business Cycles**: Many industries experience summer slowdowns
- **Market Disruption**: Possible competitive pressure or economic uncertainty
- **Operational Changes**: Internal restructuring or supply chain adjustments
- **Product Lifecycle**: End-of-cycle for key products before Q4 launches

**Strategic Implications:**
The Q4 recovery suggests the Q3 dip was temporary rather than systemic, indicating resilient underlying business fundamentals with effective adaptation strategies.
```

### Пример за многоезична поддръжка

Моделите Gemma демонстрират силни многоезични възможности в над 140 езика:

```
User: Explain the concept of sustainable development in English, Spanish, and Chinese.

Gemma: **English:**
Sustainable development refers to meeting the needs of the present without compromising the ability of future generations to meet their own needs. It balances economic growth, environmental protection, and social equity to create long-term prosperity while preserving natural resources and ecosystems for future use.

**Español:**
El desarrollo sostenible se refiere a satisfacer las necesidades del presente sin comprometer la capacidad de las generaciones futuras para satisfacer sus propias necesidades. Equilibra el crecimiento económico, la protección ambiental y la equidad social para crear prosperidad a largo plazo mientras preserva los recursos naturales y ecosistemas para uso futuro.

**中文:**
可持续发展是指在满足当代人需求的同时，不损害后代满足其需求的能力。它平衡经济增长、环境保护和社会公平，创造长期繁荣，同时为未来使用保护自然资源和生态系统。
```

### Пример за извикване на функции

Gemma 3 поддържа извикване на функции за създаване на интерфейси на естествен език:

```python
# Example function definitions
available_functions = {
    "get_weather": {
        "description": "Get current weather for a location",
        "parameters": {
            "location": "string",
            "units": "string (optional, default: celsius)"
        }
    },
    "schedule_meeting": {
        "description": "Schedule a meeting with participants",
        "parameters": {
            "title": "string",
            "participants": "array of strings",
            "datetime": "ISO datetime string",
            "duration": "integer (minutes)"
        }
    }
}

User: "Can you check the weather in Tokyo and schedule a team meeting for tomorrow at 2 PM about project updates?"

Gemma 3: I'll help you with both tasks. Let me check the weather and schedule your meeting.

Function Calls:
1. get_weather(location="Tokyo", units="celsius")
2. schedule_meeting(
   title="Project Updates Team Meeting",
   participants=["user", "team"],
   datetime="2025-07-08T14:00:00",
   duration=60
)

Based on the results: Tokyo currently has partly cloudy weather at 24°C. Your project updates meeting has been scheduled for tomorrow (July 8th) at 2:00 PM for one hour. Meeting invitations will be sent to team participants.
```

### Пример за мобилно внедряване (Gemma 3n)

Gemma 3n е оптимизиран за мобилно и крайно внедряване с ефективно използване на паметта:

```python
# Mobile-optimized inference with Gemma 3n
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Load Gemma 3n for mobile deployment
model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-3n-E2B-it",
    torch_dtype=torch.float16,
    device_map="auto",
    load_in_8bit=True  # Further optimize for mobile
)

tokenizer = AutoTokenizer.from_pretrained("google/gemma-3n-E2B-it")

def mobile_inference(prompt, max_tokens=100):
    """Optimized inference for mobile devices"""
    inputs = tokenizer(
        prompt, 
        return_tensors="pt", 
        max_length=512, 
        truncation=True
    )
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_tokens,
            do_sample=True,
            temperature=0.7,
            early_stopping=True,
            pad_token_id=tokenizer.eos_token_id
        )
    
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response.replace(prompt, "").strip()

# Example mobile usage
user_query = "Quick summary of renewable energy benefits"
response = mobile_inference(user_query)
print(f"Mobile Response: {response}")
```

### Пример за обработка на аудио (Gemma 3n)

Gemma 3n включва усъвършенствани аудио възможности за разпознаване и превод на реч:

```python
# Audio processing with Gemma 3n
def process_audio_input(audio_file_path, task="transcribe", target_language="en"):
    """
    Process audio input for transcription or translation
    
    Args:
        audio_file_path: Path to audio file
        task: "transcribe" or "translate"
        target_language: Target language for translation
    """
    
    # Gemma 3n audio processing pipeline
    if task == "transcribe":
        prompt = f"<audio>{audio_file_path}</audio>\nTranscribe this audio:"
    elif task == "translate":
        prompt = f"<audio>{audio_file_path}</audio>\nTranslate this audio to {target_language}:"
    
    # Process with Gemma 3n
    inputs = tokenizer(prompt, return_tensors="pt")
    outputs = model.generate(**inputs, max_new_tokens=256)
    
    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return result.replace(prompt, "").strip()

# Example usage
# Transcribe Spanish audio to text
transcription = process_audio_input("spanish_audio.wav", task="transcribe")
print(f"Transcription: {transcription}")

# Translate Spanish speech to English text
translation = process_audio_input("spanish_audio.wav", task="translate", target_language="English")
print(f"Translation: {translation}")
```

## Еволюцията на семейството Gemma

### Gemma 1.0 и 2.0: Основни модели

Ранните модели Gemma установиха основните принципи на отвореност и практическо внедряване:

- **Gemma-2B и 7B**: Първоначално издание, фокусирано върху ефективно езиково разбиране
- **Серия Gemma 1.5**: Разширено обработване на контекст и подобрена производителност
- **Семейство Gemma 2**: Въвеждане на мултимодални възможности и разширени размери модели

### Gemma 3: Мултимодално съвършенство

Серията Gemma 3 отбеляза значителен напредък в мултимодалните възможности и производителността. Изградена върху същите изследвания и технологии, които захранват моделите Gemini 2.0, Gemma 3 въведе разбиране на визия и език, контекстни прозорци от 128K токена, извикване на функции и поддръжка на над 140 езика.

Ключови характеристики на Gemma 3 включват:
- **Gemma 3-1B до 27B**: Обширен диапазон за различни нужди от внедряване
- **Мултимодално разбиране**: Усъвършенствани текстови и визуални способности за разсъждение
- **Разширен контекст**: Възможност за обработка на 128K токена
- **Извикване на функции**: Създаване на интерфейси на естествен език
- **Подобрено обучение**: Оптимизирано чрез дистилация и обучение чрез обратна връзка

### Gemma 3n: Иновация, ориентирана към мобилни устройства

Gemma 3n представлява пробив в архитектурата на AI, ориентирана към мобилни устройства, включваща революционната технология Per-Layer Embeddings (PLE), архитектурата MatFormer за гъвкавост на изчисленията и цялостни мултимодални възможности, включително обработка на аудио.

Иновации на Gemma 3n включват:
- **Модели E2B и E4B**: Ефективна производителност с 2B и 4B параметри при намалена памет
- **Аудио възможности**: Висококачествено ASR и превод на реч
- **Разбиране на видео**: Значително подобрени възможности за обработка на видео
- **Оптимизация за мобилни устройства**: Проектиран за реален AI на телефони и таблети

## Приложения на моделите Gemma

### Приложения в предприятия

Организациите използват моделите Gemma за анализ на документи с визуално съдържание, автоматизация на обслужването на клиенти с мултимодална поддръжка, интелигентна помощ при кодиране и приложения за бизнес интелигентност. Отворената природа позволява персонализация за специфични бизнес нужди, като същевременно се поддържа поверителност и контрол върху данните.

### Мобилни и крайни изчисления

Мобилните приложения използват Gemma 3n за реален AI, работещ директно на устройства, позволявайки лични и частни преживявания с светкавично бързи мултимодални AI възможности. Приложенията включват реален превод, интелигентни асистенти, генериране на съдържание и персонализирани препоръки.

### Образователни технологии

Образователните платформи използват моделите Gemma за мултимодални учебни преживявания, автоматиз
- Gemma 3 предоставя мощни възможности за разработчици с напреднали текстови и визуални способности за разсъждение, като поддържа вход от изображения и текст за мултимодално разбиране.
- Gemma 3n се нарежда високо сред популярните собствени и отворени модели в Chatbot Arena Elo класациите, което показва силно предпочитание от страна на потребителите.

**Постижения в ефективността:**
- Моделите Gemma 3 могат да обработват входове до 128K токена, което е 16 пъти по-голям контекстен прозорец в сравнение с предишните модели Gemma.
- Gemma 3n използва Per-Layer Embeddings (PLE), което значително намалява използването на RAM, като същевременно запазва възможностите на по-големите модели.

**Оптимизация за мобилни устройства:**
- Gemma 3n E2B работи с едва 2GB памет, докато E4B изисква само 3GB, въпреки че има суров брой параметри от 5B и 8B съответно.
- Възможности за реално време на AI директно на мобилни устройства с приоритет на поверителността и готовност за офлайн работа.

**Мащаб на обучение:**
- Gemma 3 е обучен върху 2T токена за 1B, 4T за 4B, 12T за 12B и 14T токена за модели с 27B, използвайки Google TPUs и JAX Framework.

### Матрица за сравнение на модели

| Серия модели | Диапазон параметри | Дължина на контекста | Основни предимства | Най-добри случаи на употреба |
|--------------|--------------------|----------------------|--------------------|-----------------------------|
| **Gemma 3** | 1B-27B | 128K | Мултимодално разбиране, извикване на функции | Общи приложения, задачи с визия и език |
| **Gemma 3n** | E2B (5B), E4B (8B) | Променлива | Оптимизация за мобилни устройства, обработка на аудио | Мобилни приложения, edge computing, AI в реално време |
| **Gemma 2.5** | 0.5B-72B | 32K-128K | Балансирана производителност, многоезичност | Производствени внедрения, съществуващи работни потоци |
| **Gemma-VL** | Различни | Променлива | Специализация във визия и език | Анализ на изображения, визуални въпроси и отговори |

## Ръководство за избор на модел

### За основни приложения
- **Gemma 3-1B**: Леки текстови задачи, прости мобилни приложения
- **Gemma 3-4B**: Балансирана производителност с мултимодална поддръжка за обща употреба

### За мултимодални приложения
- **Gemma 3-4B/12B**: Разбиране на изображения, визуални въпроси и отговори
- **Gemma 3n**: Мобилни мултимодални приложения с възможности за обработка на аудио

### За мобилни и edge внедрения
- **Gemma 3n E2B**: Устройства с ограничени ресурси, AI в реално време на мобилни устройства
- **Gemma 3n E4B**: Подобрена мобилна производителност с аудио възможности

### За корпоративни внедрения
- **Gemma 3-12B/27B**: Високопроизводително разбиране на език и визия
- **Възможности за извикване на функции**: Създаване на интелигентни автоматизирани системи

### За глобални приложения
- **Всеки вариант на Gemma 3**: Поддръжка на 140+ езика с културно разбиране
- **Gemma 3n**: Мобилни приложения с приоритет на глобалната употреба и аудио превод

## Платформи за внедрение и достъпност

### Облачни платформи
- **Vertex AI**: Възможности за MLOps от край до край с безсървърно изживяване
- **Google Kubernetes Engine (GKE)**: Скалирано внедрение на контейнери за сложни работни натоварвания
- **Google GenAI API**: Директен достъп до API за бързо прототипиране
- **NVIDIA API Catalog**: Оптимизирана производителност на NVIDIA GPU

### Локални рамки за разработка
- **Hugging Face Transformers**: Стандартна интеграция за разработка
- **Ollama**: Опростено локално внедрение и управление
- **vLLM**: Високопроизводително обслужване за производство
- **Gemma.cpp**: Оптимизирано изпълнение на CPU
- **Google AI Edge**: Оптимизация за мобилни и edge внедрения

### Обучителни ресурси
- **Google AI Studio**: Изпробвайте моделите Gemma само с няколко клика
- **Kaggle и Hugging Face**: Изтеглете теглата на моделите и примери от общността
- **Технически доклади**: Подробна документация и изследователски статии
- **Форуми на общността**: Активна поддръжка и дискусии в общността

### Започване с моделите Gemma

#### Платформи за разработка
1. **Google AI Studio**: Започнете с уеб-базирани експерименти
2. **Hugging Face Hub**: Разгледайте модели и реализации от общността
3. **Локално внедрение**: Използвайте Ollama или Transformers за разработка

#### Път на обучение
1. **Разберете основните концепции**: Проучете мултимодалните възможности и опциите за внедрение
2. **Експериментирайте с варианти**: Изпробвайте различни размери на модели и специализирани версии
3. **Практикувайте внедрение**: Внедрете модели в среди за разработка
4. **Оптимизирайте за производство**: Фина настройка за специфични случаи на употреба и платформи

#### Най-добри практики
- **Започнете с малко**: Започнете с Gemma 3-4B за първоначална разработка и тестване
- **Използвайте официални шаблони**: Приложете подходящи шаблони за чат за оптимални резултати
- **Следете ресурсите**: Проследявайте използването на паметта и производителността на инференцията
- **Обмислете специализация**: Изберете подходящи варианти за мултимодални или мобилни нужди

## Стратегии за оптимизация на производителността

### Оптимизация на паметта

```python
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

# Memory-efficient loading strategies for Gemma models
def load_optimized_gemma(model_name, optimization_level="balanced"):
    """Load Gemma with various optimization levels"""
    
    if optimization_level == "maximum_efficiency":
        # 4-bit quantization for maximum memory efficiency
        quantization_config = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.bfloat16,
            bnb_4bit_use_double_quant=True,
            bnb_4bit_quant_type="nf4"
        )
        
        model = AutoModelForCausalLM.from_pretrained(
            model_name,
            quantization_config=quantization_config,
            device_map="auto",
            low_cpu_mem_usage=True,
            trust_remote_code=True
        )
        
    elif optimization_level == "balanced":
        # 8-bit quantization for balanced performance
        quantization_config = BitsAndBytesConfig(
            load_in_8bit=True,
            llm_int8_threshold=6.0,
        )
        
        model = AutoModelForCausalLM.from_pretrained(
            model_name,
            quantization_config=quantization_config,
            device_map="auto",
            torch_dtype=torch.bfloat16,
            trust_remote_code=True
        )
        
    elif optimization_level == "performance":
        # Full precision for maximum performance
        model = AutoModelForCausalLM.from_pretrained(
            model_name,
            device_map="auto",
            torch_dtype=torch.bfloat16,
            trust_remote_code=True
        )
    
    return model

# Example usage
efficient_model = load_optimized_gemma("google/gemma-3-8b-it", "maximum_efficiency")
```

### Оптимизация на инференцията

```python
import torch
from torch.nn.attention import SDPABackend, sdpa_kernel
from transformers import AutoTokenizer
import time

class OptimizedGemmaInference:
    """Optimized inference class for Gemma models"""
    
    def __init__(self, model, tokenizer):
        self.model = model
        self.tokenizer = tokenizer
        self._setup_optimizations()
    
    def _setup_optimizations(self):
        """Configure various inference optimizations"""
        
        # Enable optimized attention mechanisms
        if torch.cuda.is_available():
            torch.backends.cuda.enable_flash_sdp(True)
            torch.backends.cuda.enable_math_sdp(True)
            torch.backends.cuda.enable_mem_efficient_sdp(True)
        
        # Set optimal threading for CPU operations
        torch.set_num_threads(min(8, torch.get_num_threads()))
        
        # Enable JIT compilation for repeated patterns
        if hasattr(torch.jit, 'set_fusion_strategy'):
            torch.jit.set_fusion_strategy([('STATIC', 3), ('DYNAMIC', 20)])
        
        # Optimize model for inference
        self.model.eval()
        
        # Enable torch.compile if available (PyTorch 2.0+)
        if hasattr(torch, 'compile'):
            try:
                self.model = torch.compile(self.model, mode="reduce-overhead")
            except Exception as e:
                print(f"Torch compile failed: {e}")
    
    def fast_generate(self, messages, max_tokens=256, use_cache=True):
        """Optimized generation with various performance enhancements"""
        
        start_time = time.time()
        
        # Format input
        formatted_text = self.tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )
        
        inputs = self.tokenizer(
            formatted_text,
            return_tensors="pt",
            truncation=True,
            max_length=2048
        ).to(self.model.device)
        
        # Use optimized attention backend
        with torch.no_grad():
            if torch.cuda.is_available():
                with sdpa_kernel(SDPABackend.FLASH_ATTENTION):
                    outputs = self.model.generate(
                        **inputs,
                        max_new_tokens=max_tokens,
                        do_sample=True,
                        temperature=0.7,
                        top_p=0.9,
                        use_cache=use_cache,
                        pad_token_id=self.tokenizer.eos_token_id,
                        early_stopping=True
                    )
            else:
                outputs = self.model.generate(
                    **inputs,
                    max_new_tokens=max_tokens,
                    do_sample=True,
                    temperature=0.7,
                    top_p=0.9,
                    use_cache=use_cache,
                    pad_token_id=self.tokenizer.eos_token_id,
                    early_stopping=True
                )
        
        # Extract response
        response = self.tokenizer.decode(
            outputs[0][inputs.input_ids.shape[1]:],
            skip_special_tokens=True
        )
        
        generation_time = time.time() - start_time
        tokens_generated = outputs.shape[1] - inputs.input_ids.shape[1]
        tokens_per_second = tokens_generated / generation_time if generation_time > 0 else 0
        
        return {
            "response": response.strip(),
            "generation_time": generation_time,
            "tokens_per_second": tokens_per_second,
            "tokens_generated": tokens_generated
        }
    
    def batch_generate(self, batch_messages, max_tokens=256):
        """Optimized batch generation"""
        
        # Format all inputs
        formatted_texts = []
        for messages in batch_messages:
            formatted_text = self.tokenizer.apply_chat_template(
                messages,
                tokenize=False,
                add_generation_prompt=True
            )
            formatted_texts.append(formatted_text)
        
        # Tokenize batch with padding
        inputs = self.tokenizer(
            formatted_texts,
            return_tensors="pt",
            padding=True,
            truncation=True,
            max_length=2048
        ).to(self.model.device)
        
        start_time = time.time()
        
        with torch.no_grad():
            outputs = self.model.generate(
                **inputs,
                max_new_tokens=max_tokens,
                do_sample=True,
                temperature=0.7,
                top_p=0.9,
                use_cache=True,
                pad_token_id=self.tokenizer.eos_token_id,
                early_stopping=True
            )
        
        # Extract all responses
        responses = []
        for i, output in enumerate(outputs):
            response = self.tokenizer.decode(
                output[inputs.input_ids[i].shape[0]:],
                skip_special_tokens=True
            )
            responses.append(response.strip())
        
        generation_time = time.time() - start_time
        
        return {
            "responses": responses,
            "batch_generation_time": generation_time,
            "average_time_per_item": generation_time / len(batch_messages)
        }

# Example usage
tokenizer = AutoTokenizer.from_pretrained("google/gemma-3-8b-it")
model = load_optimized_gemma("google/gemma-3-8b-it", "balanced")

optimized_inference = OptimizedGemmaInference(model, tokenizer)

# Single optimized generation
test_messages = [{"role": "user", "content": "Explain machine learning in simple terms"}]
result = optimized_inference.fast_generate(test_messages)
print(f"Response: {result['response']}")
print(f"Speed: {result['tokens_per_second']:.1f} tokens/second")
```

## Най-добри практики и насоки

### Сигурност и поверителност

```python
import hashlib
import time
import re
from typing import List, Dict, Optional
import logging

class SecureGemmaService:
    """Security-focused Gemma service implementation"""
    
    def __init__(self, model_name: str, max_requests_per_hour: int = 100):
        self.model_name = model_name
        self.max_requests_per_hour = max_requests_per_hour
        self.model = None
        self.tokenizer = None
        self.request_logs = {}
        self.logger = logging.getLogger("SecureGemmaService")
        self._load_model()
    
    def _load_model(self):
        """Load model with security considerations"""
        from transformers import AutoModelForCausalLM, AutoTokenizer
        
        self.tokenizer = AutoTokenizer.from_pretrained(
            self.model_name,
            trust_remote_code=True  # Only enable for trusted models
        )
        
        self.model = AutoModelForCausalLM.from_pretrained(
            self.model_name,
            torch_dtype=torch.bfloat16,
            device_map="auto",
            trust_remote_code=True
        )
    
    def _sanitize_input(self, text: str) -> str:
        """Comprehensive input sanitization"""
        if not isinstance(text, str):
            raise ValueError("Input must be a string")
        
        # Remove potentially harmful patterns
        dangerous_patterns = [
            r"<script[^>]*>.*?</script>",
            r"javascript:",
            r"data:text/html",
            r"<iframe[^>]*>.*?</iframe>",
            r"<object[^>]*>.*?</object>",
            r"<embed[^>]*>.*?</embed>"
        ]
        
        sanitized = text
        for pattern in dangerous_patterns:
            sanitized = re.sub(pattern, "", sanitized, flags=re.IGNORECASE | re.DOTALL)
        
        # Limit length to prevent resource exhaustion
        max_length = 8192
        if len(sanitized) > max_length:
            sanitized = sanitized[:max_length]
            self.logger.warning(f"Input truncated to {max_length} characters")
        
        return sanitized
    
    def _rate_limit_check(self, user_id: str) -> bool:
        """Advanced rate limiting with sliding window"""
        current_time = time.time()
        window_size = 3600  # 1 hour in seconds
        
        if user_id not in self.request_logs:
            self.request_logs[user_id] = []
        
        # Clean old requests outside the time window
        self.request_logs[user_id] = [
            req_time for req_time in self.request_logs[user_id]
            if current_time - req_time < window_size
        ]
        
        # Check if limit exceeded
        if len(self.request_logs[user_id]) >= self.max_requests_per_hour:
            self.logger.warning(f"Rate limit exceeded for user {user_id[:8]}...")
            return False
        
        # Log current request
        self.request_logs[user_id].append(current_time)
        return True
    
    def _validate_messages(self, messages: List[Dict[str, str]]) -> List[Dict[str, str]]:
        """Validate and sanitize message structure"""
        if not isinstance(messages, list):
            raise ValueError("Messages must be a list")
        
        if len(messages) == 0:
            raise ValueError("Messages list cannot be empty")
        
        if len(messages) > 50:  # Reasonable conversation limit
            raise ValueError("Too many messages in conversation")
        
        validated_messages = []
        for message in messages:
            if not isinstance(message, dict):
                raise ValueError("Each message must be a dictionary")
            
            if "role" not in message or "content" not in message:
                raise ValueError("Each message must have 'role' and 'content' fields")
            
            # Validate role
            valid_roles = ["user", "assistant", "system"]
            if message["role"] not in valid_roles:
                raise ValueError(f"Invalid role: {message['role']}")
            
            # Sanitize content
            sanitized_content = self._sanitize_input(message["content"])
            
            validated_messages.append({
                "role": message["role"],
                "content": sanitized_content
            })
        
        return validated_messages
    
    def _content_filter(self, text: str) -> tuple[bool, str]:
        """Basic content filtering for inappropriate content"""
        # This is a simplified example - in production, use more sophisticated filtering
        prohibited_keywords = [
            "violence", "hate", "illegal", "harmful",
            # Add more as needed for your use case
        ]
        
        text_lower = text.lower()
        for keyword in prohibited_keywords:
            if keyword in text_lower:
                return False, f"Content contains prohibited keyword: {keyword}"
        
        return True, ""
    
    def _hash_sensitive_data(self, data: str) -> str:
        """Hash sensitive data for logging"""
        return hashlib.sha256(data.encode()).hexdigest()[:16]
    
    def secure_generate(
        self, 
        messages: List[Dict[str, str]], 
        user_id: str,
        max_tokens: int = 512
    ) -> Dict[str, any]:
        """Generate response with comprehensive security measures"""
        
        try:
            # Rate limiting
            if not self._rate_limit_check(user_id):
                return {
                    "success": False,
                    "error": "Rate limit exceeded. Please try again later.",
                    "error_code": "RATE_LIMIT_EXCEEDED"
                }
            
            # Input validation
            validated_messages = self._validate_messages(messages)
            
            # Content filtering
            for message in validated_messages:
                is_safe, filter_message = self._content_filter(message["content"])
                if not is_safe:
                    self.logger.warning(f"Content filtered for user {user_id[:8]}...: {filter_message}")
                    return {
                        "success": False,
                        "error": "Content violates safety guidelines",
                        "error_code": "CONTENT_FILTERED"
                    }
            
            # Log request (with hashed content for privacy)
            content_hash = self._hash_sensitive_data(str(validated_messages))
            self.logger.info(f"Processing request from user {user_id[:8]}... Content hash: {content_hash}")
            
            # Validate token limit
            max_allowed_tokens = min(max_tokens, 1024)
            
            # Generate response
            start_time = time.time()
            
            formatted_prompt = self.tokenizer.apply_chat_template(
                validated_messages,
                tokenize=False,
                add_generation_prompt=True
            )
            
            inputs = self.tokenizer(formatted_prompt, return_tensors="pt").to(self.model.device)
            
            with torch.no_grad():
                outputs = self.model.generate(
                    **inputs,
                    max_new_tokens=max_allowed_tokens,
                    temperature=0.7,
                    top_p=0.9,
                    repetition_penalty=1.05,
                    do_sample=True,
                    pad_token_id=self.tokenizer.eos_token_id,
                    early_stopping=True
                )
            
            response = self.tokenizer.decode(
                outputs[0][inputs.input_ids.shape[1]:],
                skip_special_tokens=True
            ).strip()
            
            generation_time = time.time() - start_time
            
            # Filter response content
            is_safe_response, filter_message = self._content_filter(response)
            if not is_safe_response:
                self.logger.warning(f"Response filtered for user {user_id[:8]}...: {filter_message}")
                return {
                    "success": False,
                    "error": "Generated response violates safety guidelines",
                    "error_code": "RESPONSE_FILTERED"
                }
            
            # Log successful generation
            self.logger.info(f"Successful generation for user {user_id[:8]}... in {generation_time:.2f}s")
            
            return {
                "success": True,
                "response": response,
                "generation_time": generation_time,
                "tokens_used": max_allowed_tokens
            }
            
        except ValueError as e:
            self.logger.error(f"Validation error for user {user_id[:8]}...: {str(e)}")
            return {
                "success": False,
                "error": f"Input validation failed: {str(e)}",
                "error_code": "VALIDATION_ERROR"
            }
        
        except Exception as e:
            self.logger.error(f"Generation error for user {user_id[:8]}...: {str(e)}")
            return {
                "success": False,
                "error": "An error occurred while processing your request",
                "error_code": "GENERATION_ERROR"
            }
    
    def get_usage_statistics(self, user_id: str) -> Dict[str, any]:
        """Get usage statistics for a user"""
        current_time = time.time()
        window_size = 3600  # 1 hour
        
        if user_id not in self.request_logs:
            return {
                "requests_last_hour": 0,
                "remaining_requests": self.max_requests_per_hour,
                "reset_time": current_time + window_size
            }
        
        # Count recent requests
        recent_requests = [
            req_time for req_time in self.request_logs[user_id]
            if current_time - req_time < window_size
        ]
        
        requests_last_hour = len(recent_requests)
        remaining_requests = max(0, self.max_requests_per_hour - requests_last_hour)
        
        # Calculate reset time (when oldest request expires)
        reset_time = min(recent_requests) + window_size if recent_requests else current_time
        
        return {
            "requests_last_hour": requests_last_hour,
            "remaining_requests": remaining_requests,
            "reset_time": reset_time
        }

# Example secure usage
secure_service = SecureGemmaService("google/gemma-3-8b-it", max_requests_per_hour=50)

# Safe generation
user_messages = [
    {"role": "user", "content": "Explain the benefits of renewable energy"}
]

result = secure_service.secure_generate(user_messages, user_id="user123")

if result["success"]:
    print(f"Secure Response: {result['response']}")
else:
    print(f"Error: {result['error']} (Code: {result['error_code']})")

# Check usage statistics
usage_stats = secure_service.get_usage_statistics("user123")
print(f"Usage Statistics: {usage_stats}")
```

### Мониторинг и оценка

```python
import time
import psutil
import torch
from dataclasses import dataclass, asdict
from typing import List, Dict, Any, Optional
import json
from datetime import datetime
import statistics

@dataclass
class PerformanceMetrics:
    """Comprehensive performance metrics for Gemma models"""
    timestamp: float
    response_time: float
    memory_usage_mb: float
    gpu_memory_mb: float
    token_count: int
    tokens_per_second: float
    model_name: str
    input_length: int
    success: bool
    error_message: Optional[str] = None

@dataclass
class QualityMetrics:
    """Quality assessment metrics"""
    relevance_score: float  # 0-1
    coherence_score: float  # 0-1
    safety_score: float     # 0-1
    factual_accuracy: float # 0-1
    user_satisfaction: Optional[float] = None  # 0-1

class GemmaMonitoringService:
    """Comprehensive monitoring service for Gemma models"""
    
    def __init__(self, model_name: str):
        self.model_name = model_name
        self.performance_history: List[PerformanceMetrics] = []
        self.quality_history: List[QualityMetrics] = []
        self.alert_thresholds = {
            "max_response_time": 10.0,  # seconds
            "max_memory_usage": 8192,   # MB
            "min_tokens_per_second": 5.0,
            "min_success_rate": 0.95    # 95%
        }
    
    def measure_performance(
        self, 
        model, 
        tokenizer, 
        messages: List[Dict[str, str]],
        expected_tokens: int = 256
    ) -> PerformanceMetrics:
        """Comprehensive performance measurement"""
        
        start_time = time.time()
        start_memory = psutil.Process().memory_info().rss / 1024 / 1024  # MB
        
        # GPU metrics
        gpu_memory = 0
        if torch.cuda.is_available():
            torch.cuda.reset_peak_memory_stats()
            gpu_memory = torch.cuda.memory_allocated() / 1024 / 1024  # MB
        
        success = True
        error_message = None
        token_count = 0
        
        try:
            # Format input
            formatted_text = tokenizer.apply_chat_template(
                messages,
                tokenize=False,
                add_generation_prompt=True
            )
            
            input_length = len(tokenizer.encode(formatted_text))
            
            inputs = tokenizer(formatted_text, return_tensors="pt").to(model.device)
            
            # Generate response
            with torch.no_grad():
                outputs = model.generate(
                    **inputs,
                    max_new_tokens=expected_tokens,
                    temperature=0.7,
                    do_sample=True,
                    pad_token_id=tokenizer.eos_token_id
                )
            
            token_count = outputs.shape[1] - inputs.input_ids.shape[1]
            
        except Exception as e:
            success = False
            error_message = str(e)
            input_length = 0
        
        # Calculate final metrics
        end_time = time.time()
        end_memory = psutil.Process().memory_info().rss / 1024 / 1024
        
        response_time = end_time - start_time
        memory_usage = end_memory - start_memory
        
        if torch.cuda.is_available():
            gpu_memory = torch.cuda.max_memory_allocated() / 1024 / 1024
        
        tokens_per_second = token_count / response_time if response_time > 0 and success else 0
        
        metrics = PerformanceMetrics(
            timestamp=start_time,
            response_time=response_time,
            memory_usage_mb=memory_usage,
            gpu_memory_mb=gpu_memory,
            token_count=token_count,
            tokens_per_second=tokens_per_second,
            model_name=self.model_name,
            input_length=input_length,
            success=success,
            error_message=error_message
        )
        
        self.performance_history.append(metrics)
        return metrics
    
    def evaluate_quality(
        self, 
        input_text: str, 
        generated_text: str,
        reference_text: Optional[str] = None
    ) -> QualityMetrics:
        """Evaluate response quality using various metrics"""
        
        # Simple quality assessment (in production, use more sophisticated methods)
        relevance_score = self._assess_relevance(input_text, generated_text)
        coherence_score = self._assess_coherence(generated_text)
        safety_score = self._assess_safety(generated_text)
        factual_accuracy = self._assess_factual_accuracy(generated_text, reference_text)
        
        quality_metrics = QualityMetrics(
            relevance_score=relevance_score,
            coherence_score=coherence_score,
            safety_score=safety_score,
            factual_accuracy=factual_accuracy
        )
        
        self.quality_history.append(quality_metrics)
        return quality_metrics
    
    def _assess_relevance(self, input_text: str, output_text: str) -> float:
        """Simple relevance assessment based on keyword overlap"""
        input_words = set(input_text.lower().split())
        output_words = set(output_text.lower().split())
        
        if len(input_words) == 0:
            return 0.0
        
        overlap = len(input_words.intersection(output_words))
        return min(1.0, overlap / len(input_words) * 2)  # Scale appropriately
    
    def _assess_coherence(self, text: str) -> float:
        """Simple coherence assessment"""
        sentences = text.split('.')
        if len(sentences) < 2:
            return 0.8  # Short text, assume reasonably coherent
        
        # Simple heuristic: check for reasonable sentence length
        avg_sentence_length = sum(len(s.split()) for s in sentences) / len(sentences)
        
        if 5 <= avg_sentence_length <= 25:
            return 0.9
        elif 3 <= avg_sentence_length <= 30:
            return 0.7
        else:
            return 0.5
    
    def _assess_safety(self, text: str) -> float:
        """Simple safety assessment"""
        harmful_indicators = [
            "violence", "harmful", "dangerous", "illegal",
            "hate", "discriminat", "threaten"
        ]
        
        text_lower = text.lower()
        harmful_count = sum(1 for indicator in harmful_indicators if indicator in text_lower)
        
        if harmful_count == 0:
            return 1.0
        elif harmful_count <= 2:
            return 0.7
        else:
            return 0.3
    
    def _assess_factual_accuracy(self, text: str, reference: Optional[str] = None) -> float:
        """Simple factual accuracy assessment"""
        if reference is None:
            # Without reference, use simple heuristics
            confidence_indicators = [
                "according to", "research shows", "studies indicate",
                "data suggests", "evidence shows"
            ]
            
            text_lower = text.lower()
            confidence_count = sum(1 for indicator in confidence_indicators if indicator in text_lower)
            
            return min(0.8, 0.5 + confidence_count * 0.1)
        
        # With reference, calculate similarity (simplified)
        ref_words = set(reference.lower().split())
        text_words = set(text.lower().split())
        
        if len(ref_words) == 0:
            return 0.5
        
        overlap = len(ref_words.intersection(text_words))
        return min(1.0, overlap / len(ref_words))
    
    def get_performance_summary(self, last_n: int = 100) -> Dict[str, Any]:
        """Get comprehensive performance summary"""
        if not self.performance_history:
            return {"error": "No performance data available"}
        
        recent_metrics = self.performance_history[-last_n:]
        successful_metrics = [m for m in recent_metrics if m.success]
        
        if not successful_metrics:
            return {"error": "No successful operations in recent history"}
        
        summary = {
            "total_requests": len(recent_metrics),
            "successful_requests": len(successful_metrics),
            "success_rate": len(successful_metrics) / len(recent_metrics),
            "avg_response_time": statistics.mean(m.response_time for m in successful_metrics),
            "avg_memory_usage": statistics.mean(m.memory_usage_mb for m in successful_metrics),
            "avg_tokens_per_second": statistics.mean(m.tokens_per_second for m in successful_metrics),
            "p95_response_time": statistics.quantiles([m.response_time for m in successful_metrics], n=20)[18],
            "total_tokens_generated": sum(m.token_count for m in successful_metrics),
        }
        
        if torch.cuda.is_available():
            summary["avg_gpu_memory"] = statistics.mean(m.gpu_memory_mb for m in successful_metrics)
        
        return summary
    
    def get_quality_summary(self, last_n: int = 100) -> Dict[str, Any]:
        """Get quality metrics summary"""
        if not self.quality_history:
            return {"error": "No quality data available"}
        
        recent_quality = self.quality_history[-last_n:]
        
        return {
            "total_evaluations": len(recent_quality),
            "avg_relevance": statistics.mean(q.relevance_score for q in recent_quality),
            "avg_coherence": statistics.mean(q.coherence_score for q in recent_quality),
            "avg_safety": statistics.mean(q.safety_score for q in recent_quality),
            "avg_factual_accuracy": statistics.mean(q.factual_accuracy for q in recent_quality),
            "overall_quality": statistics.mean([
                (q.relevance_score + q.coherence_score + q.safety_score + q.factual_accuracy) / 4
                for q in recent_quality
            ])
        }
    
    def check_alerts(self) -> List[Dict[str, Any]]:
        """Check for performance alerts"""
        alerts = []
        
        if not self.performance_history:
            return alerts
        
        recent_metrics = self.performance_history[-10:]  # Last 10 requests
        successful_metrics = [m for m in recent_metrics if m.success]
        
        if not successful_metrics:
            alerts.append({
                "type": "error",
                "message": "No successful requests in recent history",
                "severity": "high",
                "timestamp": time.time()
            })
            return alerts
        
        # Check response time
        avg_response_time = statistics.mean(m.response_time for m in successful_metrics)
        if avg_response_time > self.alert_thresholds["max_response_time"]:
            alerts.append({
                "type": "performance",
                "message": f"High response time: {avg_response_time:.2f}s (threshold: {self.alert_thresholds['max_response_time']}s)",
                "severity": "medium",
                "timestamp": time.time()
            })
        
        # Check memory usage
        avg_memory = statistics.mean(m.memory_usage_mb for m in successful_metrics)
        if avg_memory > self.alert_thresholds["max_memory_usage"]:
            alerts.append({
                "type": "memory",
                "message": f"High memory usage: {avg_memory:.1f}MB (threshold: {self.alert_thresholds['max_memory_usage']}MB)",
                "severity": "medium",
                "timestamp": time.time()
            })
        
        # Check tokens per second
        avg_tps = statistics.mean(m.tokens_per_second for m in successful_metrics)
        if avg_tps < self.alert_thresholds["min_tokens_per_second"]:
            alerts.append({
                "type": "performance",
                "message": f"Low generation speed: {avg_tps:.1f} tokens/s (threshold: {self.alert_thresholds['min_tokens_per_second']} tokens/s)",
                "severity": "low",
                "timestamp": time.time()
            })
        
        # Check success rate
        success_rate = len(successful_metrics) / len(recent_metrics)
        if success_rate < self.alert_thresholds["min_success_rate"]:
            alerts.append({
                "type": "reliability",
                "message": f"Low success rate: {success_rate:.2%} (threshold: {self.alert_thresholds['min_success_rate']:.2%})",
                "severity": "high",
                "timestamp": time.time()
            })
        
        return alerts
    
    def export_metrics(self, filepath: str):
        """Export metrics to JSON file"""
        export_data = {
            "model_name": self.model_name,
            "export_timestamp": datetime.now().isoformat(),
            "performance_metrics": [asdict(m) for m in self.performance_history],
            "quality_metrics": [asdict(q) for q in self.quality_history],
            "performance_summary": self.get_performance_summary(),
            "quality_summary": self.get_quality_summary(),
            "current_alerts": self.check_alerts()
        }
        
        with open(filepath, 'w') as f:
            json.dump(export_data, f, indent=2)

# Example monitoring usage
def monitoring_example():
    """Example of comprehensive Gemma monitoring"""
    
    # Initialize monitoring
    monitor = GemmaMonitoringService("google/gemma-3-8b-it")
    
    # Load model for testing
    from transformers import AutoModelForCausalLM, AutoTokenizer
    
    model = AutoModelForCausalLM.from_pretrained(
        "google/gemma-3-8b-it",
        torch_dtype=torch.bfloat16,
        device_map="auto"
    )
    
    tokenizer = AutoTokenizer.from_pretrained("google/gemma-3-8b-it")
    
    # Test various scenarios
    test_scenarios = [
        [{"role": "user", "content": "What is machine learning?"}],
        [{"role": "user", "content": "Explain quantum computing in simple terms"}],
        [{"role": "user", "content": "Write a short story about AI"}],
        [{"role": "user", "content": "How does photosynthesis work?"}],
        [{"role": "user", "content": "What are the benefits of renewable energy?"}]
    ]
    
    print("Running performance tests...")
    for i, messages in enumerate(test_scenarios):
        print(f"Test {i+1}/5: {messages[0]['content'][:50]}...")
        
        # Measure performance
        perf_metrics = monitor.measure_performance(model, tokenizer, messages)
        print(f"  Response time: {perf_metrics.response_time:.2f}s")
        print(f"  Tokens/sec: {perf_metrics.tokens_per_second:.1f}")
        print(f"  Success: {perf_metrics.success}")
        
        if perf_metrics.success:
            # Generate actual response for quality evaluation
            formatted_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
            inputs = tokenizer(formatted_text, return_tensors="pt").to(model.device)
            
            with torch.no_grad():
                outputs = model.generate(**inputs, max_new_tokens=100, temperature=0.7)
            
            response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
            
            # Evaluate quality
            quality_metrics = monitor.evaluate_quality(messages[0]['content'], response)
            print(f"  Quality score: {(quality_metrics.relevance_score + quality_metrics.coherence_score + quality_metrics.safety_score + quality_metrics.factual_accuracy) / 4:.2f}")
        
        print()
    
    # Get comprehensive summary
    perf_summary = monitor.get_performance_summary()
    quality_summary = monitor.get_quality_summary()
    alerts = monitor.check_alerts()
    
    print("=== Performance Summary ===")
    print(f"Success Rate: {perf_summary.get('success_rate', 0):.2%}")
    print(f"Average Response Time: {perf_summary.get('avg_response_time', 0):.2f}s")
    print(f"Average Tokens/Second: {perf_summary.get('avg_tokens_per_second', 0):.1f}")
    print(f"Total Tokens Generated: {perf_summary.get('total_tokens_generated', 0)}")
    
    print("\n=== Quality Summary ===")
    print(f"Overall Quality Score: {quality_summary.get('overall_quality', 0):.2f}")
    print(f"Average Relevance: {quality_summary.get('avg_relevance', 0):.2f}")
    print(f"Average Safety: {quality_summary.get('avg_safety', 0):.2f}")
    
    print(f"\n=== Alerts ({len(alerts)}) ===")
    for alert in alerts:
        print(f"[{alert['severity'].upper()}] {alert['type']}: {alert['message']}")
    
    # Export metrics
    monitor.export_metrics("gemma_monitoring_report.json")
    print("\nMetrics exported to gemma_monitoring_report.json")

# Run monitoring example
# monitoring_example()
```

## Заключение

Семейството модели Gemma представлява цялостния подход на Google към демократизацията на AI технологиите, като същевременно поддържа конкурентна производителност в разнообразни приложения и сценарии за внедрение. Чрез ангажимента си към достъпността на отворения код, мултимодалните възможности и иновативните архитектурни дизайни, Gemma позволява на организациите и разработчиците да използват мощни AI възможности, независимо от техните ресурси или специфични изисквания.

### Основни изводи

**Отличие на отворения код**: Gemma демонстрира, че моделите с отворен код могат да постигнат производителност, конкурентна на собствени алтернативи, като същевременно предоставят прозрачност, персонализация и контрол върху внедрението на AI.

**Мултимодална иновация**: Интеграцията на текст, визия и аудио възможности в Gemma 3 и Gemma 3n представлява значителен напредък в достъпния мултимодален AI, позволявайки цялостно разбиране на различни типове вход.

**Архитектура, ориентирана към мобилни устройства**: Пробивната технология Per-Layer Embeddings (PLE) на Gemma 3n и оптимизацията за мобилни устройства демонстрират, че мощният AI може да работи ефективно на устройства с ограничени ресурси, без да жертва възможностите.

**Скалирано внедрение**: Диапазонът от 1B до 27B параметри, със специализирани мобилни варианти, позволява внедрение в целия спектър от изчислителни среди, като същевременно поддържа последователно качество и производителност.

**Отговорна интеграция на AI**: Вградените мерки за безопасност чрез ShieldGemma 2 и отговорните практики за разработка гарантират, че мощните AI възможности могат да бъдат внедрени безопасно и етично.

### Бъдещи перспективи

С развитието на семейството Gemma можем да очакваме:

**Подобрени мобилни възможности**: Допълнителна оптимизация за мобилни и edge внедрения с интеграция на архитектурата Gemma 3n в основни платформи като Android и Chrome.

**Разширено мултимодално разбиране**: Продължаващ напредък в интеграцията на визия, език и аудио за по-цялостни AI изживявания.

**Подобрена ефективност**: Постоянни архитектурни иновации за по-добри съотношения производителност-параметър и намалени изчислителни изисквания.

**По-широка интеграция в екосистемата**: Подобрена поддръжка в рамките на рамки за разработка, облачни платформи и инструменти за внедрение за безпроблемна интеграция в съществуващи работни потоци.

**Растеж на общността**: Продължаващо разширяване на Gemmaverse с модели, инструменти и приложения, създадени от общността, които разширяват основните възможности.

### Следващи стъпки

Независимо дали създавате мобилни приложения с AI възможности в реално време, разработвате мултимодални образователни инструменти, създавате интелигентни автоматизирани системи или работите върху глобални приложения, изискващи многоезична поддръжка, семейството Gemma предоставя скалируеми решения със силна общностна подкрепа и подробна документация.

**Препоръки за започване:**
1. **Експериментирайте с Google AI Studio** за незабавен практически опит
2. **Изтеглете модели от Hugging Face** за локална разработка и персонализация
3. **Разгледайте специализирани варианти** като Gemma 3n за мобилни приложения
4. **Внедрете мултимодални възможности** за цялостни AI изживявания
5. **Следвайте най-добрите практики за сигурност** за производствени внедрения

**За мобилна разработка**: Започнете с Gemma 3n E2B за ресурсно ефективно внедрение с аудио и визуални възможности.

**За корпоративни приложения**: Обмислете модели Gemma 3-12B или 27B за максимални възможности с извикване на функции и напреднали разсъждения.

**За глобални приложения**: Използвайте поддръжката на 140+ езика на Gemma с културно осъзнато инженерство на подсказки.

**За специализирани случаи на употреба**: Разгледайте подходи за фина настройка и техники за оптимизация за конкретни домейни.

### 🔮 Демократизацията на AI

Семейството Gemma е пример за бъдещето на AI разработката, където мощни, способни модели са достъпни за всеки – от индивидуални разработчици до големи предприятия. Чрез комбиниране на авангардни изследвания с достъпност на отворения код, Google създаде основа, която позволява иновации във всички сектори и мащаби.

Успехът на Gemma с над 100 милиона изтегляния и 60,000+ варианти, създадени от общността, демонстрира силата на отвореното сътрудничество в напредъка на AI технологиите. С напредването си, семейството Gemma ще продължи да служи като катализатор за AI иновации, позволявайки разработването на приложения, които преди бяха възможни само със собствени, скъпи модели.

Бъдещето на AI е отворено, достъпно и мощно – и семейството Gemma води пътя към реализирането на тази визия.

## Допълнителни ресурси

**Официална документация и модели:**
- **Google AI Studio**: [Изпробвайте моделите Gemma директно](https://aistudio.google.com)
- **Hugging Face Collections**: 
  - [Gemma 3 Release](https://huggingface.co/collections/google/gemma-3-release-67c6c6f89c4f76621268bb6d)
  - [Gemma 3n Preview](https://huggingface.co/collections/google/gemma-3n-685065323f5984ef315c93f4)
- **Google AI Developer Documentation**: [Подробни ръководства за Gemma](https://ai.google.dev/gemma)
- **Vertex AI Documentation**: [Ръководства за корпоративно внедрение](https://cloud.google.com/vertex-ai/generative-ai/docs/open-models/use-gemma)

**Технически ресурси:**
- **Изследователски статии и технически доклади**: [Публикации на Google DeepMind](https://deepmind.google/models/gemma/)
- **Блогове за разработчици**: [Последни съобщения и уроци](https://developers.googleblog.com)
- **Карти на модели**: Подробни технически спецификации и показатели за производителност

**Общност и поддръжка:**
- **Hugging Face Community**: Активни дискусии и примери от общността
- **GitHub Repositories**: Реализации с отворен код и инструменти
- **Форуми за разработчици**: Поддръжка от общността на Google AI Developer
- **Stack Overflow**: Въпроси с тагове и решения от общността

**Инструменти за разработка:**
- **Ollama**: [Опростено локално внедрение](https://ollama.ai)
- **vLLM**: [Високопроизводително обслужване](https://github.com/vllm-project/vllm)
- **Transformers Library**: [Интеграция с Hugging Face](https://huggingface.co/docs/transformers)
- **Google AI Edge**: Оптимизация за мобилни и edge внедрения

**Пътища за обучение:**
- **Начинаещи**: Започнете с Google AI Studio → Примери от Hugging Face → Локално внедрение
- **Разработчици**: Интеграция с Transformers → Персонализирани приложения → Производствено внедрение
- **Изследователи**: Технически статии → Фина настройка → Нови приложения
- **Предприятия**: Внедрение с Vertex AI → Имплементация на сигурност → Оптимизация на мащаба

Семейството модели Gemma представлява не просто колекция от AI модели, но цялостна екосистема за изграждане на бъдещето на достъпни, мощни и отговорни AI приложения. Започнете да изследвате днес и се присъединете към растящата общност от разработчици и изследователи, които разширяват границите на възможното с AI с отворен код.

---

**Отказ от отговорност**:  
Този документ е преведен с помощта на AI услуга за превод [Co-op Translator](https://github.com/Azure/co-op-translator). Въпреки че се стремим към точност, моля, имайте предвид, че автоматизираните преводи може да съдържат грешки или неточности. Оригиналният документ на неговия роден език трябва да се счита за авторитетен източник. За критична информация се препоръчва професионален човешки превод. Ние не носим отговорност за каквито и да било недоразумения или погрешни интерпретации, произтичащи от използването на този превод.