In this guide, we will go through the step-by-step process of installing, configuring, and running Whisper AI for live transcription on a Linux system.

What is Whisper AI?

Whisper AI is an open-source speech recognition model trained on a vast dataset of audio recordings and it is based on a deep-learning architecture that enables it to:

• Transcribe speech in multiple languages.
• Handle accents and background noise efficiently.
• Perform translation of spoken language into English.

Since it is designed for high-accuracy transcription, it is widely used in:

• Live transcription services (e.g., for accessibility).
• Voice assistants and automation.
• Transcribing recorded audio files.

By default, Whisper AI is not optimized for real-time processing. However, with some additional tools, it can process live audio streams for immediate transcription.

Whisper AI System Requirements

Before running Whisper AI on Linux, ensure your system meets the following requirements:

Hardware Requirements:

• CPU: A multi-core processor (Intel/AMD).
• RAM: At least 8GB (16GB or more is recommended).
• GPU: NVIDIA GPU with CUDA (optional but speeds up processing significantly).
• Storage: Minimum 10GB of free disk space for models and dependencies.

Software Requirements:

• A Linux distribution such as Ubuntu, Debian, Arch, Fedora, etc.
• Python version 3.8 or later.
• Pip package manager for installing Python packages.
• FFmpeg for handling audio files and streams.

Step 1: Installing Required Dependencies

Before installing Whisper AI, update your package list and upgrade existing packages.

sudo apt update     [On Ubuntu]
sudo dnf update -y  [On Fedora]
sudo pacman -Syu    [On Arch]

Next, you need to install Python 3.8 or higher and Pip package manager as shown.

sudo apt install python3 python3-pip python3-venv -y             [On Ubuntu]
sudo dnf install python3 python3-pip python3-virtualenv -y       [On Fedora]
sudo pacman -S python python-pip python-virtualenv               [On Arch] 

Lastly, you need to install FFmpeg, which is a multimedia framework used to process audio and video files.

sudo apt install ffmpeg     [On Ubuntu]
sudo dnf install ffmpeg     [On Fedora]
sudo pacman -S ffmpeg       [On Arch]

Step 2: Install Whisper AI in Linux

Once the required dependencies are installed, you can proceed to install Whisper AI in a virtual environment that allows you to install Python packages without affecting system packages.

python3 -m venv whisper_env
source whisper_env/bin/activate
pip install openai-whisper

Once the installation is complete, check if Whisper AI was installed correctly by running.

whisper --help

This should display a help menu with available commands and options, which means Whisper AI is installed and ready to use.

Step 3: Running Whisper AI in Linux

Once Whisper AI is installed, you can start transcribing audio files using different commands.

Transcribing an Audio File

To transcribe an audio file (audio.mp3), run:

whisper audio.mp3

Whisper will process the file and generate a transcript in text format.

Now that everything is installed, let’s create a Python script to capture audio from your microphone and transcribe it in real time.

nano real_time_transcription.py

Copy and paste the following code into the file.

import sounddevice as sd
import numpy as np
import whisper
import queue
import threading

# Load the Whisper model
model = whisper.load_model("base")

# Audio parameters
SAMPLE_RATE = 16000
BUFFER_SIZE = 1024
audio_queue = queue.Queue()

def audio_callback(indata, frames, time, status):
    """Callback function to capture audio data."""
    if status:
        print(status)
    audio_queue.put(indata.copy())

def transcribe_audio():
    """Thread to transcribe audio in real time."""
    while True:
        audio_data = audio_queue.get()
        audio_data = np.concatenate(list(audio_queue.queue))  # Combine buffered audio
        audio_queue.queue.clear()

        # Transcribe the audio
        result = model.transcribe(audio_data.flatten(), language="en")
        print(f"Transcription: {result['text']}")

# Start the transcription thread
transcription_thread = threading.Thread(target=transcribe_audio, daemon=True)
transcription_thread.start()

# Start capturing audio from the microphone
with sd.InputStream(callback=audio_callback, channels=1, samplerate=SAMPLE_RATE, blocksize=BUFFER_SIZE):
    print("Listening... Press Ctrl+C to stop.")
    try:
        while True:
            pass
    except KeyboardInterrupt:
        print("nStopping...")

Execute the script using Python, which will start listening to your microphone input and display the transcribed text in real time. Speak clearly into your microphone, and you should see the results printed on the terminal.

python3 real_time_transcription.py

Conclusion

Whisper AI is a powerful speech-to-text tool that can be adapted for real-time transcription on Linux. For best results, use a GPU and optimize your system for real-time processing.

The post Running Whisper AI for Real-Time Speech-to-Text on Linux appeared first on MASSIVE News.

Artificial Intelligence (AI) is rapidly transforming industries, from healthcare and finance to creative fields like art and music. Linux, with its open-source nature, customizability, and performance, has become a leading platform for AI development.

