This repository provides a professional-grade Docker container for the "Bark" GitHub repository. It utilizes FastAPI to create a robust API endpoint that receives prompts as requests and passes them on to the Bark repository for efficient processing. The API then returns the processed results as responses, enabling seamless integration with Bark functionalities. This Docker container enables you to effortlessly deploy and utilize a fully-functional API for Bark.
The main objective is to utilize the suno-ai/bark repository, a cutting-edge text-to-audio transformer model. This repository includes both a user interface (UI) and API endpoints, allowing us to fully utilize the capabilities of the model. By integrating the API into our organization's products, we can enhance our offerings with high-quality text-to-audio functionality.
To facilitate easy deployment, I have also written a Dockerfile, enabling us to host the model within a container on our server. This ensures efficient and scalable usage of the model. Additionally, the UI I have created provides a user-friendly interface to interact with the model through the appropriate API endpoints.
Furthermore, the model can be further improved by training and developing it with our own voice data. This customization allows us to tailor the output to match our specific requirements and create a unique audio experience.
Overall, the suno-ai/bark repository offers a powerful text-to-audio transformer model, along with the necessary components for easy integration and customization within our organization's products.
Follow these steps to install and set up the Bark-Docker:
-
Clone this repository:
git clone https://github.com/your-username/bark-docker.git
-
Install the required dependencies:
pip install -r requirements.txt
-
Install Bark from the official repository. You can either clone it or install it directly using the following command:
pip install git+https://github.com/suno-ai/bark.git
-
Specify the location for preloading trained models by setting the
XDG_CACHE_HOME
environment variable. You can choose your preferred location. For example, to set it to a subdirectory namedcache
, use the following command:export XDG_CACHE_HOME=cache/
Note: By default, the models are saved locally in the Users/Home/... directory. The code will efficiently utilize available GPUs for processing.
-
To use the trained models, you can either preload them or download them manually:
-
Preload the models using the following Python code snippet:
from bark import SAMPLE_RATE, generate_audio, preload_models # Download and load all models preload_models()
-
Download the models manually from https://huggingface.co/suno/bark/tree/main and move them to your
XDG_CACHE_HOME/suno/bark_v0
directory.
-
-
Once the models are preloaded, run the following command to start the API:
uvicorn main:app --reload
The API I created supports asynchronous processing, allowing concurrent users to effectively utilize its capabilities. The API behaves as a job queue, enabling efficient handling of multiple requests.
To submit a request, send a POST request to http://127.0.0.1:8000/audio
with the following JSON format:
Note: Only the prompt
field is required; others are optional.
curl --location 'http://127.0.0.1:8000/audio' \
--header 'Content-Type: application/json' \
--data '{
"prompt": "Mass",
"text_temp":0.7,
"waveform_temp":0.7,
"output_full":"False"
}'
The response will contain a job ID and its status:
{
"job_id": "ExNg544vfj3MzbTp4wGkdnQGgOUlYo",
"status": "pending",
"track_your_job": "/audio/ExNg544vfj3MzbTp4wGkdnQGgOUlYo"
}
To track the status of a job, send a GET request to /audio/{job_id}
or click on the track_your_job
link from the above response:
curl --location 'http://127.0.0.1:8000/audio/ExNg544vfj3MzbTp4wGkdnQGgOUlYo'
The response will be like below until the job is completed.
{
"job_id": "ExNg544vfj3MzbTp4wGkdnQGgOUlYo",
"status": "pending",
"audio_url": null
}
Once the job is complete, the response will contain the audio URL:
{
"job_id": "ExNg544vfj3MzbTp4wGkdnQGgOUlYo",
"status": "completed",
"audio_url": "/audio_files/ExNg544vfj3MzbTp4wGkdnQGgOUlYo.wav"
}
Click on the audio_url
to listen to the generated audio.
Note: If you are running the API on a different location, replace http://127.0.0.1:8000
with the appropriate host and port.
To optimize the Docker image, two Dockerfiles are provided:
Dockerfile1:
# Stage 1: Build dependencies and clone repository
FROM python:3.9-slim as builder
RUN apt-get update \
&& apt-get install -y --no-install-recommends git \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir -r requirements.txt \
&& pip install git+https://github.com/suno-ai/bark.git
# Copy the necessary files
COPY cache /app/cache
COPY main.py /app/main.py
COPY audio_files /app/audio_files
# Stage 2: Final image
FROM python:3.9-slim
WORKDIR /app
COPY --from=builder /app /app
# Set environment variables
ENV XDG_CACHE_HOME=cache/
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
in the above Dockerfile, consists of two stages: "builder" and "final image."
Reduced image size: By using multiple stages, you can discard unnecessary dependencies and files from the final image. The builder stage installs the required dependencies but is not included in the final image, resulting in a smaller image size.
Dockerfile2:
# Use a smaller base image
FROM python:3.9-alpine
# Install git and other dependencies
RUN apk --no-cache add git
# Set the working directory
WORKDIR /app
# Copy the necessary files
COPY cache /app/cache
COPY main.py /app/main.py
COPY audio_files /app/audio_files
COPY requirements.txt /app/requirements.txt
# Install dependencies
RUN --mount=type=cache,target=/root/.cache \
pip install --no-cache-dir -r requirements.txt \
&& pip install git+https://github.com/suno-ai/bark.git
# Set environment variables
ENV XDG_CACHE_HOME=cache/
EXPOSE 8000
# Set production mode environment variable
ENV PYTHONBUFFERED=1
# Run the application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
To build the optimized Docker image, execute the following command:
docker build -t myapp:latest .
To run the Docker container and expose the API on port 8000, execute the following command:
docker run -p 8000:8000 myapp:latest
Once the container is running, you can use the Bark API as described above.