GpuRunner

flashlight::prelude

Struct GpuRunner 

Source 
pub struct GpuRunner {
    pub gpu_data: GpuData,
    /* private fields */
}
Expand description

Gpu runner for easier gpu usage

Fields§

§gpu_data: GpuData

Implementations§

Source§

impl GpuRunner

Source

pub async fn backward_bias(&mut self) -> Vec<Tensor<f32>>

Backpropagation for bias without activation No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;

#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let grad_output: Tensor<f32> = Tensor::fill(0.69, &[3, 2]);
    let linear_cache: Tensor<f32> = Tensor::fill(0.2137, &[3, 2]);

    let bias: Tensor<f32> = Tensor::fill(0.12412, &[3, 1]);

    let learning_rate = 0.01;

    let sample = Sample::from_data(vec!{bias, grad_output, linear_cache}, vec!{learning_rate}, &[]);
 
    let mut runner = GpuRunner::init(1, MemoryMetric::GB);
    runner.append(sample);

    let full_gpu_output: Vec<Tensor<f32>> = runner.backward_bias().await;
}
Source§

impl GpuRunner

Source

pub async fn backward_grad(&mut self) -> Vec<Tensor<f32>>

Backpropagation for gradient without activation No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;

#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let grad_output: Tensor<f32> = Tensor::fill(0.69, &[3, 2]);
    let weights: Tensor<f32> = Tensor::fill(0.12412, &[3, 3]);

    let sample = Sample::from_data(vec!{weights, grad_output}, vec!{}, &[]);

    let mut runner = GpuRunner::init(1, MemoryMetric::GB);
    runner.append(sample);

    let full_gpu_output: Vec<Tensor<f32>> = runner.backward_grad().await;
}
Source§

impl GpuRunner

Source

pub async fn backward_weight(&mut self) -> Vec<Tensor<f32>>

Backpropagation for weights without activation No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;

#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }

    let grad_output: Tensor<f32> = Tensor::fill(0.69, &[3, 2]);
    let linear_cache: Tensor<f32> = Tensor::fill(0.2137, &[3, 2]);
    let weights: Tensor<f32> = Tensor::fill(0.12412, &[3, 3]);

    let learning_rate = 0.01;

    let sample = Sample::from_data(vec!{weights, grad_output, linear_cache}, vec!{learning_rate}, &[]);

    let mut runner = GpuRunner::init(1, MemoryMetric::GB);

    runner.append(sample);

    let full_gpu_output: Vec<Tensor<f32>> = runner.backward_weight().await;
}
Source§

impl GpuRunner

Source

pub async fn forward_no_activ(&mut self) -> Vec<Tensor<f32>>

Forward propagation without activation No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;

#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }

    let inputs: Tensor<f32> = Tensor::from_data(&[1.0, 2.0, 0.5, 0.1, 0.3, 0.6], &[2, 3]).unwrap();
    let weights: Tensor<f32> = Tensor::from_data(&[2.0, 3.0, -4.0, 5.0], &[2,2]).unwrap();
    let biases: Tensor<f32> = Tensor::from_data(&[3.0, 4.0], &[2,1]).unwrap();

    let sample = Sample::from_data(vec!{weights, inputs, biases}, vec!{}, &[]);

    let mut runner = GpuRunner::init(1, MemoryMetric::GB);

    runner.append(sample);

    let full_gpu_output: Vec<Tensor<f32>> = runner.forward_no_activ().await;
}
Source

pub async fn forward_relu(&mut self) -> Vec<Tensor<f32>>

Forward propagation with relu activation No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;

#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }

    let inputs: Tensor<f32> = Tensor::from_data(&[1.0, 2.0, 0.5, 0.1, 0.3, 0.6], &[2, 3]).unwrap();
    let weights: Tensor<f32> = Tensor::from_data(&[2.0, 3.0, -4.0, 5.0], &[2,2]).unwrap();
    let biases: Tensor<f32> = Tensor::from_data(&[3.0, 4.0], &[2,1]).unwrap();

    let sample = Sample::from_data(vec!{weights, inputs, biases}, vec!{}, &[]);

    let mut runner = GpuRunner::init(1, MemoryMetric::GB);

    runner.append(sample);

    let full_gpu_output: Vec<Tensor<f32>> = runner.forward_relu().await;
}
Source

