Struct Tensor 

pub struct Tensor {
    pub data: ArrayD<f32>,
}

A simple multi-dimensional tensor for our NPU framework. Internally uses ndarray::ArrayD<f32> for flexible dimensions.

Fields

data: ArrayD<f32>

Implementations

impl Tensor

pub fn new(data: Vec<f32>, shape: &[usize]) -> Self

Create a new tensor from a Vec and a shape. Example: Tensor::new(vec![1.0, 2.0, 3.0], &[3])

pub fn zeros(shape: &[usize]) -> Self

Create a tensor filled with zeros.

pub fn ones(shape: &[usize]) -> Self

Create a tensor filled with ones.

pub fn random(shape: &[usize]) -> Self

Create a tensor with random values between 0 and 1.

Examples found in repository

examples/full_inference_pipeline.rs (line 117)

fn quantize_model() {
    println!("3. Model Quantization");

    let calibration_data = vec![
        Tensor::random(&[1, 224, 224, 3]).data,
        Tensor::random(&[1, 224, 224, 3]).data,
        Tensor::random(&[1, 224, 224, 3]).data,
    ];

    let ptq = PTQEngine::new(8, false);
    match ptq.calibrate(&calibration_data) {
        Ok(converter) => {
            println!("   ✓ Calibration complete");
            
            let sample = &calibration_data[0];
            let stats = QuantStats::from_tensor(sample);
            println!("   Calibration Stats:");
            println!("   - Min: {:.6}", stats.min_val);
            println!("   - Max: {:.6}", stats.max_val);
            println!("   - Mean: {:.6}", stats.mean_val);
            println!("   - Std: {:.6}", stats.std_val);
            
            match converter.quantize_tensor(sample) {
                Ok(quantized) => {
                    println!("   ✓ Quantization complete: {} values", quantized.len());
                    println!("   Compression: {:.2}x\n", 
                        (sample.len() * 4) as f64 / quantized.len() as f64
                    );
                }
                Err(e) => println!("   ✗ Quantization failed: {}\n", e),
            }
        }
        Err(e) => println!("   ✗ Calibration failed: {}\n", e),
    }
}

fn execute_inference() {
    println!("4. Inference Execution");

    let device = Arc::new(NpuDevice::new());
    match device.initialize() {
        Ok(_) => {
            let ctx = ExecutionContext::new(device);
            
            let input = Tensor::random(&[1, 224, 224, 3]);
            let weights = Tensor::random(&[1, 1, 3, 64]);

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

            match ctx.execute_conv1x1(&input.data, &weights.data) {
                Ok(output) => {
                    println!("   ✓ Conv1x1 executed");
                    println!("   Output: {:?}", output.shape());
                    println!("   Throughput: {:.4} GOPS\n", ctx.get_current_throughput_gops());
                }
                Err(e) => println!("   ✗ Execution failed: {}\n", e),
            }
        }
        Err(e) => println!("   ✗ Device init failed: {}\n", e),
    }
}

pub fn from_scalar(value: f32) -> Self

Create a scalar tensor (0-D tensor).

pub fn shape(&self) -> &[usize]

Return the shape of the tensor as a slice.

Examples found in repository

examples/full_inference_pipeline.rs (line 160)

fn execute_inference() {
    println!("4. Inference Execution");

    let device = Arc::new(NpuDevice::new());
    match device.initialize() {
        Ok(_) => {
            let ctx = ExecutionContext::new(device);
            
            let input = Tensor::random(&[1, 224, 224, 3]);
            let weights = Tensor::random(&[1, 1, 3, 64]);

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

            match ctx.execute_conv1x1(&input.data, &weights.data) {
                Ok(output) => {
                    println!("   ✓ Conv1x1 executed");
                    println!("   Output: {:?}", output.shape());
                    println!("   Throughput: {:.4} GOPS\n", ctx.get_current_throughput_gops());
                }
                Err(e) => println!("   ✗ Execution failed: {}\n", e),
            }
        }
        Err(e) => println!("   ✗ Device init failed: {}\n", e),
    }
}

pub fn sum(&self) -> f32

Compute the sum of all elements.

pub fn print(&self)

Pretty-print tensor contents.

pub fn add(&self, other: &Self) -> Self

Element-wise addition.

pub fn sub(&self, other: &Self) -> Self

Element-wise subtraction.

pub fn mul(&self, other: &Self) -> Self

Element-wise multiplication.

pub fn div(&self, other: &Self) -> Self

Element-wise division.

pub fn relu(&self) -> Self

ReLU activation function.

pub fn sigmoid(&self) -> Self

Sigmoid activation function.

Trait Implementations

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.