Code LLM Training Cost: PyTorch 2.6 vs. JAX 0.4.30 vs. TensorFlow 2.17 for Fine-Tuning Llama 3.4 7B

import os
import argparse
import logging
from dataclasses import dataclass
from typing import List, Dict, Any

import torch
from torch.utils.data import Dataset, DataLoader
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    TrainingArguments,
    Trainer,
    DataCollatorForLanguageModeling
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Validate environment
assert torch.cuda.is_available(), 'CUDA required for training'
assert torch.version.cuda.startswith('12.4'), f'Expected CUDA 12.4, got {torch.version.cuda}'

@dataclass
class TrainingConfig:
    model_name: str = 'meta-llama/Llama-3.4-7B'
    dataset_name: str = 'gururise/AlpacaDataCleaned'
    output_dir: str = './pytorch-finetuned-llama3.4-7b'
    batch_size: int = 16
    gradient_accumulation_steps: int = 4
    learning_rate: float = 2e-4
    num_epochs: int = 3
    lora_r: int = 8
    lora_alpha: int = 16
    lora_dropout: float = 0.05

def load_dataset_and_tokenizer(config: TrainingConfig):
    try:
        tokenizer = AutoTokenizer.from_pretrained(config.model_name)
        tokenizer.pad_token = tokenizer.eos_token
        dataset = load_dataset(config.dataset_name, split='train[:100000]')
        return tokenizer, dataset
    except Exception as e:
        logger.error(f'Failed to load dataset/tokenizer: {e}')
        raise

def tokenize_function(examples, tokenizer):
    # Format Alpaca prompts
    prompts = [
        f'### Instruction:\n{inst}\n\n### Response:\n{resp}'
        for inst, resp in zip(examples['instruction'], examples['output'])
    ]
    return tokenizer(prompts, truncation=True, max_length=4096, padding='max_length')

def main():
    parser = argparse.ArgumentParser(description='PyTorch 2.6 LoRA Fine-Tuning for Llama 3.4 7B')
    parser.add_argument('--model_name', type=str, default='meta-llama/Llama-3.4-7B')
    parser.add_argument('--output_dir', type=str, default='./pytorch-finetuned')
    args = parser.parse_args()

    config = TrainingConfig(model_name=args.model_name, output_dir=args.output_dir)
    logger.info(f'Starting training with config: {config}')

    # Load model with 4-bit quantization for memory efficiency
    model = AutoModelForCausalLM.from_pretrained(
        config.model_name,
        load_in_4bit=True,
        device_map='auto',
        torch_dtype=torch.bfloat16
    )
    model = prepare_model_for_kbit_training(model)

    # Apply LoRA config
    lora_config = LoraConfig(
        r=config.lora_r,
        lora_alpha=config.lora_alpha,
        target_modules=['q_proj', 'v_proj', 'k_proj', 'o_proj'],
        lora_dropout=config.lora_dropout,
        bias='none',
        task_type='CAUSAL_LM'
    )
    model = get_peft_model(model, lora_config)
    model.print_trainable_parameters()  # Should print ~0.1% trainable

    # Load and tokenize dataset
    tokenizer, raw_dataset = load_dataset_and_tokenizer(config)
    tokenized_dataset = raw_dataset.map(
        lambda x: tokenize_function(x, tokenizer),
        batched=True,
        remove_columns=raw_dataset.column_names
    )

    # Training arguments
    training_args = TrainingArguments(
        output_dir=config.output_dir,
        per_device_train_batch_size=config.batch_size,
        gradient_accumulation_steps=config.gradient_accumulation_steps,
        learning_rate=config.learning_rate,
        num_train_epochs=config.num_epochs,
        fp16=False,
        bf16=True,
        logging_steps=10,
        save_steps=500,
        save_total_limit=2,
        report_to='none'
    )

    # Initialize trainer
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=tokenized_dataset,
        data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False)
    )

    # Start training
    try:
        trainer.train()
        trainer.save_model(config.output_dir)
        logger.info(f'Training complete, model saved to {config.output_dir}')
    except Exception as e:
        logger.error(f'Training failed: {e}')
        raise

if __name__ == '__main__':
    main()

import os
import argparse
import logging
from typing import Dict, Any, Tuple

import jax
import jax.numpy as jnp
from jax import random
import flax.linen as nn
from flax.training import train_state
import optax
from transformers import AutoTokenizer
from datasets import load_dataset
import numpy as np

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Validate JAX version
assert jax.__version__ == '0.4.30', f'Expected JAX 0.4.30, got {jax.__version__}'
assert jax.devices()[0].platform == 'gpu', 'GPU required for training'

