rmayormartins commited on
Commit
00c6275
·
1 Parent(s): 98ee348
Files changed (4) hide show
  1. EXEMPLO_DE_USO.md +125 -0
  2. README.md +84 -5
  3. app.py +510 -0
  4. requirements.txt +8 -0
EXEMPLO_DE_USO.md ADDED
@@ -0,0 +1,125 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # 📖 Exemplo de Uso - Classificador de Imagens
2
+
3
+ ## 🎯 Cenário: Classificação de Gatos vs Cachorros
4
+
5
+ Este é um exemplo passo-a-passo de como usar o sistema para criar um classificador de gatos e cachorros.
6
+
7
+ ### Passo 1: Configuração Inicial
8
+
9
+ 1. **Definir número de classes**: 2
10
+ 2. **Configurar rótulos**:
11
+ - Classe 0: "gato"
12
+ - Classe 1: "cachorro"
13
+
14
+ ### Passo 2: Preparação dos Dados
15
+
16
+ 1. **Coletar imagens**:
17
+ - 20-30 imagens de gatos
18
+ - 20-30 imagens de cachorros
19
+ - Formatos suportados: JPG, PNG, JPEG
20
+
21
+ 2. **Upload das imagens**:
22
+ - Selecionar "Classe 0 - gato"
23
+ - Fazer upload das imagens de gatos
24
+ - Selecionar "Classe 1 - cachorro"
25
+ - Fazer upload das imagens de cachorros
26
+
27
+ ### Passo 3: Configuração do Treinamento
28
+
29
+ **Parâmetros recomendados para iniciantes**:
30
+ - **Batch Size**: 8 (para economizar memória)
31
+ - **Tamanho da imagem**: 224,224
32
+ - **Modelo**: MobileNetV2 (rápido e eficiente)
33
+ - **Épocas**: 5
34
+ - **Learning Rate**: 0.001
35
+
36
+ ### Passo 4: Treinamento
37
+
38
+ 1. Clicar em "⚙️ Preparar Dados"
39
+ - Verificar se aparece algo como: "✅ Dados preparados: 35 treino, 10 validação, 5 teste"
40
+
41
+ 2. Clicar em "🚀 Iniciar Treinamento"
42
+ - Aguardar conclusão (2-5 minutos)
43
+ - Observar a redução da loss e aumento da accuracy
44
+
45
+ ### Passo 5: Avaliação
46
+
47
+ 1. **Relatório de avaliação**:
48
+ - Clicar em "📊 Avaliar Modelo"
49
+ - Verificar precision, recall e f1-score
50
+
51
+ 2. **Matriz de confusão**:
52
+ - Clicar em "📈 Matriz de Confusão"
53
+ - Analisar onde o modelo está errando
54
+
55
+ ### Passo 6: Teste com Novas Imagens
56
+
57
+ 1. Fazer upload de imagens novas (que não foram usadas no treinamento)
58
+ 2. Clicar em "🔮 Predizer"
59
+ 3. Verificar as predições e níveis de confiança
60
+
61
+ ## 📊 Resultados Esperados
62
+
63
+ Com um dataset bem balanceado, você deve ver:
64
+
65
+ - **Accuracy**: 80-95%
66
+ - **Confiança**: 70-99% nas predições
67
+ - **Tempo de treinamento**: 2-5 minutos (CPU)
68
+
69
+ ## 🚨 Dicas Importantes
70
+
71
+ ### Para melhores resultados:
72
+
73
+ 1. **Qualidade das imagens**:
74
+ - Use imagens claras e bem iluminadas
75
+ - Evite imagens muito pequenas ou borradas
76
+ - Varie poses e ângulos
77
+
78
+ 2. **Balanceamento**:
79
+ - Use aproximadamente o mesmo número de imagens por classe
80
+ - Mínimo de 15-20 imagens por classe
81
+
82
+ 3. **Diversidade**:
83
+ - Inclua diferentes raças
84
+ - Varie ambientes (interno/externo)
85
+ - Diferentes idades dos animais
86
+
87
+ ### Solução de problemas comuns:
88
+
89
+ 1. **"Muito poucas imagens"**:
90
+ - Adicione mais imagens (mínimo 10 por classe)
91
+
92
+ 2. **Accuracy muito baixa**:
93
+ - Verifique se as imagens estão nas classes corretas
94
+ - Aumente o número de épocas
95
+ - Use mais dados de treinamento
96
+
97
+ 3. **Erro de memória**:
98
+ - Reduza o batch size para 4 ou 8
99
+ - Use MobileNetV2 em vez de ResNet50
100
+
101
+ ## 🎓 Expandindo o Projeto
102
+
103
+ Depois de dominar gatos vs cachorros, tente:
104
+
105
+ 1. **Mais classes**: gatos, cachorros, pássaros
106
+ 2. **Objetos**: carros, motos, bicicletas
107
+ 3. **Plantas**: rosas, margaridas, tulipas
108
+ 4. **Documentos**: faturas, contratos, recibos
109
+
110
+ ## 📈 Métricas de Sucesso
111
+
112
+ - **Precision**: % de predições corretas para cada classe
113
+ - **Recall**: % de exemplos corretamente identificados
114
+ - **F1-Score**: Média harmônica entre precision e recall
115
+ - **Accuracy**: % geral de acertos
116
+
117
+ ### Interpretação:
118
+ - **>90%**: Excelente
119
+ - **80-90%**: Muito bom
120
+ - **70-80%**: Bom
121
+ - **<70%**: Precisa melhorar (mais dados ou ajuste de parâmetros)
122
+
123
+ ---
124
+
125
+ 🎉 **Parabéns!** Agora você tem um classificador de imagens funcionando!
README.md CHANGED
@@ -1,12 +1,91 @@
1
  ---
