# Оптимизация скорости обработки

## Текущая ситуация

- **Модель:** DeepSeek-V3.1-Terminus (через smolagents InferenceClientModel)
- **Время обработки:** ~2.5 минуты для 13 строк логов
- **Проблема:** Модель медленная из-за размера и API задержек

## Варианты ускорения

### 1. Использование более быстрых моделей DeepSeek

#### Вариант A: DeepSeek-R1 (более быстрая версия)
```python
model = InferenceClientModel(
    model_id="deepseek-ai/DeepSeek-R1",
    token=hf_token,
    max_tokens=4096
)
```
- **Плюсы:** Быстрее, меньше задержка
- **Минусы:** Может быть менее точной для сложных задач

#### Вариант B: DeepSeek-Coder (специализированная модель для кода/структурированных данных)
```python
model = InferenceClientModel(
    model_id="deepseek-ai/deepseek-coder-6.7b-instruct",
    token=hf_token,
    max_tokens=2048
)
```
- **Плюсы:** Оптимизирована для структурированных данных (JSON, логи)
- **Минусы:** Меньший контекст, может быть менее точной для анализа

### 2. Использование других быстрых моделей через HF Inference API

#### Qwen/Qwen2.5 (быстрая и качественная)
```python
model = InferenceClientModel(
    model_id="Qwen/Qwen2.5-7B-Instruct",
    token=hf_token,
    max_tokens=2048
)
```

#### Mistral (баланс скорости и качества)
```python
model = InferenceClientModel(
    model_id="mistralai/Mistral-7B-Instruct-v0.2",
    token=hf_token,
    max_tokens=2048
)
```

### 3. Оптимизация промптов и параметров

#### Уменьшение max_tokens для более коротких ответов
```python
model = InferenceClientModel(
    model_id="deepseek-ai/DeepSeek-V3.1-Terminus",
    token=hf_token,
    max_tokens=2048  # Вместо 4096 - быстрее генерация
)
```

#### Уменьшение max_steps для агентов
```python
parser_agent = ToolCallingAgent(
    model=model,
    tools=[final_tool],
    instructions="...",
    name="LogParserAgent",
    max_steps=5,  # Вместо 10 - меньше итераций
)
```

### 4. Параллельная обработка чанков

В `streaming_processor.py` можно добавить:
```python
from concurrent.futures import ThreadPoolExecutor

def process_chunks_parallel(chunks, max_workers=3):
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        results = executor.map(process_single_chunk, chunks)
    return list(results)
```

### 5. Кэширование результатов

Кэшировать результаты парсинга одинаковых строк:
```python
from functools import lru_cache
import hashlib

@lru_cache(maxsize=1000)
def cached_parse(log_hash: str, logs: str):
    return run_parser_agent(logs)
```

### 6. Использование локальной модели (если доступно)

Если есть GPU, можно использовать локальную модель вместо API:
```python
from transformers import AutoModelForCausalLM, AutoTokenizer
from smolagents import LocalModel

model = LocalModel(
    model_id="deepseek-ai/DeepSeek-V3.1-Terminus",
    device="cuda"  # или "cpu"
)
```

## Рекомендации

### Для максимальной скорости (уровень 1):
1. Использовать более быструю модель (Qwen2.5 или DeepSeek-R1)
2. Уменьшить max_tokens до 2048
3. Уменьшить max_steps до 5
4. Включить потоковую обработку для больших файлов

### Для баланса скорости и качества (уровень 2):
1. Оставить DeepSeek-V3.1-Terminus
2. Уменьшить max_tokens до 2048
3. Оптимизировать промпты (делать их короче и конкретнее)
4. Использовать потоковую обработку

### Для максимального качества (текущий уровень):
1. Оставить текущую настройку
2. Использовать retry механизм
3. Использовать потоковую обработку для больших файлов

## Пример реализации быстрой модели

Создать `agents/fast_agents.py`:
```python
import os
from smolagents import ToolCallingAgent, InferenceClientModel, FinalAnswerTool

hf_token = os.getenv("HF_TOKEN")

# Быстрая модель для быстрой обработки
fast_model = InferenceClientModel(
    model_id="Qwen/Qwen2.5-7B-Instruct",  # или "deepseek-ai/DeepSeek-R1"
    token=hf_token,
    max_tokens=2048,
    temperature=0.3  # Меньше творчества = быстрее
)

# Использовать fast_model вместо model для быстрых задач
```

## Тестирование скорости

Создать бенчмарк:
```python
import time
from test_logs.good_example_1_web_server import test_logs

start = time.time()
result = analyze_logs(test_logs)
end = time.time()

print(f"Время обработки: {end - start:.2f} секунд")
```

## Вывод

**Рекомендуемый подход:**
1. Добавить выбор модели в интерфейс (Fast/Standard)
2. Использовать Qwen2.5 для быстрого режима
3. Оставить DeepSeek-V3.1 для режима максимального качества
4. Включить потоковую обработку по умолчанию для файлов >500 строк