go7

app.py

@@ -7,6 +7,8 @@ import torch.optim as optim
 from torchvision import datasets, transforms, models
 from torch.utils.data import DataLoader, random_split
 from PIL import Image
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
@@ -15,9 +17,9 @@ import tempfile
 import warnings
 warnings.filterwarnings("ignore")
 
-# Configuração do device
+# Configuração
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(f"🖥️ Usando device: {device}")
+print(f"🖥️ Device: {device}")
 
 # Modelos disponíveis
 MODELS = {
@@ -25,77 +27,61 @@ MODELS = {
     'MobileNetV2': models.mobilenet_v2
 }
 
-# Estado global da aplicação
+# Estado global
 class AppState:
     def __init__(self):
         self.model = None
         self.train_loader = None
-        self.val_loader = None
+        self.val_loader = None  
         self.test_loader = None
         self.dataset_path = None
         self.class_dirs = []
         self.class_labels = []
         self.num_classes = 2
 
-# Instância global do estado
-app_state = AppState()
+state = AppState()
 
 def setup_classes(num_classes_value):
-    """Configura o número de classes e cria diretórios"""
+    """Configura classes"""
     try:
-        app_state.num_classes = int(num_classes_value)
+        state.num_classes = int(num_classes_value)
+        state.dataset_path = tempfile.mkdtemp()
+        state.class_labels = [f'classe_{i}' for i in range(state.num_classes)]
         
-        # Criar diretório temporário
-        app_state.dataset_path = tempfile.mkdtemp()
-        
-        # Inicializar rótulos padrão
-        app_state.class_labels = [f'classe_{i}' for i in range(app_state.num_classes)]
-        
-        # Criar diretórios para cada classe
-        app_state.class_dirs = []
-        for i in range(app_state.num_classes):
-            class_dir = os.path.join(app_state.dataset_path, f'classe_{i}')
+        state.class_dirs = []
+        for i in range(state.num_classes):
+            class_dir = os.path.join(state.dataset_path, f'classe_{i}')
             os.makedirs(class_dir, exist_ok=True)
-            app_state.class_dirs.append(class_dir)
-        
-        choices = [(f"{i} - {app_state.class_labels[i]}", i) for i in range(app_state.num_classes)]
+            state.class_dirs.append(class_dir)
         
-        return (
-            f"✅ Criados {app_state.num_classes} diretórios para classes",
-            gr.Dropdown(choices=choices, value=0)
-        )
+        return f"✅ Criados {state.num_classes} diretórios"
     except Exception as e:
-        return f"❌ Erro: {str(e)}", gr.Dropdown()
+        return f"❌ Erro: {str(e)}"
 
-def set_class_labels(label0, label1, label2, label3, label4):
-    """Define rótulos personalizados para as classes"""
+def set_class_labels(labels_text):
+    """Define rótulos das classes (separados por vírgula)"""
     try:
-        labels = [label0, label1, label2, label3, label4]
-        filtered_labels = [label.strip() for label in labels if label.strip()][:app_state.num_classes]
+        labels = [label.strip() for label in labels_text.split(',') if label.strip()]
         
-        if len(filtered_labels) != app_state.num_classes:
-            return f"❌ Erro: Forneça exatamente {app_state.num_classes} rótulos.", gr.Dropdown()
+        if len(labels) != state.num_classes:
+            return f"❌ Forneça {state.num_classes} rótulos separados por vírgula"
         
-        app_state.class_labels = filtered_labels
-        choices = [(f"{i} - {app_state.class_labels[i]}", i) for i in range(app_state.num_classes)]
-        
-        return (
-            f"✅ Rótulos definidos: {', '.join(app_state.class_labels)}",
-            gr.Dropdown(choices=choices, value=0)
-        )
+        state.class_labels = labels
+        return f"✅ Rótulos: {', '.join(state.class_labels)}"
     except Exception as e:
-        return f"❌ Erro: {str(e)}", gr.Dropdown()
+        return f"❌ Erro: {str(e)}"
 
 def upload_images(class_id, images):
-    """Faz upload das imagens para a classe especificada"""
+    """Upload de imagens"""
     try:
         if not images:
-            return "❌ Nenhuma imagem selecionada."
+            return "❌ Selecione imagens"
         
-        if int(class_id) >= len(app_state.class_dirs):
-            return f"❌ Classe {class_id} inválida."
+        class_idx = int(class_id)
+        if class_idx >= len(state.class_dirs):
+            return f"❌ Classe inválida"
         
-        class_dir = app_state.class_dirs[int(class_id)]
+        class_dir = state.class_dirs[class_idx]
         count = 0
         
         for image in images:
@@ -103,33 +89,29 @@ def upload_images(class_id, images):
                 shutil.copy2(image, class_dir)
                 count += 1
         
-        class_name = app_state.class_labels[int(class_id)]
-        return f"✅ {count} imagens salvas na classe {class_id} ({class_name})"
+        class_name = state.class_labels[class_idx]
+        return f"✅ {count} imagens → {class_name}"
     except Exception as e:
         return f"❌ Erro: {str(e)}"
 
 def prepare_data(batch_size):
-    """Prepara os dados para treinamento"""
+    """Prepara dados"""
     try:
-        if not app_state.dataset_path or not os.path.exists(app_state.dataset_path):
-            return "❌ Configure as classes primeiro."
+        if not state.dataset_path:
+            return "❌ Configure classes primeiro"
         
-        # Transformações
         transform = transforms.Compose([
             transforms.Resize((224, 224)),
             transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
         ])
         
-        dataset = datasets.ImageFolder(app_state.dataset_path, transform=transform)
-        
-        if len(dataset.classes) == 0:
-            return "❌ Nenhuma classe encontrada. Faça upload das imagens primeiro."
+        dataset = datasets.ImageFolder(state.dataset_path, transform=transform)
         
         if len(dataset) < 6:
-            return f"❌ Muito poucas imagens ({len(dataset)}). Adicione pelo menos 2 imagens por classe."
+            return f"❌ Poucas imagens ({len(dataset)}). Mínimo: 6"
         
-        # Divisão dos dados
+        # Divisão: 70% treino, 20% val, 10% teste
         train_size = int(0.7 * len(dataset))
         val_size = int(0.2 * len(dataset))
         test_size = len(dataset) - train_size - val_size
@@ -139,268 +121,270 @@ def prepare_data(batch_size):
             generator=torch.Generator().manual_seed(42)
         )
         
