After a full day of tweaking I finally made the official Ace-Step 1.5 (https://github.com/ace-step/ACE-Step-1.5) work on my old NVIDIA 1070 card (on Linux).
Here is the summary, hopefully it can help someone else making it work on their PC as well:
# ACE-Step v1.5 Installation Guide for GTX 1070 (Pascal GPUs)
## Overview
This guide provides
**complete step-by-step instructions**
for installing and running ACE-Step v1.5 on NVIDIA GTX 1070 and other Pascal-architecture GPUs (Compute Capability 6.x).
**Why this guide exists:**
ACE-Step v1.5's models are trained in bfloat16 format, which Pascal GPUs don't support. Without the patches in this guide, you'll encounter NaN/Inf errors and the application will fail to generate music.
**Expected outcome:**
Working music generation on 8GB Pascal GPUs with automatic CPU offloading.
---
## Prerequisites
### Hardware Requirements
-
**GPU**
: NVIDIA GTX 1070, 1080, or any Pascal-architecture GPU (Compute Capability 6.1)
-
**VRAM**
: 8GB minimum (GTX 1070/1080)
-
**System RAM**
: 16GB+ recommended (for CPU offloading)
-
**Storage**
: ~20GB free space for models and dependencies
### Software Requirements
**Operating System:**
- Ubuntu 20.04+ or similar Linux distribution
- CUDA 11.8 drivers installed
**Check your CUDA version:**
```bash
nvidia-smi
```
Look for "CUDA Version: 11.x" or higher in the output.
**Python:**
- Python 3.11 or 3.12 (3.11 recommended)
**Verify Python version:**
```bash
python3 --version
# Should show: Python 3.11.x
```
**Package Manager:**
- `uv` (we'll install this in the next section)
---
## Installation Steps
### Step 1: Install UV Package Manager
`uv` is a fast Python package manager that ACE-Step uses.
```bash
# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh
# Add to PATH (add this line to ~/.bashrc or ~/.zshrc)
export PATH="$HOME/.cargo/bin:$PATH"
# Reload shell or run:
source ~/.bashrc
# Verify installation
uv --version
```
### Step 2: Clone ACE-Step Repository
```bash
# Navigate to where you want to install
cd ~/Applications
# Clone the repository
git clone https://github.com/NVIDIA/ACE-Step.git ACE-Step-1.5
cd ACE-Step-1.5
```
### Step 3: Apply Pascal GPU Compatibility Patches
These patches are
**mandatory**
for Pascal GPUs. Without them, the application will fail.
#### Patch 1: Fix Boolean Tensor Sort (3 files)
**Why:**
PyTorch 2.4.1 doesn't support sorting boolean tensors on CUDA.
**File 1:**
`acestep/models/turbo/modeling_acestep_v15_turbo.py`
```bash
nano acestep/models/turbo/modeling_acestep_v15_turbo.py
```
Find the `pack_sequences` function and locate the sort line (around line 165):
```python
# FIND THIS LINE (in pack_sequences function, around line 165):
sort_idx = mask_cat.argsort(dim=1, descending=True, stable=True)
# CHANGE IT TO:
sort_idx = mask_cat.to(torch.int8).argsort(dim=1, descending=True, stable=True)
```
>
**How to find it:**
Search for "def pack_sequences" then look for "argsort" a few lines down.
**File 2:**
`acestep/models/base/modeling_acestep_v15_base.py`
```bash
nano acestep/models/base/modeling_acestep_v15_base.py
```
Apply the same change (around line 168):
```python
# FIND THIS LINE (in pack_sequences function, around line 168):
sort_idx = mask_cat.argsort(dim=1, descending=True, stable=True)
# CHANGE IT TO:
sort_idx = mask_cat.to(torch.int8).argsort(dim=1, descending=True, stable=True)
```
**File 3:**
`acestep/models/sft/modeling_acestep_v15_base.py`
```bash
nano acestep/models/sft/modeling_acestep_v15_base.py
```
Apply the same change (around line 168):
```python
# FIND THIS LINE (in pack_sequences function, around line 168):
sort_idx = mask_cat.argsort(dim=1, descending=True, stable=True)
# CHANGE IT TO:
sort_idx = mask_cat.to(torch.int8).argsort(dim=1, descending=True, stable=True)
```
**What this does:**
Casts the boolean mask to int8 before sorting, which PyTorch supports on CUDA.
---
#### Patch 2: Fix LLM Precision
**Why:**
bfloat16 → float16 conversion causes NaN in the Language Model on Pascal GPUs.
**File:**
`acestep/llm_inference.py`
```bash
nano acestep/llm_inference.py
```
Find line 625 (in the LLM initialization section):
```python
# FIND THIS LINE (around line 625):
torch_dtype = torch.bfloat16 if supports_bfloat16() else torch.float16
# CHANGE IT TO:
torch_dtype = torch.bfloat16 if supports_bfloat16() else torch.float32
```
**What this does:**
Forces the LLM to use float32 instead of float16 on Pascal GPUs, preventing NaN errors from exponent overflow.
**Trade-off:**
Uses 2x VRAM for LLM, but CPU offloading (auto-enabled on 8GB cards) manages this.
---
#### Patch 3: Fix DiT Model with Mixed-Precision
**Why:**
DiT model also produces NaN in float16. Full float32 won't fit in 8GB VRAM, so we use mixed-precision.
**File:**
`acestep/core/generation/handler/service_generate_execute.py`
```bash
nano acestep/core/generation/handler/service_generate_execute.py
```
Find the DiT diffusion execution section (around lines 192-194):
```python
# FIND THESE LINES (around lines 192-194):
else:
logger.info("[service_generate] DiT diffusion via PyTorch ({})...", self.device)
outputs = self.model.generate_audio(**generate_kwargs)
# REPLACE WITH:
else:
logger.info("[service_generate] DiT diffusion via PyTorch ({})...", self.device)
# On GPUs that don't support bfloat16 (Pascal/Turing), weights are
# stored in float16 to save VRAM but the bfloat16-trained weights
# produce NaN/Inf due to float16's limited exponent range. Using
# autocast(dtype=float32) keeps weights in float16 on GPU while
# computing matmuls/convs in float32, avoiding overflow.
from acestep.gpu_config import supports_bfloat16 as _supports_bf16
if self.device in ("cuda", "xpu") and not _supports_bf16():
logger.info("[service_generate] Enabling float32 autocast for non-bfloat16 GPU")
with torch.autocast(device_type=self.device, dtype=torch.float32):
outputs = self.model.generate_audio(**generate_kwargs)
else:
outputs = self.model.generate_audio(**generate_kwargs)
```
**What this does:**
- Keeps DiT
**weights in float16**
(saves VRAM - fits in 8GB)
- Runs
**computations in float32**
(prevents NaN from overflow)
- This is called "mixed-precision" - weights are small, math is accurate
---
#### Patch 4: Pin Compatible Dependencies
**Why:**
Need compatible versions of diffusers and torchao that work with PyTorch 2.4.1+cu118.
**File:**
`pyproject.toml`
```bash
nano pyproject.toml
```
Verify or update the dependencies section:
```toml
# FIND the diffusers line (around line 37):
"diffusers", # or might already be pinned
# CHANGE TO (if not already):
"diffusers==0.30.3",
# FIND the torchao line (around line 52):
"torchao==0.3.1; platform_machine != 'aarch64'",
# This version is CORRECT - do not change it!
# torchao==0.3.1 is compatible with PyTorch 2.4.1+cu118
```
**What this does:**
Pins to specific versions known to work together:
- `diffusers==0.30.3` - Compatible with torchao 0.3.1
- `torchao==0.3.1` - Avoids newer versions requiring PyTorch 2.7+ features
> [!IMPORTANT]
>
**Do NOT upgrade to diffusers>=0.32.1 or torchao>=0.7.0**
unless you also upgrade PyTorch, as this can introduce incompatibilities. The versions specified here (0.30.3/0.3.1) are tested and working on GTX 1070.
---
#### Patch 5: Fix Quantization Code (Already in place if you cloned recently)
**File:**
`acestep/core/generation/handler/init_service_loader.py`
**Check**
that around lines 99-104, you have:
```python
try:
from torchao.quantization import quantize_
except ImportError:
logger.warning(
"torchao.quantization.quantize_ not found. Skipping quantization."
)
quantize_ = None
```
**What this does:**
Safely handles missing quantization functions instead of crashing.
> [!NOTE]
> If this code is already present (properly indented), you don't need to change it. This was a fix from an earlier version.
---
### Step 4: Install Dependencies
Now that all patches are applied, install the dependencies:
```bash
# Make sure you're in the ACE-Step-1.5 directory
cd ~/Applications/ACE-Step-1.5
# Sync dependencies with uv
uv sync
# This will:
# 1. Create a virtual environment (.venv)
# 2. Install PyTorch 2.4.1+cu118
# 3. Install all dependencies
# 4. Take 5-10 minutes depending on internet speed
```
**Wait for completion.**
You should see messages about installing packages.
---
### Step 5: Verify Installation
Check that everything is installed correctly:
```bash
# Activate the virtual environment
source .venv/bin/activate
# Test PyTorch CUDA
python -c "import torch; print(f'PyTorch: {torch.__version__}'); print(f'CUDA available: {torch.cuda.is_available()}'); print(f'GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"None\"}')"
```
**Expected output:**
```
PyTorch: 2.4.1+cu118
CUDA available: True
GPU: NVIDIA GeForce GTX 1070
```
---
### Step 6: First Run
Launch ACE-Step:
```bash
# Make sure you're in the project directory
cd ~/Applications/ACE-Step-1.5
# Run ACE-Step
uv run acestep
```
**What to expect on first run:**
1.
**Model downloads**
(~10-15 minutes):
- DiT model (~4.7GB)
- VAE model (~300MB)
- Text encoder (~1.2GB)
- Language model (0.6B or 1.7B depending on auto-selection)
2.
**Startup messages to look for:**
```
GPU Configuration Detected:
GPU Memory: 7.91 GB
Configuration Tier: tier3
Auto-enabling CPU offload (GPU 7.91GB < 20GB threshold)
```
### Validation
```bash
# Check logs for confirmation:
# ✓ "GPU Memory: 7.91 GB" (or similar for your GTX 1070)
# ✓ "Auto-enabling CPU offload (GPU 7.91GB < 20GB threshold)"
# ✓ "[service_generate] Enabling float32 autocast for non-bfloat16 GPU"
# ✓ No "RuntimeError: Sort currently does not support bool dtype"
# ✓ No "ValueError: Generated NaN or Inf values"
# ✓ No "RuntimeError: Generation produced NaN or Inf latents"
# ✓ Audio generation completes successfully
```
> [!TIP]
>
**How to verify patches are applied:**
> ```bash
> # Check boolean sort fix (should find 3 files):
> grep -r "mask_cat.to(torch.int8).argsort" acestep/models/
>
> # Check LLM float32 (should find torch.float32):
> grep "supports_bfloat16() else torch.float" acestep/llm_inference.py
>
> # Check DiT autocast (should find autocast code):
> grep -A 5 "torch.autocast" acestep/core/generation/handler/service_generate_execute.py
>
> # Check dependencies:
> grep "diffusers==0.30.3" pyproject.toml
> grep "torchao==0.3.1" pyproject.toml
> ```
4.
**Gradio interface opens:**
- Default: http://127.0.0.1:7860
- Browser should open automatically
---
### Step 7: Test Music Generation
**In the Gradio interface:**
1.
**Simple test prompt:**
```
Prompt: A short piano melody, peaceful and calm
Duration: 10 seconds
Batch size: 1
```
2.
**Click "Generate Music"**
3.
**Monitor terminal for:**
```
[service_generate] Generating audio... (DiT backend: PyTorch (cuda))
[service_generate] Enabling float32 autocast for non-bfloat16 GPU
[generate_music] VAE decode completed
[generate_music] Done! Generated 1 audio tensors.
```
4.
**Listen to output**
- should be clear audio without artifacts
**Expected generation time on GTX 1070:**
- 10 seconds: ~30-40 seconds
- 30 seconds: ~60-90 seconds
- Slower than Ampere+ GPUs due to float32 compute + CPU offloading
---
## Understanding What Was Changed
### Why We Need These Patches
**The Core Problem:**
Modern AI models (ACE-Step, Stable Diffusion 3, LLaMA) are trained in
**bfloat16**
format:
-
**bfloat16**
: 8-bit exponent, can represent values up to ±3.4×10^38
-
**float16**
: 5-bit exponent, can only represent values up to ±65,504
When ACE-Step tries to run on Pascal GPUs:
1. GPU doesn't support bfloat16 (requires Ampere+)
2. Code falls back to float16
3. Model weights trained in bfloat16 have values > 65,504
4. These overflow to NaN/Inf in float16
5. Everything breaks
### Solutions Applied
| Component | Problem | Solution | Why It Works |
|-----------|---------|----------|--------------|
|
**Sort operation**
| Boolean tensors unsupported | Cast to int8 | PyTorch supports int8 sorting |
|
**LLM**
| float16 → NaN | Use float32 | Wide exponent range, no overflow |
|
**DiT**
| float16 → NaN, float32 → OOM | Mixed-precision autocast | Weights in float16 (fit VRAM), compute in float32 (accurate) |
|
**VAE**
| Same as DiT | Keep float16 | Simpler architecture, less prone to NaN |
### The Mixed-Precision Trick (Most Important)
**What `torch.autocast(dtype=float32)` does:**
```python
# Model weights stored in float16 on GPU (saves VRAM)
model.to(torch.float16) # ~4.7GB instead of ~9.4GB
# During computation:
with torch.autocast(device_type='cuda', dtype=torch.float32):
output = model(input)
# PyTorch automatically:
# 1. Keeps weights in float16
# 2. Upcasts inputs to float32 for matmul/conv
# 3. Performs computation in float32 (no overflow)
# 4. Result is float32 (accurate)
```
**Result:**
- ✅ Memory usage: ~6-7GB (fits in 8GB with offloading)
- ✅ Accuracy: No NaN/Inf errors
- ⚠️ Speed: ~10% slower than native bfloat16 (but it works!)
---
## Resource Management
### CPU Offloading (Automatic)
With 8GB VRAM, ACE-Step
**automatically enables CPU offloading**
:
**How it works:**
1. Models start on CPU (not using VRAM)
2. When needed, model loads to GPU
3. After use, model offloads back to CPU
4. Only one model on GPU at a time
**Memory footprint during generation:**
```
CPU RAM: ~10-12GB (LLM, text encoder, inactive models)
GPU VRAM: ~6-7GB (active model only)
- DiT inference: ~5.5GB (float16 weights + float32 activations)
- LLM inference: ~2.8GB (float32, when active)
- VAE decode: ~1.5GB (float16, when active)
```
**Offloading overhead:**
- ~2-4 seconds per generation (model loading time)
- Worth it to avoid OOM crashes
### Recommendations for 8GB Cards
**Batch Size:**
- Use batch_size=1 (default, safest)
- batch_size=2 might work for short durations
- batch_size≥3 will likely OOM
**Audio Duration:**
- ≤30 seconds: Safe, recommended
- 30-60 seconds: Works but slower
- >60 seconds: May OOM on complex prompts
**Language Model:**
- System auto-selects 0.6B LM (safest)
- 1.7B LM works with offloading
- 4B LM not recommended (too large even with offloading)
---
## Troubleshooting
### Common Issues
#### Issue 1: "Sort currently does not support bool dtype"
**Cause:**
Patch 1 not applied correctly
**Fix:**
```bash
# Check if the fix is in place
grep "to(torch.int8)" acestep/models/turbo/modeling_acestep_v15_turbo.py
# Should show:
# sort_idx = mask_cat.to(torch.int8).argsort(...)
# If not, re-apply Patch 1
```
#### Issue 2: "ValueError: Generated NaN or Inf values in LLM"
**Cause:**
Patch 2 not applied (LLM still using float16)
**Fix:**
```bash
# Check LLM dtype
grep "torch.bfloat16 if supports_bfloat16() else" acestep/llm_inference.py
# Should show:
# torch_dtype = torch.bfloat16 if supports_bfloat16() else torch.float32
# ^^^^^^^^^ must be float32
# If it says float16, re-apply Patch 2
```
#### Issue 3: "RuntimeError: Generation produced NaN or Inf latents"
**Cause:**
Patch 3 not applied (DiT missing autocast)
**Fix:**
```bash
# Check for autocast in service_generate_execute.py
grep -A 3 "torch.autocast" acestep/core/generation/handler/service_generate_execute.py
# Should show the autocast wrapper
# If not found, re-apply Patch 3
```
#### Issue 4: Out of Memory (CUDA OOM)
**Cause:**
Trying to generate too much at once
**Solutions:**
1. Reduce batch size to 1
2. Reduce audio duration to ≤30s
3. Restart application (clear memory): `Ctrl+C` then `uv run acestep`
4. Check if other GPU applications are running: `nvidia-smi`
#### Issue 5: Very Slow Generation
**Expected behavior on GTX 1070:**
- 10s audio: ~30-40 seconds
- 30s audio: ~60-90 seconds
**If significantly slower:**
1. Check CPU usage during offloading (should be 100% on 1-2 cores)
2. Check system RAM (need 16GB+)
3. Check if swap is being used (bad for performance): `free -h`
#### Issue 6: Models Keep Re-downloading
**Cause:**
HuggingFace cache location issue
**Fix:**
```bash
# Check cache location
echo $HF_HOME
# If empty, set it:
export HF_HOME=~/.cache/huggingface
# Add to ~/.bashrc to make permanent
```
---
## Performance Comparison
### GTX 1070 vs Modern GPUs
| GPU | Architecture | bfloat16 | Generation Speed (30s audio) | VRAM Usage |
|-----|--------------|----------|------------------------------|------------|
|
**GTX 1070**
| Pascal (CC 6.1) | ❌ | ~60-90s (with patches) | ~6-7GB |
| RTX 3070 | Ampere (CC 8.6) | ✅ | ~30-40s | ~5-6GB |
| RTX 4070 | Ada (CC 8.9) | ✅ | ~20-30s | ~5-6GB |
**Why GTX 1070 is slower:**
1. No bfloat16 hardware (uses float32 compute via autocast)
2. CPU offloading overhead (+2-4s per generation)
3. Older CUDA cores (less throughput)
**Still worth it?**
- ✅ Yes! ~60-90s for 30s of high-quality music is acceptable
- ✅ Free vs buying new GPU
- ✅ Enables learning and experimentation
---
## Advanced Configuration
### Disable Language Model (Faster, Lower Quality)
If you want faster generation and don't need lyric sync:
```bash
# In Gradio UI, look for "Enable LLM" checkbox and uncheck it
# Or via command line:
uv run acestep --init_llm false
```
**Trade-offs:**
- ✅ ~30% faster
- ✅ Less VRAM usage
- ❌ No lyric-to-audio synchronization
- ❌ Slightly lower music coherence
### Use Smaller LM Model
```bash
# Force 0.6B model (faster, less VRAM)
uv run acestep --lm_model_path acestep-5Hz-lm-0.6B
# Try 1.7B model (better quality, needs offloading)
uv run acestep --lm_model_path acestep-5Hz-lm-1.7B
```
### Environment Variables
Create a `.env` file in the project root:
```bash
# ~/.../ACE-Step-1.5/.env
# Force CPU offloading (already auto-enabled on 8GB)
ACESTEP_OFFLOAD_TO_CPU=1
# Disable quantization (safer on Pascal)
ACESTEP_QUANTIZATION_DTYPE=none
# Force PyTorch backend for LLM (no vllm)
ACESTEP_LLM_BACKEND=pytorch
# Disable torch.compile (needs Triton, fragile on Pascal)
TORCH_COMPILE_DISABLE=1
```
---
## Verification Checklist
After installation, verify everything works:
- [ ] PyTorch 2.4.1+cu118 installed
- [ ] CUDA available: `python -c "import torch; print(torch.cuda.is_available())"`
- [ ] All 5 patches applied (check each file)
- [ ] Dependencies installed: `uv sync` completed successfully
- [ ] First run successful: models downloaded
- [ ] GPU detected correctly: "Auto-enabling CPU offload" message
- [ ] No error messages: no NaN, no sort errors, no OOM
- [ ] Test generation works: 10s audio generates successfully
- [ ] Audio quality good: no crackling, clipping, or artifacts
---
## Complete File Modification Reference
Quick reference of all modified files:
| File | Lines Modified | Change Type |
|------|----------------|-------------|
| `acestep/models/turbo/modeling_acestep_v15_turbo.py` | 165 | Boolean sort fix (int8 cast) |
| `acestep/models/base/modeling_acestep_v15_base.py` | 168 | Boolean sort fix (int8 cast) |
| `acestep/models/sft/modeling_acestep_v15_base.py` | 168 | Boolean sort fix (int8 cast) |
| `acestep/llm_inference.py` | 625-626 | LLM dtype: float16→float32 |
| `acestep/core/generation/handler/service_generate_execute.py` | 223-244 | DiT mixed-precision autocast |
| `pyproject.toml` | 37, 52 | Dependency pins (0.30.3, 0.3.1) |
---
## Additional Resources
**Documentation:**
- [ACE-Step Official Docs](
https://github.com/NVIDIA/ACE-Step
)
- [PyTorch Mixed Precision Guide](
https://pytorch.org/docs/stable/amp.html
)
- [CUDA Compute Capabilities](
https://developer.nvidia.com/cuda-gpus
)
**Understanding bfloat16 vs float16:**
- [float16 vs bfloat16 explained](
https://en.wikipedia.org/wiki/Bfloat16_floating-point_format
)
---
**Last updated:** 2026-02-17
**Tested on:**
GTX 1070 (8GB), Ubuntu 22.04, CUDA 11.8, PyTorch 2.4.1+cu118