2
  title: Image Classifier Interactive2
3
- emoji: 👁
4
- colorFrom: yellow
5
- colorTo: red
6
  sdk: gradio
7
- sdk_version: 5.42.0
8
  app_file: app.py
9
  pinned: false
 
10
  ---
11
 
12
- Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  ---
2
  title: Image Classifier Interactive2
3
+ emoji: 🖼️
4
+ colorFrom: blue
5
+ colorTo: purple
6
  sdk: gradio
7
+ sdk_version: 4.44.0
8
  app_file: app.py
9
  pinned: false
10
+ license: mit
11
  ---
12
 
13
+ # 🖼️ Sistema de Classificação de Imagens Interativo
14
+
15
+ Um sistema completo e interativo para classificação de imagens usando Deep Learning com PyTorch e Gradio.
16
+
17
+ ## 🌟 Características
18
+
19
+ - **Interface Intuitiva**: Interface web fácil de usar com Gradio
20
+ - **Múltiplos Modelos**: Suporte para AlexNet, ResNet18/34/50 e MobileNetV2
21
+ - **Treinamento Personalizado**: Treine modelos com suas próprias imagens
22
+ - **Avaliação Detalhada**: Relatórios de classificação e matriz de confusão
23
+ - **Predições em Tempo Real**: Teste o modelo treinado com novas imagens
24
+
25
+ ## 🚀 Como Usar
26
+
27
+ ### 1. Configuração
28
+ - Defina o número de classes (2-10)
29
+ - Configure rótulos personalizados para cada classe
30
+
31
+ ### 2. Upload de Dados
32
+ - Faça upload de imagens para cada classe
33
+ - Recomendado: pelo menos 10-20 imagens por classe
34
+
35
+ ### 3. Treinamento
36
+ - Configure parâmetros (batch size, épocas, learning rate)
37
+ - Escolha um modelo pré-treinado
38
+ - Inicie o treinamento
39
+
40
+ ### 4. Avaliação
41
+ - Visualize métricas de desempenho
42
+ - Analise a matriz de confusão
43
+
44
+ ### 5. Predição
45
+ - Teste o modelo com novas imagens
46
+ - Veja as predições com níveis de confiança
47
+
48
+ ## 🛠️ Tecnologias
49
+
50
+ - **PyTorch**: Framework de deep learning
51
+ - **Gradio**: Interface web interativa
52
+ - **Torchvision**: Modelos pré-treinados e transformações
53
+ - **Scikit-learn**: Métricas de avaliação
54
+ - **Matplotlib/Seaborn**: Visualizações
55
+
56
+ ## 📋 Exemplos de Uso
57
+
58
+ - Classificação de animais (gatos vs cachorros)
59
+ - Reconhecimento de objetos
60
+ - Classificação de plantas/flores
61
+ - Detecção de defeitos em produtos
62
+ - Classificação de documentos
63
+
64
+ ## ⚠️ Limitações
65
+
66
+ - Ambiente temporário: dados são perdidos ao reiniciar
67
+ - Recomendado para prototipagem e demonstrações
68
+ - Para uso em produção, considere salvar modelos externamente
69
+
70
+ ## 📄 Licença
71
+
72
+ MIT License - veja o arquivo LICENSE para detalhes.
73
+
74
+ ---
75
+
76
+ 💡 **Dica**: Para melhores resultados, use imagens bem organizadas e balanceadas entre as classes!
77
+
78
+ ## Additional Information
79
+
80
+ - Developed by Ramon Mayor Martins (2025)
81
+ - E-mail: [[email protected]](mailto:[email protected])
82
+ - Homepage: [https://rmayormartins.github.io/](https://rmayormartins.github.io/)
83
+ - Twitter: [@rmayormartins](https://twitter.com/rmayormartins)
84
+ - GitHub: [https://github.com/rmayormartins](https://github.com/rmayormartins)
85
+
86
+
87
+
88
+
89
+
90
+
91
+
app.py ADDED
@@ -0,0 +1,510 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ============================================================================
2
+ # SISTEMA DE CLASSIFICAÇÃO DE IMAGENS - HUGGING FACE SPACE
3
+ # ============================================================================
4
+
5
+ import os
6
+ import shutil
7
+ import gradio as gr
8
+ import torch
9
+ import torch.nn as nn
10
+ import torch.optim as optim
11
+ from torchvision import datasets, transforms, models
12
+ from torch.utils.data import DataLoader, random_split
13
+ from PIL import Image
14
+ import matplotlib.pyplot as plt
15
+ import seaborn as sns
16
+ import numpy as np
17
+ from sklearn.metrics import classification_report, confusion_matrix
18
+ import tempfile
19
+ import warnings
20
+ warnings.filterwarnings("ignore")
21
+
22
+ print("✅ Todas as bibliotecas carregadas com sucesso!")
23
+ print(f"🔥 GPU disponível: {torch.cuda.is_available()}")
24
+ print(f"🖥️ Device: {torch.device('cuda' if torch.cuda.is_available() else 'cpu')}")
25
+
26
+ # ============================================================================
27
+ # CONFIGURAÇÕES E VARIÁVEIS GLOBAIS
28
+ # ============================================================================
29
+
30
+ # Modelos disponíveis
31
+ model_dict = {
32
+ 'AlexNet': models.alexnet,
33
+ 'ResNet18': models.resnet18,
34
+ 'ResNet34': models.resnet34,
35
+ 'ResNet50': models.resnet50,
36
+ 'MobileNetV2': models.mobilenet_v2
37
+ }
38
+
39
+ # Variáveis globais
40
+ model = None
41
+ train_loader = None
42
+ val_loader = None
43
+ test_loader = None
44
+ dataset_path = tempfile.mkdtemp() # Usar diretório temporário
45
+ class_dirs = []
46
+ class_labels = []
47
+ test_dataset_path = tempfile.mkdtemp()
48
+ test_class_dirs = []
49
+ num_classes = 2
50
+ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
51
+
52
+ print("🎯 Configurações inicializadas!")
53
+
54
+ # ============================================================================
55
+ # FUNÇÕES PRINCIPAIS
56
+ # ============================================================================
57
+
58
+ def setup_classes(num_classes_value):
59
+ """Configura o número de classes e cria diretórios"""
60
+ global class_dirs, dataset_path, num_classes, class_labels
61
+
62
+ num_classes = int(num_classes_value)
63
+
64
+ # Limpar e criar diretórios
65
+ if os.path.exists(dataset_path):
66
+ shutil.rmtree(dataset_path)
67
+ dataset_path = tempfile.mkdtemp()
68
+
69
+ # Inicializar rótulos padrão
70
+ class_labels = [f'class_{i}' for i in range(num_classes)]
71
+
72
+ # Criar diretórios para cada classe
73
+ class_dirs = [os.path.join(dataset_path, f'class_{i}') for i in range(num_classes)]
74
+ for class_dir in class_dirs:
75
+ os.makedirs(class_dir)
76
+
77
+ return f"✅ Criados {num_classes} diretórios para classes"
78
+
79
+ def set_class_labels(*labels):
80
+ """Define rótulos personalizados para as classes"""
81
+ global class_labels
82
+
83
+ # Filtrar labels vazios
84
+ filtered_labels = [label.strip() for label in labels if label.strip()][:num_classes]
85
+
86
+ if len(filtered_labels) != num_classes:
87
+ return f"❌ Erro: Você deve fornecer exatamente {num_classes} rótulos. Fornecidos: {len(filtered_labels)}"
88
+
89
+ class_labels = filtered_labels
90
+ return f"✅ Rótulos definidos: {', '.join(class_labels)}"
91
+
92
+ def upload_images(class_id, images):
93
+ """Faz upload das imagens para a classe especificada"""
94
+ if int(class_id) >= len(class_dirs):
95
+ return f"❌ Erro: ID da classe {class_id} inválido."
96
+
97
+ if not images:
98
+ return "❌ Nenhuma imagem foi selecionada."
99
+
100
+ class_dir = class_dirs[int(class_id)]
101
+ count = 0
102
+
103
+ for image in images:
104
+ try:
105
+ shutil.copy(image, class_dir)
106
+ count += 1
107
+ except Exception as e:
108
+ return f"❌ Erro ao copiar imagem: {str(e)}"
109
+
110
+ class_name = class_labels[int(class_id)] if int(class_id) < len(class_labels) else f"class_{class_id}"
111
+ return f"✅ {count} imagens salvas na classe {class_id} ({class_name})"
112
+
113
+ def prepare_data(batch_size=32, resize_str="224,224"):
114
+ """Prepara os dados para treinamento"""
115
+ global train_loader, val_loader, test_loader, num_classes
116
+
117
+ try:
118
+ # Parse do resize
119
+ resize = tuple(map(int, resize_str.split(',')))
120
+
121
+ # Transformações
122
+ transform = transforms.Compose([
123
+ transforms.Resize(resize),
124
+ transforms.ToTensor(),
125
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
126
+ ])
127
+
128
+ dataset = datasets.ImageFolder(dataset_path, transform=transform)
129
+
130
+ if len(dataset.classes) == 0:
131
+ return "❌ Nenhuma classe encontrada. Faça upload das imagens primeiro."
132
+
133
+ if len(dataset.classes) != num_classes:
134
+ return f"❌ Erro: {len(dataset.classes)} classes detectadas, {num_classes} esperadas."
135
+
136
+ # Verificar se há imagens suficientes
137
+ if len(dataset) < 10:
138
+ return f"❌ Muito poucas imagens ({len(dataset)}). Adicione pelo menos 10 imagens por classe."
139
+
140
+ # Divisão dos dados: 70% treino, 20% validação, 10% teste
141
+ train_size = int(0.7 * len(dataset))
142
+ val_size = int(0.2 * len(dataset))
143
+ test_size = len(dataset) - train_size - val_size
144
+
145
+ train_dataset, val_dataset, test_dataset = random_split(
146
+ dataset, [train_size, val_size, test_size],
147
+ generator=torch.Generator().manual_seed(42)
148
+ )
149
+
150
+ train_loader = DataLoader(train_dataset, batch_size=int(batch_size), shuffle=True)
151
+ val_loader = DataLoader(val_dataset, batch_size=int(batch_size), shuffle=False)
152
+ test_loader = DataLoader(test_dataset, batch_size=int(batch_size), shuffle=False)
153
+
154
+ return f"✅ Dados preparados: {train_size} treino, {val_size} validação, {test_size} teste"
155
+
156
+ except Exception as e:
157
+ return f"❌ Erro na preparação: {str(e)}"
158
+
159
+ def start_training(model_name, epochs, lr, progress=gr.Progress()):
160
+ """Inicia o treinamento do modelo"""
161
+ global model, train_loader, val_loader, device
162
+
163
+ if train_loader is None or val_loader is None:
164
+ return "❌ Erro: Dados não preparados. Execute a preparação dos dados primeiro."
165
+
166
+ try:
167
+ # Carregar modelo pré-treinado
168
+ model = model_dict[model_name](pretrained=True)
169
+
170
+ # Adaptar última camada para número de classes
171
+ if hasattr(model, 'fc'):
172
+ model.fc = nn.Linear(model.fc.in_features, num_classes)
173
+ elif hasattr(model, 'classifier'):
174
+ model.classifier[-1] = nn.Linear(model.classifier[-1].in_features, num_classes)
175
+
176
+ model = model.to(device)
177
+
178
+ criterion = nn.CrossEntropyLoss()
179
+ optimizer = optim.Adam(model.parameters(), lr=float(lr))
180
+
181
+ results = []
182
+ results.append(f"🚀 Iniciando treinamento com {model_name}")
183
+ results.append(f"📊 Épocas: {epochs}, Learning Rate: {lr}")
184
+ results.append(f"🔥 Device: {device}")
185
+ results.append("-" * 50)
186
+
187
+ model.train()
188
+
189
+ for epoch in range(int(epochs)):
190
+ running_loss = 0.0
191
+ correct = 0
192
+ total = 0
193
+
194
+ progress(epoch / int(epochs), desc=f"Época {epoch+1}/{epochs}")
195
+
196
+ for batch_idx, (inputs, labels) in enumerate(train_loader):
197
+ inputs, labels = inputs.to(device), labels.to(device)
198
+
199
+ optimizer.zero_grad()
200
+ outputs = model(inputs)
201
+ loss = criterion(outputs, labels)
202
+ loss.backward()
203
+ optimizer.step()
204
+
205
+ running_loss += loss.item()
206
+ _, predicted = torch.max(outputs.data, 1)
207
+ total += labels.size(0)
208
+ correct += (predicted == labels).sum().item()
209
+
210
+ # Estatísticas da época
211
+ epoch_loss = running_loss / len(train_loader)
212
+ epoch_acc = 100. * correct / total
213
+ results.append(f"📈 Época {epoch+1}: Loss={epoch_loss:.4f}, Accuracy={epoch_acc:.2f}%")
214
+
215
+ # Salvar modelo
216
+ model_path = tempfile.NamedTemporaryFile(suffix='.pth', delete=False).name
217
+ torch.save(model.state_dict(), model_path)
218
+ results.append("-" * 50)
219
+ results.append(f"✅ Treinamento concluído! Modelo salvo temporariamente.")
220
+
221
+ return "\n".join(results)
222
+
223
+ except Exception as e:
224
+ return f"❌ Erro durante treinamento: {str(e)}"
225
+
226
+ def evaluate_model():
227
+ """Avalia o modelo no conjunto de teste"""
228
+ global model, device, num_classes, class_labels, test_loader
229
+
230
+ if model is None:
231
+ return "❌ Erro: Modelo não treinado."
232
+
233
+ if test_loader is None:
234
+ return "❌ Erro: Conjunto de dados não preparado."
235
+
236
+ model.eval()
237
+ all_preds = []
238
+ all_labels = []
239
+
240
+ try:
241
+ with torch.no_grad():
242
+ for inputs, labels in test_loader:
243
+ inputs, labels = inputs.to(device), labels.to(device)
244
+ outputs = model(inputs)
245
+ _, preds = torch.max(outputs, 1)
246
+ all_preds.extend(preds.cpu().numpy())
247
+ all_labels.extend(labels.cpu().numpy())
248
+
249
+ # Usar rótulos personalizados
250
+ target_names = class_labels if len(class_labels) == num_classes else [f"class_{i}" for i in range(num_classes)]
251
+ report = classification_report(all_preds, all_labels, target_names=target_names, zero_division=0)
252
+
253
+ return f"📊 RELATÓRIO DE CLASSIFICAÇÃO:\n\n{report}"
254
+
255
+ except Exception as e:
256
+ return f"❌ Erro durante avaliação: {str(e)}"
257
+
258
+ def show_confusion_matrix():
259
+ """Gera matriz de confusão"""
260
+ global model, device, num_classes, class_labels, test_loader
261
+
262
+ if model is None:
263
+ return None
264
+
265
+ if test_loader is None:
266
+ return None
267
+
268
+ model.eval()
269
+ all_preds = []
270
+ all_labels = []
271
+
272
+ with torch.no_grad():
273
+ for inputs, labels in test_loader:
274
+ inputs, labels = inputs.to(device), labels.to(device)
275
+ outputs = model(inputs)
276
+ _, preds = torch.max(outputs, 1)
277
+ all_preds.extend(preds.cpu().numpy())
278
+ all_labels.extend(labels.cpu().numpy())
279
+
280
+ cm = confusion_matrix(all_labels, all_preds)
281
+ labels_for_cm = class_labels if len(class_labels) == num_classes else [f"class_{i}" for i in range(num_classes)]
282
+
283
+ plt.figure(figsize=(8, 6))
284
+ sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
285
+ xticklabels=labels_for_cm,
286
+ yticklabels=labels_for_cm)
287
+ plt.xlabel('Predições')
288
+ plt.ylabel('Valores Reais')
289
+ plt.title('Matriz de Confusão')
290
+ plt.tight_layout()
291
+
292
+ # Salvar em arquivo temporário
293
+ temp_path = tempfile.NamedTemporaryFile(suffix='.png', delete=False).name
294
+ plt.savefig(temp_path, dpi=150, bbox_inches='tight')
295
+ plt.close()
296
+
297
+ return temp_path
298
+
299
+ def predict_images(images):
300
+ """Faz predições em novas imagens"""
301
+ global model, device, class_labels
302
+
303
+ if model is None:
304
+ return "❌ Erro: Modelo não treinado."
305
+
306
+ if not images:
307
+ return "❌ Nenhuma imagem selecionada."
308
+
309
+ transform = transforms.Compose([
310
+ transforms.Resize((224, 224)),
311
+ transforms.ToTensor(),
312
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
313
+ ])
314
+
315
+ model.eval()
316
+ results = []
317
+
318
+ for image_path in images:
319
+ try:
320
+ image = Image.open(image_path).convert('RGB')
321
+ img_tensor = transform(image).unsqueeze(0).to(device)
322
+
323
+ with torch.no_grad():
324
+ outputs = model(img_tensor)
325
+ probabilities = torch.nn.functional.softmax(outputs[0], dim=0)
326
+ _, predicted = torch.max(outputs, 1)
327
+
328
+ predicted_class_id = predicted.item()
329
+ confidence = probabilities[predicted_class_id].item() * 100
330
+
331
+ if predicted_class_id < len(class_labels):
332
+ predicted_class_name = class_labels[predicted_class_id]
333
+ else:
334
+ predicted_class_name = f"class_{predicted_class_id}"
335
+
336
+ results.append(f"📸 {os.path.basename(image_path)}")
337
+ results.append(f" 🎯 Classe: {predicted_class_name}")
338
+ results.append(f" 📊 Confiança: {confidence:.2f}%")
339
+ results.append("-" * 40)
340
+
341
+ except Exception as e:
342
+ results.append(f"❌ Erro ao processar {os.path.basename(image_path)}: {str(e)}")
343
+
344
+ return "\n".join(results)
345
+
346
+ # ============================================================================
347
+ # INTERFACE GRADIO
348
+ # ============================================================================
349
+
350
+ def create_interface():
351
+ """Cria a interface Gradio"""
352
+
353
+ with gr.Blocks(title="🖼️ Classificador de Imagens", theme=gr.themes.Soft()) as demo:
354
+
355
+ gr.Markdown("""
356
+ # 🖼️ Sistema de Classificação de Imagens Interativo
357
+ #### Por [Ramon Mayor Martins](https://rmayormartins.github.io/)
358
+
359
+ **Instruções:**
360
+ 1. Configure o número de classes e defina os rótulos
361
+ 2. Faça upload das imagens para cada classe
362
+ 3. Prepare os dados e treine o modelo
363
+ 4. Avalie o desempenho e faça predições!
364
+
365
+ ⚠️ **Nota**: Este é um ambiente temporário. Os dados e modelos serão perdidos ao reiniciar.
366
+ """)
367
+
368
+ with gr.Tab("1️⃣ Configuração"):
369
+ gr.Markdown("### 🎯 Configurar Classes")
370
+
371
+ num_classes_input = gr.Number(
372
+ label="Número de Classes",
373
+ value=2,
374
+ precision=0,
375
+ minimum=2,
376
+ maximum=10
377
+ )
378
+ setup_button = gr.Button("🔧 Configurar Classes", variant="primary")
379
+ setup_output = gr.Textbox(label="📋 Status", lines=2)
380
+
381
+ gr.Markdown("### 🏷️ Definir Rótulos")
382
+
383
+ # Campos para rótulos dinâmicos
384
+ label_inputs = []
385
+ for i in range(10):
386
+ label_input = gr.Textbox(
387
+ label=f"Rótulo da Classe {i}",
388
+ placeholder=f"Ex: gato, cachorro, pássaro...",
389
+ visible=(i < 2)
390
+ )
391
+ label_inputs.append(label_input)
392
+
393
+ set_labels_button = gr.Button("🏷️ Definir Rótulos", variant="secondary")
394
+ labels_output = gr.Textbox(label="📋 Status dos Rótulos")
395
+
396
+ # Atualizar visibilidade dos campos
397
+ def update_label_visibility(num_classes_value):
398
+ updates = []
399
+ for i in range(10):
400
+ updates.append(gr.update(visible=(i < int(num_classes_value))))
401
+ return updates
402
+
403
+ # Conectar eventos
404
+ setup_button.click(setup_classes, inputs=num_classes_input, outputs=setup_output)
405
+ num_classes_input.change(update_label_visibility, inputs=num_classes_input, outputs=label_inputs)
406
+ set_labels_button.click(set_class_labels, inputs=label_inputs, outputs=labels_output)
407
+
408
+ with gr.Tab("2️⃣ Upload de Imagens"):
409
+ gr.Markdown("### 📤 Upload de Imagens por Classe")
410
+
411
+ with gr.Row():
412
+ class_selector = gr.Dropdown(
413
+ label="Selecionar Classe",
414
+ choices=[(f"Classe 0", 0), (f"Classe 1", 1)],
415
+ value=0
416
+ )
417
+ images_upload = gr.File(
418
+ label="Selecionar Imagens",
419
+ file_count="multiple",
420
+ type="filepath",
421
+ file_types=["image"]
422
+ )
423
+
424
+ upload_button = gr.Button("📤 Fazer Upload", variant="primary")
425
+ upload_output = gr.Textbox(label="📋 Status do Upload")
426
+
427
+ # Atualizar dropdown de classes
428
+ def update_class_dropdown(num_classes_value):
429
+ choices = []
430
+ for i in range(int(num_classes_value)):
431
+ label = class_labels[i] if i < len(class_labels) else f"Classe {i}"
432
+ choices.append((f"{i} - {label}", i))
433
+ return gr.update(choices=choices, value=0)
434
+
435
+ # Conectar eventos
436
+ upload_button.click(upload_images, inputs=[class_selector, images_upload], outputs=upload_output)
437
+ num_classes_input.change(update_class_dropdown, inputs=num_classes_input, outputs=class_selector)
438
+ set_labels_button.click(update_class_dropdown, inputs=num_classes_input, outputs=class_selector)
439
+
440
+ with gr.Tab("3️⃣ Preparação & Treinamento"):
441
+ gr.Markdown("### ⚙️ Configurar Parâmetros")
442
+
443
+ with gr.Row():
444
+ batch_size = gr.Number(label="Batch Size", value=16, minimum=1, maximum=64)
445
+ resize_input = gr.Textbox(label="Tamanho da Imagem (formato: 224,224)", value="224,224")
446
+
447
+ prepare_button = gr.Button("⚙️ Preparar Dados", variant="primary")
448
+ prepare_output = gr.Textbox(label="📋 Status da Preparação", lines=3)
449
+
450
+ gr.Markdown("### 🚀 Treinamento")
451
+
452
+ with gr.Row():
453
+ model_name = gr.Dropdown(
454
+ label="Modelo",
455
+ choices=list(model_dict.keys()),
456
+ value="MobileNetV2"
457
+ )
458
+ epochs = gr.Number(label="Épocas", value=3, minimum=1, maximum=20)
459
+ lr = gr.Number(label="Learning Rate", value=0.001, minimum=0.0001, maximum=0.1)
460
+
461
+ train_button = gr.Button("🚀 Iniciar Treinamento", variant="primary", size="lg")
462
+ train_output = gr.Textbox(label="📋 Status do Treinamento", lines=10)
463
+
464
+ # Conectar eventos
465
+ prepare_button.click(prepare_data, inputs=[batch_size, resize_input], outputs=prepare_output)
466
+ train_button.click(start_training, inputs=[model_name, epochs, lr], outputs=train_output)
467
+
468
+ with gr.Tab("4️⃣ Avaliação"):
469
+ gr.Markdown("### 📊 Avaliar Desempenho do Modelo")
470
+
471
+ with gr.Row():
472
+ eval_button = gr.Button("📊 Avaliar Modelo", variant="primary")
473
+ cm_button = gr.Button("📈 Matriz de Confusão", variant="secondary")
474
+
475
+ eval_output = gr.Textbox(label="📋 Relatório de Avaliação", lines=15)
476
+ cm_output = gr.Image(label="📈 Matriz de Confusão")
477
+
478
+ # Conectar eventos
479
+ eval_button.click(evaluate_model, outputs=eval_output)
480
+ cm_button.click(show_confusion_matrix, outputs=cm_output)
481
+
482
+ with gr.Tab("5️⃣ Predição"):
483
+ gr.Markdown("### 🔮 Fazer Predições em Novas Imagens")
484
+
485
+ predict_images_input = gr.File(
486
+ label="Upload de Imagens para Predição",
487
+ file_count="multiple",
488
+ type="filepath",
489
+ file_types=["image"]
490
+ )
491
+ predict_button = gr.Button("🔮 Predizer", variant="primary", size="lg")
492
+ predict_output = gr.Textbox(label="📋 Resultados das Predições", lines=10)
493
+
494
+ # Conectar eventos
495
+ predict_button.click(predict_images, inputs=predict_images_input, outputs=predict_output)
496
+
497
+ return demo
498
+
499
+ # ============================================================================
500
+ # EXECUÇÃO PRINCIPAL
501
+ # ============================================================================
502
+
503
+ if __name__ == "__main__":
504
+ print("🎯 Criando interface...")
505
+ demo = create_interface()
506
+
507
+ print("🚀 Iniciando aplicação...")
508
+ demo.launch()
509
+
510
+ print("✅ Sistema pronto para uso!")
requirements.txt ADDED
@@ -0,0 +1,8 @@
 
 
 
 
 
 
 
 
 
1
+ gradio>=4.0.0
2
+ torch>=2.0.0
3
+ torchvision>=0.15.0
4
+ scikit-learn>=1.3.0
5
+ matplotlib>=3.7.0
6
+ seaborn>=0.12.0
7
+ numpy>=1.24.0
8
+ Pillow>=10.0.0