Patrones de diseño en Python para ingenieros de IA y LLM: una guía práctica

Como ingenieros de IA, crear código limpio, eficiente y fácil de mantener es basic, especialmente cuando se crean sistemas complejos.

Patrones de diseño son soluciones reutilizables a problemas comunes en el diseño de software program. Para Ingenieros de IA y modelos de lenguaje grande (LLM)los patrones de diseño ayudan a construir sistemas robustos, escalables y mantenibles que manejan flujos de trabajo complejos de manera eficiente. Este artículo profundiza en los patrones de diseño en Python, centrándose en su relevancia en IA y LLM-sistemas basados ​​en. Explicaré cada patrón con casos prácticos de uso de IA y ejemplos de código Python.

Exploremos algunos patrones de diseño clave que son particularmente útiles en contextos de inteligencia synthetic y aprendizaje automático, junto con ejemplos de Python.

Por qué los patrones de diseño son importantes para los ingenieros de IA

Los sistemas de IA suelen implicar:

1. Creación de objetos complejos (p. ej., modelos de carga, canales de preprocesamiento de datos).
2. Gestionar interacciones entre componentes (p. ej., inferencia de modelos, actualizaciones en tiempo actual).
3. Manejo de escalabilidad, mantenibilidad y flexibilidad para requisitos cambiantes.

Los patrones de diseño abordan estos desafíos, proporcionando una estructura clara y reduciendo las correcciones advert hoc. Se dividen en tres categorías principales:

• Patrones creacionales: Centrarse en la creación de objetos. (Singleton, Fábrica, Constructor)
• Patrones estructurales: Organiza las relaciones entre objetos. (Adaptador, Decorador)
• Patrones de comportamiento: Gestiona la comunicación entre objetos. (Estrategia, Observador)

1. Patrón único

El Patrón singleton garantiza que una clase tenga solo una instancia y proporciona un punto de acceso international a esa instancia. Esto es especialmente valioso en los flujos de trabajo de IA donde los recursos compartidos (como ajustes de configuración, sistemas de registro o instancias de modelos) deben administrarse de manera consistente y sin redundancia.

Cuando usar

• Gestionar configuraciones globales (p. ej., hiperparámetros del modelo).
• Compartir recursos a través de múltiples subprocesos o procesos (p. ej., Memoria GPU).
• Garantizar un acceso constante a un único motor de inferencia o conexión de base de datos.

Implementación

A continuación se explica cómo implementar un patrón Singleton en Python para administrar configuraciones para un modelo de IA:

class ModelConfig:
    """
    A Singleton class for managing international mannequin configurations.
    """
    _instance = None  # Class variable to retailer the singleton occasion
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            # Create a brand new occasion if none exists
            cls._instance = tremendous().__new__(cls)
            cls._instance.settings = {}  # Initialize configuration dictionary
        return cls._instance
    def set(self, key, worth):
        """
        Set a configuration key-value pair.
        """
        self.settings[key] = worth
    def get(self, key):
        """
        Get a configuration worth by key.
        """
        return self.settings.get(key)
# Utilization Instance
config1 = ModelConfig()
config1.set("model_name", "GPT-4")
config1.set("batch_size", 32)
# Accessing the identical occasion
config2 = ModelConfig()
print(config2.get("model_name"))  # Output: GPT-4
print(config2.get("batch_size"))  # Output: 32
print(config1 is config2)  # Output: True (each are the identical occasion)

Explicación

1. El __new__ Método: Esto garantiza que solo se cree una instancia de la clase. Si ya existe una instancia, devuelve la existente.
2. Estado compartido: Ambos config1 y config2 apunte a la misma instancia, haciendo que todas las configuraciones sean globalmente accesibles y consistentes.
3. Caso de uso de IA: utilice este patrón para administrar configuraciones globales como rutas a conjuntos de datos, configuraciones de registro o variables de entorno.

2. Patrón de fábrica

El Patrón de fábrica proporciona una forma de delegar la creación de objetos a subclases o métodos de fábrica dedicados. En los sistemas de IA, este patrón es very best para crear diferentes tipos de modelos, cargadores de datos o canalizaciones de forma dinámica según el contexto.

Cuando usar

• Creación dinámica de modelos basados ​​en la entrada del usuario o los requisitos de la tarea.
• Gestionar una lógica de creación de objetos compleja (por ejemplo, canalizaciones de preprocesamiento de varios pasos).
• Desacoplar la creación de instancias de objetos del resto del sistema para mejorar la flexibilidad.

Implementación

Construyamos una fábrica para crear modelos para diferentes tareas de IA, como clasificación, resumen y traducción de texto:

class BaseModel:
    """
    Summary base class for AI fashions.
    """
    def predict(self, knowledge):
        elevate NotImplementedError("Subclasses should implement the `predict` methodology")
class TextClassificationModel(BaseModel):
    def predict(self, knowledge):
        return f"Classifying textual content: {knowledge}"
class SummarizationModel(BaseModel):
    def predict(self, knowledge):
        return f"Summarizing textual content: {knowledge}"
class TranslationModel(BaseModel):
    def predict(self, knowledge):
        return f"Translating textual content: {knowledge}"
class ModelFactory:
    """
    Manufacturing facility class to create AI fashions dynamically.
    """
    @staticmethod
    def create_model(task_type):
        """
        Manufacturing facility methodology to create fashions primarily based on the duty kind.
        """
        task_mapping = {
            "classification": TextClassificationModel,
            "summarization": SummarizationModel,
            "translation": TranslationModel,
        }
        model_class = task_mapping.get(task_type)
        if not model_class:
            elevate ValueError(f"Unknown activity kind: {task_type}")
        return model_class()
# Utilization Instance
activity = "classification"
mannequin = ModelFactory.create_model(activity)
print(mannequin.predict("AI will rework the world!"))
# Output: Classifying textual content: AI will rework the world!

Explicación

1. Clase base abstracta: El BaseModel la clase outline la interfaz (predict) que todas las subclases deben implementar, asegurando la coherencia.
2. Lógica de fábrica: El ModelFactory selecciona dinámicamente la clase apropiada según el tipo de tarea y crea una instancia.
3. Extensibilidad: Agregar un nuevo tipo de modelo es sencillo: simplemente implemente una nueva subclase y actualice la fábrica. task_mapping.

Caso de uso de IA

Think about que está diseñando un sistema que selecciona un LLM diferente (por ejemplo, BERT, GPT o T5) según la tarea. El patrón Manufacturing facility facilita la ampliación del sistema a medida que hay nuevos modelos disponibles sin modificar el código existente.

3. Patrón de constructor

El Patrón de constructor separa la construcción de un objeto complejo de su representación. Es útil cuando un objeto implica varios pasos para inicializarlo o configurarlo.

Cuando usar

• Creación de canales de varios pasos (por ejemplo, preprocesamiento de datos).
• Gestionar configuraciones para experimentos o entrenamiento de modelos.
• Crear objetos que requieran muchos parámetros, asegurando legibilidad y mantenibilidad.

Implementación

A continuación se explica cómo utilizar el patrón Builder para crear una canalización de preprocesamiento de datos:

class DataPipeline:
    """
    Builder class for setting up an information 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 allow methodology chaining
    def run(self, knowledge):
        """
        Execute all steps within the pipeline.
        """
        for step in self.steps:
            knowledge = step(knowledge)
        return knowledge
# Utilization Instance
pipeline = DataPipeline()
pipeline.add_step(lambda x: x.strip())  # Step 1: Strip whitespace
pipeline.add_step(lambda x: x.decrease())  # Step 2: Convert to lowercase
pipeline.add_step(lambda x: x.change(".", ""))  # Step 3: Take away durations
processed_data = pipeline.run("  Hey World. ")
print(processed_data)  # Output: hiya world

Explicación

1. Métodos encadenados: El add_step El método permite el encadenamiento para una sintaxis intuitiva y compacta al definir canalizaciones.
2. Ejecución paso a paso: La canalización procesa datos ejecutándolos en cada paso en secuencia.
3. Caso de uso de IA: Utilice el patrón Builder para crear canales de preprocesamiento de datos complejos y reutilizables o configuraciones de entrenamiento de modelos.

4. Patrón de estrategia

El Patrón de estrategia outline una familia de algoritmos intercambiables, encapsulando cada uno de ellos y permitiendo que el comportamiento cambie dinámicamente en tiempo de ejecución. Esto es especialmente útil en sistemas de IA donde el mismo proceso (por ejemplo, inferencia o procesamiento de datos) puede requerir diferentes enfoques según el contexto.

Cuando usar

• Cambiando entre diferentes inferencia estrategias (por ejemplo, procesamiento por lotes versus transmisión por secuencias).
• Aplicar diferentes técnicas de procesamiento de datos de forma dinámica.
• Elegir estrategias de gestión de recursos en función de la infraestructura disponible.

Implementación

Utilicemos el patrón de estrategia para implementar dos estrategias de inferencia diferentes para un modelo de IA: inferencia por lotes e inferencia por transmisión.

class InferenceStrategy:
    """
    Summary base class for inference methods.
    """
    def infer(self, mannequin, knowledge):
        elevate NotImplementedError("Subclasses should implement the `infer` methodology")
class BatchInference(InferenceStrategy):
    """
    Technique for batch inference.
    """
    def infer(self, mannequin, knowledge):
        print("Performing batch inference...")
        return [model.predict(item) for item in data]
class StreamInference(InferenceStrategy):
    """
    Technique for streaming inference.
    """
    def infer(self, mannequin, knowledge):
        print("Performing streaming inference...")
        outcomes = []
        for merchandise in knowledge:
            outcomes.append(mannequin.predict(merchandise))
        return outcomes
class InferenceContext:
    """
    Context class to change between inference methods dynamically.
    """
    def __init__(self, technique: InferenceStrategy):
        self.technique = technique
    def set_strategy(self, technique: InferenceStrategy):
        """
        Change the inference technique dynamically.
        """
        self.technique = technique
    def infer(self, mannequin, knowledge):
        """
        Delegate inference to the chosen technique.
        """
        return self.technique.infer(mannequin, knowledge)
# Mock Mannequin Class
class MockModel:
    def predict(self, input_data):
        return f"Predicted: {input_data}"
# Utilization Instance
mannequin = MockModel()
knowledge = ["sample1", "sample2", "sample3"]
context = InferenceContext(BatchInference())
print(context.infer(mannequin, knowledge))
# Output:
# Performing batch inference...
# ['Predicted: sample1', 'Predicted: sample2', 'Predicted: sample3']
# Change to streaming inference
context.set_strategy(StreamInference())
print(context.infer(mannequin, knowledge))
# Output:
# Performing streaming inference...
# ['Predicted: sample1', 'Predicted: sample2', 'Predicted: sample3']

Explicación

1. Clase de estrategia abstracta: El InferenceStrategy outline la interfaz que todas las estrategias deben seguir.
2. Estrategias concretas: Cada estrategia (p. ej., BatchInference, StreamInference) implementa la lógica específica de ese enfoque.
3. Conmutación dinámica: El InferenceContext permite cambiar de estrategia en tiempo de ejecución, ofreciendo flexibilidad para diferentes casos de uso.

Cuando usar

• Cambiar entre inferencia por lotes para procesamiento fuera de línea y inferencia de transmisión para aplicaciones en tiempo actual.
• Ajuste dinámicamente las técnicas de preprocesamiento o aumento de datos según la tarea o el formato de entrada.

5. Patrón de observador

El Patrón de observador Establece una relación de uno a muchos entre objetos. Cuando un objeto (el sujeto) cambia de estado, todos sus dependientes (observadores) son notificados automáticamente. Esto es particularmente útil en sistemas de inteligencia synthetic para monitoreo en tiempo actual, manejo de eventos o sincronización de datos.

Cuando usar

• Monitorear métricas como precisión o pérdida durante el entrenamiento del modelo.
• Actualizaciones en tiempo actual para paneles o registros.
• Gestionar dependencias entre componentes en flujos de trabajo complejos.

Implementación

Utilicemos el patrón Observer para monitorear el rendimiento de un modelo de IA en tiempo actual.

class Topic:
    """
    Base class for topics being noticed.
    """
    def __init__(self):
        self._observers = []
    def connect(self, observer):
        """
        Connect an observer to the topic.
        """
        self._observers.append(observer)
    def detach(self, observer):
        """
        Detach an observer from the topic.
        """
        self._observers.take away(observer)
    def notify(self, knowledge):
        """
        Notify all observers of a change in state.
        """
        for observer in self._observers:
            observer.replace(knowledge)
class ModelMonitor(Topic):
    """
    Topic that screens mannequin efficiency metrics.
    """
    def update_metrics(self, metric_name, worth):
        """
        Simulate updating a efficiency metric and notifying observers.
        """
        print(f"Up to date {metric_name}: {worth}")
        self.notify({metric_name: worth})
class Observer:
    """
    Base class for observers.
    """
    def replace(self, knowledge):
        elevate NotImplementedError("Subclasses should implement the `replace` methodology")
class LoggerObserver(Observer):
    """
    Observer to log metrics.
    """
    def replace(self, knowledge):
        print(f"Logging metric: {knowledge}")
class AlertObserver(Observer):
    """
    Observer to boost alerts if thresholds are breached.
    """
    def __init__(self, threshold):
        self.threshold = threshold
    def replace(self, knowledge):
        for metric, worth in knowledge.objects():
            if worth > self.threshold:
                print(f"ALERT: {metric} exceeded threshold with worth {worth}")
# Utilization Instance
monitor = ModelMonitor()
logger = LoggerObserver()
alert = AlertObserver(threshold=90)
monitor.connect(logger)
monitor.connect(alert)
# Simulate metric updates
monitor.update_metrics("accuracy", 85)  # Logs the metric
monitor.update_metrics("accuracy", 95)  # Logs and triggers alert

1. Sujeto: Gestiona una lista de observadores y les notifica cuando cambia su estado. En este ejemplo, el ModelMonitor la clase sigue las métricas.
2. Observadores: realice acciones específicas cuando se le notifique. Por ejemplo, el LoggerObserver registra métricas, mientras que el AlertObserver genera alertas si se supera un umbral.
3. Diseño desacoplado: Los observadores y los sujetos están débilmente acoplados, lo que hace que el sistema sea modular y extensible.

En qué se diferencian los patrones de diseño para los ingenieros de IA frente a los ingenieros tradicionales

Los patrones de diseño, si bien son de aplicación common, adquieren características únicas cuando se implementan en la ingeniería de IA en comparación con la ingeniería de software program tradicional. La diferencia radica en los desafíos, objetivos y flujos de trabajo intrínsecos de los sistemas de IA, que a menudo exigen que los patrones se adapten o amplíen más allá de sus usos convencionales.

1. Creación de objetos: necesidades estáticas versus dinámicas

• Ingeniería Tradicional: Los patrones de creación de objetos como Manufacturing facility o Singleton se utilizan a menudo para gestionar configuraciones, conexiones de bases de datos o estados de sesión de usuario. Generalmente son estáticos y están bien definidos durante el diseño del sistema.
• Ingeniería de IA: La creación de objetos a menudo implica flujos de trabajo dinámicoscomo:
  • Creación de modelos sobre la marcha basados ​​en la entrada del usuario o los requisitos del sistema.
  • Cargando diferentes configuraciones de modelo para tareas como traducción, resumen o clasificación.
  • Creación de instancias de múltiples procesos de procesamiento de datos que varían según las características del conjunto de datos (por ejemplo, texto tabular versus texto no estructurado).

Ejemplo: En IA, un patrón de fábrica podría generar dinámicamente un modelo de aprendizaje profundo basado en el tipo de tarea y las restricciones de {hardware}, mientras que en los sistemas tradicionales, podría simplemente generar un componente de interfaz de usuario.

2. Restricciones de desempeño

• Ingeniería Tradicional: Los patrones de diseño suelen estar optimizados para la latencia y el rendimiento en aplicaciones como servidores net, consultas de bases de datos o representación de UI.
• Ingeniería de IA: Los requisitos de rendimiento en IA se extienden a latencia de inferencia del modelo, GPU/TPU utilización, y optimización de la memoria. Los patrones deben acomodar:
  • Almacenamiento en caché de resultados intermedios para reducir cálculos redundantes (patrones Decorador o Proxy).
  • Cambiar algoritmos dinámicamente (patrón de estrategia) para equilibrar la latencia y la precisión en función de la carga del sistema o las limitaciones de tiempo actual.

3. Naturaleza centrada en los datos

• Ingeniería Tradicional: Los patrones a menudo operan en estructuras fijas de entrada y salida (por ejemplo, formularios, respuestas de API REST).
• Ingeniería de IA: Los patrones deben manejar variabilidad de datos tanto en estructura como en escala, incluyendo:
  • Transmisión de datos para sistemas en tiempo actual.
  • Datos multimodales (p. ej., texto, imágenes, vídeos) que requieren procesos con pasos de procesamiento flexibles.
  • Conjuntos de datos a gran escala que necesitan preprocesamiento eficiente y canalizaciones de aumento, que a menudo utilizan patrones como Builder o Pipeline.

4. Experimentación versus estabilidad

• Ingeniería Tradicional: Se hace hincapié en la construcción de sistemas estables y predecibles donde los patrones garanticen un rendimiento y una confiabilidad consistentes.
• Ingeniería de IA: Los flujos de trabajo de IA a menudo son experimental e involucrar:
  • Iterando sobre diferentes arquitecturas de modelos o técnicas de preprocesamiento de datos.
  • Actualizar dinámicamente los componentes del sistema (por ejemplo, reentrenar modelos, intercambiar algoritmos).
  • Ampliar los flujos de trabajo existentes sin interrumpir los procesos de producción, a menudo utilizando patrones extensibles como Decorator o Manufacturing facility.

Ejemplo: Una fábrica en IA no solo puede crear una instancia de un modelo, sino también adjuntar pesos precargados, configurar optimizadores y vincular devoluciones de llamadas de entrenamiento, todo de forma dinámica.