Шаблони проектування в Python для інженерів штучного інтелекту та магістра права: практичний посібник

Для інженерів штучного інтелекту створення чистого, ефективного коду, який можна підтримувати, є критично важливим, особливо під час створення складних систем.

Патерни проектування є багаторазовими рішеннями типових проблем у розробці програмного забезпечення. для Інженери ШІ та великої мовної моделі (LLM)., шаблони проектування допомагають створювати надійні, масштабовані та підтримувані системи, які ефективно обробляють складні робочі процеси. Ця стаття занурюється в шаблони проектування в Python, зосереджуючись на їх актуальності в ШІ та LLMсистеми на основі. Я поясню кожен шаблон за допомогою прикладів практичного використання ШІ та прикладів коду Python.

Давайте розглянемо деякі ключові шаблони проектування, які особливо корисні в контекстах штучного інтелекту та машинного навчання, разом із прикладами Python.

Чому шаблони проектування важливі для інженерів ШІ

Системи ШІ часто включають:

1. Створення складних об'єктів (наприклад, завантаження моделей, конвеєри попередньої обробки даних).
2. Керування взаємодією між компонентами (наприклад, висновок моделі, оновлення в реальному часі).
3. Масштабованість, ремонтопридатність і гнучкість для мінливих вимог.

Шаблони проектування вирішують ці проблеми, забезпечуючи чітку структуру та зменшуючи випадкові виправлення. Вони діляться на три основні категорії:

• Творчі моделі: Зосередьтеся на створенні об’єкта. (Синглтон, Фабрика, Будівельник)
• Структурні закономірності: організуйте зв’язки між об’єктами. (Адаптер, Декоратор)
• Патерни поведінки: Керуйте зв’язком між об’єктами. (Стратегія, Спостерігач)

1. Шаблон Singleton

Команда Одномісний візерунок гарантує, що клас має лише один екземпляр і забезпечує глобальну точку доступу до цього екземпляра. Це особливо цінно в робочих процесах штучного інтелекту, де спільними ресурсами, такими як параметри конфігурації, системи журналювання або екземпляри моделі, потрібно керувати послідовно без надмірності.

Коли використовувати

