Struct GPTModel

pub struct GPTModel<F: Float + Debug + ScalarOperand + Send + Sync> { /* private fields */ }

GPT model implementation

Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync> GPTModel<F>

pub fn new(config: GPTConfig) -> Result<Self>

Create a new GPT model

Examples found in repository

examples/gpt_example.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("GPT Model Example");

    // Create a small GPT model for demonstration
    println!("Creating a small GPT model...");

    let config = GPTConfig::custom(
        10000, // vocab_size
        128,   // hidden_size
        2,     // num_hidden_layers
        2,     // num_attention_heads
    );

    let model = GPTModel::<f32>::new(config)?;

    // Create dummy input (batch_size=2, seq_len=16)
    // Input tensor contains token IDs
    let input = Array::from_shape_fn(
        IxDyn(&[2, 16]),
        |_| rand::random::<f32>() * 100.0, // Random token IDs between 0 and 100
    );

    println!("Input shape: {:?}", input.shape());

    // Forward pass to get hidden states
    let hidden_states = model.forward(&input)?;

    println!("Hidden states shape: {:?}", hidden_states.shape());

    // Calculate logits for next-token prediction
    let logits = model.logits(&input)?;

    println!("Logits shape: {:?}", logits.shape());
    println!("Vocabulary size: {}", logits.shape()[2]);

    // Let's create a GPT-2 Small model
    println!("\nCreating a GPT-2 Small model...");

    let gpt2_small = GPTModel::<f32>::gpt2_small()?;

    // Create dummy input for a longer sequence
    let small_input = Array::from_shape_fn(
        IxDyn(&[1, 32]),
        |_| rand::random::<f32>() * 1000.0, // Random token IDs
    );

    println!("GPT-2 Small input shape: {:?}", small_input.shape());

    // Forward pass
    let small_hidden_states = gpt2_small.forward(&small_input)?;

    println!(
        "GPT-2 Small hidden states shape: {:?}",
        small_hidden_states.shape()
    );
    println!(
        "GPT-2 Small hidden dimension: {}",
        small_hidden_states.shape()[2]
    );

    // For text generation (logits for next token prediction)
    let small_logits = gpt2_small.logits(&small_input)?;
    println!("GPT-2 Small logits shape: {:?}", small_logits.shape());
    println!("GPT-2 Small vocabulary size: {}", small_logits.shape()[2]);

    println!("\nGPT example completed successfully!");

    Ok(())
}

pub fn gpt2_small() -> Result<Self>

Create a GPT-2 Small model

Examples found in repository

examples/gpt_example.rs (line 43)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("GPT Model Example");

    // Create a small GPT model for demonstration
    println!("Creating a small GPT model...");

    let config = GPTConfig::custom(
        10000, // vocab_size
        128,   // hidden_size
        2,     // num_hidden_layers
        2,     // num_attention_heads
    );

    let model = GPTModel::<f32>::new(config)?;

    // Create dummy input (batch_size=2, seq_len=16)
    // Input tensor contains token IDs
    let input = Array::from_shape_fn(
        IxDyn(&[2, 16]),
        |_| rand::random::<f32>() * 100.0, // Random token IDs between 0 and 100
    );

    println!("Input shape: {:?}", input.shape());

    // Forward pass to get hidden states
    let hidden_states = model.forward(&input)?;

    println!("Hidden states shape: {:?}", hidden_states.shape());

    // Calculate logits for next-token prediction
    let logits = model.logits(&input)?;

    println!("Logits shape: {:?}", logits.shape());
    println!("Vocabulary size: {}", logits.shape()[2]);

    // Let's create a GPT-2 Small model
    println!("\nCreating a GPT-2 Small model...");

    let gpt2_small = GPTModel::<f32>::gpt2_small()?;

    // Create dummy input for a longer sequence
    let small_input = Array::from_shape_fn(
        IxDyn(&[1, 32]),
        |_| rand::random::<f32>() * 1000.0, // Random token IDs
    );

    println!("GPT-2 Small input shape: {:?}", small_input.shape());

    // Forward pass
    let small_hidden_states = gpt2_small.forward(&small_input)?;

    println!(
        "GPT-2 Small hidden states shape: {:?}",
        small_hidden_states.shape()
    );
    println!(
        "GPT-2 Small hidden dimension: {}",
        small_hidden_states.shape()[2]
    );

    // For text generation (logits for next token prediction)
    let small_logits = gpt2_small.logits(&small_input)?;
    println!("GPT-2 Small logits shape: {:?}", small_logits.shape());
    println!("GPT-2 Small vocabulary size: {}", small_logits.shape()[2]);

    println!("\nGPT example completed successfully!");

    Ok(())
}