-        app_state.train_loader = DataLoader(train_dataset, batch_size=int(batch_size), shuffle=True)
-        app_state.val_loader = DataLoader(val_dataset, batch_size=int(batch_size), shuffle=False)
-        app_state.test_loader = DataLoader(test_dataset, batch_size=int(batch_size), shuffle=False)
+        state.train_loader = DataLoader(train_dataset, batch_size=int(batch_size), shuffle=True)
+        state.val_loader = DataLoader(val_dataset, batch_size=int(batch_size), shuffle=False)
+        state.test_loader = DataLoader(test_dataset, batch_size=int(batch_size), shuffle=False)
         
-        return f"✅ Dados preparados: {train_size} treino, {val_size} validação, {test_size} teste"
-    
+        return f"✅ Dados preparados:\n• Treino: {train_size}\n• Validação: {val_size}\n• Teste: {test_size}"
     except Exception as e:
-        return f"❌ Erro na preparação: {str(e)}"
+        return f"❌ Erro: {str(e)}"
 
-def start_training(model_name, epochs, lr):
-    """Inicia o treinamento do modelo"""
+def train_model(model_name, epochs, lr):
+    """Treina modelo"""
     try:
-        if app_state.train_loader is None:
-            return "❌ Erro: Dados não preparados."
+        if state.train_loader is None:
+            return "❌ Prepare os dados primeiro"
         
         # Carregar modelo
-        app_state.model = MODELS[model_name](pretrained=True)
-        
-        # Adaptar última camada
-        if hasattr(app_state.model, 'fc'):
-            app_state.model.fc = nn.Linear(app_state.model.fc.in_features, app_state.num_classes)
-        elif hasattr(app_state.model, 'classifier'):
-            if isinstance(app_state.model.classifier, nn.Sequential):
-                app_state.model.classifier[-1] = nn.Linear(app_state.model.classifier[-1].in_features, app_state.num_classes)
-            else:
-                app_state.model.classifier = nn.Linear(app_state.model.classifier.in_features, app_state.num_classes)
+        state.model = MODELS[model_name](pretrained=True)
         