• Керування глобальними конфігураціями (наприклад, гіперпараметрами моделі).
• Спільне використання ресурсів між кількома потоками або процесами (наприклад, Пам'ять GPU).
• Забезпечення узгодженого доступу до єдиного двигун висновку або підключення до бази даних.

Реалізація

Ось як реалізувати шаблон Singleton у Python для керування конфігураціями для моделі ШІ:

class ModelConfig:
    """
    A Singleton class for managing global model configurations.
    """
    _instance = None  # Class variable to store the singleton instance

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            # Create a new instance if none exists
            cls._instance = super().__new__(cls)
            cls._instance.settings = {}  # Initialize configuration dictionary
        return cls._instance

    def set(self, key, value):
        """
        Set a configuration key-value pair.
        """
        self.settings[key] = value

    def get(self, key):
        """
        Get a configuration value by key.
        """
        return self.settings.get(key)

# Usage Example
config1 = ModelConfig()
config1.set("model_name", "GPT-4")
config1.set("batch_size", 32)

# Accessing the same instance
config2 = ModelConfig()
print(config2.get("model_name"))  # Output: GPT-4
print(config2.get("batch_size"))  # Output: 32
print(config1 is config2)  # Output: True (both are the same instance)

Пояснення

1. Команда __new__ Метод: це гарантує, що буде створено лише один екземпляр класу. Якщо екземпляр уже існує, він повертає існуючий.
2. Спільний стан: Обидва config1 та config2 вказують на той самий екземпляр, роблячи всі конфігурації глобально доступними та узгодженими.
3. Випадок використання ШІ: Використовуйте цей шаблон для керування глобальними параметрами, наприклад шляхами до наборів даних, конфігураціями журналювання або змінними середовища.

2. Фабричний шаблон

Команда Фабричний візерунок надає спосіб делегувати створення об’єктів підкласам або спеціальним фабричним методам. У системах ШІ цей шаблон ідеально підходить для створення різних типів моделей, завантажувачів даних або конвеєрів динамічно на основі контексту.

Коли використовувати

• Динамічне створення моделей на основі даних користувача або вимог завдання.
• Управління складною логікою створення об’єктів (наприклад, багатоетапними конвеєрами попередньої обробки).
• Відокремлення екземплярів об’єктів від решти системи для підвищення гнучкості.

Реалізація

Давайте створимо Factory для створення моделей для різних завдань ШІ, таких як класифікація тексту, підсумовування та переклад:

class BaseModel:
    """
    Abstract base class for AI models.
    """
    def predict(self, data):
        raise NotImplementedError("Subclasses must implement the `predict` method")

class TextClassificationModel(BaseModel):
    def predict(self, data):
        return f"Classifying text: {data}"

class SummarizationModel(BaseModel):
    def predict(self, data):
        return f"Summarizing text: {data}"

class TranslationModel(BaseModel):
    def predict(self, data):
        return f"Translating text: {data}"

class ModelFactory:
    """
    Factory class to create AI models dynamically.
    """
    @staticmethod
    def create_model(task_type):
        """
        Factory method to create models based on the task type.
        """
        task_mapping = {
            "classification": TextClassificationModel,
            "summarization": SummarizationModel,
            "translation": TranslationModel,
        }
        model_class = task_mapping.get(task_type)
        if not model_class:
            raise ValueError(f"Unknown task type: {task_type}")
        return model_class()

# Usage Example
task = "classification"
model = ModelFactory.create_model(task)
print(model.predict("AI will transform the world!"))
# Output: Classifying text: AI will transform the world!

Пояснення

1. Абстрактний базовий клас: BaseModel клас визначає інтерфейс (predict), які всі підкласи повинні реалізувати, забезпечуючи узгодженість.
2. Заводська логіка: ModelFactory динамічно вибирає відповідний клас на основі типу завдання та створює екземпляр.
3. Розширюваність: Додавання нового типу моделі просте — просто запровадьте новий підклас і оновіть заводські task_mapping.

Випадок використання ШІ

Уявіть, що ви розробляєте систему, яка вибирає інший LLM (наприклад, BERT, GPT або T5) на основі завдання. Шаблон Factory дозволяє легко розширювати систему, коли з’являються нові моделі, без зміни існуючого коду.

3. Шаблон будівельника

Команда Будівельник візерунком відокремлює конструкцію складного об'єкта від його представлення. Це корисно, коли ініціалізація або налаштування об’єкта вимагає кількох кроків.

Коли використовувати

• Побудова багатокрокових конвеєрів (наприклад, попередня обробка даних).
• Керування конфігураціями для експериментів або навчання моделі.
• Створення об'єктів, які потребують великої кількості параметрів, забезпечення читабельності та зручності обслуговування.

Реалізація

Ось як використовувати шаблон Builder для створення конвеєра попередньої обробки даних:

class DataPipeline:
    """
    Builder class for constructing a data preprocessing pipeline.
    """
    def __init__(self):
        self.steps = []

    def add_step(self, step_function):
        """
        Add a preprocessing step to the pipeline.
        """
        self.steps.append(step_function)
        return self  # Return self to enable method chaining

    def run(self, data):
        """
        Execute all steps in the pipeline.
        """
        for step in self.steps:
            data = step(data)
        return data

# Usage Example
pipeline = DataPipeline()
pipeline.add_step(lambda x: x.strip())  # Step 1: Strip whitespace
pipeline.add_step(lambda x: x.lower())  # Step 2: Convert to lowercase
pipeline.add_step(lambda x: x.replace(".", ""))  # Step 3: Remove periods

processed_data = pipeline.run("  Hello World. ")
print(processed_data)  # Output: hello world

Пояснення

1. Ланцюгові методи: add_step метод дозволяє об’єднувати для інтуїтивно зрозумілого та компактного синтаксису під час визначення конвеєрів.
2. Поетапне виконання: Конвеєр обробляє дані, прогоняючи їх на кожному етапі послідовно.
3. Випадок використання ШІ: Використовуйте шаблон Builder для створення складних багаторазово використовуваних конвеєрів попередньої обробки даних або налаштувань навчання моделі.

4. Патерн стратегії

Команда Стратегія визначає сімейство взаємозамінних алгоритмів, інкапсулюючи кожен і дозволяючи поведінці динамічно змінюватися під час виконання. Це особливо корисно в системах штучного інтелекту, де один процес (наприклад, висновок або обробка даних) може вимагати різних підходів залежно від контексту.

Коли використовувати

• Перемикання між різними умовивод стратегії (наприклад, пакетна обробка проти потокової передачі).
• Динамічне застосування різних методів обробки даних.
• Вибір стратегій управління ресурсами на основі наявної інфраструктури.

Реалізація

Давайте використаємо шаблон стратегії для реалізації двох різних стратегій висновку для моделі AI: пакетного висновку та потокового висновку.

class InferenceStrategy:
    """
    Abstract base class for inference strategies.
    """
    def infer(self, model, data):
        raise NotImplementedError("Subclasses must implement the `infer` method")

class BatchInference(InferenceStrategy):
    """
    Strategy for batch inference.
    """
    def infer(self, model, data):
        print("Performing batch inference...")
        return [model.predict(item) for item in data]

class StreamInference(InferenceStrategy):
    """
    Strategy for streaming inference.
    """
    def infer(self, model, data):
        print("Performing streaming inference...")
        results = []
        for item in data:
            results.append(model.predict(item))
        return results

class InferenceContext:
    """
    Context class to switch between inference strategies dynamically.
    """
    def __init__(self, strategy: InferenceStrategy):
        self.strategy = strategy

    def set_strategy(self, strategy: InferenceStrategy):
        """
        Change the inference strategy dynamically.
        """
        self.strategy = strategy

    def infer(self, model, data):
        """
        Delegate inference to the selected strategy.
        """
        return self.strategy.infer(model, data)

# Mock Model Class
class MockModel:
    def predict(self, input_data):
        return f"Predicted: {input_data}"

# Usage Example
model = MockModel()
data = ["sample1", "sample2", "sample3"]

context = InferenceContext(BatchInference())
print(context.infer(model, data))
# Output:
# Performing batch inference...
# ['Predicted: sample1', 'Predicted: sample2', 'Predicted: sample3']

# Switch to streaming inference
context.set_strategy(StreamInference())
print(context.infer(model, data))
# Output:
# Performing streaming inference...
# ['Predicted: sample1', 'Predicted: sample2', 'Predicted: sample3']

Пояснення

1. Абстрактний клас стратегії: InferenceStrategy визначає інтерфейс, якому повинні відповідати всі стратегії.
2. Конкретні стратегії: кожна стратегія (наприклад, BatchInference, StreamInference) реалізує логіку, специфічну для цього підходу.
3. Динамічне перемикання: InferenceContext дозволяє перемикати стратегії під час виконання, пропонуючи гнучкість для різних випадків використання.

Коли використовувати

• Перемикатися між ними пакетний висновок для офлайн-обробки та потоковий висновок для програм реального часу.
• Динамічно налаштовуйте методи збільшення даних або попередньої обробки на основі завдання або формату введення.

5. Шаблон спостерігача

Команда Візерунок спостерігача встановлює зв’язок «один до багатьох» між об’єктами. Коли один об'єкт (суб'єкт) змінює стан, всі його залежні (спостерігачі) автоматично сповіщаються. Це особливо корисно в системах ШІ для моніторингу в реальному часі, обробки подій або синхронізації даних.