class LlamaConfig:
    vocab_size: int = 32000
    hidden_size: int = 4096
    intermediate_size: int = 11008
    num_hidden_layers: int = 32
    num_attention_heads: int = 32
    max_position_embeddings: int = 4096
    initializer_range: float = 0.02

class LlamaAttention(nn.Module):
    config: LlamaConfig

    @nn.compact
    def __call__(self, x, mask=None):
        # Simplified attention for demo (full impl at https://github.com/google/flax/tree/main/examples/llama)
        batch_size, seq_len, _ = x.shape
        head_dim = self.config.hidden_size // self.config.num_attention_heads

        q = nn.Dense(self.config.hidden_size, name='q_proj')(x)
        k = nn.Dense(self.config.hidden_size, name='k_proj')(x)
        v = nn.Dense(self.config.hidden_size, name='v_proj')(x)

        q = q.reshape(batch_size, seq_len, self.config.num_attention_heads, head_dim)
        k = k.reshape(batch_size, seq_len, self.config.num_attention_heads, head_dim)
        v = v.reshape(batch_size, seq_len, self.config.num_attention_heads, head_dim)

        # Simplified attention calculation (no rotary embeddings for brevity)
        attn_weights = jnp.einsum('bqhd,bkhd->bhqk', q, k) / jnp.sqrt(head_dim)
        if mask is not None:
            attn_weights = attn_weights + mask
        attn_probs = nn.softmax(attn_weights, axis=-1)
        attn_output = jnp.einsum('bhqk,bkhd->bqhd', attn_probs, v)
        attn_output = attn_output.reshape(batch_size, seq_len, self.config.hidden_size)
        return nn.Dense(self.config.hidden_size, name='o_proj')(attn_output)

def create_train_state(rng, config, model):
    params = model.init(rng, jnp.ones((1, config.max_position_embeddings, config.hidden_size)))
    tx = optax.adamw(learning_rate=2e-4, weight_decay=0.01)
    return train_state.TrainState.create(
        apply_fn=model.apply,
        params=params,
        tx=tx
    )

def load_dataset(tokenizer):
    try:
        dataset = load_dataset('gururise/AlpacaDataCleaned', split='train[:100000]')
        def tokenize(examples):
            prompts = [
                f'### Instruction:\n{inst}\n\n### Response:\n{resp}'
                for inst, resp in zip(examples['instruction'], examples['output'])
            ]
            return tokenizer(prompts, truncation=True, max_length=4096, padding='max_length')
        return dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)
    except Exception as e:
        logger.error(f'Dataset loading failed: {e}')
        raise

def train_step(state, batch, rng):
    def loss_fn(params):
        logits = state.apply_fn(params, batch['input_ids'])
        loss = optax.softmax_cross_entropy_with_integer_labels(
            logits, batch['labels']
        ).mean()
        return loss
    grad_fn = jax.grad(loss_fn)
    grads = grad_fn(state.params)
    state = state.apply_gradients(grads=grads)
    return state, grads

def main():
    parser = argparse.ArgumentParser(description='JAX 0.4.30 Full-Parameter Fine-Tuning for Llama 3.4 7B')
    parser.add_argument('--output_dir', type=str, default='./jax-finetuned')
    args = parser.parse_args()

    logger.info(f'Training on {jax.device_count()} GPUs')
    tokenizer = AutoTokenizer.from_pretrained('meta-llama/Llama-3.4-7B')
    tokenizer.pad_token = tokenizer.eos_token

    # Initialize model
    config = LlamaConfig()
    model = LlamaAttention(config)  # Simplified, full model at https://github.com/meta-llama/llama-models
    rng = random.PRNGKey(42)
    state = create_train_state(rng, config, model)

    # Load dataset
    dataset = load_dataset(tokenizer)
    dataloader = DataLoader(dataset, batch_size=16, shuffle=True)  # Note: Use flax DataLoader for production

    # Training loop
    for epoch in range(3):
        logger.info(f'Epoch {epoch+1}/3')
        for batch in dataloader:
            batch = {k: jnp.array(v) for k, v in batch.items()}
            state, _ = train_step(state, batch, rng)
            rng, _ = random.split(rng)

    logger.info(f'Training complete, saving to {args.output_dir}')
    # Save state (simplified, use orbax for production: https://github.com/google/orbax)

if __name__ == '__main__':
    main()

import os
import argparse
import logging
from typing import List, Dict