This article explores essential Linux tools for AI development, catering to both beginners and experienced developers.

Why Linux for AI Development?

Linux’s popularity in AI stems from several key advantages:

• Open-Source Nature: Allows for modification and customization, crucial for the iterative nature of AI development.
• Stability and Performance: Handles demanding workloads and complex model training efficiently.
• Strong Community Support: A vast and active community provides ample resources and troubleshooting assistance.
• Compatibility with AI Frameworks: Optimized for major frameworks like TensorFlow and PyTorch.
• Command-Line Interface: Offers powerful and efficient control over system resources.

Essential Linux Tools for AI Development

To make it easier to navigate, we’ve grouped the tools into categories based on their primary use cases.

1. Deep Learning Frameworks

These frameworks are the backbone of AI development, enabling you to build, train, and deploy machine learning models.

TensorFlow

Developed by Google, TensorFlow is a powerful framework for building and training machine learning models, particularly deep learning. Its versatility makes it suitable for research and production deployments.

Keras, a high-level API, simplifies model building, while TensorFlow Extended (TFX) supports production-level deployments.

To install TensorFlow on Linux, use pip package manager.

pip install tensorflow

PyTorch

Developed by Facebook’s AI Research lab (FAIR), PyTorch is favored by researchers for its dynamic computation graphs, which offer flexibility in model experimentation and debugging. TorchScript enables model optimization for production.

To install PyTorch on Linux, run:

pip install torch

2. Data Science and Machine Learning

These tools are essential for data preprocessing, analysis, and traditional machine learning tasks.

Scikit-learn

Scikit-learn is a comprehensive library for various machine learning algorithms, including classification, regression, clustering, and dimensionality reduction. It’s an excellent tool for both beginners and experienced practitioners.

To install Scikit-learn on Linux, run:

pip install scikit-learn

XGBoost/LightGBM/CatBoost

These gradient boosting libraries are known for their performance and accuracy, which are widely used in machine learning competitions and real-world applications.

To install XGBoost/LightGBM/CatBoost on Linux, run:

pip install xgboost lightgbm catboost

3. Development Environment and Workflow

These tools help you write, test, and debug your code efficiently.

Jupyter Notebooks/Lab

Jupyter provides an interactive environment for coding, data visualization, and documentation, making it ideal for exploring data and prototyping models.

To install Jupyter on Linux, run:

pip install jupyterlab  
or 
pip install notebook

Integrated Development Environments (IDEs)

Popular IDEs like VS Code (with Python extensions) or PyCharm offer features like code completion, debugging, and version control integration.

These are excellent IDEs for managing large AI projects.

4. Containerization and Deployment

These tools help you package and deploy AI applications efficiently.

Docker

Docker simplifies packaging AI applications and their dependencies into containers, ensuring consistent execution across different environments, which is essential for portability and deployment.

To install Docker on Linux, run:

sudo apt install docker.io

Kubernetes

Kubernetes is a powerful container orchestration platform for managing and scaling containerized AI applications, which is crucial for deploying models in production at scale.

To install Kubernetes on Linux, run:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Kubeflow

Kubeflow streamlines machine learning workflows on Kubernetes, from data preprocessing to model training and deployment.

To install Kubeflow on Linux, run:

kubectl apply -k "github.com/kubeflow/pipelines/manifests/kustomize/cluster-scoped-resources?ref=<version>"

5. Data Processing and Big Data

These tools are essential for handling large datasets and distributed computing.

Apache Spark

Apache Spark is a powerful distributed computing framework that’s widely used for big data processing and machine learning in AI development. Its MLlib library provides scalable algorithms.

To install Spark on Linux, run:

wget https://downloads.apache.org/spark/spark-3.5.4/spark-3.5.4-bin-hadoop3.tgz
tar -xvf spark-3.5.4-bin-hadoop3.tgz
sudo mv spark-3.5.4-bin-hadoop3 /opt/spark
echo -e "export SPARK_HOME=/opt/sparknexport PATH=$PATH:$SPARK_HOME/bin" >> ~/.bashrc && source ~/.bashrc
spark-shell
pip install pyspark

6. Computer Vision

These tools are essential for AI projects involving image and video processing.

OpenCV

OpenCV (Open Source Computer Vision Library) is a must-have tool for AI developers working on computer vision projects, as it offers a wide range of functions for image and video processing, making it easier to build applications like facial recognition, object detection, and more.

To install OpenCV on Linux, run:

pip install opencv-python

7. Other Important Tools

These tools enhance productivity and streamline the AI development lifecycle.

Anaconda/Miniconda

Anaconda (or its lighter version, Miniconda) simplifies Python and R package management, especially for data science and AI. It provides a convenient way to manage dependencies and create isolated environments.