Коли використовувати

• Моніторинг таких показників, як точність або втрата під час навчання моделі.
• Оновлення в режимі реального часу для інформаційних панелей або журналів.
• Управління залежностями між компонентами в складних робочих процесах.

Реалізація

Давайте скористаємося шаблоном спостерігача для моніторингу продуктивності моделі ШІ в реальному часі.

class Subject:
    """
    Base class for subjects being observed.
    """
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        """
        Attach an observer to the subject.
        """
        self._observers.append(observer)

    def detach(self, observer):
        """
        Detach an observer from the subject.
        """
        self._observers.remove(observer)

    def notify(self, data):
        """
        Notify all observers of a change in state.
        """
        for observer in self._observers:
            observer.update(data)

class ModelMonitor(Subject):
    """
    Subject that monitors model performance metrics.
    """
    def update_metrics(self, metric_name, value):
        """
        Simulate updating a performance metric and notifying observers.
        """
        print(f"Updated {metric_name}: {value}")
        self.notify({metric_name: value})

class Observer:
    """
    Base class for observers.
    """
    def update(self, data):
        raise NotImplementedError("Subclasses must implement the `update` method")

class LoggerObserver(Observer):
    """
    Observer to log metrics.
    """
    def update(self, data):
        print(f"Logging metric: {data}")

class AlertObserver(Observer):
    """
    Observer to raise alerts if thresholds are breached.
    """
    def __init__(self, threshold):
        self.threshold = threshold

    def update(self, data):
        for metric, value in data.items():
            if value > self.threshold:
                print(f"ALERT: {metric} exceeded threshold with value {value}")