-        app_state.model = app_state.model.to(device)
+        # Adaptar camada final
+        if hasattr(state.model, 'fc'):
+            state.model.fc = nn.Linear(state.model.fc.in_features, state.num_classes)
+        elif hasattr(state.model, 'classifier'):
+            if isinstance(state.model.classifier, nn.Sequential):
+                state.model.classifier[-1] = nn.Linear(state.model.classifier[-1].in_features, state.num_classes)
         
+        state.model = state.model.to(device)
         criterion = nn.CrossEntropyLoss()
-        optimizer = optim.Adam(app_state.model.parameters(), lr=float(lr))
+        optimizer = optim.Adam(state.model.parameters(), lr=float(lr))
         
-        app_state.model.train()
-        
-        results = [f"🚀 Treinando {model_name} por {epochs} épocas"]
+        state.model.train()
+        results = [f"🚀 Treinando {model_name}"]
         
         for epoch in range(int(epochs)):
             running_loss = 0.0
             correct = 0
             total = 0
             
-            for inputs, labels in app_state.train_loader:
+            for inputs, labels in state.train_loader:
                 inputs, labels = inputs.to(device), labels.to(device)
                 
                 optimizer.zero_grad()
-                outputs = app_state.model(inputs)
+                outputs = state.model(inputs)
                 loss = criterion(outputs, labels)
                 loss.backward()
                 optimizer.step()
                 
                 running_loss += loss.item()
-                _, predicted = torch.max(outputs.data, 1)
+                _, predicted = torch.max(outputs, 1)
                 total += labels.size(0)
                 correct += (predicted == labels).sum().item()
             
-            epoch_loss = running_loss / len(app_state.train_loader)
+            epoch_loss = running_loss / len(state.train_loader)
             epoch_acc = 100. * correct / total
             results.append(f"Época {epoch+1}: Loss={epoch_loss:.4f}, Acc={epoch_acc:.2f}%")
         
         results.append("✅ Treinamento concluído!")
         return "\n".join(results)
-    
     except Exception as e:
-        return f"❌ Erro durante treinamento: {str(e)}"
+        return f"❌ Erro: {str(e)}"
 
 def evaluate_model():
-    """Avalia o modelo no conjunto de teste"""
+    """Avalia modelo"""
     try:
-        if app_state.model is None or app_state.test_loader is None:
-            return "❌ Modelo ou dados não disponíveis."
+        if state.model is None or state.test_loader is None:
+            return "❌ Modelo/dados não disponíveis"
         
-        app_state.model.eval()
+        state.model.eval()
         all_preds = []
         all_labels = []
         
         with torch.no_grad():
-            for inputs, labels in app_state.test_loader:
+            for inputs, labels in state.test_loader:
                 inputs, labels = inputs.to(device), labels.to(device)
-                outputs = app_state.model(inputs)
+                outputs = state.model(inputs)
                 _, preds = torch.max(outputs, 1)
                 all_preds.extend(preds.cpu().numpy())
                 all_labels.extend(labels.cpu().numpy())
         
-        report = classification_report(all_labels, all_preds, target_names=app_state.class_labels, zero_division=0)
-        return f"📊 RELATÓRIO DE CLASSIFICAÇÃO:\n\n{report}"
-    
+        report = classification_report(
+            all_labels, all_preds, 
+            target_names=state.class_labels, 
+            zero_division=0
+        )
+        return f"📊 RELATÓRIO:\n\n{report}"
     except Exception as e:
-        return f"❌ Erro durante avaliação: {str(e)}"
+        return f"❌ Erro: {str(e)}"
+
+def generate_confusion_matrix():
+    """Gera matriz de confusão"""
+    try:
+        if state.model is None or state.test_loader is None:
+            return None
+        
+        state.model.eval()
+        all_preds = []
+        all_labels = []
+        
+        with torch.no_grad():
+            for inputs, labels in state.test_loader:
+                inputs, labels = inputs.to(device), labels.to(device)
+                outputs = state.model(inputs)
+                _, preds = torch.max(outputs, 1)
+                all_preds.extend(preds.cpu().numpy())
+                all_labels.extend(labels.cpu().numpy())
+        
+        cm = confusion_matrix(all_labels, all_preds)
+        
+        plt.figure(figsize=(8, 6))
+        sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
+                    xticklabels=state.class_labels,
+                    yticklabels=state.class_labels)
+        plt.xlabel('Predições')
+        plt.ylabel('Valores Reais')
+        plt.title('Matriz de Confusão')
+        plt.tight_layout()
+        
+        temp_path = tempfile.NamedTemporaryFile(suffix='.png', delete=False).name
+        plt.savefig(temp_path, dpi=150, bbox_inches='tight')
+        plt.close()
+        
+        return temp_path
+    except Exception as e:
+        print(f"Erro matriz confusão: {e}")
+        return None
 
 def predict_images(images):
-    """Faz predições em novas imagens"""
+    """Prediz imagens"""
     try:
-        if app_state.model is None:
-            return "❌ Modelo não treinado."
+        if state.model is None:
+            return "❌ Treine o modelo primeiro"
         
         if not images:
-            return "❌ Nenhuma imagem selecionada."
+            return "❌ Selecione imagens"
         
         transform = transforms.Compose([
             transforms.Resize((224, 224)),
             transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
         ])
         
-        app_state.model.eval()
+        state.model.eval()
         results = []
         
         for image_path in images:
-            if image_path is not None:
+            if image_path:
                 image = Image.open(image_path).convert('RGB')
                 img_tensor = transform(image).unsqueeze(0).to(device)
                 
                 with torch.no_grad():
-                    outputs = app_state.model(img_tensor)
-                    probabilities = torch.nn.functional.softmax(outputs[0], dim=0)
+                    outputs = state.model(img_tensor)
+                    probs = torch.nn.functional.softmax(outputs[0], dim=0)
                     _, predicted = torch.max(outputs, 1)
                     
-                    predicted_class_id = predicted.item()
-                    confidence = probabilities[predicted_class_id].item() * 100
-                    predicted_class_name = app_state.class_labels[predicted_class_id]
+                    class_id = predicted.item()
+                    confidence = probs[class_id].item() * 100
+                    class_name = state.class_labels[class_id]
                     
                     results.append(f"📸 {os.path.basename(image_path)}")
-                    results.append(f"   🎯 Classe: {predicted_class_name}")
-                    results.append(f"   📊 Confiança: {confidence:.2f}%")
-                    results.append("-" * 40)
+                    results.append(f"   🎯 {class_name}")
+                    results.append(f"   📊 {confidence:.2f}%")
+                    results.append("-" * 30)
         
-        return "\n".join(results) if results else "❌ Nenhuma predição realizada."
-    
+        return "\n".join(results) if results else "❌ Nenhuma predição"
     except Exception as e:
         return f"❌ Erro: {str(e)}"
 
