chore: translate infrastructure and code comments from Portuguese to English

Author: ciro-maciel

inference/src/index.js

@@ -8,7 +8,7 @@ import natural from 'natural';
 
 const { BayesClassifier } = natural;
 
-// Resolve caminho do DB relativo a este arquivo (independente do CWD)
+// Resolve DB path relative to this file (independent of CWD)
 const dbPath = new URL('../main.db', import.meta.url).pathname;
 const sqlite = new Database(dbPath);
 const db = drizzle(sqlite, { schema });
@@ -18,15 +18,15 @@ let classifier = null;
 async function loadProductionModel() {
     const prodRun = await db.query.runs.findFirst({ where: eq(schema.runs.isProduction, true) });
     if (prodRun && prodRun.modelArtifactPath) {
-        // Resolve o caminho do artefato. Se for relativo (ex: 'artifacts/...'), resolvemos a partir da raiz do repo.
+        // Resolve artifact path. If it's relative (e.g., 'artifacts/...'), resolve from the repo root.
         const artifactPath = prodRun.modelArtifactPath.startsWith('/')
           ? prodRun.modelArtifactPath
           : new URL(`../../${prodRun.modelArtifactPath}`, import.meta.url).pathname;
-        console.log(`Carregando modelo: ${artifactPath}`);
+        console.log(`Loading model: ${artifactPath}`);
         const modelJson = await Bun.file(artifactPath).text();
         classifier = BayesClassifier.restore(JSON.parse(modelJson));
     } else {
-        console.log("Nenhum modelo em produção encontrado.");
+        console.log("No production model found.");
     }
 }
 
@@ -50,15 +50,15 @@ const app = new Elysia()
   .post('/predict', async ({ body }) => {
     if (!classifier) {
         await loadProductionModel();
-        if(!classifier) return { error: 'Modelo não está carregado' };
+        if(!classifier) return { error: 'Model is not loaded' };
     }
     const prediction = classifier.getClassifications(body.message);
     return { prediction };
   }, {
-    // O `t.Object` é um validador de schema em tempo de execução, útil também em JS.
+    // `t.Object` is a runtime schema validator; useful in JS too.
     body: t.Object({ message: t.String() })
   })
   .listen(3001);
 
-console.log(`API rodando em http://${app.server?.hostname}:${app.server?.port}`);
+console.log(`API running at http://${app.server?.hostname}:${app.server?.port}`);
 loadProductionModel();

infra/README.md

@@ -1,18 +1,18 @@
-# Infraestrutura (conceitual)
+# Infrastructure (conceptual)
 
-Este diretório contém artefatos de infraestrutura para executar o monorepo em ambientes conteinerizados ou orquestrados.
+This directory contains infrastructure artifacts to run the monorepo in containerized or orchestrated environments.
 
-Estrutura:
+Structure:
 - docker/
-  - Dockerfile.inference: imagem do serviço de inferência (Elysia/Bun)
-  - Dockerfile.dashboard: imagem do dashboard (Vite -> Nginx)
-  - Dockerfile.training: imagem para job de treinamento on-demand
-- docker-compose.yml: orquestração local dos serviços (inference + dashboard). O serviço de training está em profile opcional.
+  - Dockerfile.inference: image for the inference service (Elysia/Bun)
+  - Dockerfile.dashboard: image for the dashboard (Vite -> Nginx)
+  - Dockerfile.training: image for an on-demand training job
+- docker-compose.yml: local orchestration for services (inference + dashboard). The training job is in an optional profile.
 - k8s/
   - inference-deployment.yaml, inference-service.yaml
   - dashboard-deployment.yaml, dashboard-service.yaml
 
-Observações:
-- Artefatos de modelo ficam centralizados em `artifacts/` na raiz e são montados nos containers.
-- O banco SQLite (`inference/main.db`) é compartilhado entre treino e inferência. No compose, o DB é efêmero por simplicidade; pode-se bind-mount conforme necessidade.
-- As imagens no diretório k8s são placeholders; ajuste com seu registry.
+Notes:
+- Model artifacts are centralized under `artifacts/` at the repo root and are mounted into containers.
+- The SQLite database (`inference/main.db`) is shared between training and inference. In compose, the DB is ephemeral for simplicity; you can bind-mount if needed.
+- Images in the k8s directory are placeholders; update them with your registry.

infra/docker/Dockerfile.inference

@@ -2,10 +2,10 @@
 FROM oven/bun:1
 WORKDIR /app
 
-# Copia o monorepo inteiro (conceitual/simples)
+# Copy the whole monorepo (simple/conceptual)
 COPY . .
 
-# Instala dependências (workspaces)
+# Install dependencies (workspaces)
 RUN bun install --ci
 
 EXPOSE 3001