pub async fn forward_sigmoid(&mut self) -> Vec<Tensor<f32>>

Forward propagation with sigmoid activation No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;

#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }

    let inputs: Tensor<f32> = Tensor::from_data(&[1.0, 2.0, 0.5, 0.1, 0.3, 0.6], &[2, 3]).unwrap();
    let weights: Tensor<f32> = Tensor::from_data(&[2.0, 3.0, -4.0, 5.0], &[2,2]).unwrap();
    let biases: Tensor<f32> = Tensor::from_data(&[3.0, 4.0], &[2,1]).unwrap();

    let sample = Sample::from_data(vec!{weights, inputs, biases}, vec!{}, &[]);

    let mut runner = GpuRunner::init(1, MemoryMetric::GB);

    runner.append(sample);

    let full_gpu_output: Vec<Tensor<f32>> = runner.forward_sigmoid().await;
}
Source§

impl GpuRunner

Source

pub async fn relu(&mut self) -> Vec<Tensor<f32>>

Perform a relu operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.relu().await;
}
Source

pub async fn relu_der(&mut self) -> Vec<Tensor<f32>>

Perform a relu derivative operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.relu_der().await;
}
Source

pub async fn sigmoid(&mut self) -> Vec<Tensor<f32>>

Perform a sigmoid operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.sigmoid().await;
}
Source

pub async fn sigmoid_der(&mut self) -> Vec<Tensor<f32>>

Perform a sigmoid derivative operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.sigmoid().await;
}
Source§

impl GpuRunner

Source

pub async fn backward_relu(&mut self) -> Vec<Tensor<f32>>

Perform a relu operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 1]), Tensor::fill(1.0, &[1, 2])}, vec!{}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.backward_relu().await;
}
Source

pub async fn backward_sigmoid(&mut self) -> Vec<Tensor<f32>>

Perform a relu operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 1]), Tensor::fill(1.0, &[1, 2])}, vec!{}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.backward_sigmoid().await;
}
Source§

impl GpuRunner

Source

pub async fn add(&mut self) -> Vec<Tensor<f32>>

Perform an addition operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.add().await;
}
Source

pub async fn tens_add(&mut self) -> Vec<Tensor<f32>>

Perform a tensor addition operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2]), Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.tens_add().await;
}
Source§

impl GpuRunner

Source

pub async fn div(&mut self) -> Vec<Tensor<f32>>

Perform a division operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.div().await;
}
Source

pub async fn tens_div(&mut self) -> Vec<Tensor<f32>>

Perform a tensor division operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2]), Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.tens_div().await;
}
Source§

impl GpuRunner

Source

pub async fn log(&mut self) -> Vec<Tensor<f32>>

Perform a logarighmic operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(2.0, &[2, 2])}, vec!{2.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.log().await;
}
Source

pub async fn nlog(&mut self) -> Vec<Tensor<f32>>

Perform a natural log (log10) operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(10.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.nlog().await;
}
Source§

impl GpuRunner

Source

pub async fn matmul(&mut self) -> Vec<Tensor<f32>>

Perform a matmul operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2]), Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        
     
    //return shape [tens1[0], tens2[1]]
    let output_data: Vec<Tensor<f32>> = runner.matmul().await;
}
Source

pub async fn matrix_col_prod(&mut self) -> Vec<Tensor<f32>>

Perform a matrix column product operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        
     
    //return shape [tens[0], 1]
    let output_data: Vec<Tensor<f32>> = runner.matrix_col_prod().await;
}
Source

pub async fn matrix_col_sum(&mut self) -> Vec<Tensor<f32>>

Perform a matrix column sum operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        
     
    //return shape [tens[0], 1]
    let output_data: Vec<Tensor<f32>> = runner.matrix_col_sum().await;
}
Source

pub async fn matrix_row_prod(&mut self) -> Vec<Tensor<f32>>

Perform a matrix row product operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        
     
    //return shape [1, tens[1]]
    let output_data: Vec<Tensor<f32>> = runner.matrix_row_prod().await;
}
Source