pub fn gpt2_medium() -> Result<Self>

Create a GPT-2 Medium model

pub fn gpt2_large() -> Result<Self>

Create a GPT-2 Large model

pub fn custom( vocab_size: usize, hidden_size: usize, num_hidden_layers: usize, num_attention_heads: usize, ) -> Result<Self>

Create a custom GPT model

pub fn logits(&self, input: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Calculate logits (prediction scores) for next tokens

Examples found in repository

examples/gpt_example.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("GPT Model Example");

    // Create a small GPT model for demonstration
    println!("Creating a small GPT model...");

    let config = GPTConfig::custom(
        10000, // vocab_size
        128,   // hidden_size
        2,     // num_hidden_layers
        2,     // num_attention_heads
    );

    let model = GPTModel::<f32>::new(config)?;

    // Create dummy input (batch_size=2, seq_len=16)
    // Input tensor contains token IDs
    let input = Array::from_shape_fn(
        IxDyn(&[2, 16]),
        |_| rand::random::<f32>() * 100.0, // Random token IDs between 0 and 100
    );

    println!("Input shape: {:?}", input.shape());

    // Forward pass to get hidden states
    let hidden_states = model.forward(&input)?;

    println!("Hidden states shape: {:?}", hidden_states.shape());

    // Calculate logits for next-token prediction
    let logits = model.logits(&input)?;

    println!("Logits shape: {:?}", logits.shape());
    println!("Vocabulary size: {}", logits.shape()[2]);

    // Let's create a GPT-2 Small model
    println!("\nCreating a GPT-2 Small model...");

    let gpt2_small = GPTModel::<f32>::gpt2_small()?;

    // Create dummy input for a longer sequence
    let small_input = Array::from_shape_fn(
        IxDyn(&[1, 32]),
        |_| rand::random::<f32>() * 1000.0, // Random token IDs
    );

    println!("GPT-2 Small input shape: {:?}", small_input.shape());

    // Forward pass
    let small_hidden_states = gpt2_small.forward(&small_input)?;

    println!(
        "GPT-2 Small hidden states shape: {:?}",
        small_hidden_states.shape()
    );
    println!(
        "GPT-2 Small hidden dimension: {}",
        small_hidden_states.shape()[2]
    );

    // For text generation (logits for next token prediction)
    let small_logits = gpt2_small.logits(&small_input)?;
    println!("GPT-2 Small logits shape: {:?}", small_logits.shape());
    println!("GPT-2 Small vocabulary size: {}", small_logits.shape()[2]);

    println!("\nGPT example completed successfully!");

    Ok(())
}

Trait Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync> Layer<F> for GPTModel<F>

fn forward(&self, input: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Forward pass of the layer

fn backward( &self, _input: &Array<F, IxDyn>, grad_output: &Array<F, IxDyn>, ) -> Result<Array<F, IxDyn>>

Backward pass of the layer to compute gradients

fn update(&mut self, learning_rate: F) -> Result<()>

Update the layer parameters with the given gradients

fn as_any(&self) -> &dyn Any

Get the layer as a dyn Any for downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get the layer as a mutable dyn Any for downcasting

fn params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

fn gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the layer parameters

fn set_gradients(&mut self, _gradients: &[Array<F, IxDyn>]) -> Result<()>

Set the gradients of the layer parameters

fn set_params(&mut self, _params: &[Array<F, IxDyn>]) -> Result<()>

Set the parameters of the layer

fn set_training(&mut self, _training: bool)

Set the layer to training mode (true) or evaluation mode (false)

fn is_training(&self) -> bool

Get the current training mode

fn layer_type(&self) -> &str

Get the type of the layer (e.g., “Dense”, “Conv2D”)

fn parameter_count(&self) -> usize

Get the number of trainable parameters in this layer

fn layer_description(&self) -> String

Get a detailed description of this layer