infra/docker/Dockerfile.training

@@ -5,5 +5,5 @@ WORKDIR /app
 COPY . .
 RUN bun install --ci
 
-# Perfil de job: executa e finaliza
+# Job profile: run and exit
 CMD ["bun", "--cwd", "training", "run", "train"]

training/src/train.js

@@ -8,9 +8,9 @@ import { promises as fs } from 'fs';
 const { BayesClassifier } = natural;
 
 async function trainAndEvaluate() {
-  console.log('Iniciando o pipeline de treinamento...');
+  console.log('Starting training pipeline...');
 
-  // Lê o dataset centralizado em data/raw/ (relativo a este arquivo)
+  // Read dataset centralized in data/raw/ (relative to this file)
   const datasetPath = new URL('../../data/raw/dataset.csv', import.meta.url).pathname;
   const datasetRaw = await fs.readFile(datasetPath, 'utf-8');
   const dataset = datasetRaw.split('\n').slice(1).map(line => {
@@ -22,22 +22,22 @@ async function trainAndEvaluate() {
   const classifier = new BayesClassifier();
   dataset.forEach(item => item && classifier.addDocument(item.text, item.label));
   classifier.train();
-  console.log('Modelo treinado.');
+  console.log('Model trained.');
 
   let correct = 0;
   dataset.forEach(item => {
     if (item && classifier.classify(item.text) === item.label) correct++;
   });
   const accuracy = correct / dataset.length;
-  const metrics = { f1Score: accuracy, accuracy: accuracy }; // Simplificação
-  console.log(`Acurácia do novo modelo: ${metrics.accuracy}`);
+  const metrics = { f1Score: accuracy, accuracy: accuracy }; // Simplification
+  console.log(`New model accuracy: ${metrics.accuracy}`);
 
-  // Usa o mesmo banco do serviço de inferência (inference/main.db)
+  // Use the same DB as the inference service (inference/main.db)
   const dbPath = new URL('../../inference/main.db', import.meta.url).pathname;
   const sqlite = new Database(dbPath, { create: true });
   const db = drizzle(sqlite, { schema });
 
-  // Garante que exista um experimento padrão e obtem seu ID
+  // Ensure a default experiment exists and get its ID
   let experimentId = 1;
   try {
     const existing = await db.query.experiments.findFirst({
@@ -53,14 +53,14 @@ async function trainAndEvaluate() {
       experimentId = existing.id;
     }
   } catch (e) {
-    console.warn('Não foi possível verificar/criar experimento padrão:', e?.message || e);
+    console.warn('Could not verify/create default experiment:', e?.message || e);
   }
 
   const currentProdRun = await db.query.runs.findFirst({
     where: eq(schema.runs.isProduction, true),
   });
 
-  // Lê métricas atuais do modelo em produção (podem estar como string JSON)
+  // Read current production model metrics (may be stored as JSON string)
   let currentProdAccuracy = 0;
   if (currentProdRun?.metrics) {
     try {
@@ -70,23 +70,23 @@ async function trainAndEvaluate() {
       currentProdAccuracy = 0;
     }
   }
-  console.log(`Acurácia do modelo em produção: ${currentProdAccuracy}`);
+  console.log(`Production model accuracy: ${currentProdAccuracy}`);
 
   if (metrics.accuracy <= currentProdAccuracy) {
-    console.log('Novo modelo não superou o modelo em produção. Abortando.');
+    console.log('New model did not outperform the production model. Aborting.');
     return;
   }
 
-  console.log('Novo modelo é superior! Promovendo para produção.');
+  console.log('New model is better! Promoting to production.');
   const runId = Date.now();
-  // Salva o artefato centralizado em artifacts/ na raiz do repo
+  // Save artifact centralized under artifacts/ at the repo root
   const modelArtifactPath = `artifacts/model_${runId}.json`;
 
   const artifactDir = new URL('../../artifacts/', import.meta.url).pathname;
   await fs.mkdir(artifactDir, { recursive: true });
   const classifierJson = JSON.stringify(classifier);
   await fs.writeFile(`${artifactDir}model_${runId}.json`, classifierJson);
-  console.log(`Modelo salvo em: ${modelArtifactPath}`);
+  console.log(`Model saved at: ${modelArtifactPath}`);
 
   if (currentProdRun) {
     await db.update(schema.runs).set({ isProduction: false }).where(eq(schema.runs.id, currentProdRun.id));
@@ -101,7 +101,7 @@ async function trainAndEvaluate() {
     isProduction: true,
   });
 
-  console.log('Pipeline de treinamento concluído com sucesso!');
+  console.log('Training pipeline completed successfully!');
 }
 
 trainAndEvaluate();