Add UFPAlign Docker implementation - Fix MFA Portuguese model names in original Dockerfile - Add comprehensive UFPAlign Docker setup with Kaldi toolkit - Include Docker Compose configuration for multi-container deployment - Add Makefile with convenient commands for container management - Support for interactive shell, API service, and batch processing - Complete documentation for UFPAlign Brazilian Portuguese alignment

Dockerfile

@@ -17,7 +17,7 @@ RUN pip install --no-cache-dir \
 WORKDIR /app
 
 # Download Portuguese models during build
-RUN mfa model download acoustic portuguese_brazil_mfa && \
+RUN mfa model download acoustic portuguese_mfa && \
     mfa model download g2p portuguese_brazil_mfa
 
 # Copy application files

Dockerfile.ufpalign

@@ -0,0 +1,96 @@
+FROM kaldiasr/kaldi:latest
+
+LABEL maintainer="UFPAlign Docker Implementation"
+LABEL description="UFPAlign - Brazilian Portuguese Forced Phonetic Alignment Tool"
+LABEL version="1.0"
+
+# Set environment variables
+ENV UFPALIGN_DIR=/opt/UFPAlign
+ENV KALDI_ROOT=/opt/kaldi
+ENV LC_ALL=pt_BR.UTF-8
+ENV LANG=pt_BR.UTF-8
+ENV PYTHONPATH=/opt/UFPAlign:$PYTHONPATH
+
+# Update system and install dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    sudo \
+    curl \
+    wget \
+    openjdk-8-jdk \
+    locales \
+    python3-pip \
+    python3-dev \
+    python3-setuptools \
+    build-essential \
+    sox \
+    ffmpeg \
+    git && \
+    # Configure locale for Portuguese (Brazil)
+    sed -i '/pt_BR.UTF-8/s/^# //g' /etc/locale.gen && \
+    locale-gen && \
+    # Upgrade pip
+    pip3 install --upgrade pip && \
+    # Create UFPAlign directory
+    mkdir -p $UFPALIGN_DIR && \
+    # Clean up apt cache
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir \
+    gdown==5.0.0 \
+    numpy==1.26.3 \
+    pandas==2.2.2 \
+    TextGrid==1.5 \
+    Unidecode==1.3.8 \
+    fastapi \
+    uvicorn \
+    python-multipart \
+    pydantic \
+    aiofiles
+
+# Clone UFPAlign repository
+RUN cd /opt && \
+    git clone https://github.com/falabrasil/ufpalign.git UFPAlign && \
+    cd UFPAlign && \
+    chmod +x ufpalign.sh
+
+# Set working directory
+WORKDIR $UFPALIGN_DIR
+
+# Copy application files if they exist in build context
+COPY app.py /opt/UFPAlign/ 2>/dev/null || true
+COPY requirements.txt /opt/UFPAlign/ 2>/dev/null || true
+
+# Create necessary directories
+RUN mkdir -p \
+    $UFPALIGN_DIR/uploads \
+    $UFPALIGN_DIR/output \
+    $UFPALIGN_DIR/textgrid \
+    /root/logs
+
+# Download models during build (optional - can be done at runtime)
+# RUN utils/download_model.sh "data" $UFPALIGN_DIR && \
+#     utils/download_model.sh "mono" $UFPALIGN_DIR
+
+# Make sure Kaldi is properly linked
+RUN if [ -d "/opt/kaldi" ]; then \
+        ln -sf /opt/kaldi/egs/wsj/s5/steps $UFPALIGN_DIR/steps; \
+        ln -sf /opt/kaldi/egs/wsj/s5/utils $UFPALIGN_DIR/utils_kaldi; \
+        ln -sf /opt/kaldi/egs/wsj/s5/path.sh $UFPALIGN_DIR/path.sh; \
+    fi
+
+# Set proper permissions
+RUN chown -R root:root $UFPALIGN_DIR && \
+    chmod -R 755 $UFPALIGN_DIR
+
+# Expose port for API if needed
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD [ -f "$UFPALIGN_DIR/ufpalign.sh" ] && echo "UFPAlign is ready" || exit 1
+
+# Default command
+CMD ["/bin/bash"] 

Makefile.ufpalign

