Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/storswiftlabs/convolution
Convolution
https://github.com/storswiftlabs/convolution
Last synced: 3 months ago
JSON representation
Convolution
- Host: GitHub
- URL: https://github.com/storswiftlabs/convolution
- Owner: storswiftlabs
- License: apache-2.0
- Created: 2023-08-29T09:50:53.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2024-03-02T13:52:27.000Z (9 months ago)
- Last Synced: 2024-04-14T02:08:18.132Z (7 months ago)
- Language: Roff
- Size: 53.7 KB
- Stars: 2
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-noir - Convolution - a library for Convolutional Neural Network (CNN) library in Noir, including Convolutional layers, Pooling layers, and Linear (fully connected) layers (Get Coding / Libraries)
README
# Convolution
This is a simple implementation of a convolutional neural network (CNN) library in Noir. The library provides basic building blocks for creating and working with CNN layers, including Convolutional layers, Pooling layers, and Linear (fully connected) layers.
## Features
- Convolutional Layer: The library includes a `Conv2D` struct for creating convolutional layers. You can specify the weight, bias, stride, and padding parameters when creating a convolutional layer. The layer supports both forward and padding operations.
- Pooling Layer: The library includes a `Pool2D` struct for creating pooling layers. You can specify the pooling type (max or average), stride, padding, and kernel size when creating a pooling layer. The layer supports both max pooling and average pooling operations.
- Linear (Fully Connected) Layer: The library includes a `Linear` struct for creating linear layers. You can specify the weight and bias when creating a linear layer. The layer supports forward operations.
## Usage
Here's a basic example of how to use the library to create a simple CNN:
```rust
use dep::convolution::{conv::{Conv2D, Pool2D, Linear}, tensor::Tensor};global in_len = 784;
global w1_len = 45;
global b1_len = 5;
global w2_len = 90;
global b2_len = 10;
global w3_len = 490;
global b3_len = 10;
global zero_point = 100000;
global scale = 10000;fn main(inputs: [Field; in_len], w1 : [Field; w1_len], b1 : [Field; b1_len], w2 : [Field; w2_len], b2 : [Field; b2_len], w3 : [Field; w3_len], b3 : [Field; b3_len]) {
let weight1 = Tensor::new_quantized(w1, [5, 1, 3, 3], zero_point, scale);
let bias1 = Tensor::new_quantized(b1, [5], zero_point, scale);
let weight2 = Tensor::new_quantized(w2, [10, 1, 3, 3], zero_point, scale);
let bias2 = Tensor::new_quantized(b2, [10], zero_point, scale);
let weight3 = Tensor::new_quantized(w3, [49, 10], zero_point, scale);
let bias3 = Tensor::new_quantized(b3, [10], zero_point, scale);// Create a convolutional layer
let conv_layer1 = Conv2D::new(weight1, bias1, 1, 1);
let conv_layer2 = Conv2D::new(weight2, bias2, 1, 1);// Create a pooling layer
let pooling_layer = Pool2D {
stride: 2,
padding: 0,
kernel_size: 2,
};// Create a linear layer
let linear_layer = Linear::new(weight3, bias3);// Perform forward pass
let input = Tensor::new_quantized(inputs, [1, 28, 28], zero_point, scale);
let mut conv_output1 = conv_layer1.forward(input);
conv_output1.values = conv_output1.relu();
let pooled_output1 = pooling_layer.max_pooling(conv_output1);
let mut conv_output2 = conv_layer2.forward(pooled_output1);
conv_output2.values = conv_output2.relu();
let pooled_output2 = pooling_layer.max_pooling(conv_output2);
// Fixed the side with 1 to have only one column
let reshape_output = pooled_output2.reshape([1, weight3.shape[0]]);
let linear_output = linear_layer.forward(reshape_output);
}#[test]
fn test_main() {
let inputs = [0; in_len];
let w1 = [0; w1_len];
let b1 = [0; b1_len];
let w2 = [0; w2_len];
let b2 = [0; b2_len];
let w3 = [0; w3_len];
let b3 = [0; b3_len];
main(inputs, w1, b1, w2, b2, w3, b3);
}```
## Dependencies
This library utilizes [quantized_arithmetic](https://github.com/storswiftlabs/quantized_arithmetic/tree/main) for quantized arithmetic operations and employs [matrix_operations](https://github.com/storswiftlabs/matrix_operations) for matrix operations.
## License
This project is provided under the [Apache License, Version 2.0](LICENSE).
## Acknowledgments
This library is a simple implementation and may not cover all the features and optimizations required for a production-level CNN library. It serves as a starting point for building more complex neural networks in Noir.
If you have any questions, suggestions, or contributions, please feel free to contact the project maintainers.