repo

.gitignore

@@ -0,0 +1,42 @@
+# Ignorar ambiente virtual
+.venv/
+venv/
+env/
+
+# Ignorar arquivos de cache do Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Ignorar arquivos de configuração do VS Code
+.vscode/
+
+# Ignorar arquivos de ambiente
+.env
+.env.local
+
+# Ignorar arquivos de dados temporários (opcional, dependendo do fluxo de trabalho)
+*.csv
+*.joblib
+
+# Ignorar arquivos de log
+*.log
+
+# Ignorar diretórios de build e distribuição
+build/
+dist/
+*.egg-info/
+
+# Ignorar arquivos do sistema operacional
+.DS_Store
+Thumbs.db
+
+# Ignorar arquivos específicos do Hugging Face (se houver)
+*.huggingface/
+*.hf_cache/
+
+# Ignorar arquivos gerados pelo Streamlit (opcional)
+.streamlit/
+
+animals/

requirements.txt

@@ -0,0 +1,12 @@
+torch==2.1.0
+torchvision==0.16.0
+pandas==2.1.1
+numpy==1.26.0
+opencv-python==4.8.1.78
+scikit-learn==1.3.2
+seaborn==0.12.2
+matplotlib==3.7.2
+streamlit==1.27.0
+joblib==1.3.2
+huggingface_hub==0.19.4
+Pillow==10.0.0

src/app.py