@@ -0,0 +1,158 @@
+# UFPAlign Docker Management Makefile
+# Inspired by Docker containerizing test tooling best practices
+
+# Variables
+IMAGE_NAME := ufpalign
+HUB_NAMESPACE := your-namespace
+VERSION := $(shell date +'%Y%m%d')
+CONTAINER_NAME := ufpalign-container
+API_CONTAINER_NAME := ufpalign-api-container
+
+# Docker Compose files
+COMPOSE_FILE := docker-compose.ufpalign.yml
+
+# Color output
+RED := \033[31m
+GREEN := \033[32m
+YELLOW := \033[33m
+BLUE := \033[34m
+RESET := \033[0m
+
+.PHONY: help version-check clean-image image push test-container run-interactive run-api stop clean setup-dirs
+
+help: ## Show this help message
+	@echo "$(BLUE)UFPAlign Docker Management$(RESET)"
+	@echo ""
+	@echo "$(GREEN)Available targets:$(RESET)"
+	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "  $(YELLOW)%-20s$(RESET) %s\n", $$1, $$2}' $(MAKEFILE_LIST)
+
+version-check: ## Check current version and image status
+	@echo "$(BLUE)Current version: $(VERSION)$(RESET)"
+	@echo "$(BLUE)Checking for existing images:$(RESET)"
+	@docker images | grep $(IMAGE_NAME) || echo "$(YELLOW)No existing images found$(RESET)"
+
+setup-dirs: ## Create necessary local directories
+	@echo "$(GREEN)Creating local directories...$(RESET)"
+	@mkdir -p audio_input text_input output textgrid logs
+	@echo "$(GREEN)Directories created successfully$(RESET)"
+
+clean-image: version-check ## Remove existing Docker images
+	@echo "$(RED)Removing existing images...$(RESET)"
+	@docker rmi $(IMAGE_NAME):latest 2>/dev/null || true
+	@docker rmi $(IMAGE_NAME):$(VERSION) 2>/dev/null || true
+	@docker rmi $(HUB_NAMESPACE)/$(IMAGE_NAME):latest 2>/dev/null || true
+	@docker rmi $(HUB_NAMESPACE)/$(IMAGE_NAME):$(VERSION) 2>/dev/null || true
+
+image: version-check ## Build the Docker image
+	@echo "$(GREEN)Building UFPAlign Docker image...$(RESET)"
+	@docker build -t $(IMAGE_NAME):$(VERSION) -f Dockerfile.ufpalign .
+	@docker tag $(IMAGE_NAME):$(VERSION) $(IMAGE_NAME):latest
+	@docker tag $(IMAGE_NAME):$(VERSION) $(HUB_NAMESPACE)/$(IMAGE_NAME):$(VERSION)
+	@docker tag $(IMAGE_NAME):$(VERSION) $(HUB_NAMESPACE)/$(IMAGE_NAME):latest
+	@echo "$(GREEN)Image built successfully$(RESET)"
+	@docker images | grep $(IMAGE_NAME)
+
+push: clean-image image ## Build and push image to registry
+	@echo "$(BLUE)Pushing images to registry...$(RESET)"
+	@docker push $(HUB_NAMESPACE)/$(IMAGE_NAME):$(VERSION)
+	@docker push $(HUB_NAMESPACE)/$(IMAGE_NAME):latest
+	@echo "$(GREEN)Images pushed successfully$(RESET)"
+
+test-container: image ## Run UFPAlign tests in container
+	@echo "$(GREEN)Running UFPAlign tests...$(RESET)"
+	@docker run --rm --name ufpalign-test \
+		-v $(PWD)/temp_ufpalign/demo:/opt/UFPAlign/test_data:ro \
+		$(IMAGE_NAME):latest \
+		bash -c "cd /opt/UFPAlign && KALDI_ROOT=/opt/kaldi bash ufpalign.sh test_data/ex.wav test_data/ex.txt mono"
+
+run-interactive: setup-dirs image ## Run UFPAlign container interactively
+	@echo "$(GREEN)Starting UFPAlign container in interactive mode...$(RESET)"
+	@docker run -it --rm \
+		--name $(CONTAINER_NAME) \
+		-v $(PWD)/audio_input:/opt/UFPAlign/audio_input:ro \
+		-v $(PWD)/text_input:/opt/UFPAlign/text_input:ro \
+		-v $(PWD)/output:/opt/UFPAlign/output:rw \
+		-v $(PWD)/textgrid:/opt/UFPAlign/textgrid:rw \
+		-v $(PWD)/logs:/root/logs:rw \
+		$(IMAGE_NAME):latest bash
+
+run-api: setup-dirs image ## Run UFPAlign with API service
+	@echo "$(GREEN)Starting UFPAlign API service...$(RESET)"
+	@docker run -d \
+		--name $(API_CONTAINER_NAME) \
+		-p 7860:7860 \
+		-v $(PWD)/audio_input:/opt/UFPAlign/audio_input:ro \
+		-v $(PWD)/text_input:/opt/UFPAlign/text_input:ro \
+		-v $(PWD)/output:/opt/UFPAlign/output:rw \
+		-v $(PWD)/textgrid:/opt/UFPAlign/textgrid:rw \
+		-v $(PWD)/logs:/root/logs:rw \
+		-v $(PWD)/app.py:/opt/UFPAlign/app.py:ro \
+		$(IMAGE_NAME):latest \
+		uvicorn app:app --host 0.0.0.0 --port 7860
+	@echo "$(GREEN)API service started at http://localhost:7860$(RESET)"
+
+compose-up: setup-dirs ## Start services using Docker Compose
+	@echo "$(GREEN)Starting UFPAlign services with Docker Compose...$(RESET)"
+	@docker-compose -f $(COMPOSE_FILE) up -d
+	@echo "$(GREEN)Services started$(RESET)"
+
+compose-down: ## Stop Docker Compose services
+	@echo "$(RED)Stopping Docker Compose services...$(RESET)"
+	@docker-compose -f $(COMPOSE_FILE) down
+	@echo "$(GREEN)Services stopped$(RESET)"
+
+compose-logs: ## Show Docker Compose logs
+	@docker-compose -f $(COMPOSE_FILE) logs -f
+
+stop: ## Stop running containers
+	@echo "$(RED)Stopping UFPAlign containers...$(RESET)"
+	@docker stop $(CONTAINER_NAME) 2>/dev/null || true
+	@docker stop $(API_CONTAINER_NAME) 2>/dev/null || true
+	@docker rm $(CONTAINER_NAME) 2>/dev/null || true
+	@docker rm $(API_CONTAINER_NAME) 2>/dev/null || true
+	@echo "$(GREEN)Containers stopped$(RESET)"
+
+clean: stop clean-image ## Clean up containers and images
+	@echo "$(RED)Cleaning up Docker resources...$(RESET)"
+	@docker system prune -f
+	@echo "$(GREEN)Cleanup completed$(RESET)"
+
+demo: image ## Run a demo with provided sample files
+	@echo "$(GREEN)Running UFPAlign demo...$(RESET)"
+	@cp temp_ufpalign/demo/ex.wav audio_input/ 2>/dev/null || true
+	@cp temp_ufpalign/demo/ex.txt text_input/ 2>/dev/null || true
+	@docker run --rm \
+		--name ufpalign-demo \
+		-v $(PWD)/audio_input:/opt/UFPAlign/audio_input:ro \
+		-v $(PWD)/text_input:/opt/UFPAlign/text_input:ro \
+		-v $(PWD)/output:/opt/UFPAlign/output:rw \
+		-v $(PWD)/textgrid:/opt/UFPAlign/textgrid:rw \
+		$(IMAGE_NAME):latest \
+		bash -c "cd /opt/UFPAlign && KALDI_ROOT=/opt/kaldi bash ufpalign.sh audio_input/ex.wav text_input/ex.txt mono"
+	@echo "$(GREEN)Demo completed. Check output/ and textgrid/ directories$(RESET)"
+
+shell: image ## Get a shell in the UFPAlign container
+	@echo "$(GREEN)Opening shell in UFPAlign container...$(RESET)"
+	@docker run -it --rm \
+		--name ufpalign-shell \
+		-v $(PWD)/audio_input:/opt/UFPAlign/audio_input:ro \
+		-v $(PWD)/text_input:/opt/UFPAlign/text_input:ro \
+		-v $(PWD)/output:/opt/UFPAlign/output:rw \
+		-v $(PWD)/textgrid:/opt/UFPAlign/textgrid:rw \
+		$(IMAGE_NAME):latest bash
+
+install-models: image ## Download and install UFPAlign models
+	@echo "$(GREEN)Installing UFPAlign models...$(RESET)"
+	@docker run --rm \
+		--name ufpalign-install-models \
+		-v $(PWD)/models:/opt/UFPAlign/models:rw \
+		$(IMAGE_NAME):latest \
+		bash -c "cd /opt/UFPAlign && \
+		utils/download_model.sh data /opt/UFPAlign && \
+		utils/download_model.sh mono /opt/UFPAlign && \
+		utils/download_model.sh tri1 /opt/UFPAlign && \
+		utils/download_model.sh tri2b /opt/UFPAlign && \
+		utils/download_model.sh tri3b /opt/UFPAlign && \
+		utils/download_model.sh tdnn /opt/UFPAlign && \
+		utils/download_model.sh ie /opt/UFPAlign"
+	@echo "$(GREEN)Models installed successfully$(RESET)" 

README.ufpalign.md

@@ -0,0 +1,290 @@
+# UFPAlign Docker Implementation
+
+This repository provides a comprehensive Docker implementation of [UFPAlign](https://github.com/falabrasil/ufpalign) - a free tool for forced phonetic alignment in Brazilian Portuguese developed by the FalaBrasil group at UFPA.
+
+## Overview
+
+UFPAlign is a forced phonetic alignment system specifically designed for Brazilian Portuguese that uses the Kaldi toolkit. This Docker implementation makes it easy to run UFPAlign without complex local installations.
+
+### Features
+
+- **Complete UFPAlign Environment**: Pre-configured with Kaldi, Python dependencies, and Brazilian Portuguese locale
+- **Multiple Usage Modes**: Interactive shell, API service, and batch processing
+- **Volume Mapping**: Easy access to input/output files on your host system
+- **Model Management**: Automated downloading and installation of acoustic models
+- **Docker Compose Support**: Easy multi-container deployment
+
+## Quick Start
+
+### Prerequisites
+
+- Docker (version 20.10+)
+- Docker Compose (version 1.29+)
+- At least 4GB of available disk space
+
+### 1. Clone and Build
+
+```bash
+# Clone this repository or download the Docker files
+git clone <your-repo-url>
+cd <your-repo-directory>
+
+# Build the UFPAlign Docker image
+make -f Makefile.ufpalign image
+```
+
+### 2. Run a Demo
+
+```bash
+# Run the demo with sample files from UFPAlign repository
+make -f Makefile.ufpalign demo
+```
+
+This will:
+- Copy sample audio and text files to the appropriate directories
+- Run UFPAlign alignment using the monophone model
+- Output results to `output/` and `textgrid/` directories
+
+## Usage Methods
+
+### 1. Interactive Shell
+
+Get a shell inside the UFPAlign container for manual operations:
+
+```bash
+make -f Makefile.ufpalign run-interactive
+```
+
+Inside the container, you can run:
+```bash
+# Basic alignment command
+KALDI_ROOT=/opt/kaldi bash ufpalign.sh audio_input/your_audio.wav text_input/your_text.txt mono
+
+# Available acoustic models: mono, tri1, tri2b, tri3b, tdnn
+KALDI_ROOT=/opt/kaldi bash ufpalign.sh audio_input/your_audio.wav text_input/your_text.txt tdnn
+```
+
+### 2. API Service
+
+Run UFPAlign as a web API service:
+
+```bash
+make -f Makefile.ufpalign run-api
+```
+
+The API will be available at `http://localhost:7860`
+
+### 3. Docker Compose (Recommended)
+
+Use Docker Compose for a complete setup:
+
+```bash
+# Start all services
+make -f Makefile.ufpalign compose-up
+
+# View logs
+make -f Makefile.ufpalign compose-logs
+
+# Stop services
+make -f Makefile.ufpalign compose-down
+```
+
+## Directory Structure
+
+The Docker setup creates and uses the following local directories:
+
+```
+your-project/
+├── audio_input/          # Place your .wav files here (read-only in container)
+├── text_input/           # Place your .txt transcription files here (read-only)
+├── output/               # UFPAlign processing outputs (read-write)
+├── textgrid/            # Generated TextGrid files (read-write)
+├── logs/                # Processing logs (read-write)
+└── models/              # Downloaded acoustic models (optional)
+```
+
+## Acoustic Models
+
+UFPAlign supports several acoustic model architectures:
+
+- **mono**: Monophone model (fastest, basic alignment)
+- **tri1**: First triphone model
+- **tri2b**: Second triphone model with feature transforms
+- **tri3b**: Third triphone model with speaker adaptation
+- **tdnn**: Time Delay Neural Network (best quality, requires more resources)
+
+### Installing Models
+
+```bash
+# Download and install all models (requires significant time and bandwidth)
+make -f Makefile.ufpalign install-models
+```
+
+Models are automatically downloaded on first use if not present.
+
+## File Formats
+
+### Input Files
+
+1. **Audio Files** (`audio_input/`):
+   - Format: WAV (16-bit, mono recommended)
+   - Sample rate: 16kHz recommended (UFPAlign can handle others)
+   - Example: `audio_input/my_recording.wav`
+
+2. **Text Files** (`text_input/`):
+   - Format: Plain text with orthographic transcription
+   - Encoding: UTF-8
+   - Content: Brazilian Portuguese text matching the audio
+   - Example: `text_input/my_recording.txt`
+
+### Output Files
+
+1. **TextGrid Files** (`textgrid/`):
+   - Praat-compatible TextGrid format
+   - Multiple tiers: phonemes, syllables, words, phonetic transcription, orthographic transcription
+
+2. **Processing Outputs** (`output/`):
+   - CTM (Conversation Time Mark) files
+   - Intermediate processing files
+   - Alignment statistics
+
+## Makefile Commands
+
+The included Makefile provides convenient commands for managing the Docker setup:
+
+```bash
+# Get help with all available commands
+make -f Makefile.ufpalign help
+
+# Build the image
+make -f Makefile.ufpalign image
+
+# Run demo
+make -f Makefile.ufpalign demo
+
+# Interactive shell
+make -f Makefile.ufpalign shell
+
+# API service
+make -f Makefile.ufpalign run-api
+
+# Docker Compose operations
+make -f Makefile.ufpalign compose-up
+make -f Makefile.ufpalign compose-down
+make -f Makefile.ufpalign compose-logs
+
+# Cleanup
+make -f Makefile.ufpalign clean
+```
+
+## API Usage
+
+When running in API mode, you can interact with UFPAlign through HTTP requests:
+
+```bash
+# Example: Upload audio and text for alignment
+curl -X POST "http://localhost:7860/align" \
+  -F "audio=@your_audio.wav" \
+  -F "text=@your_text.txt" \
+  -F "model=mono"
+```
+
+## Performance Considerations
+
+### Resource Requirements
+
+- **RAM**: Minimum 2GB, recommended 4GB+
+- **CPU**: Multi-core recommended for faster processing
+- **Storage**: 2-4GB for base image + models
+- **Network**: Required for initial model downloads
+
+### Model Performance vs Speed
+
+- **mono**: Fastest, basic accuracy
+- **tri1, tri2b, tri3b**: Progressive improvement in accuracy
+- **tdnn**: Best accuracy, requires most resources and time
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Permission Errors**:
+   ```bash
+   # Ensure proper permissions on directories
+   chmod -R 755 audio_input text_input output textgrid logs
+   ```
+
+2. **Model Download Failures**:
+   ```bash
+   # Manually install models
+   make -f Makefile.ufpalign install-models
+   ```
+
+3. **Memory Issues**:
+   - Use smaller models (mono instead of tdnn)
+   - Increase Docker memory allocation
+   - Process smaller audio files
+
+4. **Audio Format Issues**:
+   ```bash
+   # Convert audio to supported format using sox
+   sox input.mp3 -r 16000 -c 1 output.wav
+   ```
+
+### Debug Mode
+
+Run with debug output:
+
+```bash
+docker run -it --rm \
+  -v $(PWD)/audio_input:/opt/UFPAlign/audio_input:ro \
+  -v $(PWD)/text_input:/opt/UFPAlign/text_input:ro \
+  -v $(PWD)/output:/opt/UFPAlign/output:rw \
+  -v $(PWD)/textgrid:/opt/UFPAlign/textgrid:rw \
+  ufpalign:latest \
+  bash -c "set -x && cd /opt/UFPAlign && KALDI_ROOT=/opt/kaldi bash ufpalign.sh audio_input/your_file.wav text_input/your_file.txt mono"
+```
+
+## Citation
+
+If you use UFPAlign in your research, please cite:
+
+```bibtex
+@article{Batista22a,
+    author     = {Batista, Cassio and Dias, Ana Larissa and Neto, Nelson},
+    title      = {Free resources for forced phonetic alignment in Brazilian Portuguese based on Kaldi toolkit},
+    journal    = {EURASIP Journal on Advances in Signal Processing},
+    year       = {2022},
+    month      = {Feb},
+    day        = {19},
+    volume     = {2022},
+    number     = {1},
+    pages      = {11},
+    issn       = {1687-6180},
+    doi        = {10.1186/s13634-022-00844-9},
+    url        = {https://doi.org/10.1186/s13634-022-00844-9}
+}
+```
+
+## License
+
+This Docker implementation follows the same MIT license as the original UFPAlign project.
+
+## Support
+
+- **Original UFPAlign**: [GitHub Repository](https://github.com/falabrasil/ufpalign)
+- **FalaBrasil Group**: [Website](https://ufpafalabrasil.gitlab.io/)
+- **Docker Issues**: Create an issue in this repository
+
+## Contributing
+
+1. Fork this repository
+2. Create a feature branch
+3. Make your changes
+4. Test with the provided demo
+5. Submit a pull request
+
+---
+
+**Grupo FalaBrasil (2024)** - https://ufpafalabrasil.gitlab.io/  
+**Universidade Federal do Pará (UFPA)** - https://portal.ufpa.br/ 

docker-compose.ufpalign.yml

@@ -0,0 +1,54 @@
+version: '3.8'
+
+services:
+  ufpalign:
+    build:
+      context: .
+      dockerfile: Dockerfile.ufpalign
+    image: ufpalign:latest
+    container_name: ufpalign-container
+    environment:
+      - KALDI_ROOT=/opt/kaldi
+      - UFPALIGN_DIR=/opt/UFPAlign
+      - LC_ALL=pt_BR.UTF-8
+      - LANG=pt_BR.UTF-8
+    volumes:
+      # Map local directories to container
+      - ./audio_input:/opt/UFPAlign/audio_input:ro
+      - ./text_input:/opt/UFPAlign/text_input:ro
+      - ./output:/opt/UFPAlign/output:rw
+      - ./textgrid:/opt/UFPAlign/textgrid:rw
+      - ./logs:/root/logs:rw
+    ports:
+      - "7860:7860"
+    working_dir: /opt/UFPAlign
+    stdin_open: true
+    tty: true
+    restart: unless-stopped
+    command: /bin/bash
+    
+  ufpalign-api:
+    build:
+      context: .
+      dockerfile: Dockerfile.ufpalign
+    image: ufpalign:latest
+    container_name: ufpalign-api-container
+    environment:
+      - KALDI_ROOT=/opt/kaldi
+      - UFPALIGN_DIR=/opt/UFPAlign
+      - LC_ALL=pt_BR.UTF-8
+      - LANG=pt_BR.UTF-8
+    volumes:
+      - ./audio_input:/opt/UFPAlign/audio_input:ro
+      - ./text_input:/opt/UFPAlign/text_input:ro
+      - ./output:/opt/UFPAlign/output:rw
+      - ./textgrid:/opt/UFPAlign/textgrid:rw
+      - ./logs:/root/logs:rw
+      - ./app.py:/opt/UFPAlign/app.py:ro
+    ports:
+      - "7861:7860"
+    working_dir: /opt/UFPAlign
+    restart: unless-stopped
+    command: uvicorn app:app --host 0.0.0.0 --port 7860
+    depends_on:
+      - ufpalign