# Usage Example
monitor = ModelMonitor()
logger = LoggerObserver()
alert = AlertObserver(threshold=90)

monitor.attach(logger)
monitor.attach(alert)

# Simulate metric updates
monitor.update_metrics("accuracy", 85)  # Logs the metric
monitor.update_metrics("accuracy", 95)  # Logs and triggers alert

1. Тема: керує списком спостерігачів і сповіщає їх, коли його стан змінюється. У цьому прикладі ModelMonitor клас відстежує показники.
2. Спостерігачі: Виконання певних дій після сповіщення. Наприклад, LoggerObserver журнали метрики, а AlertObserver подає сповіщення, якщо порогове значення перевищено.
3. Роздільний дизайн: спостерігачі та об’єкти слабо пов’язані, що робить систему модульною та розширюваною.

Як шаблони проектування відрізняються для інженерів ШІ та традиційних інженерів

Патерни проектування, незважаючи на те, що вони є універсальними, набувають унікальних характеристик, якщо їх впровадити в розробку штучного інтелекту порівняно з традиційною розробкою програмного забезпечення. Різниця полягає в викликах, цілях і робочих процесах, властивих системам штучного інтелекту, які часто вимагають адаптації або розширення шаблонів за межі традиційного використання.

1. Створення об’єкта: статичні проти динамічних потреб

• Традиційна інженерія: шаблони створення об’єктів, такі як Factory або Singleton, часто використовуються для керування конфігураціями, підключеннями до бази даних або станами сеансу користувача. Зазвичай вони статичні та чітко визначені під час проектування системи.
• Інженерія ШІ: Створення об’єкта часто передбачає динамічні робочі процеси, Такі як:
  • Створення моделей на льоту на основі даних користувача або системних вимог.
  • Завантаження різних конфігурацій моделі для таких завдань, як переклад, узагальнення чи класифікація.
  • Створення кількох конвеєрів обробки даних, які відрізняються характеристиками набору даних (наприклад, табличний або неструктурований текст).

Приклад: у ШІ шаблон Factory може динамічно генерувати модель глибокого навчання на основі типу завдання та апаратних обмежень, тоді як у традиційних системах він може просто генерувати компонент інтерфейсу користувача.

2. Обмеження продуктивності

• Традиційна інженерія: Шаблони проектування зазвичай оптимізовані для затримки та пропускної здатності в таких програмах, як веб-сервери, запити до бази даних або рендеринг інтерфейсу користувача.
• Інженерія ШІ: вимоги до продуктивності в ШІ поширюються на затримка виведення моделі, GPU/TPU використання та оптимізація пам'яті. Викрійки повинні включати:
  • Кешування проміжних результатів для зменшення надлишкових обчислень (шаблони Decorator або Proxy).
  • Динамічне перемикання алгоритмів (шаблон стратегії), щоб збалансувати затримку та точність на основі навантаження системи або обмежень у реальному часі.

3. Природа, орієнтована на дані

• Традиційна інженерія: Шаблони часто працюють на фіксованих структурах вводу-виводу (наприклад, форми, відповіді REST API).
• Інженерія ШІ: Шаблони повинні оброблятися мінливість даних як за структурою, так і за масштабом, включаючи:
  • Потокова передача даних для систем реального часу.
  • Мультимодальні дані (наприклад, текст, зображення, відео), які потребують конвеєрів із гнучкими етапами обробки.
  • Масштабні набори даних, які потребують ефективної попередньої обробки та конвеєрів доповнення, часто використовують такі шаблони, як Builder або Pipeline.

4. Експеримент проти стабільності

• Традиційна інженерія: акцент робиться на побудові стабільних, передбачуваних систем, де шаблони забезпечують постійну продуктивність і надійність.
• Інженерія ШІ: ШІ робочі процеси часто експериментальний і включають:
  • Ітерація на різних архітектурах моделей або методах попередньої обробки даних.
  • Динамічне оновлення компонентів системи (наприклад, моделі перенавчання, алгоритми заміни).
  • Розширення існуючих робочих процесів без порушення виробничих конвеєрів, часто за допомогою розширюваних шаблонів, таких як Decorator або Factory.

Приклад: Фабрика в штучному інтелекті може не тільки створювати екземпляр моделі, але й приєднувати попередньо завантажені ваги, налаштовувати оптимізатори та пов’язувати зворотні виклики навчання — усе це динамічно.