Installing HairFastGAN on Your Computer

Now that you understand what HairFastGAN is and how it works, it’s time to set it up on your own computer. Although the project is designed primarily for developers and AI enthusiasts, the installation process is straightforward if you already have some experience with Python and Git.

Before you begin, make sure your system meets the recommended requirements.

Software Requirements

You’ll need the following software installed:

• Python 3.10 or later
• Git
• pip (Python package manager)
• A virtual environment tool (recommended)
• NVIDIA GPU with CUDA (optional but highly recommended)

Using a virtual environment helps avoid conflicts with other Python projects by keeping dependencies isolated.

Step 1: Clone the HairFastGAN Repository

The first step is downloading the project files from the official GitHub repository.

Open your terminal or Command Prompt and run:

git clone https://github.com/AIRI-Institute/HairFastGAN
cd HairFastGAN

This downloads the latest version of HairFastGAN and changes your working directory to the project folder.

Step 2: Create a Virtual Environment

Although optional, creating a virtual environment is considered a best practice.

On Windows:

python -m venv venv
venv\Scripts\activate

On macOS and Linux:

python3 -m venv venv
source venv/bin/activate

Once activated, any Python packages you install will remain inside this project instead of affecting your global Python installation.

Step 3: Install Required Dependencies

HairFastGAN relies on several open-source libraries for image processing, face alignment, and machine learning.

Install them using:

pip install pillow face_alignment dill addict fpie git+https://github.com/openai/CLIP.git

Depending on your internet connection, this may take several minutes.

Some systems may require additional libraries depending on the installed version of PyTorch or CUDA.

Step 4: Prepare the Input Images

HairFastGAN typically works with three images:

• Target Image – the person whose hairstyle you want to change.
• Shape Reference – provides the hairstyle shape.
• Color Reference – provides the hair color.

This flexible setup allows you to mix hairstyles and colors from different reference photos.

For example:

• Person A → Face
• Person B → Hairstyle
• Person C → Hair Color

The AI combines these elements into a realistic final image.

Step 5: Load the AI Model

Once everything is installed, you can initialize the HairFastGAN model in Python.

from hair_swap import HairFast, get_parser

model_args = get_parser()
hair_fast = HairFast(model_args.parse_args([]))

This code prepares the AI model for inference and loads the necessary configurations.

The first launch may take a little longer because model weights need to be loaded into memory.

Step 6: Load Your Images

Next, specify the image paths.

from pathlib import Path
import torchvision.transforms as T

input_dir = Path("/HairFastGAN/input")

face_path = input_dir / "6.png"
shape_path = input_dir / "7.png"
color_path = input_dir / "8.png"

Here:

• face_path is the original face.
• shape_path controls the hairstyle.
• color_path controls the hair color.

Using separate references gives you greater creative flexibility.

Step 7: Generate the New Hairstyle

Now you’re ready to perform the hairstyle transfer.

final_image = hair_fast.swap(
    face_path,
    shape_path,
    color_path
)

The model processes the images and generates a new hairstyle while preserving the facial identity.

To preview the result:

T.functional.to_pil_image(final_image).resize((512,512))

Within moments, you’ll see your transformed hairstyle.

Understanding the Workflow

Behind the scenes, HairFastGAN performs several AI operations automatically.

Face Detection

The model first detects the face and identifies important landmarks such as:

• Eyes
• Nose
• Mouth
• Jawline
• Hairline

These landmarks help align the hairstyle naturally.

Hair Segmentation

Next, HairFastGAN separates the hair region from the rest of the image.

This segmentation step allows the model to modify only the hairstyle while leaving facial features untouched.

Style Transfer

The hairstyle’s:

• Shape
• Texture
• Volume
• Color

are transferred from the reference image.

Rather than copying pixels, HairFastGAN recreates the hairstyle using learned visual representations.

Final Refinement

The AI performs additional corrections for:

• Lighting
• Hair edges
• Texture consistency
• Facial harmony

This refinement stage contributes to more realistic outputs.

CPU vs GPU Performance

One of the most common questions is whether HairFastGAN can run without a dedicated graphics card.

The answer is yes—but performance differs significantly.

Running on a CPU

Advantages:

• No dedicated GPU required.
• Compatible with most modern computers.
• Suitable for learning and experimentation.

Disadvantages:

• Slower image generation.
• Longer model loading times.
• Reduced responsiveness.

For occasional testing, a CPU is perfectly acceptable.

Running on a GPU

A CUDA-compatible NVIDIA GPU offers a much smoother experience.

Benefits include:

• Faster processing.
• Near real-time results.
• Better handling of larger images.
• Improved workflow efficiency.

If you’re planning to process many images or build a production application, a GPU is highly recommended.

Recommended Hardware

Although HairFastGAN can run on modest systems, stronger hardware provides better performance.

Budget Configuration

• Intel Core i7 or AMD Ryzen 7
• 16 GB RAM
• NVIDIA RTX 3060

This setup is suitable for students, hobbyists, and developers learning AI.

Mid-Range Configuration

• Intel Core i9 or AMD Ryzen 9
• 32 GB RAM
• NVIDIA RTX 3080

This offers significantly faster processing and smoother experimentation.

High-End Workstation

• AMD Ryzen 9 or Intel Core i9
• 64 GB RAM
• NVIDIA RTX 4090

Ideal for research, commercial applications, and high-resolution image generation.

Tips for Better Results

To achieve the most realistic hairstyle transformations, keep these best practices in mind.

Use High-Quality Photos

Clear, high-resolution images generally produce better outputs.

Avoid blurry or heavily compressed photos.

Face the Camera

Front-facing images with minimal head tilt are easier for the AI to process accurately.

Good Lighting Matters

Even lighting reduces shadows and helps HairFastGAN detect facial features more accurately.

Natural daylight often works best.

Choose Similar Angles

The reference hairstyle should have a viewing angle similar to the target image.

Large differences in perspective may reduce realism.

Avoid Obstructions

Hair accessories, hats, hands, or sunglasses can interfere with face detection and hair segmentation.

For best results, use unobstructed photos.

Common Installation Problems

Even experienced developers occasionally encounter setup issues.

Here are some common problems and possible solutions.

Dependency Errors

Make sure you’re using the recommended Python version and install packages inside a clean virtual environment.

CUDA Not Detected

Verify that:

• Your NVIDIA drivers are up to date.
• CUDA is installed correctly.
• Your PyTorch version supports your CUDA installation.

Model Loading Issues

If the model fails to load:

• Confirm all required files are downloaded.
• Check directory paths.
• Ensure sufficient RAM or GPU memory is available.

Slow Processing

If generation feels slow:

• Close unnecessary applications.
• Use smaller test images.
• Enable GPU acceleration if available.