@@ -0,0 +1,50 @@
+import streamlit as st
+import joblib
+from PIL import Image
+import torchvision.transforms as transforms
+from huggingface_hub import hf_hub_download
+
+# Função para carregar o modelo e o LabelEncoder do Hugging Face
+@st.cache_resource
+def load_model():
+    # Baixar o modelo e o LabelEncoder do Hugging Face
+    model_path = hf_hub_download(repo_id="arturevs/90AnimalClassification", filename="mlp_classifier.joblib")
+    label_encoder_path = hf_hub_download(repo_id="arturevs/90AnimalClassification", filename="label_encoder.joblib")
+    
+    # Carregar o modelo e o LabelEncoder
+    model = joblib.load(model_path)
+    label_encoder = joblib.load(label_encoder_path)
+    return model, label_encoder
+
+# Função para pré-processar a imagem
+def preprocess_image(image):
+    transform = transforms.Compose([
+        transforms.Resize((256, 256)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+    ])
+    image = transform(image).flatten().numpy().reshape(1, -1)
+    return image
+
+# Interface da aplicação
+st.title("Classificador de Animais")
+st.write("Envie uma imagem de um animal (gato, cachorro ou pássaro) para classificação.")
+
+# Carregar o modelo e o LabelEncoder
+model, label_encoder = load_model()
+
+# Upload da imagem
+uploaded_file = st.file_uploader("Escolha uma imagem...", type=["jpg", "jpeg", "png"])
+if uploaded_file is not None:
+    image = Image.open(uploaded_file)
+    st.image(image, caption="Imagem enviada", use_column_width=True)
+
+    # Pré-processar a imagem
+    image_processed = preprocess_image(image)
+
+    # Fazer a previsão
+    prediction = model.predict(image_processed)
+    predicted_class = label_encoder.inverse_transform(prediction)[0]
+
+    # Exibir o resultado
+    st.write(f"Classificação: **{predicted_class}**")

src/csv_creation.py

@@ -0,0 +1,36 @@
+import os
+import pandas as pd
+
+# Caminho para a pasta csv_folder (usando caminho relativo)
+CSV_FOLDER = "./csv_folder"
+
+# Lista para armazenar todos os DataFrames
+dataframes = []
+
+# Percorrer todos os arquivos na pasta csv_folder
+for csv_file in os.listdir(CSV_FOLDER):
+    if csv_file.endswith(".csv"):  # Verificar se é um arquivo CSV
+        csv_path = os.path.join(CSV_FOLDER, csv_file)
+        
+        try:
+            # Ler o CSV e adicionar à lista de DataFrames
+            df = pd.read_csv(csv_path)
+            dataframes.append(df)
+            print(f"Arquivo '{csv_file}' carregado com sucesso.")
+        except Exception as e:
+            print(f"Erro ao carregar o arquivo '{csv_file}': {e}")
+
+# Verificar se há DataFrames para unificar
+if not dataframes:
+    print("Nenhum arquivo CSV foi carregado. Verifique a pasta 'csv_folder'.")
+else:
+    # Unificar todos os DataFrames em um único DataFrame
+    unified_df = pd.concat(dataframes, ignore_index=True)
+    
+    # Salvar o DataFrame unificado em um novo arquivo CSV
+    output_csv_path = os.path.join("./", "unified_dataset.csv")
+    try:
+        unified_df.to_csv(output_csv_path, index=False)
+        print(f"Dataset unificado salvo como '{output_csv_path}'")
+    except Exception as e:
+        print(f"Erro ao salvar o dataset unificado: {e}")

src/img_processing.py

@@ -0,0 +1,97 @@
+import os
+import cv2
+import pandas as pd
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from torchvision.models import resnet18  # Usaremos uma CNN pré-treinada (ResNet18)
+
+# Configurações
+DATASET_PATH = "./animals/"  # Pasta principal com as subpastas de animais
+CSV_FOLDER = "./csv_folder"  # Pasta para salvar os CSVs
+IMAGE_SIZE = (224, 224)    # Tamanho das imagens para a CNN
+
+# Criar a pasta csv_folder se não existir
+if not os.path.exists(CSV_FOLDER):
+    os.makedirs(CSV_FOLDER)
+
+# Carregar uma CNN pré-treinada (ResNet18) e remover a camada final (fully connected)
+cnn_model = resnet18(pretrained=True)
+cnn_model = nn.Sequential(*list(cnn_model.children())[:-1])  # Remove a última camada
+cnn_model.eval()  # Colocar o modelo em modo de avaliação
+
+# Transformações para a imagem
+transform = transforms.Compose([
+    transforms.ToPILImage(),
+    transforms.Resize(IMAGE_SIZE),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Normalização para o modelo pré-treinado
+])
+
+# Função para extrair características de uma imagem usando a CNN
+def extract_features(image):
+    with torch.no_grad():  # Desativar cálculo de gradientes
+        image_tensor = transform(image).unsqueeze(0)  # Adicionar dimensão do batch
+        features = cnn_model(image_tensor)  # Extrair características
+        return features.flatten().numpy()  # Achatar e converter para numpy array
+
+# Função para processar uma subpasta (espécie) e salvar em um DataFrame
+def process_animal_folder(animal_class, class_path):
+    # Lista para armazenar os dados da subpasta
+    data = []
+    
+    # Percorrer as imagens da subpasta
+    for image_name in os.listdir(class_path):
+        image_path = os.path.join(class_path, image_name)
+        
+        try:
+            # Verificar se o arquivo é uma imagem válida
+            if not image_name.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
+                print(f"Ignorando arquivo não suportado: {image_path}")
+                continue
+            
+            # Carregar a imagem
+            image = cv2.imread(image_path)
+            if image is None:
+                raise ValueError(f"Falha ao carregar a imagem: {image_path}")
+            
+            # Extrair características usando a CNN
+            features = extract_features(image)
+            
+            # Adicionar ao dataset com o label sendo o nome da subpasta
+            data.append([animal_class] + list(features))
+        except Exception as e:
+            print(f"Erro ao processar {image_path}: {e}")
+    
+    # Verificar se há dados antes de criar o DataFrame
+    if not data:
+        print(f"Nenhuma imagem válida encontrada na pasta: {class_path}")
+        return None
+    
+    # Criar DataFrame
+    columns = ["label"] + [f"feature_{i}" for i in range(len(data[0]) - 1)]
+    df = pd.DataFrame(data, columns=columns)
+    
+    return df
+
+# Percorrer as subpastas
+for animal_class in os.listdir(DATASET_PATH):
+    class_path = os.path.join(DATASET_PATH, animal_class)
+    
+    # Verificar se é uma pasta
+    if os.path.isdir(class_path):
+        print(f"Processando imagens da classe: {animal_class}")
+        
+        # Processar a subpasta e obter o DataFrame
+        df = process_animal_folder(animal_class, class_path)
+        
+        if df is not None:
+            # Salvar CSV com o nome do animal
+            csv_filename = os.path.join(CSV_FOLDER, f"{animal_class}_dataset.csv")
+            try:
+                df.to_csv(csv_filename, index=False)
+                print(f"Dataset salvo como '{csv_filename}'")
+            except Exception as e:
+                print(f"Erro ao salvar o dataset {csv_filename}: {e}")
+
+print("Processamento concluído!")

src/model_training.py

@@ -0,0 +1,99 @@
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import classification_report, accuracy_score, confusion_matrix
+import seaborn as sns
+import matplotlib.pyplot as plt
+import joblib
+
+# Carregar o dataset unificado
+csv_path = "./unified_dataset.csv"  # Caminho relativo a partir da pasta src
+try:
+    df = pd.read_csv(csv_path)
+    print("Dataset carregado com sucesso!")
+except Exception as e:
+    print(f"Erro ao carregar o dataset: {e}")
+    exit()
+
+# Verificar o dataset
+print(df.head())
+print(f"Tamanho do dataset: {df.shape}")
+
+# Separar features (X) e labels (y)
+X = df.drop(columns=["label"])  # Todas as colunas exceto 'label'
+y = df["label"]  # Coluna 'label'
+
+# Codificar as labels (transformar strings em números)
+label_encoder = LabelEncoder()
+y = label_encoder.fit_transform(y)
+
+# Dividir o dataset em treino e teste
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Normalizar as features (importante para MLP)
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# Criar e treinar a MLP
+mlp = MLPClassifier(
+    hidden_layer_sizes=(128, 64),  # Duas camadas ocultas com 128 e 64 neurônios
+    activation="relu",             # Função de ativação ReLU
+    solver="adam",                 # Otimizador Adam
+    max_iter=500,                  # Número máximo de iterações
+    random_state=42,
+    verbose=True                   # Mostrar progresso durante o treinamento
+)
+
+print("Treinando a MLP...")
+mlp.fit(X_train, y_train)
+
+# Fazer previsões no conjunto de teste
+y_pred = mlp.predict(X_test)
+
+# Avaliar o modelo
+print("\nRelatório de classificação:")
+print(classification_report(y_test, y_pred, target_names=label_encoder.classes_))
+
+print(f"Acurácia: {accuracy_score(y_test, y_pred):.4f}")
+
+# Gerar a matriz de confusão
+conf_matrix = confusion_matrix(y_test, y_pred)
+
+# Plotar a matriz de confusão
+plt.figure(figsize=(10, 7))
+sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues",
+            xticklabels=label_encoder.classes_,
+            yticklabels=label_encoder.classes_)
+plt.xlabel("Predito")
+plt.ylabel("Verdadeiro")
+plt.title("Matriz de Confusão")
+plt.show()
+
+# Extrair valores relevantes da matriz de confusão
+print("\nValores relevantes da matriz de confusão:")
+
+# Acurácia por classe
+class_accuracy = conf_matrix.diagonal() / conf_matrix.sum(axis=1)
+for i, accuracy in enumerate(class_accuracy):
+    print(f"Acurácia da classe {label_encoder.classes_[i]}: {accuracy:.4f}")
+
+# Erros mais comuns (maiores valores fora da diagonal)
+conf_matrix_df = pd.DataFrame(conf_matrix, index=label_encoder.classes_, columns=label_encoder.classes_)
+conf_matrix_df.values[np.diag_indices_from(conf_matrix_df)] = 0  # Zerar a diagonal para focar nos erros
+most_common_errors = conf_matrix_df.stack().sort_values(ascending=False).head(5)
+
+print("\nErros mais comuns:")
+print(most_common_errors)
+
+# Salvar o modelo
+model_filename = "mlp_classifier.joblib"
+joblib.dump(mlp, model_filename)
+print(f"Modelo salvo como {model_filename}")
+
+# Salvar o LabelEncoder (para decodificar as previsões)
+label_encoder_filename = "label_encoder.joblib"
+joblib.dump(label_encoder, label_encoder_filename)
+print(f"LabelEncoder salvo como {label_encoder_filename}")

src/send_model.py

@@ -0,0 +1,18 @@
+from huggingface_hub import HfApi
+
+# Nome do repositório no Hugging Face
+repo_id = "arturevs/90AnimalClassifier"  # Substitua pelo seu usuário e nome do repositório
+
+# Arquivos a serem enviados
+files_to_upload = ["./mlp_classifier.joblib", "./label_encoder.joblib"]
+
+# Enviar arquivos para o Hugging Face
+api = HfApi()
+for file in files_to_upload:
+    api.upload_file(
+        path_or_fileobj=file,
+        path_in_repo=file,
+        repo_id=repo_id,
+        repo_type="model"
+    )
+print("Modelo enviado para o Hugging Face!")