Initial commit of the Computer Vision Journey presentation, including main application files, project pages, assets, and configuration. Added .gitignore to exclude unnecessary files and created requirements.txt for dependencies.

.gitattributes

@@ -33,3 +33,27 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+# Video files
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.mov filter=lfs diff=lfs merge=lfs -text
+*.avi filter=lfs diff=lfs merge=lfs -text
+*.wmv filter=lfs diff=lfs merge=lfs -text
+*.mkv filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+# Image files
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.svg filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Specific files in assets directory
+assets/drone_line_following_video.mp4 filter=lfs diff=lfs merge=lfs -text
+assets/hand_control_arm_video.mp4 filter=lfs diff=lfs merge=lfs -text
+assets/quickdraw_game_video.mp4 filter=lfs diff=lfs merge=lfs -text
+assets/*.jpg filter=lfs diff=lfs merge=lfs -text
+assets/*.jpeg filter=lfs diff=lfs merge=lfs -text
+assets/*.png filter=lfs diff=lfs merge=lfs -text
+assets/*.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,8 @@
+.vscode/
+.streamlit/secrets.toml
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz

.streamlit/config.toml

@@ -0,0 +1,15 @@
+[theme]
+primaryColor = "#FF4B4B"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730"
+font = "sans serif"
+
+[server]
+enableCORS = true
+enableXsrfProtection = true
+maxUploadSize = 200
+maxMessageSize = 200
+
+[browser]
+gatherUsageStats = false 

README.md

@@ -12,3 +12,91 @@ short_description: Computer Vision Hangout
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Computer Vision Journey - Interactive Streamlit Presentation
+
+An interactive Streamlit presentation showcasing my journey in Computer Vision, from autonomous drones to Vision Language Models.
+
+## Overview
+
+This application serves as an interactive presentation for a Computer Vision Hangout on Hugging Face. Instead of traditional slides, I've created a modern, interactive Streamlit application that walks through my development in computer vision through various projects I've worked on over the years.
+
+### Featured Projects
+
+1. **Black Bee Drones** - First autonomous drone team in Latin America
+   - Line following algorithms
+   - ArUco marker detection
+   - Real-time control systems
+
+2. **Asimov Foundation** - STEM education through robotics and computer vision
+   - Hand gesture recognition for robotic arm control
+   - Educational tools for teaching CV concepts
+
+3. **CafeDL** - A Java Deep Learning library built from scratch
+   - CNN architecture implementation
+   - Real-time drawing classification
+   - QuickDraw game clone
+
+4. **Tech4Humans ML Projects** - Industry applications
+   - Signature Detection Model (open-source)
+   - Document Information Extraction using VLMs
+
+## Live Demos
+
+The presentation includes links to several live demos on Hugging Face Spaces:
+
+- [OpenCV GUI Demo](https://samuellimabraz-opencv-gui.hf.space)
+- [Line Following PID Demo](https://samuellimabraz-line-follow-pid.hf.space)
+- [Signature Detection Demo](https://tech4humans-signature-detection.hf.space)
+
+## Installation and Running
+
+### Requirements
+
+- Python 3.8+
+- Streamlit 1.33.0+
+- Other dependencies listed in `requirements.txt`
+
+### Setup
+
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/samuellimabraz/cv-journey-presentation.git
+   cd cv-journey-presentation
+   ```
+
+2. Install the required packages:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Run the Streamlit application:
+   ```bash
+   streamlit run app.py
+   ```
+
+## Project Structure
+
+- `app.py` - Main entry point for the Streamlit application
+- `pages/` - Individual page modules for each section of the presentation
+- `assets/` - Images, videos, and other static assets
+- `utils/` - Helper functions and utilities
+
+## Contributing
+
+This is a personal presentation project, but feedback and suggestions are welcome. Feel free to open an issue or contact me directly.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- Black Bee Drones team at UNIFEI
+- Asimov Foundation
+- Tech4Humans team
+- Hugging Face community for hosting the Computer Vision Hangout
+
+## Contact
+
+Samuel Lima Braz - [GitHub](https://github.com/samuellimabraz) | [LinkedIn](https://www.linkedin.com/) | [Hugging Face](https://huggingface.co/samuellimabraz)

app.py

@@ -0,0 +1,176 @@
+import streamlit as st
+from streamlit_extras.switch_page_button import switch_page
+import os
+import sys
+
+# Add the project root to the path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Set page configuration
+st.set_page_config(
+    page_title="Samuel Lima Braz | CV Journey",
+    page_icon="🧠",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Custom CSS for better styling
+st.markdown(
+    """
+<style>
+    .main .block-container {
+        padding-top: 2rem;
+    }
+    h1, h2, h3 {
+        margin-top: 0;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2rem;
+    }
+    .stTabs [data-baseweb="tab"] {
+        height: 4rem;
+        white-space: pre-wrap;
+        background-color: transparent;
+        border-radius: 4px 4px 0 0;
+        gap: 1rem;
+        padding-top: 1rem;
+        padding-bottom: 1rem;
+    }
+    a {
+        text-decoration: none;
+    }
+    .badge {
+        display: inline-block;
+        padding: 0.25em 0.4em;
+        font-size: 75%;
+        font-weight: 700;
+        line-height: 1;
+        text-align: center;
+        white-space: nowrap;
+        vertical-align: baseline;
+        border-radius: 0.25rem;
+        margin-right: 0.5rem;
+        margin-bottom: 0.5rem;
+    }
+    .badge-primary {
+        color: #fff;
+        background-color: #007bff;
+    }
+    .badge-secondary {
+        color: #fff;
+        background-color: #6c757d;
+    }
+    .badge-success {
+        color: #fff;
+        background-color: #28a745;
+    }
+    .badge-info {
+        color: #fff;
+        background-color: #17a2b8;
+    }
+    .tech-list {
+        list-style-type: none;
+        padding-left: 0;
+    }
+    .tech-list li {
+        margin-bottom: 0.5rem;
+    }
+    .tech-list li::before {
+        content: "•";
+        color: #ff4b4b;
+        font-weight: bold;
+        display: inline-block;
+        width: 1em;
+        margin-left: -1em;
+    }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+# Title and introduction
+st.title("My Computer Vision Journey")
+st.subheader("Presented by Samuel Lima Braz")
+
+# Profile image - create a column layout
+col1, col2 = st.columns([1, 3])
+
+with col1:
+    st.image("assets/profile.jpg", width=200)
+
+with col2:
+    st.markdown(
+        """
+    Hi, I'm **Samuel Lima Braz**, a Computer Engineering student at UNIFEI (Universidade Federal de Itajubá) 
+    and Machine Learning Engineer at Tech4Humans in Brazil. 
+    
+    My programming journey began in 2018 with C during my technical course in Industrial Automation. 
+    I entered the world of Computer Vision in 2023 when I joined Black Bee Drones, the first autonomous 
+    drone team in Latin America, where I continue to develop cutting-edge solutions for autonomous flight.
+    """
+    )
+
+st.markdown("---")
+
+st.markdown("#### Presentation Goal:")
+st.markdown(
+    """
+This interactive presentation, built entirely with Streamlit, walks you through my key projects in Computer Vision, 
+from autonomous drones to fine-tuning Vision Language Models. We'll explore concepts, challenges, and see some live demos along the way!
+"""
+)
+
+# Navigation section
+st.markdown("### Navigate Through My Journey")
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    black_bee_btn = st.button("🐝 Black Bee Drones", use_container_width=True)
+    if black_bee_btn:
+        switch_page("black_bee_drones")
+
+    cafe_dl_btn = st.button("☕ CafeDL Project", use_container_width=True)
+    if cafe_dl_btn:
+        switch_page("cafe_dl")
+
+with col2:
+    asimov_btn = st.button("🤖 Asimo Foundation", use_container_width=True)
+    if asimov_btn:
+        switch_page("asimo_foundation")
+
+    tech4humans_btn = st.button("💼 Tech4Humans", use_container_width=True)
+    if tech4humans_btn:
+        switch_page("tech4humans")
+
+with col3:
+    conclusion_btn = st.button("✅ Conclusion", use_container_width=True)
+    if conclusion_btn:
+        switch_page("conclusion")
+
+
+# Add information about this presentation
+st.sidebar.markdown("## About This Presentation")
+st.sidebar.markdown(
+    """
+This interactive presentation was built with Streamlit as an alternative to traditional slides.
+
+Navigate through the sections using the buttons above or the pages in the sidebar.
+
+Each section includes:
+- Project description
+- Technologies used
+- Interactive demos (where applicable)
+- Code examples & visualizations
+"""
+)
+
+# Add contact information in the sidebar
+st.sidebar.markdown("## Connect With Me")
+st.sidebar.markdown(
+    """
+- [GitHub](https://github.com/samuellimabraz)
+- [LinkedIn](https://www.linkedin.com/in/samuel-lima-braz/)
+- [Hugging Face](https://huggingface.co/samuellimabraz)
+"""
+)

assets/.gitkeep

@@ -0,0 +1,12 @@
+# This file ensures that the assets directory is tracked by git even if it is empty.
+# You should place the following files in this directory:
+#
+# - profile.jpg: A profile picture for the intro page
+# - imav_mission_diagram.jpg: A diagram of the IMAV 2023 Indoor Mission
+# - drone_line_following_video.mp4: Video of the drone following a line during IMAV 2023
+# - gesture_control.jpg: Image showing hand gesture detection for drone control
+# - aruco_navigation.jpg: Image showing ArUco marker detection for positioning
+# - robotic_arm.jpg: Image of the robotic arm used in the Asimov Foundation project
+# - hand_control_arm_video.mp4: Demo video of hand gesture controlling a robotic arm
+# - quickdraw_game_video.mp4: Demo video of the QuickDraw game using CafeDL
+# - signature_detection.jpg: Example image of signature detection on a document 

assets/[Samuel] Fine-tuning Structured OCR.md

@@ -0,0 +1,350 @@
+# Fine-tuning Structured OCR
+
+por **Samuel Lima Braz** em **27/02/2025**
+
+# Atividades
+
+- Refinamento do dataset  
+- Avaliação de modelo Open Source com vllm  
+- Ajuste Fino  
+  - Unsloth  
+  - Swift  
+- Avaliação de Generalização de documentos
+
+## Introdução
+
+Iniciei o desenvolvimento dos experimentos no cenário de fine-tuning de modelos multimodais para a extração de dados. O objetivo não é construir um modelo geral que substitua nossa solução atual, mas sim validar a capacidade de modelos menores nesse campo e nossa competência em treiná-los e implantá-los. Já havia iniciado a preparação do dataset e, agora, refinei os dados, defini métricas e estabeleci métodos para avaliar os modelos open-source de forma eficiente, realizando o fine-tuning de determinados modelos e comparando os resultados entre as versões pré-treinadas e ajustadas.
+
+## Dataset
+
+Anteriormente, criei um dataset com amostras de CNH, RG e Notas Fiscais a partir de dados públicos, utilizando um processo de estruturação dos dados extraídos por LLM. Contudo, durante o desenvolvimento do processo de avaliação, percebi diversas inconsistências nas anotações, falhas nas associações dos campos, despadronização dos dados extraídos e até algumas imagens invertidas.
+
+Para solucionar esses problemas, realizei uma seleção manual de 170 exemplos de CNH e 170 exemplos de RG, refazendo as anotações e revisando as imagens consideradas adequadas para a extração. No caso das Notas Fiscais, as anotações já estavam adequadas, tendo sido feita apenas a seleção das amostras com boa qualidade de imagem.
+
+Posteriormente, dividi o dataset em 70% para treino, 15% para teste e 15% para validação, mantendo uma proporção igualitária de cada tipo de documento em cada divisão. Além disso, utilizando a ferramenta de augmentations em imagens do Roboflow, gerei três vezes mais dados de treino aplicando transformações nas imagens.
+
+![][image1]
+
+[Brazilian Document Extration Multimodal Dataset by tech](https://universe.roboflow.com/tech-ysdkk/brazilian-document-extration)
+
+### Pré-Processamento
+
+Preparando os dados para a avaliação e treinamento.
+
+- Formatação
+
+```py
+SYSTEM_MESSAGE = """
+Parse the provided image of a document and extract the relevant information in a well-structured JSON format that the user will provide.
+- If data is not available in OCR, leave the field empty in the JSON.
+- Do not include authorities and type in the final response.
+- Respond only the final JSON. Avoid additional explanations or comments.
+Fill the following json schema:
+"""
+
+def format_conversation(
+    image: str | bytes | Image.Image, prefix: str, suffix: str | None = None, system_message: str | None = None
+) -> list[dict]:
+    messages = []
+
+    if system_message is not None:
+        messages.append(
+            {
+                "role": "system",
+                "content": [{"type": "text", "text": system_message}],
+            }
+        )
+
+    messages.append(
+        {
+            "role": "user",
+            "content": [
+                {"type": "text",  "text": prefix},
+                {"type": "image", "image": image},
+            ],
+        }
+    )
+
+    if suffix is not None:
+        messages.append(
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": suffix}],
+            }
+        )
+
+    return { "messages" : messages }
+```
+
+Preparei os dados para a avaliação e o treinamento. Após carregar o dataset do Roboflow e transformá-lo em um Dataset do PyTorch, criei um pipeline de transformações semelhante às aplicadas na API de extração de documentos. Neste pipeline, apliquei um resize para um máximo de (640, 640), mantendo o aspect ratio das imagens. Explorei técnicas como auto-orientação, CLAHE, Sharpen, entre outras testadas na avaliação da Mirela, e identifiquei algumas combinações funcionais. Contudo, optei inicialmente por aplicar somente o resize, pois ainda não estava claro como as demais transformações afetariam o desempenho do treinamento, além de alguns modelos (como o deepseek-vl2) não aceitarem entradas em grayscale, o que poderia gerar viés para modelos treinados com conjuntos de imagens em formatos diferentes.
+
+## Avaliação
+
+### Arquiteturas
+
+Primeiro analisei os principais benchmarks de modelos de vision com foco nas métricas de dataset generalistas em extração de dados como OCRBench e OCR-VQA ([https://huggingface.co/spaces/opencompass/open\_vlm\_leaderboard](https://huggingface.co/spaces/opencompass/open_vlm_leaderboard)). Em resumo as principais arquiteturas com tamanhos entre 1B há 10B (uma média de tamanho acessível para uma GPU L4), com as melhores métricas em extração de dados são
+
+- Qwen (2, 2.5)-VL  
+- InterVL2.5  
+- Ovis2  
+- MiniCPM-o-2.6  
+- deepseek-vl2  
+- h20-vl  
+- phi-3.5-vision  
+- moondream  
+- SmolVLM  
+- MiniMonkey
+
+### vLLM
+
+Para facilitar o sistema de inferência entre os diferentes modelos de vision optei por utilizar uma ferramenta de inferência, ao invés de utilizar a lib transformers diretamente, melhorando também o tempo de inferência com as otimizações que elas trazem. Avaliei as ferramentas lmdeploy, ollama, tri, llama.cpp e vllm, e dentre eles o vllm possui o maior nível de suporte a modelos de vision, além de ser simples de utilizar de forma “offline” sem a necessidade de servir o modelo e sim utilizá-lo diretamente na GPU do ambiente do colab.
+
+Mas ainda assim fiz uma estrutura que me permitisse usar modelos através do transformers, vllm ou via litellm, mantendo o mesmo padrão para avaliação. 
+
+Um dos desafios com os modelos de vision são as variações no pré-processamento de como é aplicado o tokenizer e/ou o processor, a compatibilidade entre versões do transformers e a própria classe de modelo. Então quando iniciei o desenvolvimento percebi que teria que escrever e testar códigos diferentes para cada arquitetura, o que é normal e interessante para estudar uma arquitetura, porém deixaria meu desenvolvimento mais lento.
+
+Além disso, o vllm fornece a funcionalidade de saída estruturada, por meio das ferramentas  [outlines](https://github.com/dottxt-ai/outlines), [lm-format-enforcer](https://github.com/noamgat/lm-format-enforcer), or [xgrammar](https://github.com/mlc-ai/xgrammar). Há um artigo do prórpiro vLLM que é muito bacana e explica como funciona essas ferramentas e uma comparação de desempenho entre elas e como elas estão arquitetadas na versão atual do projeto deles: [Structured Decoding in vLLM: a gentle introduction](https://blog.vllm.ai/2025/01/14/struct-decode-intro.html) 
+
+* Pretendo trazer uma escrita sobre o tema, porém não tive o devido tempo para isso.
+
+### Projeto
+
+Esse é o projeto que fiz para realizar inferência via transformers, vllm e litellm seguindo o mesmo padrão de geração
+
+![][image2]
+
+Link para o diagrama: [https://www.mermaidchart.com/app/projects/54b59dc6-881e-4e56-88a2-e5571cdb40e1/diagrams/acaa69c6-d3e5-4edf-9c88-c4db6a242025/version/v0.1/edit](https://www.mermaidchart.com/app/projects/54b59dc6-881e-4e56-88a2-e5571cdb40e1/diagrams/acaa69c6-d3e5-4edf-9c88-c4db6a242025/version/v0.1/edit) 
+
+### Métricas
+
+Para metrificar o desempenho dos modelos criei uma serie de funções em python para calcular o match ou a similaridade entre campos do json de ground trut, normalizando os valores para que não seja considerado pontuações, espaços, variações de indicações do vazio (ex. “null”, “n/a” …), variações na formatação de data ("%Y-%m-%d", "%d/%m/%Y", "%m-%d-%Y", "%d-%m-%Y"),  aproximações de valores numéricos, letras maiúsculas e minúsculas, remoção de caracteres especiais … 
+
+O processo irá avaliar um match exato, ou então calcular a similaridade entre as strings utilizando da ferramenta rapidfuzz que calcula a similaridade entre duas strings utilizando uma métrica baseada na distância de edição do tipo Indel, que, em essência, é uma variação da distância de Levenshtein que considera inserções e deleções.   
+Ela determina o número mínimo de operações necessárias (inserções e deleções) para transformar uma string na outra. Esse número é a "distância" entre as duas strings. Para transformar esse valor em uma medida de similaridade, a distância é normalizada em relação à soma dos comprimentos das duas strings. A fórmula é dada por:  
+similaridade \= (1 \- (distância / (len(s1) \+ len(s2)))) \* 100  
+Assim, o resultado é um número entre 0 e 100, onde 100 indica que as strings são idênticas e 0 que são completamente diferentes.
+
+De forma exemplificada ela atua dessa forma:
+
+```py
+predicted = {"date": "2018-07-11", "company": {"name": "Empresa XYZ", "ti": "123"}, "cpf": ""}
+ground_truth = {"date": "11/07/2018", "company": {"name":"epresa xyz", "ti": "12"}, "cpf": ""}
+calculate_metrics(predicted, ground_truth, "nota")
+
+{
+ 'exact_match': 0,
+ 'field_accuracy': {
+'date': 1.0,
+  	'company.name': 0.9523809523809522,
+'company.ti': 0.8888888888888888,
+'cpf': 1.0
+  },
+ 'type': 'nota',
+ 'missing_fields': [],
+ 'incorrect_fields': [],
+ 'overall_accuracy': 0.9603174603174602,
+ 'field_coverage': 1.0
+}
+```
+
+   
+Também desenvolvi uma série de funções para gerar visualizações dos resultados contendo a imagem, label e predição e permitindo salvar isso em arquivo xlsx e também construir alguns relatórios e plots dinâmicos com plotly.
+
+### Resultados
+
+![][image3]
+
+![][image4]
+
+#### Desempenho de Acurácia
+
+- **InternVL2\_5-1B e InternVL2\_5-1B-MPO (≈0,94B):**  
+    
+  - **CNH:** Estes modelos apresentam uma acurácia relativamente melhor na classe CNH, chegando a 61–63%, o que indica uma boa capacidade de extrair dados desse tipo de documento.  
+  - **Geral e RG:** As acurácias gerais ficam em torno de 54–57%, com desempenho estável, embora não se destaquem nas demais categorias.  
+  - **NF:** A acurácia na categoria NF é a mais baixa (cerca de 44%), sinalizando maior dificuldade nessa classe.
+
+
+- **InternVL2\_5-2B-MPO (2,21B):**  
+    
+  - Apesar de ser o dobro em termos de parâmetros em relação aos modelos de 1B, observa-se uma queda significativa na acurácia geral (41%) e, especialmente, na categoria NF (apenas 21,85%).  
+  - Esse comportamento pode indicar que o aumento de parâmetros não necessariamente se traduz em melhor desempenho se outros fatores (como treinamento ou arquitetura específica) não forem otimizados.
+
+
+- **Qwen2-VL-2B-Instruct (2,21B):**  
+    
+  - Apresenta uma acurácia geral um pouco superior (55,23%) e se destaca na categoria RG (66,16%), embora na CNH a performance caia para cerca de 55%.  
+  - Isso sugere que, para documentos do tipo RG, esse modelo pode ser mais eficaz, mesmo que o ganho não seja uniforme entre todas as classes.
+
+
+- **h2ovl-mississippi-2b (2,15B):**  
+    
+  - Com resultados próximos dos 2B, a acurácia geral (53,43%) e na classe CNH (52,92%) é similar ou um pouco inferior, mas o desempenho em RG (67,54%) indica que pode ser competitivo em categorias específicas.  
+  - A classe NF fica em torno de 39,81%, também apontando desafios nesse tipo de documento.
+
+
+- **llava-onevision-qwen2-0.5b-ov-hf (0,89B):**  
+    
+  - Entre os modelos menores, este se destaca negativamente, com acurácias baixas em todas as classes (por exemplo, 36,87% no geral e 28,70% em NF), sugerindo que a redução extrema no tamanho pode impactar a capacidade de extração de dados de forma crítica.
+
+#### Tempo de Inferência
+
+- **Modelos de 1B (InternVL2\_5-1B e InternVL2\_5-1B-MPO):**  
+    
+  - Apresentam os tempos de inferência mais rápidos (em média entre 1,33 e 1,54 segundos)
+
+
+- **Modelos de \~2B (InternVL2\_5-2B-MPO, Qwen2-VL-2B-Instruct e h2ovl-mississippi-2b):**  
+    
+  - O InternVL2\_5-2B-MPO tem tempos de inferência um pouco maiores (em torno de 1,96 a 2,19 s), enquanto o Qwen2-VL-2B-Instruct fica entre 2,44 e 2,80 s.  
+  - O h2ovl-mississippi-2b é ainda mais lento, com médias que chegam a 3,04–3,38 s, indicando um trade-off entre o tamanho e a velocidade.
+
+
+- **llava-onevision-qwen2-0.5b-ov-hf:**  
+    
+  - Apesar de ser o menor em termos de parâmetros, seu tempo de inferência (aproximadamente 1,43–1,49 s) é competitivo, mas esse ganho de velocidade não compensa sua acurácia inferior.  
+    
+
+Observamos aqui como uma ferramenta de inferência como o vLLM acelera significativamente a predição. Isso ainda com modelos de vision que demandam alto custo operacional devido ao processamento de imagens.  
+No meu primeiro caso da sumarização um dos pontos críticos era que mesmo alcançando boa acurácia com modelo pequenos servir ele parecia ter grandes desvantagens de latência.   
+De certa forma era uma comparação injusta, realizando a inferência utilizando puramente transformers na gpu do colab com uma api serveless onde as grandes empresas utilizam servidores com milhares de GPUs em paralelo e otimizadas para uma única tarefa.   
+Embora não consigamos alcançar os mesmos custos oferecidos por essas empresas, acredito que nossos modelos podem oferecer desempenhos suficientemente bons para validar a implantação de um modelo generativo próprio.
+
+Estou iniciando um estudo mais profundo das otimizações e formas de servir modelos menores com eficiência.
+
+### Destaques e Considerações
+
+- **Trade-off entre Acurácia e Velocidade:**  
+    
+  - Os modelos de \~1B (InternVL2\_5-1B e sua variante MPO) demonstram que é possível obter uma inferência rápida sem perder muito em termos de acurácia, especialmente em CNH.  
+  - Em contrapartida, os modelos de \~2B, como o Qwen2-VL-2B-Instruct, conseguem melhorar em algumas categorias (como RG), mas isso vem acompanhado de um aumento no tempo de processamento.
+
+
+- **Impacto do Treinamento e Arquitetura:**  
+    
+  - O InternVL2\_5-2B-MPO ilustra que simplesmente aumentar o número de parâmetros não garante melhor desempenho; a metodologia de treinamento (como o uso de MPO) e a arquitetura empregada têm impacto direto nos resultados.  
+  - Já o desempenho inferior do llava-onevision-qwen2-0.5b-ov-hf reforça que reduções extremas podem prejudicar a capacidade de generalização do modelo.
+
+## Ajuste Fino
+
+### Unsloth
+
+Iniciei o processo de treinamento buscando utilizar a unsloth, que é uma ferramenta de otimização na ‘engine’ de treinamento atuando nos kernels e operações tensoriais, em que eu já havia explorado nas primeiras experimentações e já conhecia as dependências e forma de trabalho.
+
+A unsloth iniciou o suporte a modelos de vision no final do ano passado e tem suporte para as arquiteturas llama-vision, qwen2 e qwen2\_5\*, pixtral e llava-v1.6. 
+
+Iniciei explorando o modelo mas recente qwen2\_5, e obtive bons comportamentos durante o treinamento, onde as perdas de treinamento e avaliação tiveram um decaimento de convergência, sem variações bruscas e a princípio nenhuma indicação de overfitting (“perda de treinamento muito abaixo da de avaliação”), e realizando a inferência utilizando o adaptador LoRA através da unsloth o modelo se comportava bem.   
+Porém ao realizar o merge do adaptador com o modelo base e realizar a inferência por meio do vLLM, o modelo gerava respostas completamente diferentes e incorretas.
+
+O merge é o processo de juntar os novos pesos do adaptador criado com o modelo base.
+
+* Atualmente o  vLLM suporta servidores “Multi-Lora”, que é a ideia de ter os adaptadores “in-fly”, e o adaptador a ser utilizado se torna um parâmetro na requisição de inferência, assim é servido apenas um modelo base e múltiplos adaptadores para diferentes tarefas podem atuar na hora da inferência. Isso adiciona um pouco de latência, mas apresenta grandes economias ao implantar um modelo e ganha versatilidade.  
+  * Atualmente ele só suporta adaptador de backbone de linguagem, ou seja apenas adaptadores que vieram do ajuste das camadas de linguagem, não suportando adaptações na camadas de visão. Nesse caso é preciso realizar o merge
+
+
+Depois de alguns testes e interações com a comunidade do discord da unsloth e do hugginface, cheguei a conclusão de que a arquitetura 2.5 ainda não está 100% validada na unsloth. 
+
+No entanto, a arquitetura Qwen2-VL funciona muito bem e consegui fazer o ajuste das versões 2B e 7B.
+
+### Swift
+
+Visando acelerar o processo de finetuning, decide explorar alguns frameworks de treinamento. Eu havia avaliado alguns na minha primeira experimentação na tech, mas decidi criar o código passo a passo com as libs transformers, peft e trl que são a base da grande maioria dos frameworks para eu entender todo o processo. Agora que eu sou capaz de ler e compreender o código por trás das ferramentas achei ser benéfico utilizar uma ferramenta mais alto nível, principalmente no caso de multimodais que eu não tenho tanta experiência e não faria nenhuma alteração muito específica e assim fazendo basicamente um over engineering e copiando códigos das próprias ferramentas e tutoriais. 
+
+Analisando frameworks como LlamaFactory, axoltl, auto-train, adapters e ms-swift, me preocupei com as arquiteturas suportadas, métodos de treinamento, otimizações de memória e facilidade de uso. Decidi utilizar a ferramenta do Model Scope denominada [SWIFT](https://github.com/modelscope/ms-swift). Este é um framework recente lançado no final de 2023, desenvolvido pela equipe do [ModelScope](https://github.com/modelscope/modelscope), vinculada ao Alibaba Group. Ela não tem tanta notoriedade por ser um software “chinês”, e sem muita divulgação, porém a estrutura planejada por eles e os níveis de integrações com os diferentes tipos de tarefas e arquiteturas e métodos de ajuste são superiores em relação aos outros frameworks. Há um paper dos desenvolvedores onde explicam a arquitetura planejada e se comparam com essas outras ferramentas: [\[2408.05517\] SWIFT:A Scalable lightWeight Infrastructure for Fine-Tuning](https://arxiv.org/abs/2408.05517)
+
+ ![][image5]
+
+### Resultados
+
+Não vou me estender aqui a problemas e experimentos de teste, até por terem ocorrido muitos, dessa vez consegui recorrer a ajudas externas nas comunidades e grupos de ML Open Source onde fui resolvendo erros e comportamentos inadequados com cada arquitetura que fui treinar.
+
+Em resumo, realizei o ajuste das arquiteturas 
+
+- Unsloth  
+  - Qwen2-VL 2B e 7B   
+- SWIFT  
+  - Qwe2.5-VL 3B  
+  - InternVL-2\_5-MPO 1B e 4B  
+  - DeepSeek-VL2
+
+* *Tabela comparativa entre todos os modelos*
+
+![][image6]
+
+* Gráfico Scatter Acurácia x Tempo de Inferência x N° Parâmetros
+
+![][image7]
+
+* Tabela em Heatmap
+
+![][image8]
+
+Todos os resultados estão registrados nesta planilha: [Doc Extraction Evaluation - Open Models](https://docs.google.com/spreadsheets/d/1RCB5fCGZSwhVCB9YgLWpeEUkzBovz9Ni26HysnX13qY/edit?gid=1949031965#gid=1949031965)  
+Contém cada resultado de inferência para cada modelo e uma página que compila todos os resultados.
+
+Os registros das experimentações podem ser encontrados no MLFlow: [https://mlflow.tech4.ai/\#/experiments/251?searchFilter=\&orderByKey=attributes.start\_time\&orderByAsc=false\&startTime=ALL\&lifecycleFilter=Active\&modelVersionFilter=All+Runs\&datasetsFilter=W10%3D](https://mlflow.tech4.ai/#/experiments/251?searchFilter=&orderByKey=attributes.start_time&orderByAsc=false&startTime=ALL&lifecycleFilter=Active&modelVersionFilter=All+Runs&datasetsFilter=W10%3D) 
+
+E também no Weights & Biases: [https://wandb.ai/samuel-lima-tech4humans/ocr-finetuning-v2?nw=nwusersamuellima](https://wandb.ai/samuel-lima-tech4humans/ocr-finetuning-v2?nw=nwusersamuellima) 
+
+- Realizei os registros também no wandb para o caso de se tornar registros open source, há maneiras de compartilhar relatórios e métricas de forma segura
+
+Os modelos com ajuste fino (-tuned) demonstram ganhos expressivos em acurácia e eficiência, mesmo em tamanhos reduzidos. Abaixo, a análise detalhada por faixa de parâmetros:
+
+#### Modelos Pequenos (1B–3B)
+
+| Modelo | Parâmetros (B) | Δ Acurácia Geral | Acurácia Geral (%) |
+| :---- | :---- | :---- | :---- |
+| **InternVL2\_5-1B-MPO-tuned** | 0.94 | **\+28.24%** | 54.76 → **83.00** |
+| **Qwen2-VL-2B-Instruct-tuned** | 2.21 | **\+22.38%** | 55.23 → **77.61** |
+| **deepseek-vl2-tiny-tuned** | 3.37 | **\+28.34%** | 50.47 → **78.81** |
+
+- **M**elhorias acima de **20%** em todos os casos, com destaque para o **InternVL2\_5-1B-MPO-tuned** (83% de acurácia geral), superando modelos base de até **8B** (ex: MiniCPM-8.67B, 58.14%).  
+- **Capacidade em Tarefas Complexas**: Acurácia em Nota Fiscal (NF) do InternVL2\_5-1B-MPO-tuned salta de **44,60% → 73,24%**, aproximando-se de modelos grandes não ajustados (ex: Ovis2-4B: 58,70%).
+
+#### Modelos Médios (4B+): 
+
+| Modelo | Parâmetros (B) | Δ Acurácia Geral | Acurácia Geral (%) |
+| :---- | :---- | :---- | :---- |
+| **InternVL2\_5-4B-MPO-tuned** | 3.71 | **\+18.39%** | 68.36 → **86.75** |
+| **Qwen2.5-VL-3B-Instruct-tuned** | 3.75 | **\+17.63%** | 62.04 → **79.67** |
+
+- O **InternVL2\_5-4B-MPO-tuned** atinge **93,95% em CNH** e **89,50% em RG**.  
+- Supera modelos não ajustados de 7B-8B (ex: Qwen2.5-VL-7B: 68,29%) com **40% menos parâmetros**.
+
+#### Modelos Grandes (7B+):
+
+| Modelo | Parâmetros (B) | Δ Acurácia Geral | Acurácia Geral (%) | Δ Tempo (s) |
+| :---- | :---- | :---- | :---- | :---- |
+| **Qwen2-VL-7B-Instruct-tuned** | 8.29 | **\+13.74%** | 64.53 → **78.27** | \-0.04 |
+
+- Ajuste fino em modelos grandes traz melhorias mais modestas (**\+13,74%**) comparado a modelos menores, sugerindo **diminishing returns**.  
+- Acurácia em RG do Qwen2-VL-7B-tuned salta de **65,47% → 82,18%**, útil para casos críticos de precisão.
+
+#### Comparativo Geral: Tamanho vs. Eficácia do Ajuste Fino
+
+| Categoria | Δ Acurácia Média | Δ Tempo Médio |
+| :---- | :---- | :---- |
+| **Pequenos (1B–3B)** | **\+26,32%** | **\-0,18s** |
+| **Médios (4B–4B)** | **\+18,01%** | **\-0,50s** |
+| **Grandes (7B+)** | **\+13,74%** | **\-0,04s** |
+
+- **Quanto menor o modelo, maior o ganho relativo com ajuste fino**.  
+- **Tempo de Inferência:** Houve redução no tempo de inferência em todos os modelos ajustados, pois neles eu não utilizei a ferramenta de saída estrutura que guia o modelo ao json schema. Isso foi feito pois percebi que os modelos se saiam melhor sem essa ferramenta.  
+- **NF permanece desafio**: Mesmo com tuning, acurácia máxima em NF é **76,79%** (InternVL2\_5-4B-tuned), abaixo de CNH/RG.
+
+#### Conclusão
+
+O ajuste fino torna modelos menores competitivos com modelos grandes não ajustados. Não foram feitas tantas experimentações com ajuste de hiperparâmetros, pois passei mais tempo tentando realizar o treinamento em si, e surpreendentemente os experimentos básicos utilizando lora ranks pequenos (2 e 4\) e com a estratégia de decaimento rslora foram resultados muito bons.
+
+## Avaliação de Generalização
+
+Atualmente, estou avaliando o comportamento dos modelos ajustados em documentos e layouts diferentes daqueles vistos durante o treinamento, a fim de identificar eventuais esquecimentos das habilidades básicas do modelo.
+
+Não dispomos de um conjunto de dados robusto que já tenha passado pela API de extração de documentos – contamos apenas com algumas certidões e um número maior de comprovantes de pagamento. Realizei uma pesquisa por datasets brasileiros que contivessem, ao menos, imagens capazes de gerar uma saída estruturada, mas não encontrei alternativas satisfatórias.
+
+Optei, então, por utilizar um dataset em inglês que segue uma lógica semelhante à aplicação, ou seja, utiliza um esquema JSON de entrada para um tipo de documento e gera o JSON de saída esperado ([getomni-ai/ocr-benchmark · Datasets at Hugging Face](https://huggingface.co/datasets/getomni-ai/ocr-benchmark)).
+
+O dataset abrange 18 tipos de documentos com layouts variados e inclui casos complexos com gráficos, tabelas e fotos. Excluí formatos que não contivessem, pelo menos, 5 amostras e, em seguida, ordenei o dataset pelo tamanho do JSON de saída, selecionando 5 amostras de 8 formatos que apresentavam os menores JSONs. Esse procedimento se justifica pelo fato de o dataset conter estruturas bastante complexas, e o objetivo não é avaliar a acurácia absoluta, mas sim a acurácia relativa entre o modelo pré-treinado e sua versão ajustada, a fim de identificar eventuais quedas de desempenho em estruturas não treinadas.
+
+Todo o notebook foi preparado e as avaliações estão em execução no momento.  
+

assets/activations_diagram.md

@@ -0,0 +1,71 @@
+```mermaid
+classDiagram
+    namespace Activations {
+        class IActivation {
+            <<interface>>
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+        }
+        class Activation {
+            <<static>>
+            -Map<ActivateEnum>, IActivation activationMap
+            -Map<String>, ActivateEnum labelMap
+            -Activation() 
+            +static valueOfLabel(String label) ActivateEnum
+            +static create(ActivateEnum type) IActivation
+            +static create(String type) IActivation
+        }
+        class ActivateEnum {
+            <<enumeration>>
+            SIGMOID
+            TANH
+            RELU
+            SOFTMAX
+            SILU
+            LEAKY_RELU
+            LINEAR
+        }
+        class Sigmoid {
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+        }
+        class TanH {
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+        }
+        class ReLU {
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+        }
+        class LeakyReLU {
+            -double alpha
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+            +setAlpha(double alpha) void
+        }
+        class Linear {
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+        }
+        class SiLU {
+            -Sigmoid sigmoid
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+        }
+        class Softmax {
+            +forward(INDArray input) INDArray
+            +backward(INDArray input) INDArray
+        }
+    }
+
+    IActivation <|.. Sigmoid
+    IActivation <|.. TanH
+    IActivation <|.. ReLU
+    IActivation <|.. LeakyReLU
+    IActivation <|.. Linear
+    IActivation <|.. SiLU
+    IActivation <|.. Softmax
+    Activation o--> ActivateEnum
+    Activation <|.. IActivation
+    SiLU ..> Sigmoid
+``` 

assets/data_diagram.md

@@ -0,0 +1,88 @@
+```mermaid
+classDiagram
+    namespace Data {
+        class DataLoader {
+            -INDArray trainData
+            -INDArray testData
+            +DataLoader(String trainDataPath, String testDataPath)
+            +DataLoader(String trainX, String trainY, String testX, String testY)
+            +static INDArray loadCsv(String csvFile)
+            +INDArray getAllTrainImages()
+            +INDArray getAllTestImages()
+            +INDArray getAllTrainLabels()
+            +INDArray getAllTestLabels()
+            +INDArray getTrainImage(int index)
+            +INDArray getTestImage(int index)
+            +int getTrainLabel(int index)
+            +int getTestLabel(int index)
+            +INDArray getTrainData()
+            +INDArray getTestData()
+        }
+
+        class Util {
+            +static INDArray normalize(INDArray array)
+            +static INDArray unnormalize(INDArray array)
+            +static INDArray clip(INDArray array, double min, double max)
+            +static INDArray[][] trainTestSplit(INDArray x, INDArray y, double trainSize)
+            +static void printProgressBar(int current, int total)
+            +static INDArray oneHotEncode(INDArray labels, int numClasses)
+            +static WritableImage arrayToImage(INDArray imageArray, int WIDTH, int HEIGHT)
+            +static WritableImage byteArrayToImage(byte[] byteArray)
+            +static INDArray imageToINDArray(WritableImage writableImage, int width, int height)
+            +static INDArray bytesToINDArray(byte[] bytes, int width, int height)
+            +static INDArray confusionMatrix(INDArray predictions, INDArray labels)
+        }
+
+        class PlotDataPredict {
+            +void plot2d(INDArray x, INDArray y, INDArray predict, String title)
+            +void plot3dGridandScatter(INDArray x, INDArray y, INDArray predict, String title)
+        }
+
+        class DataProcessor {
+            <<abstract>>
+            +abstract void fit(INDArray data)
+            +abstract INDArray transform(INDArray data)
+            +abstract INDArray inverseTransform(INDArray data)
+            +INDArray fitTransform(INDArray data)
+        }
+
+        class DataPipeline {
+            -List<DataProcessor> processors
+            +DataPipeline(List<DataProcessor> processors)
+            +DataPipeline()
+            +void add(DataProcessor processor)
+            +void fit(INDArray data)
+            +INDArray transform(INDArray data)
+            +INDArray fitTransform(INDArray data)
+            +INDArray inverseTransform(INDArray data)
+            +List<DataProcessor> getProcessors()
+        }
+
+        class StandardScaler {
+            -double mean, std
+            -static final double EPSILON
+            +void fit(INDArray data)
+            +INDArray transform(INDArray data)
+            +INDArray inverseTransform(INDArray data)
+            +double getMean()
+            +double getStd()
+        }
+
+        class MinMaxScaler {
+            -INDArray min, max
+            -final double minRange
+            -final double maxRange
+            +MinMaxScaler(double minRange, double maxRange)
+            +MinMaxScaler()
+            +void fit(INDArray data)
+            +INDArray transform(INDArray data)
+            +INDArray inverseTransform(INDArray data)
+        }
+    }
+
+    %% Relationships within Data namespace
+    DataProcessor <|-- StandardScaler
+    DataProcessor <|-- MinMaxScaler
+    DataProcessor <|-- DataPipeline
+    DataPipeline *--> "0..*" DataProcessor: contains
+``` 

assets/database_diagram.md

@@ -0,0 +1,13 @@
+```mermaid
+classDiagram
+    namespace Database {
+        class NeuralNetworkService {
+            -final static String MONGODB_URI
+            -final Datastore datastore
+            +NeuralNetworkService()
+            +void saveModel(NeuralNetwork model)
+            +NeuralNetwork loadModel(String modelName)
+            +List<NeuralNetwork> getAllModels()
+        }
+    }
+``` 

assets/drone_line_following_video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22c81837e66130a2d5ee60dc30cc544ec61683df62516d4a8a1ea61f3a37d34f
+size 131817886

assets/full_diagram.md

@@ -0,0 +1,694 @@
+```mermaid
+classDiagram
+    %% Removido o namespace Activations e cardinalidade complexa %%
+    class IActivation {
+        <<interface>>
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+    }
+    class Activation {
+        <<static>>
+        -Map activationMap %% Simplificado %%
+        -Map labelMap %% Simplificado %%
+        -Activation()
+        +static valueOfLabel(String label) ActivateEnum
+        +static create(ActivateEnum type) IActivation
+        +static create(String type) IActivation
+    }
+    class ActivateEnum {
+        <<enumeration>>
+        SIGMOID
+        TANH
+        RELU
+        SOFTMAX
+        SILU
+        LEAKY_RELU
+        LINEAR
+    }
+    class Sigmoid {
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+    }
+    class TanH {
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+    }
+    class ReLU {
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+    }
+    class LeakyReLU {
+        -double alpha
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+        +setAlpha(double alpha) void
+    }
+    class Linear {
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+    }
+    class SiLU {
+        -Sigmoid sigmoid
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+    }
+    class Softmax {
+        +forward(INDArray input) INDArray
+        +backward(INDArray input) INDArray
+    }
+
+    IActivation <|.. Sigmoid
+    IActivation <|.. TanH
+    IActivation <|.. ReLU
+    IActivation <|.. LeakyReLU
+    IActivation <|.. Linear
+    IActivation <|.. SiLU
+    IActivation <|.. Softmax
+    Activation o--> ActivateEnum
+    Activation <|.. IActivation
+    SiLU ..> Sigmoid
+
+    Dense *--> IActivation
+    Conv2D *--> IActivation
+
+    %% Removido o namespace models %%
+    class ModelBuilder {
+        +layers: List %% Simplificado %%
+        +add(layer:Layer): ModelBuilder
+        +build(): NeuralNetwork
+    }
+    class NeuralNetwork {
+        +id: ObjectId
+        +name: String
+        #layers: List %% Simplificado %%
+        -trainableLayers: List %% Simplificado %%
+        -output: INDArray
+        +NeuralNetwork(modelBuilder:ModelBuilder)
+        #NeuralNetwork()
+        +initTrainableLayers()
+        +getId(): ObjectId
+        +setName(name:String): void
+        +getName(): String
+        +predict(x:INDArray): INDArray
+        +backPropagation(gradout:INDArray): void
+        +getLayers(): List %% Simplificado %%
+        +getTrainableLayers(): List %% Simplificado %%
+        -setLayers(layers:List): void %% Simplificado %%
+        +setTrainable(trainable:boolean): void
+        +setInference(inference:boolean): void
+        +saveModel(String filePath): void
+        +static loadModel(String filePath): NeuralNetwork
+    }
+
+    ModelBuilder --> NeuralNetwork: builds
+    ModelBuilder *--> Layer: contains %% Cardinalidade simplificada %%
+    NeuralNetwork *--> Layer: contains %% Cardinalidade simplificada %%
+    NeuralNetwork *--> TrainableLayer: contains %% Cardinalidade simplificada %%
+    Optimizer o--> NeuralNetwork: manages
+    NeuralNetwork ..> LayerLoader: uses
+
+    %% Removido o namespace Layers %%
+    class Layer {
+        <<abstract>>
+        #INDArray input
+        #INDArray output
+        #boolean inference
+        +INDArray forward(INDArray inputs)*
+        +INDArray backward(INDArray gradout)*
+        +Layer load(DataInputStream dis)
+        +void save(DataOutputStream dos)
+        +void saveAdditional(DataOutputStream dos)*
+        +Layer loadAdditional(DataInputStream dis)*
+        +void setInput(INDArray input)
+        +INDArray getInput()
+        +void setOutput(INDArray output)
+        +INDArray getOutput()
+        +void setInference(boolean inference)
+        +void save(Datastore datastore)
+    }
+    class Flatten {
+        +Flatten()
+        +INDArray forward(INDArray inputs)
+        +INDArray backward(INDArray gradout)
+        +String toString()
+        +Flatten loadAdditional(DataInputStream dis)
+        +void saveAdditional(DataOutputStream dos)
+    }
+    class Dropout {
+        -double dropoutRate
+        -INDArray mask
+        +Dropout(double dropoutRate)
+        +Dropout()
+        +INDArray forward(INDArray inputs)
+        +INDArray backward(INDArray gradout)
+        +String toString()
+        +double getDropoutRate()
+        +void setDropoutRate(double dropoutRate)
+        +INDArray getMask()
+        +void setMask(INDArray mask)
+        +void saveAdditional(DataOutputStream dos)
+        +Dropout loadAdditional(DataInputStream dis)
+    }
+    class ZeroPadding2D {
+        #int padding
+        +ZeroPadding2D(int padding)
+        +ZeroPadding2D()
+        +INDArray forward(INDArray inputs)
+        +INDArray backward(INDArray gradout)
+        +ZeroPadding2D loadAdditional(DataInputStream dis)
+        +void saveAdditional(DataOutputStream dos)
+        +String toString()
+    }
+    class MaxPooling2D {
+        -int poolSize
+        -int stride
+        +MaxPooling2D(int poolSize, int stride)
+        +MaxPooling2D()
+        +INDArray forward(INDArray inputs)
+        +INDArray backward(INDArray gradout)
+        +String toString()
+        +MaxPooling2D loadAdditional(DataInputStream dis)
+        +void saveAdditional(DataOutputStream dos)
+    }
+    class TrainableLayer {
+        <<abstract>>
+        #INDArray params
+        #INDArray grads
+        #boolean trainable
+        #byte[] paramsData
+        #byte[] gradsData
+        +void setup(INDArray input)
+        +INDArray getParams()
+        +void setParams(INDArray params)
+        +INDArray getGrads()
+        +void setGrads(INDArray grads)
+        +void setTrainable(boolean trainable)
+        +boolean isTrainable()
+        +void saveAdditional(DataOutputStream dos)
+        +TrainableLayer loadAdditional(DataInputStream dis)
+    }
+    class Dense {
+        -IActivation activation
+        -String activationType
+        -int units
+        -boolean isInitialized
+        -String kernelInitializer
+        -double lambda
+        +Dense(int units, IActivation activation, String kernelInitializer, double lambda)
+        +Dense(int units, IActivation activation, String kernelInitializer)
+        +Dense(int units, IActivation activation)
+        +Dense(int units)
+        +Dense()
+        +INDArray getWeights()
+        +INDArray getGradientWeights()
+        +INDArray getBias()
+        +INDArray getGradientBias()
+        +void setup(INDArray inputs)
+        +INDArray forward(INDArray inputs)
+        +INDArray backward(INDArray gradout)
+        +IActivation getActivation()
+        +int getUnits()
+        +String getKernelInitializer()
+    }
+    class Conv2D {
+        #int filters
+        #int kernelSize
+        #List strides %% Simplificado %%
+        #String padding
+        #IActivation activation
+        #String activationType
+        #String kernelInitializer
+        #int pad
+        #Layer zeroPadding2D %% Simplificado %%
+        #int m, nHInput, nWInput, nCInput
+        #int nHOutput, nWOutput, nCOutput
+        #boolean isInitialized
+        #INDArray paddedInputs
+        #INDArray weightsC, biasesC, aPrev, aSlicePrev
+        #int[] vert_starts, horiz_starts
+        +Conv2D(int filters, int kernelSize, List strides, String padding, IActivation activation, String kernelInitializer) %% Simplificado %%
+        +Conv2D(int filters, int kernelSize, String padding, IActivation activation, String kernelInitializer)
+        +Conv2D(int filters, int kernelSize, IActivation activation)
+        +Conv2D(int filters, int kernelSize)
+        +Conv2D()
+        +void setup(INDArray inputs)
+        +INDArray forward(INDArray inputs)
+        +INDArray backward(INDArray gradout)
+        +INDArray getWeights()
+        +INDArray getBiases()
+        +void setWeights(INDArray weights)
+        +void setBiases(INDArray biases)
+        +INDArray getGradWeights()
+        +INDArray getGradBiases()
+    }
+    class LayerLoader {
+        -Map layerLoaders %% Simplificado %%
+        +static Layer load(DataInputStream dis)
+    }
+
+    Layer <|-- TrainableLayer : extends
+    TrainableLayer <|-- Dense : extends
+    TrainableLayer <|-- Conv2D : extends
+    Layer <|-- Flatten : extends
+    Layer <|-- Dropout : extends
+    Layer <|-- MaxPooling2D : extends
+    Layer <|-- ZeroPadding2D : extends
+    Conv2D *-- ZeroPadding2D : uses
+    LayerLoader --> Layer : creates
+
+    %% Removido o namespace Optimizers %%
+    class Optimizer {
+        <<abstract>>
+        #NeuralNetwork neuralNetwork
+        #LearningRateDecayStrategy learningRateDecayStrategy
+        #double learningRate
+        #Map auxParams %% Simplificado %%
+        #List trainableLayers %% Simplificado %%
+        -boolean initialized
+
+        +Optimizer()
+        #Optimizer(double learningRate)
+        +Optimizer(LearningRateDecayStrategy learningRateDecayStrategy)
+        +Optimizer(NeuralNetwork neuralNetwork)
+        +setNeuralNetwork(NeuralNetwork neuralNetwork)
+        #init()
+        +update()
+        +updateEpoch()
+        #abstract List createAuxParams(INDArray params) %% Simplificado %%
+        #abstract void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class LearningRateDecayStrategy {
+        <<abstract>>
+        #double decayPerEpoch
+        #double learningRate
+
+        +LearningRateDecayStrategy(double initialRate, double finalRate, int epochs)
+        #abstract double calculateDecayPerEpoch(double initialRate, double finalRate, int epochs)
+        +abstract double updateLearningRate()
+    }
+
+    class ExponentialDecayStrategy {
+        +ExponentialDecayStrategy(double initialRate, double finalRate, int epochs)
+        #double calculateDecayPerEpoch(double initialRate, double finalRate, int epochs)
+        +double updateLearningRate()
+    }
+
+    class LinearDecayStrategy {
+        +LinearDecayStrategy(double initialRate, double finalRate, int epochs)
+        #double calculateDecayPerEpoch(double initialRate, double finalRate, int epochs)
+        +double updateLearningRate()
+    }
+
+    class SGD {
+        +SGD(double learningRate)
+        +SGD(LearningRateDecayStrategy learningRateDecayStrategy)
+        +SGD()
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class SGDMomentum {
+        -double momentum
+        -INDArray velocities
+
+        +SGDMomentum(double learningRate, double momentum)
+        +SGDMomentum(double learningRate)
+        +SGDMomentum(LearningRateDecayStrategy learningRateDecayStrategy, double momentum)
+        +SGDMomentum(LearningRateDecayStrategy learningRateDecayStrategy)
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class SGDNesterov {
+        -double momentum
+        -INDArray velocities
+
+        +SGDNesterov(double learningRate, double momentum)
+        +SGDNesterov(double learningRate)
+        +SGDNesterov(LearningRateDecayStrategy learningRateDecayStrategy, double momentum)
+        +SGDNesterov(LearningRateDecayStrategy learningRateDecayStrategy)
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class RegularizedSGD {
+        -double alpha
+
+        +RegularizedSGD(double learningRate, double alpha)
+        +RegularizedSGD()
+        +RegularizedSGD(double learningRate)
+        +RegularizedSGD(LearningRateDecayStrategy learningRateDecayStrategy)
+        +RegularizedSGD(LearningRateDecayStrategy learningRateDecayStrategy, double alpha)
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class AdaGrad {
+        -double eps
+        -INDArray sumSquares
+
+        +AdaGrad(double lr)
+        +AdaGrad()
+        +AdaGrad(LearningRateDecayStrategy learningRateDecayStrategy)
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class RMSProp {
+        -double decayRate
+        -double epsilon
+        -INDArray accumulator
+
+        +RMSProp(double learningRate, double decayRate, double epsilon)
+        +RMSProp(LearningRateDecayStrategy learningRateDecayStrategy, double decayRate, double epsilon)
+        +RMSProp(LearningRateDecayStrategy learningRateDecayStrategy)
+        +RMSProp()
+        +RMSProp(double learningRate, double decayRate)
+        +RMSProp(double learningRate)
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class Adam {
+        -double beta1
+        -double beta2
+        -double epsilon
+        -INDArray m
+        -INDArray v
+        -int t
+
+        +Adam(double learningRate, double beta1, double beta2, double epsilon)
+        +Adam(double learningRate)
+        +Adam()
+        +Adam(LearningRateDecayStrategy learningRateDecayStrategy, double beta1, double beta2, double epsilon)
+        +Adam(LearningRateDecayStrategy learningRateDecayStrategy)
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    class AdaDelta {
+        -double decayRate
+        -double epsilon
+        -INDArray accumulator
+        -INDArray delta
+
+        +AdaDelta(double decayRate, double epsilon)
+        +AdaDelta(double decayRate)
+        +AdaDelta()
+        #List createAuxParams(INDArray params) %% Simplificado %%
+        #void updateRule(INDArray params, INDArray grads, List auxParams) %% Simplificado %%
+    }
+
+    Optimizer <|-- SGD
+    Optimizer <|-- SGDMomentum
+    Optimizer <|-- SGDNesterov
+    Optimizer <|-- RegularizedSGD
+    Optimizer <|-- AdaGrad
+    Optimizer <|-- RMSProp
+    Optimizer <|-- Adam
+    Optimizer <|-- AdaDelta
+
+    LearningRateDecayStrategy <|-- LinearDecayStrategy
+    LearningRateDecayStrategy <|-- ExponentialDecayStrategy
+
+    Optimizer o-- LearningRateDecayStrategy
+
+    TrainableLayer <--o Optimizer: trainableLayers %% Cardinalidade simplificada %%
+
+    %% Removido o namespace Losses %%
+    class ILossFunction {
+        <<interface>>
+        +INDArray forward(INDArray predicted, INDArray real)
+        +INDArray backward(INDArray predicted, INDArray real)
+    }
+
+    class MeanSquaredError {
+        +INDArray forward(INDArray predictions, INDArray labels)
+        +INDArray backward(INDArray predictions, INDArray labels)
+    }
+
+    class BinaryCrossEntropy {
+        +INDArray forward(INDArray predictions, INDArray labels)
+        +INDArray backward(INDArray predictions, INDArray labels)
+    }
+
+    class CategoricalCrossEntropy {
+        -double eps
+        +INDArray forward(INDArray predicted, INDArray real)
+        +INDArray backward(INDArray predicted, INDArray real)
+    }
+
+    class SoftmaxCrossEntropy {
+        -double eps
+        -boolean singleClass
+        -INDArray softmaxPreds
+        -Softmax softmax
+        +SoftmaxCrossEntropy()
+        +SoftmaxCrossEntropy(double eps)
+        +INDArray forward(INDArray predicted, INDArray real)
+        +INDArray backward(INDArray predicted, INDArray real)
+    }
+
+    ILossFunction <|.. MeanSquaredError
+    ILossFunction <|.. BinaryCrossEntropy
+    ILossFunction <|.. CategoricalCrossEntropy
+    ILossFunction <|.. SoftmaxCrossEntropy
+
+    %% Removido o namespace Metrics %%
+    class IMetric {
+        <<interface>>
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class MSE {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class RMSE {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class MAE {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class R2 {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class Accuracy {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class Precision {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class Recall {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    class F1Score {
+        +double evaluate(INDArray yTrue, INDArray yPred)
+    }
+
+    IMetric <|.. MSE
+    IMetric <|.. RMSE
+    IMetric <|.. MAE
+    IMetric <|.. R2
+    IMetric <|.. Accuracy
+    IMetric <|.. Precision
+    IMetric <|.. Recall
+    IMetric <|.. F1Score
+
+    F1Score ..> Precision
+    F1Score ..> Recall
+
+    %% Removido o namespace Train %%
+    class TrainerBuilder {
+        +batch: INDArray[2]
+        +trainInputs: INDArray
+        +trainTargets: INDArray
+        +testInputs: INDArray
+        +testTargets: INDArray
+        +epochs: int = 100
+        +batchSize: int = 32
+        +earlyStopping: boolean = false
+        +verbose: boolean = true
+        +patience: int = 20
+        +evalEvery: int = 10
+        +trainRatio: double = 0.8
+
+        +TrainerBuilder(model:NeuralNetwork, trainInputs:INDArray, trainTargets:INDArray, lossFunction:ILossFunction)
+        +TrainerBuilder(model:NeuralNetwork, trainInputs:INDArray, trainTargets:INDArray, testInputs:INDArray, testTargets:INDArray, lossFunction:ILossFunction)
+        +setOptimizer(optimizer:Optimizer): TrainerBuilder
+        +setEpochs(epochs:int): TrainerBuilder
+        +setBatchSize(batchSize:int): TrainerBuilder
+        +setEarlyStopping(earlyStopping:boolean): TrainerBuilder
+        +setPatience(patience:int): TrainerBuilder
+        +setTrainRatio(trainRatio:double): TrainerBuilder
+        +setEvalEvery(evalEvery:int): TrainerBuilder
+        +setVerbose(verbose:boolean): TrainerBuilder
+        +setMetric(metric:IMetric): TrainerBuilder
+        +build(): Trainer
+    }
+
+    class Trainer {
+        -model: NeuralNetwork
+        -optimizer: Optimizer
+        -lossFunction: ILossFunction
+        -metric: IMetric
+        -trainInputs: INDArray
+        -trainTargets: INDArray
+        -testInputs: INDArray
+        -testTargets: INDArray
+        -batch: INDArray[2]
+        -epochs: int
+        -batchSize: int
+        -currentIndex: int
+        -patience: int
+        -evalEvery: int
+        -earlyStopping: boolean
+        -verbose: boolean
+        -bestLoss: double
+        -wait: int
+        -threshold: double
+        -trainLoss: double
+        -valLoss: double
+        -trainMetricValue: double
+        -valMetricValue: double
+
+        +Trainer(TrainerBuilder)
+        +fit(): void
+        +evaluate(): void
+        -earlyStopping(): boolean
+        -hasNextBatch(): boolean
+        -getNextBatch(): void
+        +splitData(inputs:INDArray, targets:INDArray, trainRatio:double): void
+        +printDataInfo(): void
+        +getTrainInputs(): INDArray
+        +getTrainTargets(): INDArray
+        +getTestInputs(): INDArray
+        +getTestTargets(): INDArray
+    }
+
+    TrainerBuilder --> Trainer: builds
+    TrainerBuilder o--> NeuralNetwork: model
+    TrainerBuilder o--> ILossFunction: lossFunction
+    TrainerBuilder o--> IMetric: metric
+    TrainerBuilder o--> Optimizer: optimizer
+
+    Trainer *--> NeuralNetwork: model
+    Trainer *--> Optimizer: optimizer
+    Trainer *--> ILossFunction: lossFunction
+    Trainer *--> IMetric: metric
+
+    %% Removido o namespace Data %%
+    class DataLoader {
+        -INDArray trainData
+        -INDArray testData
+        +DataLoader(String trainDataPath, String testDataPath)
+        +DataLoader(String trainX, String trainY, String testX, String testY)
+        +static INDArray loadCsv(String csvFile)
+        +INDArray getAllTrainImages()
+        +INDArray getAllTestImages()
+        +INDArray getAllTrainLabels()
+        +INDArray getAllTestLabels()
+        +INDArray getTrainImage(int index)
+        +INDArray getTestImage(int index)
+        +int getTrainLabel(int index)
+        +int getTestLabel(int index)
+        +INDArray getTrainData()
+        +INDArray getTestData()
+    }
+
+    class Util {
+        +static INDArray normalize(INDArray array)
+        +static INDArray unnormalize(INDArray array)
+        +static INDArray clip(INDArray array, double min, double max)
+        +static INDArray[][] trainTestSplit(INDArray x, INDArray y, double trainSize)
+        +static void printProgressBar(int current, int total)
+        +static INDArray oneHotEncode(INDArray labels, int numClasses)
+        +static WritableImage arrayToImage(INDArray imageArray, int WIDTH, int HEIGHT)
+        +static WritableImage byteArrayToImage(byte[] byteArray)
+        +static INDArray imageToINDArray(WritableImage writableImage, int width, int height)
+        +static INDArray bytesToINDArray(byte[] bytes, int width, int height)
+        +static INDArray confusionMatrix(INDArray predictions, INDArray labels)
+    }
+
+    class PlotDataPredict {
+        +void plot2d(INDArray x, INDArray y, INDArray predict, String title)
+        +void plot3dGridandScatter(INDArray x, INDArray y, INDArray predict, String title)
+    }
+
+    class DataProcessor {
+        <<abstract>>
+        +abstract void fit(INDArray data)
+        +abstract INDArray transform(INDArray data)
+        +abstract INDArray inverseTransform(INDArray data)
+        +INDArray fitTransform(INDArray data)
+    }
+
+    class DataPipeline {
+        -List processors %% Simplificado %%
+        +DataPipeline(List processors) %% Simplificado %%
+        +DataPipeline()
+        +void add(DataProcessor processor)
+        +void fit(INDArray data)
+        +INDArray transform(INDArray data)
+        +INDArray fitTransform(INDArray data)
+        +INDArray inverseTransform(INDArray data)
+        +List getProcessors() %% Simplificado %%
+    }
+
+    class StandardScaler {
+        -double mean, std
+        -static final double EPSILON
+        +void fit(INDArray data)
+        +INDArray transform(INDArray data)
+        +INDArray inverseTransform(INDArray data)
+        +double getMean()
+        +double getStd()
+    }
+
+    class MinMaxScaler {
+        -INDArray min, max
+        -final double minRange
+        -final double maxRange
+        +MinMaxScaler(double minRange, double maxRange)
+        +MinMaxScaler()
+        +void fit(INDArray data)
+        +INDArray transform(INDArray data)
+        +INDArray inverseTransform(INDArray data)
+    }
+
+    %% Removido o namespace Database %%
+    class NeuralNetworkService {
+        -final static String MONGODB_URI
+        -final Datastore datastore
+        +NeuralNetworkService()
+        +void saveModel(NeuralNetwork model)
+        +NeuralNetwork loadModel(String modelName)
+        +List getAllModels() %% Simplificado %%
+    }
+
+    DataProcessor <|-- StandardScaler
+    DataProcessor <|-- MinMaxScaler
+    DataProcessor <|-- DataPipeline
+    DataPipeline *--> DataProcessor: contains %% Cardinalidade simplificada %%
+
+    Trainer ..> Util: uses
+    Trainer ..> DataLoader: uses
+    TrainerBuilder ..> DataLoader: uses
+
+    NeuralNetwork ..> Util: uses
+    TrainableLayer ..> Util: uses
+
+    %% Removida relação models.NeuralNetwork %%
+    Trainer *--> DataLoader: loads data
+
+    NeuralNetwork --o NeuralNetworkService: manages %% Removido namespace Database %%
+    Layer ..> NeuralNetworkService: uses for persistence %% Removido namespace Database %%
+    NeuralNetworkService ..> Datastore: uses
+```

assets/hand_control_arm_video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46180485f0252f79f794fa37e73db029d0c7abe692ed967f417fb1d033a937b0
+size 4119656

assets/layers_diagram.md

@@ -0,0 +1,152 @@
+```mermaid
+classDiagram
+    namespace Layers {
+        class Layer {
+            <<abstract>>
+            #INDArray input
+            #INDArray output
+            #boolean inference
+            +INDArray forward(INDArray inputs)* 
+            +INDArray backward(INDArray gradout)* 
+            +Layer load(DataInputStream dis)
+            +void save(DataOutputStream dos)
+            +void saveAdditional(DataOutputStream dos)*
+            +Layer loadAdditional(DataInputStream dis)*
+            +void setInput(INDArray input)
+            +INDArray getInput()
+            +void setOutput(INDArray output)
+            +INDArray getOutput()
+            +void setInference(boolean inference)
+            +void save(Datastore datastore)
+        }
+        class Flatten {
+            +Flatten()
+            +INDArray forward(INDArray inputs)
+            +INDArray backward(INDArray gradout)
+            +String toString()
+            +Flatten loadAdditional(DataInputStream dis)
+            +void saveAdditional(DataOutputStream dos)
+        }
+        class Dropout {
+            -double dropoutRate
+            -INDArray mask
+            +Dropout(double dropoutRate)
+            +Dropout()
+            +INDArray forward(INDArray inputs)
+            +INDArray backward(INDArray gradout)
+            +String toString()
+            +double getDropoutRate()
+            +void setDropoutRate(double dropoutRate)
+            +INDArray getMask()
+            +void setMask(INDArray mask)
+            +void saveAdditional(DataOutputStream dos)
+            +Dropout loadAdditional(DataInputStream dis)
+        }
+        class ZeroPadding2D {
+            #int padding
+            +ZeroPadding2D(int padding)
+            +ZeroPadding2D()
+            +INDArray forward(INDArray inputs)
+            +INDArray backward(INDArray gradout)
+            +ZeroPadding2D loadAdditional(DataInputStream dis) 
+            +void saveAdditional(DataOutputStream dos)
+            +String toString()
+        }
+        class MaxPooling2D {
+            -int poolSize
+            -int stride
+            +MaxPooling2D(int poolSize, int stride)
+            +MaxPooling2D()
+            +INDArray forward(INDArray inputs)
+            +INDArray backward(INDArray gradout)
+            +String toString()
+            +MaxPooling2D loadAdditional(DataInputStream dis)
+            +void saveAdditional(DataOutputStream dos)
+        }
+        class TrainableLayer {
+            <<abstract>>
+            #INDArray params
+            #INDArray grads
+            #boolean trainable
+            #byte[] paramsData
+            #byte[] gradsData
+            +void setup(INDArray input)
+            +INDArray getParams()
+            +void setParams(INDArray params)
+            +INDArray getGrads()
+            +void setGrads(INDArray grads)
+            +void setTrainable(boolean trainable)
+            +boolean isTrainable()
+            +void saveAdditional(DataOutputStream dos)
+            +TrainableLayer loadAdditional(DataInputStream dis)
+        }
+        class Dense {
+            -IActivation activation
+            -String activationType
+            -int units
+            -boolean isInitialized
+            -String kernelInitializer
+            -double lambda
+            +Dense(int units, IActivation activation, String kernelInitializer, double lambda)
+            +Dense(int units, IActivation activation, String kernelInitializer)
+            +Dense(int units, IActivation activation)
+            +Dense(int units)
+            +Dense()
+            +INDArray getWeights()
+            +INDArray getGradientWeights()
+            +INDArray getBias()
+            +INDArray getGradientBias()
+            +void setup(INDArray inputs)
+            +INDArray forward(INDArray inputs)
+            +INDArray backward(INDArray gradout)
+            +IActivation getActivation()
+            +int getUnits()
+            +String getKernelInitializer()
+        }
+        class Conv2D {
+            #int filters
+            #int kernelSize
+            #List<Integer> strides
+            #String padding
+            #IActivation activation
+            #String activationType
+            #String kernelInitializer
+            #int pad
+            #Layer<ZeroPadding2D> zeroPadding2D
+            #int m, nHInput, nWInput, nCInput
+            #int nHOutput, nWOutput, nCOutput
+            #boolean isInitialized
+            #INDArray paddedInputs
+            #INDArray weightsC, biasesC, aPrev, aSlicePrev
+            #int[] vert_starts, horiz_starts
+            +Conv2D(int filters, int kernelSize, List<Integer> strides, String padding, IActivation activation, String kernelInitializer)
+            +Conv2D(int filters, int kernelSize, String padding, IActivation activation, String kernelInitializer)
+            +Conv2D(int filters, int kernelSize, IActivation activation)
+            +Conv2D(int filters, int kernelSize)
+            +Conv2D()
+            +void setup(INDArray inputs)
+            +INDArray forward(INDArray inputs)
+            +INDArray backward(INDArray gradout)
+            +INDArray getWeights()
+            +INDArray getBiases()
+            +void setWeights(INDArray weights)
+            +void setBiases(INDArray biases)
+            +INDArray getGradWeights()
+            +INDArray getGradBiases()
+        }
+        class LayerLoader {
+            -Map<String>, Supplier<Layer> layerLoaders
+            +static Layer load(DataInputStream dis)
+        }
+    }
+    
+    Layer <|-- TrainableLayer : extends
+    TrainableLayer <|-- Dense : extends
+    TrainableLayer <|-- Conv2D : extends
+    Layer <|-- Flatten : extends
+    Layer <|-- Dropout : extends
+    Layer <|-- MaxPooling2D : extends
+    Layer <|-- ZeroPadding2D : extends
+    Conv2D *-- ZeroPadding2D : uses
+    LayerLoader --> Layer : creates
+``` 

assets/losses_diagram.md

@@ -0,0 +1,43 @@
+```mermaid
+classDiagram
+    namespace Losses {
+        class ILossFunction {
+            <<interface>>
+            +INDArray forward(INDArray predicted, INDArray real)
+            +INDArray backward(INDArray predicted, INDArray real)
+        }
+
+        %% Concrete classes implementing ILossFunction
+        class MeanSquaredError {
+            +INDArray forward(INDArray predictions, INDArray labels)
+            +INDArray backward(INDArray predictions, INDArray labels)
+        }
+
+        class BinaryCrossEntropy {
+            +INDArray forward(INDArray predictions, INDArray labels)
+            +INDArray backward(INDArray predictions, INDArray labels)
+        }
+
+        class CategoricalCrossEntropy {
+            -double eps
+            +INDArray forward(INDArray predicted, INDArray real)
+            +INDArray backward(INDArray predicted, INDArray real)
+        }
+
+        class SoftmaxCrossEntropy {
+            -double eps
+            -boolean singleClass
+            -INDArray softmaxPreds
+            -Softmax softmax
+            +SoftmaxCrossEntropy()
+            +SoftmaxCrossEntropy(double eps)
+            +INDArray forward(INDArray predicted, INDArray real)
+            +INDArray backward(INDArray predicted, INDArray real)
+        }
+    }
+
+    ILossFunction <|.. MeanSquaredError
+    ILossFunction <|.. BinaryCrossEntropy
+    ILossFunction <|.. CategoricalCrossEntropy
+    ILossFunction <|.. SoftmaxCrossEntropy
+``` 

assets/metrics_diagram.md

@@ -0,0 +1,53 @@
+```mermaid
+classDiagram
+    namespace Metrics {
+        class IMetric {
+            <<interface>>
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+        
+        class MSE {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+        
+        class RMSE {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+        
+        class MAE {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+        
+        class R2 {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+        
+        class Accuracy {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+
+        class Precision {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+        
+        class Recall {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+        
+        class F1Score {
+            +double evaluate(INDArray yTrue, INDArray yPred)
+        }
+    }
+
+    IMetric <|.. MSE
+    IMetric <|.. RMSE
+    IMetric <|.. MAE
+    IMetric <|.. R2 
+    IMetric <|.. Accuracy 
+    IMetric <|.. Precision 
+    IMetric <|.. Recall 
+    IMetric <|.. F1Score
+
+    F1Score ..> Precision 
+    F1Score ..> Recall
+``` 

assets/models_diagram.md

@@ -0,0 +1,38 @@
+```mermaid
+classDiagram
+    namespace models {
+        class ModelBuilder {
+            +layers: List<Layer>
+            +add(layer:Layer): ModelBuilder
+            +build(): NeuralNetwork
+        }
+        class NeuralNetwork {
+            +id: ObjectId
+            +name: String = "neural_network_" + UUID.randomUUID()
+            #layers: List<Layer>
+            -trainableLayers: List<TrainableLayer>
+            -output: INDArray
+            +NeuralNetwork(modelBuilder:ModelBuilder)
+            #NeuralNetwork()
+            +initTrainableLayers()
+            +getId(): ObjectId
+            +setName(name:String): void
+            +getName(): String
+            +predict(x:INDArray): INDArray
+            +backPropagation(gradout:INDArray): void
+            +getLayers(): List<Layer>
+            +getTrainableLayers(): List<TrainableLayer>
+            -setLayers(layers:List<Layer>): void
+            +setTrainable(trainable:boolean): void
+            +setInference(inference:boolean): void
+            +saveModel(String filePath): void
+            +static loadModel(String filePath): NeuralNetwork
+        }
+    }
+    
+    %% Relationships for models namespace
+    ModelBuilder --> NeuralNetwork: builds >
+    ModelBuilder *--> "1..*" Layer: contains >
+    NeuralNetwork *--> "1..*" Layer: contains >
+    NeuralNetwork *--> "0..*" TrainableLayer: contains >
+``` 

assets/optimizers_diagram.md

@@ -0,0 +1,164 @@
+```mermaid
+classDiagram
+    namespace Optimizers {
+        class Optimizer {
+            <<abstract>>
+            #NeuralNetwork neuralNetwork
+            #LearningRateDecayStrategy learningRateDecayStrategy
+            #double learningRate
+            #Map<TrainableLayer, List<INDArray> auxParams
+            #List<TrainableLayer> trainableLayers
+            -boolean initialized
+            
+            +Optimizer()
+            #Optimizer(double learningRate)
+            +Optimizer(LearningRateDecayStrategy learningRateDecayStrategy)
+            +Optimizer(NeuralNetwork neuralNetwork)
+            +setNeuralNetwork(NeuralNetwork neuralNetwork)
+            #init()
+            +update()
+            +updateEpoch()
+            #abstract List<INDArray> createAuxParams(INDArray params)
+            #abstract void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+        
+        %% Learning Rate Decay Strategies
+        class LearningRateDecayStrategy {
+            <<abstract>>
+            #double decayPerEpoch
+            #double learningRate
+            
+            +LearningRateDecayStrategy(double initialRate, double finalRate, int epochs)
+            #abstract double calculateDecayPerEpoch(double initialRate, double finalRate, int epochs)
+            +abstract double updateLearningRate()
+        }
+        
+        class ExponentialDecayStrategy {
+            +ExponentialDecayStrategy(double initialRate, double finalRate, int epochs)
+            #double calculateDecayPerEpoch(double initialRate, double finalRate, int epochs)
+            +double updateLearningRate()
+        }
+
+        class LinearDecayStrategy {
+            +LinearDecayStrategy(double initialRate, double finalRate, int epochs)
+            #double calculateDecayPerEpoch(double initialRate, double finalRate, int epochs)
+            +double updateLearningRate()
+        }
+        
+        %% SGD Optimizers
+        class SGD {
+            +SGD(double learningRate)
+            +SGD(LearningRateDecayStrategy learningRateDecayStrategy)
+            +SGD()
+            #List<INDArray< createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+        
+        class SGDMomentum {
+            -double momentum
+            -INDArray velocities
+            
+            +SGDMomentum(double learningRate, double momentum)
+            +SGDMomentum(double learningRate)
+            +SGDMomentum(LearningRateDecayStrategy learningRateDecayStrategy, double momentum)
+            +SGDMomentum(LearningRateDecayStrategy learningRateDecayStrategy)
+            #List<INDArray> createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+        
+        class SGDNesterov {
+            -double momentum
+            -INDArray velocities
+            
+            +SGDNesterov(double learningRate, double momentum)
+            +SGDNesterov(double learningRate)
+            +SGDNesterov(LearningRateDecayStrategy learningRateDecayStrategy, double momentum)
+            +SGDNesterov(LearningRateDecayStrategy learningRateDecayStrategy)
+            #List<INDArray> createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+        
+        class RegularizedSGD {
+            -double alpha
+            
+            +RegularizedSGD(double learningRate, double alpha)
+            +RegularizedSGD()
+            +RegularizedSGD(double learningRate)
+            +RegularizedSGD(LearningRateDecayStrategy learningRateDecayStrategy)
+            +RegularizedSGD(LearningRateDecayStrategy learningRateDecayStrategy, double alpha)
+            #List<INDArray> createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+        
+        %% Adaptive optimizers
+        class AdaGrad {
+            -double eps
+            -INDArray sumSquares
+            
+            +AdaGrad(double lr)
+            +AdaGrad()
+            +AdaGrad(LearningRateDecayStrategy learningRateDecayStrategy)
+            #List<INDArray> createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+        
+        class RMSProp {
+            -double decayRate
+            -double epsilon
+            -INDArray accumulator
+            
+            +RMSProp(double learningRate, double decayRate, double epsilon)
+            +RMSProp(LearningRateDecayStrategy learningRateDecayStrategy, double decayRate, double epsilon)
+            +RMSProp(LearningRateDecayStrategy learningRateDecayStrategy)
+            +RMSProp()
+            +RMSProp(double learningRate, double decayRate)
+            +RMSProp(double learningRate)
+            #List<INDArray> createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+        
+        class Adam {
+            -double beta1
+            -double beta2
+            -double epsilon
+            -INDArray m
+            -INDArray v
+            -int t
+            
+            +Adam(double learningRate, double beta1, double beta2, double epsilon)
+            +Adam(double learningRate)
+            +Adam()
+            +Adam(LearningRateDecayStrategy learningRateDecayStrategy, double beta1, double beta2, double epsilon)
+            +Adam(LearningRateDecayStrategy learningRateDecayStrategy)
+            #List<INDArray> createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray<=> auxParams)
+        }
+        
+        class AdaDelta {
+            -double decayRate
+            -double epsilon
+            -INDArray accumulator
+            -INDArray delta
+            
+            +AdaDelta(double decayRate, double epsilon)
+            +AdaDelta(double decayRate)
+            +AdaDelta()
+            #List<INDArray> createAuxParams(INDArray params)
+            #void updateRule(INDArray params, INDArray grads, List<INDArray> auxParams)
+        }
+    }
+
+    Optimizer <|-- SGD
+    Optimizer <|-- SGDMomentum
+    Optimizer <|-- SGDNesterov
+    Optimizer <|-- RegularizedSGD
+    Optimizer <|-- AdaGrad
+    Optimizer <|-- RMSProp
+    Optimizer <|-- Adam
+    Optimizer <|-- AdaDelta
+    
+    LearningRateDecayStrategy <|-- LinearDecayStrategy
+    LearningRateDecayStrategy <|-- ExponentialDecayStrategy
+    
+    Optimizer o-- LearningRateDecayStrategy
+``` 

assets/quickdraw_game_video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9325d4ad7cfaa771e22c06de3d939922c4fff6f3e88920317ef1bb1488e78d68
+size 18380238

assets/signature_article.md

@@ -0,0 +1,588 @@
+# Open-Source Handwritten Signature Detection Model
+
+<div style="text-align: justify;">
+
+## Abstract
+
+<div style="
+    display: flex; 
+    gap: 24px; 
+    margin: 2em 0; 
+    line-height: 1.6;
+">
+
+  <!-- Left Column - Text -->
+  <div style="flex: 1; padding-right: 16px;">
+    <p style="font-size: 1.1rem; margin-bottom: 1em;">
+      This article presents an <strong>open-source project</strong> for automated signature detection in document processing, structured into four key phases:
+    </p>
+    <ul style="padding-left: 20px; margin-bottom: 1em; font-size: 1rem;">
+      <li><strong>Dataset Engineering:</strong> Curation of a hybrid dataset through aggregation of two public collections.</li>
+      <li><strong>Architecture Benchmarking:</strong> Systematic evaluation of state-of-the-art object detection architectures (<em>YOLO series, DETR variants, and YOLOS</em>), focusing on accuracy, computational efficiency, and deployment constraints.</li>
+      <li><strong>Model Optimization:</strong> Leveraged Optuna for hyperparameter tuning, yielding a 7.94% F1-score improvement over baseline configurations.</li>
+      <li><strong>Production Deployment:</strong> Utilized Triton Inference Server for OpenVINO CPU-optimized inference.</li>
+    </ul>
+    <p style="font-size: 1.1rem; margin-top: 1em;">
+      Experimental results demonstrate a robust balance between precision, recall, and inference speed, validating the solution's practicality for real-world applications.  
+    </p>
+  </div>
+
+  <!-- Right Column - Images -->
+  <div style="
+      flex: 1; 
+      display: flex; 
+      flex-direction: column; 
+      gap: 12px;
+  ">
+    <img src="https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/6AnC1ut7EOLa6EjibXZXY.webp" 
+         style="max-width: 100%; height: auto; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+    <div style="display: flex; gap: 12px;">
+      <img src="https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/jWxcAUZPt8Bzup8kL-bor.webp" 
+           style="flex: 1; max-width: 50%; height: auto; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+      <img src="https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/tzK0lJz7mI2fazpY9pB1w.webp" 
+           style="flex: 1; max-width: 50%; height: auto; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+    </div>
+  </div>
+
+</div>
+
+
+
+<table style="width: 100%; border-collapse: collapse; margin: 25px 0; font-family: 'Segoe UI', sans-serif; font-size: 0.9em;">
+<caption style="font-size: 1.1em; font-weight: 600; margin-bottom: 15px; caption-side: top;">Table 1: Key Research Features</caption>
+<thead>
+<tr style= border-bottom: 2px solid #dee2e6;">
+<th style="padding: 12px 15px; text-align: left; width: 20%;">Resource</th>
+<th style="padding: 12px 15px; text-align: left; width: 35%;">Links / Badges</th>
+<th style="padding: 12px 15px; text-align: left; width: 45%;">Details</th>
+</tr>
+</thead>
+<tbody>
+<tr style="border-bottom: 1px solid #dee2e6;">
+<td style="padding: 12px 15px; vertical-align: top;"><strong>Model Files</strong></td>
+<td style="padding: 12px 15px; vertical-align: top;">
+<a href="https://huggingface.co/tech4humans/yolov8s-signature-detector" target="_blank">
+<img src="https://huggingface.co/datasets/huggingface/badges/resolve/main/model-on-hf-md.svg" alt="HF Model" style="height:24px; margin-right:8px;">
+</a>
+</td>
+<td style="padding: 12px 15px; vertical-align: top;">
+Different formats of the final models<br>
+<span style="display: inline-flex; gap: 8px; margin-top: 6px;">
+<a href="https://pytorch.org/" target="_blank"><img src="https://img.shields.io/badge/PyTorch-%23EE4C2C.svg?style=flat&logo=PyTorch&logoColor=white" alt="PyTorch"></a>
+<a href="https://onnx.ai/" target="_blank"><img src="https://img.shields.io/badge/ONNX-005CED.svg?style=flat&logo=ONNX&logoColor=white" alt="ONNX"></a>
+<a href="https://developer.nvidia.com/tensorrt" target="_blank"><img src="https://img.shields.io/badge/TensorRT-76B900.svg?style=flat&logo=NVIDIA&logoColor=white" alt="TensorRT"></a>
+</span>
+</td>
+</tr>
+
+<tr style="border-bottom: 1px solid #dee2e6;">
+<td style="padding: 12px 15px; vertical-align: top;"><strong>Dataset – Original</strong></td>
+<td style="padding: 12px 15px; vertical-align: top;">
+<a href="https://universe.roboflow.com/tech-ysdkk/signature-detection-hlx8j" target="_blank">
+<img src="https://app.roboflow.com/images/download-dataset-badge.svg" alt="Roboflow" style="height:24px;">
+</a>
+</td>
+<td style="padding: 12px 15px; vertical-align: top;">2,819 document images annotated with signature coordinates</td>
+</tr>
+
+<tr style="border-bottom: 1px solid #dee2e6;">
+<td style="padding: 12px 15px; vertical-align: top;"><strong>Dataset – Processed</strong></td>
+<td style="padding: 12px 15px; vertical-align: top;">
+<a href="https://huggingface.co/datasets/tech4humans/signature-detection" target="_blank">
+<img src="https://huggingface.co/datasets/huggingface/badges/resolve/main/dataset-on-hf-md.svg" alt="HF Dataset" style="height:24px;">
+</a>
+</td>
+<td style="padding: 12px 15px; vertical-align: top;">Augmented and pre-processed version (640px) for model training</td>
+</tr>
+
+<tr style="border-bottom: 1px solid #dee2e6;">
+<td style="padding: 12px 15px; vertical-align: top;"><strong>Notebooks – Model Experiments</strong></td>
+<td style="padding: 12px 15px; vertical-align: top;">
+<span style="display: inline-flex; gap: 8px;">
+<a href="https://colab.research.google.com/drive/1wSySw_zwyuv6XSaGmkngI4dwbj-hR4ix" target="_blank">
+<img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Colab" style="height:24px;">
+</a>
+<a href="https://api.wandb.ai/links/samuel-lima-tech4humans/30cmrkp8" target="_blank">
+<img src="https://img.shields.io/badge/W%26B_Training-FFBE00?style=flat&logo=WeightsAndBiases&logoColor=white" alt="W&B Training" style="height:24px;">
+</a>
+</span>
+</td>
+<td style="padding: 12px 15px; vertical-align: top;">Complete training and evaluation pipeline with selection among different architectures (yolo, detr, rt-detr, conditional-detr, yolos)</td>
+</tr>
+
+<tr style="border-bottom: 1px solid #dee2e6;">
+<td style="padding: 12px 15px; vertical-align: top;"><strong>Notebooks – HP Tuning</strong></td>
+<td style="padding: 12px 15px; vertical-align: top;">
+<span style="display: inline-flex; gap: 8px;">
+<a href="https://colab.research.google.com/drive/1wSySw_zwyuv6XSaGmkngI4dwbj-hR4ix" target="_blank">
+<img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Colab" style="height:24px;">
+</a>
+<a href="https://api.wandb.ai/links/samuel-lima-tech4humans/31a6zhb1" target="_blank">
+<img src="https://img.shields.io/badge/W%26B_HP_Tuning-FFBE00?style=flat&logo=WeightsAndBiases&logoColor=white" alt="W&B HP Tuning" style="height:24px;">
+</a>
+</span>
+</td>
+<td style="padding: 12px 15px; vertical-align: top;">Optuna trials for optimizing the precision/recall balance</td>
+</tr>
+
+<tr style="border-bottom: 1px solid #dee2e6;">
+<td style="padding: 12px 15px; vertical-align: top;"><strong>Inference Server</strong></td>
+<td style="padding: 12px 15px; vertical-align: top;">
+<a href="https://github.com/tech4ai/t4ai-signature-detect-server" target="_blank">
+<img src="https://img.shields.io/badge/Deploy-ffffff?style=for-the-badge&logo=github&logoColor=black" alt="GitHub" style="height:24px;">
+</a>
+</td>
+<td style="padding: 12px 15px; vertical-align: top;">
+Complete deployment and inference pipeline with Triton Inference Server<br>
+<span style="display: inline-flex; gap: 8px; margin-top: 6px;">
+<a href="https://docs.openvino.ai/2025/index.html" target="_blank"><img src="https://img.shields.io/badge/OpenVINO-00c7fd?style=flat&logo=intel&logoColor=white" alt="OpenVINO"></a>
+<a href="https://www.docker.com/" target="_blank"><img src="https://img.shields.io/badge/Docker-2496ED?logo=docker&logoColor=fff" alt="Docker"></a>
+<a href="https://developer.nvidia.com/triton-inference-server" target="_blank"><img src="https://img.shields.io/badge/Triton-Inference%20Server-76B900?labelColor=black&logo=nvidia" alt="Triton"></a>
+</span>
+</td>
+</tr>
+
+<tr style="border-bottom: 1px solid #dee2e6;">
+<td style="padding: 12px 15px; vertical-align: top;"><strong>Live Demo</strong></td>
+<td style="padding: 12px 15px; vertical-align: top;">
+<a href="https://huggingface.co/spaces/tech4humans/signature-detection" target="_blank">
+<img src="https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-hf-spaces-md.svg" alt="HF Space" style="height:24px;">
+</a>
+</td>
+<td style="padding: 12px 15px; vertical-align: top;">
+Graphical interface with real-time inference<br>
+<span style="display: inline-flex; gap: 8px; margin-top: 6px;">
+<a href="https://www.gradio.app/" target="_blank"><img src="https://img.shields.io/badge/Gradio-FF5722?style=flat&logo=Gradio&logoColor=white" alt="Gradio"></a>
+<a href="https://plotly.com/python/" target="_blank"><img src="https://img.shields.io/badge/PLotly-000000?style=flat&logo=plotly&logoColor=white" alt="Plotly"></a>
+</span>
+</td>
+</tr>
+</tbody>
+</table>
+
+---
+
+## 1\. Introduction
+
+The application of automation in document processing has received much attention in both industry and academia. In this context, handwritten signature detection presents certain challenges, including orientation, lighting, noise, document layout, cursive letters in the document content, signatures in varying positions, among others. This paper describes the end-to-end development of a model for this task, including architecture selection, dataset creation, hyperparameter optimization, and production deployment.
+
+---
+
+## 2\. Methodology
+
+### 2.1 Object Detection Architectures
+
+Object detection in computer vision has improved significantly, balancing speed and precision for use cases such as autonomous driving and surveillance applications.
+
+The field has evolved rapidly, with architectures generally falling into certain paradigms:
+
+* CNN-based Two-Stage Detectors: Models from the R-CNN family first identify potential object regions before classifying them
+* CNN-based One-Stage Detectors: YOLO family and SSD models that predict bounding boxes and classes in one pass
+* Transformer-based Detectors: DETR-based models applying attention mechanisms for end-to-end detection
+* Hybrid Architectures: Systems that combine CNN efficiency with Transformer contextual understanding
+* Zero-shot Detectors: Capable of recognizing unfamiliar object classes without specific training
+
+| Model | Architecture/Design | Latency | Applications | Precision (mAP) – Size Variants | Training Frameworks | License | Parameters (M) |
+|-------|------------------|---------|--------------|--------------------------------|---------------------|---------|----------------|
+| [YOLOv8](https://docs.ultralytics.com/models/yolov8/) | CNN (One-Stage), Yolov5 adapt -> C2f Block, SSPF and decoupled head | Very Low (1.47-14.37) [T4 GPU, TensorRT FP16]| Real-time detection, tracking | 37.4–53.9 [n-x] (COCO) | PyTorch, Ultralytics, KerasCV, TensorFlow | AGPL-3.0 | 3.2–68.2 |
+| [YOLOv9](https://docs.ultralytics.com/models/yolov9/) | CNN, GELAN (Generalized Efficient Layer Aggregation Network), Programmable Gradient Information (PGI), CSP-ELAN blocks | Low (2.3-16.77) [T4 GPU, TensorRT FP16] | Real-time detection | 38.3–55.6 [t-e] (COCO) | PyTorch, Ultralytics | GPL-3.0 | 4.5–71.0 |
+| [YOLOv10](https://docs.ultralytics.com/models/yolov10/) | CNN, Consistent Dual Assignments, Holistic Efficiency-Accuracy Design (Lightweight Head, Decoupled Downsampling, Rank-guided Blocks, Large-kernel Conv, Partial Self-Attention) | Very Low (1.84–10.79 ms) [T4 GPU, TensorRT FP16]| Real-time detection | 38.5–54.4 [n-x] (COCO) | PyTorch, Ultralytics | AGPL-3.0 | 2.3–29.5 |
+| [YOLO11](https://docs.ultralytics.com/models/yolo11/) | CNN + Attention, PSA, Dual Label Assignment, C3K2 block | Very Low (1.5-11.3) [T4 GPU, TensorRT FP16] | Real-time detection | 43.5–58.5 [n-x] (COCO) | PyTorch, Ultralytics | AGPL-3.0 | 5.9–89.7 |
+| [RTMDet](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) | CNN (One-Stage), CSPDarkNet, CSP-PAFPN neck, soft label dynamic assignment | Low (2.34–18.8 ms) [T4 GPU, TensorRT FP16] | Real-time detection | 41.1–52.8 [tiny-x] (COCO) | PyTorch, MMDetection | Apache-2.0 | 4.8–94.9 |
+| [DETR](https://huggingface.co/docs/transformers/model_doc/detr) | Transformer (Encoder-Decoder), CNN Backbone (ResNet), Bipartite Matching Loss, Set-based Prediction | Moderate (12–28 ms) [T4 GPU, TensorRT FP16] | Object detection | 42.0–44.0 [R50-R101] (COCO) | PyTorch, Hugging Face, PaddlePaddle | Apache-2.0 | 41–60 |
+| [RT-DETR](https://github.com/PaddlePaddle/PaddleDetection/tree/develop/configs/rtdetr) | Transformer (Encoder-Decoder), Efficient Hybrid Encoder, Uncertainty-Minimal Query Selection, CNN Backbone (ResNet) | Very Low 9.3–13.5 ms (108–74 FPS) [T4 GPU, TensorRT FP16] | Real-time detection | 53.1–56.2 AP [R50-R101] (COCO) | PyTorch, Hugging Face, PaddlePaddle, Ultralytics | Apache-2.0 | 20.0–67.0 |
+| [DETA](https://github.com/jozhang97/DETA) | Transformer (Two-Stage), CNN Backbone, IoU-based Label Assignment, NMS for Post-Processing | Moderate ~100 ms [V100 GPU] | High-precision detection | 50.1-62.9 (COCO) | PyTorch, Detectron2, Hugging Face | Apache-2.0 | 48–52 |
+| [GroundingDINO](https://github.com/IDEA-Research/GroundingDINO) | Transformer-based (DINO + grounded pre-training), dual-encoder-single-decoder, Swin-T/Swin-L image backbone, BERT text backbone, feature enhancer, language-guided query selection, cross-modality decoder | ~119 ms (8.37 FPS on T4 GPU)* | Open-set detection | 52.5 AP (COCO zero-shot), 62.6–63.0 AP (COCO fine-tuned) [Swin-T (172M) / Swin-L (341M)] (COCO) | PyTorch, Hugging Face | Apache-2.0 | 172–341 |
+| [YOLOS](https://github.com/hustvl/YOLOS) | Vision Transformer (ViT) with detection tokens, encoder-only, bipartite matching loss, minimal 2D inductive biases | Moderate (11.9–370.4 ms) [1080Ti GPU] | Object detection | 28.7–42.0 [Tiny-Base] (COCO) | PyTorch, Hugging Face | Apache-2.0 | 6.5–127 |
+<div style="text-align: center; font-size: smaller;">
+<strong>Table 2: Main Neural Network Architectures for Object Detection</strong>
+</div>
+
+> Check this leaderboard for the latest updates on object detection models: [Object Detection Leaderboard](https://leaderboard.roboflow.com/?ref=blog.roboflow.com).
+
+#### Background and Evolution
+Object detection has evolved from the conventional CNN-based models like Faster R-CNN and SSD to more recent transformer-based models like DETR, released in 2020 by Facebook AI. This is targeted at enhancing accuracy through the application of transformer models, which possess a superior capacity for handling global context. Recent models like RT-DETR and YOLOv11 continue to refine this balance, focusing on real-time performance and precision.
+
+##### **YOLO Series**
+
+**You Only Look Once (YOLO)** was introduced in 2016 by Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi, revolutionizing object detection by proposing a *single-stage detector*. While two-stage approaches first create region proposals and then classify and classify them, YOLO predicts *bounding boxes* and object classes in a single pass of the network. This design makes YOLO very fast and ideal for edge devices and real-time computing tasks like security surveillance, traffic monitoring, and industrial inspection.
+
+![](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/GpD0wxX4k3rs-rqpVpuYF.png)  
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 1: YOLO family timeline.<br> Source: <a href="https://blog.roboflow.com/guide-to-yolo-models/">What is YOLO? The Ultimate Guide [2025]</a></strong>
+</div>
+
+Year after year, the YOLO family has been improved over and over again. Each version had new methods and advancements to compensate for the others' weaknesses:
+
+- **YOLOv1:** First to remove region proposals by scanning the entire image in one forward pass, grabbing both global and local context at once.  
+- **YOLOv2 and YOLOv3:** Brought forth major advancements like Feature Pyramid Networks (FPN), multi-scale training, and the application of anchor boxes, improving the model's capability to detect objects of different sizes. 
+- **YOLOv4:** Marked a major architectural upgrade by adopting a CSPDarknet53-PANet-SPP backbone and integrating novel techniques like a *bag of specials*, a *bag of freebies*, genetic algorithms, and attention modules to improve both accuracy and speed.  
+- **YOLOv5:** While architecturally similar to YOLOv4, its implementation in PyTorch and the streamlined training process within the Ultralytics framework contributed to its widespread adoption.  
+- **YOLO-R, YOLO-X, YOLOv6, and YOLOv7:** These versions explored multitask learning (YOLO-R), anchor-free detection, decoupled heads, reparameterization, knowledge distillation, and quantization—allowing improved scaling and optimization of the models.  
+- **YOLOv8 and YOLO-NAS:** YOLOv8 builds upon YOLOv5 with minor changes, such as replacing the CSPLayer with the C2f module, and incorporates optimized loss functions for small object detection. YOLO-NAS stands out as a model generated through neural architecture search (NAS), employing quantization-aware blocks to achieve an optimal balance between speed and accuracy.  
+
+One of the challenges with the YOLO architecture is the large number of different versions, as the name can be used freely, and not all recent versions necessarily bring significant improvements. Indeed, when a new model is released under the YOLO name, it often shows superior metric results, but the differences tend to be minimal.
+
+![](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/bHRDiT5qM0-0II1XXzBN6.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 2: The Incremental Pursuit of SOTA in mAP. <br> Source: Take from video <a href="https://youtu.be/wuZtUMEiKWY?si=cXQAJJVOdvrtIF8z&t=50">YOLOv8: How to Train for Object Detection on a Custom Dataset - Roboflow</a></strong>
+</div>
+
+Moreover, a model achieving superior metrics on a general evaluation dataset, such as COCO, does not necessarily mean it will perform better in your specific use case. There are also differences in model size, inference and training time, library and hardware compatibility, and differences in the characteristics and quality of your data.
+
+![image](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/4FQcW5hSA2_w8aHKRVBW8.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 3: YOLO Performance Comparison.<br> Source: <a href="https://docs.ultralytics.com/pt/models/yolo11/">Ultralytics YOLO11</a></strong>
+</div>
+
+The family is distinguished by its unified and optimized design, making it deployable on low-resource devices and real-time applications. The diversity of YOLO versions presents challenges in choosing the ideal model for a specific use case.
+
+#### **DETR**
+
+The **DEtection TRansformer (DETR)** introduces an innovative approach by combining convolutional neural networks with transformer architecture, eliminating traditional and complex post-processing steps used in other methods, such as *Non-Maximum Suppression (NMS)*.
+
+![](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/U1oKg0tcfrXHBHifC-A0j.jpeg)  
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 4: DETR architecture representation.<br> Source: <a href="https://arxiv.org/pdf/2005.12872">End-to-End Object Detection with Transformers</a></strong>
+</div>
+
+The DETR architecture can be divided into four main components:
+
+1. **Backbone (e.g., ResNet):**  
+   - **Function:** Extract a feature map rich in semantic and spatial information from the input image.  
+   - **Output:** A set of two-dimensional vectors (feature map) that serves as input for the transformer module.  
+
+2. **Transformer Encoder-Decoder:**  
+   - **Encoder:**  
+     - **Function:** Process the feature map from the backbone by applying *multi-head self-attention* and feed-forward layers, capturing global and contextual relationships between different regions of the image.  
+   - **Decoder:**  
+     - **Function:** Use a fixed set of *object queries* (embeddings representing candidate objects) to iteratively refine bounding box and class label predictions.  
+     - **Output:** A final set of predictions, where each *query* corresponds to a bounding box and its respective class.  
+
+3. **Feed-Forward Network (FFN):**  
+   - **Function:** For each query processed by the decoder, the FFN generates the final predictions, including normalized box coordinates (x, y, width, and height) and classification scores (including a special class for "no object").  
+
+4. **Joint Reasoning:**  
+   - **Feature:** DETR processes all objects simultaneously, leveraging *pairwise* relationships between predictions to handle ambiguities such as object overlap, eliminating the need for post-processing techniques like NMS.  
+
+The original DETR faced challenges such as slow convergence and suboptimal performance on small object detection. To address these limitations, improved variants have emerged:
+
+- [**Deformable DETR:**](https://huggingface.co/docs/transformers/model_doc/deformable_detr)  
+   - **Deformable Attention:** Focuses attention on a fixed number of sampling points near each reference, improving efficiency and enabling the detection of fine details in high-resolution images.  
+   - **Multiscale Module:** Incorporates feature maps from different backbone layers, enhancing the model's ability to detect objects of varying sizes.
+
+   ![](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/tQSdHW-SCEMjt_H-nzfGY.png)
+    <div style="text-align: center; font-size: smaller;">
+    <strong>Figure 5: Deformable DETR mitigates the slow convergence issues and limited feature spatial resolution of the original DETR.<br> Source: <a href="https://arxiv.org/abs/2010.04159">Deformable DETR: Deformable Transformers for End-to-End Object Detection</a></strong></div>
+
+
+- [**Conditional DETR:**](https://huggingface.co/docs/transformers/model_doc/conditional_detr) 
+   - **Convergence Improvement:** Introduces conditional cross-attention in the decoder, making the *object queries* more specific to the input image and accelerating training (with reported convergence up to 6.7 times faster). 
+
+   ![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/conditional_detr_curve.jpg)
+    <div style="text-align: center; font-size: smaller;">
+    <strong>Figure 6: Conditional DETR shows faster convergence.<br> Source: <a href="https://arxiv.org/abs/2108.06152">Conditional DETR for Fast Training Convergence</a></strong></div>
+
+Thus, DETR and its variants represent a paradigm shift in object detection, harnessing the power of transformers to capture global and contextual relationships in an end-to-end manner while simplifying the detection pipeline by removing manual post-processing steps.
+
+#### **RT-DETR**
+
+[**RT-DETR (Real-Time DEtection TRansformer)**](https://huggingface.co/docs/transformers/model_doc/rt_detr) is a transformer-based model designed for real-time object detection, extending the foundational DETR architecture with optimizations for speed and efficiency.
+
+![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/rt_detr_overview.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 7: RT-DETR performance comparison.<br> Source: <a href="https://arxiv.org/abs/2304.08069">DETRs Beat YOLOs on Real-time Object Detection</a></strong></div>
+
+1. **Hybrid Encoder**:  
+   - RT-DETR employs a hybrid encoder that integrates **intra-scale interaction** and **cross-scale fusion**. This design enables the model to efficiently process features at different scales, capturing both local details and global relationships.  
+   - This is particularly advantageous for detecting objects of varying sizes in complex scenes, a challenge for earlier transformer models.
+
+2. **Elimination of NMS**:  
+   - Like DETR, RT-DETR eliminates the need for **Non-Maximum Suppression (NMS)** by predicting all objects simultaneously. This end-to-end approach simplifies the detection pipeline and reduces post-processing overhead.
+
+3. **Real-time Optimization**:  
+   - RT-DETR achieves **medium latency (10–200 ms)**, making it suitable for real-time applications such as autonomous driving and video surveillance, while maintaining competitive accuracy.
+
+RT-DETR approximates high-speed CNN-based models like YOLO and accuracy-focused transformer models.
+
+#### **YOLOS**
+
+[**YOLOS (You Only Look at One Sequence)**](https://huggingface.co/docs/transformers/model_doc/yolos) introduces a novel transformer-based approach to object detection, drawing inspiration from the **Vision Transformer (ViT)**. Unlike traditional CNN-based models, YOLOS reimagines object detection by treating images as sequences of patches, leveraging the transformer’s sequence-processing strengths.
+
+![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/yolos_architecture.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 8: YOLOS Architecture representation.<br> Source: <a href="https://arxiv.org/abs/2106.00666">You Only Look at One Sequence: Rethinking Transformer in Vision through Object Detection</a></strong></div>
+
+1. **Vision Transformer (ViT) Backbone**:  
+   - YOLOS uses a ViT backbone, which splits the input image into fixed-size patches (e.g., 16x16 pixels). Each patch is treated as a token, allowing the transformer to process the image as a sequence and capture long-range dependencies.
+
+2. **Patch-based Processing**:  
+   - By converting the image into a sequence of patches, YOLOS efficiently handles high-resolution inputs and detects objects across different scales, making it adaptable to diverse detection tasks.
+
+3. **Object Queries**:  
+   - Similar to DETR, YOLOS employs **object queries** to predict bounding boxes and class labels directly. This eliminates the need for anchor boxes or NMS, aligning with the end-to-end philosophy of transformer-based detection.
+
+4. **Efficiency Variants**:  
+   - YOLOS offers variants such as **yolos-tiny**, **-small**, and **-base**, allowing to balance computational cost and performance based on application needs.
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/GtjC5Z-Xs7dgkibPGosXj.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 9: YOLOS Detection tokens inspect.<br> Source: <a href="https://arxiv.org/abs/2106.00666">You Only Look at One Sequence: Rethinking Transformer in Vision through Object Detection</a></strong></div>
+
+I think this figure is very cool. It illustrates the specialization of [DET] tokens to focus on specific sizes of objects and distinct regions of the image. This adaptive behavior highlights the effectiveness in object detection tasks, allowing the model to dynamically allocate its detection capabilities based on the spatial and scale characteristics of the objects.
+
+---
+
+### 2.2. Dataset Composition and Preprocessing
+
+The dataset was constructed by merging two publicly available benchmarks:
+
+- [**Tobacco800**](https://paperswithcode.com/dataset/tobacco-800): A subset of the Complex Document Image Processing (CDIP) Test Collection, comprising scanned documents from the tobacco industry. Ground truth annotations include signatures and corporate logos.  
+- [**Signatures-XC8UP**](https://universe.roboflow.com/roboflow-100/signatures-xc8up): Part of the [Roboflow 100](https://rf100.org/) benchmark, containing 368 annotated images of handwritten signatures.  
+
+#### Roboflow 
+
+The [Roboflow](https://roboflow.com/) platform was employed for dataset management, preprocessing, and annotation. Key workflow components included:
+
+- **Dataset Partitioning:**  
+  - Training: 1,980 images (70%)  
+  - Validation: 420 images (15%)  
+  - Testing: 419 images (15%)  
+
+- **Preprocessing Pipeline:**  
+  - Auto-orientation and bilinear resampling to 640×640 pixels  
+
+- **Spatial-Augmentation Strategy:**  
+  - Rotation (90° fixed and ±10° random)  
+  - Shear transformations (±4° horizontal, ±3° vertical)  
+  - Photometric adjustments (±20% brightness/exposure variation)  
+  - Stochastic blur (σ=1.5) and Gaussian noise (σ=0.05)  
+
+These techniques enhance model generalization across diverse document acquisition scenarios.
+
+**Dataset Availability:**  
+  - Roboflow Universe:  
+    [![Download Badge](https://app.roboflow.com/images/download-dataset-badge.svg)](https://universe.roboflow.com/tech-ysdkk/signature-detection-hlx8j)  
+  - Hugging Face Datasets Hub:  
+    [![HF Dataset](https://huggingface.co/datasets/huggingface/badges/resolve/main/dataset-on-hf-md.svg)](https://huggingface.co/datasets/tech4humans/signature-detection)  
+
+![](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/_o4PZzTyj17qhUYMLM2Yn.png)  
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 10: Annotated document samples demonstrating signature and logo detection tasks.</strong>
+</div>  
+
+---
+
+### 2.3. Training Process and Model Selection
+
+Various models were evaluated using experiments conducted over 35 training epochs with consistent batch size and learning rate settings, based on the available computational capacity. The table below summarizes the results obtained for metrics such as CPU inference time, mAP@50, mAP@50-95, and total training time:
+
+| Metric | [rtdetr-l](https://github.com/ultralytics/assets/releases/download/v8.2.0/rtdetr-l.pt) | [yolos-base](https://huggingface.co/hustvl/yolos-base) | [yolos-tiny](https://huggingface.co/hustvl/yolos-tiny) | [conditional-detr-resnet-50](https://huggingface.co/microsoft/conditional-detr-resnet-50) | [detr-resnet-50](https://huggingface.co/facebook/detr-resnet-50) | [yolov8x](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x.pt) | [yolov8l](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l.pt) | [yolov8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m.pt) | [yolov8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt) | [yolov8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n.pt) | [yolo11x](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x.pt) | [yolo11l](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l.pt) | [yolo11m](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m.pt) | [yolo11s](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s.pt) | [yolo11n](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt) | [yolov10x](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10x.pt) | [yolov10l](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10l.pt) | [yolov10b](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10b.pt) | [yolov10m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10m.pt) | [yolov10s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10s.pt) | [yolov10n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10n.pt) | [yolo12n](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo12n.pt)  | [yolo12s](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo12s.pt)  | [yolo12m](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo12m.pt)  | [yolo12l](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo12l.pt)  | [yolo12x](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo12x.pt)  |
+| :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- | :---- |
+| **Inference Time (CPU [ONNX] \- ms)** | 583.608 | 1706.49 | 265.346 | 476.831 | 425.649 | 1259.47 | 871.329 | 401.183 | 216.6 | 110.442 | 1016.68 | 518.147 | 381.652 | 179.792 | 106.656 | 821.183 | 580.767 | 473.109 | 320.12 | 150.076 | **73.8596** | 90.36 | 166.572 | 372.803 | 505.747 | 1022.84 |
+| **mAP@50** | 0.92709 | 0.901154 | 0.869814 | **0.936524** | 0.88885 | 0.794237 | 0.800312 | 0.875322 | 0.874721 | 0.816089 | 0.667074 | 0.707409 | 0.809557 | 0.835605 | 0.813799 | 0.681023 | 0.726802 | 0.789835 | 0.787688 | 0.663877 | 0.734332 | 0.75856 | 0.66663 | 0.61959 | 0.54924 | 0.51162 |
+| **mAP@50-95** | 0.622364 | 0.583569 | 0.469064 | 0.653321 | 0.579428 | 0.552919 | 0.593976 | **0.665495** | 0.65457 | 0.623963 | 0.482289 | 0.499126 | 0.600797 | 0.638849 | 0.617496 | 0.474535 | 0.522654 | 0.578874 | 0.581259 | 0.473857 | 0.55274 | 0.55868 | 0.48538 | 0.45616 | 0.41 | 0.35423 |
+| **Training Time** | 55m 33s | 7h 53m | 1h 42m | 2h 45m | 2h 31m | 1h 30m | 1h | 44m 7s | 29m 1s | 22m 51s | 1h 28m | 55m 30s | 48m 2s | 30m 37s | 27m 33s | 1h 36m | 1h 8m | 1h 1m | 51m 38s | 34m 17s | 29m 2s | **20m 6s** | 36m 53s | 1h 8m | 1h 47m | 3h 1m |
+<div style="text-align: center; font-size: smaller;">
+<strong>Table 3. Training Results.</strong>
+</div>
+
+> <strong>Note:</strong> Best values in each category are highlighted. mAP (mean Average Precision) values range from 0-1, with higher values indicating better performance. Inference times measured on CPU using ONNX runtime in milliseconds (ms).
+
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/_kup34OxLYA7tcm6bBs9z.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 11: Comparison of Inference Time vs. mAP@50</strong>
+</div>
+
+**Highlights:**
+
+- **Best mAP@50:** `conditional-detr-resnet-50` (93.65%)  
+- **Best mAP@50-95:** `yolov8m` (66.55%)  
+- **Lowest Inference Time:** `yolov10n` (73.86 ms)
+
+The complete experiments are available on [***Weights & Biases***](https://api.wandb.ai/links/samuel-lima-tech4humans/30cmrkp8).
+
+Our findings reveal a different behavior from general benchmarks, where larger model versions typically yield incremental improvements. In this experiment, smaller models such as YOLOv8n and YOLOv11s achieved satisfactory and comparable results to their larger counterparts.
+
+Furthermore, purely convolutional architectures demonstrated faster inference and training times compared to transformer-based models while maintaining similar levels of accuracy.
+
+---
+
+### 2.4. Hyperparameter Optimization
+
+Due to its strong initial performance and ease of export, the YOLOv8s model was selected for hyperparameter fine-tuning using [Optuna](https://optuna.org/). A total of 20 trials were conducted, with the test set F1-score serving as the objective function. The hyperparameter search space included:
+
+```py
+dropout = trial.suggest_float("dropout", 0.0, 0.5, step=0.1)
+lr0     = trial.suggest_float("lr0", 1e-5, 1e-1, log=True)
+box     = trial.suggest_float("box", 3.0, 7.0, step=1.0)
+cls     = trial.suggest_float("cls", 0.5, 1.5, step=0.2)
+opt     = trial.suggest_categorical("optimizer", ["AdamW", "RMSProp"])
+```
+
+The results of this hypertuning experiment can be viewed here: [***Hypertuning Experiment***](https://api.wandb.ai/links/samuel-lima-tech4humans/31a6zhb1).
+
+The figure below illustrates the correlation between the hyperparameters and the achieved F1-score:
+
+![](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/yXI9HJMs2V0Mhhb65UtZJ.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 12: Correlation between hyperparameters and the F1-score.</strong>
+</div>
+
+After tuning, the best trial (#10) exhibited the following improvements compared to the base model:
+
+| Metric       | Base Model | Best Trial (#10) | Difference |
+|--------------|------------|------------------|------------|
+| mAP@50       | 87.47%     | **95.75%**       | +8.28%     |
+| mAP@50-95    | 65.46%     | **66.26%**       | +0.81%     |
+| Precision    | **97.23%** | 95.61%           | -1.63%     |
+| Recall       | 76.16%     | **91.21%**       | +15.05%    |
+| F1-score     | 85.42%     | **93.36%**       | +7.94%     |
+<div style="text-align: left; font-size: smaller;">
+<strong>Table 4: Comparison between the fine-tuned model and the pre-trained model.</strong>
+</div>
+
+---
+
+## 3\. Evaluation and Results
+
+The final evaluation of the model was conducted using ONNX format (for CPU inference) and TensorRT (for GPU – T4 inference). The key metrics obtained were:
+
+- **Precision:** 94.74%  
+- **Recall:** 89.72%  
+- **mAP@50:** 94.50%  
+- **mAP@50-95:** 67.35%
+
+Regarding inference times:
+
+- **ONNX Runtime (CPU):** 171.56 ms  
+- **TensorRT (GPU – T4):** 7.657 ms
+
+Figure 13 presents a graphical comparison of the evaluated metrics:
+
+![](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/VzLniAUAy8RrdMMM4H49d.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 13. Model performance under different training hyperparameter configurations.</strong>
+</div>
+
+> The Base Model – Phase 1 (☆) represents the model obtained during the selection phase of training.
+
+---
+
+## 4\. Deployment and Publication
+
+In this section, we describe the deployment process of the handwritten signature detection model using the [**Triton Inference Server**](https://github.com/triton-inference-server/server) and the publication of both the model and dataset on the [**Hugging Face Hub**](https://huggingface.co/). The objective was to create an efficient, cost-effective, and secure solution for making the model available in a production environment, while also providing public access to the work in accordance with open science principles.
+
+### 4.1. Inference Server
+
+The **Triton Inference Server** was chosen as the deployment platform due to its flexibility, efficiency, and support for multiple machine learning frameworks, including PyTorch, TensorFlow, ONNX, and TensorRT. It supports inference on both CPU and GPU and offers native tools for performance analysis and optimization, making it ideal for scaling model deployment.
+
+The repository containing the server configurations and utility code is available at: [https://github.com/tech4ai/t4ai-signature-detect-server](https://github.com/tech4ai/t4ai-signature-detect-server)
+
+#### Server Configuration
+
+For the Triton implementation, we opted for an optimized approach using a custom **Docker** container. Instead of using the default image—which includes all backends and results in a size of 17.4 GB, we included only the necessary backends for this project: **Python**, **ONNX**, and **OpenVINO**. This optimization reduced the image size to 12.54 GB, thereby improving deployment efficiency. For scenarios that require GPU inference, the **TensorRT** backend would need to be included and the model would have to be in the .engine format; however, in this case, we prioritized CPU execution to reduce costs and simplify the infrastructure.
+
+The server was configured using the following startup command, which has been adapted to ensure explicit control over models and enhanced security:
+
+```bash
+tritonserver \
+  --model-repository=${TRITON_MODEL_REPOSITORY} \
+  --model-control-mode=explicit \
+  --load-model=* \
+  --log-verbose=1 \
+  --allow-metrics=false \
+  --allow-grpc=true \
+  --grpc-restricted-protocol=model-repository,model-config,shared-memory,statistics,trace:admin-key=${TRITON_ADMIN_KEY} \
+  --http-restricted-api=model-repository,model-config,shared-memory,statistics,trace:admin-key=${TRITON_ADMIN_KEY}
+```
+
+The `explicit` mode allows models to be dynamically loaded and unloaded via HTTP/GRPC protocols, providing the flexibility to update models without restarting the server.
+
+#### Access Restriction
+
+Triton is configured to restrict access to sensitive administrative endpoints such as `model-repository`, `model-config`, `shared-memory`, `statistics`, and `trace`. These endpoints are accessible only to requests that include the correct `admin-key` header, thereby safeguarding administrative operations while leaving inference requests open to all users.
+
+#### Ensemble Model
+
+We developed an **Ensemble Model** within Triton to integrate the **YOLOv8** model (in ONNX format) with dedicated pre- and post-processing scripts, thereby creating a complete inference pipeline executed directly on the server. This approach minimizes latency by eliminating the need for multiple network calls and simplifies client-side integration. The Ensemble Model workflow comprises:
+
+* **Preprocessing (Python backend):**  
+  - Decoding the image from BGR to RGB.  
+  - Resizing the image to 640×640 pixels.  
+  - Normalizing pixel values (dividing by 255.0).  
+  - Transposing the data to the [C, H, W] format.
+
+* **Inference (ONNX model):**  
+  - The YOLOv8 model performs signature detection.
+
+* **Post-processing (Python backend):**  
+  - Transposing the model outputs.  
+  - Filtering bounding boxes based on a confidence threshold.  
+  - Applying **Non-Maximum Suppression (NMS)** with an IoU threshold to eliminate redundant detections.  
+  - Formatting the results in the [x, y, w, h, score] format.
+
+![image](https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/yo7GQagyUXED6gIJKgKq8.png)
+<div style="text-align: center; font-size: smaller;">
+<strong>Figure 14: Sequence Diagram — Ensemble Model</strong>
+</div>
+
+The pre- and post-processing scripts are treated as separate "models" by Triton and are executed on the Python backend, enabling flexibility for adjustments or replacements without modifying the core model. This Ensemble Model encapsulates the entire inference pipeline into a single entry point, thereby optimizing performance and usability.
+
+#### Inference Pipeline
+
+Within the project repository, we developed multiple inference scripts to interact with the Triton Inference Server using various methods:
+
+- **Triton Client:** Inference via the Triton SDK.  
+- **Vertex AI:** Integration with a Google Cloud Vertex AI endpoint.  
+- **HTTP:** Direct requests to the Triton server via the HTTP protocol.
+
+These scripts were designed to test the server and facilitate future integrations. In addition, the pipeline includes supplementary tools:
+
+- **Graphical User Interface (GUI):** Developed with Gradio, this interface enables interactive model testing with real-time visualization of results. For example:
+
+  ```py
+  python signature-detection/gui/inference_gui.py --triton-url {triton_url}
+  ```
+
+  https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/rsR7UNEeucN-felJeizkb.mp4
+
+- **Command-Line Interface (CLI):** This tool allows for batch inference on datasets, timing metrics calculation, and report generation. For example:
+
+  ```py
+  python signature-detection/inference/inference_pipeline.py
+  ```
+
+The pipeline was designed to be modular and extensible, supporting experimentation and deployment in various environments—from local setups to cloud-based infrastructures.
+
+---
+
+### 4.2. Hugging Face Hub
+
+The signature detection model has been published on the **Hugging Face Hub** to make it accessible to the community and to meet the licensing requirements of Ultralytics YOLO. The model repository includes:
+
+- [**Model Card**](https://huggingface.co/tech4humans/yolov8s-signature-detector):  
+  A comprehensive document detailing the training process, performance metrics (such as precision and recall), and usage guidelines. Model files are available in **PyTorch**, **ONNX**, and **TensorRT** formats, offering flexibility in selecting the inference backend.
+
+- [**Demo Space**](https://huggingface.co/spaces/tech4humans/signature-detection):  
+  An interactive interface developed with **Gradio**, where users can test the model by uploading images and viewing real-time detections.
+
+- [**Dataset**](https://huggingface.co/datasets/tech4humans/signature-detection):  
+  The dataset used for training and validation is also hosted on Hugging Face, alongside Roboflow, accompanied by comprehensive documentation and files in accessible formats.
+
+---
+
+## 5. Conclusion
+
+This work demonstrated the feasibility of developing an efficient model for handwritten signature detection in documents by combining modern computer vision techniques with robust deployment tools. The comparative analysis of architectures revealed that YOLO-based models—particularly YOLOv8s—offer an ideal balance between speed and accuracy for the studied scenario, achieving **94.74% precision** and **89.72% recall** following hyperparameter optimization with Optuna. The integration of the Triton Inference Server enabled the creation of a scalable inference pipeline, while publication on the Hugging Face Hub ensured transparency and accessibility, in line with open science principles.
+
+The proposed solution has immediate applications in fields such as legal, financial, and administrative sectors, where automating document verification can reduce operational costs and minimize human error. The model’s inference performance on both CPU (171.56 ms) and GPU (7.65 ms) makes it versatile for deployment across a range of infrastructures, from cloud servers to edge devices.
+
+Limitations include the reliance on the quality of dataset annotations and the need for further validation on documents with complex layouts or partially obscured signatures. Future work may explore:
+- Expanding the dataset to include images with greater cultural and typographic diversity.
+- Adapting the model to detect other document elements (e.g., stamps, seals).
+
+Ultimately, the open availability of the code, model, and dataset on the Hugging Face Hub and GitHub fosters community collaboration, accelerating the development of similar solutions. This project not only validates the efficacy of the tested approaches but also establishes a blueprint for the practical deployment of detection models in production, reinforcing the potential of AI to transform traditional workflows.
+
+</div>

assets/train_diagram.md

@@ -0,0 +1,83 @@
+```mermaid
+classDiagram
+    namespace Train {
+        class TrainerBuilder {
+            +batch: INDArray[2]
+            +trainInputs: INDArray
+            +trainTargets: INDArray
+            +testInputs: INDArray
+            +testTargets: INDArray
+            +epochs: int = 100
+            +batchSize: int = 32
+            +earlyStopping: boolean = false
+            +verbose: boolean = true
+            +patience: int = 20
+            +evalEvery: int = 10
+            +trainRatio: double = 0.8
+            
+            +TrainerBuilder(model:NeuralNetwork, trainInputs:INDArray, trainTargets:INDArray, lossFunction:ILossFunction)
+            +TrainerBuilder(model:NeuralNetwork, trainInputs:INDArray, trainTargets:INDArray, testInputs:INDArray, testTargets:INDArray, lossFunction:ILossFunction)
+            +setOptimizer(optimizer:Optimizer): TrainerBuilder
+            +setEpochs(epochs:int): TrainerBuilder
+            +setBatchSize(batchSize:int): TrainerBuilder
+            +setEarlyStopping(earlyStopping:boolean): TrainerBuilder
+            +setPatience(patience:int): TrainerBuilder
+            +setTrainRatio(trainRatio:double): TrainerBuilder
+            +setEvalEvery(evalEvery:int): TrainerBuilder
+            +setVerbose(verbose:boolean): TrainerBuilder
+            +setMetric(metric:IMetric): TrainerBuilder
+            +build(): Trainer
+        }
+        
+        class Trainer {
+            -model: NeuralNetwork
+            -optimizer: Optimizer
+            -lossFunction: ILossFunction
+            -metric: IMetric
+            -trainInputs: INDArray
+            -trainTargets: INDArray
+            -testInputs: INDArray
+            -testTargets: INDArray
+            -batch: INDArray[2]
+            -epochs: int
+            -batchSize: int
+            -currentIndex: int
+            -patience: int
+            -evalEvery: int
+            -earlyStopping: boolean
+            -verbose: boolean
+            -bestLoss: double
+            -wait: int
+            -threshold: double
+            -trainLoss: double
+            -valLoss: double
+            -trainMetricValue: double
+            -valMetricValue: double
+            
+            +Trainer(TrainerBuilder)
+            +fit(): void
+            +evaluate(): void
+            -earlyStopping(): boolean
+            -hasNextBatch(): boolean
+            -getNextBatch(): void
+            +splitData(inputs:INDArray, targets:INDArray, trainRatio:double): void
+            +printDataInfo(): void
+            +getTrainInputs(): INDArray
+            +getTrainTargets(): INDArray
+            +getTestInputs(): INDArray
+            +getTestTargets(): INDArray
+        }
+    }
+    
+    %% Relationships for Train namespace
+    TrainerBuilder --> Trainer: builds >
+    TrainerBuilder o--> NeuralNetwork: model
+    TrainerBuilder o--> ILossFunction: lossFunction
+    TrainerBuilder o--> IMetric: metric
+    TrainerBuilder o--> Optimizer: optimizer
+    
+    Trainer *--> NeuralNetwork: model
+    Trainer *--> Optimizer: optimizer
+    Trainer *--> ILossFunction: lossFunction
+    Trainer *--> IMetric: metric
+``` 

pages/1_black_bee_drones.py

@@ -0,0 +1,337 @@
+import streamlit as st
+import plotly.graph_objects as go
+from streamlit_extras.badges import badge
+import sys
+import os
+
+# Add the root directory to the path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import helper functions
+from utils.helpers import display_asset_or_placeholder, display_iframe_or_link
+
+# Set page configuration
+st.set_page_config(
+    page_title="Black Bee Drones | CV Journey",
+    page_icon="assets/black_bee.png",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Title and introduction
+st.header("🐝 Black Bee Drones - Autonomous Missions")
+
+st.markdown(
+    """
+### First Autonomous Drone Team in Latin America
+
+I joined the Black Bee Drones team in 2023 as a software member and continue to this day. The team, based at UNIFEI,
+focuses on indoor and outdoor autonomous mission competitions, and we build our own drones from the ground up.
+
+**Key Focus Areas:**
+- Autonomous indoor/outdoor missions
+- Custom drone building and integration
+- Software development for autonomous flight
+- Computer vision algorithms for navigation and object detection
+
+**Main Competition:** International Micro Air Vehicles (IMAV) Conference and Competition
+
+**Notable Achievement:** 3rd place in IMAV 2023 Indoor competition with a special award for being 
+the only team to perform the flight completely autonomously.
+"""
+)
+
+# Create columns for team structure
+st.subheader("Team Structure")
+col1, col2, col3, col4 = st.columns(4)
+
+with col1:
+    st.markdown("#### Hardware Team")
+    st.markdown(
+        """
+    - Controller boards (PixHawk)
+    - Onboard computers (Raspberry Pi 4)
+    - Cameras (RaspCam, Oak-D)
+    - Positioning systems (GPS, LiDAR)
+    """
+    )
+
+with col2:
+    st.markdown("#### Software Team")
+    st.markdown(
+        """
+    - Computer Vision algorithms
+    - Mapping & localization
+    - Position estimation
+    - Autonomous control
+    """
+    )
+
+with col3:
+    st.markdown("#### Mechanics Team")
+    st.markdown(
+        """
+    - Frame design
+    - 3D printing
+    - Propulsion systems
+    - Component arrangement
+    """
+    )
+
+with col4:
+    st.markdown("#### Management Team")
+    st.markdown(
+        """
+    - Competition strategy
+    - Documentation
+    - Team organization
+    - Resource allocation
+    """
+    )
+
+st.markdown("---")
+
+# Technologies section
+st.subheader("Core Technologies & Concepts")
+
+tech_tab1, tech_tab2, tech_tab3 = st.tabs(
+    ["Software Stack", "CV Techniques", "Hardware Components"]
+)
+
+with tech_tab1:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown(
+            """
+        #### Main Software Tools
+        - **OpenCV:** Image processing and computer vision
+        - **ROS (Robot Operating System):** Distributed computing for robotics
+        - **TensorFlow/PyTorch:** Deep learning frameworks
+        - **Docker:** Containerization for deployment
+        - **MAVLink/MAVROS:** Drone communication protocols
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        #### Programming Languages
+        - **Python:** Main language for CV and high-level control
+        - **C++:** Performance-critical components and ROS nodes
+        """
+        )
+
+with tech_tab2:
+    st.markdown(
+        """
+    #### Computer Vision & AI Techniques
+    - **Basic Image Processing:** Filters, morphological operations, thresholding
+    - **Feature Detection:** Corners, edges, and contours
+    - **Marker Detection:** ArUco markers for localization
+    - **Object Detection:** Custom models for mission-specific objects
+    - **Line Following:** Color segmentation and path estimation
+    - **Hand/Face Detection:** Using MediaPipe for gesture control
+    - **Visual Odometry:** For position estimation in GPS-denied environments
+    """
+    )
+
+with tech_tab3:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown(
+            """
+        #### Control & Computing
+        - **PixHawk:** Flight controller board
+        - **Raspberry Pi 4:** Onboard computer
+        - **ESCs & Motors:** Propulsion system
+        - **Battery:** Power source
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        #### Sensors & Perception
+        - **RaspCam/Oak-D:** Cameras for visual perception
+        - **GPS:** Outdoor positioning (when available)
+        - **LiDAR:** Distance sensing and mapping
+        - **RealSense T265:** Visual-inertial odometry
+        - **PX4 Flow:** Optical flow sensor for position holding
+        """
+        )
+
+st.markdown("---")
+
+# OpenCV Demo section
+st.subheader("Demo: Real-time OpenCV Operations")
+
+st.markdown(
+    """
+Basic image processing is fundamental to drone perception. This demo showcases real-time:
+- Various image filters and transformations
+- ArUco marker detection (used for drone localization)
+- Hand and face detection using MediaPipe
+"""
+)
+
+display_iframe_or_link("https://samuellimabraz-opencv-gui.hf.space", height=800)
+
+st.caption(
+    "Link to Hugging Face Space: [OpenCV GUI Demo](https://samuellimabraz-opencv-gui.hf.space)"
+)
+
+st.markdown("---")
+
+# Line Following Challenge
+st.subheader("IMAV 2023 Indoor Mission: Line Following Challenge")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown(
+        """
+    ### The Challenge
+    
+    The [IMAV 2023 Indoor](https://2023.imavs.org/index.php/indoor-competition/) Mission required drones to:
+    
+    1. Navigate using ArUco markers for initial positioning
+    2. Follow a colored line on the floor to reach a deposit location
+    3. Deliver a block autonomously
+    
+    This mission tested precise control, vision-based navigation, and autonomous decision-making.
+    """
+    )
+
+    display_asset_or_placeholder(
+        "imav_mission_diagram.jpg",
+        caption="Diagram of the IMAV 2023 Indoor Mission",
+        use_column_width=True,
+    )
+
+with col2:
+    st.markdown(
+        """
+    ### Line Following Algorithm
+    
+    I developed a robust line-following algorithm consisting of:
+    
+    1. **Color Filtering:** Isolate the colored line using HSV thresholding in OpenCV
+    2. **Line Detection & Orientation:** Estimate the line's position and direction
+    3. **PID Controller:** Adjust the drone's heading based on the line's position relative to the center
+    
+    The algorithm was robust to varying lighting conditions and line widths, which was crucial for the competition environment.
+    """
+    )
+
+    # Create a simple PID visualization
+    st.markdown("#### PID Control Visualization")
+
+    fig = go.Figure()
+
+    # Create data for the PID controller visualization
+    import numpy as np
+
+    # Time points
+    t = np.linspace(0, 10, 100)
+
+    # Target (setpoint)
+    setpoint = np.ones_like(t) * 0
+
+    # PID response for roll (center line error)
+    center_error = np.sin(t) * np.exp(-0.3 * t)
+    roll_output = -center_error * 0.8
+
+    # PID response for yaw (angle error)
+    angle_error = np.cos(t) * np.exp(-0.4 * t)
+    yaw_output = -angle_error * 0.7
+
+    # Add traces
+    fig.add_trace(
+        go.Scatter(
+            x=t,
+            y=setpoint,
+            mode="lines",
+            name="Setpoint",
+            line=dict(color="green", width=2, dash="dash"),
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=t,
+            y=center_error,
+            mode="lines",
+            name="Center Line Error",
+            line=dict(color="red", width=2),
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=t,
+            y=angle_error,
+            mode="lines",
+            name="Angle Error",
+            line=dict(color="orange", width=2),
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=t,
+            y=roll_output,
+            mode="lines",
+            name="Roll Correction",
+            line=dict(color="blue", width=2),
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=t,
+            y=yaw_output,
+            mode="lines",
+            name="Yaw Correction",
+            line=dict(color="purple", width=2),
+        )
+    )
+
+    # Update layout
+    fig.update_layout(
+        title="PID Controllers for Line Following",
+        xaxis_title="Time",
+        yaxis_title="Error / Correction",
+        legend=dict(y=0.99, x=0.01, orientation="h"),
+        margin=dict(l=0, r=0, t=40, b=0),
+        height=300,
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+# Demo iFrame
+st.markdown("### Line Following Simulation Demo")
+display_iframe_or_link("https://samuellimabraz-line-follow-pid.hf.space", height=1200)
+st.caption(
+    "Link to Hugging Face Space: [Line Follow PID Demo](https://samuellimabraz-line-follow-pid.hf.space)"
+)
+
+# Video demo
+st.markdown("### Real Flight Footage (IMAV 2023)")
+display_asset_or_placeholder(
+    "drone_line_following_video.mp4",
+    asset_type="video",
+    caption="Black Bee Drone executing the line following task during IMAV 2023",
+)
+
+
+st.markdown("---")
+st.markdown(
+    """
+### Team Recognition
+
+This work was made possible by the incredible Black Bee Drones team at UNIFEI. Special thanks to all members
+who contributed their expertise in hardware, software, mechanics, and management.
+"""
+)
+
+st.markdown(
+    "[Black Bee Drones](https://www.linkedin.com/company/blackbeedrones/posts/?feedView=all)"
+)

pages/2_asimo_foundation.py

@@ -0,0 +1,286 @@
+import streamlit as st
+import plotly.graph_objects as go
+from streamlit_extras.badges import badge
+
+# Set page configuration
+st.set_page_config(
+    page_title="Asimo Foundation | CV Journey",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Title and introduction
+st.header("🤖 Asimo Foundation - STEM Education")
+
+st.markdown(
+    """
+### Bringing Technology Education to Public Schools
+
+The Asimo Foundation is a social project at UNIFEI that aims to reduce educational inequality 
+by bringing STEAM (Science, Technology, Engineering, Arts, and Mathematics) education to public schools in the region.
+
+This initiative:
+- Introduces students to robotics, programming, and technology
+- Provides hands-on experience with Arduino, Lego Mindstorms, and ESP32
+- Develops problem-solving and critical thinking skills
+- Inspires interest in technology and engineering careers
+"""
+)
+
+# Project details in tabs
+project_tabs = st.tabs(["Mission & Impact", "Technologies", "Teaching Methodology"])
+
+with project_tabs[0]:
+    col1, col2 = st.columns([3, 2])
+
+    with col1:
+        st.markdown(
+            """
+        ### Our Mission
+        
+        The Asimo Foundation believes that all students, regardless of socioeconomic background, 
+        deserve access to high-quality STEM education. By bringing technology education to public
+        schools, we aim to:
+        
+        - **Bridge the digital divide** between private and public education
+        - **Empower students** with technical skills for the future job market
+        - **Inspire curiosity and innovation** in young minds
+        - **Provide university students** with teaching experience and community engagement
+        """
+        )
+
+
+with project_tabs[1]:
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown(
+            """
+        ### Arduino
+        
+        **Applications:**
+        - Basic circuits and electronics
+        - Sensor integration (temperature, light, distance)
+        - Simple robotics projects (line followers, obstacle avoidance)
+        - LED control and displays
+        
+        **Benefits:**
+        - Low cost and widely available
+        - Excellent introduction to programming and electronics
+        - Versatile platform with thousands of project examples
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        ### Lego Mindstorms
+        
+        **Applications:**
+        - Robot construction and design
+        - Visual programming introduction
+        - Sensor integration and robotics concepts
+        - Competitive challenges and problem-solving
+        
+        **Benefits:**
+        - Intuitive building system
+        - Robust components for classroom use
+        - Engaging form factor that appeals to students
+        - Scaffolded learning progression
+        """
+        )
+
+    with col3:
+        st.markdown(
+            """
+        ### ESP32
+        
+        **Applications:**
+        - IoT (Internet of Things) projects
+        - Wireless communication
+        - Advanced sensing and control
+        - Web-based interfaces
+        
+        **Benefits:**
+        - Built-in Wi-Fi and Bluetooth
+        - Powerful processing capabilities
+        - Low power consumption
+        - Bridge to more advanced applications
+        """
+        )
+
+with project_tabs[2]:
+    st.markdown(
+        """
+    ### Our Teaching Approach
+    
+    We follow a project-based learning methodology that emphasizes:
+    
+    1. **Hands-on Exploration:** Students learn by doing, building, and experimenting
+    2. **Collaborative Problem-Solving:** Group projects that encourage teamwork
+    3. **Incremental Challenges:** Starting with simple concepts and building to complex projects
+    4. **Real-World Applications:** Connecting technology concepts to everyday life
+    5. **Student-Led Innovation:** Encouraging creativity and independent thinking
+    
+    This approach ensures that students not only learn technical skills but also develop critical thinking,
+    collaboration, and self-confidence.
+    """
+    )
+
+st.markdown("---")
+
+# Gesture-controlled robotic arm project
+st.subheader("Featured Project: Gesture-Controlled Robotic Arm")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown(
+        """
+    ### Computer Vision Meets Robotics
+    
+    This project combines computer vision with robotic control to create an intuitive
+    interface for controlling a robotic arm using hand gestures.
+    
+    **How it works:**
+    1. A webcam captures the user's hand movements
+    2. MediaPipe hand tracking detects hand landmarks in real-time
+    3. Custom algorithms convert hand position to servo angles
+    4. Arduino/ESP32 receives commands and controls the servo motors
+    5. The robotic arm mimics the user's hand movements
+    
+    This project demonstrates how computer vision can create natural human-machine interfaces
+    and serves as an engaging introduction to both robotics and CV concepts.
+    """
+    )
+
+with col2:
+    # Placeholder for robotic arm image
+    st.image(
+        "assets/robotic_arm.jpg",
+        caption="Robotic Arm used in the Asimo Foundation project",
+        use_container_width=True,
+    )
+
+# Technical implementation details
+st.subheader("Technical Implementation")
+
+implementation_tabs = st.tabs(["Hand Tracking", "Angle Calculation", "Arduino Control"])
+
+with implementation_tabs[0]:
+    st.markdown(
+        """
+    ### MediaPipe Hand Tracking
+    
+    We use Google's MediaPipe framework to detect and track hand landmarks in real-time.
+    
+    **Key Technologies:**
+    - [MediaPipe](https://developers.google.com/mediapipe) - Google's open-source framework for building multimodal ML pipelines
+    - [MediaPipe Hands](https://developers.google.com/mediapipe/solutions/vision/hand_landmarker) - Specific solution for hand tracking
+    - [OpenCV](https://opencv.org/) - Open source computer vision library
+    
+    **What it does:**
+    - Detects up to 21 landmarks on each hand
+    - Works in real-time on CPU
+    - Provides robust tracking even with partial occlusion
+    - Returns normalized 3D coordinates for each landmark
+    
+    **Resources:**
+    - [MediaPipe GitHub](https://github.com/google/mediapipe)
+    - [Hand Tracking Tutorial](https://developers.google.com/mediapipe/solutions/vision/hand_landmarker/python)
+    - [OpenCV Documentation](https://docs.opencv.org/)
+    """
+    )
+
+with implementation_tabs[1]:
+    st.markdown(
+        """
+    ### Mapping Hand Position to Servo Angles
+    
+    Converting hand landmark positions to meaningful servo angles requires mathematical transformations.
+    
+    **Key Technologies:**
+    - [NumPy](https://numpy.org/) - Fundamental package for scientific computing in Python
+    - [SciPy](https://scipy.org/) - Library for mathematics, science, and engineering
+    
+    **What it does:**
+    - Calculates angles between landmarks
+    - Maps raw angles to appropriate servo ranges
+    - Applies smoothing and filtering to reduce jitter
+    - Converts 3D hand positions to robotic arm coordinate space
+    
+    **Resources:**
+    - [NumPy Documentation](https://numpy.org/doc/stable/)
+    - [SciPy Spatial Transforms](https://docs.scipy.org/doc/scipy/reference/spatial.html)
+    - [Vector Mathematics Tutorial](https://realpython.com/python-linear-algebra/)
+    """
+    )
+
+with implementation_tabs[2]:
+    st.markdown(
+        """
+    ### Arduino Communication and Control
+    
+    The calculated angles are sent to an Arduino to control the servos.
+    
+    **Key Technologies:**
+    - [pyFirmata2](https://github.com/berndporr/pyFirmata2) - Python interface for the Firmata protocol
+    - [Firmata](https://github.com/firmata/arduino) - Protocol for communicating with microcontrollers
+    - [PySerial](https://pyserial.readthedocs.io/en/latest/) - Python serial port access library
+    - [Arduino Servo Library](https://www.arduino.cc/reference/en/libraries/servo/) - Controls servo motors
+    
+    **What it does:**
+    - Establishes serial communication between Python and Arduino
+    - Formats and sends servo angle commands
+    - Controls multiple servo motors in the robotic arm
+    - Provides real-time response to hand position changes
+    """
+    )
+
+# Demo video
+st.markdown("### Demo Video")
+st.video(
+    "assets/hand_control_arm_video.mp4",
+    # caption="Demonstration of hand gesture-controlled robotic arm",
+)
+st.markdown(
+    """
+* [GitHub Repository](https://github.com/Fundacao-Asimo/RoboArm)
+"""
+)
+
+# Educational impact
+st.markdown("---")
+st.subheader("Educational Impact")
+
+st.markdown(
+    """
+### Learning Outcomes
+- **Computer Vision Concepts:** Introduction to image processing, feature detection, and tracking
+- **Robotics Fundamentals:** Servo control, degrees of freedom, coordinate systems
+- **Programming Skills:** Python, Arduino/C++, communication protocols
+- **Engineering Design:** System integration, calibration, testing
+
+### Student Feedback
+Students find this project particularly engaging because it:
+- Provides immediate visual feedback
+- Feels like "magic" when the arm responds to hand movements
+- Combines multiple disciplines in a tangible application
+- Offers many opportunities for creative extensions and customization
+"""
+)
+
+# Footer with attribution
+st.markdown("---")
+st.markdown(
+    """
+### Project Team
+
+This work was developed and implemented as part of the Asimo Foundation at UNIFEI.
+Special thanks to all the volunteers, educators, and students who contributed to this initiative.
+"""
+)
+
+
+st.markdown("[🌎 Asimo Foundation](https://www.instagram.com/fundacaoasimo/)")

pages/3_cafe_dl.py

@@ -0,0 +1,596 @@
+import streamlit as st
+from streamlit_mermaid import st_mermaid
+from streamlit_extras.badges import badge
+
+# Set page configuration
+st.set_page_config(
+    page_title="CafeDL Project | CV Journey",
+    page_icon="☕",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Title and introduction
+st.header("☕ CafeDL - A Java Deep Learning Library")
+
+st.markdown(
+    """
+### Building Neural Networks from Scratch in Java
+
+CafeDL is a deep learning framework I developed from scratch during my Software Design undergraduate course. 
+Inspired by Keras' architecture and API, it's an educational exploration of neural network fundamentals, 
+implemented entirely in Java.
+
+This project combines software engineering principles with machine learning concepts, demonstrating how
+modern deep learning frameworks are designed under the hood.
+"""
+)
+
+st.markdown(
+    "[GitHub Repository: samuellimabraz/cafedl](https://github.com/samuellimabraz/cafedl)"
+)
+
+# Project motivation
+st.markdown("---")
+st.subheader("Project Motivation")
+
+st.markdown(
+    """
+### Why Build a DL Framework from Scratch?
+
+Most deep learning courses teach how to use existing frameworks like TensorFlow or PyTorch.
+While valuable for practical applications, this approach often leaves engineers with knowledge gaps 
+in the fundamental concepts that power these frameworks.
+
+**By building CafeDL, I aimed to:**
+
+- **Deepen Understanding:** Learn the mathematical foundations and computational challenges of neural networks
+- **Apply Design Patterns:** Explore software architecture patterns in a complex domain
+- **Bridge Engineering & ML:** Connect software engineering principles with machine learning concepts
+- **Challenge Myself:** Implement gradient descent, backpropagation, convolutional operations, and more without relying on existing libraries
+"""
+)
+
+
+# Technology Stack
+st.markdown("---")
+st.subheader("Technology Stack")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown(
+        """
+    ### Core Technologies
+    
+    - **Java:** The entire library is implemented in pure Java
+    - **ND4J (N-Dimensional Arrays for Java):** Used for tensor and matrix manipulation
+    - **MongoDB & Morphia:** For Object Document Mapping (ODM) and persisting trained models
+    - **JavaFX:** For the QuickDraw game interface
+    
+    ND4J provides efficient data structures similar to NumPy arrays, enabling vectorized operations
+    while still implementing my own mathematical operations for learning purposes.
+    """
+    )
+
+with col2:
+    st.markdown(
+        """
+    ### Design Philosophy
+    
+    - **Educational Focus:** Prioritizes readability and understanding over raw performance
+    - **Object-Oriented Design:** Heavy use of design patterns and clean architecture
+    - **API Familiarity:** Interface inspired by Keras for intuitive model building
+    - **Modularity:** Components are designed to be mixed and matched
+    - **Extensibility:** Easy to add new layers, optimizers, and activation functions
+    """
+    )
+
+# Key features
+st.markdown("---")
+st.subheader("Key Features of CafeDL")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown(
+        """
+    ### Neural Network Components
+    
+    - **Layers:**
+      - Dense (Fully Connected)
+      - Convolutional 2D
+      - Max Pooling 2D
+      - Zero Padding 2D
+      - Flattening
+      - Dropout
+    
+    - **Activation Functions:**
+      - ReLU
+      - Leaky ReLU 
+      - SiLU (Sigmoid Linear Unit)
+      - Sigmoid
+      - Tanh
+      - Softmax
+      - Linear
+    
+    - **Loss Functions:**
+      - Mean Squared Error (MSE)
+      - Binary Cross-Entropy
+      - Categorical Cross-Entropy
+      - Softmax Cross-Entropy
+    """
+    )
+
+with col2:
+    st.markdown(
+        """
+    ### Training Components
+    
+    - **Optimizers:**
+      - SGD (Stochastic Gradient Descent)
+      - SGD with Momentum
+      - SGD with Nesterov Momentum
+      - Regularized SGD
+      - Adam
+      - RMSProp
+      - AdaGrad
+      - AdaDelta
+    
+    - **Learning Rate Strategies:**
+      - Linear Decay
+      - Exponential Decay
+    
+    - **Metrics:**
+      - Accuracy
+      - Precision
+      - Recall
+      - F1 Score
+      - MSE, RMSE, MAE
+      - R²
+    """
+    )
+
+# Data Processing Features
+st.markdown("---")
+st.subheader("Data Processing Features")
+
+st.markdown(
+    """
+### Comprehensive Data Pipeline
+
+- **Data Loading:** Utility functions to load and preprocess training/testing data
+- **Preprocessing:** Tools for data normalization and transformation
+  - StandardScaler
+  - MinMaxScaler
+  - One-hot encoding
+- **Visualization:** Functions to plot model predictions and training performance
+- **Image Utilities:** Convert between array and image formats
+"""
+)
+
+# Example usage code
+st.markdown("---")
+
+# Add a more complete model example from the README
+st.markdown("### Example: Building & Training a CNN Model")
+
+st.code(
+    """
+DataLoader dataLoader = new DataLoader(root + "/npy/train/x_train250.npy", root + "/npy/train/y_train250.npy", root + "/npy/test/x_test250.npy", root + "/npy/test/y_test250.npy");
+INDArray xTrain = dataLoader.getAllTrainImages().get(NDArrayIndex.interval(0, trainSize));
+INDArray yTrain = dataLoader.getAllTrainLabels().reshape(-1, 1).get(NDArrayIndex.interval(0, trainSize));
+INDArray xTest = dataLoader.getAllTestImages().get(NDArrayIndex.interval(0, testSize));
+INDArray yTest = dataLoader.getAllTestLabels().reshape(-1, 1).get(NDArrayIndex.interval(0, testSize));
+
+// Normalization
+xTrain = xTrain.divi(255);
+xTest = xTest.divi(255);
+// Reshape
+xTrain = xTrain.reshape(xTrain.rows(), 28, 28, 1);
+xTest = xTest.reshape(xTest.rows(), 28, 28, 1);
+
+NeuralNetwork model = new ModelBuilder()
+    .add(new Conv2D(32, 2, Arrays.asList(2, 2), "valid", Activation.create("relu"), "he"))
+    .add(new Conv2D(16, 1, Arrays.asList(1, 1), "valid", Activation.create("relu"), "he"))
+    .add(new Flatten())
+    .add(new Dense(178, Activation.create("relu"), "he"))
+    .add(new Dropout(0.4))
+    .add(new Dense(49, Activation.create("relu"), "he"))
+    .add(new Dropout(0.3))
+    .add(new Dense(numClasses,  Activation.create("linear"), "he"))
+    .build();
+
+int epochs = 20;
+int batchSize = 64;
+
+LearningRateDecayStrategy lr = new ExponentialDecayStrategy(0.01, 0.0001, epochs);
+Optimizer optimizer = new RMSProp(lr);
+Trainer trainer = new TrainerBuilder(model, xTrain, yTrain, xTest, yTest, new SoftmaxCrossEntropy())
+        .setOptimizer(optimizer)
+        .setBatchSize(batchSize)
+        .setEpochs(epochs)
+        .setEvalEvery(2)
+        .setEarlyStopping(true)
+        .setPatience(4)
+        .setMetric(new Accuracy())
+        .build();
+trainer.fit();
+""",
+    language="java",
+)
+
+# Application: QuickDraw Game
+st.markdown("---")
+st.subheader("Application: QuickDraw Game Clone")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown(
+        """
+    ### Project Demo: Real-time Drawing Recognition
+    
+    As a demonstration of CafeDL's capabilities, I developed a JavaFX application inspired by Google's QuickDraw game.
+    
+    **Features:**
+    
+    - Real-time classification of hand-drawn sketches
+    - Drawing canvas with intuitive UI
+    - Displays model confidence for each class
+    - User feedback and game mechanics
+    - 10 different object categories for classification
+    - Database integration to store drawings and game sessions
+    
+    **Technical Implementation:**
+    
+    - **CNN Model:** Trained using CafeDL on the QuickDraw dataset
+    - **Game Logic:** 4 rounds per session, requiring >50% confidence for success
+    - **Database:** MongoDB for storing drawings and game statistics
+    - **MVC Architecture:** Clean separation of game components using JavaFX
+    """
+    )
+
+with col2:
+    # Placeholder for QuickDraw game video
+    st.video(
+        "assets/quickdraw_game_video.mp4",
+    )
+
+# Regression Examples
+st.markdown("---")
+st.subheader("Regression Examples")
+
+st.markdown(
+    """
+### Function Approximation Capabilities
+
+CafeDL isn't limited to classification problems. It can also tackle regression tasks, approximating various functions:
+
+- Linear regression
+- Sine waves
+- Complex 3D surfaces like Rosenbrock and Saddle functions
+
+Example visualizations from the original project include:
+"""
+)
+
+
+col1, col2 = st.columns(2)
+col3, col4 = st.columns(2)
+
+with col1:
+    st.markdown("#### Saddle Function")
+    st.image("assets/saddle_function2.png", use_container_width=True)
+
+with col2:
+    st.markdown("#### Rosenbrock Function")
+    st.image("assets/rosenbrock2.png", use_container_width=True)
+
+with col3:
+    st.markdown("#### Sine Function")
+    st.image("assets/sine.png", use_container_width=True)
+
+with col4:
+    st.markdown("#### Linear Regression")
+    st.image("assets/linear.png", use_container_width=True)
+
+
+# UML Diagrams with Mermaid
+st.markdown("---")
+st.subheader("CafeDL Architecture: UML Diagrams")
+
+# Create all diagram file paths
+diagram_files = {
+    "Full Diagram": "assets/full_diagram.md",
+    "Layers": "assets/layers_diagram.md",
+    "Activations": "assets/activations_diagram.md",
+    "Models": "assets/models_diagram.md",
+    "Optimizers": "assets/optimizers_diagram.md",
+    "Losses": "assets/losses_diagram.md",
+    "Metrics": "assets/metrics_diagram.md",
+    "Data": "assets/data_diagram.md",
+    "Database": "assets/database_diagram.md",
+    "Train": "assets/train_diagram.md",
+}
+
+
+# Function to extract Mermaid diagram text from .md files
+def extract_mermaid_from_md(file_path):
+    try:
+        with open(file_path, "r") as file:
+            content = file.read()
+            # Extract the Mermaid content between the ```mermaid and ``` tags
+            if "```mermaid" in content and "```" in content:
+                start_idx = content.find("```mermaid") + len("```mermaid")
+                end_idx = content.rfind("```")
+                return content[start_idx:end_idx].strip()
+            return None
+    except Exception as e:
+        st.error(f"Error reading diagram file {file_path}: {e}")
+        return None
+
+
+# Display diagrams sequentially
+st.info(
+    "The following UML diagrams represent the architecture of the CafeDL framework, organized by namespace."
+)
+
+# For each diagram, display it sequentially
+for name, file_path in diagram_files.items():
+    st.markdown(f"### {name}")
+    st.markdown(f"UML class diagram showing the {name.lower()} structure.")
+
+    mermaid_content = extract_mermaid_from_md(file_path)
+
+    if mermaid_content:
+        st_mermaid(mermaid_content)
+    else:
+        st.warning(f"Could not load diagram from {file_path}")
+
+        # Fallback diagrams for common namespace views
+        if name == "Activations":
+            st_mermaid(
+                """
+                classDiagram
+                    class IActivation {
+                        <<interface>>
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class Sigmoid {
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class TanH {
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class ReLU {
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class LeakyReLU {
+                        -alpha: double
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class Linear {
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class SiLU {
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class Softmax {
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    IActivation <|.. Sigmoid
+                    IActivation <|.. TanH
+                    IActivation <|.. ReLU
+                    IActivation <|.. LeakyReLU
+                    IActivation <|.. Linear
+                    IActivation <|.. SiLU
+                    IActivation <|.. Softmax
+                """
+            )
+        elif name == "Layers":
+            st_mermaid(
+                """
+                classDiagram
+                    class Layer {
+                        <<abstract>>
+                        #inputShape: int[]
+                        #outputShape: int[]
+                        +forward(input): double[][]
+                        +backward(gradient): double[][]
+                        +getParameters(): Map<String, double[][]>
+                        +updateParameters(optimizer): void
+                    }
+                    
+                    class TrainableLayer {
+                        <<abstract>>
+                        #params: INDArray
+                        #grads: INDArray
+                        #trainable: boolean
+                        +setup(input): void
+                        +getParams(): INDArray
+                        +getGrads(): INDArray
+                    }
+                    
+                    class Dense {
+                        -weights: INDArray
+                        -bias: INDArray
+                        -activation: IActivation
+                        +Dense(units, activation)
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class Conv2D {
+                        -filters: INDArray
+                        -biases: INDArray
+                        -kernelSize: int[]
+                        -strides: int[]
+                        -padding: String
+                        -activation: IActivation
+                        +Conv2D(filters, kernelHeight, kernelWidth, activation, padding)
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class MaxPooling2D {
+                        -poolSize: int[]
+                        -strides: int[]
+                        +MaxPooling2D(poolHeight, poolWidth, strides)
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class Flatten {
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class Dropout {
+                        -rate: double
+                        -mask: INDArray
+                        +Dropout(rate)
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    class ZeroPadding2D {
+                        -padding: int
+                        +ZeroPadding2D(padding)
+                        +forward(input): INDArray
+                        +backward(gradient): INDArray
+                    }
+                    
+                    Layer <|-- TrainableLayer
+                    TrainableLayer <|-- Dense
+                    TrainableLayer <|-- Conv2D
+                    Layer <|-- MaxPooling2D
+                    Layer <|-- Flatten
+                    Layer <|-- Dropout
+                    Layer <|-- ZeroPadding2D
+                    Conv2D --> ZeroPadding2D : uses
+                """
+            )
+        elif name == "Optimizers":
+            st_mermaid(
+                """
+                classDiagram
+                    class Optimizer {
+                        <<abstract>>
+                        #learningRate: double
+                        #neuralNetwork: NeuralNetwork
+                        +update(): void
+                        +updateEpoch(): void
+                        #createAuxParams(params): List<INDArray>
+                        #updateRule(params, grads, auxParams): void
+                    }
+                    
+                    class LearningRateDecayStrategy {
+                        <<abstract>>
+                        #decayPerEpoch: double
+                        #learningRate: double
+                        +updateLearningRate(): double
+                    }
+                    
+                    class SGD {
+                        +SGD(learningRate)
+                        #updateRule(params, grads, auxParams): void
+                    }
+                    
+                    class SGDMomentum {
+                        -momentum: double
+                        +SGDMomentum(learningRate, momentum)
+                        #updateRule(params, grads, auxParams): void
+                    }
+                    
+                    class Adam {
+                        -beta1: double
+                        -beta2: double
+                        -epsilon: double
+                        +Adam(learningRate, beta1, beta2, epsilon)
+                        #updateRule(params, grads, auxParams): void
+                    }
+                    
+                    class RMSProp {
+                        -decayRate: double
+                        -epsilon: double
+                        +RMSProp(learningRate, decayRate, epsilon)
+                        #updateRule(params, grads, auxParams): void
+                    }
+                    
+                    Optimizer <|-- SGD
+                    Optimizer <|-- SGDMomentum
+                    Optimizer <|-- Adam
+                    Optimizer <|-- RMSProp
+                    
+                    LearningRateDecayStrategy <|-- ExponentialDecayStrategy
+                    LearningRateDecayStrategy <|-- LinearDecayStrategy
+                    
+                    Optimizer o-- LearningRateDecayStrategy
+                """
+            )
+
+    # Add a separator between diagrams
+    st.markdown("---")
+
+# Technical challenges
+st.markdown("---")
+
+st.markdown(
+    """
+### Key Learning Outcomes
+
+- **Deep Understanding of Neural Networks:** Gained insights into the mathematical foundations of deep learning
+- **Software Design Patterns:** Applied OOP principles to a complex domain
+- **Algorithm Implementation:** Translated mathematical concepts into efficient code
+- **Performance Optimization:** Balanced readability with computational efficiency
+- **Full Stack Development:** Combined ML models with UI and database components
+- **Documentation & API Design:** Created an intuitive interface for users
+"""
+)
+
+# Conclusion and future work
+st.markdown("---")
+st.subheader("Conclusion & Future Work")
+
+st.markdown(
+    """
+### Project Impact & Next Steps
+
+The CafeDL project successfully demonstrates how modern deep learning frameworks function internally,
+while providing a practical educational tool for exploring neural network concepts.
+
+**Future Enhancements:**
+- Additional layer types (LSTM, GRU, BatchNorm)
+- More optimization algorithms
+- Transfer learning capabilities
+- Data augmentation pipeline
+- Enhanced visualization tools
+- Performance optimizations
+
+This project represents the intersection of software engineering principles and machine learning concepts,
+providing a foundation for deeper exploration of both fields.
+"""
+)
+
+badge(
+    type="github",
+    name="samuellimabraz/cafedl",
+    url="https://github.com/samuellimabraz/cafedl",
+)

pages/4_tech4humans.py

@@ -0,0 +1,695 @@
+import streamlit as st
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+from streamlit_extras.badges import badge
+import numpy as np
+import pathlib
+import streamlit.components.v1 as components
+
+# Set page configuration
+st.set_page_config(
+    page_title="Tech4Humans Projects | CV Journey",
+    page_icon="💼",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Title and introduction
+st.header("💼 Tech4Humans - Industry Applications of CV")
+
+st.markdown(
+    """
+### Professional Experience in Machine Learning Engineering
+
+I joined Tech4Humans initially as an ML Engineering intern in mid-2024 and was later hired as a full-time 
+Machine Learning Engineer. My work focuses on customizing and creating AI models for real-world applications,
+with a strong emphasis on computer vision solutions.
+
+This section showcases two significant CV projects I've worked on at Tech4Humans:
+"""
+)
+
+# Project tabs
+projects_tab = st.tabs(["Signature Detection", "Document Information Extraction"])
+
+# Signature Detection Project
+with projects_tab[0]:
+    st.subheader("Open-Source Signature Detection Model")
+
+    col1, col2 = st.columns([1, 1])
+
+    with col1:
+        html_content = """
+<div style="
+    display: flex; 
+    gap: 24px; 
+    margin: 2em 0; 
+    line-height: 1.6;
+">
+
+  <!-- Left Column - Text -->
+  <div style="flex: 1; padding-right: 16px;">
+    <p style="font-size: 1.1rem; margin-bottom: 1em;">
+      This article presents an <strong>open-source project</strong> for automated signature detection in document processing, structured into four key phases:
+    </p>
+    <ul style="padding-left: 20px; margin-bottom: 1em; font-size: 1rem;">
+      <li><strong>Dataset Engineering:</strong> Curation of a hybrid dataset through aggregation of two public collections.</li>
+      <li><strong>Architecture Benchmarking:</strong> Systematic evaluation of state-of-the-art object detection architectures (<em>YOLO series, DETR variants, and YOLOS</em>), focusing on accuracy, computational efficiency, and deployment constraints.</li>
+      <li><strong>Model Optimization:</strong> Leveraged Optuna for hyperparameter tuning, yielding a 7.94% F1-score improvement over baseline configurations.</li>
+      <li><strong>Production Deployment:</strong> Utilized Triton Inference Server for OpenVINO CPU-optimized inference.</li>
+    </ul>
+    <p style="font-size: 1.1rem; margin-top: 1em;">
+      Experimental results demonstrate a robust balance between precision, recall, and inference speed, validating the solution's practicality for real-world applications.  
+    </p>
+  </div>
+
+  <!-- Right Column - Images -->
+  <div style="
+      flex: 1; 
+      display: flex; 
+      flex-direction: column; 
+      gap: 12px;
+  ">
+    <img src="https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/6AnC1ut7EOLa6EjibXZXY.webp" 
+         style="max-width: 100%; height: auto; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+    <div style="display: flex; gap: 12px;">
+      <img src="https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/jWxcAUZPt8Bzup8kL-bor.webp" 
+           style="flex: 1; max-width: 50%; height: auto; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+      <img src="https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/tzK0lJz7mI2fazpY9pB1w.webp" 
+           style="flex: 1; max-width: 50%; height: auto; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+    </div>
+  </div>
+
+</div>
+        """
+        st.html(html_content)
+
+    # Dataset section
+    st.markdown("---")
+    st.markdown("### Dataset Engineering")
+
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.markdown(
+            """
+        #### Dataset Composition & Preprocessing
+        
+        The dataset was constructed by merging two publicly available benchmarks:
+        
+        - **[Tobacco800](https://paperswithcode.com/dataset/tobacco-800):** Scanned documents with signature annotations.
+        - **[Signatures-XC8UP](https://universe.roboflow.com/roboflow-100/signatures-xc8up):** Part of the Roboflow 100 benchmark with handwritten signature images.
+        
+        **Preprocessing & Augmentation (using [Roboflow](https://roboflow.com/)):**
+        - **Split:** Training (70%), Validation (15%), Test (15%) from 2,819 total images.
+        - **Preprocessing:** Auto-orientation, resize to 640x640px.
+        - **Augmentation:** Rotation, shear, brightness/exposure changes, blur, noise to enhance model robustness.
+        
+        The final dataset combines diverse document types and signature styles.
+        """
+        )
+
+    with col2:
+        st.image(
+            "https://cdn-uploads.huggingface.co/production/uploads/666b9ef5e6c60b6fc4156675/_o4PZzTyj17qhUYMLM2Yn.png",
+            caption="Figure 10: Annotated document samples (Source: Signature Detection Article)",
+            use_container_width=True,
+        )
+        st.caption(
+            "The dataset includes various document types with annotated signatures and logos."
+        )
+
+    # Architecture evaluation
+    st.markdown("---")
+    st.markdown("### Architecture Evaluation")
+
+    st.markdown(
+        """
+    We systematically evaluated multiple state-of-the-art object detection architectures (YOLO series, DETR variants, YOLOS) 
+    to find the optimal balance between accuracy (mAP), inference speed (CPU ONNX), and training time. 
+    The results below are based on training for 35 epochs.
+    """
+    )
+
+    # Actual model performance comparison data from Article Table 3
+    model_data = {
+        "Model": [
+            "rtdetr-l",
+            "yolos-base",
+            "yolos-tiny",
+            "conditional-detr",
+            "detr",
+            "yolov8x",
+            "yolov8l",
+            "yolov8m",
+            "yolov8s",
+            "yolov8n",
+            "yolo11x",
+            "yolo11l",
+            "yolo11m",
+            "yolo11s",
+            "yolo11n",
+            "yolov10x",
+            "yolov10l",
+            "yolov10b",
+            "yolov10m",
+            "yolov10s",
+            "yolov10n",
+            "yolo12n",
+            "yolo12s",
+            "yolo12m",
+            "yolo12l",
+            "yolo12x",
+        ],
+        "mAP@50 (%)": [
+            92.71,
+            90.12,
+            86.98,
+            93.65,
+            88.89,
+            79.42,
+            80.03,
+            87.53,
+            87.47,
+            81.61,
+            66.71,
+            70.74,
+            80.96,
+            83.56,
+            81.38,
+            68.10,
+            72.68,
+            78.98,
+            78.77,
+            66.39,
+            73.43,
+            75.86,
+            66.66,
+            61.96,
+            54.92,
+            51.16,
+        ],
+        "Inference Time (ms)": [
+            583.6,
+            1706.5,
+            265.3,
+            476.8,
+            425.6,
+            1259.5,
+            871.3,
+            401.2,
+            216.6,
+            110.4,
+            1016.7,
+            518.1,
+            381.7,
+            179.8,
+            106.7,
+            821.2,
+            580.8,
+            473.1,
+            320.1,
+            150.1,
+            73.9,
+            90.4,
+            166.6,
+            372.8,
+            505.7,
+            1022.8,
+        ],
+        "mAP@50-95 (%)": [  # Added for hover data
+            62.24,
+            58.36,
+            46.91,
+            65.33,
+            57.94,
+            55.29,
+            59.40,
+            66.55,
+            65.46,
+            62.40,
+            48.23,
+            49.91,
+            60.08,
+            63.88,
+            61.75,
+            47.45,
+            52.27,
+            57.89,
+            58.13,
+            47.39,
+            55.27,
+            55.87,
+            48.54,
+            45.62,
+            41.00,
+            35.42,
+        ],
+    }
+
+    model_df = pd.DataFrame(model_data)
+    model_df = model_df.sort_values(
+        "Inference Time (ms)"
+    )  # Sort for better visualization
+
+    # Create a scatter plot for model comparison (based on Article Figure 11)
+    fig = px.scatter(
+        model_df,
+        x="Inference Time (ms)",
+        y="mAP@50 (%)",
+        color="Model",  # Color by model
+        hover_name="Model",
+        hover_data=["mAP@50-95 (%)"],  # Show mAP50-95 on hover
+        text="Model",  # Display model names on points (optional, can be cluttered)
+        title="Model Architecture Comparison (CPU ONNX Inference)",
+    )
+
+    fig.update_traces(textposition="top center")  # Adjust text position if displayed
+    fig.update_layout(
+        xaxis_title="Inference Time (ms) - lower is better",
+        yaxis_title="mAP@50 (%) - higher is better",
+        height=600,  # Increased height for clarity
+        margin=dict(l=20, r=20, t=50, b=20),
+        legend_title_text="Model Variant",
+    )
+    # Optional: Add annotations for key models if needed
+    # fig.add_annotation(x=216.6, y=87.47, text="YOLOv8s", showarrow=True, arrowhead=1)
+    # fig.add_annotation(x=73.9, y=73.43, text="YOLOv10n (Fastest)", showarrow=True, arrowhead=1)
+    # fig.add_annotation(x=476.8, y=93.65, text="Conditional DETR (Highest mAP@50)", showarrow=True, arrowhead=1)
+
+    st.plotly_chart(fig, use_container_width=True)
+
+    st.markdown(
+        """
+    **Model Selection:**
+
+    While `conditional-detr-resnet-50` achieved the highest mAP@50 (93.65%), and `yolov10n` had the lowest CPU inference time (73.9 ms), **YOLOv8s** was selected for further optimization. 
+    
+    **Rationale for YOLOv8s:**
+    - **Strong Balance:** Offered a competitive mAP@50 (87.47%) and mAP@50-95 (65.46%) with a reasonable inference time (216.6 ms).
+    - **Efficiency:** Convolutional architectures like YOLO generally showed faster inference and training times compared to transformer models in this experiment.
+    - **Export & Ecosystem:** Excellent support for various export formats (ONNX, OpenVINO, TensorRT) facilitated by the Ultralytics library, simplifying deployment.
+    - **Community & Development:** Active development and large community support.
+    """
+    )
+
+    # Hyperparameter tuning
+    st.markdown("---")
+    st.markdown("### Hyperparameter Optimization")
+
+    col1, col2 = st.columns([2, 1])  # Keep ratio
+
+    with col1:
+        st.markdown(
+            """
+        Using **Optuna**, we performed hyperparameter tuning on the selected **YOLOv8s** model over 20 trials, optimizing for the F1-score on the test set.
+        
+        **Key Parameters Explored:**
+        - `dropout`: (0.0 to 0.5)
+        - `lr0` (Initial Learning Rate): (1e-5 to 1e-1, log scale)
+        - `box` (Box Loss Weight): (3.0 to 7.0)
+        - `cls` (Class Loss Weight): (0.5 to 1.5)
+        - `optimizer`: (AdamW, RMSProp)
+        
+        **Optimization Objective:**
+        Maximize F1-score, balancing precision and recall, crucial for signature detection where both false positives and false negatives are problematic.
+        
+        **Results:**
+        The best trial (#10) significantly improved performance compared to the baseline YOLOv8s configuration, notably increasing Recall.
+        """
+        )
+
+    with col2:
+        # Data from Article Table 4
+        hp_results = {
+            "Model": ["YOLOv8s (Base)", "YOLOv8s (Tuned)"],
+            "F1-score (%)": [85.42, 93.36],
+            "Precision (%)": [97.23, 95.61],
+            "Recall (%)": [76.16, 91.21],
+            "mAP@50 (%)": [87.47, 95.75],
+            "mAP@50-95 (%)": [65.46, 66.26],
+        }
+        hp_df = pd.DataFrame(hp_results)
+
+        # Create bar chart comparing F1 scores
+        fig_hp = px.bar(
+            hp_df,
+            x="Model",
+            y="F1-score (%)",
+            color="Model",
+            title="F1-Score Improvement After HPO",
+            text="F1-score (%)",
+            color_discrete_sequence=px.colors.qualitative.Pastel,
+            labels={"F1-score (%)": "F1-Score (%)"},
+            hover_data=["Precision (%)", "Recall (%)", "mAP@50 (%)", "mAP@50-95 (%)"],
+        )
+        fig_hp.update_traces(texttemplate="%{text:.2f}%", textposition="outside")
+        fig_hp.update_layout(
+            yaxis_range=[0, 100],  # Set y-axis from 0 to 100
+            height=400,  # Adjusted height
+            margin=dict(l=20, r=20, t=40, b=20),
+            showlegend=False,
+        )
+        st.plotly_chart(fig_hp, use_container_width=True)
+        st.markdown(
+            f"The tuning resulted in a **{hp_df.loc[1, 'F1-score (%)'] - hp_df.loc[0, 'F1-score (%)']:.2f}% absolute improvement** in F1-score."
+        )
+
+    # Production deployment
+    st.markdown("---")
+    st.markdown("### Production Deployment")
+
+    st.markdown(
+        """
+    The final, optimized YOLOv8s model was deployed using a production-ready inference pipeline designed for efficiency and scalability.
+    
+    **Key Components:**
+    - **Model Format:** Exported to **ONNX** for broad compatibility and optimized CPU inference with **OpenVINO**. TensorRT format also available for GPU inference.
+    - **Inference Server:** **Triton Inference Server** used for serving the model, chosen for its flexibility and performance.
+    - **Deployment:** Containerized using **Docker** for reproducible environments. A custom Docker image including only necessary backends (Python, ONNX, OpenVINO) was built to reduce size.
+    - **Ensemble Model:** A Triton Ensemble Model integrates preprocessing (Python), inference (ONNX/OpenVINO), and postprocessing (Python, including NMS) into a single server-side pipeline, minimizing latency.
+    
+    **Final Performance Metrics (Test Set):**
+    - **Precision:** 94.74%
+    - **Recall:** 89.72%
+    - **F1-score:** 93.36% (derived from Precision/Recall or Table 4)
+    - **mAP@50:** 94.50%
+    - **mAP@50-95:** 67.35%
+    - **Inference Latency:** 
+        - CPU (ONNX Runtime): **~171.6 ms**
+        - GPU (TensorRT on T4): **~7.7 ms** 
+    """
+    )
+
+    # Architecture diagram
+    st.markdown("### Deployment Architecture (Triton Ensemble)")
+
+    # Mermaid diagram for the Ensemble Model (based on Article Figure 14)
+    mermaid_code = """
+    flowchart TB
+    subgraph "Triton Inference Server"
+        direction TB
+        subgraph "Ensemble Model Pipeline"
+            direction TB
+            subgraph Input
+                raw["raw_image
+                 (UINT8, [-1])"]
+                conf["confidence_threshold
+                 (FP16, [1])"]
+                iou["iou_threshold
+                 (FP16, [1])"]
+            end
+
+            subgraph "Preprocess Py-Backend"
+                direction TB
+                pre1["Decode Image
+                    BGR to RGB"]
+                pre2["Resize (640x640)"]
+                pre3["Normalize (/255.0)"]
+                pre4["Transpose
+                [H,W,C]->[C,H,W]"]
+                pre1 --> pre2 --> pre3 --> pre4
+            end
+
+            subgraph "YOLOv8 Model ONNX Backend"
+                yolo["Inference YOLOv8s"]
+            end
+
+            subgraph "Postproces Python Backend"
+                direction TB
+                post1["Transpose
+                   Outputs"]
+                post2["Filter Boxes (confidence_threshold)"]
+                post3["NMS (iou_threshold)"]
+                post4["Format Results [x,y,w,h,score]"]
+                post1 --> post2 --> post3 --> post4
+            end
+
+            subgraph Output
+                result["detection_result
+                    (FP16, [-1,5])"]
+            end
+
+            raw --> pre1
+            pre4 --> |"preprocessed_image (FP32, [3,-1,-1])"| yolo
+            yolo --> |"output0"| post1
+            conf --> post2
+            iou --> post3
+            post4 --> result
+        end
+    end
+
+    subgraph Client
+        direction TB
+        client_start["Client Application"]
+        response["Detections Result
+                [x,y,w,h,score]"]
+    end
+
+    client_start -->|"HTTP/gRPC Request
+          with raw image
+          confidence_threshold
+          iou_threshold"| raw
+    result -->|"HTTP/gRPC Response with detections"| response
+    """
+
+    # Check if streamlit_mermaid is available
+    try:
+        from streamlit_mermaid import st_mermaid
+
+        st_mermaid(mermaid_code) 
+    except ImportError:
+        st.warning(
+            "`streamlit-mermaid` not installed. Displaying Mermaid code instead."
+        )
+        st.code(mermaid_code, language="mermaid")
+
+    # Project resources
+    st.markdown("---")
+    st.markdown("### Project Resources")
+
+    st.markdown(
+        """
+    | Resource | Links / Badges | Details |
+    |----------|----------------|---------|
+    | **Article** | [![Paper page](https://huggingface.co/datasets/huggingface/badges/resolve/main/paper-page-md.svg)](https://huggingface.co/blog/samuellimabraz/signature-detection-model) | A detailed community article covering the full development process of the project |
+    | **Model Files** | [![HF Model](https://huggingface.co/datasets/huggingface/badges/resolve/main/model-on-hf-md.svg)](https://huggingface.co/tech4humans/yolov8s-signature-detector) | **Available formats:** [![PyTorch](https://img.shields.io/badge/PyTorch-%23EE4C2C.svg?style=flat&logo=PyTorch&logoColor=white)](https://pytorch.org/) [![ONNX](https://img.shields.io/badge/ONNX-005CED.svg?style=flat&logo=ONNX&logoColor=white)](https://onnx.ai/) [![TensorRT](https://img.shields.io/badge/TensorRT-76B900.svg?style=flat&logo=NVIDIA&logoColor=white)](https://developer.nvidia.com/tensorrt) |
+    | **Dataset – Original** | [![Roboflow](https://app.roboflow.com/images/download-dataset-badge.svg)](https://universe.roboflow.com/tech-ysdkk/signature-detection-hlx8j) | 2,819 document images annotated with signature coordinates |
+    | **Dataset – Processed** | [![HF Dataset](https://huggingface.co/datasets/huggingface/badges/resolve/main/dataset-on-hf-md.svg)](https://huggingface.co/datasets/tech4humans/signature-detection) | Augmented and pre-processed version (640px) for model training |
+    | **Notebooks – Model Experiments** | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1wSySw_zwyuv6XSaGmkngI4dwbj-hR4ix) [![W&B Training](https://img.shields.io/badge/W%26B_Training-FFBE00?style=flat&logo=WeightsAndBiases&logoColor=white)](https://api.wandb.ai/links/samuel-lima-tech4humans/30cmrkp8) | Complete training and evaluation pipeline with selection among different architectures (yolo, detr, rt-detr, conditional-detr, yolos) |
+    | **Notebooks – HP Tuning** | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1wSySw_zwyuv6XSaGmkngI4dwbj-hR4ix) [![W&B HP Tuning](https://img.shields.io/badge/W%26B_HP_Tuning-FFBE00?style=flat&logo=WeightsAndBiases&logoColor=white)](https://api.wandb.ai/links/samuel-lima-tech4humans/31a6zhb1) | Optuna trials for optimizing the precision/recall balance |
+    | **Inference Server** | [![GitHub](https://img.shields.io/badge/Deploy-ffffff?style=for-the-badge&logo=github&logoColor=black)](https://github.com/tech4ai/t4ai-signature-detect-server) | Complete deployment and inference pipeline with Triton Inference Server<br> [![OpenVINO](https://img.shields.io/badge/OpenVINO-00c7fd?style=flat&logo=intel&logoColor=white)](https://docs.openvino.ai/2025/index.html) [![Docker](https://img.shields.io/badge/Docker-2496ED?logo=docker&logoColor=fff)](https://www.docker.com/) [![Triton](https://img.shields.io/badge/Triton-Inference%20Server-76B900?labelColor=black&logo=nvidia)](https://developer.nvidia.com/triton-inference-server) |
+    | **Live Demo** | [![HF Space](https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-hf-spaces-md.svg)](https://huggingface.co/spaces/tech4humans/signature-detection) | Graphical interface with real-time inference<br> [![Gradio](https://img.shields.io/badge/Gradio-FF5722?style=flat&logo=Gradio&logoColor=white)](https://www.gradio.app/) [![Plotly](https://img.shields.io/badge/PLotly-000000?style=flat&logo=plotly&logoColor=white)](https://plotly.com/python/) |
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Live demo using iframe
+    st.markdown("### Live Demo")
+    st.components.v1.iframe(
+        "https://tech4humans-signature-detection.hf.space", height=1000, scrolling=True
+    )
+
+    # Project impact
+    st.markdown("---")
+    st.markdown("### Project Impact")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown(
+            """
+        #### Community Recognition
+        
+        This project gained visibility in the ML community:
+        
+        - +100 upvote in Community Articles
+        - Shared by [Merve Noyan](https://huggingface.co/merve) on LinkedIn
+        - Served as a reference for end-to-end computer vision projects
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        #### Business Impact
+        
+        The model has been integrated into document processing pipelines, resulting in:
+        
+        - **Automation:** Reduction in manual verification steps
+        - **Accuracy:** Fewer missed signatures and false positives
+        - **Speed:** Faster document processing throughput
+        """
+        )
+
+# Document Data Extraction Project
+with projects_tab[1]:
+    st.subheader("Fine-tuning Vision-Language Models for Structured Document Extraction")
+
+    st.markdown("""
+    ### Project Goal: Extracting Structured Data from Brazilian Documents
+
+    This project explores fine-tuning open-source Vision-Language Models (VLMs) to extract structured data (JSON format) from images of Brazilian documents (National IDs - RG, Driver's Licenses - CNH, Invoices - NF) based on user-defined schemas.
+
+    The objective wasn't to replace existing solutions immediately but to validate the capabilities of smaller, fine-tuned VLMs and our ability to train and deploy them efficiently.
+    """)
+
+    # --- Dataset Section ---
+    st.markdown("---")
+    st.markdown("### 1. Dataset Refinement and Preparation")
+    st.markdown("""
+    Building upon public datasets, we initially faced inconsistencies in annotations and data standardization.
+
+    **Refinement Process:**
+    - Manually selected and re-annotated 170 examples each for CNH and RG.
+    - Selected high-quality Invoice (Nota Fiscal - NF) samples.
+    - **Split:** 70% Training, 15% Validation, 15% Test, maintaining class balance using Roboflow. ([Dataset Link](https://universe.roboflow.com/tech-ysdkk/brazilian-document-extration))
+    - **Augmentation:** Used Roboflow to apply image transformations (e.g., rotations, noise) to the training set, tripling its size.
+    - **Preprocessing:** Resized images to a maximum of 640x640 (maintaining aspect ratio) for evaluation and training. Initially avoided complex preprocessing like grayscale conversion to prevent model bias.
+
+    The final dataset provides a robust foundation for evaluating and fine-tuning models on specific Brazilian document types.
+    """)
+
+    # --- Evaluation Section ---
+    st.markdown("---")
+    st.markdown("### 2. Base Model Evaluation")
+    st.markdown("""
+    We benchmarked several open-source VLMs (1B to 10B parameters, suitable for L4 GPU) using the [Open VLM Leaderboard](https://huggingface.co/spaces/opencompass/open_vlm_leaderboard) as a reference. Key architectures considered include Qwen-VL, InternVL, Ovis, MiniCPM, DeepSeek-VL, Phi-3.5-Vision, etc.
+
+    **Efficient Inference with vLLM:**
+    - Utilized **vLLM** for optimized inference, leveraging its support for various vision models and features like structured output generation (though not used in the final fine-tuned evaluations). This significantly accelerated prediction compared to standard Transformers pipelines.
+
+    **Metrics:**
+    - Developed custom Python functions to calculate field similarity between predicted and ground truth JSONs.
+    - Normalized values (dates, numbers, case, special characters) and used **rapidfuzz** (based on Indel distance) for string similarity scoring (0-100).
+    - Calculated overall accuracy and field coverage.
+    """)
+
+    # --- Finetuning Section ---
+    st.markdown("---")
+    st.markdown("### 3. Fine-tuning Experiments")
+    st.markdown("""
+    We fine-tuned promising architectures using parameter-efficient techniques (LoRA) to improve performance on our specific dataset.
+
+    **Frameworks & Tools:**
+    - **Unsloth:** Leveraged for optimized training kernels, initially exploring Qwen2.5 but settling on **Qwen2-VL (2B, 7B)** due to better stability and merge compatibility with vLLM.
+    - **MS-Swift:** Adopted this comprehensive framework from ModelScope (Alibaba) for its broad support of architectures and fine-tuning methods. Tuned **InternVL-2.5-MPO (1B, 4B)**, **Qwen2.5-VL (3B)**, and **DeepSeek-VL2**.
+    - **LoRA:** Employed low-rank adaptation (ranks 2 and 4) with RSLora decay strategy.
+
+    **Fine-tuning Results:**
+    Fine-tuning demonstrated significant accuracy improvements, especially for smaller models, making them competitive with larger base models.
+    """)
+
+    # --- Embed Performance by Category Plot ---
+    st.markdown("#### Performance Comparison: Base vs. Fine-tuned (by Category)")
+    try:
+        # Construct path relative to the current script file
+        current_dir = pathlib.Path(__file__).parent
+        perf_cat_path = current_dir.parent / "assets/model_performance_by_category.html"
+        if perf_cat_path.is_file():
+            with open(perf_cat_path, 'r', encoding='utf-8') as f:
+                perf_cat_html = f.read()
+            components.html(perf_cat_html, height=700, scrolling=True)
+        else:
+            st.warning(f"Performance by category plot file not found at `{perf_cat_path}`")
+    except NameError:
+         # Handle case where __file__ is not defined
+         st.warning("Cannot determine file path automatically. Make sure `assets/model_performance_by_category.html` exists relative to the execution directory.")
+    except Exception as e:
+        st.error(f"Error loading performance by category plot: {e}")
+
+    # --- Embed Heatmap Plot ---
+    st.markdown("#### Accuracy Heatmap (Base Models)")
+    try:
+        # Construct path relative to the current script file
+        current_dir = pathlib.Path(__file__).parent
+        heatmap_path = current_dir.parent / "assets/heatmap_accuracy.html"
+        if heatmap_path.is_file():
+            with open(heatmap_path, 'r', encoding='utf-8') as f:
+                heatmap_html = f.read()
+            components.html(heatmap_html, height=600, scrolling=True)
+        else:
+            st.warning(f"Heatmap plot file not found at `{heatmap_path}`")
+    except NameError:
+         # Handle case where __file__ is not defined (e.g. interactive environment)
+         st.warning("Cannot determine file path automatically. Make sure `assets/heatmap_accuracy.html` exists relative to the execution directory.")
+    except Exception as e:
+        st.error(f"Error loading heatmap plot: {e}")
+
+    st.markdown("""
+    **Key Fine-tuning Observations:**
+    - **Small Models (1-3B):** Showed the largest relative gains (e.g., `InternVL2_5-1B-MPO-tuned` +28% absolute accuracy, reaching 83% overall). Fine-tuned small models outperformed larger base models.
+    - **Medium Models (~4B):** Also improved significantly (e.g., `InternVL2_5-4B-MPO-tuned` +18%, reaching 87% overall, with >90% on CNH).
+    - **Large Models (7B+):** Showed more modest gains (+13-14%), suggesting diminishing returns for fine-tuning very large models on this dataset/task.
+    - **Efficiency:** Fine-tuning often slightly *reduced* inference time, potentially because structured output guidance (used in base eval) was removed for tuned models as they performed better without it.
+    - **Challenge:** Extracting data from Invoices (NF) remained the most difficult task, even after tuning (max ~77% accuracy).
+    """)
+
+    # --- Generalization Section ---
+    st.markdown("---")
+    st.markdown("### 4. Generalization Analysis (Ongoing)")
+    st.markdown("""
+    To assess if fine-tuning caused the models to "forget" how to handle different document types, we are evaluating their performance on an out-of-distribution dataset.
+
+    **Methodology:**
+    - Used the English-language [`getomni-ai/ocr-benchmark`](https://huggingface.co/datasets/getomni-ai/ocr-benchmark) dataset.
+    - Selected samples from 8 document types with varying layouts and relatively simple JSON schemas.
+    - Focus is on the *relative* performance drop between the base model and its fine-tuned version on these unseen documents, rather than absolute accuracy.
+
+    **Preliminary Results:**
+    This plot compares the performance of base vs. fine-tuned models on the original Brazilian dataset vs. the English benchmark dataset. (*Note: Evaluation is ongoing*)
+    """)
+
+    # --- Embed Generalization Plot ---
+    st.markdown("#### Generalization Performance: Original vs. English Benchmark")
+    try:
+        # Construct path relative to the current script file
+        current_dir = pathlib.Path(__file__).parent
+        gen_path = current_dir.parent / "assets/generic_eval_all.html"
+        if gen_path.is_file():
+            with open(gen_path, 'r', encoding='utf-8') as f:
+                gen_html = f.read()
+            components.html(gen_html, height=850, scrolling=True)
+        else:
+            st.warning(f"Generalization plot file not found at `{gen_path}`")
+    except NameError:
+        # Handle case where __file__ is not defined
+        st.warning("Cannot determine file path automatically. Make sure `assets/generic_eval_all.html` exists relative to the execution directory.")
+    except Exception as e:
+        st.error(f"Error loading generalization plot: {e}")
+
+
+    # --- Conclusions & Next Steps ---
+    st.markdown("---")
+    st.markdown("### Conclusions & Next Steps")
+    st.markdown("""
+    **Key Insights:**
+    - Fine-tuned open-source VLMs (even smaller ones) can achieve high accuracy on specific document extraction tasks, rivaling larger models.
+    - Parameter-efficient fine-tuning (LoRA) with tools like Unsloth and MS-Swift is effective and feasible on standard hardware (e.g., L4 GPU).
+    - vLLM significantly optimizes inference speed for VLMs.
+    - There's a trade-off: Fine-tuning boosts performance on target domains but may reduce generalization to unseen document types (analysis ongoing).
+
+    **Ongoing Work:**
+    - Completing the generalization evaluation.
+    - Implementing a production-ready inference pipeline using optimized fine-tuned models.
+    - Exploring few-shot adaptation techniques for new document types.
+    - Investigating model distillation to potentially create even smaller, efficient models.
+    """)
+
+
+# Additional career highlights
+st.markdown("---")
+st.subheader("Additional ML Engineering Experience at Tech4Humans")
+
+st.markdown(
+    """
+Beyond the computer vision projects detailed above, my role at Tech4Humans has involved:
+
+- **MLOps Pipeline Development:** Building robust training and deployment pipelines for ML models
+- **Performance Optimization:** Tuning models for efficient inference in resource-constrained environments
+- **Data Engineering:** Creating pipelines for data acquisition, cleaning, and annotation
+- **Model Monitoring:** Implementing systems to track model performance and detect drift
+- **Client Consulting:** Working directly with clients to understand requirements and translate them into ML solutions
+"""
+)

pages/5_conclusion.py

@@ -0,0 +1,266 @@
+import streamlit as st
+from streamlit_extras.badges import badge
+import plotly.express as px
+import pandas as pd
+
+# Set page configuration
+st.set_page_config(
+    page_title="Conclusion | CV Journey",
+    page_icon="✅",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Title and introduction
+st.header("✅ Key Takeaways & Future Directions")
+
+st.markdown(
+    """
+### My Computer Vision Journey: Connecting the Dots
+
+Throughout this presentation, we've explored different facets of my journey in Computer Vision - from robotics and
+autonomous systems to deep learning frameworks and cutting-edge VLMs for document analysis.
+
+What connects these diverse projects is a progression of skills, knowledge, and application complexity that
+reflects the broader evolution of the computer vision field itself.
+"""
+)
+
+# Core knowledge areas
+st.markdown("---")
+st.subheader("Core Knowledge Areas")
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.markdown(
+        """
+    ### Computer Vision Fundamentals
+    
+    - Image processing and filtering techniques
+    - Feature detection and tracking
+    - Camera calibration and homography
+    - Geometric transformations
+    - Color spaces and thresholding
+    - Motion estimation and optical flow
+    - Object detection techniques
+    """
+    )
+
+with col2:
+    st.markdown(
+        """
+    ### Deep Learning for Vision
+    
+    - Convolutional Neural Networks (CNNs)
+    - Model architecture design principles
+    - Training and optimization strategies
+    - Transfer learning and fine-tuning
+    - Object detection frameworks
+    - Vision Transformers (ViT)
+    - Vision-Language Models (VLMs)
+    """
+    )
+
+with col3:
+    st.markdown(
+        """
+    ### MLOps & Production Engineering
+    
+    - Dataset engineering and annotation
+    - Hyperparameter optimization
+    - Model conversion and optimization
+    - Inference server deployment
+    - Performance benchmarking
+    - Integration with larger systems
+    - Monitoring and maintenance
+    """
+    )
+
+# Key experiences by project
+st.markdown("---")
+st.subheader("Key Experiences by Project")
+
+project_tabs = st.tabs(
+    ["Black Bee Drones", "Asimo Foundation", "CafeDL", "Tech4Humans"]
+)
+
+with project_tabs[0]:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown(
+            """
+        ### Black Bee Drones
+        
+        **Technical Skills:**
+        - Real-time image processing
+        - Control systems integration (PID)
+        - Vision-based, indoor navigation
+        - Marker detection and tracking
+        - Line following algorithms
+        
+        **Soft Skills:**
+        - Teamwork in a multidisciplinary environment
+        - Working under competition pressure
+        - Quick prototyping and iteration
+        - Technical presentation
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        ### Key Lessons
+        
+        1. **Robustness Over Perfection:** In the real world, perception systems must handle varying conditions and edge cases.
+        
+        2. **System Integration Challenges:** Computer vision is just one piece of a complex autonomous system.
+        
+        3. **Resource Constraints:** Balancing computational load with real-time response requirements.
+        
+        4. **Testing is Critical:** Simulation testing before real flights saves time and prevents crashes.
+        
+        5. **Iterative Development:** Start simple, verify, then add complexity incrementally.
+        """
+        )
+
+with project_tabs[1]:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown(
+            """
+        ### Asimo Foundation
+        
+        **Technical Skills:**
+        - Computer vision for educational applications
+        - Hand and gesture recognition
+        - Hardware integration (Arduino, servos)
+        - Real-time control systems
+        - Simple UI development
+        
+        **Soft Skills:**
+        - Teaching complex concepts to beginners
+        - Project planning for educational contexts
+        - Adapting technical solutions to limited resources
+        - Public speaking and demonstration
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        ### Key Lessons
+        
+        1. **Accessibility Matters:** Technology should be approachable for beginners with appropriate scaffolding.
+        
+        2. **Engagement Through Interactivity:** Visual, hands-on applications provide immediate feedback and motivation.
+        
+        3. **Simplified Interfaces:** Complex technology can be presented through simplified interfaces.
+        
+        4. **Project-Based Learning:** Students learn best when working toward tangible, interesting goals.
+        
+        5. **Educational Impact:** Computer vision can be a gateway to broader STEM interest.
+        """
+        )
+
+with project_tabs[2]:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown(
+            """
+        ### CafeDL
+        
+        **Technical Skills:**
+        - Deep understanding of neural network architectures
+        - Backpropagation and gradient calculation
+        - Convolutional operations implementation
+        - Software architecture and design patterns
+        - Algorithm optimization
+        
+        **Soft Skills:**
+        - Independent research and learning
+        - Technical documentation writing
+        - Project planning and execution
+        - Problem decomposition
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        ### Key Lessons
+        
+        1. **First Principles Matter:** Building ML systems from scratch provides deep understanding of the fundamentals.
+        
+        2. **Software Design Matters:** Good architecture makes complex systems maintainable and extensible.
+        
+        3. **Mathematics Underlies Everything:** Strong mathematical foundation is essential for ML implementation.
+        
+        4. **Performance Engineering:** Optimization requires understanding both mathematical and computing constraints.
+        
+        5. **Documentation is Critical:** Clear APIs and documentation are as important as the code itself.
+        """
+        )
+
+with project_tabs[3]:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown(
+            """
+        ### Tech4Humans
+        
+        **Technical Skills:**
+        - State-of-the-art model selection and evaluation
+        - Dataset engineering and curation
+        - Hyperparameter optimization
+        - Production deployment pipelines
+        - Fine-tuning large models
+        - Benchmarking and evaluation
+        
+        **Soft Skills:**
+        - Project management
+        - Client communication
+        - Technical writing
+        - Presentation of complex results
+        - Collaboration in a business environment
+        """
+        )
+
+    with col2:
+        st.markdown(
+            """
+        ### Key Lessons
+        
+        1. **Problem Definition is Critical:** Understanding business requirements before technical solutions.
+        
+        2. **Data Quality Trumps Model Complexity:** Better data often yields better results than more complex models.
+        
+        3. **Production Readiness:** Considerations beyond model accuracy include inference speed, resource usage, and maintainability.
+        
+        4. **Evaluation Methodology:** Careful evaluation with appropriate metrics is essential for comparing approaches.
+        
+        5. **Generalization Challenges:** Models may perform differently on out-of-distribution data, requiring careful testing.
+        """
+        )
+
+
+# Thank you and Q&A
+st.markdown("---")
+st.markdown("## Thank You for Your Attention!")
+
+st.markdown(
+    """
+I hope this presentation has given you an overview of my journey into the world of Computer Vision and that you may have gained some insight or even learned something from it as well.
+
+I am excited to continue exploring this field and expanding my knowledge.
+
+Feel free to reach out if you have any questions or would like to discuss computer vision or machine learning further!
+"""
+)
+
+# Add some fun at the end
+st.balloons()

requirements.txt

@@ -0,0 +1,7 @@
+streamlit==1.33.0
+plotly==5.18.0
+streamlit-mermaid==0.1.0
+pillow==10.1.0
+pandas==2.1.1
+streamlit-embedcode==0.1.3
+streamlit-extras==0.3.6

utils/__init__.py

@@ -0,0 +1 @@
+# Utils package initialization file 

utils/helpers.py

@@ -0,0 +1,80 @@
+"""
+Helper functions for the Computer Vision Journey presentation.
+"""
+
+import os
+import streamlit as st
+
+
+def check_asset_exists(filename):
+    """
+    Check if an asset file exists and return the path if it does, otherwise return None.
+
+    Args:
+        filename (str): The filename to check in the assets directory
+
+    Returns:
+        str or None: The full path to the asset if it exists, None otherwise
+    """
+    assets_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "assets")
+    filepath = os.path.join(assets_dir, filename)
+
+    if os.path.exists(filepath):
+        return filepath
+    else:
+        return None
+
+
+def display_asset_or_placeholder(
+    filename, asset_type="image", caption=None, use_column_width=True
+):
+    """
+    Display an asset or a placeholder if the asset doesn't exist.
+
+    Args:
+        filename (str): The filename of the asset
+        asset_type (str): The type of asset ('image' or 'video')
+        caption (str, optional): Caption for the asset
+        use_column_width (bool, optional): Whether to use the full column width
+    """
+    filepath = check_asset_exists(filename)
+
+    if filepath:
+        if asset_type == "image":
+            st.image(filepath, caption=caption, use_container_width=use_column_width)
+        elif asset_type == "video":
+            st.video(filepath)
+    else:
+        if asset_type == "image":
+            st.warning(
+                f"Place '{filename}' in the assets directory to display the {caption or 'image'}"
+            )
+        elif asset_type == "video":
+            st.warning(
+                f"Place '{filename}' in the assets directory to display the {caption or 'video'}"
+            )
+
+
+def display_iframe_or_link(url, height=500):
+    """
+    Display an iframe to an external URL or a link if iframe loading fails.
+
+    Args:
+        url (str): The URL to embed
+        height (int, optional): Height of the iframe
+    """
+    try:
+        st.components.v1.iframe(url, height=height)
+    except Exception:
+        st.warning(f"Unable to load iframe. Please visit the link directly: {url}")
+        st.markdown(f"[Open in new tab]({url})")
+
+
+def get_project_tabs():
+    """
+    Return a list of project tab names for consistent naming across pages.
+
+    Returns:
+        list: List of project tab names
+    """
+    return ["Black Bee Drones", "Asimov Foundation", "CafeDL", "Tech4Humans"]