1. Введение в LLM

Что такое LLM?
Large Language Models (большие языковые модели) - это нейросетевые модели, обученные на огромных объемах текстовых данных. Они могут:

• Генерировать текст
• Отвечать на вопросы
• Переводить языки
• Писать код
• Анализировать текст

Популярные LLM:

• GPT (OpenAI)
• LLaMA (Meta)
• Claude (Anthropic)
• Gemini (Google)

2. Основные подходы к использованию LLM

2.1 Использование API (OpenAI, Anthropic и др.)

# Установка необходимых библиотек
# pip install openai anthropic google-generativeai

import openai
from anthropic import Anthropic
import google.generativeai as genai
import os
from dotenv import load_dotenv

# Загрузка переменных окружения
load_dotenv()

2.2 Локальные модели (через трансформеры)

# Установка
# pip install transformers torch accelerate

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

3. Практические примеры

3.1 Работа с OpenAI API

# Пример с OpenAI GPT
def chat_with_gpt(prompt, model="gpt-3.5-turbo"):
    """
    Функция для общения с GPT через API
    """
    openai.api_key = os.getenv("OPENAI_API_KEY")
    
    try:
        response = openai.ChatCompletion.create(
            model=model,
            messages=[
                {"role": "system", "content": "Ты полезный ассистент."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7,
            max_tokens=500
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"Ошибка: {str(e)}"

# Использование
result = chat_with_gpt("Напиши короткое стихотворение о Python")
print(result)

3.2 Работа с локальной моделью (Hugging Face)

def load_local_model(model_name="gpt2"):
    """
    Загрузка локальной модели из Hugging Face
    """
    print(f"Загрузка модели {model_name}...")
    
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.float16,
        device_map="auto"
    )
    
    return tokenizer, model

def generate_text(prompt, tokenizer, model, max_length=100):
    """
    Генерация текста с помощью локальной модели
    """
    inputs = tokenizer(prompt, return_tensors="pt")
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_length=max_length,
            temperature=0.7,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id
        )
    
    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return generated_text

# Пример использования
# tokenizer, model = load_local_model("gpt2")
# result = generate_text("Python - это", tokenizer, model)
# print(result)

3.3 Использование Google Gemini

def setup_gemini():
    """
    Настройка Gemini API
    """
    genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
    
    model = genai.GenerativeModel('gemini-pro')
    return model

def chat_with_gemini(prompt, model):
    """
    Общение с Gemini
    """
    response = model.generate_content(prompt)
    return response.text

# Пример использования
# model = setup_gemini()
# response = chat_with_gemini("Объясни, что такое машинное обучение", model)

4. Продвинутые техники

4.1 Контекстное управление (Few-shot learning)

def few_shot_example():
    """
    Пример few-shot обучения через промпт
    """
    prompt = """
    Переведи с английского на русский:
    
    Английский: Hello, how are you?
    Русский: Привет, как дела?
    
    Английский: I love programming
    Русский: Я люблю программирование
    
    Английский: The weather is beautiful today
    Русский: """
    
    return chat_with_gpt(prompt)

print(few_shot_example())

4.2 Построение чат-бота

class ChatBot:
    def __init__(self, api_type="openai"):
        self.api_type = api_type
        self.conversation_history = []
        
        if api_type == "openai":
            openai.api_key = os.getenv("OPENAI_API_KEY")
    
    def add_message(self, role, content):
        """Добавление сообщения в историю"""
        self.conversation_history.append({
            "role": role,
            "content": content
        })
    
    def get_response(self, user_message):
        """Получение ответа от модели"""
        self.add_message("user", user_message)
        
        if self.api_type == "openai":
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=self.conversation_history,
                temperature=0.7
            )
            assistant_message = response.choices[0].message.content
        
        self.add_message("assistant", assistant_message)
        return assistant_message
    
    def chat_loop(self):
        """Интерактивный чат-режим"""
        print("Чат-бот запущен! Введите 'выход' для завершения.")
        print("-" * 50)
        
        while True:
            user_input = input("\nВы: ")
            
            if user_input.lower() in ['выход', 'exit', 'quit']:
                print("До свидания!")
                break
            
            response = self.get_response(user_input)
            print(f"\nБот: {response}")

# Запуск бота
# bot = ChatBot()
# bot.chat_loop()

4.3 Анализ настроений (Sentiment Analysis)

def analyze_sentiment(text):
    """
    Анализ настроений текста с помощью LLM
    """
    prompt = f"""
    Проанализируй настроение следующего текста и классифицируй его как:
    - ПОЛОЖИТЕЛЬНЫЙ
    - НЕГАТИВНЫЙ
    - НЕЙТРАЛЬНЫЙ
    
    Текст: "{text}"
    
    Ответ предоставь в формате:
    Настроение: [КАТЕГОРИЯ]
    Объяснение: [КРАТКОЕ ОБЪЯСНЕНИЕ]
    """
    
    return chat_with_gpt(prompt)