To install Anaconda on Linux, run:

wget https://repo.anaconda.com/archive/Anaconda3-2024.10-1-Linux-x86_64.sh
bash Anaconda3-2024.10-1-Linux-x86_64.sh

Hugging Face Transformers

Hugging Face has revolutionized natural language processing (NLP) with its Transformers library that provides access to pre-trained transformer models for NLP tasks, simplifying tasks like text generation, translation, and sentiment analysis.

To install Hugging Face Transformers on Linux, run:

pip install transformers

MLflow

MLflow is an open-source platform for managing the machine learning lifecycle, including experiment tracking, model packaging, and deployment.

To install MLflow on Linux, run:

pip install transformers

If you’re interested in diving deeper into AI development on Linux, check out these related articles:

• AI for Linux Users – Discover how Linux users can leverage AI tools and frameworks to enhance productivity and solve real-world problems.
• Setting Up Linux for AI Development – A step-by-step guide to configuring your Linux environment for AI development, including essential tools and libraries.
• Run DeepSeek Locally on Linux – Learn how to set up and run DeepSeek, a powerful AI tool, on your Linux machine for local development and experimentation.

These articles will help you get the most out of your Linux system for AI development, whether you’re a beginner or an experienced developer.

Conclusion

The AI landscape is constantly evolving, and Linux provides a robust and versatile platform for developers. By mastering these essential tools, developers can effectively build, train, and deploy AI models, staying at the forefront of this exciting field.

Remember to consult the official documentation for each tool for the most up-to-date information and installation instructions.

The post Best Linux Tools for AI Development in 2025 appeared first on MASSIVE News.

In this guide, we’ll walk you through installing DeepSeek using Ollama on Ubuntu 24.04 and setting up a Web UI for an interactive and user-friendly experience.

What is DeepSeek and Ollama?

• DeepSeek: An advanced AI model designed for natural language processing tasks like answering questions, generating text, and more. .
• Ollama: A platform that simplifies running large language models locally by providing tools to manage and interact with models like DeepSeek.
• Web UI: A graphical interface that allows you to interact with DeepSeek through your browser, making it more accessible and user-friendly.

Prerequisites

Before we begin, make sure you have the following:

• Ubuntu 24.04 installed on your machine.
• A stable internet connection.
• At least 8GB of RAM (16GB or more is recommended for smoother performance).
• Basic familiarity with the terminal.

Step 1: Install Python and Git

Before installing anything, it’s a good idea to update your system to ensure all existing packages are up to date.

sudo apt update && sudo apt upgrade -y

Ubuntu likely comes with Python pre-installed, but it’s important to ensure you have the correct version (Python 3.8 or higher).

sudo apt install python3
python3 --version

pip is the package manager for Python, and it’s required to install dependencies for DeepSeek and Ollama.

sudo apt install python3-pip
pip3 --version

Git is essential for cloning repositories from GitHub.

sudo apt install git
git --version

Step 2: Install Ollama for DeepSeek

Now that Python and Git are installed, you’re ready to install Ollama to manage DeepSeek.

curl -fsSL https://ollama.com/install.sh | sh
ollama --version

Next, start and enable Ollama to start automatically when your system boots.

sudo systemctl start ollama
sudo systemctl enable ollama

Now that Ollama is installed, we can proceed with installing DeepSeek.

Step 3: Download and Run DeepSeek Model

Now that Ollama is installed, you can download the DeepSeek model.

ollama run deepseek-r1:7b

This may take a few minutes depending on your internet speed, as the model is several gigabytes in size.

Once the download is complete, you can verify that the model is available by running:

ollama list

You should see deepseek listed as one of the available models.

Step 4: Run DeepSeek in a Web UI

While Ollama allows you to interact with DeepSeek via the command line, you might prefer a more user-friendly web interface. For this, we’ll use Ollama Web UI, a simple web-based interface for interacting with Ollama models.

First, create a virtual environment that isolates your Python dependencies from the system-wide Python installation.

sudo apt install python3-venv
python3 -m venv ~/open-webui-venv
source ~/open-webui-venv/bin/activate

Now that your virtual environment is active, you can install Open WebUI using pip.

pip install open-webui

Once installed, start the server using.

open-webui serve

Open your web browser and navigate to http://localhost:8080 – you should see the Ollama Web UI interface.

In the Web UI, select the deepseek model from the dropdown menu and start interacting with it. You can ask questions, generate text, or perform other tasks supported by DeepSeek.

You should now see a chat interface where you can interact with DeepSeek just like ChatGPT.

Conclusion

You’ve successfully installed Ollama and DeepSeek on Ubuntu 24.04. You can now run DeepSeek in the terminal or use a Web UI for a better experience.

The post How to Install DeepSeek Locally with Ollama LLM in Ubuntu 24.04 appeared first on MASSIVE News.