Readme e Documentacao

README.md

@@ -1 +1,178 @@
-[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/LUsvMCbe)
+# 2024-2-APP-GP-VERDE-APP
+
+## Descrição do Projeto
+
+Este é um projeto desenvolvido para a Sprint Session do 4º semestre de 2024/2 no Insper, em parceria com a DASA. O projeto consiste em um sistema completo com:
+
+- **Frontend:** Implementado em React + Vite.
+- **Backend:** Implementado em FastAPI.
+
+**Link para acessar o site do projeto:** [http://3.81.205.150](http://3.81.205.150)
+
+## Estrutura do Repositório
+
+- **`app/`**: Contém o código do frontend (React + Vite).
+- **`back/`**: Contém o código do backend (FastAPI).
+
+---
+
+## Instalação do AWS CLI e DVC
+
+### **1. Instalar o Python**
+Certifique-se de que o Python está instalado em sua máquina:
+
+1. Verifique a versão do Python:
+   ```bash
+   python3 --version
+   ```
+2. Caso não esteja instalado, siga as instruções específicas do seu sistema operacional para instalá-lo.
+
+### **2. Instalar o Node.js**
+Certifique-se de que o Node.js está instalado em sua máquina:
+
+1. Verifique a versão do Node.js:
+   ```bash
+   node --version
+   ```
+2. Caso não esteja instalado, baixe o instalador do [site oficial do Node.js](https://nodejs.org) e siga as instruções.
+
+### **3. Instalar o AWS CLI**
+
+#### **Windows**
+
+1. Baixe o instalador oficial: [AWS CLI para Windows](https://awscli.amazonaws.com/AWSCLIV2.msi)
+2. Execute o arquivo `.msi` e siga as instruções do instalador.
+3. Verifique a instalação:
+   ```bash
+   aws --version
+   ```
+
+#### **macOS**
+
+1. Baixe o pacote do instalador:
+   ```bash
+   curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
+   ```
+2. Instale com o comando:
+   ```bash
+   sudo installer -pkg AWSCLIV2.pkg -target /
+   ```
+3. Verifique a instalação:
+   ```bash
+   aws --version
+   ```
+
+#### **Linux**
+
+1. Baixe o instalador:
+   ```bash
+   curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
+   ```
+2. Extraia o arquivo:
+   ```bash
+   unzip awscliv2.zip
+   ```
+3. Execute o instalador:
+   ```bash
+   sudo ./aws/install
+   ```
+4. Verifique a instalação:
+   ```bash
+   aws --version
+   ```
+
+### **4. Instalar o DVC**
+
+#### **Via pip (Recomendado)**
+
+1. Certifique-se de que o Python está instalado:
+   ```bash
+   python3 --version
+   ```
+2. Instale o DVC:
+   ```bash
+   pip install dvc[s3]
+   ```
+3. Verifique a instalação:
+   ```bash
+   dvc --version
+   ```
+
+---
+
+## Instalação e Execução do Projeto
+
+### **1. Clonar o Repositório**
+
+1. Clone o repositório para a sua máquina local:
+   ```bash
+   git clone https://github.com/insper-classroom/2024-2-app-gp-verde-app.git
+   ```
+2. Entre na pasta do projeto:
+   ```bash
+   cd 2024-2-app-gp-verde-app
+   ```
+
+### **2. Configuração Inicial do Repositório**
+
+1. Configure suas credenciais AWS:
+   ```bash
+   aws configure
+   ```
+   Insira as seguintes informações:
+   - AWS Access Key ID
+   - AWS Secret Access Key
+   - Default region (us-east-1)
+   - Output format (deixe vazio ou "json")
+
+2. Baixe os arquivos de dados gerenciados pelo DVC:
+   ```bash
+   dvc pull
+   ```
+3. Certifique-se de que todos os arquivos foram baixados corretamente antes de rodar o backend.
+
+### **3. Configuração do Frontend**
+
+1. Abra um terminal e entre na pasta do frontend:
+   ```bash
+   cd app
+   ```
+2. Instale as dependências:
+   ```bash
+   npm install
+   ```
+3. Inicie o servidor de desenvolvimento:
+   ```bash
+   npm run dev
+   ```
+   O servidor será iniciado localmente em [http://localhost:5173](http://localhost:5173).
+
+### **4. Configuração do Backend**
+
+1. Abra outro terminal e entre na pasta do backend:
+   ```bash
+   cd back
+   ```
+2. Instale as dependências:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Inicie o servidor do FastAPI:
+   ```bash
+   uvicorn main:app --reload
+   ```
+   O servidor será iniciado localmente em [http://127.0.0.1:8000](http://127.0.0.1:8000).
+
+> **Nota:** É necessário utilizar dois terminais separados para rodar o frontend e o backend simultaneamente.
+
+---
+
+## Contribuições
+
+Este repositório foi desenvolvido por:
+
+- Giovanny Russo
+- Leonardo Freitas
+- Luigi Orlandi
+- Thiago Penha
+

app/src/App.jsx

@@ -1,3 +1,10 @@
+/**
+ * Este código React implementa uma interface para carregar arquivos .txt,
+ * enviá-los para um servidor backend e exibir os resultados processados,
+ * incluindo predições e heatmaps. A interface é estilizada com Material-UI
+ * e inclui animações com Framer Motion.
+ */
+
 import React, { useState } from "react";
 import {
   Box,

back/main.py

@@ -5,78 +5,91 @@
 from utils import *
 import numpy as np
 from plot import *
-import base64 
+import base64
 import pickle
 import os
 import shutil
 
+# Inicializa a aplicação FastAPI
 app = FastAPI()
 
+# Configuração de CORS para permitir requisições de qualquer origem
 origins = ["*"]
-
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=origins,
+    allow_origins=origins,  # Permitir todas as origens
     allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_methods=["*"],    # Permitir todos os métodos HTTP
+    allow_headers=["*"],    # Permitir todos os cabeçalhos
 )
 
+# Carregamento do modelo pré-treinado de TensorFlow
 model = tf.keras.models.load_model("model/model_artigo_v4.keras")
 
+# Carregamento das informações de comprimento dos braços cromossômicos
 with open("./data/arm_lengths/arm_lengths.pkl", "rb") as f:
     chr_arms = pickle.load(f)
 
+# Definição de diretórios para uploads e logs
 TEMP_DIR = "./uploads/coverage"
 LOG_DIR = "./logs"
-os.makedirs(TEMP_DIR, exist_ok=True)
-os.makedirs(LOG_DIR, exist_ok=True)
+os.makedirs(TEMP_DIR, exist_ok=True)  # Garante que o diretório temporário existe
+os.makedirs(LOG_DIR, exist_ok=True)  # Garante que o diretório de logs existe
 
+# Endpoint raiz para verificação da API
 @app.get("/")
 async def root():
     return {"message": "Hello World"}
 
+# Endpoint para processar múltiplos arquivos enviados pelo usuário
 @app.post("/process-multiple-files")
 async def process_multiple_files(files: list[UploadFile] = File(...)):
+    """
+    Processa múltiplos arquivos de cobertura enviados pelo usuário.
+    Para cada arquivo:
+    1. Salva temporariamente.
+    2. Pré-processa os dados e realiza predição.
+    3. Gera um heatmap e salva nos logs.
+    4. Retorna resultados, incluindo as predições e o heatmap em Base64.
+    """
     results = []
     threshold = 0.6518086791038513  # Limiar para classificação
+
     try:
         for file in files:
-            # Salvar arquivo temporariamente
+            # Salvar o arquivo temporariamente
             cov_file = os.path.join(TEMP_DIR, file.filename)
             with open(cov_file, "wb") as f:
-                f.write(await file.read())
+                f.write(await file.read())  # Escreve o conteúdo do arquivo
 
             try:
-                # Criar pasta para logs deste arquivo
+                # Criar subdiretório para logs deste arquivo
                 log_subdir = os.path.join(LOG_DIR, os.path.splitext(file.filename)[0])
                 os.makedirs(log_subdir, exist_ok=True)
 
-                # Copiar o arquivo enviado para a pasta de logs
+                # Copiar o arquivo enviado para os logs
                 shutil.copy(cov_file, os.path.join(log_subdir, file.filename))
 
-                # Pré-processamento
+                # Pré-processamento do arquivo
                 min_size = 2500000
                 max_size = 3500000
                 step = 100
-
-                # Processar arquivo de cobertura para matriz de entrada
                 cov_matrix = process_new_sample(cov_file, chr_arms, min_size, max_size, step)
 
-                # Preparar a matriz para predição
+                # Preparar matriz para predição
                 prepared_matrix = prepare_data([cov_matrix])[0]
 
-                # Predição
+                # Realizar predição com o modelo
                 prediction = model.predict(np.array([prepared_matrix]))[0][0]
                 prediction_result = "Positive" if prediction >= threshold else "Negative"
 
-                # Gerar heatmap
+                # Gerar heatmap do arquivo
                 corrected_df = pd.read_csv(cov_file, sep="\t")
                 smoothed_cov = smooth_normalized_coverage(corrected_df, chr_arms, min_size, max_size, step)
                 cov_matrix = create_2d_array(smoothed_cov)
                 heatmap_buffer = plot_heatmap(cov_matrix, file.filename.split('.')[0])
 
-                # Salvar heatmap na pasta de logs
+                # Salvar heatmap nos logs
                 heatmap_path = os.path.join(log_subdir, f"{os.path.splitext(file.filename)[0]}_heatmap.png")
                 with open(heatmap_path, "wb") as heatmap_file:
                     heatmap_buffer.seek(0)
@@ -86,17 +99,18 @@ async def process_multiple_files(files: list[UploadFile] = File(...)):
                 heatmap_buffer.seek(0)
                 heatmap_base64 = base64.b64encode(heatmap_buffer.read()).decode("utf-8")
 
-                # Adicionar resultado ao retorno
+                # Adicionar resultados ao retorno
                 results.append({
                     "filename": file.filename,
                     "prediction": prediction_result,
                     "heatmap": heatmap_base64,
                 })
             finally:
-                # Remover arquivo temporário
+                # Remover o arquivo temporário
                 os.remove(cov_file)
 
-        # Retornar resultados
+        # Retornar todos os resultados
         return JSONResponse(content={"results": results})
     except Exception as e:
+        # Em caso de erro, retornar uma exceção HTTP
         raise HTTPException(status_code=500, detail=f"Erro ao processar arquivos: {str(e)}")