# Пример
texts = [
    "Я обожаю эту библиотеку, она работает прекрасно!",
    "Ужасный сервис, никогда больше не вернусь.",
    "Сегодня обычный день, ничего особенного."
]

for text in texts:
    print(f"Текст: {text}")
    print(analyze_sentiment(text))
    print("-" * 50)

5. Оптимизация и лучшие практики

5.1 Управление токенами

def count_tokens(text, model_name="gpt-3.5-turbo"):
    """
    Подсчет токенов в тексте
    """
    import tiktoken
    
    encoding = tiktoken.encoding_for_model(model_name)
    tokens = encoding.encode(text)
    return len(tokens)

# Пример
text = "Привет, как твои дела?"
token_count = count_tokens(text)
print(f"Текст: {text}")
print(f"Количество токенов: {token_count}")

5.2 Кэширование ответов

from functools import lru_cache
import hashlib

@lru_cache(maxsize=100)
def get_cached_response(prompt, model="gpt-3.5-turbo"):
    """
    Кэширование запросов для экономии API вызовов
    """
    # Создаем хэш промпта для ключа кэша
    cache_key = hashlib.md5(f"{prompt}_{model}".encode()).hexdigest()
    
    # Здесь была бы логика проверки кэша
    # Для примера просто вызываем API
    return chat_with_gpt(prompt, model)

5.3 Обработка ошибок

class LLMHandler:
    def __init__(self, api_key, max_retries=3):
        self.api_key = api_key
        self.max_retries = max_retries
    
    def safe_api_call(self, prompt):
        """
        Безопасный вызов API с повторными попытками
        """
        for attempt in range(self.max_retries):
            try:
                response = chat_with_gpt(prompt)
                return response
            except Exception as e:
                print(f"Попытка {attempt + 1} не удалась: {str(e)}")
                if attempt == self.max_retries - 1:
                    return "Извините, сервис временно недоступен"
                time.sleep(2 ** attempt)  # Экспоненциальная задержка

6. Проект: Интеллектуальный помощник для программирования

class ProgrammingAssistant:
    def __init__(self):
        self.context = """
        Ты - эксперт по программированию на Python.
        Ты помогаешь разработчикам писать чистый, эффективный код.
        Ты объясняешь концепции простым языком.
        """
    
    def explain_concept(self, concept):
        """Объяснение концепции программирования"""
        prompt = f"{self.context}\n\nОбъясни понятие: {concept}"
        return chat_with_gpt(prompt)
    
    def debug_code(self, code, error):
        """Помощь в отладке кода"""
        prompt = f"""{self.context}
        
        Помоги исправить ошибку в коде:
        
        Код:
        ```python
        {code}
        ```
        
        Ошибка: {error}
        
        Предложи исправление и объясни, в чем была проблема.
        """
        return chat_with_gpt(prompt)
    
    def generate_code(self, description):
        """Генерация кода по описанию"""
        prompt = f"""{self.context}
        
        Напиши код на Python для следующей задачи:
        
        {description}
        
        Добавь комментарии к коду.
        """
        return chat_with_gpt(prompt)

# Пример использования
assistant = ProgrammingAssistant()

# Объяснение концепции
print(assistant.explain_concept("декораторы в Python"))

# Помощь с отладкой
buggy_code = """
def calculate_average(numbers):
    total = sum(numbers)
    return total / len(number)
"""
print(assistant.debug_code(buggy_code, "NameError: name 'number' is not defined"))

# Генерация кода
print(assistant.generate_code("Функция для проверки, является ли число простым"))

7. Домашнее задание

1. Задача 1: Создайте простого чат-бота, который запоминает контекст разговора
2. Задача 2: Реализуйте систему для анализа тональности отзывов
3. Задача 3: Напишите функцию, которая генерирует документацию для Python функций
4. Задача 4: Создайте консольного помощника для изучения программирования

8. Ресурсы для дальнейшего изучения

1. Документация:

   • OpenAI API: https://platform.openai.com/docs
   • Hugging Face: https://huggingface.co/docs
   • LangChain: https://python.langchain.com/

2. Библиотеки:

   • LangChain - для построения сложных LLM-приложений
   • LlamaIndex - для работы с векторными базами данных
   • FastAPI - для создания API

3. Локальные модели:

   • GPT4All
   • Ollama
   • Llama.cpp

9. Важные предупреждения

1. Конфиденциальность: Не отправляйте конфиденциальные данные в API
2. Стоимость: Следите за использованием токенов в платных API
3. Этика: Проверяйте вывод моделей на наличие bias и ошибок
4. Производительность: Оптимизируйте промпты для уменьшения токенов

Этот урок покрывает основные аспекты работы с LLM на Python. Начните с простых примеров и постепенно переходите к более сложным проектам!