-# Interface Gradio
-def create_interface():
-    with gr.Blocks(title="🖼️ Classificador de Imagens", theme=gr.themes.Soft()) as demo:
-        
-        gr.Markdown("""
-        # 🖼️ Sistema de Classificação de Imagens
-        
-        **Instruções:**
-        1. Configure as classes e rótulos
-        2. Faça upload das imagens
-        3. Prepare os dados e treine
-        4. Avalie e faça predições!
-        """)
-        
-        with gr.Tab("1️⃣ Configuração"):
-            with gr.Row():
-                num_classes_input = gr.Number(
-                    label="Número de Classes", 
-                    value=2, 
-                    minimum=2, 
-                    maximum=5,
-                    precision=0
-                )
-                setup_button = gr.Button("🔧 Configurar Classes", variant="primary")
-            
-            setup_output = gr.Textbox(label="Status", lines=2)
-            
-            gr.Markdown("### Rótulos das Classes")
-            
-            with gr.Row():
-                label0 = gr.Textbox(label="Classe 0", placeholder="Ex: gato")
-                label1 = gr.Textbox(label="Classe 1", placeholder="Ex: cachorro")
-            
-            with gr.Row():
-                label2 = gr.Textbox(label="Classe 2", placeholder="Ex: pássaro", visible=False)
-                label3 = gr.Textbox(label="Classe 3", placeholder="Ex: peixe", visible=False)
-                label4 = gr.Textbox(label="Classe 4", placeholder="Ex: hamster", visible=False)
-            
-            set_labels_button = gr.Button("🏷️ Definir Rótulos")
-            labels_output = gr.Textbox(label="Status dos Rótulos")
-            
-            # Dropdown que será atualizado
-            class_selector = gr.Dropdown(
-                label="Selecionar Classe",
-                choices=[(f"Classe 0", 0), (f"Classe 1", 1)],
-                value=0
-            )
-            
-        with gr.Tab("2️⃣ Upload"):
-            images_upload = gr.File(
-                label="Selecionar Imagens", 
-                file_count="multiple", 
-                file_types=["image"]
-            )
-            upload_button = gr.Button("📤 Fazer Upload", variant="primary")
-            upload_output = gr.Textbox(label="Status do Upload")
-            
-        with gr.Tab("3️⃣ Treinamento"):
-            batch_size = gr.Number(label="Batch Size", value=8, minimum=1, maximum=32)
-            prepare_button = gr.Button("⚙️ Preparar Dados", variant="primary")
-            prepare_output = gr.Textbox(label="Status", lines=3)
-            
-            with gr.Row():
-                model_name = gr.Dropdown(
-                    label="Modelo", 
-                    choices=list(MODELS.keys()), 
-                    value="MobileNetV2"
-                )
-                epochs = gr.Number(label="Épocas", value=3, minimum=1, maximum=10)
-                lr = gr.Number(label="Learning Rate", value=0.001, minimum=0.0001, maximum=0.1)
-            
-            train_button = gr.Button("🚀 Treinar", variant="primary")
-            train_output = gr.Textbox(label="Status do Treinamento", lines=10)
-            
-        with gr.Tab("4️⃣ Avaliação"):
-            eval_button = gr.Button("📊 Avaliar", variant="primary")
-            eval_output = gr.Textbox(label="Relatório", lines=15)
-            
-        with gr.Tab("5️⃣ Predição"):
-            predict_images_input = gr.File(
-                label="Imagens para Predição", 
-                file_count="multiple", 
-                file_types=["image"]
-            )
-            predict_button = gr.Button("🔮 Predizer", variant="primary")
-            predict_output = gr.Textbox(label="Resultados", lines=10)
-        
-        # Conectar eventos
-        setup_button.click(
-            fn=setup_classes,
-            inputs=[num_classes_input],
-            outputs=[setup_output, class_selector]
-        )
+# Interface
+with gr.Blocks(title="🖼️ Classificador", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 🖼️ Sistema de Classificação de Imagens
+    **Instruções:** Configure → Upload → Treine → Avalie → Prediga
+    """)
+    
+    with gr.Tab("1️⃣ Configuração"):
+        gr.Markdown("### 🎯 Configurar Classes")
         
-        set_labels_button.click(
-            fn=set_class_labels,
-            inputs=[label0, label1, label2, label3, label4],
-            outputs=[labels_output, class_selector]
+        num_classes = gr.Slider(
+            minimum=2, maximum=5, value=2, step=1,
+            label="Número de Classes"
         )
         
-        upload_button.click(
-            fn=upload_images,
-            inputs=[class_selector, images_upload],
-            outputs=[upload_output]
-        )
+        setup_btn = gr.Button("🔧 Configurar", variant="primary")
+        setup_status = gr.Textbox(label="Status", lines=2)
+        
+        gr.Markdown("### 🏷️ Definir Rótulos")
         
-        prepare_button.click(
-            fn=prepare_data,
-            inputs=[batch_size],
-            outputs=[prepare_output]
+        labels_input = gr.Textbox(
+            label="Rótulos (separados por vírgula)",
+            placeholder="gato, cachorro",
+            value="gato, cachorro"
         )
         
-        train_button.click(
-            fn=start_training,
-            inputs=[model_name, epochs, lr],
-            outputs=[train_output]
+        labels_btn = gr.Button("🏷️ Definir Rótulos")
+        labels_status = gr.Textbox(label="Status Rótulos")
+        
+    with gr.Tab("2️⃣ Upload"):
+        gr.Markdown("### 📤 Upload de Imagens")
+        
+        class_selector = gr.Slider(
+            minimum=0, maximum=1, value=0, step=1,
+            label="Classe (0, 1, 2...)"
         )
         
-        eval_button.click(
-            fn=evaluate_model,
-            outputs=[eval_output]
+        images_upload = gr.File(
+            label="Imagens",
+            file_count="multiple",
+            file_types=["image"]
         )
         
-        predict_button.click(
-            fn=predict_images,
-            inputs=[predict_images_input],
-            outputs=[predict_output]
+        upload_btn = gr.Button("📤 Upload", variant="primary")
+        upload_status = gr.Textbox(label="Status")
+        
+    with gr.Tab("3️⃣ Treinamento"):
+        gr.Markdown("### ⚙️ Preparar Dados")
+        
+        batch_size = gr.Slider(1, 32, 8, step=1, label="Batch Size")
+        prepare_btn = gr.Button("⚙️ Preparar", variant="primary")
+        prepare_status = gr.Textbox(label="Status", lines=4)
+        
+        gr.Markdown("### 🚀 Treinar Modelo")
+        
+        with gr.Row():
+            model_choice = gr.Radio(
+                choices=list(MODELS.keys()),
+                value="MobileNetV2",
+                label="Modelo"
+            )
+            epochs = gr.Slider(1, 10, 3, step=1, label="Épocas")
+            learning_rate = gr.Slider(0.0001, 0.01, 0.001, label="Learning Rate")
+        
+        train_btn = gr.Button("🚀 Treinar", variant="primary")
+        train_status = gr.Textbox(label="Status Treinamento", lines=8)
+        
+    with gr.Tab("4️⃣ Avaliação"):
+        gr.Markdown("### 📊 Avaliar Modelo")
+        
+        with gr.Row():
+            eval_btn = gr.Button("📊 Avaliar", variant="primary")
+            matrix_btn = gr.Button("📈 Matriz Confusão")
+        
+        eval_results = gr.Textbox(label="Relatório", lines=12)
+        confusion_matrix_plot = gr.Image(label="Matriz de Confusão")
+        
+    with gr.Tab("5️⃣ Predição"):
+        gr.Markdown("### 🔮 Predizer Novas Imagens")
+        
+        predict_images_input = gr.File(
+            label="Imagens para Predição",
+            file_count="multiple",
+            file_types=["image"]
         )
+        
+        predict_btn = gr.Button("🔮 Predizer", variant="primary")
+        predict_results = gr.Textbox(label="Resultados", lines=10)
     
-    return demo
+    # Conectar eventos
+    setup_btn.click(setup_classes, [num_classes], [setup_status])
+    labels_btn.click(set_class_labels, [labels_input], [labels_status])
+    upload_btn.click(upload_images, [class_selector, images_upload], [upload_status])
+    prepare_btn.click(prepare_data, [batch_size], [prepare_status])
+    train_btn.click(train_model, [model_choice, epochs, learning_rate], [train_status])
+    eval_btn.click(evaluate_model, [], [eval_results])
+    matrix_btn.click(generate_confusion_matrix, [], [confusion_matrix_plot])
+    predict_btn.click(predict_images, [predict_images_input], [predict_results])
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch()

requirements.txt

@@ -1,8 +1,8 @@
-gradio==4.44.0
-torch==2.1.0
-torchvision==0.16.0
-scikit-learn==1.3.2
-matplotlib==3.8.0
-seaborn==0.13.0
+gradio==4.20.0
+torch==2.0.1
+torchvision==0.15.2
+scikit-learn==1.3.0
+matplotlib==3.7.1
+seaborn==0.12.2
 numpy==1.24.3
-Pillow==10.0.1
+Pillow==9.5.0