pub async fn matrix_row_sum(&mut self) -> Vec<Tensor<f32>>

Perform a matrix row sum operation on tensors using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        
     
    //return shape [1, tens[1]]
    let output_data: Vec<Tensor<f32>> = runner.matrix_row_sum().await;
}
Source§

impl GpuRunner

Source

pub async fn mul(&mut self) -> Vec<Tensor<f32>>

Perform a multiplication operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.mul().await;
}
Source

pub async fn tens_mul(&mut self) -> Vec<Tensor<f32>>

Perform a tensor multiplication operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2]), Tensor::fill(1.0, &[2, 2])}, vec!{}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.tens_mul().await;
}
Source§

impl GpuRunner

Source

pub async fn sub(&mut self) -> Vec<Tensor<f32>>

Perform a subtraction operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.sub().await;
}
Source

pub async fn tens_sub(&mut self) -> Vec<Tensor<f32>>

Perform a subtraction operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 2])}, vec!{1.0}, &[]);

    runner.append(sample);        

    let output_data: Vec<Tensor<f32>> = runner.tens_sub().await;
}
Source§

impl GpuRunner

Source

pub async fn matrix_transpose(&mut self) -> Vec<Tensor<f32>>

Source§

impl GpuRunner

Source

pub async fn tens_broadcast_add(&mut self) -> Vec<Tensor<f32>>

Perform a broadcast addition operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 1]), Tensor::fill(1.0, &[1, 2])}, vec!{}, &[]);

    runner.append(sample);
     
    //output shape: [2, 2]
    let output_data: Vec<Tensor<f32>> = runner.tens_broadcast_add().await;
}
Source

pub async fn tens_broadcast_sub(&mut self) -> Vec<Tensor<f32>>

Perform a broadcast subtraction operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 1]), Tensor::fill(1.0, &[1, 2])}, vec!{}, &[]);

    runner.append(sample);
     
    //output shape: [2, 2]
    let output_data: Vec<Tensor<f32>> = runner.tens_broadcast_sub().await;
}
Source

pub async fn tens_broadcast_mul(&mut self) -> Vec<Tensor<f32>>

Perform a broadcast multiplication operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 1]), Tensor::fill(1.0, &[1, 2])}, vec!{}, &[]);

    runner.append(sample);
     
    //output shape: [2, 2]
    let output_data: Vec<Tensor<f32>> = runner.tens_broadcast_mul().await;
}
Source

pub async fn tens_broadcast_div(&mut self) -> Vec<Tensor<f32>>

Perform a broadcast division operation on tensor using GpuRunner No need to care about output shape while creating sample It is managed by GpuRunner

§Example
use flashlight_tensor::prelude::*;
 
#[tokio::main]
async fn main(){
    if std::env::var("CI").is_ok() {
        eprintln!("Skipping GPU test in CI");
        return;
    }
    let mut runner: GpuRunner = GpuRunner::init(1, MemoryMetric::GB);
 
    let sample = Sample::from_data(vec!{Tensor::fill(1.0, &[2, 1]), Tensor::fill(1.0, &[1, 2])}, vec!{}, &[]);

    runner.append(sample);
     
    //output shape: [2, 2]
    let output_data: Vec<Tensor<f32>> = runner.tens_broadcast_div().await;
}
Source§

impl GpuRunner

Source

pub fn init(buffer_size: u64, metric: MemoryMetric) -> GpuRunner

Initialize GpuRunner with memory size. memory limit is 2GB because of the wgpu limitations

Source

pub fn with_capacity( capacity: usize, buffer_size: u64, metric: MemoryMetric, ) -> GpuRunner

Initialize GpuRunner with memory size with gpu_data.input_capacity = capacity. memory limit is 2GB because of the wgpu limitations

Source

pub fn append(&mut self, sample: Sample)

append sample to GpuRunner

Source

pub fn clear(&mut self)

clear gpu_data

Source

pub fn set_data(&mut self, gpu_data: GpuData)

set new gpu_data

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WasmNotSend for T
where T: Send,

Source§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

Source§

impl<T> WasmNotSync for T
where T: Sync,