Skip to content

architecture_explained.md

Latest commit

 

History

History
170 lines (133 loc) · 6 KB

architecture_explained.md

File metadata and controls

170 lines (133 loc) · 6 KB
Raw

Arquitectura del Sistema: FCN, CNN y Transfer Learning

Este documento detalla la arquitectura completa del sistema de visión desarrollado, explicando cómo se conectan la Fully Convolutional Network (FCN) y la Convolutional Neural Network (CNN) mediante técnicas de Transfer Learning y procesamiento de datos.

1. Visión General del Pipeline

El sistema funciona en dos etapas principales conectadas tanto por datos como por conocimiento (pesos):

  1. Etapa de Segmentación (FCN): Una red entrena "desde cero" para aprender a separar la flor del fondo.
  2. Puente de Transferencia:
    • Datos: Las máscaras generadas por la FCN se usan para recortar (crop) las flores, eliminando el fondo irrelevante.
    • Conocimiento (Transfer Learning): El "Encoder" de la FCN (que ya sabe reconocer texturas y formas de flores) se trasplanta a la CNN para inicializarla.
  3. Etapa de Clasificación (CNN): Una red más profunda toma los recortes y refina el conocimiento heredado para clasificar la especie exacta de la flor.
graph LR
    subgraph Stage1 [Etapa 1: Segmentación]
        Img[Imagen Original] --> FCN[FCN (Segmentador)]
        FCN --> Mask[Máscara Binaria]
    end

    subgraph Bridge [Transferencia]
        Mask -.-> |Recorte Automático| Crop[Imagen Recortada]
        FCN -.-> |Pesos del Encoder| CNN_Feat[CNN Features]
    end

    subgraph Stage2 [Etapa 2: Clasificación]
        Crop --> CNN[BetterCNN (Clasificador)]
        CNN_Feat --> CNN
        CNN --> Class[Clase de Flor]
    end

    style Stage1 fill:#e1f5fe,stroke:#01579b
    style Stage2 fill:#fff3e0,stroke:#e65100
    style Bridge fill:#f3e5f5,stroke:#4a148c
Loading

2. Arquitectura FCN (El "Profesor")

La FCN (Fully Convolutional Network) sigue una arquitectura tipo U-Net. Su objetivo es generar una máscara píxel a píxel.

  • Entrenamiento: Desde cero (from scratch).
  • Misión: Aprender qué es una flor y qué es fondo.
graph TD
    subgraph Encoder [Encoder: Extracción de Características]
        direction TB
        In[Input 256x256] --> E1[Bloque 1<br/>32 filtros]
        E1 --> P1[Pool]
        P1 --> E2[Bloque 2<br/>64 filtros]
        E2 --> P2[Pool]
        P2 --> E3[Bloque 3<br/>128 filtros]
        E3 --> P3[Pool]
        P3 --> E4[Bloque 4<br/>256 filtros]
        E4 --> P4[Pool]
    end

    subgraph Bottleneck [Cuello de Botella]
        P4 --> B[Bloque Central<br/>512 filtros]
    end

    subgraph Decoder [Decoder: Reconstrucción Espacial]
        direction TB
        B --> U1[UpSample]
        U1 --> C1{Concat}
        E4 -.-> |Skip| C1
        C1 --> D1[Bloque Dec 1<br/>256 filtros]
        
        D1 --> U2[UpSample]
        U2 --> C2{Concat}
        E3 -.-> |Skip| C2
        C2 --> D2[Bloque Dec 2<br/>128 filtros]

        D2 --> U3[UpSample]
        U3 --> C3{Concat}
        E2 -.-> |Skip| C3
        C3 --> D3[Bloque Dec 3<br/>64 filtros]

        D3 --> U4[UpSample]
        U4 --> C4{Concat}
        E1 -.-> |Skip| C4
        C4 --> D4[Bloque Dec 4<br/>32 filtros]
    end

    D4 --> Out[Conv 1x1<br/>Salida Binaria]

    style Encoder fill:#d1c4e9,stroke:#512da8,stroke-width:2px
    style Decoder fill:#b2dfdb,stroke:#00695c,stroke-width:2px
    style Bottleneck fill:#ffccbc,stroke:#bf360c,stroke-width:2px
Loading

3. Transfer Learning: La Conexión

Aquí ocurre la magia. En lugar de empezar la CNN con pesos aleatorios (que no saben nada sobre imágenes), tomamos los pesos del Encoder de la FCN.

¿Por qué? El Encoder de la FCN ya ha pasado horas aprendiendo a detectar bordes, texturas de pétalos y formas de hojas para poder segmentar. Ese conocimiento es directamente útil para clasificar.

graph LR
    subgraph FCN_Source [FCN]
        E1_F[Encoder Bloque 1]
        E2_F[Encoder Bloque 2]
        E3_F[Encoder Bloque 3]
        E4_F[Encoder Bloque 4]
    end

    subgraph CNN_Target [CNN]
        F1_C[Features Bloque 1]
        F2_C[Features Bloque 2]
        F3_C[Features Bloque 3]
        F4_C[Features Bloque 4]
    end

    E1_F ==> |Copiar Pesos| F1_C
    E2_F ==> |Copiar Pesos| F2_C
    E3_F ==> |Copiar Pesos| F3_C
    E4_F ==> |Copiar Pesos| F4_C

    style FCN_Source fill:#e1f5fe,stroke:#0277bd
    style CNN_Target fill:#fff3e0,stroke:#ef6c00
Loading

4. Arquitectura CNN (BetterCNN)

La CNN toma el relevo. Usa las características aprendidas por la FCN y añade capas más profundas y específicas para distinguir entre 102 tipos de flores.

  • Entrada: Imágenes recortadas (Cropped) centradas en la flor.
  • Base: self.features (Inicializada con FCN).
  • Cabeza: self.deep_features + self.classifier (Entrenadas para clasificar).
graph TD
    subgraph Transferred [Parte Transferida]
        Input[Input Crop<br/>224x224] --> F1[Bloque 1<br/>64 filtros]
        F1 --> F2[Bloque 2<br/>128 filtros]
        F2 --> F3[Bloque 3<br/>256 filtros]
        F3 --> F4[Bloque 4<br/>512 filtros]
    end

    subgraph NewLayers [Nuevas Capas Profundas]
        F4 --> D1[Conv 3x3<br/>512 filtros]
        D1 --> Drop1[Dropout]
        Drop1 --> D2[Conv 7x7<br/>Contexto Global]
        D2 --> Drop2[Dropout]
        Drop2 --> D3[Conv 3x3<br/>Refinamiento]
    end

    subgraph Classifier [Clasificador Final]
        D3 --> GAP[Global Avg Pool]
        GAP --> Conv1x1[Conv 1x1<br/>102 Clases]
        Conv1x1 --> Flat[Flatten]
        Flat --> Softmax
    end

    style Transferred fill:#d1c4e9,stroke:#512da8,stroke-width:2px,stroke-dasharray: 5 5
    style NewLayers fill:#ffecb3,stroke:#ff6f00,stroke-width:2px
    style Classifier fill:#c8e6c9,stroke:#2e7d32,stroke-width:2px
Loading

Detalles Clave de BetterCNN

  1. Kernel 7x7: En las capas profundas, usamos un kernel grande (7x7) para capturar patrones globales de la flor entera, crucial para distinguir especies similares.
  2. Fully Convolutional Classifier: En lugar de capas lineales (Linear) gigantes que consumen mucha memoria, usamos AdaptiveAvgPool + Conv 1x1. Esto hace la red más eficiente y flexible con los tamaños de entrada.