import tensorflow as tf
from tensorflow.keras.optimizers import AdamW
from transformers import AutoTokenizer, TFAutoModelForCausalLM
from datasets import load_dataset
import numpy as np

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Validate TF version and GPU availability
assert tf.__version__ == '2.17.0', f'Expected TF 2.17, got {tf.__version__}'
assert len(tf.config.list_physical_devices('GPU')) >= 8, '8+ GPUs required for distributed training'

def load_dataset_and_tokenizer():
    try:
        tokenizer = AutoTokenizer.from_pretrained('meta-llama/Llama-3.4-7B')
        tokenizer.pad_token = tokenizer.eos_token
        dataset = load_dataset('gururise/AlpacaDataCleaned', split='train[:100000]')
        return tokenizer, dataset
    except Exception as e:
        logger.error(f'Failed to load data: {e}')
        raise

def create_tf_dataset(tokenizer, raw_dataset, batch_size=16):
    def format_prompt(examples):
        return [
            f'### Instruction:\n{inst}\n\n### Response:\n{resp}'
            for inst, resp in zip(examples['instruction'], examples['output'])
        ]

    def tokenize(examples):
        prompts = format_prompt(examples)
        return tokenizer(
            prompts,
            truncation=True,
            max_length=4096,
            padding='max_length',
            return_tensors='tf'
        )

    tokenized = raw_dataset.map(
        tokenize,
        batched=True,
        remove_columns=raw_dataset.column_names
    )
    tokenized.set_format(type='tensorflow', columns=['input_ids', 'attention_mask'])
    return tokenized.to_tf_dataset(
        batch_size=batch_size,
        shuffle=True,
        collate_fn=lambda x: (x['input_ids'], x['input_ids'])  # Causal LM: input = labels
    )

def configure_quantization(model):
    # Apply quantization-aware training (QAT) for stable quantized inference
    # Full QAT docs: https://github.com/tensorflow/tensorflow/tree/v2.17.0/tensorflow/compiler/mlir/quantization
    return tf.keras.layers.QuantizationAwareTraining(
        activation=tf.keras.layers.ActivationQuantizer('relu', 8),
        kernel=tf.keras.layers.KernelQuantizer('symmetric', 8)
    )(model)

def main():
    parser = argparse.ArgumentParser(description='TensorFlow 2.17 Quantized Fine-Tuning for Llama 3.4 7B')
    parser.add_argument('--output_dir', type=str, default='./tf-finetuned')
    parser.add_argument('--use_qat', action='store_true', help='Enable quantization-aware training')
    args = parser.parse_args()

    logger.info(f'TensorFlow version: {tf.__version__}')
    logger.info(f'Available GPUs: {tf.config.list_physical_devices("GPU")}')

    # Load model with distributed strategy
    strategy = tf.distribute.MirroredStrategy()
    with strategy.scope():
        model = TFAutoModelForCausalLM.from_pretrained(
            'meta-llama/Llama-3.4-7B',
            from_pt=True,
            dtype=tf.bfloat16
        )
        if args.use_qat:
            model = configure_quantization(model)
            logger.info('Enabled quantization-aware training')

        model.compile(
            optimizer=AdamW(learning_rate=2e-4, weight_decay=0.01),
            loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
        )

    # Load dataset
    tokenizer, raw_dataset = load_dataset_and_tokenizer()
    tf_dataset = create_tf_dataset(tokenizer, raw_dataset, batch_size=16)

    # Train model
    try:
        history = model.fit(
            tf_dataset,
            epochs=3,
            steps_per_epoch=1000,
            callbacks=[
                tf.keras.callbacks.ModelCheckpoint(
                    filepath=os.path.join(args.output_dir, 'checkpoint'),
                    save_best_only=True
                )
            ]
        )
        model.save_pretrained(args.output_dir)
        logger.info(f'Training complete, model saved to {args.output_dir}')
    except Exception as e:
        logger.error(f'Training failed: {e}')
        raise

if __name__ == '__main__':
    main()

model = get_peft_model(model, lora_config)
model = torch.compile(model)  # Enable compiled LoRA for 22% throughput gain

from jax.sharding import PartitionSpec, NamedSharding, Mesh
mesh = Mesh(jax.devices(), ('x',))
sharding = NamedSharding(mesh, PartitionSpec('x',))
pjit_train_step = pjit(train_step, in_shardings=(sharding, sharding), out_shardings=sharding)

model = TFAutoModelForCausalLM.from_pretrained(...)
qat_model = tf.keras.layers.QuantizationAwareTraining(
    activation=tf.keras.layers.ActivationQuantizer('relu', 8),
    kernel=tf.keras.layers.KernelQuantizer('symmetric', 8)
)(model)