file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
awesome-orion/finance/provable_multiple_linear_regression_solver/src/datasets/linear_data/feature_data.cairo | use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn x_feature_data() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![50].span(),
data: array![
FixedTrait::new(19671, false),
FixedTrait::new(23085, true),
FixedTrait::new(74876, true),
FixedTrait::new(22894, true),
FixedTrait::new(13690, true),
FixedTrait::new(38444, false),
FixedTrait::new(54983, false),
FixedTrait::new(61020, false),
FixedTrait::new(18716, false),
FixedTrait::new(58008, false),
FixedTrait::new(49440, true),
FixedTrait::new(82107, false),
FixedTrait::new(33615, false),
FixedTrait::new(19535, true),
FixedTrait::new(32015, false),
FixedTrait::new(4952, true),
FixedTrait::new(74162, false),
FixedTrait::new(99602, false),
FixedTrait::new(143233, false),
FixedTrait::new(91520, true),
FixedTrait::new(94641, true),
FixedTrait::new(33060, true),
FixedTrait::new(10488, false),
FixedTrait::new(57420, false),
FixedTrait::new(20685, false),
FixedTrait::new(132526, true),
FixedTrait::new(20067, true),
FixedTrait::new(54262, false),
FixedTrait::new(15079, false),
FixedTrait::new(49939, false),
FixedTrait::new(14570, true),
FixedTrait::new(13156, true),
FixedTrait::new(12226, false),
FixedTrait::new(26873, false),
FixedTrait::new(12995, false),
FixedTrait::new(7799, false),
FixedTrait::new(43952, true),
FixedTrait::new(24744, false),
FixedTrait::new(7983, false),
FixedTrait::new(74021, false),
FixedTrait::new(78572, false),
FixedTrait::new(12134, false),
FixedTrait::new(24594, true),
FixedTrait::new(41859, true),
FixedTrait::new(27754, false),
FixedTrait::new(5068, false),
FixedTrait::new(22534, true),
FixedTrait::new(2857, false),
FixedTrait::new(40632, true),
FixedTrait::new(45746, false),
]
.span()
);
return tensor;
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/datasets/linear_data/label_data.cairo | use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn y_label_data() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![50].span(),
data: array![
FixedTrait::new(6817428, false),
FixedTrait::new(6328827, false),
FixedTrait::new(5919977, false),
FixedTrait::new(6300125, false),
FixedTrait::new(6500794, false),
FixedTrait::new(6710325, false),
FixedTrait::new(7107816, false),
FixedTrait::new(6991879, false),
FixedTrait::new(6724238, false),
FixedTrait::new(7001326, false),
FixedTrait::new(6253898, false),
FixedTrait::new(7075450, false),
FixedTrait::new(6801393, false),
FixedTrait::new(6372144, false),
FixedTrait::new(6884026, false),
FixedTrait::new(6441896, false),
FixedTrait::new(7135599, false),
FixedTrait::new(7292890, false),
FixedTrait::new(7702237, false),
FixedTrait::new(5859629, false),
FixedTrait::new(5724338, false),
FixedTrait::new(6364135, false),
FixedTrait::new(6696592, false),
FixedTrait::new(7045896, false),
FixedTrait::new(6778122, false),
FixedTrait::new(5448575, false),
FixedTrait::new(6385007, false),
FixedTrait::new(6926370, false),
FixedTrait::new(6656679, false),
FixedTrait::new(6987870, false),
FixedTrait::new(6391707, false),
FixedTrait::new(6422343, false),
FixedTrait::new(6606377, false),
FixedTrait::new(6713193, false),
FixedTrait::new(6613575, false),
FixedTrait::new(6615164, false),
FixedTrait::new(6128755, false),
FixedTrait::new(6766914, false),
FixedTrait::new(6726246, false),
FixedTrait::new(7194405, false),
FixedTrait::new(7169606, false),
FixedTrait::new(6592503, false),
FixedTrait::new(6307876, false),
FixedTrait::new(6329638, false),
FixedTrait::new(6778962, false),
FixedTrait::new(6552402, false),
FixedTrait::new(6385833, false),
FixedTrait::new(6714099, false),
FixedTrait::new(6236415, false),
FixedTrait::new(6960018, false),
]
.span()
);
return tensor;
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/datasets/user_inputs_data.cairo | mod user_inputs_boston_data;
mod aave_weth_revenue_data_input;
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/datasets/user_inputs_data/aave_weth_revenue_data_input.cairo | use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn aave_weth_revenue_data_input() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![7, 9].span(),
data: array![
FixedTrait::new(160, false),
FixedTrait::new(786432, false),
FixedTrait::new(1048576, false),
FixedTrait::new(16973824, false),
FixedTrait::new(4128, false),
FixedTrait::new(10354688, false),
FixedTrait::new(1952972, false),
FixedTrait::new(5852364, false),
FixedTrait::new(198574079, false),
FixedTrait::new(185, false),
FixedTrait::new(681574, false),
FixedTrait::new(1048576, false),
FixedTrait::new(17170432, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1959526, false),
FixedTrait::new(5891686, false),
FixedTrait::new(207093760, false),
FixedTrait::new(211, false),
FixedTrait::new(688128, false),
FixedTrait::new(1055129, false),
FixedTrait::new(17301504, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1952972, false),
FixedTrait::new(5963776, false),
FixedTrait::new(206438400, false),
FixedTrait::new(236, false),
FixedTrait::new(707788, false),
FixedTrait::new(1055129, false),
FixedTrait::new(17367040, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1907097, false),
FixedTrait::new(6035865, false),
FixedTrait::new(203161600, false),
FixedTrait::new(261, false),
FixedTrait::new(792985, false),
FixedTrait::new(1061683, false),
FixedTrait::new(17432576, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1880883, false),
FixedTrait::new(6134169, false),
FixedTrait::new(195952639, false),
FixedTrait::new(285, false),
FixedTrait::new(792985, false),
FixedTrait::new(1061683, false),
FixedTrait::new(17432576, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1880883, false),
FixedTrait::new(6153830, false),
FixedTrait::new(195952639, false),
FixedTrait::new(308, false),
FixedTrait::new(792985, false),
FixedTrait::new(1061683, false),
FixedTrait::new(17498112, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1887436, false),
FixedTrait::new(6180044, false),
FixedTrait::new(196607999, false),
]
.span()
);
return tensor;
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/datasets/user_inputs_data/user_inputs_boston_data.cairo | use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn user_input_boston_housing() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![11].span(),
data: array![
FixedTrait::new(26719, false),
FixedTrait::new(0, false),
FixedTrait::new(406323, false),
FixedTrait::new(65536, false),
FixedTrait::new(33226, false),
FixedTrait::new(403963, false),
FixedTrait::new(5983436, false),
FixedTrait::new(199753, false),
FixedTrait::new(524288, false),
FixedTrait::new(20119552, false),
FixedTrait::new(1140326, false),
]
.span()
);
return tensor;
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/helper_functions.cairo | use debug::PrintTrait;
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
};
use orion::numbers::{FP16x16, FixedTrait};
// retrieves row data by index in a 2D tensor
fn get_tensor_data_by_row(tensor_data: Tensor<FP16x16>, row_index: u32,) -> Tensor<FP16x16> {
let column_len = *tensor_data.shape.at(1); //13
// crete new array
let mut result = ArrayTrait::<FP16x16>::new();
// loop through the x values and append values
let mut i: u32 = 0;
loop {
if i >= column_len {
break ();
}
result.append(tensor_data.at(indices: array![row_index, i].span()));
i += 1;
};
let resultant_tensor = TensorTrait::<
FP16x16
>::new(array![column_len].span(), data: result.span());
return resultant_tensor;
}
// transposes tensor
fn transpose_tensor(tensor_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let tensor_transposed = tensor_data.transpose(axes: array![1, 0].span());
return tensor_transposed;
}
fn calculate_mean(tensor_data: Tensor<FP16x16>) -> FP16x16 {
let tensor_size = FixedTrait::<FP16x16>::new_unscaled(tensor_data.data.len(), false);
let cumulated_sum = tensor_data.cumsum(0, Option::None(()), Option::None(()));
let sum_result = cumulated_sum.data[tensor_data.data.len() - 1];
let mean = *sum_result / tensor_size;
return mean;
}
// Calculates the R-Squared score between two tensors.
fn calculate_r_score(Y_values: Tensor<FP16x16>, Y_pred_values: Tensor<FP16x16>) -> FP16x16 {
let mut Y_values_ = Y_values;
let mean_y_value = calculate_mean(Y_values);
// creating the appropriate tensor shapes and empty arrays to populate values into
let mut squared_diff_shape = array::ArrayTrait::new();
squared_diff_shape.append(Y_values.data.len());
let mut squared_diff_vals = array::ArrayTrait::new();
let mut squared_mean_diff_shape = array::ArrayTrait::new();
squared_mean_diff_shape.append(Y_values.data.len());
let mut squared_mean_diff_vals = array::ArrayTrait::new();
let mut i: u32 = 0;
loop {
match Y_values_.data.pop_front() {
Option::Some(y_value) => {
let diff_pred = *y_value - *Y_pred_values.data.at(i);
let squared_diff = diff_pred * diff_pred;
squared_diff_vals.append(squared_diff);
let diff_mean = *y_value - mean_y_value;
let squared_mean_diff = diff_mean * diff_mean;
squared_mean_diff_vals.append(squared_mean_diff);
i += 1;
},
Option::None(_) => { break; }
}
};
let squared_diff_tensor = TensorTrait::<
FP16x16
>::new(squared_diff_shape.span(), squared_diff_vals.span());
let squared_mean_diff_tensor = TensorTrait::<
FP16x16
>::new(squared_mean_diff_shape.span(), squared_mean_diff_vals.span());
let sum_squared_diff = squared_diff_tensor.cumsum(0, Option::None(()), Option::None(()));
let sum_squared_mean_diff = squared_mean_diff_tensor
.cumsum(0, Option::None(()), Option::None(()));
let r_score = FixedTrait::new_unscaled(1, false)
- *sum_squared_diff.data.at(Y_values.data.len() - 1)
/ *sum_squared_mean_diff.data.at(Y_values.data.len() - 1);
return r_score;
}
// computes the x_min, x_max and x_range. Used for helping in normalizing and denormalizing user inputed values operations
fn normalize_user_x_inputs(
x_inputs: Tensor<FP16x16>, original_x_values: Tensor<FP16x16>
) -> Tensor<FP16x16> {
let mut x_inputs_normalized = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut x_min = ArrayTrait::<FP16x16>::new();
let mut x_max = ArrayTrait::<FP16x16>::new();
let mut x_range = ArrayTrait::<FP16x16>::new();
let mut result = ArrayTrait::<FP16x16>::new();
if original_x_values.shape.len() > 1 {
let transposed_tensor = original_x_values.transpose(axes: array![1, 0].span());
let data_len = *transposed_tensor.shape.at(0); //13
// loop through each row calculating the min, max and range row values for each feature columns
let mut i: u32 = 0;
loop {
if i >= data_len {
break ();
}
let mut transposed_tensor_row = get_tensor_data_by_row(transposed_tensor, i);
x_min.append(transposed_tensor_row.min_in_tensor());
x_max.append(transposed_tensor_row.max_in_tensor());
x_range
.append(
transposed_tensor_row.max_in_tensor() - transposed_tensor_row.min_in_tensor()
);
i += 1;
};
let mut x_min_tensor = TensorTrait::new(shape: array![data_len].span(), data: x_min.span());
let mut x_max_tensor = TensorTrait::new(shape: array![data_len].span(), data: x_max.span());
let mut x_range_tensor = TensorTrait::new(
shape: array![data_len].span(), data: x_range.span()
);
// for normalizing 2D user inputed feature vals
if x_inputs.shape.len() > 1 {
let mut j: u32 = 0;
loop {
if j >= *x_inputs.shape.at(0) {
break ();
};
let mut row_data = get_tensor_data_by_row(x_inputs, j);
let mut norm_row_data = (row_data - x_min_tensor) / x_range_tensor;
let mut k: u32 = 0;
loop {
if k >= norm_row_data.data.len() {
break ();
};
result.append(*norm_row_data.data.at(k));
k += 1;
};
j += 1;
};
x_inputs_normalized =
TensorTrait::<
FP16x16
>::new(
array![*x_inputs.shape.at(0), *x_inputs.shape.at(1)].span(), data: result.span()
);
};
// for normalizing 1D feature input
if x_inputs.shape.len() == 1 {
x_inputs_normalized = (x_inputs - x_min_tensor) / x_range_tensor;
};
}
if original_x_values.shape.len() == 1 {
let mut x_min_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![original_x_values.min_in_tensor()].span());
let mut x_max_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![original_x_values.max_in_tensor()].span());
let mut x_range_tensor = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(),
data: array![original_x_values.max_in_tensor() - original_x_values.min_in_tensor()]
.span()
);
let mut diff = ((x_inputs - x_min_tensor));
x_inputs_normalized = ((x_inputs - x_min_tensor)) / x_range_tensor;
};
return x_inputs_normalized;
}
// rescales model predictions to standard format
fn rescale_predictions(
prediction_result: Tensor<FP16x16>, y_values: Tensor<FP16x16>
) -> Tensor<FP16x16> {
let mut rescale_predictions = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut y_min_array = ArrayTrait::<FP16x16>::new();
let mut y_max_array = ArrayTrait::<FP16x16>::new();
let mut y_range_array = ArrayTrait::<FP16x16>::new();
let mut y_max = y_values.max_in_tensor();
let mut y_min = y_values.min_in_tensor();
let mut y_range = y_values.max_in_tensor() - y_values.min_in_tensor();
// convert to tensor format for ease of math operations
let y_min_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![y_min].span());
let y_max_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![y_max].span());
let y_range_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![y_range].span());
rescale_predictions = (prediction_result * y_range_tensor) + y_min_tensor;
return rescale_predictions;
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/lib.cairo | mod test;
mod data_preprocessing;
mod helper_functions;
mod datasets;
mod model;
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/model.cairo | mod linear_regression_model;
mod multiple_linear_regression_model;
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/model/linear_regression_model.cairo | use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
};
use orion::numbers::{FP16x16, FixedTrait};
use multiple_linear_regresion::data_preprocessing::{Dataset, DatasetTrait};
use multiple_linear_regresion::helper_functions::{
get_tensor_data_by_row, transpose_tensor, calculate_mean, calculate_r_score,
normalize_user_x_inputs, rescale_predictions
};
#[derive(Copy, Drop)]
struct LinearRegressionModel {
gradient: Tensor<FP16x16>,
bias: Tensor<FP16x16>
}
#[generate_trait]
impl RegressionOperation of LinearRegressionModelTrait {
fn predict(ref self: LinearRegressionModel, x_input: Tensor<FP16x16>) -> Tensor<FP16x16> {
let gradient = self.gradient;
let bias = self.bias;
let mut prediction = (gradient * x_input) + bias;
return prediction;
}
}
fn LinearRegression(dataset: Dataset) -> LinearRegressionModel {
let gradient = compute_gradient(dataset);
let bias = compute_bias(dataset);
return LinearRegressionModel { gradient, bias };
}
// computes the mean of a given 1D tensor and outputs result as tensor
fn compute_mean(tensor_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let tensor_size = FixedTrait::<FP16x16>::new_unscaled(tensor_data.data.len(), false);
let cumulated_sum = tensor_data.cumsum(0, Option::None(()), Option::None(()));
let sum_result = cumulated_sum.data[tensor_data.data.len() - 1];
let mean = *sum_result / tensor_size;
let mut result_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![mean].span());
return result_tensor;
}
/// Calculates the deviation of each element from the mean of the provided 1D tensor.
fn deviation_from_mean(tensor_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let mut tensor_data_ = tensor_data;
let mean_value = calculate_mean(tensor_data);
let mut tensor_shape = array::ArrayTrait::new();
tensor_shape.append(tensor_data.data.len());
let mut deviation_values = array::ArrayTrait::new();
let mut i: u32 = 0;
loop {
match tensor_data_.data.pop_front() {
Option::Some(tensor_val) => {
let distance_from_mean = *tensor_val - mean_value;
deviation_values.append(distance_from_mean);
i += 1;
},
Option::None(_) => { break; }
};
};
let distance_from_mean_tensor = TensorTrait::<
FP16x16
>::new(tensor_shape.span(), deviation_values.span());
return distance_from_mean_tensor;
}
/// Calculates the beta value for linear regression.
fn compute_gradient(dataset: Dataset) -> Tensor<FP16x16> {
let x_deviation = deviation_from_mean(dataset.x_values);
let y_deviation = deviation_from_mean(dataset.y_values);
let x_y_covariance = x_deviation.matmul(@y_deviation);
let x_variance = x_deviation.matmul(@x_deviation);
let beta_value = x_y_covariance / x_variance;
return beta_value;
}
/// Calculates the intercept for linear regression.
fn compute_bias(dataset: Dataset) -> Tensor<FP16x16> {
let x_mean = compute_mean(dataset.x_values);
let y_mean = compute_mean(dataset.y_values);
let gradient = compute_gradient(dataset);
let mx = gradient * x_mean;
let intercept = y_mean - mx;
return intercept;
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/model/multiple_linear_regression_model.cairo | use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
};
use orion::numbers::{FP16x16, FixedTrait};
use multiple_linear_regresion::data_preprocessing::{Dataset, DatasetTrait};
use multiple_linear_regresion::helper_functions::{
get_tensor_data_by_row, transpose_tensor, calculate_mean, calculate_r_score,
normalize_user_x_inputs, rescale_predictions
};
#[derive(Copy, Drop)]
struct MultipleLinearRegressionModel {
coefficients: Tensor<FP16x16>
}
#[generate_trait]
impl RegressionOperation of MultipleLinearRegressionModelTrait {
// reconstruct the y values using the computed gradients and x values
fn predict(
ref self: MultipleLinearRegressionModel, feature_inputs: Tensor<FP16x16>
) -> Tensor<FP16x16> {
// random tensor value that we will replace
let mut prediction_result = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut result = ArrayTrait::<FP16x16>::new();
// for multiple predictions
if feature_inputs.shape.len() > 1 {
let feature_values = add_bias_term(feature_inputs, 1);
let mut data_len: u32 = *feature_values.shape.at(0);
let mut i: u32 = 0;
loop {
if i >= data_len {
break ();
}
let feature_row_values = get_tensor_data_by_row(feature_values, i);
let predicted_values = feature_row_values.matmul(@self.coefficients);
result.append(*predicted_values.data.at(0));
i += 1;
};
prediction_result =
TensorTrait::<
FP16x16
>::new(shape: array![result.len()].span(), data: result.span());
}
// for single predictions
if feature_inputs.shape.len() == 1 && self.coefficients.data.len() > 1 {
let feature_values = add_bias_term(feature_inputs, 1);
prediction_result = feature_values.matmul(@self.coefficients);
}
return prediction_result;
}
}
fn MultipleLinearRegression(dataset: Dataset) -> MultipleLinearRegressionModel {
let x_values_tranposed = transpose_tensor(dataset.x_values);
let x_values_tranposed_with_bias = add_bias_term(x_values_tranposed, 0);
let decorrelated_x_features = decorrelate_x_features(x_values_tranposed_with_bias);
let coefficients = compute_gradients(
decorrelated_x_features, dataset.y_values, x_values_tranposed_with_bias
);
return MultipleLinearRegressionModel { coefficients };
}
//Adds bias term to features based on axis
fn add_bias_term(x_feature: Tensor<FP16x16>, axis: u32) -> Tensor<FP16x16> {
let mut x_feature_ = x_feature;
let mut tensor_with_bias = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut result = ArrayTrait::<FP16x16>::new();
// check if feature data has multiple rows and columns
if x_feature.shape.len() > 1 {
let mut index: u32 = 0;
if axis == 1 {
index = 0;
} else {
index = 1;
}
let data_len = *x_feature.shape.at(index); // 50
let mut i: u32 = 0;
loop {
if i >= data_len {
break ();
}
result
.append(FixedTrait::new(65536, false)); //65536=ONE in FP16x16, change accordingly
i += 1;
};
if axis == 0 {
let res_tensor = TensorTrait::new(
shape: array![1, data_len].span(), data: result.span()
);
tensor_with_bias =
TensorTrait::concat(tensors: array![x_feature, res_tensor].span(), axis: axis);
} else {
let res_tensor = TensorTrait::new(
shape: array![data_len, 1].span(), data: result.span()
);
tensor_with_bias =
TensorTrait::concat(tensors: array![x_feature, res_tensor].span(), axis: axis);
}
}
// check if feature data is 1D
if x_feature.shape.len() == 1 {
let mut j: u32 = 0;
loop {
match x_feature_.data.pop_front() {
Option::Some(x_val) => {
result.append(*x_val);
j += 1;
},
Option::None(_) => { break; }
};
};
result.append(FixedTrait::new(65536, false)); //65536=ONE in FP16x16, change accordingly
tensor_with_bias =
TensorTrait::<FP16x16>::new(shape: array![result.len()].span(), data: result.span());
}
return tensor_with_bias;
}
// decorrelates the feature data (*only the last tensor row of the decorelated feature data will be fully orthogonal)
fn decorrelate_x_features(x_feature_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let mut input_tensor = x_feature_data;
let mut i: u32 = 0;
loop {
if i >= *x_feature_data.shape.at(0) {
break ();
}
let mut placeholder = ArrayTrait::<FP16x16>::new();
let mut feature_row_values = get_tensor_data_by_row(input_tensor, i);
let mut feature_squared = feature_row_values.matmul(@feature_row_values);
// avoiding division by zero errors
if *feature_squared.data.at(0) == FixedTrait::new(0, false) {
feature_squared =
TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
}
// loop throgh remaining tensor data and remove the individual tensor factors from one another
let mut j: u32 = i + 1;
loop {
if j >= *x_feature_data.shape.at(0) {
break ();
}
let mut remaining_tensor_values = get_tensor_data_by_row(input_tensor, j);
let feature_cross_product = feature_row_values.matmul(@remaining_tensor_values);
let feature_gradients = feature_cross_product / feature_squared;
remaining_tensor_values = remaining_tensor_values
- (feature_row_values
* feature_gradients); //remove the feature factors from one another
// loop and append the modifieed remaining_tensor_values (after the corelated factor has been removed) to placeholder array
let mut k: u32 = 0;
loop {
if k >= remaining_tensor_values.data.len() {
break ();
}
placeholder.append(*remaining_tensor_values.data.at(k));
k += 1;
};
j += 1;
};
// convert placeholder array to tensor format and update the original tensor with the new modified decorrelated tensor row values
let mut decorrelated_tensor = TensorTrait::new(
shape: array![*x_feature_data.shape.at(0) - 1 - i, *x_feature_data.shape.at(1)].span(),
data: placeholder.span()
);
let mut original_tensor = input_tensor
.slice(
starts: array![0, 0].span(),
ends: array![i + 1, *x_feature_data.shape.at(1)].span(),
axes: Option::None(()),
steps: Option::Some(array![1, 1].span())
);
input_tensor =
TensorTrait::concat(
tensors: array![original_tensor, decorrelated_tensor].span(), axis: 0
);
i += 1;
};
return input_tensor;
}
// computes the corresponding MLR gradient using decorrelated feature
fn compute_gradients(
decorrelated_x_features: Tensor<FP16x16>,
y_values: Tensor<FP16x16>,
original_x_tensor_values: Tensor<FP16x16>
) -> Tensor<FP16x16> {
let mut gradient_values_flipped = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut result = ArrayTrait::<FP16x16>::new();
let mut tensor_y_vals = y_values;
let mut i: u32 = *decorrelated_x_features.shape.at(0);
// loop through Decorrelated_x_features starting from the fully orthogonlised last tensor row value
loop {
if i <= 0 {
break ();
}
let index_val = i - 1;
let mut decorelated_feature_row_values = get_tensor_data_by_row(
decorrelated_x_features, index_val
); // 50 vals
let mut decorelated_features_squared = decorelated_feature_row_values
.matmul(@decorelated_feature_row_values);
let mut feature_label_cross_product = tensor_y_vals
.matmul(@decorelated_feature_row_values); // multiply the tensors
// avoiding division by zero errors
if *decorelated_features_squared.data.at(0) == FixedTrait::new(0, false) {
decorelated_features_squared =
TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
}
// computing the feature gradient values using the y values and decorrelated x features and appending to array
let mut single_gradient_value = feature_label_cross_product
/ decorelated_features_squared; // devide the summed value by each other
result.append(*single_gradient_value.data.at(0));
// remove the assosciated feature gradient value away from y values
let mut original_x_tensor_row_values = get_tensor_data_by_row(
original_x_tensor_values, index_val
);
tensor_y_vals = tensor_y_vals
- (original_x_tensor_row_values
* single_gradient_value); //remove the first feature from second feature values
i -= 1;
};
// convert the gradient array to tensor format
let final_gradients = TensorTrait::new(
shape: array![*decorrelated_x_features.shape.at(0)].span(), data: result.span()
);
let mut reverse_grad_array = ArrayTrait::<FP16x16>::new();
let mut data_len: u32 = final_gradients.data.len();
loop {
if data_len <= 0 {
break ();
}
let temp_val = data_len - 1;
reverse_grad_array.append(*final_gradients.data.at(temp_val));
data_len -= 1;
};
// convert gradient values to tensor format
let gradient_values_flipped = TensorTrait::<
FP16x16
>::new(shape: array![reverse_grad_array.len()].span(), data: reverse_grad_array.span());
return gradient_values_flipped;
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/finance/provable_multiple_linear_regression_solver/src/test.cairo | // use traits::Into;
use debug::PrintTrait;
use array::{ArrayTrait, SpanTrait};
use multiple_linear_regresion::datasets::aave_data::aave_x_features::aave_x_features;
use multiple_linear_regresion::datasets::aave_data::aave_y_labels::aave_y_labels;
use multiple_linear_regresion::datasets::boston_data::boston_x_features::boston_x_features;
use multiple_linear_regresion::datasets::boston_data::boston_y_labels::boston_y_labels;
use multiple_linear_regresion::datasets::linear_data::feature_data::x_feature_data;
use multiple_linear_regresion::datasets::linear_data::label_data::y_label_data;
use multiple_linear_regresion::datasets::user_inputs_data::user_inputs_boston_data::user_input_boston_housing;
use multiple_linear_regresion::datasets::user_inputs_data::aave_weth_revenue_data_input::{
aave_weth_revenue_data_input
};
use orion::numbers::{FP16x16, FixedTrait};
use multiple_linear_regresion::model::linear_regression_model::{
LinearRegressionModel, compute_mean, LinearRegression, LinearRegressionModelTrait
};
use multiple_linear_regresion::model::multiple_linear_regression_model::{
MultipleLinearRegressionModel, MultipleLinearRegression, MultipleLinearRegressionModelTrait
};
use multiple_linear_regresion::data_preprocessing::{
Dataset, DatasetTrait, normalize_feature_data, normalize_label_data
};
use multiple_linear_regresion::helper_functions::{
get_tensor_data_by_row, transpose_tensor, calculate_mean, calculate_r_score,
normalize_user_x_inputs, rescale_predictions
};
use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
};
#[test]
#[available_gas(99999999999999999)]
fn multiple_linear_regression_test() {
// -------------------------------------------------------------------AAVE dataset tests---------------------------------------------------------------------------------------------
let mut main_x_vals = aave_x_features();
let mut main_y_vals = aave_y_labels();
let mut dataset = Dataset { x_values: main_x_vals, y_values: main_y_vals };
let mut normalized_dataset = dataset.normalize_dataset();
let mut model = MultipleLinearRegression(normalized_dataset);
let mut model_coefficients = model.coefficients;
let mut reconstructed_ys = model.predict(normalized_dataset.x_values);
let mut r_squared_score = calculate_r_score(normalized_dataset.y_values, reconstructed_ys);
r_squared_score.print();
// checking if data has been normalized correctly
assert(
normalized_dataset.x_values.max_in_tensor() <= FixedTrait::new(65536, false),
'normalized x not between 0-1'
);
assert(
normalized_dataset.x_values.min_in_tensor() >= FixedTrait::new(0, false),
'normalized x not between 0-1'
);
assert(
normalized_dataset.y_values.max_in_tensor() <= FixedTrait::new(65536, false),
'normalized y not between 0-1'
);
assert(
normalized_dataset.x_values.min_in_tensor() >= FixedTrait::new(0, false),
'normalized y not between 0-1'
);
// performing checks on the shape of normalized data
assert(
normalized_dataset.x_values.data.len() == main_x_vals.data.len()
&& normalized_dataset.y_values.data.len() == main_y_vals.data.len(),
'normalized data shape mismatch'
);
// performing checks on shape on coefficient values (gradient vals + bias)
assert(
model.coefficients.data.len() == *main_x_vals.shape.at(1) + 1,
'coefficient data shape mismatch'
);
// model accuracy deviance checks
assert(r_squared_score >= FixedTrait::new(62259, false), 'AAVE model acc. less than 95%');
// using model to forecast aave's 7 day WETH lifetime repayments forecast
let last_7_days_aave_data = aave_weth_revenue_data_input();
let last_7_days_aave_data_normalized = normalize_user_x_inputs(
last_7_days_aave_data, main_x_vals
);
let mut forecast_results = model.predict(last_7_days_aave_data_normalized);
let mut rescale_forecasts = rescale_predictions(
forecast_results, main_y_vals
); // PS. ** the rescaled forecasted ouputs are in denominated thousands of ETH
(*rescale_forecasts.data.at(0)).print();
(*rescale_forecasts.data.at(1)).print();
(*rescale_forecasts.data.at(2)).print();
(*rescale_forecasts.data.at(5)).print();
(*rescale_forecasts.data.at(6)).print();
// -------------------------------------------------------------------Boston dataset tests---------------------------------------------------------------------------------------------
// let mut main_x_vals = boston_x_features();
// let mut main_y_vals = boston_y_labels();
// let mut dataset = Dataset{x_values: main_x_vals,y_values:main_y_vals};
// let mut normalized_dataset = dataset.normalize_dataset();
// let mut model = MultipleLinearRegression(normalized_dataset);
// let mut model_coefficients = model.coefficients;
// let mut reconstructed_ys = model.predict (normalized_dataset.x_values);
// let mut r_squared_score = calculate_r_score(normalized_dataset.y_values,reconstructed_ys);
// r_squared_score.print();
// // checking if data has been normalized correctly
// assert(normalized_dataset.x_values.max_in_tensor() <= FixedTrait::new(65536, false), 'normalized x not between 0-1');
// assert(normalized_dataset.x_values.min_in_tensor() >= FixedTrait::new(0, false), 'normalized x not between 0-1');
// assert(normalized_dataset.y_values.max_in_tensor() <= FixedTrait::new(65536, false), 'normalized y not between 0-1');
// assert(normalized_dataset.x_values.min_in_tensor() >= FixedTrait::new(0, false), 'normalized y not between 0-1');
// // performing checks on the shape of normalized data
// assert(normalized_dataset.x_values.data.len()== main_x_vals.data.len() &&
// normalized_dataset.y_values.data.len()== main_y_vals.data.len() , 'normalized data shape mismatch');
// // performing checks on shape on coefficient values (gradient vals + bias)
// assert(model.coefficients.data.len() == *main_x_vals.shape.at(1)+1, 'coefficient data shape mismatch');
// // model accuracy deviance checks
// assert(r_squared_score >= FixedTrait::new(55699, false), 'Boston model acc. less than 84%');
// // boston user inputed house valuation predictions
// let user_input = user_input_boston_housing();
// let mut normalized_user_x_inputs = normalize_user_x_inputs(user_input, main_x_vals) ;
// let mut prediction_result = model.predict (normalized_user_x_inputs);
// let mut rescale_prediction = rescale_predictions(prediction_result, main_y_vals);
// (*rescale_prediction.data.at(0)).print();
// // ----------------------------------------------------------------Simple Linear regression tests---------------------------------------------------------------------------------
// let mut main_x_vals = x_feature_data();
// let mut main_y_vals = y_label_data();
// let dataset = Dataset{x_values: main_x_vals,y_values:main_y_vals};
// let mut model = LinearRegression(dataset);
// let gradient = model.gradient;
// let mut reconstructed_ys = model.predict(main_x_vals);
// let mut r_squared_score = calculate_r_score(main_y_vals,reconstructed_ys);
// r_squared_score.print();
// // // performing checks on shape on coefficient values (gradient vals + bias)
// // assert(model.gradient.data.len() == 1, 'gradient data shape mismatch');
// // assert(model.bias.data.len() == 1, 'bias data shape mismatch');
// // // model accuracy deviance checks
// // assert(r_squared_score >= FixedTrait::new(62259, false), 'Linear model acc. less than 95%');
// // linear regression model new input predictions
// let mut user_value = TensorTrait::<FP16x16>::new(shape: array![2].span(), data: array![FixedTrait::new(65536, false), FixedTrait::new(65536, true)].span());
// let mut prediction_results = model.predict(user_value);
// (*prediction_results.data.at(0)).print();
// (*prediction_results.data.at(1)).print();
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe.ipynb | {
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Importing required moduless\n",
"import numpy as np \n",
"import pandas as pd \n",
"import pprint,random\n",
"\n",
"from scipy.ndimage.interpolation import shift\n",
"import matplotlib.pyplot as plt\n",
"\n",
"from keras.models import Sequential\n",
"from keras.layers import Dense,Dropout\n",
"from keras.optimizers import SGD"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Creating a Tic Tac Toe Game\n",
"In order for a program to learn how to play Tic-Tac-Toe, we first need to create the Tic-Tac-Toe game\n",
"\n",
"Below, we create a simple tic tac toe game using Numpy\n",
"\n",
"Below are the details of the Numpy Tic Tac Toe Game:\n",
"\n",
"* The game board is a 3 * 3 numpy array\n",
"* The below is the denotation used:\n",
" * 2: placeholder/empty cell\n",
" * 0: 'O'\n",
" * 1: 'X'\n",
"* By default, the array is filled with the number 2 as placeholder\n",
"* The number 0 denotes an 'O' and the number 1 denotes an 'X'\n",
"* Players take turns in choosing the coordinates of the numpy array where they will place 0 or 1 respectively\n",
"* The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row wins the game\n",
"* For simplicity, the program always plays with the mark 1 and the opponent plays with 0"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class tic_tac_toe_game(object):\n",
" def __init__(self):\n",
" self.board=np.full((3,3),2)\n",
"\n",
" def toss(self):\n",
" \"\"\"Function to simulate a toss and decide which player goes first\n",
"\n",
" Args:\n",
"\n",
" Returns:\n",
" Returns 1 if player assigned mark 1 has won, or 0 if his opponent won\n",
"\n",
" \"\"\"\n",
" turn=np.random.randint(0,2,size=1)\n",
" if turn.mean()==0:\n",
" self.turn_monitor=0\n",
" elif turn.mean()==1:\n",
" self.turn_monitor=1\n",
" return self.turn_monitor\n",
"\n",
" def move(self,player,coord):\n",
" \"\"\"Function to perform the action of placing a mark on the tic tac toe board\n",
" After performing the action, this function flips the value of the turn_monitor to \n",
" the next player\n",
"\n",
" Args:\n",
" player: 1 if player who is assigned the mark 1 is performing the action, \n",
" 0 if his opponent is performing the action\n",
" coord: The coordinate where the 1 or 0 is to be placed on the \n",
" tic-tac-toe board (numpy array)\n",
"\n",
" Returns:\n",
" game_status(): Calls the game status function and returns its value\n",
" board: Returns the new board state after making the move\n",
"\n",
" \"\"\"\n",
" if self.board[coord]!=2 or self.game_status()!=\"In Progress\" or self.turn_monitor!=player:\n",
" raise ValueError(\"Invalid move\")\n",
" self.board[coord]=player\n",
" self.turn_monitor=1-player\n",
" return self.game_status(),self.board\n",
"\n",
"\n",
" def game_status(self):\n",
" \"\"\"Function to check the current status of the game, \n",
" whether the game has been won, drawn or is in progress\n",
"\n",
" Args:\n",
"\n",
" Returns:\n",
" \"Won\" if the game has been won, \"Drawn\" if the \n",
" game has been drawn, or \"In Progress\", if the game is still in progress\n",
"\n",
" \"\"\"\n",
" #check for a win along rows\n",
" for i in range(self.board.shape[0]):\n",
" if 2 not in self.board[i,:] and len(set(self.board[i,:]))==1:\n",
" return \"Won\"\n",
" #check for a win along columns\n",
" for j in range(self.board.shape[1]):\n",
" if 2 not in self.board[:,j] and len(set(self.board[:,j]))==1:\n",
" return \"Won\"\n",
" # check for a win along diagonals\n",
" if 2 not in np.diag(self.board) and len(set(np.diag(self.board)))==1:\n",
" return \"Won\"\n",
" if 2 not in np.diag(np.fliplr(self.board)) and len(set(np.diag(np.fliplr(self.board))))==1:\n",
" return \"Won\"\n",
" # check for a Draw\n",
" if not 2 in self.board:\n",
" return \"Drawn\"\n",
" else:\n",
" return \"In Progress\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Testing the Tic Tac Toe game\n",
"\n",
"To simply test the tic-tac-toe game created above, let us play a dummy game. We make the moves for both the players."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# create an object of the class tick_tac_toe_game\n",
"game=tic_tac_toe_game()\n",
"# toss to decide which player goes first\n",
"game.toss()\n",
"print(\"Player \",game.turn_monitor,\" has won the toss\")\n",
"# make the first move\n",
"print(\"Initial board state \\n\",game.board)\n",
"print(\"Let first player place their mark on 0,0\")\n",
"game_status,board=game.move(game.turn_monitor,(0,0))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Let second player place their mark on 0,1\")\n",
"game_status,board=game.move(game.turn_monitor,(0,1))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Let first player place their mark on 1,1\")\n",
"game_status,board=game.move(game.turn_monitor,(1,1))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Let second player place their mark on 0,2\")\n",
"game_status,board=game.move(game.turn_monitor,(0,2))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Let first player place their mark on 2,2\")\n",
"game_status,board=game.move(game.turn_monitor,(2,2))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Player \",1-game.turn_monitor,\" Has \",game_status)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Creating the Legal Moves Generator\n",
"\n",
"The legal moves genator accepts the board state and player as input, and provides the set of all possible legal moves as output.\n",
"\n",
"Basically, for a given board state and player, it tells us where all the player can place his mark legally (the player can only place the mark where there is no opponent's mark)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def legal_moves_generator(current_board_state,turn_monitor):\n",
" \"\"\"Function that returns the set of all possible legal moves and resulting board states, \n",
" for a given input board state and player\n",
"\n",
" Args:\n",
" current_board_state: The current board state\n",
" turn_monitor: 1 if it's the player who places the mark 1's turn to play, 0 if its his opponent's turn\n",
"\n",
" Returns:\n",
" legal_moves_dict: A dictionary of a list of possible next coordinate-resulting board state pairs\n",
" The resulting board state is flattened to 1 d array\n",
"\n",
" \"\"\"\n",
" legal_moves_dict={}\n",
" for i in range(current_board_state.shape[0]):\n",
" for j in range(current_board_state.shape[1]):\n",
" if current_board_state[i,j]==2:\n",
" board_state_copy=current_board_state.copy()\n",
" board_state_copy[i,j]=turn_monitor\n",
" legal_moves_dict[(i,j)]=board_state_copy.flatten()\n",
" return legal_moves_dict"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Testing the Legal Moves Generator\n",
"\n",
"Let us test the above created Legal Moves Generator.\n",
"\n",
"We start a dummy game, and do the toss. We then pass the current board state and toss winner to the Legal Moves Generator. It returns the dictionary of legal moves that it returns the dictionary is of the form \"possible next legal move coordinate\":\"flattened resulting board state\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"game=tic_tac_toe_game()\n",
"game.toss()\n",
"print(\"Player \",game.turn_monitor,\" has won the toss\")\n",
"print(\"Current board state \\n\",game.board)\n",
"legal_moves_dict=legal_moves_generator(game.board,game.turn_monitor)\n",
"print(\"Dictionary of Possible Next Legal Moves:\")\n",
"pprint.pprint(legal_moves_dict)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can observe above that the Legal Moves Generator returns a dictionary with all the possible legal coordinates and their resulting flattened numpy board states"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Creating the Evaluator (Neural Network Model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As defined previously, the Evaluator function maps board states to scores.\n",
"\n",
"It is expected that after training, the Evaluator learns to assign higher scores to board states that are favourable to the program.\n",
"In our kernel, we use a neural network as an Evaluator Function.\n",
"\n",
"Below, we create the neural network. The weights of the neural network are intialized randomly.\n",
"The neural network takes the flattened tic-tac-toe board numpy array as input and outputs a score."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"model = Sequential()\n",
"model.add(Dense(18, input_dim=9,kernel_initializer='normal', activation='relu'))\n",
"model.add(Dropout(0.1))\n",
"model.add(Dense(9, kernel_initializer='normal',activation='relu'))\n",
"model.add(Dropout(0.1))\n",
"model.add(Dense(1,kernel_initializer='normal'))\n",
"\n",
"learning_rate = 0.001\n",
"momentum = 0.8\n",
"\n",
"sgd = SGD(lr=learning_rate, momentum=momentum,nesterov=False)\n",
"model.compile(loss='mean_squared_error', optimizer=sgd)\n",
"model.summary()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Creating the Program Move Selector\n",
"\n",
"The Program Move Selector selects the next move for a player given the current board state using the following approach:\n",
"* Use the Legal Moves Generator to get all the possible next legal board states.\n",
"* Use the Evaluator (model) to score each possible next board state.\n",
"* The next board state that is assigned the highest score is selected as the next board state.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def move_selector(model,current_board_state,turn_monitor):\n",
" \"\"\"Function that selects the next move to make from a set of possible legal moves\n",
"\n",
" Args:\n",
" model: The Evaluator function to use to evaluate each possible next board state\n",
" turn_monitor: 1 if it's the player who places the mark 1's turn to play, 0 if its his opponent's turn\n",
"\n",
" Returns:\n",
" selected_move: The numpy array coordinates where the player should place thier mark\n",
" new_board_state: The flattened new board state resulting from performing above selected move\n",
" score: The score that was assigned to the above selected_move by the Evaluator (model)\n",
"\n",
" \"\"\"\n",
" tracker={}\n",
" legal_moves_dict=legal_moves_generator(current_board_state,turn_monitor)\n",
" for legal_move_coord in legal_moves_dict:\n",
" score=model.predict(legal_moves_dict[legal_move_coord].reshape(1,9))\n",
" tracker[legal_move_coord]=score\n",
" selected_move=max(tracker, key=tracker.get)\n",
" new_board_state=legal_moves_dict[selected_move]\n",
" score=tracker[selected_move]\n",
" return selected_move,new_board_state,score"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Testing the Program Move Selector\n",
"\n",
"Let us play a dummy game and use the above created Program Move Selector function to select the next move"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# new game\n",
"game=tic_tac_toe_game()\n",
"# toss\n",
"game.toss()\n",
"# choose the first move\n",
"print(\"Player assigned mark 1\",game.turn_monitor,\" won the toss\")\n",
"print(\"Initial board state:\")\n",
"print(game.board)\n",
"selected_move,new_board_state,score=move_selector(model,game.board,game.turn_monitor)\n",
"print(\"Selected move: \",selected_move)\n",
"print(\"Resulting new board state: \",new_board_state)\n",
"print(\"Score assigned to above board state by Evaluator(model): \", score)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Please note that since the Evaluator (model) has not yet been trained and has been assigned random weights, hence the score above is a random number"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Creating the opponent (The Opponent Move Selector)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For our program to self learn, it needs to play several games of tic-tac-toe.\n",
"\n",
"But with who will it play with?\n",
"\n",
"The program learns by playing games against a coded opponent.\n",
"\n",
"The opponent is coded to do the following:\n",
"\n",
"1. If playing in \"Easy\" mode:\n",
"\n",
" * When it is your turn, use the Legal Moves Generator to get all possible legal next moves\n",
" * Pick a legal move at random\n",
" * Repeat above until the end of the game\n",
"\n",
"2. If playing in \"Hard\" mode:\n",
"\n",
" * When it is your turn, use the Legal Moves Generator to get all possible legal next moves\n",
" * Of the above legal moves, if any legal move makes you win (along row/column/diagonal), pick that legal move\n",
" * Else, if any legal move prevents your opponent (program) from winning when it is one move away from a win, pick that move\n",
" * Else, if any legal move leads to a row/diagonal/column having two 0's and no 1's (program's mark) , pick that legal move\n",
" * If none of the above conditions exist, pick a legal move at random\n",
"\n",
"The Program is trained by repeatedly playing games against the above opponent and updating the weights of the model at the end of each game.\n",
"\n",
"Each game is played at either \"Easy\" or \"Hard\" mode, which is picked at random at the start of each game.\n",
"\n",
"The \"Easy\" mode helps the Program explore the tic-tac-toe space. The \"Hard\" mode helps the Program learn how to play with a real opponent."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def row_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan rowwise and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" #check for a win along rows\n",
" for i in range(current_board_state_copy.shape[0]):\n",
" if 2 not in current_board_state_copy[i,:] and len(set(current_board_state_copy[i,:]))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def column_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan column wise and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
"\n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" for j in range(current_board_state_copy.shape[1]):\n",
" if 2 not in current_board_state_copy[:,j] and len(set(current_board_state_copy[:,j]))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"def diag1_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan diagonal and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
"\n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 2 not in np.diag(current_board_state_copy) and len(set(np.diag(current_board_state_copy)))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def diag2_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan second diagonal and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
"\n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 2 not in np.diag(np.fliplr(current_board_state_copy)) and len(set(np.diag(np.fliplr(current_board_state_copy))))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"#------------#\n",
"\n",
"def row_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan rowwise and identify coordinate amongst the legal coordinates \n",
" that will prevent the program \n",
" from winning\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will block 1 from winning\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" for i in range(current_board_state_copy.shape[0]):\n",
" if 2 not in current_board_state_copy[i,:] and (current_board_state_copy[i,:]==1).sum()==2:\n",
" if not (2 not in current_board_state[i,:] and (current_board_state[i,:]==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def column_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan column wise and identify coordinate amongst the legal coordinates that will prevent 1 \n",
" from winning\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will block 1 from winning\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" \n",
" for j in range(current_board_state_copy.shape[1]):\n",
" if 2 not in current_board_state_copy[:,j] and (current_board_state_copy[:,j]==1).sum()==2:\n",
" if not (2 not in current_board_state[:,j] and (current_board_state[:,j]==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"def diag1_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan diagonal 1 and identify coordinate amongst the legal coordinates that will prevent 1 \n",
" from winning\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will block 1 from winning\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor \n",
" if 2 not in np.diag(current_board_state_copy) and (np.diag(current_board_state_copy)==1).sum()==2:\n",
" if not (2 not in np.diag(current_board_state) and (np.diag(current_board_state)==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def diag2_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan second diagonal wise and identify coordinate amongst the legal coordinates that will\n",
" result in a column having only 0s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 2 not in np.diag(np.fliplr(current_board_state_copy)) and (np.diag(np.fliplr(current_board_state_copy))==1).sum()==2:\n",
" if not (2 not in np.diag(np.fliplr(current_board_state)) and (np.diag(np.fliplr(current_board_state))==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"#---------------#\n",
"def row_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan rowwise and identify coordinate amongst the legal coordinates that will\n",
" result in a row having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" \n",
" for i in range(current_board_state_copy.shape[0]):\n",
" if 1 not in current_board_state_copy[i,:] and (current_board_state_copy[i,:]==0).sum()==2:\n",
" if not (1 not in current_board_state[i,:] and (current_board_state[i,:]==0).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def column_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan column wise and identify coordinate amongst the legal coordinates that will\n",
" result in a column having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" \n",
" for j in range(current_board_state_copy.shape[1]):\n",
" if 1 not in current_board_state_copy[:,j] and (current_board_state_copy[:,j]==0).sum()==2:\n",
" if not (1 not in current_board_state[:,j] and (current_board_state[:,j]==0).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"def diag1_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan diagonal wise and identify coordinate amongst the legal coordinates that will\n",
" result in a column having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 1 not in np.diag(current_board_state_copy) and (np.diag(current_board_state_copy)==0).sum()==2:\n",
" if not (1 not in np.diag(current_board_state) and (np.diag(current_board_state)==0).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def diag2_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan second diagonal wise and identify coordinate amongst \n",
" the legal coordinates that will result in a column having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where opponent places their mark\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 1 not in np.diag(np.fliplr(current_board_state_copy)) and (np.diag(np.fliplr(current_board_state_copy))==0).sum()==2:\n",
" if not (1 not in np.diag(np.fliplr(current_board_state)) and (np.diag(np.fliplr(current_board_state))==0).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def opponent_move_selector(current_board_state,turn_monitor,mode):\n",
" \"\"\"Function that picks a legal move for the opponent\n",
"\n",
" Args:\n",
" current_board_state: Current board state\n",
" turn_monitor: whose turn it is to move\n",
" mode: whether hard or easy mode\n",
"\n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_moves_dict=legal_moves_generator(current_board_state,turn_monitor)\n",
" \n",
" winning_move_checks=[row_winning_move_check,column_winning_move_check,diag1_winning_move_check,diag2_winning_move_check]\n",
" block_move_checks=[row_block_move_check,column_block_move_check,diag1_block_move_check,diag2_block_move_check]\n",
" second_move_checks=[row_second_move_check,column_second_move_check,diag1_second_move_check,diag2_second_move_check]\n",
"\n",
" if mode==\"Hard\":\n",
" random.shuffle(winning_move_checks)\n",
" random.shuffle(block_move_checks)\n",
" random.shuffle(second_move_checks) \n",
" \n",
" for fn in winning_move_checks:\n",
" if fn(current_board_state,legal_moves_dict,turn_monitor):\n",
" return fn(current_board_state,legal_moves_dict,turn_monitor)\n",
" \n",
" for fn in block_move_checks:\n",
" if fn(current_board_state,legal_moves_dict,turn_monitor):\n",
" return fn(current_board_state,legal_moves_dict,turn_monitor)\n",
" \n",
" for fn in second_move_checks:\n",
" if fn(current_board_state,legal_moves_dict,turn_monitor):\n",
" return fn(current_board_state,legal_moves_dict,turn_monitor)\n",
" \n",
" selected_move=random.choice(list(legal_moves_dict.keys()))\n",
" return selected_move\n",
" \n",
" elif mode==\"Easy\":\n",
" legal_moves_dict=legal_moves_generator(current_board_state,turn_monitor)\n",
" selected_move=random.choice(list(legal_moves_dict.keys()))\n",
" return selected_move"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Training the Program\n",
"\n",
"Training the progam is essentially training the Evaluator(model) to assign higher scores to board states favourable to the program, and lower scores to board states unfavourable to the program.\n",
"\n",
"The progam is expected to learn by playing games against the Opponent.\n",
"\n",
"The Evaluator (model) is trained in the following way:\n",
"\n",
"* At first the weights of the model are randomly assigned\n",
"* Using this model, the Move Selector function selects the next move to make for the program\n",
"* The program and the opponent make thier moves until the game ends\n",
"* After the game is completed, the scores are corrected as follows:\n",
" * If the game was Won by the program, assign the score 1 to the final board state, or assign -1 if lost or 0 if drawn\n",
" * Shift the remaining scores so that they become the scores of the previous board states\n",
" * Update the weights of the model using the board state and corrected score\n",
"* The above process is repeated over 100s of thousands of games\n",
"* It is expected that eventually, the Evaluator (model) learns to assign higher scores to more favourable board states and lower scores to less favourable board states"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def train(model,mode,print_progress=False):\n",
" \"\"\"Function trains the Evaluator (model) by playing a game against an opponent \n",
" playing random moves, and updates the weights of the model after the game\n",
" \n",
" Note that the model weights are updated using SGD with a batch size of 1\n",
"\n",
" Args:\n",
" model: The Evaluator function being trained\n",
"\n",
" Returns:\n",
" model: The model updated using SGD\n",
" y: The corrected scores\n",
"\n",
" \"\"\" \n",
" # start the game\n",
" if print_progress==True:\n",
" print(\"___________________________________________________________________\")\n",
" print(\"Starting a new game\")\n",
" game=tic_tac_toe_game()\n",
" game.toss()\n",
" scores_list=[]\n",
" corrected_scores_list=[]\n",
" new_board_states_list=[]\n",
" \n",
" while(1):\n",
" if game.game_status()==\"In Progress\" and game.turn_monitor==1:\n",
" # If its the program's turn, use the Move Selector function to select the next move\n",
" selected_move,new_board_state,score=move_selector(model,game.board,game.turn_monitor)\n",
" scores_list.append(score[0][0])\n",
" new_board_states_list.append(new_board_state)\n",
" # Make the next move\n",
" game_status,board=game.move(game.turn_monitor,selected_move)\n",
" if print_progress==True:\n",
" print(\"Program's Move\")\n",
" print(board)\n",
" print(\"\\n\")\n",
" elif game.game_status()==\"In Progress\" and game.turn_monitor==0:\n",
" selected_move=opponent_move_selector(game.board,game.turn_monitor,mode=mode)\n",
" \n",
" # Make the next move\n",
" game_status,board=game.move(game.turn_monitor,selected_move)\n",
" if print_progress==True:\n",
" print(\"Opponent's Move\")\n",
" print(board)\n",
" print(\"\\n\")\n",
" else:\n",
" break\n",
"\n",
" \n",
" # Correct the scores, assigning 1/0/-1 to the winning/drawn/losing final board state, \n",
" # and assigning the other previous board states the score of their next board state\n",
" new_board_states_list=tuple(new_board_states_list)\n",
" new_board_states_list=np.vstack(new_board_states_list)\n",
" if game_status==\"Won\" and (1-game.turn_monitor)==1: \n",
" corrected_scores_list=shift(scores_list,-1,cval=1.0)\n",
" result=\"Won\"\n",
" if game_status==\"Won\" and (1-game.turn_monitor)!=1:\n",
" corrected_scores_list=shift(scores_list,-1,cval=-1.0)\n",
" result=\"Lost\"\n",
" if game_status==\"Drawn\":\n",
" corrected_scores_list=shift(scores_list,-1,cval=0.0)\n",
" result=\"Drawn\"\n",
" if print_progress==True:\n",
" print(\"Program has \",result)\n",
" print(\"\\n Correcting the Scores and Updating the model weights:\")\n",
" print(\"___________________________________________________________________\\n\")\n",
" \n",
" x=new_board_states_list\n",
" y=corrected_scores_list\n",
" \n",
" def unison_shuffled_copies(a, b):\n",
" assert len(a) == len(b)\n",
" p = np.random.permutation(len(a))\n",
" return a[p], b[p]\n",
" \n",
" # shuffle x and y in unison\n",
" x,y=unison_shuffled_copies(x,y)\n",
" x=x.reshape(-1,9) \n",
" \n",
" # update the weights of the model, one record at a time\n",
" model.fit(x,y,epochs=1,batch_size=1,verbose=0)\n",
" return model,y,result"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### A sample single training game\n",
"\n",
"Note that the program will always play the mark '1' and the opponent will always play mark '0'.\n",
"\n",
"below, we run a single iteration of training, or in other words, a single game of tic-tac-toe between the program and opponent."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"updated_model,y,result=train(model,mode=\"Hard\",print_progress=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Training by playing a large number of games\n",
"\n",
"We play 200,000 games of tic-tac-toe between the program and the opponent. We record the result of each game and plot the distribution of wins/losses/draws by the program over fixed intervals of games"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"game_counter=1\n",
"data_for_graph=pd.DataFrame()\n",
"\n",
"mode_list=[\"Easy\",\"Hard\"]\n",
"\n",
"while(game_counter<=200000):\n",
" mode_selected=np.random.choice(mode_list, 1, p=[0.5,0.5])\n",
" model,y,result=train(model,mode=mode_selected[0],print_progress=False)\n",
" # data_for_graph=data_for_graph.append({\"game_counter\":game_counter,\"result\":result},ignore_index=True)\n",
" if game_counter % 10000 == 0:\n",
" print(\"Game#: \",game_counter)\n",
" print(\"Mode: \",mode_selected[0])\n",
" game_counter+=1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"model.save('model/ttt.h5') # creates a HDF5 file 'ttt.h5'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Play Against AI\n",
"Below you can play against AI agent"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def play_with_model(model):\n",
" # Start a new game\n",
" game = tic_tac_toe_game()\n",
" game.toss()\n",
" current_player = \"Human\" if game.turn_monitor == 0 else \"Model\"\n",
"\n",
" print(f\"{current_player} won the toss\")\n",
"\n",
" # Game loop\n",
" while game.game_status() == \"In Progress\":\n",
" print(\"Current board state:\")\n",
" print(game.board)\n",
" \n",
" if game.turn_monitor == 0: # Human's turn\n",
" valid_move = False\n",
" while not valid_move:\n",
" try:\n",
" move_row = int(input(\"Enter the row where you want to place your mark (0, 1, 2): \"))\n",
" move_col = int(input(\"Enter the column where you want to place your mark (0, 1, 2): \"))\n",
" game_status, board = game.move(0, (move_row, move_col))\n",
" valid_move = True\n",
" except ValueError as e:\n",
" print(e)\n",
" print(\"Try again.\")\n",
" else: # Model's turn\n",
" selected_move, new_board_state, score = move_selector(model, game.board, game.turn_monitor)\n",
" game_status, board = game.move(1, selected_move)\n",
" print(f\"Model places at {selected_move}\")\n",
"\n",
" print(f\"Game Over! Status: {game_status}\")\n",
" print(\"Final board state:\")\n",
" print(game.board)\n",
"\n",
"model = load_model('ttt.h5')\n",
"play_with_model(model)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Convert to ONNX"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"! pip install onnx\n",
"! pip install keras2onnx\n",
"! pip install tensorflow\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.python.keras.models import load_model\n",
"import os\n",
"os.environ['TF_KERAS'] = '1'\n",
"import onnxmltools\n",
"\n",
"\n",
"model = load_model('model/ttt.h5')\n",
"onnx_model = onnxmltools.convert_keras(model) \n",
"\n",
"onnxmltools.utils.save_model(onnx_model, 'model/ttt.onnx')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import onnx\n",
"\n",
"# Load the ONNX model and check the model structure\n",
"onnx_model = onnx.load('model/ttt.onnx')\n",
"onnx.checker.check_model(onnx_model)\n",
"\n",
"# You can print the ONNX model's graph to inspect its structure\n",
"print(onnx_model.graph)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.9"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/crates/sequential_1_dense_1_biasadd_readvariableop_0/src/lib.cairo | use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![18,].span(),
data: array![
FP16x16 { mag: 77099, sign: true },
FP16x16 { mag: 140625, sign: true },
FP16x16 { mag: 59258, sign: true },
FP16x16 { mag: 40408, sign: false },
FP16x16 { mag: 66634, sign: true },
FP16x16 { mag: 27092, sign: false },
FP16x16 { mag: 3196, sign: true },
FP16x16 { mag: 392, sign: true },
FP16x16 { mag: 81839, sign: true },
FP16x16 { mag: 39890, sign: true },
FP16x16 { mag: 16196, sign: false },
FP16x16 { mag: 59646, sign: false },
FP16x16 { mag: 55690, sign: false },
FP16x16 { mag: 181170, sign: true },
FP16x16 { mag: 22719, sign: true },
FP16x16 { mag: 91746, sign: false },
FP16x16 { mag: 141435, sign: true },
FP16x16 { mag: 123843, sign: true },
]
.span()
}
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/crates/sequential_1_dense_1_matmul_readvariableop_0/src/lib.cairo | use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![9, 18,].span(),
data: array![
FP16x16 { mag: 3955, sign: false },
FP16x16 { mag: 31098, sign: true },
FP16x16 { mag: 56097, sign: false },
FP16x16 { mag: 5925, sign: true },
FP16x16 { mag: 11807, sign: false },
FP16x16 { mag: 14772, sign: true },
FP16x16 { mag: 62093, sign: true },
FP16x16 { mag: 2509, sign: true },
FP16x16 { mag: 78328, sign: false },
FP16x16 { mag: 112161, sign: true },
FP16x16 { mag: 39446, sign: true },
FP16x16 { mag: 75575, sign: true },
FP16x16 { mag: 2793, sign: true },
FP16x16 { mag: 86022, sign: false },
FP16x16 { mag: 2420, sign: true },
FP16x16 { mag: 64022, sign: true },
FP16x16 { mag: 13386, sign: false },
FP16x16 { mag: 36355, sign: true },
FP16x16 { mag: 60754, sign: false },
FP16x16 { mag: 6195, sign: true },
FP16x16 { mag: 32924, sign: false },
FP16x16 { mag: 18469, sign: false },
FP16x16 { mag: 77241, sign: true },
FP16x16 { mag: 41273, sign: false },
FP16x16 { mag: 1430, sign: true },
FP16x16 { mag: 892, sign: true },
FP16x16 { mag: 32289, sign: false },
FP16x16 { mag: 21674, sign: false },
FP16x16 { mag: 88897, sign: true },
FP16x16 { mag: 74800, sign: true },
FP16x16 { mag: 56068, sign: true },
FP16x16 { mag: 16620, sign: false },
FP16x16 { mag: 21513, sign: true },
FP16x16 { mag: 19496, sign: false },
FP16x16 { mag: 61824, sign: false },
FP16x16 { mag: 26766, sign: true },
FP16x16 { mag: 16100, sign: true },
FP16x16 { mag: 33159, sign: false },
FP16x16 { mag: 45269, sign: true },
FP16x16 { mag: 41714, sign: true },
FP16x16 { mag: 4038, sign: true },
FP16x16 { mag: 12259, sign: true },
FP16x16 { mag: 23497, sign: true },
FP16x16 { mag: 2852, sign: true },
FP16x16 { mag: 16666, sign: false },
FP16x16 { mag: 90011, sign: true },
FP16x16 { mag: 89479, sign: true },
FP16x16 { mag: 47499, sign: true },
FP16x16 { mag: 2231, sign: false },
FP16x16 { mag: 42105, sign: true },
FP16x16 { mag: 27305, sign: true },
FP16x16 { mag: 54180, sign: true },
FP16x16 { mag: 24296, sign: true },
FP16x16 { mag: 53924, sign: false },
FP16x16 { mag: 7000, sign: false },
FP16x16 { mag: 4234, sign: true },
FP16x16 { mag: 41393, sign: false },
FP16x16 { mag: 24115, sign: false },
FP16x16 { mag: 18438, sign: false },
FP16x16 { mag: 13772, sign: false },
FP16x16 { mag: 30782, sign: false },
FP16x16 { mag: 1532, sign: false },
FP16x16 { mag: 14289, sign: false },
FP16x16 { mag: 19607, sign: false },
FP16x16 { mag: 44319, sign: false },
FP16x16 { mag: 20825, sign: true },
FP16x16 { mag: 206, sign: false },
FP16x16 { mag: 85743, sign: false },
FP16x16 { mag: 5984, sign: false },
FP16x16 { mag: 28843, sign: true },
FP16x16 { mag: 33272, sign: true },
FP16x16 { mag: 4101, sign: true },
FP16x16 { mag: 10691, sign: true },
FP16x16 { mag: 66566, sign: false },
FP16x16 { mag: 1461, sign: true },
FP16x16 { mag: 64292, sign: true },
FP16x16 { mag: 9889, sign: false },
FP16x16 { mag: 1602, sign: true },
FP16x16 { mag: 79586, sign: false },
FP16x16 { mag: 860, sign: true },
FP16x16 { mag: 16922, sign: true },
FP16x16 { mag: 13655, sign: false },
FP16x16 { mag: 3763, sign: false },
FP16x16 { mag: 13831, sign: false },
FP16x16 { mag: 16606, sign: true },
FP16x16 { mag: 31081, sign: true },
FP16x16 { mag: 1148, sign: true },
FP16x16 { mag: 7401, sign: true },
FP16x16 { mag: 5918, sign: false },
FP16x16 { mag: 172902, sign: true },
FP16x16 { mag: 16803, sign: true },
FP16x16 { mag: 2761, sign: false },
FP16x16 { mag: 60016, sign: true },
FP16x16 { mag: 57641, sign: true },
FP16x16 { mag: 25229, sign: true },
FP16x16 { mag: 409, sign: true },
FP16x16 { mag: 4561, sign: false },
FP16x16 { mag: 2739, sign: true },
FP16x16 { mag: 33103, sign: false },
FP16x16 { mag: 15444, sign: true },
FP16x16 { mag: 2938, sign: true },
FP16x16 { mag: 9677, sign: false },
FP16x16 { mag: 1959, sign: false },
FP16x16 { mag: 48004, sign: true },
FP16x16 { mag: 21527, sign: true },
FP16x16 { mag: 13099, sign: true },
FP16x16 { mag: 4516, sign: true },
FP16x16 { mag: 61344, sign: false },
FP16x16 { mag: 24844, sign: true },
FP16x16 { mag: 20932, sign: false },
FP16x16 { mag: 32461, sign: false },
FP16x16 { mag: 21037, sign: false },
FP16x16 { mag: 3844, sign: true },
FP16x16 { mag: 63076, sign: true },
FP16x16 { mag: 116403, sign: true },
FP16x16 { mag: 47, sign: true },
FP16x16 { mag: 167757, sign: true },
FP16x16 { mag: 33293, sign: false },
FP16x16 { mag: 8474, sign: false },
FP16x16 { mag: 36467, sign: true },
FP16x16 { mag: 5361, sign: false },
FP16x16 { mag: 94574, sign: false },
FP16x16 { mag: 3961, sign: true },
FP16x16 { mag: 20948, sign: false },
FP16x16 { mag: 8617, sign: false },
FP16x16 { mag: 9743, sign: true },
FP16x16 { mag: 67822, sign: false },
FP16x16 { mag: 7211, sign: true },
FP16x16 { mag: 32215, sign: true },
FP16x16 { mag: 18519, sign: false },
FP16x16 { mag: 58230, sign: false },
FP16x16 { mag: 41745, sign: true },
FP16x16 { mag: 8810, sign: true },
FP16x16 { mag: 4189, sign: true },
FP16x16 { mag: 7625, sign: false },
FP16x16 { mag: 17757, sign: false },
FP16x16 { mag: 6851, sign: false },
FP16x16 { mag: 15698, sign: false },
FP16x16 { mag: 68976, sign: true },
FP16x16 { mag: 8665, sign: false },
FP16x16 { mag: 144, sign: false },
FP16x16 { mag: 72523, sign: true },
FP16x16 { mag: 70719, sign: false },
FP16x16 { mag: 21577, sign: true },
FP16x16 { mag: 28121, sign: true },
FP16x16 { mag: 20052, sign: false },
FP16x16 { mag: 46946, sign: true },
FP16x16 { mag: 87657, sign: true },
FP16x16 { mag: 33678, sign: true },
FP16x16 { mag: 48832, sign: true },
FP16x16 { mag: 4698, sign: true },
FP16x16 { mag: 878, sign: true },
FP16x16 { mag: 41781, sign: true },
FP16x16 { mag: 12867, sign: true },
FP16x16 { mag: 1281, sign: true },
FP16x16 { mag: 12234, sign: false },
FP16x16 { mag: 5716, sign: true },
FP16x16 { mag: 48745, sign: true },
FP16x16 { mag: 11140, sign: false },
FP16x16 { mag: 22035, sign: true },
FP16x16 { mag: 9363, sign: true },
FP16x16 { mag: 67049, sign: false },
]
.span()
}
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/crates/sequential_1_dense_2_biasadd_readvariableop_0/src/lib.cairo | use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![9,].span(),
data: array![
FP16x16 {mag: 1241, sign: true}, FP16x16 {mag: 32808, sign: true}, FP16x16 {mag: 5666, sign: false}, FP16x16 {mag: 896, sign: false}, FP16x16 {mag: 12018, sign: false}, FP16x16 {mag: 11826, sign: false}, FP16x16 {mag: 3795, sign: false}, FP16x16 {mag: 13949, sign: false}, FP16x16 {mag: 3218, sign: true}, ].span()
}
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/crates/sequential_1_dense_2_matmul_readvariableop_0/src/lib.cairo | use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![18,9,].span(),
data: array![
FP16x16 {mag: 2465, sign: false}, FP16x16 {mag: 2340, sign: false}, FP16x16 {mag: 32664, sign: true}, FP16x16 {mag: 16005, sign: false}, FP16x16 {mag: 40259, sign: true}, FP16x16 {mag: 37822, sign: true}, FP16x16 {mag: 2872, sign: true}, FP16x16 {mag: 39356, sign: true}, FP16x16 {mag: 1725, sign: true}, FP16x16 {mag: 11180, sign: true}, FP16x16 {mag: 34264, sign: false}, FP16x16 {mag: 6638, sign: false}, FP16x16 {mag: 3478, sign: false}, FP16x16 {mag: 14102, sign: true}, FP16x16 {mag: 12535, sign: true}, FP16x16 {mag: 12001, sign: true}, FP16x16 {mag: 18569, sign: true}, FP16x16 {mag: 22851, sign: true}, FP16x16 {mag: 12523, sign: false}, FP16x16 {mag: 26931, sign: false}, FP16x16 {mag: 3529, sign: true}, FP16x16 {mag: 13909, sign: true}, FP16x16 {mag: 23747, sign: false}, FP16x16 {mag: 29669, sign: false}, FP16x16 {mag: 14539, sign: false}, FP16x16 {mag: 27740, sign: false}, FP16x16 {mag: 18385, sign: false}, FP16x16 {mag: 30201, sign: true}, FP16x16 {mag: 13759, sign: true}, FP16x16 {mag: 11985, sign: true}, FP16x16 {mag: 71619, sign: false}, FP16x16 {mag: 19944, sign: false}, FP16x16 {mag: 4239, sign: false}, FP16x16 {mag: 33485, sign: true}, FP16x16 {mag: 6481, sign: true}, FP16x16 {mag: 33629, sign: true}, FP16x16 {mag: 2260, sign: false}, FP16x16 {mag: 6532, sign: true}, FP16x16 {mag: 5292, sign: true}, FP16x16 {mag: 24375, sign: false}, FP16x16 {mag: 13574, sign: false}, FP16x16 {mag: 8645, sign: false}, FP16x16 {mag: 7671, sign: false}, FP16x16 {mag: 14861, sign: false}, FP16x16 {mag: 12084, sign: false}, FP16x16 {mag: 7675, sign: true}, FP16x16 {mag: 4015, sign: true}, FP16x16 {mag: 22250, sign: true}, FP16x16 {mag: 15436, sign: true}, FP16x16 {mag: 28003, sign: false}, FP16x16 {mag: 18767, sign: false}, FP16x16 {mag: 6382, sign: true}, FP16x16 {mag: 31147, sign: false}, FP16x16 {mag: 5390, sign: false}, FP16x16 {mag: 17990, sign: false}, FP16x16 {mag: 39474, sign: false}, FP16x16 {mag: 9985, sign: false}, FP16x16 {mag: 33327, sign: true}, FP16x16 {mag: 29900, sign: true}, FP16x16 {mag: 23978, sign: true}, FP16x16 {mag: 9985, sign: false}, FP16x16 {mag: 12197, sign: true}, FP16x16 {mag: 7435, sign: true}, FP16x16 {mag: 639, sign: false}, FP16x16 {mag: 2532, sign: true}, FP16x16 {mag: 5910, sign: false}, FP16x16 {mag: 2848, sign: false}, FP16x16 {mag: 4306, sign: false}, FP16x16 {mag: 1856, sign: true}, FP16x16 {mag: 1251, sign: true}, FP16x16 {mag: 1589, sign: true}, FP16x16 {mag: 2191, sign: true}, FP16x16 {mag: 1067, sign: false}, FP16x16 {mag: 37203, sign: true}, FP16x16 {mag: 4686, sign: false}, FP16x16 {mag: 40127, sign: true}, FP16x16 {mag: 33823, sign: true}, FP16x16 {mag: 23325, sign: true}, FP16x16 {mag: 35514, sign: false}, FP16x16 {mag: 2639, sign: true}, FP16x16 {mag: 46695, sign: false}, FP16x16 {mag: 49480, sign: false}, FP16x16 {mag: 24483, sign: true}, FP16x16 {mag: 2421, sign: true}, FP16x16 {mag: 22600, sign: true}, FP16x16 {mag: 10720, sign: false}, FP16x16 {mag: 5655, sign: false}, FP16x16 {mag: 36440, sign: false}, FP16x16 {mag: 7469, sign: false}, FP16x16 {mag: 37046, sign: false}, FP16x16 {mag: 32540, sign: true}, FP16x16 {mag: 23355, sign: true}, FP16x16 {mag: 18911, sign: true}, FP16x16 {mag: 19967, sign: false}, FP16x16 {mag: 7995, sign: false}, FP16x16 {mag: 2876, sign: false}, FP16x16 {mag: 28494, sign: true}, FP16x16 {mag: 3640, sign: false}, FP16x16 {mag: 55301, sign: true}, FP16x16 {mag: 19263, sign: true}, FP16x16 {mag: 28503, sign: true}, FP16x16 {mag: 20567, sign: true}, FP16x16 {mag: 19075, sign: false}, FP16x16 {mag: 12334, sign: false}, FP16x16 {mag: 9320, sign: false}, FP16x16 {mag: 302, sign: true}, FP16x16 {mag: 8293, sign: false}, FP16x16 {mag: 48929, sign: true}, FP16x16 {mag: 9371, sign: true}, FP16x16 {mag: 7195, sign: false}, FP16x16 {mag: 9507, sign: true}, FP16x16 {mag: 27072, sign: true}, FP16x16 {mag: 31023, sign: false}, FP16x16 {mag: 28161, sign: false}, FP16x16 {mag: 15273, sign: true}, FP16x16 {mag: 27178, sign: false}, FP16x16 {mag: 7702, sign: true}, FP16x16 {mag: 11518, sign: false}, FP16x16 {mag: 10741, sign: false}, FP16x16 {mag: 20454, sign: false}, FP16x16 {mag: 26801, sign: true}, FP16x16 {mag: 27046, sign: true}, FP16x16 {mag: 24313, sign: true}, FP16x16 {mag: 14909, sign: false}, FP16x16 {mag: 28354, sign: true}, FP16x16 {mag: 17081, sign: false}, FP16x16 {mag: 7418, sign: false}, FP16x16 {mag: 25151, sign: false}, FP16x16 {mag: 8309, sign: false}, FP16x16 {mag: 4019, sign: false}, FP16x16 {mag: 16244, sign: true}, FP16x16 {mag: 981, sign: true}, FP16x16 {mag: 306, sign: true}, FP16x16 {mag: 3737, sign: false}, FP16x16 {mag: 6126, sign: false}, FP16x16 {mag: 12213, sign: true}, FP16x16 {mag: 38450, sign: true}, FP16x16 {mag: 22926, sign: true}, FP16x16 {mag: 5183, sign: true}, FP16x16 {mag: 32450, sign: true}, FP16x16 {mag: 30705, sign: true}, FP16x16 {mag: 43870, sign: true}, FP16x16 {mag: 26190, sign: true}, FP16x16 {mag: 54292, sign: true}, FP16x16 {mag: 3506, sign: true}, FP16x16 {mag: 12819, sign: false}, FP16x16 {mag: 46049, sign: true}, FP16x16 {mag: 241, sign: true}, FP16x16 {mag: 64050, sign: true}, FP16x16 {mag: 50948, sign: true}, FP16x16 {mag: 1238, sign: true}, FP16x16 {mag: 52562, sign: true}, FP16x16 {mag: 2508, sign: false}, FP16x16 {mag: 46211, sign: false}, FP16x16 {mag: 7648, sign: true}, FP16x16 {mag: 43005, sign: false}, FP16x16 {mag: 24333, sign: true}, FP16x16 {mag: 20222, sign: true}, FP16x16 {mag: 18892, sign: true}, FP16x16 {mag: 34596, sign: false}, FP16x16 {mag: 16295, sign: true}, FP16x16 {mag: 5455, sign: true}, ].span()
}
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/crates/sequential_1_dense_3_biasadd_readvariableop_0/src/lib.cairo | use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![1,].span(),
data: array![
FP16x16 {mag: 17046, sign: false}, ].span()
}
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/crates/sequential_1_dense_3_matmul_readvariableop_0/src/lib.cairo | use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![9,1,].span(),
data: array![
FP16x16 {mag: 15010, sign: true}, FP16x16 {mag: 27195, sign: true}, FP16x16 {mag: 36261, sign: true}, FP16x16 {mag: 26590, sign: false}, FP16x16 {mag: 23070, sign: false}, FP16x16 {mag: 29654, sign: false}, FP16x16 {mag: 25429, sign: true}, FP16x16 {mag: 28541, sign: false}, FP16x16 {mag: 27150, sign: true}, ].span()
}
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/src/inference.cairo | #[starknet::contract]
mod OrionRunner {
use core::array::SpanTrait;
use orion::operators::tensor::{TensorTrait, FP16x16Tensor, Tensor, FP16x16TensorAdd};
use orion::operators::nn::{NNTrait, FP16x16NN};
use orion::numbers::{FP16x16, FixedTrait};
use sequential_1_dense_1_matmul_readvariableop_0::tensor as t1;
use sequential_1_dense_1_biasadd_readvariableop_0::tensor as t2;
use sequential_1_dense_2_matmul_readvariableop_0::tensor as t3;
use sequential_1_dense_2_biasadd_readvariableop_0::tensor as t4;
use sequential_1_dense_3_matmul_readvariableop_0::tensor as t5;
use sequential_1_dense_3_biasadd_readvariableop_0::tensor as t6;
#[storage]
struct Storage {
id: u8,
}
#[external(v0)]
fn predict(self: @ContractState, mut x: Tensor<FP16x16>) -> FP16x16 {
// let two = FixedTrait::<FP16x16>::new_unscaled(2, false);
// let mut x = Tensor {
// shape: array![9].span(),
// data: array![two, two, two, two, two, two, two, two, two].span()
// };
// DENSE 1
x = TensorTrait::matmul(@x, @t1());
x = x + t2();
x = NNTrait::relu(@x);
// DENSE 2
x = TensorTrait::matmul(@x, @t3());
x = x + t4();
x = NNTrait::relu(@x);
// DENSE 3
x = TensorTrait::matmul(@x, @t5());
x = x + t6();
return *x.data.at(0);
}
}
| https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/src/lib.cairo | mod inference;
mod test; | https://github.com/gizatechxyz/Giza-Hub |
awesome-orion/gaming/tic_tac_toe/tic_tac_toe_orion/src/test.cairo | #[cfg(test)]
mod tests {
use core::array::SpanTrait;
use orion::operators::tensor::{TensorTrait, FP16x16Tensor, Tensor, FP16x16TensorAdd};
use orion::operators::nn::{NNTrait, FP16x16NN};
use orion::numbers::{FP16x16, FixedTrait};
use sequential_1_dense_1_matmul_readvariableop_0::tensor as _sequential_1_dense_1_matmul_readvariableop_0;
use sequential_1_dense_1_biasadd_readvariableop_0::tensor as _sequential_1_dense_1_biasadd_readvariableop_0;
use sequential_1_dense_2_matmul_readvariableop_0::tensor as _sequential_1_dense_2_matmul_readvariableop_0;
use sequential_1_dense_2_biasadd_readvariableop_0::tensor as _sequential_1_dense_2_biasadd_readvariableop_0;
use sequential_1_dense_3_matmul_readvariableop_0::tensor as _sequential_1_dense_3_matmul_readvariableop_0;
use sequential_1_dense_3_biasadd_readvariableop_0::tensor as _sequential_1_dense_3_biasadd_readvariableop_0;
use debug::PrintTrait;
#[test]
#[available_gas(2000000000000)]
fn _main() {
let two = FixedTrait::<FP16x16>::new_unscaled(2, false);
let mut x = Tensor {
shape: array![9].span(),
data: array![two, two, two, two, two, two, two, two, two].span()
};
// DENSE 1
x = TensorTrait::matmul(@x, @_sequential_1_dense_1_matmul_readvariableop_0());
x = x + _sequential_1_dense_1_biasadd_readvariableop_0();
x = NNTrait::relu(@x);
// DENSE 2
x = TensorTrait::matmul(@x, @_sequential_1_dense_2_matmul_readvariableop_0());
x = x + _sequential_1_dense_2_biasadd_readvariableop_0();
x = NNTrait::relu(@x);
// DENSE 3
x = TensorTrait::matmul(@x, @_sequential_1_dense_3_matmul_readvariableop_0());
x = x + _sequential_1_dense_3_biasadd_readvariableop_0();
(*x.data.at(0)).print();
}
}
| https://github.com/gizatechxyz/Giza-Hub |
benches/accum_conv.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_keys;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::srs::gen_srs;
use ezkl::pfsys::TranscriptType;
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
static mut KERNEL_HEIGHT: usize = 2;
static mut KERNEL_WIDTH: usize = 2;
static mut OUT_CHANNELS: usize = 1;
static mut IMAGE_HEIGHT: usize = 2;
static mut IMAGE_WIDTH: usize = 2;
static mut IN_CHANNELS: usize = 1;
const K: usize = 17;
#[derive(Clone, Debug)]
struct MyCircuit {
image: ValTensor<Fr>,
kernel: ValTensor<Fr>,
bias: ValTensor<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = 10;
let a = VarTensor::new_advice(cs, K, 1, len * len);
let b = VarTensor::new_advice(cs, K, 1, len * len);
let output = VarTensor::new_advice(cs, K, 1, (len + 1) * len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&[self.image.clone(), self.kernel.clone(), self.bias.clone()],
Box::new(PolyOp::Conv {
padding: vec![(0, 0)],
stride: vec![1; 2],
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runcnvrl(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_conv");
let params = gen_srs::<KZGCommitmentScheme<_>>(K as u32);
for size in [1, 2, 4].iter() {
unsafe {
KERNEL_HEIGHT = size * 2;
KERNEL_WIDTH = size * 2;
IMAGE_HEIGHT = size * 4;
IMAGE_WIDTH = size * 4;
IN_CHANNELS = 1;
OUT_CHANNELS = 1;
let mut image = Tensor::from(
(0..IN_CHANNELS * IMAGE_HEIGHT * IMAGE_WIDTH)
.map(|_| Value::known(Fr::random(OsRng))),
);
image
.reshape(&[1, IN_CHANNELS, IMAGE_HEIGHT, IMAGE_WIDTH])
.unwrap();
let mut kernel = Tensor::from(
(0..{ OUT_CHANNELS * IN_CHANNELS * KERNEL_HEIGHT * KERNEL_WIDTH })
.map(|_| Fr::random(OsRng)),
);
kernel
.reshape(&[OUT_CHANNELS, IN_CHANNELS, KERNEL_HEIGHT, KERNEL_WIDTH])
.unwrap();
kernel.set_visibility(&ezkl::graph::Visibility::Private);
let mut bias = Tensor::from((0..{ OUT_CHANNELS }).map(|_| Fr::random(OsRng)));
bias.set_visibility(&ezkl::graph::Visibility::Private);
let circuit = MyCircuit {
image: ValTensor::from(image),
kernel: ValTensor::try_from(kernel).unwrap(),
bias: ValTensor::try_from(bias).unwrap(),
};
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runcnvrl
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/accum_dot.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16;
#[derive(Clone)]
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&self.inputs,
Box::new(PolyOp::Einsum {
equation: "i,i->".to_string(),
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn rundot(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_dot");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
// parameters
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let b = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = rundot
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/accum_einsum_matmul.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16;
#[derive(Clone)]
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len * len);
let b = VarTensor::new_advice(cs, K, 1, len * len);
let output = VarTensor::new_advice(cs, K, 1, (len + 1) * len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&self.inputs,
Box::new(PolyOp::Einsum {
equation: "ab,bc->ac".to_string(),
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runmatmul(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_einsum_matmul");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [4, 32].iter() {
unsafe {
LEN = len;
};
let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
a.reshape(&[len, len]).unwrap();
// parameters
let mut b = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
b.reshape(&[len, len]).unwrap();
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runmatmul
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/accum_matmul_relu.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::table::Range;
use ezkl::circuit::*;
use ezkl::circuit::lookup::LookupOp;
use ezkl::circuit::poly::PolyOp;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
const BITS: Range = (-32768, 32768);
static mut LEN: usize = 4;
const K: usize = 16;
#[derive(Clone)]
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
// A columnar ReLu MLP
#[derive(Clone)]
struct MyConfig {
base_config: BaseConfig<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = MyConfig;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
let mut base_config =
BaseConfig::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::UNSAFE);
// sets up a new relu table
base_config
.configure_lookup(cs, &b, &output, &a, BITS, K, &LookupOp::ReLU)
.unwrap();
MyConfig { base_config }
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
config.base_config.layout_tables(&mut layouter).unwrap();
layouter.assign_region(
|| "",
|region| {
let op = PolyOp::Einsum {
equation: "ij,jk->ik".to_string(),
};
let mut region = region::RegionCtx::new(region, 0, 1);
let output = config
.base_config
.layout(&mut region, &self.inputs, Box::new(op))
.unwrap();
let _output = config
.base_config
.layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runmatmul(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_matmul");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [4, 32].iter() {
unsafe {
LEN = len;
};
let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::from(1))));
a.reshape(&[len, len]).unwrap();
// parameters
let mut b = Tensor::from((0..len).map(|_| Value::known(Fr::from(1))));
b.reshape(&[len, 1]).unwrap();
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runmatmul
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/accum_matmul_relu_overflow.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::*;
use ezkl::circuit::lookup::LookupOp;
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::table::Range;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
const BITS: Range = (-8180, 8180);
static mut LEN: usize = 4;
static mut K: usize = 16;
#[derive(Clone)]
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
// A columnar ReLu MLP
#[derive(Clone)]
struct MyConfig {
base_config: BaseConfig<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = MyConfig;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let k = unsafe { K };
let a = VarTensor::new_advice(cs, k, 1, len);
let b = VarTensor::new_advice(cs, k, 1, len);
let output = VarTensor::new_advice(cs, k, 1, len);
let mut base_config =
BaseConfig::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::UNSAFE);
// sets up a new relu table
base_config
.configure_lookup(cs, &b, &output, &a, BITS, k, &LookupOp::ReLU)
.unwrap();
MyConfig { base_config }
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
config.base_config.layout_tables(&mut layouter).unwrap();
layouter.assign_region(
|| "",
|region| {
let op = PolyOp::Einsum {
equation: "ij,jk->ik".to_string(),
};
let mut region = region::RegionCtx::new(region, 0, 1);
let output = config
.base_config
.layout(&mut region, &self.inputs, Box::new(op))
.unwrap();
let _output = config
.base_config
.layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runmatmul(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_matmul");
for &k in [8, 10, 11, 12, 13, 14].iter() {
let len = unsafe { LEN };
unsafe {
K = k;
};
let params = gen_srs::<KZGCommitmentScheme<_>>(k as u32);
let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::from(1))));
a.reshape(&[len, len]).unwrap();
// parameters
let mut b = Tensor::from((0..len).map(|_| Value::known(Fr::from(1))));
b.reshape(&[len, 1]).unwrap();
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("pk", k), &k, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("prove", k), &k, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots().sample_size(10);
targets = runmatmul
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/accum_sum.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16;
#[derive(Clone)]
struct MyCircuit {
inputs: [ValTensor<Fr>; 1],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&self.inputs,
Box::new(PolyOp::Sum { axes: vec![0] }),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runsum(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_sum");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
// parameters
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runsum
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/accum_sumpool.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::hybrid::HybridOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_keys;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::srs::gen_srs;
use ezkl::pfsys::TranscriptType;
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
static mut IMAGE_HEIGHT: usize = 2;
static mut IMAGE_WIDTH: usize = 2;
static mut IN_CHANNELS: usize = 3;
const K: usize = 17;
#[derive(Clone, Debug)]
struct MyCircuit {
image: ValTensor<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = 10;
let a = VarTensor::new_advice(cs, K, 1, len * len);
let b = VarTensor::new_advice(cs, K, 1, len * len);
let output = VarTensor::new_advice(cs, K, 1, (len + 1) * len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&[self.image.clone()],
Box::new(HybridOp::SumPool {
padding: vec![(0, 0); 2],
stride: vec![1, 1],
kernel_shape: vec![2, 2],
normalized: false,
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runsumpool(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_sumpool");
let params = gen_srs::<KZGCommitmentScheme<_>>(K as u32);
for size in [1, 2].iter() {
unsafe {
IMAGE_HEIGHT = size * 4;
IMAGE_WIDTH = size * 4;
let mut image = Tensor::from(
(0..IN_CHANNELS * IMAGE_HEIGHT * IMAGE_WIDTH)
.map(|_| Value::known(Fr::random(OsRng))),
);
image
.reshape(&[1, IN_CHANNELS, IMAGE_HEIGHT, IMAGE_WIDTH])
.unwrap();
let circuit = MyCircuit {
image: ValTensor::from(image),
};
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runsumpool
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/pairwise_add.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16;
#[derive(Clone)]
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(&mut region, &self.inputs, Box::new(PolyOp::Add))
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runadd(c: &mut Criterion) {
let mut group = c.benchmark_group("pairwise_add");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
// parameters
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let b = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runadd
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/pairwise_pow.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::region::RegionCtx;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16;
#[derive(Clone)]
struct MyCircuit {
inputs: [ValTensor<Fr>; 1],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::SAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = RegionCtx::new(region, 0, 1);
config
.layout(&mut region, &self.inputs, Box::new(PolyOp::Pow(4)))
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runpow(c: &mut Criterion) {
let mut group = c.benchmark_group("pairwise_pow");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
// parameters
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runpow
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/poseidon.rs | use std::collections::HashMap;
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
use ezkl::circuit::modules::poseidon::{PoseidonChip, PoseidonConfig};
use ezkl::circuit::modules::Module;
use ezkl::circuit::*;
use ezkl::pfsys::create_keys;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::srs::gen_srs;
use ezkl::pfsys::TranscriptType;
use ezkl::tensor::*;
use halo2_proofs::circuit::Value;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
const L: usize = 10;
#[derive(Clone, Debug)]
struct MyCircuit {
image: ValTensor<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = PoseidonConfig<POSEIDON_WIDTH, POSEIDON_RATE>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, 10>::configure(cs, ())
}
fn synthesize(
&self,
config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
let chip: PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L> =
PoseidonChip::new(config);
chip.layout(&mut layouter, &[self.image.clone()], 0, &mut HashMap::new())?;
Ok(())
}
}
fn runposeidon(c: &mut Criterion) {
let mut group = c.benchmark_group("poseidon");
for size in [64, 784, 2352, 12288].iter() {
let k = (PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::num_rows(*size)
as f32)
.log2()
.ceil() as u32;
let params = gen_srs::<KZGCommitmentScheme<_>>(k);
let message = (0..*size).map(|_| Fr::random(OsRng)).collect::<Vec<_>>();
let _output =
PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::run(message.to_vec())
.unwrap();
let mut image = Tensor::from(message.into_iter().map(Value::known));
image.reshape(&[1, *size]).unwrap();
let circuit = MyCircuit {
image: ValTensor::from(image),
};
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots().sample_size(10);
targets = runposeidon
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
benches/relu.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::region::RegionCtx;
use ezkl::circuit::table::Range;
use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::Rng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
const BITS: Range = (-32768, 32768);
static mut LEN: usize = 4;
const K: usize = 16;
#[derive(Clone)]
struct NLCircuit {
pub input: ValTensor<Fr>,
}
impl Circuit<Fr> for NLCircuit {
type Config = Config<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
unsafe {
let advices = (0..3)
.map(|_| VarTensor::new_advice(cs, K, 1, LEN))
.collect::<Vec<_>>();
let nl = LookupOp::ReLU;
let mut config = Config::default();
config
.configure_lookup(cs, &advices[0], &advices[1], &advices[2], BITS, K, &nl)
.unwrap();
config
}
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>, // layouter is our 'write buffer' for the circuit
) -> Result<(), Error> {
config.layout_tables(&mut layouter).unwrap();
layouter.assign_region(
|| "",
|region| {
let mut region = RegionCtx::new(region, 0, 1);
config
.layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
.unwrap();
Ok(())
},
)?;
Ok(())
}
}
fn runrelu(c: &mut Criterion) {
let mut group = c.benchmark_group("relu");
let mut rng = rand::thread_rng();
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [4, 8].iter() {
unsafe {
LEN = len;
};
let input: Tensor<Value<Fr>> =
Tensor::<i32>::from((0..len).map(|_| rng.gen_range(0..10))).into();
let circuit = NLCircuit {
input: ValTensor::from(input.clone()),
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
NLCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runrelu
}
criterion_main!(benches);
| https://github.com/zkonduit/ezkl |
contracts/AttestData.sol | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import './LoadInstances.sol';
// This contract serves as a Data Attestation Verifier for the EZKL model.
// It is designed to read and attest to instances of proofs generated from a specified circuit.
// It is particularly constructed to read only int256 data from specified on-chain contracts' view functions.
// Overview of the contract functionality:
// 1. Initialization: Through the constructor, it sets up the contract calls that the EZKL model will read from.
// 2. Data Quantization: Quantizes the returned data into a scaled fixed-point representation. See the `quantizeData` method for details.
// 3. Static Calls: Makes static calls to fetch data from other contracts. See the `staticCall` method.
// 4. Field Element Conversion: The fixed-point representation is then converted into a field element modulo P using the `toFieldElement` method.
// 5. Data Attestation: The `attestData` method validates that the public instances match the data fetched and processed by the contract.
// 6. Proof Verification: The `verifyWithDataAttestation` method parses the instances out of the encoded calldata and calls the `attestData` method to validate the public instances,
// then calls the `verifyProof` method to verify the proof on the verifier.
contract DataAttestation is LoadInstances {
/**
* @notice Struct used to make view only calls to accounts to fetch the data that EZKL reads from.
* @param the address of the account to make calls to
* @param the abi encoded function calls to make to the `contractAddress`
*/
struct AccountCall {
address contractAddress;
mapping(uint256 => bytes) callData;
mapping(uint256 => uint256) decimals;
uint callCount;
}
AccountCall[] public accountCalls;
uint[] public scales;
address public admin;
/**
* @notice EZKL P value
* @dev In order to prevent the verifier from accepting two version of the same pubInput, n and the quantity (n + P), where n + P <= 2^256, we require that all instances are stricly less than P. a
* @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
*/
uint256 constant ORDER = uint256(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001);
uint256 constant INPUT_CALLS = 0;
uint256 constant OUTPUT_CALLS = 0;
uint8 public instanceOffset;
/**
* @dev Initialize the contract with account calls the EZKL model will read from.
* @param _contractAddresses - The calls to all the contracts EZKL reads storage from.
* @param _callData - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
*/
constructor(
address[] memory _contractAddresses,
bytes[][] memory _callData,
uint256[][] memory _decimals,
uint[] memory _scales,
uint8 _instanceOffset,
address _admin
) {
admin = _admin;
for (uint i; i < _scales.length; i++) {
scales.push(1 << _scales[i]);
}
populateAccountCalls(_contractAddresses, _callData, _decimals);
instanceOffset = _instanceOffset;
}
function updateAdmin(address _admin) external {
require(msg.sender == admin, "Only admin can update admin");
if(_admin == address(0)) {
revert();
}
admin = _admin;
}
function updateAccountCalls(
address[] memory _contractAddresses,
bytes[][] memory _callData,
uint256[][] memory _decimals
) external {
require(msg.sender == admin, "Only admin can update instanceOffset");
populateAccountCalls(_contractAddresses, _callData, _decimals);
}
function populateAccountCalls(
address[] memory _contractAddresses,
bytes[][] memory _callData,
uint256[][] memory _decimals
) internal {
require(
_contractAddresses.length == _callData.length &&
accountCalls.length == _contractAddresses.length,
"Invalid input length"
);
require(
_decimals.length == _contractAddresses.length,
"Invalid number of decimals"
);
// fill in the accountCalls storage array
uint counter = 0;
for (uint256 i = 0; i < _contractAddresses.length; i++) {
AccountCall storage accountCall = accountCalls[i];
accountCall.contractAddress = _contractAddresses[i];
accountCall.callCount = _callData[i].length;
for (uint256 j = 0; j < _callData[i].length; j++) {
accountCall.callData[j] = _callData[i][j];
accountCall.decimals[j] = 10 ** _decimals[i][j];
}
// count the total number of storage reads across all of the accounts
counter += _callData[i].length;
}
require(counter == INPUT_CALLS + OUTPUT_CALLS, "Invalid number of calls");
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
/**
* @dev Quantize the data returned from the account calls to the scale used by the EZKL model.
* @param data - The data returned from the account calls.
* @param decimals - The number of decimals the data returned from the account calls has (for floating point representation).
* @param scale - The scale used to convert the floating point value into a fixed point value.
*/
function quantizeData(
bytes memory data,
uint256 decimals,
uint256 scale
) internal pure returns (int256 quantized_data) {
int x = abi.decode(data, (int256));
bool neg = x < 0;
if (neg) x = -x;
uint output = mulDiv(uint256(x), scale, decimals);
if (mulmod(uint256(x), scale, decimals) * 2 >= decimals) {
output += 1;
}
quantized_data = neg ? -int256(output): int256(output);
}
/**
* @dev Make a static call to the account to fetch the data that EZKL reads from.
* @param target - The address of the account to make calls to.
* @param data - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
* @return The data returned from the account calls. (Must come from either a view or pure function. Will throw an error otherwise)
*/
function staticCall(
address target,
bytes memory data
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
if (success) {
if (returndata.length == 0) {
require(
target.code.length > 0,
"Address: call to non-contract"
);
}
return returndata;
} else {
revert("Address: low-level call failed");
}
}
/**
* @dev Convert the fixed point quantized data into a field element.
* @param x - The quantized data.
* @return field_element - The field element.
*/
function toFieldElement(int256 x) internal pure returns (uint256 field_element) {
// The casting down to uint256 is safe because the order is about 2^254, and the value
// of x ranges of -2^127 to 2^127, so x + int(ORDER) is always positive.
return uint256(x + int(ORDER)) % ORDER;
}
/**
* @dev Make the account calls to fetch the data that EZKL reads from and attest to the data.
* @param instances - The public instances to the proof (the data in the proof that publicly accessible to the verifier).
*/
function attestData(uint256[] memory instances) internal view {
require(
instances.length >= INPUT_CALLS + OUTPUT_CALLS,
"Invalid public inputs length"
);
uint256 _accountCount = accountCalls.length;
uint counter = 0;
for (uint8 i = 0; i < _accountCount; ++i) {
address account = accountCalls[i].contractAddress;
for (uint8 j = 0; j < accountCalls[i].callCount; j++) {
bytes memory returnData = staticCall(
account,
accountCalls[i].callData[j]
);
uint256 scale = scales[counter];
int256 quantized_data = quantizeData(
returnData,
accountCalls[i].decimals[j],
scale
);
uint256 field_element = toFieldElement(quantized_data);
require(
field_element == instances[counter + instanceOffset],
"Public input does not match"
);
counter++;
}
}
}
function verifyWithDataAttestation(
address verifier,
bytes calldata encoded
) public view returns (bool) {
require(verifier.code.length > 0,"Address: call to non-contract");
attestData(getInstancesCalldata(encoded));
// static call the verifier contract to verify the proof
(bool success, bytes memory returndata) = verifier.staticcall(encoded);
if (success) {
return abi.decode(returndata, (bool));
} else {
revert("low-level call to verifier failed");
}
}
}
| https://github.com/zkonduit/ezkl |
contracts/LoadInstances.sol | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract LoadInstances {
/**
* @dev Parse the instances array from the Halo2Verifier encoded calldata.
* @notice must pass encoded bytes from memory
* @param encoded - verifier calldata
*/
function getInstancesMemory(
bytes memory encoded
) internal pure returns (uint256[] memory instances) {
bytes4 funcSig;
uint256 instances_offset;
uint256 instances_length;
assembly {
// fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
funcSig := mload(add(encoded, 0x20))
// Fetch instances offset which is 4 + 32 + 32 bytes away from
// start of encoded for `verifyProof(bytes,uint256[])`,
// and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
instances_offset := mload(
add(encoded, add(0x44, mul(0x20, eq(funcSig, 0xaf83a18d))))
)
instances_length := mload(add(add(encoded, 0x24), instances_offset))
}
instances = new uint256[](instances_length); // Allocate memory for the instances array.
assembly {
// Now instances points to the start of the array data
// (right after the length field).
for {
let i := 0x20
} lt(i, add(mul(instances_length, 0x20), 0x20)) {
i := add(i, 0x20)
} {
mstore(
add(instances, i),
mload(add(add(encoded, add(i, 0x24)), instances_offset))
)
}
}
}
/**
* @dev Parse the instances array from the Halo2Verifier encoded calldata.
* @notice must pass encoded bytes from calldata
* @param encoded - verifier calldata
*/
function getInstancesCalldata(
bytes calldata encoded
) internal pure returns (uint256[] memory instances) {
bytes4 funcSig;
uint256 instances_offset;
uint256 instances_length;
assembly {
// fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
funcSig := calldataload(encoded.offset)
// Fetch instances offset which is 4 + 32 + 32 bytes away from
// start of encoded for `verifyProof(bytes,uint256[])`,
// and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
instances_offset := calldataload(
add(
encoded.offset,
add(0x24, mul(0x20, eq(funcSig, 0xaf83a18d)))
)
)
instances_length := calldataload(add(add(encoded.offset, 0x04), instances_offset))
}
instances = new uint256[](instances_length); // Allocate memory for the instances array.
assembly{
// Now instances points to the start of the array data
// (right after the length field).
for {
let i := 0x20
} lt(i, add(mul(instances_length, 0x20), 0x20)) {
i := add(i, 0x20)
} {
mstore(
add(instances, i),
calldataload(
add(add(encoded.offset, add(i, 0x04)), instances_offset)
)
)
}
}
}
} | https://github.com/zkonduit/ezkl |
contracts/QuantizeData.sol | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
contract QuantizeData {
/**
* @notice EZKL P value
* @dev In order to prevent the verifier from accepting two version of the same instance, n and the quantity (n + P), where n + P <= 2^256, we require that all instances are stricly less than P. a
* @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
*/
uint256 constant ORDER =
uint256(
0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
);
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function quantize_data(
bytes[] memory data,
uint256[] memory decimals,
uint256[] memory scales
) external pure returns (int256[] memory quantized_data) {
quantized_data = new int256[](data.length);
for (uint i; i < data.length; i++) {
int x = abi.decode(data[i], (int256));
bool neg = x < 0;
if (neg) x = -x;
uint denom = 10 ** decimals[i];
uint scale = 1 << scales[i];
uint output = mulDiv(uint256(x), scale, denom);
if (mulmod(uint256(x), scale, denom) * 2 >= denom) {
output += 1;
}
quantized_data[i] = neg ? -int256(output) : int256(output);
}
}
function to_field_element(
int128[] memory quantized_data
) public pure returns (uint256[] memory output) {
output = new uint256[](quantized_data.length);
for (uint i; i < quantized_data.length; i++) {
output[i] = uint256(quantized_data[i] + int(ORDER)) % ORDER;
}
}
}
| https://github.com/zkonduit/ezkl |
contracts/TestReads.sol | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
contract TestReads {
int[] public arr;
constructor(int256[] memory _numbers) {
for (uint256 i = 0; i < _numbers.length; i++) {
arr.push(_numbers[i]);
}
}
}
| https://github.com/zkonduit/ezkl |
docs/python/src/conf.py | import ezkl
project = 'ezkl'
release = '0.0.0'
version = release
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.autosummary',
'sphinx.ext.intersphinx',
'sphinx.ext.todo',
'sphinx.ext.inheritance_diagram',
'sphinx.ext.autosectionlabel',
'sphinx.ext.napoleon',
'sphinx_rtd_theme',
]
autosummary_generate = True
autosummary_imported_members = True
templates_path = ['_templates']
exclude_patterns = []
# -- Options for HTML output -------------------------------------------------
# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
html_theme = 'sphinx_rtd_theme'
html_static_path = ['_static'] | https://github.com/zkonduit/ezkl |
examples/conv2d_mnist/main.rs | use ezkl::circuit::region::RegionCtx;
use ezkl::circuit::{
ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
};
use ezkl::fieldutils;
use ezkl::fieldutils::i32_to_felt;
use ezkl::tensor::*;
use halo2_proofs::dev::MockProver;
use halo2_proofs::poly::commitment::Params;
use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{
create_proof, keygen_pk, keygen_vk, verify_proof, Circuit, Column, ConstraintSystem, Error,
Instance,
},
poly::{
commitment::ParamsProver,
kzg::{
commitment::{KZGCommitmentScheme, ParamsKZG},
strategy::SingleStrategy,
},
},
transcript::{
Blake2bRead, Blake2bWrite, Challenge255, TranscriptReadBuffer, TranscriptWriterBuffer,
},
};
use halo2curves::bn256::Bn256;
use halo2curves::bn256::Fr as F;
use instant::Instant;
use mnist::*;
use rand::rngs::OsRng;
use std::marker::PhantomData;
mod params;
const K: usize = 20;
const NUM_INNER_COLS: usize = 1;
#[derive(Clone)]
struct Config<
const LEN: usize, //LEN = CHOUT x OH x OW flattened //not supported yet in rust stable
const CLASSES: usize,
const LOOKUP_MIN: i128,
const LOOKUP_MAX: i128,
// Convolution
const KERNEL_HEIGHT: usize,
const KERNEL_WIDTH: usize,
const OUT_CHANNELS: usize,
const STRIDE: usize,
const IMAGE_HEIGHT: usize,
const IMAGE_WIDTH: usize,
const IN_CHANNELS: usize,
const PADDING: usize,
> where
Value<F>: TensorType,
{
// this will be a conv layer
layer_config: PolyConfig<F>,
// this will be an affine layer
public_output: Column<Instance>,
}
#[derive(Clone)]
struct MyCircuit<
const LEN: usize, //LEN = CHOUT x OH x OW flattened
const CLASSES: usize,
const LOOKUP_MIN: i128,
const LOOKUP_MAX: i128,
// Convolution
const KERNEL_HEIGHT: usize,
const KERNEL_WIDTH: usize,
const OUT_CHANNELS: usize,
const STRIDE: usize,
const IMAGE_HEIGHT: usize,
const IMAGE_WIDTH: usize,
const IN_CHANNELS: usize,
const PADDING: usize,
> where
Value<F>: TensorType,
{
// Given the stateless ConvConfig type information, a DNN trace is determined by its input and the parameters of its layers.
// Computing the trace still requires a forward pass. The intermediate activations are stored only by the layouter.
input: ValTensor<F>,
l0_params: [ValTensor<F>; 2],
l2_params: [ValTensor<F>; 2],
}
impl<
const LEN: usize,
const CLASSES: usize,
const LOOKUP_MIN: i128,
const LOOKUP_MAX: i128,
// Convolution
const KERNEL_HEIGHT: usize,
const KERNEL_WIDTH: usize,
const OUT_CHANNELS: usize,
const STRIDE: usize,
const IMAGE_HEIGHT: usize,
const IMAGE_WIDTH: usize,
const IN_CHANNELS: usize,
const PADDING: usize,
> Circuit<F>
for MyCircuit<
LEN,
CLASSES,
LOOKUP_MIN,
LOOKUP_MAX,
KERNEL_HEIGHT,
KERNEL_WIDTH,
OUT_CHANNELS,
STRIDE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
IN_CHANNELS,
PADDING,
>
where
Value<F>: TensorType,
{
type Config = Config<
LEN,
CLASSES,
LOOKUP_MIN,
LOOKUP_MAX,
KERNEL_HEIGHT,
KERNEL_WIDTH,
OUT_CHANNELS,
STRIDE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
IN_CHANNELS,
PADDING,
>;
type FloorPlanner = SimpleFloorPlanner;
type Params = PhantomData<F>;
fn without_witnesses(&self) -> Self {
self.clone()
}
// Here we wire together the layers by using the output advice in each layer as input advice in the next (not with copying / equality).
// This can be automated but we will sometimes want skip connections, etc. so we need the flexibility.
fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
let input = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
let params = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
let output = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
println!("INPUT COL {:#?}", input);
let mut layer_config = PolyConfig::configure(
cs,
&[input.clone(), params.clone()],
&output,
CheckMode::SAFE,
);
layer_config
.configure_lookup(
cs,
&input,
&output,
¶ms,
(LOOKUP_MIN, LOOKUP_MAX),
K,
&LookupOp::ReLU,
)
.unwrap();
layer_config
.configure_lookup(
cs,
&input,
&output,
¶ms,
(LOOKUP_MIN, LOOKUP_MAX),
K,
&LookupOp::Div { denom: 32.0.into() },
)
.unwrap();
let public_output: Column<Instance> = cs.instance_column();
cs.enable_equality(public_output);
Config {
layer_config,
public_output,
}
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
config.layer_config.layout_tables(&mut layouter).unwrap();
let x = layouter
.assign_region(
|| "mlp_4d",
|region| {
let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
let op = PolyOp::Conv {
padding: vec![(PADDING, PADDING); 2],
stride: vec![STRIDE; 2],
};
let x = config
.layer_config
.layout(
&mut region,
&[
self.input.clone(),
self.l0_params[0].clone(),
self.l0_params[1].clone(),
],
Box::new(op),
)
.unwrap();
let x = config
.layer_config
.layout(&mut region, &[x.unwrap()], Box::new(LookupOp::ReLU))
.unwrap();
let mut x = config
.layer_config
.layout(
&mut region,
&[x.unwrap()],
Box::new(LookupOp::Div { denom: 32.0.into() }),
)
.unwrap()
.unwrap();
x.flatten();
// multiply by weights
let x = config
.layer_config
.layout(
&mut region,
&[self.l2_params[0].clone(), x],
Box::new(PolyOp::Einsum {
equation: "ij,j->ik".to_string(),
}),
)
.unwrap()
.unwrap();
// add bias
let x: ValTensor<F> = config
.layer_config
.layout(
&mut region,
&[x, self.l2_params[1].clone()],
Box::new(PolyOp::Add),
)
.unwrap()
.unwrap();
Ok(x)
},
)
.unwrap();
match x {
ValTensor::Value {
inner: v, dims: _, ..
} => v
.enum_map(|i, x| match x {
ValType::PrevAssigned(v) => {
layouter.constrain_instance(v.cell(), config.public_output, i)
}
_ => panic!(),
})
.unwrap(),
_ => panic!("Should be assigned"),
};
Ok(())
}
}
pub fn runconv() {
#[cfg(not(target_arch = "wasm32"))]
env_logger::init();
const KERNEL_HEIGHT: usize = 5;
const KERNEL_WIDTH: usize = 5;
const OUT_CHANNELS: usize = 4;
const STRIDE: usize = 2;
const IMAGE_HEIGHT: usize = 28;
const IMAGE_WIDTH: usize = 28;
const IN_CHANNELS: usize = 1;
const PADDING: usize = 0;
const CLASSES: usize = 10;
const LEN: usize = {
OUT_CHANNELS
* ((IMAGE_HEIGHT + 2 * PADDING - KERNEL_HEIGHT) / STRIDE + 1)
* ((IMAGE_WIDTH + 2 * PADDING - KERNEL_WIDTH) / STRIDE + 1)
};
// Load the parameters and preimage from somewhere
let Mnist {
trn_img,
trn_lbl,
tst_img: _,
tst_lbl: _,
..
} = MnistBuilder::new()
.base_path("examples/data")
.label_format_digit()
.training_set_length(50_000)
.validation_set_length(10_000)
.test_set_length(10_000)
.finalize();
let mut train_data = Tensor::from(trn_img.iter().map(|x| i32_to_felt::<F>(*x as i32 / 16)));
train_data.reshape(&[50_000, 28, 28]).unwrap();
let mut train_labels = Tensor::from(trn_lbl.iter().map(|x| *x as f32));
train_labels.reshape(&[50_000, 1]).unwrap();
println!("The first digit is a {:?}", train_labels[0]);
let mut input: ValTensor<F> = train_data
.get_slice(&[0..1, 0..28, 0..28])
.unwrap()
.map(Value::known)
.into();
input.reshape(&[1, 1, 28, 28]).unwrap();
let myparams = params::Params::new();
let mut l0_kernels = Tensor::<F>::from(
myparams
.kernels
.clone()
.into_iter()
.flatten()
.flatten()
.flatten()
.map(|fl| {
let dx = fl * 32_f32;
let rounded = dx.round();
let integral: i32 = unsafe { rounded.to_int_unchecked() };
fieldutils::i32_to_felt(integral)
}),
);
l0_kernels
.reshape(&[OUT_CHANNELS, IN_CHANNELS, KERNEL_HEIGHT, KERNEL_WIDTH])
.unwrap();
l0_kernels.set_visibility(&ezkl::graph::Visibility::Private);
let l0_kernels = l0_kernels.try_into().unwrap();
let mut l0_bias = Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::i32_to_felt(0)));
l0_bias.set_visibility(&ezkl::graph::Visibility::Private);
let l0_bias = l0_bias.try_into().unwrap();
let mut l2_biases = Tensor::<F>::from(myparams.biases.into_iter().map(|fl| {
let dx = fl * 32_f32;
let rounded = dx.round();
let integral: i32 = unsafe { rounded.to_int_unchecked() };
fieldutils::i32_to_felt(integral)
}));
l2_biases.set_visibility(&ezkl::graph::Visibility::Private);
l2_biases.reshape(&[l2_biases.len(), 1]).unwrap();
let l2_biases = l2_biases.try_into().unwrap();
let mut l2_weights = Tensor::<F>::from(myparams.weights.into_iter().flatten().map(|fl| {
let dx = fl * 32_f32;
let rounded = dx.round();
let integral: i32 = unsafe { rounded.to_int_unchecked() };
fieldutils::i32_to_felt(integral)
}));
l2_weights.set_visibility(&ezkl::graph::Visibility::Private);
l2_weights.reshape(&[CLASSES, LEN]).unwrap();
let l2_weights = l2_weights.try_into().unwrap();
let circuit = MyCircuit::<
LEN,
10,
-32768,
32768,
KERNEL_HEIGHT,
KERNEL_WIDTH,
OUT_CHANNELS,
STRIDE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
IN_CHANNELS,
PADDING,
> {
input,
l0_params: [l0_kernels, l0_bias],
l2_params: [l2_weights, l2_biases],
};
let public_input: Tensor<i32> = vec![
-25124i32, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
]
.into_iter()
.into();
let pi_inner: Tensor<F> = public_input.map(i32_to_felt::<F>);
println!("MOCK PROVING");
let now = Instant::now();
let prover = MockProver::run(
K as u32,
&circuit,
vec![pi_inner.clone().into_iter().collect()],
)
.unwrap();
prover.assert_satisfied();
let elapsed = now.elapsed();
println!(
"MOCK PROVING took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
let pi_for_real_prover: &[&[&[F]]] = &[&[&pi_inner]];
// Real proof
println!("SRS GENERATION");
let now = Instant::now();
let params: ParamsKZG<Bn256> = ParamsKZG::new(K as u32);
let elapsed = now.elapsed();
println!(
"SRS GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
let empty_circuit = circuit.without_witnesses();
// Initialize the proving key
println!("VK GENERATION");
let now = Instant::now();
let vk = keygen_vk(¶ms, &empty_circuit).expect("keygen_vk should not fail");
let elapsed = now.elapsed();
println!(
"VK GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
println!("PK GENERATION");
let now = Instant::now();
let pk = keygen_pk(¶ms, vk, &empty_circuit).expect("keygen_pk should not fail");
let elapsed = now.elapsed();
println!(
"PK GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
println!("PROOF GENERATION");
let now = Instant::now();
let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
let mut rng = OsRng;
create_proof::<KZGCommitmentScheme<_>, ProverSHPLONK<_>, _, _, _, _>(
¶ms,
&pk,
&[circuit],
pi_for_real_prover,
&mut rng,
&mut transcript,
)
.expect("proof generation should not fail");
let proof = transcript.finalize();
let elapsed = now.elapsed();
println!(
"PROOF GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
let now = Instant::now();
let strategy = SingleStrategy::new(¶ms);
let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
let verify = verify_proof::<_, VerifierSHPLONK<_>, _, _, _>(
¶ms,
pk.get_vk(),
strategy,
pi_for_real_prover,
&mut transcript,
params.n(),
);
assert!(verify.is_ok());
let elapsed = now.elapsed();
println!(
"Verify took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
}
fn main() {
runconv()
}
| https://github.com/zkonduit/ezkl |
examples/conv2d_mnist/params.rs | pub struct Params {
pub kernels: Vec<Vec<Vec<Vec<f32>>>>,
pub weights: Vec<Vec<f32>>,
pub biases: Vec<f32>,
}
impl Params {
pub fn new() -> Params {
let kernels: Vec<Vec<Vec<Vec<f32>>>> = vec![
vec![
vec![vec![
-0.109_487_005,
0.909_935_65,
0.328_405_1,
0.155_579_06,
]],
vec![vec![
-0.471_988_14,
0.322_556_82,
0.157_859_01,
-0.081_366_19,
]],
vec![vec![
-0.321_307_9,
-0.709_357_5,
-0.236_524_24,
0.018_392_317,
]],
vec![vec![
-0.960_573_43,
-0.846_240_9,
-0.198_723_21,
0.338_416_52,
]],
vec![vec![
0.166_024_16,
0.430_398_14,
0.047_989_722,
0.390_401_57,
]],
],
vec![
vec![vec![0.179_814_12, 0.948_680_9, 0.071_443_19, 0.617_541_6]],
vec![vec![-0.697_547_9, -0.965_234_34, 0.536_243_9, 0.735_313_3]],
vec![vec![-0.856_151_64, -1.370_123, 0.471_787_6, 0.621_356_9]],
vec![vec![
-1.038_033_6,
-0.314_346_02,
0.054_190_256,
0.157_560_56,
]],
vec![vec![
-1.257_821_7,
0.592_307_27,
-0.602_756_1,
-0.045_588_925,
]],
],
vec![
vec![vec![
0.768_956_36,
-0.270_884_07,
0.018_818_572,
0.856_514_2,
]],
vec![vec![0.106_152_184, -1.894_055_7, 0.410_578_52, 1.128_321_6]],
vec![vec![0.258_462_85, -0.788_394_3, 0.439_590_57, 0.347_620_25]],
vec![vec![
-0.285_630_46,
0.344_891_73,
-0.158_083_84,
0.046_936_575,
]],
vec![vec![-1.207_216_4, 0.972_309_4, -1.463_360_5, 0.158_549_34]],
],
vec![
vec![vec![
0.481_335_2,
-0.999_390_1,
-0.342_961_97,
-0.462_902_43,
]],
vec![vec![0.770_321_5, -0.693_961_4, 0.349_121_36, -0.411_381_07]],
vec![vec![0.576_287_75, 0.283_153_83, 1.110_488_4, 0.188_614_32]],
vec![vec![0.697_886_77, 0.836_453_6, -0.077_697_74, 0.236_429_83]],
vec![vec![0.525_762_26, 0.838_75, -1.107_396_1, 0.395_158_26]],
],
vec![
vec![vec![0.165_011_53, -0.900_041_6, 0.047_026_41, -1.977_776]],
vec![vec![
0.307_094_28,
-0.446_277_47,
0.300_544_77,
-1.988_659_1,
]],
vec![vec![0.406_012_42, 0.884_344_8, 0.952_605_9, -0.506_538]],
vec![vec![0.980_571_8, 0.721_017_2, 0.290_006_73, -0.175_620_02]],
vec![vec![0.928_422_87, 0.359_928_97, -0.923_574_2, 0.063_738_97]],
],
];
let w: Vec<Vec<f32>> = vec![
vec![
0.205_270_19,
-0.103_883_29,
-0.899_116_8,
0.729_005_6,
-0.240_855_54,
0.212_849_54,
-0.417_299_66,
-1.158_180_5,
-1.631_655_5,
-0.357_596_07,
],
vec![
0.554_331_5,
-0.113_753_23,
-0.998_434_54,
0.527_284_1,
-0.702_836_16,
0.852_934_1,
-0.762_695,
-1.032_534_8,
-1.304_348_8,
-0.461_081_1,
],
vec![
0.235_476_17,
0.933_593,
-0.580_496_9,
0.104_375_89,
-0.041_980_47,
-0.653_047_9,
-0.642_941_1,
-0.055_830_125,
-0.506_560_2,
-0.054_289_315,
],
vec![
0.531_130_25,
-0.422_383_3,
-0.913_531_6,
0.379_514_9,
-0.694_251_5,
0.636_398_9,
-0.583_917_3,
-1.094_018_2,
-0.767_574_3,
-0.250_628_44,
],
vec![
0.210_465_77,
-0.651_549_34,
0.430_768_22,
0.073_381_59,
-0.726_815_46,
-0.955_648_3,
0.060_921_72,
-1.645_878_4,
-0.245_945_47,
-1.102_198_2,
],
vec![
-0.720_487_3,
-0.537_216_1,
0.213_335_25,
0.261_519,
-0.752_857_7,
-0.974_760_83,
0.801_267_15,
-1.639_844_2,
-0.296_582_34,
-0.877_851_4,
],
vec![
0.286_137_55,
-0.717_753_95,
0.174_010_41,
-0.781_800_03,
-0.391_660_15,
0.916_126_9,
-0.611_720_1,
-0.838_970_3,
-1.248_522_9,
-0.266_078_17,
],
vec![
0.786_667_5,
-1.937_995_7,
1.488_519_2,
-1.075_065,
-0.816_913_96,
-0.082_726_15,
0.544_172_8,
-0.647_251_5,
0.042_277_988,
-0.101_091_36,
],
vec![
-0.081_334_39,
-0.410_865_6,
4.723_240_3e-5,
0.167_322_04,
-0.229_562_98,
-0.362_416_1,
0.258_705_38,
-1.749_157_9,
0.071_778_66,
-2.777_862_5,
],
vec![
-0.085_456_52,
-1.244_134_9,
0.120_452_59,
0.158_306_17,
-0.578_419_6,
-0.349_570_4,
0.537_034,
-1.344_408,
-0.028_031_735,
-2.276_252,
],
vec![
-1.502_647_6,
0.309_662_8,
0.248_574_35,
-0.207_915_56,
-1.259_506_8,
-1.270_181_1,
1.259_249_8,
-1.636_723,
0.053_503_122,
-0.590_245_2,
],
vec![
0.065_632_41,
-0.254_215_4,
-0.589_417_6,
1.104_314_7,
-1.895_038_4,
-0.648_805_4,
1.669_961_3,
-1.083_259_8,
-0.401_768_77,
-1.511_640_2,
],
vec![
0.249_498_64,
-0.175_782_26,
-0.258_627_98,
0.194_892_62,
-0.560_735_17,
-0.160_784_18,
0.161_112_1,
-3.568_600_4,
0.172_535_03,
-0.239_725_56,
],
vec![
0.248_165_12,
-0.169_096_62,
0.112_139_55,
-0.364_031_9,
-1.327_239_8,
-0.027_334_109,
0.536_611_86,
-3.214_496_4,
0.130_880_97,
-0.526_202_7,
],
vec![
-0.799_813_03,
1.452_860_1,
-0.319_819_72,
-0.184_792_74,
0.140_319_36,
-0.867_999_26,
0.693_308_35,
-1.197_729_1,
-0.766_039_6,
-1.556_379_1,
],
vec![
-0.845_276_3,
0.304_203_3,
0.944_849_8,
0.124_821_134,
-0.922_336_76,
-0.491_067_53,
-0.184_880_93,
-2.557_060_7,
-1.775_722_1,
0.558_45,
],
vec![
0.143_072_8,
-0.264_300_5,
-0.081_971_504,
0.048_953_265,
-0.542_625,
0.011_722_911,
-0.333_903_73,
-0.390_692_65,
0.272_231_76,
0.156_067_22,
],
vec![
-0.387_689_44,
0.191_336_14,
-0.097_416_42,
0.035_105_634,
-0.395_439_33,
-0.242_016_94,
0.365_376_65,
-0.286_892_18,
-0.460_546_08,
0.274_879_22,
],
vec![
-0.286_709_82,
0.791_482_3,
0.646_904_4,
-0.833_426_06,
-0.655_702_65,
-0.107_309_21,
0.858_584_76,
-1.800_347_8,
-1.091_450_2,
-3.117_647,
],
vec![
-0.311_940_76,
0.585_462_15,
0.278_351_4,
-0.195_842_67,
-0.772_845_7,
0.177_592_13,
-0.098_054_45,
-1.845_965_5,
-1.022_349_2,
-0.907_678_4,
],
vec![
0.272_821_28,
-0.067_864_05,
-0.138_505_9,
-0.081_492_29,
-0.387_334_82,
-0.016_360_57,
-0.215_009_03,
-0.167_551_83,
0.102_085_34,
0.173_719_73,
],
vec![
-0.090_551_52,
0.208_982_07,
-0.150_085_8,
-0.553_895_7,
-0.287_771_4,
-0.334_054_1,
0.267_900_44,
-0.272_997_17,
-0.337_444_4,
-0.042_845_86,
],
vec![
-0.356_198_94,
0.072_102_97,
0.102_510_154,
-0.196_657_39,
-0.191_161_19,
-0.281_018_23,
0.778_014_7,
-1.820_609_9,
-0.116_903_074,
-1.093_936_6,
],
vec![
-1.026_930_8,
1.145_142_8,
-0.365_834_41,
0.112_254_17,
-0.342_273_4,
-1.065_313_3,
0.572_839_44,
-2.689_278_1,
-0.829_139_9,
-1.090_214_4,
],
vec![
0.049_006_45,
-0.238_958_63,
0.072_469_26,
0.021_633_074,
-0.253_975_12,
0.073_988_98,
-0.179_797_55,
-0.204_893_05,
0.084_148_675,
0.454_873_56,
],
vec![
-0.472_980_65,
0.094_130_29,
0.010_865_513,
-0.072_856_374,
-0.130_805_84,
0.288_349_66,
0.133_428_38,
-1.906_852,
-0.256_083_5,
0.130_116_46,
],
vec![
0.310_519_2,
0.158_036_98,
-0.088_624_336,
-0.378_656_36,
-0.505_495_8,
-0.353_957_36,
0.128_528_24,
-0.121_506_3,
0.106_705_7,
0.053_275_537,
],
vec![
0.404_991_5,
-0.886_301_64,
1.029_255_2,
0.946_611_64,
-1.078_323_2,
-0.478_881_12,
0.080_937_55,
-0.968_548_6,
-0.184_279_47,
-3.533_551_5,
],
vec![
0.011_388_913,
-0.327_091_72,
0.107_985_206,
0.054_274_764,
-0.060_456_365,
-0.059_907_958,
-0.374_292_46,
-0.328_351_89,
0.065_400_75,
0.415_573_6,
],
vec![
0.106_242_32,
0.290_615_23,
-0.515_454_4,
-0.672_065,
-0.247_548_16,
0.608_504_4,
-0.016_324_794,
-4.148_192_4,
-0.212_008_9,
-0.432_835_8,
],
vec![
-0.526_448_97,
0.205_754_35,
0.076_098_82,
-0.069_695_31,
-0.191_621_91,
0.291_678_22,
-0.152_594_2,
0.101_625_93,
0.214_410_33,
-0.125_688_2,
],
vec![
-1.190_686_7,
-0.957_843_84,
0.998_908_6,
1.184_374_7,
-1.852_929_7,
0.349_038_24,
0.564_113_3,
-1.171_722_8,
-0.685_080_77,
-1.525_082_7,
],
vec![
-0.121_344_47,
0.014_777_94,
0.092_460_57,
0.227_560_82,
-0.133_595_06,
-0.061_949_328,
-0.229_687_59,
-1.204_043_5,
-0.117_137_89,
0.066_422_805,
],
vec![
-0.713_826_5,
0.662_813_8,
-0.893_180_2,
-0.241_316_48,
-0.155_127_45,
0.235_396_18,
0.434_296,
-4.804_617,
-0.143_494_13,
-0.871_146_5,
],
vec![
-0.257_979_33,
0.148_611_19,
-0.216_227,
0.063_711_99,
-0.247_472_02,
0.096_262_21,
0.213_341_3,
-0.876_289_25,
0.040_421_054,
-0.139_267_49,
],
vec![
-0.095_453_01,
-1.067_049_1,
-0.109_649_43,
-0.193_885_3,
-1.734_969_9,
-0.106_661_83,
1.129_675_5,
-1.453_956_5,
0.904_227_4,
-1.171_946_4,
],
vec![
-0.039_940_894,
0.063_756_41,
-0.203_613_64,
0.329_066_4,
-0.183_243_96,
0.100_813_02,
-0.053_472_206,
0.535_816_67,
-0.316_393_52,
-0.144_898_12,
],
vec![
0.113_168_314,
-0.833_849_9,
-0.303_433_6,
-0.302_232_6,
0.228_052_87,
-0.354_127_2,
0.388_441_03,
0.625_805_4,
0.004_380_497_6,
-2.595_726,
],
vec![
0.143_565_1,
0.182_829_17,
-0.528_689_74,
-0.110_325_485,
-0.503_309_8,
0.299_748_33,
0.095_951_79,
-2.118_308_3,
-0.408_070_4,
0.146_073_6,
],
vec![
0.103_533_98,
0.597_761_1,
-1.624_569_9,
-1.605_465,
-1.133_732_3,
0.041_046_087,
0.620_659_6,
-1.410_499_7,
0.648_047_27,
-0.474_848_9,
],
vec![
0.221_853_54,
-0.451_183_77,
-0.257_857_44,
0.264_325_53,
-0.355_948_24,
0.014_300_789,
-0.059_305_04,
0.556_209,
-0.052_184_805,
-0.290_411_74,
],
vec![
0.123_746_41,
0.146_830_04,
0.365_464_8,
-2.524_588_8,
-0.209_791_47,
-0.002_517_690_6,
0.155_493_72,
-3.591_966_6,
-0.447_013_94,
-1.130_127,
],
vec![
0.217_829_11,
0.214_957_76,
0.282_495_92,
0.167_459_32,
-0.208_813_38,
-0.567_943_75,
0.198_498_55,
0.576_863_3,
-0.373_066_4,
-0.126_371_68,
],
vec![
-1.161_503_4,
-0.850_141_2,
0.323_090_46,
-1.075_380_4,
-0.876_660_05,
1.076_255_4,
-0.314_113_7,
-0.304_621_55,
-1.264_679_4,
-0.264_382_12,
],
vec![
0.149_401_25,
-0.976_069_4,
0.511_743_55,
0.000_535_424_04,
-0.117_031_43,
-0.107_678_935,
-0.069_459_68,
0.306_292_47,
0.125_225_45,
-2.442_781,
],
vec![
-1.668_387_7,
-1.762_069_5,
-0.121_069_3,
-1.923_070_9,
0.618_881_46,
-0.254_279_52,
-0.053_265_8,
-1.291_394_6,
-0.296_294_72,
-0.343_077_6,
],
vec![
0.011_316_772,
-0.560_516_9,
0.481_444_72,
-0.479_095_2,
0.200_686_35,
-0.106_225_66,
-0.037_240_833,
0.214_261_46,
-0.261_465_5,
-1.978_262_7,
],
vec![
-0.720_068_8,
-0.210_179_06,
-0.971_435_2,
-0.758_882_5,
-0.857_823_85,
-0.485_705_32,
1.141_667_8,
-0.028_217_256,
-0.530_086_4,
-0.159_677_88,
],
vec![
0.177_069_29,
-0.121_254_206,
0.224_838_26,
0.371_999_23,
-0.589_339_85,
-0.052_119_676,
-0.246_520_33,
-0.337_158_02,
-0.360_983_88,
-1.255_084_3,
],
vec![
-0.642_535_27,
0.163_133,
0.069_549_456,
0.491_649_72,
-0.022_372_723,
0.203_867_21,
-0.479_860_75,
-0.587_429_9,
-0.627_623_2,
-1.301_936_3,
],
vec![
0.147_011_62,
0.614_845_7,
-0.894_145_9,
-0.523_223_1,
-0.561_377_64,
0.613_864_54,
-0.745_141_27,
0.978_213_97,
-1.130_499_4,
-1.302_783_1,
],
vec![
0.695_418_36,
0.025_962_515,
-0.275_048_73,
0.853_301_6,
-0.425_614_98,
0.232_753_16,
-0.370_581_36,
-0.891_797_36,
-0.212_364_4,
-0.441_128_16,
],
vec![
0.467_095_23,
0.164_520_4,
-0.320_856_18,
-0.053_149_23,
0.166_585_9,
0.201_401_62,
-0.586_135_57,
-0.012_367_41,
-0.328_987_12,
-0.114_124_13,
],
vec![
0.236_447_05,
0.298_628_18,
-0.193_423_94,
0.009_453_123,
-0.490_039_44,
-0.417_519_3,
-0.036_829_55,
0.104_782_78,
-0.154_328_51,
-0.428_794_86,
],
vec![
0.521_462_1,
-1.067_498_9,
-0.352_910_64,
-0.706_459_64,
-0.156_912_03,
0.753_26,
-0.110_429_8,
0.179_951_94,
-1.210_509_1,
-0.272_030_9,
],
vec![
0.229_667_75,
0.585_958_8,
0.063_965_224,
-0.108_399_93,
-0.930_658_34,
-0.778_497_16,
-0.088_825_43,
0.233_678_62,
-0.337_286_65,
0.182_365_06,
],
vec![
0.048_408_65,
-0.036_042_29,
0.416_218_55,
-0.182_036_67,
-0.523_173_2,
-0.128_682_4,
-0.118_689_634,
-0.138_312_35,
-0.105_193_26,
0.449_392_4,
],
vec![
-0.074_198_395,
-0.436_481_77,
0.101_361_58,
0.039_507_54,
-0.011_397_873,
-0.430_790_33,
0.255_392_58,
-0.574_166_9,
0.086_148_12,
0.122_888_364,
],
vec![
-0.855_785_55,
0.457_752_32,
-1.275_530_5,
0.259_120_94,
-0.464_194_15,
0.188_488_56,
1.413_801_8,
-0.357_694_63,
-1.278_620_5,
-1.631_098_6,
],
vec![
-0.805_655_2,
-0.265_815_73,
0.124_419_026,
-0.461_629_48,
-0.314_236_97,
0.268_423_3,
0.274_402_47,
0.998_315_93,
0.380_863_43,
-0.614_466_97,
],
vec![
-0.233_871_01,
-0.302_981_8,
0.258_206_84,
-0.005_351_850_8,
-0.144_955_49,
-0.253_221_06,
-0.228_432_7,
0.090_228_595,
0.008_581_011,
0.184_043_18,
],
vec![
-0.209_811_84,
0.012_808_64,
-0.203_015_6,
-0.114_540_905,
-0.157_946_11,
-0.070_131_48,
0.271_216_4,
-0.113_623_81,
0.058_057_647,
0.014_067_203,
],
vec![
-0.972_353_8,
1.463_821_9,
-0.622_333,
-0.397_985_52,
1.035_312_5,
-0.610_709_37,
0.239_632_68,
-0.255_446_08,
0.016_936_108,
-1.764_247_2,
],
vec![
-0.260_985_3,
1.254_787_1,
0.186_725_72,
-0.455_625_27,
-0.066_667_27,
0.593_635_2,
0.162_254_18,
0.099_562_53,
-1.217_950_8,
-1.794_823_9,
],
vec![
0.041_862_838,
0.140_515_88,
0.050_972_044,
0.157_721_89,
-0.544_736_7,
-0.090_700_32,
-0.086_753_72,
0.072_839_975,
0.126_270_53,
-0.009_919_372,
],
vec![
-0.191_297_02,
0.391_595_66,
-0.347_080_17,
0.007_070_528,
0.079_755_33,
0.077_444_814,
0.275_881_83,
-0.337_502_7,
0.132_838_65,
-0.203_929_53,
],
vec![
0.353_786_1,
1.386_378_4,
-0.448_180_6,
-0.091_514_84,
0.470_257_67,
-0.466_944_75,
0.277_010_8,
-0.946_052_85,
-0.480_009_35,
-1.484_195_4,
],
vec![
-0.756_496_9,
-0.673_428_5,
0.142_579_26,
0.279_415_43,
1.044_289,
0.074_700_67,
-0.329_739_03,
1.033_776,
-0.044_540_51,
-1.185_075_5,
],
vec![
0.016_420_702,
-0.481_048_32,
0.133_203_77,
0.279_789_4,
-0.584_399,
0.082_969_56,
-0.625_780_2,
0.033_153_057,
0.104_334_9,
0.392_508_8,
],
vec![
-0.214_637_23,
0.187_661_42,
-0.509_873_2,
-0.175_593_53,
0.585_934_34,
-0.163_800_21,
0.677_062_8,
-0.294_775_52,
0.273_286_88,
-0.762_537_36,
],
vec![
-0.274_889_4,
0.610_465_76,
0.456_998_2,
-0.148_116_63,
0.434_490_23,
-0.446_525_13,
0.168_362_99,
-0.592_147_05,
-0.428_666_38,
0.017_922_09,
],
vec![
-0.867_463_77,
0.263_241_74,
0.439_303_04,
0.250_574_17,
0.456_202_2,
-0.278_351_84,
-0.850_352_35,
-0.670_502_54,
0.253_216_77,
-3.358_240_8,
],
vec![
0.170_602_65,
-0.221_394_14,
-0.018_658_5,
0.224_552_65,
-0.444_447_9,
0.027_889_86,
-0.072_897_17,
0.025_849_128,
0.000_449_741_7,
0.120_267_78,
],
vec![
0.094_457_65,
0.749_140_1,
-0.441_342_3,
-0.247_712_64,
0.380_680_47,
-0.539_401_77,
0.374_145_78,
-0.637_63,
-0.102_575_146,
-0.444_776_6,
],
vec![
0.092_296_37,
0.324_160_07,
0.053_874_45,
-0.419_170_38,
0.080_262_61,
0.034_971_14,
0.339_625_27,
-0.456_453_14,
0.155_008_8,
-0.545_077_7,
],
vec![
-0.144_919_11,
-0.484_287_77,
0.351_345_36,
1.020_092_8,
-0.322_258_44,
-0.290_137_68,
-0.837_886,
0.588_037_5,
-0.001_021_652_7,
-3.884_543_2,
],
vec![
0.115_526_795,
-0.034_962_557,
-0.139_396_6,
0.033_680_24,
-0.342_877_4,
0.083_684_86,
-0.122_894_36,
0.324_849_55,
-0.114_528_82,
0.123_401_18,
],
vec![
-0.137_530_28,
0.318_438_35,
-0.206_170_47,
-0.477_281_78,
0.460_907_3,
0.056_528_006,
0.050_785_955,
-0.574_258_3,
-0.024_915_818,
-0.404_091_6,
],
vec![
-0.202_853_07,
-0.103_542_28,
-0.116_601_42,
0.144_897_67,
-0.017_747_866,
0.235_582_32,
0.170_953_4,
-0.053_962_417,
-0.127_650_17,
-0.203_697_12,
],
vec![
0.152_913_54,
-0.516_011_83,
0.483_596_56,
0.244_190_16,
-0.029_850_394,
-0.097_673_82,
-0.312_583_42,
-1.341_605_7,
-0.423_485_9,
-0.279_781_43,
],
vec![
0.068_590_745,
-0.149_233_73,
-0.073_714_636,
0.042_948_257,
-0.197_927_46,
-0.022_572_309,
-0.224_327_13,
0.327_125_85,
0.043_589_164,
-0.018_358_223,
],
vec![
-0.294_240_27,
0.677_863_1,
-0.482_854_16,
-0.791_775_4,
0.785_504_2,
-0.272_481_23,
0.286_275_3,
-1.218_818_8,
-0.021_499_386,
-0.722_086_67,
],
vec![
-0.177_391_37,
0.223_915_52,
-0.092_343_53,
-0.066_849_515,
0.131_875_72,
0.368_566_87,
-0.151_181_6,
-0.401_858_78,
-0.131_481_93,
-0.093_791_075,
],
vec![
0.508_870_1,
-0.971_894_44,
0.366_849_9,
0.131_068_99,
-0.605_050_1,
-0.326_536_66,
0.050_295_74,
-2.077_97,
0.215_176_37,
-1.826_045_4,
],
vec![
0.156_527_64,
-0.116_625_85,
0.154_377_33,
0.154_419_14,
-0.241_974_06,
-0.418_938_8,
-0.295_733_45,
0.149_280_2,
0.067_916_89,
0.028_793_553,
],
vec![
-0.158_543_56,
0.413_012_92,
-0.627_065_3,
-1.317_622,
0.208_255_17,
0.317_041_13,
-0.227_730_59,
0.398_595_12,
-0.352_214_3,
-0.824_505_45,
],
vec![
-0.161_441_8,
0.121_852_77,
-0.270_927_64,
-0.047_329_85,
-0.524_744_7,
0.105_052_55,
0.023_019_264,
0.050_272_036,
0.119_445_64,
0.246_476_17,
],
vec![
-0.147_019_95,
-1.217_400_7,
0.256_482_8,
-0.399_383_75,
-1.991_811_2,
0.190_690_77,
-0.004_192_297,
0.097_936_116,
0.379_179_87,
-0.968_338_3,
],
vec![
0.106_748_596,
0.093_080_916,
0.073_558_204,
0.456_351_52,
-0.196_805_95,
-0.407_231_93,
-0.167_090_68,
-0.462_795_7,
-0.056_798_77,
0.363_880_04,
],
vec![
0.067_087_81,
0.700_592_1,
-2.085_968_3,
-1.309_445_1,
0.235_306_9,
0.437_614_35,
-0.111_600_46,
-0.668_872_65,
0.131_418_2,
-1.099_951,
],
vec![
0.120_559_655,
-0.173_647_66,
0.087_945_215,
0.011_596_556,
0.138_631_33,
-0.457_137_44,
-0.219_191_34,
0.418_845_4,
0.058_534_283,
-0.049_473_75,
],
vec![
-1.158_622_6,
-0.606_912_6,
-0.061_822_26,
-1.256_837_7,
-0.777_147_77,
0.427_778_1,
-0.644_817_6,
-2.014_167,
0.601_345_54,
-2.429_726,
],
vec![
0.324_109_85,
0.111_482_88,
0.177_295_82,
0.801_780_64,
-0.232_152_54,
0.068_763_666,
-0.246_951_58,
-1.317_435_4,
-0.205_863_16,
-0.434_466_93,
],
vec![
-1.748_575_2,
-2.571_439,
0.583_557_6,
-2.421_854_5,
-0.827_151,
0.664_516,
0.625_516_6,
-2.512_756_6,
0.469_817_76,
-2.431_587_2,
],
vec![
-0.067_664_62,
-0.206_810_13,
-0.029_682_456,
0.605_365_75,
-0.336_148_23,
-0.151_250_17,
-0.282_517_22,
-0.148_410_19,
0.169_121_22,
-0.164_390_13,
],
vec![
-1.392_889,
-1.023_818_9,
-1.862_098_8,
-1.219_547_2,
-0.623_446_46,
0.318_364_47,
-0.479_301_15,
-2.804_167_7,
0.677_353_2,
-1.441_338_1,
],
vec![
-0.861_262_9,
0.004_425_101,
-0.071_183_55,
-0.184_647_08,
0.031_291_18,
-1.227_623_5,
-0.386_703_46,
0.281_736_55,
-0.005_909_541_6,
-0.399_945_47,
],
vec![
-0.701_130_03,
-0.117_758_64,
0.368_344_07,
0.331_284_97,
-0.256_022_66,
-0.660_268,
0.039_130_14,
-0.481_968_08,
-0.089_253_89,
-0.579_329_7,
],
vec![
0.670_172_63,
-0.580_271_24,
-0.649_096_13,
-0.474_525_66,
-0.377_117_63,
1.405_239_2,
-1.221_097_2,
1.200_569_9,
-0.086_327_35,
-2.255_320_3,
],
vec![
-1.358_025_8,
-0.342_335_22,
0.295_178_5,
0.075_462_48,
-0.263_600_26,
-0.065_306_99,
-0.355_591_6,
-0.309_273_7,
0.027_559_858,
-0.708_983_06,
],
vec![
-0.110_825_61,
-0.441_783_8,
0.510_953,
-0.017_491_657,
-0.361_264_1,
-0.658_499_2,
-1.168_359,
-0.183_945_58,
-0.018_839_432,
0.259_778_83,
],
vec![
0.177_515_95,
-0.075_632_31,
0.013_366_969,
-0.259_934_54,
-0.146_670_1,
0.083_243_91,
-0.245_393_48,
-0.015_866_693,
-0.118_829_71,
-0.008_721_328,
],
vec![
-0.550_502_36,
0.540_914_7,
-0.971_661_1,
-0.326_274_57,
0.005_312_611_3,
-1.068_250_4,
0.266_432_85,
0.465_531_14,
-0.377_819_33,
-2.766_870_7,
],
vec![
0.389_952,
0.049_188_2,
-0.070_362_93,
-0.158_295_77,
-0.054_504_406,
-0.162_878_42,
-0.329_468_82,
0.147_300_17,
-0.285_775_2,
-0.423_477_32,
],
vec![
-0.437_943_52,
-0.068_380_67,
0.194_627_26,
0.281_447_74,
-0.220_649_88,
-0.678_889,
-0.277_028_77,
0.230_105_79,
-0.006_377_558_7,
-0.206_830_32,
],
vec![
-0.009_224_954,
-0.378_657,
-0.085_123_174,
-0.156_714_63,
-0.343_136_5,
0.055_030_156,
0.559_048_8,
-0.327_488_06,
0.169_883_4,
0.034_172_5,
],
vec![
-0.688_926_8,
-0.104_911_59,
-0.976_121_96,
-0.522_905_95,
0.565_652_97,
0.191_607_74,
0.928_987_7,
0.271_104_07,
-0.397_580_33,
-1.708_864_6,
],
vec![
0.012_301_554,
0.117_295_76,
-0.027_031_401,
0.264_092_45,
-0.886_667_85,
-0.591_631_6,
0.270_088_85,
0.682_763,
-0.278_033_26,
-0.395_845_86,
],
vec![
-0.342_501_8,
0.562_693_6,
0.067_982_31,
0.326_943_3,
-0.336_273_97,
-0.601_590_1,
-0.685_105_3,
0.369_405_27,
-0.058_104_467,
-0.033_579_066,
],
vec![
0.064_386_68,
-0.400_555_73,
-0.182_303_9,
-0.218_738_72,
0.216_905_34,
0.030_601_45,
0.094_936_07,
-0.009_266_577,
0.087_377_72,
0.053_116_817,
],
vec![
0.239_458_02,
-0.553_885_1,
-0.751_549_4,
-0.327_702_13,
0.808_595_7,
0.551_519_1,
0.284_371_67,
0.547_793_6,
-0.059_032_235,
-1.324_021_5,
],
vec![
-0.452_034_92,
0.261_517_6,
-0.252_394_05,
0.092_079_16,
0.429_929_17,
-0.167_667_57,
-0.211_615_74,
0.671_054_8,
0.349_666_24,
-2.117_855,
],
vec![
-0.528_661_1,
-0.472_939_22,
0.182_015_09,
0.317_773_28,
-0.124_089_79,
0.045_638_64,
-0.724_232_9,
0.204_953_31,
-0.398_932_28,
0.107_951_67,
],
vec![
-0.052_959_226,
0.135_726_82,
-0.136_894_15,
-0.566_229_05,
0.380_288_6,
0.140_286_85,
0.135_775_07,
-0.249_593_62,
-0.017_248_28,
-0.027_598_498,
],
vec![
-0.220_504_76,
-0.046_495_143,
0.180_323_42,
-0.790_958_3,
1.322_335_2,
-0.108_043_14,
0.217_102_74,
0.825_262_4,
-0.492_108_76,
-0.700_494_5,
],
vec![
-0.352_748_78,
0.213_851_73,
-0.163_977_56,
0.404_177_84,
-0.249_681_82,
-0.216_996_63,
-0.862_111_8,
0.325_164_74,
-0.162_396_8,
-0.256_683_9,
],
vec![
-0.436_135_6,
-0.409_798_77,
-0.208_920_99,
0.172_075_72,
-0.236_797_62,
0.082_351_59,
-0.514_797_4,
0.356_074_42,
0.015_723_99,
-0.081_596_93,
],
vec![
-0.451_420_16,
0.285_002_02,
-0.344_098_42,
-0.568_649_4,
0.139_230_56,
0.200_250_37,
0.495_893_72,
-0.290_844_05,
-0.022_031_482,
0.050_763_61,
],
vec![
-0.173_756_91,
0.419_162_12,
-0.180_732_7,
-0.057_678_43,
0.963_222_5,
-0.542_589_25,
-0.015_682_373,
0.089_011_23,
0.035_791_16,
-0.455_887_17,
],
vec![
-1.004_596_5,
-0.236_272_17,
0.173_167_3,
0.228_756_13,
0.258_503_44,
-0.065_365_806,
-0.879_822_5,
0.722_794_3,
-0.097_331_2,
-0.077_870_905,
],
vec![
0.234_086_29,
-0.009_919_475,
-0.074_891_225,
-0.144_583_54,
-0.535_934_6,
0.124_304_32,
-0.782_060_27,
0.254_513_5,
0.055_683_39,
0.069_254_84,
],
vec![
-0.390_705_17,
0.384_156_38,
-0.186_229_33,
-0.584_244_1,
0.531_919_96,
-0.069_686_66,
0.149_591_43,
-0.778_742_8,
-0.081_920_885,
-0.154_186_23,
],
vec![
-0.041_898_686,
0.129_092_99,
-0.216_378_45,
0.181_084_84,
0.883_805_04,
-0.262_621,
-0.308_502_35,
0.180_086_1,
-0.291_687_16,
-0.113_592_334,
],
vec![
-0.206_446_33,
0.171_964_9,
0.293_709_2,
0.253_592_46,
-1.241_981_9,
-0.466_809_84,
-0.528_306_25,
0.566_160_56,
-0.294_850_35,
0.329_751_46,
],
vec![
0.028_156_348,
-0.089_827_4,
-0.039_944_68,
0.003_904_477_2,
-0.143_147_95,
-0.087_608_19,
-0.271_006_9,
0.135_168_46,
-0.169_262_14,
0.179_181,
],
vec![
-0.158_213_47,
0.260_261_42,
-0.499_890_12,
-0.617_226_6,
0.677_156,
-0.141_557_51,
-0.015_163_827,
-0.268_581_3,
-0.383_393_73,
-0.079_002_6,
],
vec![
0.025_213_772,
0.040_827_68,
-0.178_087_09,
0.116_391_845,
0.563_567_34,
-0.275_989_44,
-0.174_380_75,
-0.001_827_002_7,
0.125_746_6,
-0.340_517_07,
],
vec![
0.019_749_146,
-0.783_887_57,
0.526_380_2,
-0.228_184_16,
-0.979_208_3,
0.045_181_397,
-0.290_830_22,
0.281_862_97,
0.212_756_75,
0.077_207_305,
],
vec![
0.017_906_101,
-0.163_613_9,
0.087_164_72,
-0.046_330_657,
-0.222_235_14,
0.046_974_953,
-0.568_875_7,
0.137_390_6,
0.149_732_47,
0.054_858_174,
],
vec![
-0.142_019_9,
0.449_144_24,
-0.686_669_5,
-1.090_786_9,
0.604_686_6,
0.076_722_49,
0.245_582_54,
-0.829_804_2,
-0.165_203_63,
-0.149_007_14,
],
vec![
0.320_993_96,
0.119_689_37,
-0.150_012_6,
0.191_727_18,
0.082_919_58,
-0.527_837_1,
-0.071_530_03,
-0.021_497_987,
0.270_940_7,
-0.278_216_78,
],
vec![
0.283_085_38,
-1.443_256_5,
0.252_147_61,
-0.163_902_98,
-1.414_779_3,
0.236_899_23,
-0.015_835_924,
-0.211_199_78,
0.192_544_15,
0.535_805_1,
],
vec![
-0.031_128_181,
0.098_440_4,
-0.250_576_62,
0.001_446_956_2,
-0.166_310_09,
0.114_397_4,
-0.101_888_314,
0.048_192_31,
0.161_405_6,
0.090_395_294,
],
vec![
-0.724_360_1,
0.207_801_43,
-1.503_290_2,
-1.666_891_3,
0.339_504,
0.795_809_75,
0.389_212_52,
0.054_467_775,
-0.033_395_73,
-0.436_388_46,
],
vec![
0.075_730_63,
0.098_023_93,
-0.263_772_16,
-0.093_434_33,
0.315_961_48,
-0.366_490_3,
-0.232_862_79,
-0.119_057_89,
0.091_956_18,
-0.089_295_94,
],
vec![
-0.308_372_44,
-0.820_044_16,
-0.298_285_63,
-0.393_244_65,
-0.718_027_65,
0.584_613_74,
0.539_996_6,
-1.438_904_9,
0.176_980_63,
0.054_312_26,
],
vec![
0.174_080_85,
-0.216_159_63,
-0.026_459_76,
-0.357_671_2,
-0.113_939_73,
0.013_583_492_5,
-0.351_176_86,
0.252_733_47,
-0.039_529_853,
0.268_498_1,
],
vec![
-1.993_145,
0.287_121_62,
-0.888_011_2,
-0.614_505_9,
0.438_744_78,
0.506_205_6,
0.087_504_11,
-0.068_988_88,
-0.123_064_6,
-1.331_926,
],
vec![
0.215_632_22,
0.129_511_37,
0.274_990_14,
0.122_623_39,
0.047_715_563,
-0.734_401_6,
-0.375_344_1,
-0.003_185_275_7,
0.057_150_718,
-0.352_097_4,
],
vec![
-0.425_337_6,
-0.582_686,
-1.584_758_6,
-0.888_137_8,
-0.990_626_6,
0.632_610_14,
0.343_601_02,
-0.343_171_48,
0.222_747_77,
0.065_007_046,
],
vec![
0.751_865_74,
0.084_619_09,
-0.242_130_18,
-0.014_619_584,
-0.288_201_75,
-0.035_856_392,
-0.978_297_7,
-0.108_465_13,
0.110_781_03,
0.192_797_72,
],
vec![
0.273_850_1,
-0.150_658_67,
0.348_599_05,
-1.558_001_3,
0.530_314_56,
0.911_728_44,
-0.471_142_77,
-1.818_102_1,
-0.112_300_32,
-4.107_308_4,
],
vec![
0.576_481_4,
0.174_494_85,
0.100_200_04,
0.411_519_68,
0.186_069_13,
-0.563_864_1,
-0.216_897_5,
-0.346_323_73,
-0.215_137_65,
-0.052_019_272,
],
vec![
-0.467_293_86,
-0.549_939_3,
-1.342_918_4,
-1.506_654_6,
0.483_067_24,
0.573_365,
0.154_416_11,
-1.015_882_1,
0.205_112_19,
-2.852_063_4,
],
vec![
0.213_581_4,
-1.916_046_5,
-0.781_541_6,
0.128_297_82,
0.124_022_01,
0.193_614_44,
-1.000_155_4,
0.545_728,
-0.012_136_586,
-0.500_476_4,
],
vec![
-0.691_628_8,
-0.228_353_02,
0.110_913_61,
0.106_528_59,
-0.173_485_19,
-0.040_805_902,
0.203_944_06,
-0.366_668_88,
0.147_183_84,
-0.490_145_03,
],
vec![
0.456_025_42,
-0.025_084_412,
-0.650_509_3,
0.048_621_442,
0.065_681_994,
-0.435_010_22,
-0.478_657_13,
0.297_409_1,
-2.209_085_7,
-2.428_078,
],
vec![
-0.779_053_87,
-0.167_990_27,
0.034_315_918,
0.144_756_27,
-0.375_923_57,
-0.178_410_22,
0.417_126_63,
-0.057_014_92,
0.045_673_035,
-0.833_929_9,
],
vec![
-0.359_902_32,
-0.453_145_5,
0.376_054_2,
0.005_921_751,
-0.402_688_4,
-0.281_222_13,
-0.328_012,
0.300_563_34,
-0.322_811_7,
-0.074_488_41,
],
vec![
0.155_242_74,
-0.326_161_83,
-0.004_502_223,
0.111_678_13,
-0.222_018,
0.012_103_265,
-0.348_285_56,
-0.313_547_67,
-0.090_373_31,
0.160_877_32,
],
vec![
-0.779_235_84,
0.474_958_9,
0.174_592_91,
-0.627_929_2,
0.143_707_56,
0.655_198_63,
0.920_332_2,
-1.552_636_5,
-1.044_534_9,
-0.399_366_97,
],
vec![
0.396_845_64,
-0.116_464_78,
-0.188_253_75,
0.055_635_884,
-0.439_850_36,
-0.115_104_504,
-0.056_754_448,
0.037_380_192,
0.050_991_777,
0.002_617_539_4,
],
vec![
-0.062_194_28,
-0.033_647_98,
0.563_151_8,
0.341_664_5,
-0.104_682_36,
-1.025_237_4,
-0.539_365_8,
-0.000_981_343_2,
-0.223_044_22,
-0.168_867_19,
],
vec![
0.034_815_1,
-0.044_562_746,
0.251_306_33,
-0.103_972_74,
-0.293_429,
-0.159_355_21,
0.462_565_1,
-0.656_678_1,
-0.184_929_68,
0.138_410_73,
],
vec![
-0.174_431,
-1.836_079_8,
-0.516_358_14,
-0.740_650_9,
0.628_450_63,
0.170_128_93,
0.793_973_86,
0.020_685_973,
0.408_096_08,
-0.257_820_37,
],
vec![
0.114_661_67,
-0.360_247,
-0.330_312_13,
0.139_972_79,
0.192_194_07,
0.278_673_35,
0.177_378_13,
0.021_838_47,
-0.169_735_85,
-0.255_217_5,
],
vec![
0.028_787_855,
0.378_440_35,
0.000_291_143_08,
0.002_877_849_9,
-0.058_781_974,
-0.380_325_88,
-0.472_144_9,
0.718_679_3,
-0.138_149_2,
-0.280_253_98,
],
vec![
-0.207_616_76,
-0.588_388_74,
0.261_936_13,
0.095_424_83,
0.073_274_486,
-0.358_869_7,
0.323_256_52,
-0.497_251_27,
0.098_571_09,
0.244_916_02,
],
vec![
-0.053_375_665,
-0.907_372,
-0.727_244_5,
-0.735_421_36,
1.110_396_5,
-0.135_271_1,
0.323_004_5,
-0.285_868_73,
0.309_256_9,
0.093_485_77,
],
vec![
0.084_668_264,
-0.228_887_29,
-0.118_540_026,
-0.044_351_313,
-0.233_455_63,
0.082_216_516,
-0.374_227_14,
-0.009_539_394,
0.398_557_2,
-0.049_398_433,
],
vec![
-0.263_275_8,
-0.310_658_13,
-0.045_278_024,
0.538_273_16,
-0.228_020_5,
-0.319_284_53,
-0.379_847_7,
0.403_462,
0.080_615_55,
-0.393_287,
],
vec![
0.068_945_13,
-0.858_146_67,
0.032_959_49,
-0.034_787_893,
0.424_780_7,
-0.216_492_3,
0.112_251_35,
-0.547_673_2,
0.084_244_326,
0.356_082_77,
],
vec![
0.270_711_66,
-0.755_480_23,
-0.261_522_35,
-0.893_010_74,
0.546_178_9,
0.567_656_6,
0.107_416_8,
0.016_729_54,
0.054_772_306,
-0.339_417_46,
],
vec![
-0.102_297_716,
-0.127_307_89,
0.000_735_883_37,
0.086_636_01,
-0.433_231_8,
-0.243_996_05,
-0.712_842_9,
0.360_887_5,
0.110_613_66,
0.189_828_68,
],
vec![
-0.059_796_482,
-0.650_247_5,
0.098_926_224,
-0.024_830_63,
-0.814_044_24,
-0.161_119_15,
-0.094_905_17,
0.543_763_4,
0.024_063_092,
0.069_586_42,
],
vec![
-0.213_605_99,
-0.365_503_8,
-0.127_580_96,
-0.113_292_836,
0.228_936_3,
-0.064_502_29,
0.331_887_63,
-0.558_377,
-0.105_677_84,
0.444_680_2,
],
vec![
0.092_395_35,
-0.757_139_86,
-0.181_506_59,
-0.323_408_84,
0.503_436_9,
0.635_710_5,
0.275_355_67,
-0.271_641_22,
-0.356_673_75,
-0.198_984_77,
],
vec![
-0.320_055_9,
-0.051_496_968,
0.210_841_16,
0.095_058_99,
-0.900_580_4,
-0.156_174_99,
-0.703_600_94,
0.193_674_56,
0.199_007_3,
0.074_151_62,
],
vec![
-0.013_607_603_5,
-0.190_512_06,
-0.122_698_225,
-0.009_026_426,
-0.540_006_04,
0.150_625_72,
-0.424_062_43,
0.269_272_54,
0.120_677_96,
-0.155_426_44,
],
vec![
-0.143_616_9,
0.148_102_3,
-0.157_922_39,
-0.248_577_13,
0.257_107_26,
-0.471_419,
0.425_645_65,
0.091_029_1,
-0.133_166_4,
-0.123_961_67,
],
vec![
0.433_771_67,
0.247_506_9,
0.264_603_5,
-0.381_750_3,
0.335_878_8,
-0.245_618_85,
-0.068_682_83,
-0.399_691_46,
0.022_163_01,
-0.154_636_74,
],
vec![
-0.236_952_07,
-0.070_704_85,
0.307_582,
0.150_636_15,
-1.261_24,
-0.333_410_05,
-0.273_555_9,
0.428_589_14,
0.090_926_83,
0.019_844_66,
],
vec![
0.111_911_74,
-0.250_866_5,
-0.040_530_857,
-0.009_811_868,
-0.376_664_34,
0.104_442_65,
0.236_929_12,
0.013_377_204,
-0.148_502_3,
-0.034_420_002,
],
vec![
-0.591_157_1,
0.354_086_85,
-0.014_166_484,
-0.011_582_683,
0.490_577_4,
-1.111_166_6,
-0.253_583_64,
0.226_966_57,
-0.246_680_5,
-0.316_616_7,
],
vec![
0.504_683_3,
0.082_675_785,
0.287_152_26,
-0.142_236_1,
0.190_242_7,
-0.515_907_8,
-0.559_472_44,
0.154_153_21,
-0.010_323_325,
-0.047_526_196,
],
vec![
0.040_378_43,
-0.571_260_6,
0.326_861_7,
-0.038_053_866,
-0.517_120_9,
-0.016_231_31,
0.090_821_356,
0.315_481_07,
-0.096_167_43,
0.083_659_82,
],
vec![
0.171_835_9,
-0.296_782_73,
-0.215_916_13,
-0.310_014_22,
-0.178_923_47,
0.281_085_5,
0.054_179_72,
0.038_410_88,
0.157_684_07,
0.010_856_905,
],
vec![
-0.762_344_84,
-0.197_173_1,
-0.075_202_31,
0.061_614_38,
0.914_948_6,
-0.605_976,
-0.187_276_05,
0.057_749_826,
-0.446_927_88,
-0.033_777_487,
],
vec![
0.233_660_5,
0.015_873_462,
-0.005_255_001,
-0.047_930_67,
0.257_369_7,
-0.254_187_23,
-0.628_627_66,
0.188_018_29,
0.055_216_342,
0.058_550_056,
],
vec![
0.334_796_16,
-1.575_294_3,
-0.049_017_817,
0.073_439_24,
-1.058_597_1,
0.562_272_2,
0.137_210_01,
-0.083_788_86,
-0.103_471_24,
0.205_879_26,
],
vec![
0.152_744_38,
-0.078_858_71,
-0.300_489_6,
-0.508_556_37,
-0.266_207_28,
0.130_250_9,
-0.039_310_664,
0.147_595_6,
-0.039_225_88,
0.196_362_9,
],
vec![
-0.866_875_9,
-0.032_697_26,
-0.008_656_468,
0.190_088_78,
0.596_259_3,
-0.330_446_96,
-0.226_081_36,
0.625_718_9,
-0.563_011_1,
-0.301_735_8,
],
vec![
0.189_101_77,
0.056_929_618,
0.103_171_59,
0.099_822_3,
-0.248_609_11,
-0.085_192_98,
-0.267_723_77,
0.317_740_5,
-0.030_244_146,
-0.082_437_694,
],
vec![
0.031_138_998,
-1.029_084_6,
-0.341_533_42,
-0.254_793_05,
-1.071_284_2,
0.558_588_2,
0.475_417_94,
-0.036_093_22,
0.231_615_5,
-0.322_770_45,
],
vec![
0.206_510_78,
-0.975_108_86,
-0.343_907_36,
-0.275_595_87,
0.108_924_91,
-0.082_869_17,
0.311_547_16,
0.140_963_84,
0.180_081_08,
0.021_928_212,
],
vec![
-1.792_503,
0.350_376_55,
-0.283_779_7,
0.281_561_2,
0.248_667_24,
0.750_453_65,
-0.240_568_13,
0.259_737_46,
-0.099_345_72,
-1.129_956_1,
],
vec![
0.298_311,
0.325_646_67,
0.058_641_44,
0.327_485_47,
-0.216_788_63,
-0.641_922_06,
-0.490_922_72,
0.229_161_78,
-0.169_965_76,
0.082_617_49,
],
vec![
-0.676_340_46,
-0.086_615_1,
-0.990_129_9,
-0.964_055_06,
-0.247_590_47,
0.553_486_35,
0.752_743_9,
-0.568_961_1,
0.076_329_686,
0.269_663_78,
],
vec![
0.300_149_08,
0.034_903_92,
-0.273_156_73,
0.056_118_354,
-0.397_347_72,
0.280_960_4,
-0.701_381_3,
0.309_347_1,
-0.070_615_38,
-0.147_566_08,
],
vec![
-1.512_842_3,
0.122_137_405,
-0.179_424_73,
-0.621_348_2,
0.242_645_67,
0.254_495_02,
0.367_945_88,
1.093_051_2,
-0.087_014_63,
-1.320_766_2,
],
vec![
0.542_720_8,
0.077_151_79,
-0.531_274_4,
-0.059_125_736,
0.000_248_613_5,
-0.136_497_18,
-0.709_108_35,
-0.274_145_84,
0.022_545_459,
0.260_933_85,
],
vec![
-0.764_393_57,
-0.922_812_3,
-0.821_932_6,
-0.524_062_63,
0.694_806_46,
0.568_482_94,
0.471_779_05,
-0.350_464_94,
-0.237_650_19,
-0.299_388_14,
],
vec![
0.166_719_18,
-0.987_571_95,
-0.263_751_92,
-0.581_680_95,
-0.483_688_56,
-0.518_314,
-1.389_688_4,
0.515_866_94,
0.115_079_865,
-0.318_235_1,
],
vec![
-0.271_017_07,
0.027_525_388,
-0.597_32,
-0.095_019_13,
-0.346_175_88,
0.580_207_8,
0.300_787_75,
0.043_705_73,
0.192_469_06,
-0.462_464,
],
vec![
-0.096_515_015,
0.289_297_34,
-0.863_468_95,
1.005_157_8,
0.689_947_84,
-1.832_172_2,
-0.294_198_7,
-0.983_701_9,
-2.073_236_5,
0.231_339_78,
],
vec![
-0.207_874_55,
0.057_534_594,
0.094_972_5,
-0.265_003_83,
-0.204_895_66,
0.182_718_59,
0.165_258_41,
-0.206_470_95,
0.043_471_36,
-0.343_006_22,
],
vec![
-0.508_934_4,
0.487_504_9,
0.623_735_13,
0.645_485_3,
0.305_668_68,
-1.129_35,
0.055_277_206,
-0.114_775_866,
0.181_829_91,
-0.267_725_83,
],
vec![
0.226_889_83,
-0.029_484_963,
0.074_473_15,
-0.288_940_55,
-0.178_996_61,
-0.191_890_85,
-0.276_085_3,
-0.236_703_66,
0.093_048_16,
0.225_298_88,
],
vec![
0.153_564_24,
0.594_082_36,
-1.309_799_2,
-0.612_569_87,
-0.765_506_86,
-0.534_287_15,
0.528_604_87,
-1.124_329_4,
0.193_627_3,
0.739_874_84,
],
vec![
0.515_318_45,
-0.407_639_27,
0.022_146_78,
-0.034_811_374,
-0.463_529_68,
0.219_874_3,
-0.065_351_21,
-0.027_115_954,
-0.071_082_34,
-0.167_560_82,
],
vec![
-0.603_041_3,
0.173_094_06,
0.762_386_4,
0.372_296_84,
0.222_196_31,
-0.495_753_3,
-0.050_564_97,
0.188_722_49,
-0.672_652_3,
-0.178_792_94,
],
vec![
-0.007_911_94,
-0.482_079_4,
-0.032_675_47,
0.100_052_4,
0.052_513_74,
-0.225_124_18,
0.350_639_73,
-0.364_823_76,
-0.068_803_236,
0.187_773_08,
],
vec![
-0.062_913_46,
-0.409_758,
-0.320_442_44,
-0.662_729_5,
0.509_824_34,
-0.360_478_6,
0.261_233_48,
-0.390_644_28,
0.279_211_82,
0.240_606_68,
],
vec![
0.160_814_46,
-0.166_563_53,
-0.262_935_88,
-0.128_298,
0.155_533_05,
0.059_555_724,
0.234_794_65,
-0.034_388_43,
-0.145_194_62,
-0.093_202_814,
],
vec![
-0.473_849_77,
0.157_912_72,
0.307_175_3,
-0.267_877_85,
-0.035_855_27,
-0.207_699_18,
-0.755_759_1,
0.950_489_8,
-0.056_404_267,
-0.497_116_45,
],
vec![
-0.107_620_25,
-0.324_108_27,
0.029_556_079,
0.184_373_11,
0.007_395_293,
-0.526_876_57,
0.440_726_82,
-0.351_558_86,
-0.289_385_68,
0.304_280_7,
],
vec![
0.286_830_5,
-0.225_128_16,
-0.789_902_45,
-0.810_649_3,
0.174_392_4,
0.465_826_45,
0.181_955_62,
-0.288_959_44,
0.213_181_47,
0.089_912,
],
vec![
-0.127_923_15,
0.353_413_67,
-0.127_158_69,
0.096_508_25,
-0.535_945_6,
-0.188_380_03,
-0.068_326_57,
-0.082_721_69,
0.070_878_4,
0.082_282_38,
],
vec![
-0.180_664_45,
-0.405_656_93,
-0.136_641_98,
0.076_221_325,
0.185_186_62,
-0.130_355_78,
-0.347_225_52,
0.435_685_66,
-0.321_748_17,
-0.309_609_06,
],
vec![
-0.100_575_75,
-0.154_703_74,
-0.374_440_88,
0.506_969_3,
0.237_276_14,
-0.406_840_98,
0.281_832_3,
-0.290_095_18,
-0.199_270_83,
0.243_440_67,
],
vec![
0.221_755_46,
-0.790_980_94,
-0.791_633_2,
-0.824_782_43,
0.527_411_8,
0.514_031_65,
-0.120_601_065,
0.260_423_42,
0.167_460_32,
0.026_457_088,
],
vec![
0.109_922_58,
0.160_769_25,
-0.222_593_46,
-0.154_723_23,
-0.093_943_31,
0.204_556_7,
-0.885_124_86,
0.142_079_01,
-0.057_717_92,
0.302_287_22,
],
vec![
-0.424_106_03,
-0.129_682_73,
-0.087_105_61,
0.066_099_56,
-0.148_481_16,
-0.041_067_887,
-0.416_681_7,
0.047_628_727,
0.078_313_41,
0.058_919_758,
],
vec![
0.083_984_82,
-0.395_945_52,
-0.220_289_78,
0.432_484_95,
0.357_147_13,
-0.226_951_78,
0.522_340_24,
-0.679_507_1,
-0.194_740_58,
0.244_101_08,
],
vec![
0.102_482_185,
-0.045_399_34,
-0.080_852_3,
-1.222_988,
0.312_472_9,
0.321_611_9,
-0.034_010_515,
0.186_449_16,
0.316_959_83,
-0.126_345_13,
],
vec![
-0.429_622_08,
0.161_493_81,
0.117_336_29,
0.354_605_3,
-0.120_046_5,
-0.057_381_7,
-0.986_256_5,
-0.148_423_24,
0.157_069_16,
-0.052_750_13,
],
vec![
-0.529_666_66,
-0.341_064_48,
-0.274_165_27,
-0.241_169_75,
-0.250_266_55,
0.153_471_22,
0.504_053_7,
0.009_148_11,
0.325_742_24,
-0.271_160_96,
],
vec![
-0.219_010_8,
0.314_067_42,
-0.029_913_263,
0.225_025_37,
0.235_776_56,
-0.426_587_97,
0.019_475_369,
-0.328_953_74,
-0.212_118_6,
-0.039_429_653,
],
vec![
0.143_026_13,
0.481_122_58,
0.000_815_544_16,
-0.512_762_4,
0.290_940_82,
-0.322_919_73,
-0.410_684_62,
0.214_782_43,
0.438_849_93,
-0.633_576_15,
],
vec![
-0.262_988_4,
0.058_395_483,
0.047_117_49,
0.129_354_98,
-0.311_606_05,
-0.030_636_294,
-0.587_008_95,
0.526_908_46,
-0.221_597_34,
-0.057_889_156,
],
vec![
-0.420_213_37,
0.063_557_32,
-0.267_797_08,
-0.124_470_5,
-0.566_938_64,
0.322_641_5,
0.286_732_58,
-0.067_444_466,
0.005_744_403,
-0.038_390_506,
],
vec![
-0.308_161_3,
0.022_639_94,
-0.040_295_47,
-0.061_031_915,
0.307_230_35,
-1.548_439_5,
-0.172_096_15,
0.440_008_9,
-0.280_834_56,
0.058_319_97,
],
vec![
0.458_224_1,
0.032_741_494,
0.055_647_448,
-0.113_833_08,
0.055_677_84,
-0.582_109_33,
-0.714_378_95,
0.259_702_7,
0.250_479_64,
-0.138_732_57,
],
vec![
-0.168_027_2,
-0.447_512,
0.073_285_77,
-0.102_245_696,
0.211_200_82,
0.355_911_34,
-0.286_303_85,
0.156_530_63,
-0.162_364_41,
0.003_130_642_5,
],
vec![
0.185_978_83,
-0.570_623_6,
0.027_612_407,
-0.266_153_25,
0.065_444_656,
0.182_009_19,
0.460_085_06,
0.042_860_564,
-0.435_943_75,
-0.122_467_645,
],
vec![
-0.295_862_8,
-0.726_465_9,
0.146_314_5,
0.105_163_55,
0.482_668_34,
-1.920_136_9,
-0.409_983_5,
0.098_039_93,
0.039_303_19,
0.032_061_82,
],
vec![
0.452_977_72,
-0.052_895_073,
-0.147_236_78,
0.137_071_73,
0.388_998_57,
-0.387_540_73,
-1.293_666_4,
0.330_499_02,
-0.035_247_9,
-0.099_417_49,
],
vec![
-0.183_451_46,
-1.082_602_7,
0.062_292_03,
0.275_495_1,
-0.361_221_02,
0.438_744_07,
-0.066_024_98,
0.169_357_73,
-0.069_054_18,
0.049_622_405,
],
vec![
-0.193_424_6,
0.136_046_48,
-0.034_462_936,
-0.628_403_3,
-0.393_009_78,
0.316_833_26,
0.231_041_85,
0.009_123_952,
-0.018_631_496,
0.106_618_166,
],
vec![
-0.034_093_65,
0.055_894_96,
0.231_049_24,
0.157_845_62,
0.202_304_78,
-0.788_765_5,
-0.634_623_7,
0.049_663_093,
0.184_820_65,
-0.288_572_73,
],
vec![
0.628_891_6,
0.168_256_74,
0.297_308_53,
-0.028_807_169,
0.164_852_84,
-0.840_128,
-0.878_446_5,
0.055_374_74,
0.087_389_93,
-0.110_066_74,
],
vec![
-0.396_640_54,
-0.432_740_78,
-0.332_767_5,
0.127_875_18,
-0.812_790_04,
0.703_349_65,
0.588_560_9,
-0.182_696_03,
0.048_864_517,
-0.205_589_47,
],
vec![
0.322_684_76,
0.360_689_85,
-0.641_543_6,
-0.576_271_9,
-0.008_394_989,
-0.197_300_12,
0.157_365_19,
-0.066_966_61,
-0.090_489_98,
0.292_275_55,
],
vec![
-0.272_229_2,
0.315_918_8,
0.124_067_43,
0.765_923_2,
0.052_089_103,
-1.410_848_4,
-0.537_994_5,
0.172_129_54,
0.392_988_62,
-0.357_418_63,
],
vec![
0.452_900_53,
0.376_274_23,
-0.004_683_544,
0.227_762_8,
0.130_249_32,
-0.535_433_2,
-0.777_915,
0.194_872_07,
-0.117_443_47,
0.141_114_46,
],
vec![
-0.245_853_66,
-0.098_773_584,
-0.266_520_92,
-0.224_863_57,
0.072_216_59,
0.338_712_57,
0.346_051_6,
-0.182_631_73,
0.372_764_44,
-0.743_095_1,
],
vec![
-0.024_514_986,
-0.186_378_88,
-0.195_197_45,
-0.539_516_1,
0.022_574_846,
-0.175_003_86,
-0.087_664_865,
-0.077_440_86,
-0.164_217_31,
0.861_473_14,
],
vec![
-1.176_825_3,
0.600_365_4,
0.404_460_37,
-0.293_111_56,
-0.260_110_77,
-0.525_379_7,
-0.275_370_5,
0.106_287_07,
0.424_896_2,
-0.136_489_18,
],
vec![
0.222_941_64,
0.029_136_565,
0.116_637_25,
-0.101_515_725,
-0.630_471_9,
-0.480_908,
-0.131_508_16,
-0.083_099_48,
0.181_400_16,
0.018_836_357,
],
vec![
-0.698_895_8,
0.397_754_07,
-0.329_033_97,
-0.829_641_5,
-0.215_803_35,
0.786_333_6,
-0.887_877_46,
-0.488_177_72,
0.073_410_35,
-0.162_985_18,
],
vec![
-0.612_169_5,
0.394_888_82,
0.265_389_77,
-0.136_720_23,
-0.158_774_88,
-0.750_894,
-1.383_749_1,
0.339_417_8,
-0.662_179_9,
0.269_224_73,
],
vec![
-0.072_811_88,
0.551_298_3,
-0.895_189_5,
-0.493_569_1,
-0.362_095_6,
-0.150_884_27,
0.169_696_85,
0.268_407_05,
-0.066_993_49,
0.132_940_23,
],
vec![
-0.269_540_67,
0.507_770_36,
-1.427_464_2,
-0.734_724_04,
0.670_633_8,
-0.069_052_58,
-0.740_904_9,
0.356_450_95,
-1.593_374_7,
-0.755_425_75,
],
vec![
0.279_056_88,
0.221_050_87,
-0.755_368_77,
-0.364_125_76,
-0.068_900_07,
-0.011_887_714,
-0.325_549_84,
0.097_667_33,
-0.171_342_55,
-0.043_467_447,
],
vec![
-0.267_086_36,
-0.003_381_063_2,
1.405_259_5,
0.756_799_3,
-0.517_645_36,
-0.933_590_9,
-0.861_024_8,
-0.150_117_44,
0.463_376_55,
-0.722_872,
],
vec![
0.139_099_29,
0.409_524_17,
-0.086_981_5,
-0.271_768_42,
0.187_499_46,
-0.228_399_5,
0.182_433_95,
-0.265_324_68,
-0.142_243_36,
0.101_598_375,
],
vec![
0.300_135_97,
0.836_247_44,
-0.041_253_883,
0.630_782_84,
-0.605_257_15,
-1.116_649_7,
-0.420_335_23,
-0.816_147_4,
-1.019_898_3,
0.425_557_2,
],
vec![
0.274_344_47,
-0.073_296_27,
-0.139_558_94,
-0.127_952_72,
-0.147_588_34,
-0.144_747_42,
0.132_950_99,
0.321_829_9,
-0.121_689_826,
0.006_479_399,
],
vec![
-0.303_101_42,
-0.762_328_3,
1.457_457_9,
0.527_697_86,
-0.100_971_86,
-0.107_270_725,
-0.913_583_7,
-0.301_846_62,
-0.585_341_2,
-0.335_157_7,
],
vec![
0.114_905_74,
-0.830_199_8,
0.112_558_655,
0.260_842_4,
-0.028_218_849,
-0.104_110_68,
0.330_357_46,
-0.289_884_24,
-0.151_965_86,
0.032_366_27,
],
vec![
0.478_458,
-0.387_130_95,
-0.257_576_47,
-0.438_277_48,
0.059_315_678,
0.175_215_1,
0.827_331_6,
-0.895_138_6,
-0.217_182_8,
-0.067_494_41,
],
vec![
-0.119_126_08,
-0.331_597_45,
-0.124_621_876,
0.422_070_12,
-0.404_816_3,
0.149_707_75,
-0.334_017_57,
-0.044_708_37,
-0.099_329_48,
0.051_153_32,
],
vec![
-0.040_725_574,
0.289_044_26,
0.314_958_24,
-0.140_709_3,
0.047_588_103,
-0.066_910_43,
-0.671_796_2,
0.405_210_1,
-0.104_440_644,
-0.356_477_62,
],
vec![
0.354_324_8,
0.119_619_39,
-0.241_285_52,
0.639_350_9,
-0.132_232_64,
-0.158_766_76,
0.331_828_2,
-0.224_304_81,
-0.384_496_63,
-0.419_428_74,
],
vec![
0.177_356_42,
0.066_063_36,
-1.193_538_1,
-0.978_156_1,
0.130_779_65,
0.120_268_09,
7.424_281e-5,
-0.342_935_6,
0.447_567_02,
0.269_017_25,
],
vec![
-0.120_202_97,
-0.495_071_47,
-0.274_519_18,
0.217_942_33,
-0.305_900_04,
0.293_836_6,
-0.254_543_84,
-0.036_753_487,
0.248_177_4,
0.110_505_62,
],
vec![
-0.557_222_7,
-0.440_128_18,
0.688_790_44,
-0.358_640_04,
-0.019_008_324,
-0.128_100_08,
-0.436_285_23,
0.567_290_5,
-0.040_509_716,
-0.144_320_6,
],
vec![
0.178_449_63,
-0.038_515_09,
-0.128_087_36,
0.622_190_7,
-0.044_439_893,
-0.059_167_873,
0.016_673_934,
0.057_158_887,
-0.473_533_18,
-0.514_728_07,
],
vec![
0.201_881_47,
-0.331_614_8,
-1.440_653_1,
-1.318_789_6,
0.294_876_52,
0.125_336_42,
0.064_994_34,
0.061_897_79,
0.447_803_8,
0.315_823_6,
],
vec![
0.185_746_1,
0.026_766_932,
-0.182_838_05,
-0.193_032_18,
-0.191_380_25,
0.368_004_92,
-0.685_593_2,
-0.157_489_08,
0.131_066_74,
0.104_366_794,
],
vec![
-0.263_003_98,
-0.657_123_57,
0.488_098_4,
0.217_409_31,
-0.087_866_21,
0.232_031_39,
-0.269_720_44,
-0.295_114_82,
0.061_767_95,
-0.128_803_58,
],
vec![
-0.310_965_54,
-0.075_754_36,
-0.154_235_14,
0.432_455_93,
-0.477_501_12,
-0.202_793_76,
0.262_324_48,
0.195_774_76,
-0.491_202_83,
-0.246_570_48,
],
vec![
0.627_617_9,
0.130_057_8,
-0.699_788_63,
-0.849_566_5,
-0.067_410_79,
0.087_328_6,
-0.217_621_52,
0.255_800_58,
0.420_218,
-0.264_121_9,
],
vec![
-0.538_376_87,
0.208_895,
0.156_969_23,
0.196_063_2,
0.298_645_4,
-0.041_912_43,
-0.819_426_4,
-0.240_417_4,
-0.098_353_334,
0.238_580_81,
],
vec![
-0.552_053_33,
-0.496_717_3,
0.062_322_896,
0.024_250_77,
-0.391_012_04,
0.376_012_15,
0.596_021_83,
-0.888_136_6,
0.164_711_6,
-0.238_519_71,
],
vec![
-0.372_523_64,
0.355_542_48,
-0.066_765_964,
0.190_823_06,
-0.305_456_5,
-0.475_693_26,
0.038_526,
0.092_013_51,
-0.336_231,
-0.025_312_696,
],
vec![
0.769_496_56,
0.406_899_72,
-0.332_427_3,
-0.445_128_35,
-0.627_195_9,
-0.021_385_033,
-0.173_525_02,
0.440_466_17,
0.014_422_986,
-0.515_037_36,
],
vec![
-0.475_403_67,
0.171_622_47,
-0.163_997_93,
0.218_631_22,
0.053_364_147,
-0.018_264_074,
-0.638_809,
0.136_716_44,
-0.230_133_73,
0.381_585_48,
],
vec![
-1.587_163_6,
-0.057_017_2,
-0.228_662_16,
0.127_203_36,
-0.037_028_76,
0.185_854_69,
0.693_080_66,
-0.228_369_34,
-0.386_401_03,
-0.211_039_62,
],
vec![
-0.197_697_91,
-0.439_417_15,
0.216_187_72,
-0.003_696_140_1,
-0.160_376_13,
-0.774_046_4,
-0.031_133_998,
0.276_498_97,
0.028_302_014,
-0.084_735_41,
],
vec![
0.090_599_21,
0.285_985_1,
-0.131_176_73,
-0.362_053_6,
0.210_222_94,
0.005_901_443_3,
-0.687_696_1,
-0.021_012_772,
-0.088_486_426,
0.272_508_86,
],
vec![
-0.192_863_09,
-0.651_285_77,
-0.431_206_1,
0.247_956_42,
-0.883_735_1,
0.068_415_62,
0.074_062_16,
0.190_670_46,
-0.138_411_24,
0.383_481_26,
],
vec![
-0.262_158_33,
-0.356_746_85,
0.023_556_845,
-0.193_073_73,
-0.044_097_982,
0.221_795_44,
0.191_991_46,
0.201_811_48,
0.030_214_434,
-0.043_852_43,
],
vec![
-0.123_064_674,
-0.007_795_926,
0.224_337_09,
-0.068_207_6,
0.218_500_39,
-1.402_807_7,
-0.185_828_67,
-0.275_227_55,
0.153_196_45,
-0.167_605_76,
],
vec![
0.465_332_27,
0.239_009_44,
0.239_487_83,
-0.049_675_647,
0.322_712_87,
-0.361_904_1,
-0.783_763_95,
-0.214_422_43,
-0.097_743_59,
0.090_962_596,
],
vec![
0.043_396_69,
-1.521_370_5,
-0.508_483_9,
0.592_855_33,
-0.660_342,
0.312_460_4,
0.362_794_82,
-0.059_432_253,
0.339_404_9,
-0.327_934_7,
],
vec![
-0.104_387_17,
0.009_338_523,
-0.232_447_45,
-0.035_054_065,
-0.268_270_7,
0.478_249_04,
0.269_224_76,
-0.012_519_61,
-0.189_450_31,
-0.016_516_596,
],
vec![
0.107_782_304,
0.049_322_58,
0.437_887_46,
0.041_052_792,
0.288_527_52,
-2.289_670_2,
-0.452_973_34,
-0.328_008_35,
0.655_561_1,
-0.149_166_33,
],
vec![
0.265_693_13,
0.528_191_15,
0.106_833_115,
-0.031_265_777,
-0.066_381_5,
-0.430_439_44,
-0.698_310_3,
0.241_947_83,
-0.188_879_47,
0.252_632_14,
],
vec![
-0.216_927_25,
0.121_004_46,
-0.445_989_88,
0.430_346_04,
-0.351_781_46,
0.152_730_35,
-0.425_484_9,
-0.088_983_38,
0.422_131_7,
-0.464_601_13,
],
vec![
-0.360_672_53,
0.272_008_96,
-0.080_057_725,
0.201_231_36,
0.255_325_1,
0.169_969_59,
-0.024_861_794,
-0.017_412_573,
-0.317_985_1,
-0.423_185_65,
],
vec![
0.121_128_2,
-0.288_258_37,
0.299_752_38,
0.867_127_4,
-0.493_007_18,
-1.506_429_4,
-0.199_151_4,
0.115_783_59,
0.173_776_28,
-0.029_131_787,
],
vec![
0.606_763_3,
0.342_573_73,
-0.273_926_44,
-0.550_023_85,
-0.069_819_674,
-0.349_484_98,
-0.321_020_07,
0.041_649_144,
-0.116_718_37,
0.200_557_54,
],
vec![
-0.276_791_4,
0.079_295_136,
-0.143_560_71,
0.106_754_03,
-0.082_330_11,
0.400_106_37,
0.196_720_81,
-0.285_766_4,
0.135_733_26,
-0.657_691_24,
],
vec![
-0.193_547_56,
-0.307_601_33,
-0.076_231_666,
-0.365_790_6,
0.473_794_88,
-0.260_530_92,
0.097_811_81,
0.323_311_3,
-0.560_959_7,
-0.132_552,
],
vec![
-0.556_238_5,
0.743_008_6,
0.481_494_16,
0.769_308_3,
-0.494_354_67,
-1.742_812_3,
-0.691_182_9,
0.270_070_43,
0.570_542_63,
-0.470_118_34,
],
vec![
0.221_604_51,
0.072_595_246,
-0.703_638_85,
-0.193_811_58,
-0.599_087_06,
-0.332_261_5,
0.276_940_14,
0.066_991_21,
-0.039_732_546,
0.321_589_65,
],
vec![
-0.809_401_5,
-0.330_654_8,
0.653_460_8,
-0.424_901_87,
-0.184_362_64,
0.578_688_2,
-0.596_104_8,
-0.250_692_34,
-0.054_308_05,
-0.653_985_6,
],
vec![
-0.757_264_26,
0.429_740_1,
0.716_024_1,
0.120_151_47,
-0.597_643_4,
0.180_705_19,
-0.806_157_6,
0.257_461_58,
-0.015_053_513,
-1.014_189_7,
],
vec![
-0.394_121_2,
0.859_029_7,
0.112_626_344,
-0.747_587_4,
0.334_439_93,
-0.228_314_1,
-0.685_789_64,
-0.002_370_33,
-0.350_976_56,
0.267_583_22,
],
vec![
-0.533_223_7,
1.192_899_5,
0.018_847_07,
1.299_052_2,
-0.959_604_1,
-1.109_045_9,
-0.371_553_8,
1.284_699,
-1.822_740_6,
-1.447_136_5,
],
vec![
-0.346_053_45,
0.541_713_8,
-0.737_071_9,
-0.844_016_97,
-0.144_290_58,
0.096_683_5,
-0.726_433_8,
0.502_831_04,
-0.315_663_22,
0.241_362_14,
],
vec![
-0.237_618_37,
-0.054_344_088,
0.382_082_6,
0.053_052_82,
-0.476_174_8,
0.161_550_98,
0.060_836_162,
0.176_722_03,
-0.145_660_25,
-0.643_206_1,
],
vec![
0.313_486_46,
-0.040_602_36,
-0.581_557_5,
-0.075_771_7,
-0.297_903_95,
-0.003_757_668_7,
0.189_653_56,
0.180_933_73,
-0.196_731_37,
-0.133_598_33,
],
vec![
1.344_613_9,
1.172_998_8,
-0.202_547_77,
0.198_246_9,
-1.576_345_1,
-0.293_439_12,
-0.972_407_04,
-0.068_904_13,
-0.607_898_7,
0.297_143_25,
],
vec![
0.117_273_1,
-0.561_625_5,
-0.528_112,
-0.637_099_2,
0.209_079_3,
-0.027_501_42,
0.148_175_52,
0.340_330_1,
-0.197_580_55,
0.090_481_9,
],
vec![
-0.729_872_47,
0.592_992_07,
0.346_012_18,
0.104_230_6,
0.083_044_88,
0.357_109_3,
-0.601_610_66,
0.086_607_635,
-0.173_702_08,
-0.626_230_9,
],
vec![
0.122_043,
-0.018_491_197,
0.319_558_86,
-0.254_409_13,
-0.078_237_48,
-0.070_578_46,
0.239_353_3,
0.064_942_785,
-0.123_233_385,
-0.340_646,
],
vec![
0.582_297_4,
0.158_174_6,
-0.713_005_66,
-0.572_291_8,
-0.609_091_6,
0.350_477_34,
0.675_527_16,
-0.521_912_7,
-0.052_122_705,
0.171_072_05,
],
vec![
0.105_577_48,
0.187_516_94,
-0.722_696_54,
-0.129_852_52,
-0.061_905_567,
0.474_712_94,
-0.111_769_19,
0.223_120_48,
0.017_446_205,
-0.148_053_33,
],
vec![
-1.101_677_7,
0.066_154_94,
0.204_744_26,
0.431_297_1,
-0.281_498_5,
0.113_914_3,
-1.118_692_2,
0.674_603_04,
-0.015_837_92,
-0.210_914_73,
],
vec![
0.392_721_44,
-0.259_683_13,
0.303_213_18,
-0.002_489_187,
-0.032_669_59,
-0.399_611_35,
0.225_581_81,
0.264_008_67,
-0.450_054_56,
-0.351_068_35,
],
vec![
0.466_883_63,
-0.599_088_3,
-1.143_738,
-0.515_279_65,
0.090_717_19,
0.015_569_723,
0.412_253_83,
-0.076_723_94,
-0.476_769_86,
0.326_240_87,
],
vec![
-0.205_071_79,
0.077_396_1,
-0.564_069_6,
-0.010_824_216,
0.148_514_58,
0.648_877_9,
-0.107_025_71,
-0.133_371_64,
-0.317_537_13,
0.053_802_9,
],
vec![
-0.002_588_406_4,
-0.628_745,
0.242_333_65,
-0.274_682_16,
0.005_985_648,
-0.230_738_85,
-0.661_476_2,
0.266_736_95,
0.011_729_551,
-0.106_212_83,
],
vec![
0.473_162_8,
0.263_148_2,
0.284_964_68,
0.150_511_85,
-0.234_422_31,
-0.414_224_8,
0.007_981_45,
0.192_275_82,
-0.492_831_2,
-0.820_278_8,
],
vec![
0.448_108_9,
0.074_436_07,
-0.762_030_7,
-0.900_243,
-0.169_277_79,
0.501_497_5,
0.002_328_606_3,
0.056_543_965,
0.018_135_436,
0.052_846_033,
],
vec![
-0.012_141_257_5,
-0.190_645_49,
-0.550_309_24,
0.019_054_85,
0.281_741_7,
0.040_815_17,
-0.135_266_07,
0.038_118_172,
-0.057_037_137,
0.162_227_14,
],
vec![
-0.052_483_853,
-1.643_899_3,
0.285_089_28,
0.156_052_72,
0.180_602_33,
0.416_198_43,
0.111_903_85,
-0.716_806_7,
0.020_466_35,
-0.168_626_58,
],
vec![
-0.290_455_64,
0.152_129_28,
0.204_712_85,
0.267_162_02,
-0.640_323,
-0.111_096_29,
-0.082_332_194,
0.179_990_7,
-0.276_141_3,
-0.579_719_07,
],
vec![
0.411_667_73,
-0.181_603_67,
-0.617_817_9,
-0.463_887_9,
0.234_000_09,
0.517_197_8,
0.250_540_02,
-0.753_978_97,
0.009_809_169,
-0.214_948_12,
],
vec![
-0.391_700_7,
0.399_570_94,
-0.365_930_32,
-0.166_463_48,
0.427_735_72,
0.122_039_06,
-1.010_15,
-0.181_935_43,
0.056_771_737,
0.396_852,
],
vec![
-0.350_486_04,
-0.601_626_8,
0.281_698_82,
0.233_527_91,
-0.144_274_12,
0.168_160_99,
0.442_113_46,
-0.959_784_03,
-0.128_670_66,
-0.297_427_24,
],
vec![
-0.352_210_25,
0.495_663_37,
0.424_403_73,
-0.108_114_14,
-0.879_724_26,
-0.030_185_6,
0.297_537_15,
0.167_476_2,
-0.380_549_04,
-0.517_068_5,
],
vec![
-0.371_702_82,
0.131_365_8,
-0.030_542_398,
-0.460_730_94,
0.151_406_96,
0.211_525,
-0.245_326_33,
-0.119_136_095,
0.192_782_01,
0.041_209_22,
],
vec![
-1.033_863_7,
0.136_977_34,
-0.492_126_97,
0.453_187,
0.086_104_54,
0.129_965_51,
-0.221_679_52,
-0.755_657,
0.053_589_15,
0.655_690_8,
],
vec![
-0.544_424_5,
-0.237_751_4,
0.348_604_2,
-0.028_291_645,
-0.068_502_12,
0.086_517_86,
0.268_235_68,
-0.182_507_92,
-0.429_467_47,
-0.250_924_17,
],
vec![
-0.011_818_108,
0.797_707_86,
0.208_938_8,
-0.604_700_74,
-0.220_071_33,
-0.039_925_22,
0.163_447_38,
0.073_279_925,
-0.220_862_34,
-0.289_076_3,
],
vec![
0.129_709_68,
0.210_747_32,
-0.126_102_95,
-0.023_825_37,
0.344_960_84,
-0.135_978_13,
-0.421_447_52,
-0.209_916_95,
-0.252_269_18,
0.330_932_3,
],
vec![
-0.487_710_3,
-0.460_413_96,
-0.365_575_58,
0.197_697_94,
-0.364_175_53,
0.058_523_543,
0.196_115_24,
-0.393_850_65,
0.207_997_77,
0.395_273,
],
vec![
-0.198_588_37,
0.019_333_296,
-0.446_362_64,
-0.038_646_203,
0.071_068_4,
-0.048_991_922,
0.210_087_58,
0.239_180_73,
-0.022_882_91,
-0.188_380_54,
],
vec![
-0.261_959_97,
0.333_264_44,
0.400_236_37,
-0.264_737_37,
0.274_795_5,
-0.317_504_9,
-0.618_102_55,
0.205_943_23,
-0.636_521_04,
0.152_472_51,
],
vec![
0.022_477_72,
0.134_431_12,
-0.213_510_2,
0.248_061_33,
0.422_189_4,
-0.283_444_37,
-0.269_078_14,
0.057_764_01,
-0.206_792_04,
0.123_093_69,
],
vec![
-0.233_692_9,
-1.017_291_4,
-0.150_414_63,
0.274_501_23,
0.148_620_25,
0.027_794_993,
-0.129_495_64,
0.074_302_66,
0.300_377_1,
-0.246_190_31,
],
vec![
-0.150_708_17,
0.183_886_8,
-0.078_481_37,
0.087_658_904,
0.048_013_024,
0.170_886_93,
-0.114_284_694,
0.142_811_27,
-0.177_535_88,
-0.140_055_18,
],
vec![
0.028_543_837,
0.518_874_6,
0.242_091_75,
-0.347_047_03,
0.124_305_62,
-0.714_907_77,
-0.905_192_4,
0.157_255_22,
-0.434_522_57,
0.489_530_83,
],
vec![
0.217_295_18,
0.318_683_62,
-0.133_674_95,
-0.190_113_72,
-0.045_825_38,
-0.325_925_32,
-0.011_337_722,
0.141_903_42,
-0.049_026_8,
0.293_223_83,
],
vec![
0.123_400_32,
-0.106_249_37,
-0.084_128_685,
0.015_276_704,
0.481_030_76,
-0.324_463_07,
-0.327_308_92,
-0.216_746_37,
0.306_427_78,
-0.215_458_57,
],
vec![
-0.394_248_04,
0.267_972_32,
-0.323_327_48,
0.007_495_794,
0.274_354_7,
0.036_519_47,
0.021_192_394,
0.167_988_94,
0.037_339_807,
-0.287_706_64,
],
vec![
0.476_326_35,
-0.171_908_97,
0.187_209_59,
-0.184_707_57,
0.266_605_26,
-0.379_704_62,
-0.725_388_94,
-0.382_156_3,
0.052_183_09,
-0.189_024_15,
],
vec![
-0.068_175_21,
-0.936_696,
-0.284_851_34,
-0.312_424_24,
0.416_920_48,
-0.375_246_1,
0.166_914_12,
-0.062_018_942,
0.123_319_04,
0.251_326_02,
],
vec![
-0.092_383_966,
-0.046_410_43,
-0.046_993_304,
-0.388_989_8,
0.106_352_895,
0.124_601_215,
0.077_070_52,
-0.494_940_2,
0.246_576_04,
-0.217_108_47,
],
vec![
0.096_871_64,
0.016_262_09,
0.141_645_5,
0.007_451_025_3,
0.072_534_49,
0.056_562_357,
0.168_611_02,
-0.162_456_27,
-0.328_261_7,
-0.372_881_1,
],
vec![
0.243_483_26,
1.041_714_3,
0.791_361_9,
0.188_247_03,
-0.280_531_8,
-1.232_775,
-0.546_552_8,
-0.402_143_33,
-0.092_386_58,
-0.397_024_24,
],
vec![
0.179_208_04,
-0.010_297_535,
-0.525_091_9,
0.028_228_113,
-0.497_619_2,
0.147_705_4,
0.225_470_04,
0.150_027_7,
-0.438_805_9,
-0.228_523_7,
],
vec![
-0.409_310_8,
0.074_870_44,
1.139_456_7,
-0.908_665_6,
0.320_797_95,
-0.477_966_25,
-0.522_859_04,
-0.480_945_1,
0.096_658_655,
-0.717_741_85,
],
vec![
0.134_947_06,
-1.164_856_6,
0.246_233_84,
-0.609_766_54,
-0.025_210_831,
0.393_831_34,
0.685_161_7,
-0.135_826_19,
-0.096_989_535,
-1.079_150_1,
],
vec![
-0.049_614_098,
-0.048_862_495,
-0.094_735_25,
-0.314_993_68,
0.411_675_1,
-0.036_843_784,
-0.471_937_2,
-0.006_239_565,
-0.048_200_63,
-0.049_639_5,
],
vec![
-0.453_031_18,
1.981_460_9,
-0.534_942_5,
1.134_923_5,
-1.180_825,
-0.436_842_23,
-0.440_320_67,
-0.145_491_84,
-1.055_054_4,
-1.082_154_6,
],
vec![
0.034_054_637,
0.987_097_86,
-0.180_340_56,
-0.405_921_8,
0.348_030_4,
-0.096_445_14,
-0.402_231_4,
0.393_197_66,
-0.034_837_45,
0.040_728_43,
],
vec![
-0.927_784_8,
-0.331_701_96,
0.043_690_126,
0.348_231,
-0.148_379_56,
0.751_553_5,
-0.743_430_8,
-0.633_260_6,
0.104_607_72,
-1.347_444_8,
],
vec![
0.294_677_2,
-0.262_028_93,
0.090_968_82,
-0.851_627_65,
-0.251_495_75,
-0.048_707_057,
0.087_642_65,
0.418_791_4,
-0.020_625_126,
-0.118_388_51,
],
vec![
1.411_125_4,
1.265_975_8,
-0.123_655_915,
-0.262_882_35,
-0.469_494_76,
-0.835_732,
0.179_724_92,
-0.081_000_865,
0.255_376_25,
-0.679_300_84,
],
vec![
0.239_018_35,
-0.071_063_62,
-0.550_355_73,
-0.908_293_96,
0.655_489_9,
-0.153_276_28,
-0.025_848_849,
-0.045_441_143,
0.145_653_16,
-0.070_270_97,
],
vec![
-0.897_942,
-0.021_246_374,
0.240_951_28,
0.323_842_38,
-0.729_248_46,
0.805_137_04,
-0.773_077,
-0.093_318_924,
-0.176_274_8,
-0.478_634_36,
],
vec![
0.251_268_6,
-0.085_224_04,
0.239_970_9,
-0.587_481_9,
-0.303_148_87,
-0.313_885_15,
0.300_267_34,
0.437_304_08,
0.087_836_996,
-0.311_975_42,
],
vec![
0.068_631_664,
-1.392_326_2,
-0.099_468_19,
-0.284_783_1,
-0.793_635_5,
-0.480_267_6,
0.925_394_9,
0.271_452_1,
0.133_807_76,
-0.084_477_43,
],
vec![
0.343_252_6,
-0.774_502_7,
-0.502_526_34,
-0.191_540_2,
0.355_186_13,
-0.262_243_15,
0.226_072_86,
-0.442_591_1,
-0.060_238_685,
0.115_893_52,
],
vec![
-0.657_791_6,
-0.128_316_4,
-0.296_290_46,
0.371_296_1,
0.013_583_544,
0.408_244_16,
-0.542_473_1,
0.314_351_05,
-0.361_760_5,
-0.321_493_12,
],
vec![
-0.003_390_869_6,
-0.328_679_44,
0.424_497_7,
-0.643_421_35,
-0.429_855_6,
-0.255_417_76,
0.101_383_574,
0.742_305_46,
0.214_543_4,
-0.402_187_14,
],
vec![
0.561_219_3,
-1.216_058_3,
-0.270_737_44,
-0.528_367_9,
-0.021_387_836,
-0.619_280_5,
0.504_366,
0.262_697_73,
0.132_761_42,
-0.220_773_73,
],
vec![
0.288_668_9,
0.052_324_463,
2.730_375_9e-6,
-0.561_678_7,
0.170_008_32,
-0.008_383_047,
0.310_118_82,
-0.481_119_4,
-0.014_314_591,
-0.155_750_17,
],
vec![
-0.162_936_06,
-0.757_794_5,
-0.428_959_85,
0.198_041_78,
0.044_626_14,
0.308_839_4,
-0.573_860_47,
0.142_511_28,
-0.463_218_15,
0.459_949_67,
],
vec![
-0.108_998_46,
0.143_664_78,
0.287_137_18,
-0.579_912_4,
-0.686_672_4,
-0.728_061_9,
0.073_713_4,
0.220_625_89,
0.278_465_2,
-1.068_123_3,
],
vec![
0.418_938_52,
-0.238_915_4,
-0.297_480_58,
-0.299_199_64,
-0.162_441_09,
0.114_193_65,
0.343_621_76,
-0.145_716_18,
0.115_891_285,
-0.330_101_67,
],
vec![
-0.529_461_15,
0.026_722_493,
-0.540_848_5,
0.035_596_557,
0.177_273_08,
0.194_150_37,
-0.056_900_654,
-0.362_647_8,
0.054_201_64,
0.224_758_28,
],
vec![
-0.039_142_657,
-1.410_656_8,
0.004_147_059_7,
0.122_750_55,
0.601_991_5,
-0.190_151_87,
-0.217_774_1,
-0.161_282_72,
-0.107_949_33,
0.053_716_59,
],
vec![
0.112_159_1,
0.046_277_083,
0.275_921_76,
-0.232_220_19,
-0.514_986_8,
-0.385_808_1,
0.475_410_9,
-0.089_640_72,
0.377_189,
-0.587_000_6,
],
vec![
0.422_242_9,
0.303_726_17,
-0.226_179_72,
-0.223_675_2,
-0.390_193_07,
0.241_592_42,
0.510_321_9,
-0.769_924_46,
-0.186_996_15,
-0.151_660_49,
],
vec![
-0.384_535_1,
0.537_968_6,
-0.524_274_23,
-0.155_019_48,
-0.126_955_48,
0.009_772_035,
-0.516_424_9,
-0.234_940_9,
0.141_023_25,
0.588_008_3,
],
vec![
0.190_469_76,
-0.174_279_08,
-0.032_924_425,
0.020_208_841,
-0.119_237_93,
0.320_741_65,
0.307_459_98,
-0.463_212_76,
-0.407_833_8,
-0.337_217_8,
],
vec![
0.027_527_304,
0.197_919_01,
0.425_531_77,
-0.485_134_8,
-0.014_653_06,
-0.029_860_709,
-0.220_132_3,
0.131_642_21,
-0.104_282_19,
-0.386_906_83,
],
vec![
-0.430_011_15,
0.425_528_88,
-0.203_507_21,
0.393_514_2,
-0.351_871_97,
-0.370_563_15,
-0.020_044_824,
-0.261_879_5,
-0.169_493_78,
0.200_067_86,
],
vec![
-0.567_681_25,
0.480_915_58,
-0.412_805_86,
0.302_825_93,
0.206_955_4,
-0.122_011_974,
-0.448_144_94,
-0.255_924_28,
-0.053_469_803,
0.390_555_17,
],
vec![
-0.619_630_6,
-0.184_751_24,
0.014_298_667,
-0.047_660_213,
-0.404_390_66,
0.110_633_64,
0.399_682_85,
0.151_165_56,
-0.159_483_1,
-0.407_734_16,
],
vec![
0.208_748_55,
0.558_834_97,
0.362_687_92,
-0.338_483_3,
-0.221_743_66,
0.158_116_89,
-0.274_581_67,
0.068_234_116,
-0.376_377_3,
-0.102_255_44,
],
vec![
0.337_487_16,
0.171_616,
-0.152_372_08,
-0.012_385_000_5,
-0.132_557_57,
-0.028_043_98,
-0.117_279_43,
-0.153_480_23,
0.006_574_648_4,
0.038_567_707,
],
vec![
-0.712_001_6,
-0.511_211,
-0.150_782_73,
0.340_937_82,
0.254_123_18,
-0.259_644_8,
-0.165_634_53,
-0.125_767_35,
0.116_586_65,
0.397_081_2,
],
vec![
-0.124_941_25,
-0.073_137_37,
-0.225_942_08,
0.021_587_688,
-0.310_861_4,
0.265_024,
0.437_512_52,
0.267_344_92,
0.350_228_64,
-0.933_803_86,
],
vec![
0.338_834_3,
-0.087_845_86,
0.272_357_1,
-0.358_795_73,
-0.271_767_88,
-0.295_830_1,
-0.059_075_07,
0.070_103_78,
-0.507_834_4,
0.156_935_7,
],
vec![
-0.171_727_24,
-0.071_319_28,
-0.174_659_65,
-0.190_311_45,
-0.024_922_764,
-0.155_949_18,
0.055_906_9,
0.300_718_64,
-0.061_120_763,
0.048_273_016,
],
vec![
0.000_543_689_76,
-0.869_367_8,
-0.138_599_25,
0.174_714_95,
-0.186_816_26,
0.022_358_809,
0.002_629_159_7,
-0.115_649_6,
0.283_790_8,
0.002_904_132_5,
],
vec![
-0.068_747_63,
0.092_202_19,
0.011_669_183,
-0.379_747_6,
0.117_012_89,
0.107_468_17,
-0.269_050_3,
-0.006_621_833_4,
0.417_878_3,
-0.313_864_7,
],
vec![
-0.112_997_69,
-0.889_295_4,
-0.023_633_067,
-0.089_614_69,
-0.415_933_13,
-0.074_443_22,
0.258_668_63,
0.419_528_16,
-0.490_358_4,
0.197_501_69,
],
vec![
0.019_912_645,
-0.075_473_6,
-0.420_859_46,
-0.192_252_4,
0.229_218_27,
-0.212_090_2,
0.296_866_33,
0.250_561_54,
-0.184_706_94,
0.165_873_05,
],
vec![
0.230_182_22,
-0.870_116_8,
0.038_269_054,
-0.076_351_45,
0.106_413_856,
-0.440_263_87,
0.128_705_7,
0.447_829_48,
0.203_339_47,
-0.447_020_9,
],
vec![
-0.457_046_75,
-0.235_179_57,
0.229_851_17,
-0.228_986_76,
0.471_583_55,
0.118_459_63,
-0.331_542_28,
-0.029_790_87,
0.048_763_033,
-0.408_412_78,
],
vec![
-0.091_034_68,
0.269_622_06,
-0.811_667_6,
0.296_985_98,
0.857_716_3,
-0.322_717_55,
-0.288_414_87,
0.545_152_7,
-0.844_064_9,
0.156_081_7,
],
vec![
-0.044_334_59,
-0.443_265_35,
-0.400_787_65,
0.110_924_87,
0.339_526_06,
-0.231_262_07,
-0.021_097_727,
0.399_813_53,
-0.274_332_88,
-0.021_325_925,
],
vec![
0.025_087_234,
0.216_655_64,
0.621_734_44,
-0.760_260_46,
-0.129_668_74,
-0.154_173_79,
0.086_462_654,
-0.375_934_66,
-0.049_108_52,
-0.459_173_02,
],
vec![
-0.095_576_91,
-0.020_821_411,
0.080_915_31,
0.013_726_328_5,
-0.059_133_276,
0.063_827_924,
0.112_209_514,
0.007_046_244_6,
-0.146_494_31,
-0.216_906_01,
],
vec![
0.049_646_854,
0.052_594_967,
0.154_725_54,
-1.005_775_5,
0.319_017_6,
-1.194_001_3,
-0.009_135_441,
0.154_628_23,
-0.284_685_82,
0.506_814_8,
],
vec![
0.152_965_72,
-0.356_905_73,
-0.571_670_65,
0.213_715_2,
-0.072_330_84,
0.214_608_12,
0.078_163_56,
0.217_828_07,
-0.173_689_4,
-0.658_648_5,
],
vec![
-0.376_370_76,
-0.150_108_67,
1.302_906_6,
-0.957_640_2,
-0.188_971_88,
-0.377_166_48,
-0.026_720_16,
-0.298_091_2,
-0.841_070_23,
-0.638_804_4,
],
vec![
0.240_924_88,
0.182_269_63,
0.259_873_6,
-0.018_908_517,
0.249_969_38,
0.004_253_394_4,
0.937_601_6,
-0.470_375_4,
-0.213_874_68,
-1.540_429_6,
],
vec![
0.308_340_9,
-0.562_844,
-0.056_334_414,
-0.376_736_97,
0.149_921_98,
-0.111_814_16,
0.267_282_43,
0.267_317,
0.036_327_82,
-0.108_395_79,
],
vec![
-0.230_489_94,
0.410_497_9,
-0.547_524_63,
0.039_614_655,
-0.988_154_4,
0.321_934_58,
-0.602_366_27,
1.047_812_8,
-1.289_899_1,
-1.083_098,
],
vec![
0.123_964_37,
-0.602_205_9,
0.236_914_6,
-0.170_817_54,
0.318_853_38,
-0.315_294_36,
0.268_049_06,
-0.053_268_034,
0.330_402_97,
-0.339_753_27,
],
vec![
-1.076_121_9,
0.164_622_11,
-0.085_991_43,
0.311_612_9,
0.092_236_77,
0.700_294_7,
-0.707_306_2,
0.388_372_15,
-0.459_460_05,
-0.878_541_9,
],
vec![
0.054_824_94,
-0.208_323_96,
0.255_419_28,
-0.643_839_1,
-0.036_447_406,
0.071_171_485,
0.106_985_23,
0.008_280_316,
0.163_153_02,
-0.149_317_26,
],
vec![
0.509_663_3,
-0.604_420_36,
0.096_587_76,
0.317_167_55,
-0.619_287_67,
-0.598_932_6,
0.624_861_54,
-0.523_107_9,
-0.194_404_69,
0.189_819_41,
],
vec![
0.118_258_34,
0.198_966_8,
0.067_972_64,
-0.302_075_48,
0.396_576_85,
-0.190_334_44,
0.101_252_384,
0.113_482_1,
-0.184_157_92,
-0.121_548_79,
],
vec![
-1.145_558_1,
0.348_045_68,
-0.423_409_37,
0.440_486_2,
0.072_455_76,
0.763_049_54,
-1.268_408_3,
0.250_111_82,
-0.516_340_8,
-0.221_704_6,
],
vec![
-0.262_807_97,
0.276_520_13,
0.106_213_8,
-0.840_162_6,
0.052_412_167,
-0.070_005_19,
0.178_391_87,
0.462_775_5,
0.266_045_6,
-0.749_436_86,
],
vec![
-0.202_437_94,
-2.144_087_3,
-0.066_604_58,
0.145_307_91,
-0.324_613_12,
-0.216_517_84,
0.162_818_63,
0.020_858_074,
0.214_596_1,
-0.151_569_08,
],
vec![
0.260_816_72,
0.047_080_51,
0.223_103_91,
-0.463_461_3,
0.378_594_96,
-0.177_486_64,
-0.119_682_61,
-0.136_843_38,
-0.316_811_6,
-0.301_904_92,
],
vec![
-0.050_370_42,
-0.113_588_64,
-0.635_774_6,
0.286_719_14,
0.100_364_72,
0.363_518_63,
-0.715_137_06,
-0.032_084_25,
-0.612_420_6,
0.366_159_14,
],
vec![
0.074_133_57,
-0.351_425_38,
0.301_147_34,
-0.591_415_8,
-0.691_740_3,
-0.058_086_09,
-0.023_912_637,
0.035_622_265,
0.253_961_95,
-0.318_256_23,
],
vec![
0.253_794_28,
-1.398_279_4,
0.025_405_943,
-0.100_225_77,
0.264_267_9,
-0.325_903_53,
0.353_900_52,
-0.329_170_82,
0.209_164_6,
-0.406_238_32,
],
vec![
0.052_275_31,
-0.042_211_66,
0.013_816_439,
-0.162_884_19,
0.066_365_06,
0.099_114_14,
-0.112_847_95,
-0.683_042_2,
0.152_652_59,
0.247_954_49,
],
vec![
-0.169_138_82,
0.063_316_345,
-0.076_943_83,
0.330_167_4,
-0.332_760_45,
0.434_988_68,
-0.467_590_93,
-0.163_963_1,
-1.147_984_3,
0.389_239_9,
],
vec![
0.396_338_05,
-0.439_943_28,
0.338_350_42,
-0.212_763_92,
-0.067_297_46,
-0.154_291_87,
-0.127_878_6,
0.205_634_64,
0.341_983_68,
-0.700_542_45,
],
vec![
0.459_232_57,
-0.363_285_15,
0.151_907_15,
-0.270_820_17,
0.009_670_896,
-0.742_408_9,
0.592_906_8,
-0.601_926_5,
0.274_525_64,
-0.695_935_1,
],
vec![
0.355_251_46,
-0.182_071_31,
-0.383_383_57,
0.006_683_327_3,
-0.227_649_12,
-0.277_776_72,
0.543_340_56,
-0.651_580_8,
-0.098_558_836,
0.477_418_54,
],
vec![
0.293_424_58,
-0.607_008_34,
-0.075_632_825,
0.467_701_73,
0.293_549_72,
0.043_996_7,
-0.236_586_54,
-0.435_596_67,
-0.384_609_1,
-0.038_321_488,
],
vec![
0.709_046_07,
-0.007_807_638_5,
0.201_393_7,
-0.629_413_4,
-0.310_686_8,
-0.164_051_59,
0.216_480_8,
0.212_010_01,
0.288_591_68,
-0.234_935_46,
],
vec![
0.248_700_96,
0.463_258_9,
0.213_166_83,
-0.493_549_7,
-0.500_947_36,
-0.233_916_37,
-0.170_004_2,
-0.395_093_44,
0.287_036_15,
-0.080_354_17,
],
vec![
0.061_269_62,
0.258_783_22,
-0.153_121_84,
0.113_186_5,
0.024_635_103,
-0.002_860_725_6,
-0.411_487_85,
-0.585_028_9,
0.044_166_09,
0.228_433_37,
],
vec![
0.132_530_67,
-0.180_983_57,
0.134_121_52,
0.275_544_58,
-0.566_425_5,
0.038_025_07,
0.315_159_92,
-0.802_072_64,
0.077_547_364,
-0.816_164_1,
],
vec![
0.253_262_8,
-0.189_946,
0.331_578_8,
-0.404_263_38,
-0.151_000_84,
0.073_550_07,
0.053_775_515,
-0.105_317_04,
0.135_138_12,
0.010_357_873,
],
vec![
-0.262_911_5,
0.242_837_41,
0.207_556_83,
-0.334_707_74,
0.097_789_675,
-0.122_015_78,
-0.137_531_04,
-0.221_596_08,
0.078_258_86,
0.196_424_14,
],
vec![
-0.473_952_86,
0.088_429_66,
0.038_478_95,
0.179_662_59,
0.068_714_57,
-0.325_091_87,
-0.105_515_07,
-0.208_877_01,
-0.020_721_51,
0.331_142_9,
],
vec![
-0.213_202_6,
0.111_628_61,
0.141_606_03,
-0.075_352_96,
-0.104_872_68,
0.249_525_04,
0.052_972_06,
-0.699_384_57,
0.108_099_86,
-0.880_204_74,
],
vec![
-0.012_819_135,
-0.188_733_34,
0.122_128_38,
-0.165_244_4,
-0.388_994_16,
0.040_872_46,
-0.008_985_156,
-0.082_336_16,
-0.231_696_62,
0.065_530_87,
],
vec![
-0.180_819_06,
0.083_178_22,
0.006_874_827,
-0.014_614_635,
-0.196_168_27,
-0.009_432_043,
0.327_855_74,
-0.241_962_02,
0.248_983_44,
0.071_856_335,
],
vec![
0.193_247_78,
-0.291_666_98,
0.176_878_88,
0.231_443_12,
-0.066_874_83,
-0.252_131_64,
-0.190_652_65,
-0.171_646_98,
0.055_850_454,
0.101_139_7,
],
vec![
0.109_673_426,
0.237_693_83,
0.214_820_58,
-0.169_411_7,
-0.470_538_05,
0.039_358_5,
-0.303_813_25,
-0.118_628_58,
0.180_367_75,
-0.518_705_84,
],
vec![
0.140_499_17,
-0.128_086_85,
-0.378_094_9,
-0.231_051_09,
-0.440_477_82,
0.065_958_3,
0.249_295_49,
-0.348_497_84,
-0.145_569_32,
0.148_800_55,
],
vec![
-0.146_809_82,
-0.013_122_066,
-0.358_625,
-0.225_462_26,
-0.013_221_264,
0.116_620_995,
0.297_690_93,
-0.297_707_77,
0.305_377_8,
-0.088_207_8,
],
vec![
0.288_419_66,
-0.858_799_6,
0.276_324_63,
0.323_865_12,
-0.234_156_06,
-0.215_353_5,
0.236_237,
-0.344_054_8,
-0.057_662_178,
-0.177_651_82,
],
vec![
-0.080_386_27,
0.239_525_81,
0.180_896_65,
-0.285_275_5,
-0.050_495_982,
-0.374_826_3,
-0.278_306_45,
0.112_782_456,
-0.104_671_53,
0.304_652_18,
],
vec![
0.032_451_022,
-1.064_182_9,
-0.152_482_1,
0.093_027_7,
-0.703_669_3,
0.141_962_16,
-0.124_975_15,
-0.171_874_43,
-0.039_661_873,
0.445_249_56,
],
vec![
0.046_288_554,
-0.153_212_88,
-0.320_360_78,
0.280_627_1,
0.090_613_514,
-0.055_976_465,
-0.014_144_503_5,
-0.011_305_857,
-0.018_035_34,
0.011_035_047,
],
vec![
-0.086_249_456,
0.088_105_045,
0.368_546_1,
-0.155_759_65,
0.382_325,
-0.536_992_13,
0.188_152_09,
-0.136_534_48,
-0.361_743_2,
-0.208_948_1,
],
vec![
-0.910_889_7,
0.272_101_04,
0.135_209_81,
-0.349_540_56,
0.126_585_16,
-0.089_697_324,
-0.131_358_15,
0.545_545_9,
-0.205_144_06,
0.253_362_5,
],
vec![
-0.184_916_23,
-0.374_353_44,
-0.891_287_57,
-0.267_861_46,
-0.051_716_913,
-0.515_604_73,
0.253_273_43,
0.429_561_23,
0.509_542_35,
-0.086_592_466,
],
vec![
-0.081_433_564,
0.198_853_52,
-0.033_626_94,
0.073_289_62,
0.193_763_61,
-0.048_186_395,
0.127_340_51,
-0.342_430_5,
-0.154_588_85,
-0.207_824_74,
],
vec![
0.271_959_33,
-0.041_163_232,
0.437_336_15,
-0.443_907_1,
0.084_922_336,
-0.000_430_476_33,
-0.098_115_13,
-0.343_641_52,
-0.244_402_11,
-0.175_968_54,
],
vec![
-0.190_617_32,
0.230_641_68,
-0.188_811_4,
0.177_157_28,
0.048_706_33,
-0.090_728_484,
0.153_938_11,
0.037_883_04,
-0.355_102_63,
0.116_667_435,
],
vec![
0.402_895_78,
-0.317_966_88,
0.258_100_3,
-0.026_641_415,
-0.338_13,
0.090_999_93,
-0.261_858_8,
0.191_292_58,
-1.057_412,
0.382_777_07,
],
vec![
-0.309_803_16,
-0.035_574_716,
-0.368_250_88,
0.588_673_35,
-0.211_507_75,
0.018_968_955,
0.195_586_1,
-0.303_870_17,
-0.038_711_112,
-0.266_695_6,
],
vec![
0.029_523_142,
-0.132_643_09,
0.603_934_1,
-0.538_810_8,
-0.303_734_24,
-0.611_127_6,
0.207_553_15,
-0.042_333_387,
-0.207_477_15,
-0.986_770_5,
],
vec![
-1.344_093_9,
0.169_231_64,
0.061_742_768,
-0.253_307_07,
-1.425_251_2,
-0.079_412_21,
-0.527_068_44,
0.048_233_565,
0.255_186_32,
-0.558_624_4,
],
vec![
0.361_004_3,
0.166_129_93,
0.344_421_86,
-0.383_434_74,
-0.492_711_96,
-0.684_580_45,
0.575_839_94,
-0.431_959_2,
0.416_690_38,
-0.076_345_67,
],
vec![
0.300_126_25,
0.690_369_1,
-1.068_929_3,
0.779_963_97,
-1.161_616_9,
-0.320_421_67,
-0.699_888_4,
1.190_991_5,
-1.227_549_9,
-1.279_037_4,
],
vec![
0.094_041_63,
0.374_507_96,
0.558_502_3,
-0.320_508_27,
-0.070_787_884,
-0.315_834_9,
0.404_205_9,
-0.396_628_05,
0.213_888_62,
-0.808_717_4,
],
vec![
-2.094_858_6,
0.892_611_4,
-0.239_027_08,
0.395_698_2,
-0.483_642_64,
0.949_595_7,
-1.154_229_9,
-0.320_442_9,
-0.665_861_96,
-0.597_626_86,
],
vec![
-0.177_534_52,
0.252_983_5,
0.116_914_53,
-0.560_802_1,
0.087_838_47,
-0.090_237_91,
0.053_532_7,
-0.182_902_56,
0.084_240_03,
-0.088_681_21,
],
vec![
-0.538_007,
-0.922_660_95,
0.273_737_94,
0.454_611_18,
-0.405_907_57,
0.346_772_2,
0.337_938_85,
-0.476_058_45,
-2.544_968,
-0.027_647_516,
],
vec![
0.253_208_6,
-0.398_181_68,
0.117_977_105,
-0.118_475_36,
0.316_321_02,
-0.069_564_12,
-0.162_117_57,
-0.532_771_77,
-0.053_623_687,
-0.046_250_254,
],
vec![
-1.595_345,
0.359_475_85,
-1.132_169,
0.432_727_55,
0.061_862_98,
0.488_555_88,
-1.566_254_6,
-0.057_182_09,
-0.608_943_34,
0.738_639_4,
],
vec![
0.142_813_28,
0.105_241_664,
0.111_599_65,
-0.381_024_63,
0.080_321_72,
-0.142_857_43,
-0.264_929_5,
-0.184_825_7,
0.159_262_42,
-0.245_617_99,
],
vec![
0.655_968,
-1.573_916,
0.432_372_96,
-0.298_297_8,
0.502_385_26,
-0.046_713_434,
-1.533_887,
-0.506_285_85,
-0.146_341_43,
0.242_697_31,
],
vec![
-0.024_878_51,
-0.016_973_916,
-0.008_455_125,
0.239_947_11,
0.124_730_94,
-0.347_739_07,
0.378_534_85,
-0.622_885_4,
-0.110_197_38,
0.128_122_76,
],
vec![
-0.218_680_77,
0.007_973_12,
-0.552_104_8,
0.386_266_47,
-0.118_366_756,
0.403_684_44,
-1.525_699_7,
-0.182_769_82,
-0.480_417_88,
0.622_442_54,
],
vec![
-0.303_771_9,
-0.042_189_557,
0.092_569_9,
-0.574_998_4,
0.298_017_68,
0.167_696_8,
-0.202_827_51,
-0.142_146,
-0.028_678_67,
0.029_778_654,
],
vec![
0.486_929_45,
-0.567_170_5,
0.417_988_18,
-0.692_029_06,
0.041_134_74,
-0.792_387_4,
0.482_731_85,
-0.081_591_256,
0.193_019_3,
-0.081_880_37,
],
vec![
-0.295_165_42,
0.512_547_5,
0.021_734_945,
0.172_966_55,
0.024_421_481,
-0.130_438_34,
0.182_010_81,
-1.150_716_8,
-0.215_264_6,
0.355_813_6,
],
vec![
-0.072_581_3,
-0.071_467_33,
-0.358_769_15,
0.369_515_5,
-0.309_179_04,
0.183_673_81,
-0.194_713_83,
-0.686_681_75,
-0.520_779_43,
0.190_687_49,
],
vec![
-0.304_834_3,
-0.003_794_444,
-0.041_297_033,
-0.344_114_3,
0.262_485_65,
0.134_406_94,
-0.385_703_86,
0.163_270_4,
-0.027_921_52,
-0.225_358_17,
],
vec![
0.152_046_65,
0.351_264_2,
-0.055_531_275,
-0.621_087_25,
0.161_118_24,
-0.318_924_28,
0.309_624_1,
-0.128_448_31,
0.275_008_44,
-0.246_409_85,
],
vec![
-0.123_393_57,
0.319_738_15,
-0.188_316_5,
-0.068_521_924,
0.008_892_386,
-0.022_754_567,
-0.047_962_56,
-0.411_065_5,
-0.109_584_08,
0.294_392_1,
],
vec![
0.223_933_8,
-0.908_405_07,
-0.109_861_635,
0.140_895_23,
-0.903_743_2,
0.259_576_98,
-0.231_276_26,
-0.505_061_3,
-0.055_671_822,
-0.141_510_58,
],
vec![
0.027_742_716,
-0.232_495_8,
-0.149_456_53,
-0.133_731_6,
0.017_137_157,
-0.092_800_43,
-0.595_613_24,
0.376_796_96,
-0.213_737_58,
0.137_654_66,
],
vec![
-0.183_406_59,
0.552_172_5,
-0.378_588_3,
-1.007_870_4,
-0.015_809_247,
-0.196_884_62,
0.240_182_82,
0.050_163_735,
0.068_832_89,
0.203_356_61,
],
vec![
0.287_887_1,
0.079_854_11,
-0.084_014_416,
-0.248_976_04,
-0.271_918_54,
-0.002_412_714_8,
0.216_199_38,
-0.569_119_1,
-0.112_770_88,
0.540_719_6,
],
vec![
0.222_881_64,
-0.026_424_6,
0.048_772_09,
-0.146_413_06,
-1.901_193_9,
0.080_811_17,
0.147_072_54,
-0.397_790_46,
0.009_769_149,
-0.488_872_17,
],
vec![
0.138_054_16,
-0.538_929_9,
-0.023_378_126,
-0.111_065_865,
0.276_592_94,
0.011_875_795,
-0.575_297_5,
0.184_301_76,
-0.287_715_35,
0.065_143_935,
],
vec![
-0.552_735_4,
0.170_184_34,
0.113_717_236,
-0.240_356_07,
-0.123_588_435,
-0.058_988_72,
0.245_473_03,
-0.165_541_07,
0.144_339,
0.003_233_700_5,
],
vec![
-0.029_856_594,
-0.252_960_12,
-0.012_215_844,
0.236_105_9,
0.287_288,
-0.408_385_34,
0.423_000_07,
0.157_817_66,
-0.016_059_026,
-0.278_439_52,
],
vec![
-0.218_601_96,
0.037_431_795,
0.068_911_664,
-0.052_260_6,
-0.701_169_43,
0.143_489_64,
-0.029_043_015,
0.117_241_71,
0.118_014_246,
-0.401_062_9,
],
vec![
0.184_052_65,
-0.694_549_14,
-0.227_834_02,
-0.068_688_065,
0.418_908,
-0.010_074_062,
-0.385_147_06,
-0.237_238_53,
-0.169_812_08,
0.140_497_3,
],
vec![
-0.372_383_03,
0.067_174_725,
-0.166_325_8,
-0.080_401_81,
0.290_444_9,
-0.188_639_22,
0.151_756_58,
-0.076_491_4,
-0.021_862_388,
0.104_889_02,
],
vec![
-0.342_421_56,
-0.158_555_61,
0.302_041_56,
0.164_577_9,
-0.032_191_727,
-0.149_581_67,
0.314_295_02,
-0.236_396_77,
0.062_216_03,
-0.242_104_13,
],
vec![
-0.063_866_61,
0.546_288_43,
0.592_044_6,
-0.048_455_39,
-0.035_933_536,
-0.263_329_68,
-0.395_228_48,
0.051_577_035,
-0.290_856_4,
-0.260_335_45,
],
vec![
-0.204_643_31,
-0.790_377_5,
-0.423_973_1,
0.394_549_4,
0.158_310_1,
0.520_480_2,
-0.384_039_85,
-0.470_651_3,
-0.134_060_95,
0.067_312_695,
],
vec![
-0.243_832_14,
-0.189_681_66,
-0.170_536_52,
0.070_982_26,
0.210_219_16,
-0.105_663_456,
0.070_937_06,
0.024_109_1,
-0.006_263_296,
0.018_320_573,
],
vec![
-0.172_563_31,
0.441_392_72,
0.372_488_38,
0.003_720_252_3,
0.030_075_574,
-0.216_040_12,
0.399_601_82,
-0.655_864_2,
-0.083_364_85,
-0.593_644_4,
],
vec![
0.027_736_979,
0.826_652,
0.822_206_2,
-0.582_489_25,
-0.044_828_773,
-0.581_488_4,
-0.285_438_2,
-0.379_783_5,
-0.286_307_07,
-0.102_620_09,
],
vec![
0.314_700_75,
-1.524_852_9,
-0.763_385_1,
0.722_350_4,
-0.472_515_5,
0.452_854_22,
-0.346_417_13,
-0.517_595_9,
0.155_832_47,
-0.666_454_5,
],
vec![
-0.354_128_63,
-0.150_265_6,
-0.146_090_08,
-0.002_240_108_3,
0.097_634_58,
-0.092_596_22,
-0.077_518_13,
0.098_131_66,
0.043_073_647,
-0.048_724_25,
],
vec![
0.001_564_541_6,
0.075_788_16,
0.233_583_33,
-0.104_224_06,
0.431_796_37,
-0.373_122_75,
-0.392_585_9,
-0.093_903_34,
-0.185_715_38,
0.058_544_405,
],
vec![
-0.332_656_68,
-0.189_840_85,
1.300_733_4,
-0.580_438_3,
0.223_974_1,
-0.057_784_215,
-0.214_602_26,
-0.656_930_6,
-0.157_153_49,
-0.080_237_42,
],
vec![
-0.374_737_6,
-0.203_834_73,
-0.517_297_3,
0.412_784_2,
-0.970_973_4,
0.525_642_45,
-0.345_279_6,
0.196_275_2,
0.068_473_96,
0.057_966_32,
],
vec![
-0.206_786_44,
-0.166_731_15,
-0.277_479_2,
-0.079_962_75,
0.274_603_55,
-0.076_264_1,
0.065_194_56,
-0.000_790_951_2,
-0.014_463_453,
-0.020_161_366,
],
vec![
-0.224_463_95,
0.101_412_96,
0.638_434_3,
-0.380_875_7,
-0.374_144_4,
0.106_621_68,
-0.224_464_5,
-0.106_371_82,
0.118_541_16,
-0.550_626_7,
],
vec![
-0.060_894_59,
-0.489_318_3,
0.193_886_74,
0.104_497_54,
0.006_548_385,
0.149_242_77,
-0.532_321_8,
-0.391_359_06,
-0.056_789_97,
-0.072_821_505,
],
vec![
0.861_896_63,
-0.556_303_86,
-0.339_215_52,
0.181_062_86,
-0.155_863_08,
-0.141_478_06,
-0.199_623_57,
-0.031_703_413,
-0.105_384_51,
-0.291_078_45,
],
vec![
-0.534_867_2,
0.166_174_89,
0.194_590_84,
0.211_057_96,
-0.093_018_58,
0.144_604_07,
-0.602_165_34,
-0.621_696_2,
-0.136_288_7,
0.323_563_2,
],
vec![
-0.417_162_4,
0.509_713_53,
0.629_261_9,
-0.350_670_7,
-0.785_039_4,
-0.556_359_23,
0.179_918_44,
-0.642_441_5,
-0.009_600_11,
0.252_771_4,
],
vec![
0.469_258_84,
-0.855_024_6,
-1.139_494_7,
1.120_604_8,
-1.778_672_9,
-0.088_683_52,
0.548_659_4,
-0.079_584_97,
-1.412_795_8,
-0.117_211_64,
],
vec![
0.313_460_44,
0.023_192_618,
-0.490_629_1,
-0.061_270_583,
-1.280_864_6,
0.074_842_51,
0.243_480_1,
-0.302_316_2,
0.313_274_35,
0.010_305_379_5,
],
vec![
-0.136_217_18,
0.827_996_9,
0.006_726_798_6,
0.114_384_174,
-0.416_126_25,
0.454_064_16,
-0.044_973_407,
-0.230_108_25,
-1.075_043_3,
-1.211_537_5,
],
vec![
0.254_804_46,
0.112_977_27,
0.636_671_5,
-0.396_636_04,
-1.013_891_3,
0.006_650_318_4,
0.412_682_83,
-1.177_916,
0.152_523_96,
-0.469_226_6,
],
vec![
-0.594_725_97,
-0.624_621_57,
-2.020_615_3,
-0.064_352_76,
0.183_114_38,
0.490_432_3,
-0.265_091_1,
0.644_683,
-1.330_572_6,
0.489_623_07,
],
vec![
-0.011_184_594,
0.156_875_71,
0.236_530_6,
-0.397_889_2,
-0.212_858_21,
0.044_737_875,
-0.590_274_63,
-0.066_678_21,
-0.027_576_448,
-0.136_117_09,
],
vec![
-0.233_180_85,
-1.124_434_8,
1.129_748_3,
-0.175_548_2,
-0.861_948_2,
-0.498_053_7,
-0.195_488_96,
-2.249_580_1,
-0.512_081_56,
0.198_302_9,
],
vec![
0.278_029_53,
0.142_057_5,
0.483_636_14,
-0.578_241_65,
-0.051_348_41,
-0.099_346_526,
0.280_694_54,
-0.555_599_03,
0.172_815_83,
-0.128_702_34,
],
vec![
-1.064_693_6,
-0.205_767_29,
-1.183_542_7,
0.752_033_2,
-1.288_635_6,
0.470_424_12,
-2.355_776,
-0.134_253_84,
-0.579_577_7,
-0.122_758_45,
],
vec![
-0.560_981_3,
0.278_608_56,
0.130_296_14,
-0.442_299_7,
0.532_096_6,
0.267_559_92,
-0.334_101_8,
0.205_616_82,
-0.378_532_62,
-0.133_773_39,
],
vec![
0.549_214_2,
-0.024_388_539,
0.221_822_26,
-0.573_709_13,
0.681_470_1,
0.060_962_49,
-1.178_789_9,
-0.125_538_24,
0.163_888_47,
-0.991_272_03,
],
vec![
0.172_073_77,
0.232_600_36,
0.378_192_66,
-0.214_604_97,
-0.105_139_2,
-0.473_140_27,
0.211_957_08,
-0.384_924_02,
0.264_930_34,
-0.299_187_33,
],
vec![
0.043_230_236,
-0.610_978_4,
-1.192_533,
0.493_039_85,
-0.891_411_5,
0.410_983_65,
-0.368_046_3,
-0.696_914_6,
-0.306_526_72,
0.249_337_05,
],
vec![
-0.347_867_16,
0.606_439_4,
0.021_995_341,
-0.689_578_65,
-0.003_900_446_7,
0.073_512_33,
-0.281_876_86,
0.166_069_42,
-0.458_259_58,
0.150_449_93,
],
vec![
0.249_344_18,
-0.189_730_76,
0.321_47,
0.108_508_72,
0.313_829_78,
-0.866_597_06,
0.130_970_21,
0.236_043_48,
0.072_720_06,
-0.472_748_46,
],
vec![
0.102_692_31,
0.008_673_394,
0.090_486_83,
0.002_421_351,
-0.293_571_5,
-0.083_851_23,
0.272_985_58,
-0.916_719_73,
0.312_562_76,
-0.216_144_65,
],
vec![
0.513_089_36,
-0.760_970_3,
-0.109_253_26,
0.324_638_43,
-1.610_134_4,
0.365_245_13,
0.145_767_99,
-1.275_347_6,
0.061_278_246,
-0.201_693_62,
],
vec![
-0.686_574_7,
-0.011_772_094,
-0.212_761_97,
-0.197_130_05,
0.448_876_14,
0.030_639_209,
-0.433_391_57,
0.089_604_154,
-0.522_763_25,
0.204_889_92,
],
vec![
-0.169_049_92,
0.735_562_7,
-0.368_875_9,
-0.741_709_23,
0.085_351_005,
-0.667_998_8,
0.182_068_91,
0.249_736_53,
0.024_728_911,
0.147_767_14,
],
vec![
0.269_879_73,
-0.061_343_107,
0.189_085_74,
0.057_410_844,
-0.413_874_86,
0.016_049_583,
0.354_817_8,
-0.213_496_49,
-0.016_339_261,
-0.195_600_63,
],
vec![
0.612_416_45,
-0.652_237,
-0.290_922_4,
0.100_256_38,
-0.763_017_95,
0.134_294_51,
-0.346_889_47,
-1.198_402_4,
0.058_237_143,
-0.291_215_63,
],
vec![
-1.451_199_5,
-0.261_634_74,
-0.290_876_92,
-0.112_408_124,
0.474_783_4,
0.259_347_14,
-1.402_955_7,
0.158_754_13,
-0.393_066_23,
0.170_342_42,
],
vec![
-0.025_236_953,
0.091_647_916,
-0.063_152_87,
-0.691_322_1,
0.113_248_47,
-0.495_438_43,
0.110_764_95,
0.190_719_05,
0.092_877_21,
0.021_988_474,
],
vec![
0.371_424_4,
-0.271_200_48,
0.052_355_736,
0.076_789_506,
-0.086_218_92,
-0.109_440_014,
0.269_172_04,
-0.321_849_58,
0.032_248_903,
-0.261_390_84,
],
vec![
-0.372_055_23,
0.092_231_646,
-0.044_099_193,
0.178_492_75,
-0.317_144_16,
-0.081_630_535,
0.196_395_25,
-0.639_333_2,
0.134_729_04,
-0.032_898_054,
],
vec![
-1.602_207_1,
-0.513_332_7,
-0.603_366_73,
-0.072_191_55,
0.333_521_63,
0.358_542_08,
-1.165_994_6,
0.183_343_26,
-0.066_384_84,
0.211_841_17,
],
vec![
-0.620_023_2,
0.150_212_59,
-0.350_462_08,
0.064_612_39,
0.208_557_87,
-0.146_651_24,
-0.185_354_29,
0.116_813_12,
0.138_185_2,
-0.143_217_43,
],
vec![
0.143_314_14,
-0.002_241_282,
0.001_118_428_3,
-0.144_721_54,
-0.174_310_04,
-0.140_035_72,
0.442_062_68,
-0.175_482_47,
0.057_133_213,
-0.229_593_01,
],
vec![
-0.168_592_27,
0.249_408_66,
0.407_433_4,
-0.255_238_06,
0.346_984_45,
-0.251_691_88,
0.265_445_8,
0.098_686_33,
-0.421_546_55,
-0.193_290_73,
],
vec![
-0.849_656_5,
-0.866_653_5,
-0.433_286_1,
0.437_252_34,
-0.031_424_575,
0.433_979_57,
0.068_777_926,
0.105_180_53,
0.273_456_1,
-0.106_595_99,
],
vec![
-0.698_027_73,
0.245_267_1,
-0.051_311_884,
-0.057_796_728,
0.265_975_77,
-0.204_770_73,
0.498_724_46,
0.112_041_235,
-0.230_303_29,
-0.035_942_525,
],
vec![
-0.123_949_625,
0.083_198_01,
-0.194_088_24,
0.043_361_794,
-0.143_197_5,
-0.183_903_63,
0.085_556_96,
-0.147_593_33,
0.188_463_91,
-0.067_946_32,
],
vec![
-0.776_119,
0.319_575_22,
1.368_732_1,
-0.927_126_9,
0.283_870_94,
-0.463_118_76,
-0.611_538_3,
-0.392_389_03,
-0.181_314_23,
0.006_984_539_3,
],
vec![
-0.218_999_68,
-0.384_511_35,
-0.574_313_7,
0.440_100_37,
-0.661_546_3,
0.322_600_1,
-0.286_143_45,
-0.646_361_35,
0.550_332_67,
0.120_832_48,
],
vec![
-0.643_277_35,
0.128_418_03,
0.179_817_42,
0.268_390_8,
0.079_269_51,
0.124_471_985,
0.022_212_533,
-0.147_600_32,
-0.362_296_16,
0.123_608_25,
],
vec![
-0.324_855_24,
0.066_592_135,
0.193_869_59,
0.056_280_106,
0.271_695_05,
-0.099_054_07,
-0.005_476_542_3,
-0.385_905_03,
0.016_091_432,
-0.064_823_22,
],
vec![
-1.457_897_3,
0.392_666_1,
0.960_027_4,
-0.722_546_34,
0.349_659_6,
-0.715_940_2,
-1.805_410_7,
-0.064_484_65,
-0.303_603_83,
0.187_947_15,
],
vec![
-0.428_292_3,
-0.341_486_84,
0.063_829_09,
0.292_772_02,
-1.050_140_6,
0.833_778_8,
0.437_908_62,
-0.802_109_2,
0.054_910_87,
-0.565_300_17,
],
vec![
-0.597_262_8,
0.632_949_4,
-0.113_871_31,
-0.112_093_67,
-0.103_812_83,
0.209_886_74,
0.210_339_28,
0.207_727_49,
-0.110_167_1,
-0.125_435_67,
],
vec![
-0.292_568_92,
0.100_869_8,
0.438_270_96,
0.036_628_58,
-0.052_523_613,
-0.189_247_85,
0.261_727,
-0.448_417_7,
-0.199_650_7,
-0.101_448_305,
],
vec![
-2.346_928_1,
0.048_702_62,
0.665_279,
-0.397_370_37,
0.319_130_24,
-0.522_832_45,
-0.322_557_06,
-0.543_567_6,
-0.149_809_76,
0.490_307_48,
],
vec![
-0.720_502_44,
-0.760_683_5,
-0.351_185_62,
0.345_522_28,
-0.426_943_75,
0.661_918_8,
0.549_301_8,
-0.639_204_26,
0.143_307_1,
-0.156_587_24,
],
vec![
-0.139_704_15,
-0.131_308_82,
-0.543_173_4,
0.084_604_315,
0.257_846_68,
0.065_236_166,
0.061_439_02,
0.024_350_03,
-0.102_217_88,
-0.025_649_419,
],
vec![
-0.323_183_75,
0.248_389_05,
-0.073_156_14,
-0.352_312_33,
0.437_357_43,
0.139_078_17,
0.033_624_098,
-0.242_638_07,
0.037_701_286,
-0.078_643_18,
],
vec![
-0.542_560_5,
-0.480_773_27,
-0.276_509_3,
-0.396_356_76,
-0.420_418_44,
-0.085_941_86,
0.309_436_44,
-0.039_505_947,
0.120_491_13,
0.613_434_26,
],
vec![
-0.318_124_32,
-0.063_282_974,
-0.583_637_7,
0.000_650_908_8,
0.251_998_1,
0.487_572_88,
0.294_763_92,
-0.502_559_4,
0.000_329_407_22,
-0.515_829_4,
],
vec![
-0.654_853_94,
0.223_553_2,
-0.074_558_02,
0.135_706_9,
-0.106_060_155,
0.582_190_45,
-0.645_618_5,
-0.815_949_6,
-0.367_248_62,
0.525_076_2,
],
vec![
-0.405_058_68,
0.018_883_748,
0.482_653_83,
-0.405_313_67,
-0.172_249_38,
0.247_358_53,
-0.383_800_8,
-1.180_208_6,
-0.285_524_87,
0.199_742_36,
],
vec![
0.072_124_42,
0.089_611_27,
-0.648_444_3,
-1.149_063_5,
0.871_572_9,
-0.603_575_7,
-0.042_532_567,
-0.787_138_94,
-1.449_770_2,
0.068_524_61,
],
vec![
-0.217_419_65,
-0.849_716_6,
-0.416_967_5,
0.302_742_72,
0.338_067_8,
0.029_692_076,
-1.289_909_8,
0.719_712_14,
-0.298_428_7,
-0.182_162_28,
],
vec![
0.505_294_5,
0.315_604_78,
0.276_869_18,
0.805_631_34,
-0.602_539_1,
-0.478_464_57,
-0.269_422_98,
-0.784_946_2,
-0.468_819_7,
-1.085_707_2,
],
vec![
-0.618_747_9,
-0.302_277_77,
0.243_801_47,
0.056_581_102,
0.284_645_62,
0.136_963_01,
-1.226_688_1,
0.336_242_38,
-0.480_236_17,
-0.364_608_62,
],
vec![
-2.138_444_4,
-1.581_727_5,
-1.148_180_4,
0.170_667_14,
0.835_107_5,
-0.155_976_41,
0.211_119_86,
-1.193_190_1,
-2.671_164_3,
0.546_684_74,
],
vec![
0.554_155_05,
-0.523_339_7,
0.123_114_61,
-0.190_302_52,
0.401_426_97,
-0.999_298_63,
-1.785_986_7,
-0.028_864_663,
0.075_423_63,
0.134_472_58,
],
vec![
-0.999_845_8,
-1.265_773_9,
0.185_654_45,
0.022_434_83,
-1.064_128_4,
0.605_494_6,
-0.609_147_25,
0.160_562_52,
-0.393_894_2,
-1.073_601_5,
],
vec![
0.589_565_5,
-0.083_658_06,
-0.233_503_48,
0.051_685_516,
-0.211_244_93,
-0.181_601_88,
-1.890_412_8,
-0.066_304_71,
0.160_530_27,
-0.527_078_8,
],
vec![
-1.982_653_1,
-0.369_682_7,
-1.941_524_6,
1.238_792_3,
-0.395_362_47,
0.042_821_903,
-0.935_377_36,
-0.980_699_8,
-2.589_027_2,
-0.042_432_9,
],
vec![
-1.365_509,
0.537_696_9,
-0.111_231_65,
0.185_135_45,
-0.308_016_84,
-0.549_564_96,
-0.944_409,
0.357_071_43,
-0.624_963_94,
0.194_620_94,
],
vec![
-0.426_039_52,
0.343_039_57,
-0.558_455_35,
-0.165_530_98,
0.514_893_83,
0.328_566_43,
-1.802_753_6,
0.838_755_55,
-0.659_958_24,
0.466_113_2,
],
vec![
0.304_619_76,
-0.197_458_82,
0.049_138_226,
-0.042_370_863,
-1.139_023,
-0.249_606_34,
0.102_472_335,
0.178_228_1,
0.087_729_655,
0.095_381_156,
],
vec![
-0.000_232_155_61,
-1.015_105_8,
-1.281_301,
1.485_128_3,
-1.868_158_5,
0.041_754_503,
0.610_743_17,
-0.685_658_4,
0.142_848_21,
-0.769_454_1,
],
vec![
-1.585_783_4,
0.190_147_06,
-1.414_753_4,
0.538_763_4,
0.484_258_77,
-0.715_786_04,
-0.592_829_2,
0.496_048_06,
-0.829_651,
0.413_377_2,
],
vec![
0.566_932_6,
-0.068_602_435,
0.267_610_67,
0.261_273_3,
0.178_361_62,
-1.203_597_5,
-0.964_891_6,
0.010_196_564,
-0.457_586_7,
0.418_362_9,
],
vec![
-0.004_002_593_5,
0.190_587_67,
0.128_683_66,
0.157_295_91,
-0.403_145_2,
-0.076_014_586,
-0.078_582_12,
-0.206_771_54,
0.113_126_98,
0.009_636_784,
],
vec![
0.461_833_72,
-0.031_744_67,
0.328_814_74,
0.616_160_75,
-2.074_591_6,
0.830_497_9,
0.879_883_1,
-1.641_873_4,
0.203_190_55,
-1.673_336_3,
],
vec![
-1.070_805_5,
0.108_797_63,
-0.310_216_9,
0.107_166_18,
0.215_771_24,
-0.338_961_36,
0.306_101_77,
0.367_811_7,
-0.262_294_98,
0.070_901_744,
],
vec![
0.427_335_7,
0.006_227_863,
-0.298_522_56,
-0.016_469_207,
0.535_206_2,
-0.475_492_95,
0.123_835_57,
0.370_917_1,
-0.309_676_53,
-0.045_802_142,
],
vec![
0.086_003_184,
-0.269_960_2,
0.322_433_23,
0.229_070_89,
0.097_541_71,
0.173_907_13,
-0.128_568_14,
-0.531_032_86,
0.125_477_95,
-0.333_153_04,
],
vec![
-0.719_683_6,
0.179_478_72,
-0.887_378,
0.833_087_8,
-0.613_835_93,
0.758_620_7,
1.292_799_4,
-0.829_363_1,
-0.098_033_76,
-0.475_673_14,
],
vec![
-1.122_670_9,
-0.525_466_6,
-0.975_395_2,
0.673_286_26,
0.065_977_84,
-0.214_926_73,
-0.724_994_36,
0.497_947_07,
-0.526_081_3,
0.304_432,
],
vec![
-0.147_321_76,
-0.445_857_97,
-0.303_215_4,
0.430_011_36,
-0.002_681_413,
-0.563_261,
-0.488_504_3,
0.215_144_81,
0.119_377_89,
0.374_618_44,
],
vec![
-0.031_042_775,
0.001_905_601_9,
0.375_899_1,
0.136_461_18,
-0.425_136_74,
0.113_508_43,
-0.165_993_11,
-0.183_742_42,
-0.017_969_275,
-0.226_747_04,
],
vec![
-1.277_52,
0.530_681_13,
-0.608_959_73,
-0.105_554_65,
0.247_067_32,
0.958_920_1,
-1.320_192_1,
-0.159_428_92,
-1.006_717_9,
0.172_789_87,
],
vec![
-1.090_040_2,
-0.868_742_4,
-1.176_520_7,
0.466_612_85,
-0.067_542_53,
0.456_095_34,
-0.771_310_5,
0.420_788_8,
-0.194_251_57,
0.181_740_39,
],
vec![
-0.280_148_2,
0.261_400_22,
-0.844_498_6,
0.090_790_07,
-0.232_529_8,
-0.234_734_86,
-0.303_635_95,
0.205_579_67,
0.050_524_14,
0.188_166_6,
],
vec![
0.278_557_15,
-0.290_673_97,
0.072_780_56,
-0.044_078_395,
-0.013_295_747,
0.023_838_982,
0.100_808_12,
-0.004_029_975_3,
0.087_681_495,
-0.250_307_1,
],
vec![
-2.931_820_2,
0.643_360_8,
0.109_410_7,
-2.668_557,
0.839_273_6,
-0.091_143_765,
-1.141_751_9,
-0.111_864_276,
-1.236_231_3,
0.594_588,
],
vec![
-1.329_099_8,
-0.404_363_07,
-0.786_461_3,
0.495_720_8,
0.523_596_5,
0.574_914_6,
-0.349_026_74,
0.074_060_86,
-0.291_518_78,
0.065_660_05,
],
vec![
-0.420_664_07,
-0.189_287_14,
-0.090_219_02,
-0.098_952_18,
-0.586_029_95,
-0.280_429_72,
-0.034_379,
0.042_699_914,
0.310_710_94,
0.195_342_48,
],
vec![
0.334_666_97,
-0.363_745_8,
-0.112_467_24,
0.109_010_57,
-0.239_026_34,
0.198_633_1,
0.201_740_61,
-0.145_083_79,
0.266_873_12,
-0.337_569,
],
vec![
-3.973_189_8,
0.039_358_37,
0.481_752_46,
-0.109_007_26,
-0.161_161_2,
-0.505_807_7,
0.562_568,
-0.586_035_4,
0.455_849,
0.309_762_92,
],
vec![
-1.230_398_8,
-0.176_831_8,
-0.535_786_6,
0.263_067_04,
0.242_315_7,
0.691_649_7,
-0.489_253_16,
0.264_390_2,
-0.131_665_13,
0.031_665_89,
],
vec![
-0.141_270_65,
-0.159_680_43,
-0.210_704_6,
0.241_845_88,
-0.110_234_6,
0.023_166_748,
0.041_836_73,
-0.242_392_54,
-0.177_036_39,
0.219_812_54,
],
vec![
0.345_195_98,
-0.085_443_124,
-0.370_670_35,
-0.047_733_57,
-0.272_001_9,
0.178_620_87,
0.240_321_86,
-0.216_357_14,
0.171_298_64,
-0.256_854_74,
],
vec![
-0.667_514_15,
0.622_525_93,
0.954_174_04,
-0.909_746_17,
-0.424_728_42,
-1.346_686_4,
-2.209_663_4,
0.350_954_62,
-0.477_263_96,
0.115_298_78,
],
vec![
0.060_172_78,
-0.029_796_772,
-0.057_546_39,
-0.003_541_321_5,
-0.026_794_007,
0.593_517_7,
-0.559_868_8,
0.041_287_13,
-0.123_922_66,
-0.467_462_5,
],
vec![
-0.411_580_92,
0.064_860_13,
-0.498_746_1,
0.045_083_48,
-0.922_313_45,
0.362_882_3,
0.297_462_37,
0.046_287_77,
0.075_106_24,
0.453_751_1,
],
vec![
0.100_418_225,
0.225_428_66,
-0.455_045_07,
0.093_468_67,
0.071_465_28,
-0.029_081_427,
0.174_563_81,
-0.214_674_04,
0.116_524_21,
-0.203_626_14,
],
vec![
-1.225_284,
0.685_221_2,
-0.462_594_12,
-0.456_986_4,
-0.884_543_8,
-0.459_243_54,
-0.738_546,
0.063_575_98,
0.103_217_766,
0.969_997_4,
],
vec![
-0.639_592_35,
0.264_141_44,
0.111_988_79,
-0.000_706_114_8,
0.445_127_3,
0.142_151_58,
-0.451_865_67,
-0.048_067_592,
-0.009_025_919,
-0.649_651_3,
],
vec![
-0.619_525_8,
-0.363_677_14,
-0.403_265_83,
-0.067_008_51,
0.190_474_76,
0.069_310_8,
-0.245_115_25,
-0.092_971_34,
-0.374_226_12,
0.427_289_2,
],
vec![
-0.509_418_8,
-0.371_609_36,
-0.328_480_66,
-0.018_435_072,
0.365_649_88,
0.175_797_33,
-0.477_345_17,
-0.215_904_94,
0.033_447_467,
-0.252_660_96,
],
vec![
-2.052_151_7,
-1.064_796_9,
0.051_642_984,
-0.304_278_58,
0.236_843_05,
0.399_494_26,
-0.907_562_14,
0.199_219_11,
-1.396_473_3,
0.661_582_3,
],
vec![
0.880_664_6,
-0.540_139_73,
0.181_769_37,
-0.051_451_266,
0.240_898_71,
-0.586_332_5,
0.075_078_525,
-0.629_870_06,
0.415_950_15,
-1.175_883_3,
],
vec![
-0.346_670_18,
-1.826_483_8,
-0.156_105_98,
-0.106_954_85,
0.030_861_156,
0.661_358_24,
-1.081_977_8,
-0.420_936_08,
0.022_964_55,
0.151_142_18,
],
vec![
-0.514_707_57,
-0.862_410_37,
-0.573_349_2,
-0.158_140_11,
-0.196_890_74,
0.588_682_23,
-1.308_61,
-1.008_766,
0.346_195_6,
0.537_148_7,
],
];
let b: Vec<f32> = vec![
-0.058_054_72,
0.477_797_06,
0.450_016_6,
-0.400_980_47,
-0.805_899_5,
1.038_068_2,
-0.427_971_72,
0.401_235_6,
-0.670_984_9,
-0.061_168_972,
];
Params {
kernels,
weights: w,
biases: b,
}
}
}
| https://github.com/zkonduit/ezkl |
examples/mlp_4d_einsum.rs | use ezkl::circuit::region::RegionCtx;
use ezkl::circuit::{
ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
};
use ezkl::fieldutils::i32_to_felt;
use ezkl::tensor::*;
use halo2_proofs::dev::MockProver;
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, Column, ConstraintSystem, Error, Instance},
};
use halo2curves::bn256::Fr as F;
use std::marker::PhantomData;
const K: usize = 15;
// A columnar ReLu MLP
#[derive(Clone)]
struct MyConfig {
layer_config: PolyConfig<F>,
public_output: Column<Instance>,
}
#[derive(Clone)]
struct MyCircuit<
const LEN: usize, //LEN = CHOUT x OH x OW flattened
const LOOKUP_MIN: i128,
const LOOKUP_MAX: i128,
> {
// Given the stateless MyConfig type information, a DNN trace is determined by its input and the parameters of its layers.
// Computing the trace still requires a forward pass. The intermediate activations are stored only by the layouter.
input: ValTensor<F>,
l0_params: [Tensor<F>; 2],
l2_params: [Tensor<F>; 2],
_marker: PhantomData<F>,
}
impl<const LEN: usize, const LOOKUP_MIN: i128, const LOOKUP_MAX: i128> Circuit<F>
for MyCircuit<LEN, LOOKUP_MIN, LOOKUP_MAX>
{
type Config = MyConfig;
type FloorPlanner = SimpleFloorPlanner;
type Params = PhantomData<F>;
fn without_witnesses(&self) -> Self {
self.clone()
}
// Here we wire together the layers by using the output advice in each layer as input advice in the next (not with copying / equality).
// This can be automated but we will sometimes want skip connections, etc. so we need the flexibility.
fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
let input = VarTensor::new_advice(cs, K, 1, LEN);
let params = VarTensor::new_advice(cs, K, 1, LEN * LEN);
let output = VarTensor::new_advice(cs, K, 1, LEN);
// tells the config layer to add an affine op to the circuit gate
let mut layer_config = PolyConfig::<F>::configure(
cs,
&[input.clone(), params.clone()],
&output,
CheckMode::SAFE,
);
// sets up a new ReLU table and resuses it for l1 and l3 non linearities
layer_config
.configure_lookup(
cs,
&input,
&output,
¶ms,
(LOOKUP_MIN, LOOKUP_MAX),
K,
&LookupOp::ReLU,
)
.unwrap();
// sets up a new ReLU table and resuses it for l1 and l3 non linearities
layer_config
.configure_lookup(
cs,
&input,
&output,
¶ms,
(LOOKUP_MIN, LOOKUP_MAX),
K,
&LookupOp::Div {
denom: ezkl::circuit::utils::F32::from(128.),
},
)
.unwrap();
let public_output: Column<Instance> = cs.instance_column();
cs.enable_equality(public_output);
MyConfig {
layer_config,
public_output,
}
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
config.layer_config.layout_tables(&mut layouter).unwrap();
let x = layouter
.assign_region(
|| "mlp_4d",
|region| {
let mut region = RegionCtx::new(region, 0, 1);
let x = config
.layer_config
.layout(
&mut region,
&[
self.l0_params[0].clone().try_into().unwrap(),
self.input.clone(),
],
Box::new(PolyOp::Einsum {
equation: "ab,bc->ac".to_string(),
}),
)
.unwrap()
.unwrap();
println!("1");
println!("offset: {}", region.row());
println!("x shape: {:?}", x.dims());
let x = config
.layer_config
.layout(
&mut region,
&[x, self.l0_params[1].clone().try_into().unwrap()],
Box::new(PolyOp::Add),
)
.unwrap()
.unwrap();
println!("2");
println!("offset: {}", region.row());
println!("x shape: {:?}", x.dims());
let mut x = config
.layer_config
.layout(&mut region, &[x], Box::new(LookupOp::ReLU))
.unwrap()
.unwrap();
println!("3");
println!("offset: {}", region.row());
println!("x shape: {:?}", x.dims());
x.reshape(&[x.dims()[0], 1]).unwrap();
let x = config
.layer_config
.layout(
&mut region,
&[self.l2_params[0].clone().try_into().unwrap(), x],
Box::new(PolyOp::Einsum {
equation: "ab,bc->ac".to_string(),
}),
)
.unwrap()
.unwrap();
println!("4");
println!("offset: {}", region.row());
println!("x shape: {:?}", x.dims());
let x = config
.layer_config
.layout(
&mut region,
&[x, self.l2_params[1].clone().try_into().unwrap()],
Box::new(PolyOp::Add),
)
.unwrap()
.unwrap();
println!("5");
println!("offset: {}", region.row());
println!("x shape: {:?}", x.dims());
let x = config
.layer_config
.layout(&mut region, &[x], Box::new(LookupOp::ReLU))
.unwrap();
println!("6");
println!("offset: {}", region.row());
Ok(config
.layer_config
.layout(
&mut region,
&[x.unwrap()],
Box::new(LookupOp::Div {
denom: ezkl::circuit::utils::F32::from(128.),
}),
)
.unwrap())
},
)
.unwrap();
match x.unwrap() {
ValTensor::Value {
inner: v, dims: _, ..
} => v
.enum_map(|i, x| match x {
ValType::PrevAssigned(v) => {
layouter.constrain_instance(v.cell(), config.public_output, i)
}
_ => panic!(),
})
.unwrap(),
_ => panic!("Should be assigned"),
};
Ok(())
}
}
pub fn runmlp() {
#[cfg(not(target_arch = "wasm32"))]
env_logger::init();
// parameters
let mut l0_kernel: Tensor<F> = Tensor::<i32>::new(
Some(&[10, 0, 0, -1, 0, 10, 1, 0, 0, 1, 10, 0, 1, 0, 0, 10]),
&[4, 4],
)
.unwrap()
.map(i32_to_felt);
l0_kernel.set_visibility(&ezkl::graph::Visibility::Private);
let mut l0_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
.unwrap()
.map(i32_to_felt);
l0_bias.set_visibility(&ezkl::graph::Visibility::Private);
let mut l2_kernel: Tensor<F> = Tensor::<i32>::new(
Some(&[0, 3, 10, -1, 0, 10, 1, 0, 0, 1, 0, 12, 1, -2, 32, 0]),
&[4, 4],
)
.unwrap()
.map(i32_to_felt);
l2_kernel.set_visibility(&ezkl::graph::Visibility::Private);
// input data, with 1 padding to allow for bias
let input: Tensor<Value<F>> = Tensor::<i32>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
.unwrap()
.into();
let mut l2_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
.unwrap()
.map(i32_to_felt);
l2_bias.set_visibility(&ezkl::graph::Visibility::Private);
let circuit = MyCircuit::<4, -8192, 8192> {
input: input.into(),
l0_params: [l0_kernel, l0_bias],
l2_params: [l2_kernel, l2_bias],
_marker: PhantomData,
};
let public_input: Vec<i32> = unsafe {
vec![
(531f32 / 128f32).round().to_int_unchecked::<i32>(),
(103f32 / 128f32).round().to_int_unchecked::<i32>(),
(4469f32 / 128f32).round().to_int_unchecked::<i32>(),
(2849f32 / 128f32).to_int_unchecked::<i32>(),
]
};
println!("public input {:?}", public_input);
let prover = MockProver::run(
K as u32,
&circuit,
vec![public_input.iter().map(|x| i32_to_felt::<F>(*x)).collect()],
)
.unwrap();
prover.assert_satisfied();
}
pub fn main() {
runmlp()
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/data_attest.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# data-attest-ezkl\n",
"\n",
"Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source.\n",
"\n",
"In this setup:\n",
"- the inputs and outputs are publicly known to the prover and verifier\n",
"- the on chain inputs will be fetched and then fed directly into the circuit\n",
"- the quantization of the on-chain inputs happens within the evm and is replicated at proving time \n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"First we import the necessary dependencies and set up logging to be as informative as possible. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import logging\n",
"\n",
"# uncomment for more descriptive logging \n",
"FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"logging.basicConfig(format=FORMAT)\n",
"logging.getLogger().setLevel(logging.DEBUG)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"# Defines the model\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
" self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
"\n",
" def forward(self, x):\n",
" return self.layer(x)[0]\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# this is where you'd train your model"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
"Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
"\n",
"You can replace the random `x` with real data if you so wish. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w' ))\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import subprocess\n",
"import time\n",
"import threading\n",
"\n",
"# make sure anvil is running locally\n",
"# $ anvil -p 3030\n",
"\n",
"RPC_URL = \"http://localhost:3030\"\n",
"\n",
"# Save process globally\n",
"anvil_process = None\n",
"\n",
"def start_anvil():\n",
" global anvil_process\n",
" if anvil_process is None:\n",
" anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
" if anvil_process.returncode is not None:\n",
" raise Exception(\"failed to start anvil process\")\n",
" time.sleep(3)\n",
"\n",
"def stop_anvil():\n",
" global anvil_process\n",
" if anvil_process is not None:\n",
" anvil_process.terminate()\n",
" anvil_process = None\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
"- `input_visibility` defines the visibility of the model inputs\n",
"- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
"- `output_visibility` defines the visibility of the model outputs\n",
"\n",
"Here we create the following setup:\n",
"- `input_visibility`: \"public\"\n",
"- `param_visibility`: \"private\"\n",
"- `output_visibility`: public\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"srs_path = os.path.join('kzg.srs')\n",
"data_path = os.path.join('input.json')\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"public\"\n",
"run_args.param_visibility = \"private\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.num_inner_cols = 1\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
"\n",
"You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# generate a bunch of dummy calibration data\n",
"cal_data = {\n",
" \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
"}\n",
"\n",
"cal_path = os.path.join('val_data.json')\n",
"# save as json file\n",
"with open(cal_path, \"w\") as f:\n",
" json.dump(cal_data, f)\n",
"\n",
"res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
"\n",
"- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
"- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
"Here is what the schema for an on-chain data source graph input file should look like:\n",
" \n",
"```json\n",
"{\n",
" \"input_data\": {\n",
" \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
" \"calls\": [\n",
" {\n",
" \"call_data\": [\n",
" [\n",
" \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns a single on-chain data point (we only support uint256 returns for now)\n",
" 7 // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
" ],\n",
" [\n",
" \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000001\",\n",
" 5\n",
" ],\n",
" [\n",
" \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000002\",\n",
" 5\n",
" ]\n",
" ],\n",
" \"address\": \"5fbdb2315678afecb367f032d93f642f64180aa3\" // The address of the contract that we are calling to get the data. \n",
" }\n",
" ]\n",
" }\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.setup_test_evm_witness(\n",
" data_path,\n",
" compiled_model_path,\n",
" # we write the call data to the same file as the input data\n",
" data_path,\n",
" input_source=ezkl.PyTestDataSource.OnChain,\n",
" output_source=ezkl.PyTestDataSource.File,\n",
" rpc_url=RPC_URL)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
"\n",
"These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.get_srs( settings_path)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!export RUST_BACKTRACE=1\n",
"\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a full proof. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"And verify it as a sanity check. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can now create and then deploy a vanilla evm verifier."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" \n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"\n",
"addr_path_verifier = \"addr_verifier.txt\"\n",
"\n",
"res = ezkl.deploy_evm(\n",
" addr_path_verifier,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"input_path = 'input.json'\n",
"\n",
"res = ezkl.create_evm_data_attestation(\n",
" input_path,\n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
"So should only be used for testing purposes."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"addr_path_da = \"addr_da.txt\"\n",
"\n",
"res = ezkl.deploy_da_evm(\n",
" addr_path_da,\n",
" input_path,\n",
" settings_path,\n",
" sol_code_path,\n",
" RPC_URL,\n",
" )\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# read the verifier address\n",
"addr_verifier = None\n",
"with open(addr_path_verifier, 'r') as f:\n",
" addr = f.read()\n",
"#read the data attestation address\n",
"addr_da = None\n",
"with open(addr_path_da, 'r') as f:\n",
" addr_da = f.read()\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" RPC_URL,\n",
" addr_da,\n",
")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "ezkl",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/data_attest_hashed.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# data-attest-ezkl hashed\n",
"\n",
"Here's an example leveraging EZKL whereby the hashes of the outputs to the model are read and attested to from an on-chain source.\n",
"\n",
"In this setup:\n",
"- the hashes of outputs are publicly known to the prover and verifier\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"First we import the necessary dependencies and set up logging to be as informative as possible. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import logging\n",
"\n",
"# uncomment for more descriptive logging \n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.DEBUG)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"# Defines the model\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
" self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
"\n",
" def forward(self, x):\n",
" return self.layer(x)[0]\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# this is where you'd train your model\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
"Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
"\n",
"You can replace the random `x` with real data if you so wish. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w' ))\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import subprocess\n",
"import time\n",
"import threading\n",
"\n",
"# make sure anvil is running locally\n",
"# $ anvil -p 3030\n",
"\n",
"RPC_URL = \"http://localhost:3030\"\n",
"\n",
"# Save process globally\n",
"anvil_process = None\n",
"\n",
"def start_anvil():\n",
" global anvil_process\n",
" if anvil_process is None:\n",
" anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
" if anvil_process.returncode is not None:\n",
" raise Exception(\"failed to start anvil process\")\n",
" time.sleep(3)\n",
"\n",
"def stop_anvil():\n",
" global anvil_process\n",
" if anvil_process is not None:\n",
" anvil_process.terminate()\n",
" anvil_process = None\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
"- `input_visibility` defines the visibility of the model inputs\n",
"- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
"- `output_visibility` defines the visibility of the model outputs\n",
"\n",
"Here we create the following setup:\n",
"- `input_visibility`: \"private\"\n",
"- `param_visibility`: \"private\"\n",
"- `output_visibility`: hashed\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"srs_path = os.path.join('kzg.srs')\n",
"data_path = os.path.join('input.json')\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"private\"\n",
"run_args.param_visibility = \"private\"\n",
"run_args.output_visibility = \"hashed\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
"\n",
"You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# generate a bunch of dummy calibration data\n",
"cal_data = {\n",
" \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
"}\n",
"\n",
"cal_path = os.path.join('val_data.json')\n",
"# save as json file\n",
"with open(cal_path, \"w\") as f:\n",
" json.dump(cal_data, f)\n",
"\n",
"res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
"\n",
"These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.get_srs( settings_path)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!export RUST_BACKTRACE=1\n",
"\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We now post the hashes of the outputs to the chain. This is the data that will be read from and attested to."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from web3 import Web3, HTTPProvider\n",
"from solcx import compile_standard\n",
"from decimal import Decimal\n",
"import json\n",
"import os\n",
"import torch\n",
"\n",
"\n",
"# setup web3 instance\n",
"w3 = Web3(HTTPProvider(RPC_URL))\n",
"\n",
"def test_on_chain_data(res):\n",
" # Step 0: Convert the tensor to a flat list\n",
" data = [int(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
"\n",
" # Step 1: Prepare the data\n",
" # Step 2: Prepare and compile the contract.\n",
" # We are using a test contract here but in production you would\n",
" # use whatever contract you are fetching data from.\n",
" contract_source_code = '''\n",
" // SPDX-License-Identifier: UNLICENSED\n",
" pragma solidity ^0.8.17;\n",
"\n",
" contract TestReads {\n",
"\n",
" uint[] public arr;\n",
" constructor(uint256[] memory _numbers) {\n",
" for(uint256 i = 0; i < _numbers.length; i++) {\n",
" arr.push(_numbers[i]);\n",
" }\n",
" }\n",
" }\n",
" '''\n",
"\n",
" compiled_sol = compile_standard({\n",
" \"language\": \"Solidity\",\n",
" \"sources\": {\"testreads.sol\": {\"content\": contract_source_code}},\n",
" \"settings\": {\"outputSelection\": {\"*\": {\"*\": [\"metadata\", \"evm.bytecode\", \"abi\"]}}}\n",
" })\n",
"\n",
" # Get bytecode\n",
" bytecode = compiled_sol['contracts']['testreads.sol']['TestReads']['evm']['bytecode']['object']\n",
"\n",
" # Get ABI\n",
" # In production if you are reading from really large contracts you can just use\n",
" # a stripped down version of the ABI of the contract you are calling, containing only the view functions you will fetch data from.\n",
" abi = json.loads(compiled_sol['contracts']['testreads.sol']['TestReads']['metadata'])['output']['abi']\n",
"\n",
" # Step 3: Deploy the contract\n",
" TestReads = w3.eth.contract(abi=abi, bytecode=bytecode)\n",
" tx_hash = TestReads.constructor(data).transact()\n",
" tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
" # If you are deploying to production you can skip the 3 lines of code above and just instantiate the contract like this,\n",
" # passing the address and abi of the contract you are fetching data from.\n",
" contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
"\n",
" # Step 4: Interact with the contract\n",
" calldata = []\n",
" for i, _ in enumerate(data):\n",
" call = contract.functions.arr(i).build_transaction()\n",
" calldata.append((call['data'][2:], 0))\n",
"\n",
" # Prepare the calls_to_account object\n",
" # If you were calling view functions across multiple contracts,\n",
" # you would have multiple entries in the calls_to_account array,\n",
" # one for each contract.\n",
" calls_to_account = [{\n",
" 'call_data': calldata,\n",
" 'address': contract.address[2:], # remove the '0x' prefix\n",
" }]\n",
"\n",
" print(f'calls_to_account: {calls_to_account}')\n",
"\n",
" return calls_to_account\n",
"\n",
"# Now let's start the Anvil process. You don't need to do this if you are deploying to a non-local chain.\n",
"start_anvil()\n",
"\n",
"# Now let's call our function, passing in the same input tensor we used to export the model 2 cells above.\n",
"calls_to_account = test_on_chain_data(res)\n",
"\n",
"data = dict(input_data = [data_array], output_data = {'rpc': RPC_URL, 'calls': calls_to_account })\n",
"\n",
"# Serialize on-chain data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a full proof. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"And verify it as a sanity check. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can now create and then deploy a vanilla evm verifier."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" \n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"\n",
"addr_path_verifier = \"addr_verifier.txt\"\n",
"\n",
"res = ezkl.deploy_evm(\n",
" addr_path_verifier,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"input_path = 'input.json'\n",
"\n",
"res = ezkl.create_evm_data_attestation(\n",
" input_path,\n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
"So should only be used for testing purposes."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"addr_path_da = \"addr_da.txt\"\n",
"\n",
"res = ezkl.deploy_da_evm(\n",
" addr_path_da,\n",
" input_path,\n",
" settings_path,\n",
" sol_code_path,\n",
" RPC_URL,\n",
" )\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# read the verifier address\n",
"addr_verifier = None\n",
"with open(addr_path_verifier, 'r') as f:\n",
" addr = f.read()\n",
"#read the data attestation address\n",
"addr_da = None\n",
"with open(addr_path_da, 'r') as f:\n",
" addr_da = f.read()\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" RPC_URL,\n",
" addr_da,\n",
")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "ezkl",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/decision_tree.ipynb | {
"cells": [
{
"attachments": {
"image-2.png": {
"image/png": "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"
},
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## Decision Tree\n",
"\n",
"\n",
"Sklearn based models are slightly finicky to get into a suitable onnx format. By default most tree based models will export into something that looks like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Processing such nodes can be difficult and error prone. It would be much better if the operations of the tree were represented as a proper graph, possibly ... like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"This notebook showcases how to do that using the `hummingbird-ml` python package ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.tree import DecisionTreeClassifier as De\n",
"from hummingbird.ml import convert\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"\n",
"\n",
"\n",
"iris = load_iris()\n",
"X, y = iris.data, iris.target\n",
"X = X.astype(np.float32)\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
"clr = De()\n",
"clr.fit(X_train, y_train)\n",
"\n",
"circuit = convert(clr, \"torch\", X_test[:1]).model\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# export to onnx format\n",
"# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"# Input to the model\n",
"shape = X_train.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=True)\n",
"torch_out = circuit(x)\n",
"# Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# generate a bunch of dummy calibration data\n",
"cal_data = {\n",
" \"input_data\": [(torch.rand(20, *shape)).flatten().tolist()],\n",
"}\n",
"\n",
"cal_path = os.path.join('val_data.json')\n",
"# save as json file\n",
"with open(cal_path, \"w\") as f:\n",
" json.dump(cal_data, f)\n",
"\n",
"res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/ezkl_demo.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "n8QlFzjPRIGN"
},
"source": [
"# EZKL DEMO\n",
"\n",
"**Learning Objectives**\n",
"1. Learn some basic AI/ML techniques by training a toy model in pytorch to perform classification\n",
"2. Convert the toy model into zk circuit with ezkl to do provable inference\n",
"3. Create a solidity verifier and deploy it on Remix (you can deploy it however you like but we will use Remix as it's quite easy to setup)\n",
"\n",
"\n",
"**Important Note**: You might want to avoid calling \"Run All\". There's some file locking issue with Colab which can cause weird bugs. To mitigate this issue you should run cell by cell on Colab."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "dx81GOIySIpa"
},
"source": [
"# Step 1: Training a toy model\n",
"\n",
"For this demo we will use a toy data set called the Iris dataset to demonstrate how training can be performed. The Iris dataset is a collection of Iris flowers and is one of the earliest dataset used to validate classification methodologies.\n",
"\n",
"[More info in the dataset](https://archive.ics.uci.edu/dataset/53/iris)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "JhHE2WMvS9NP"
},
"source": [
"First, we will need to import all the various dependencies required to train the model"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "gvQ5HL1bTDWF"
},
"outputs": [],
"source": [
"import pandas as pd\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
"import numpy as np\n",
"import torch\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"from torch.autograd import Variable\n",
"import tqdm"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Op9SHfZHUkaR"
},
"source": [
"Inspect the dataset. Note that for the Iris dataset we have 3 targets.\n",
"\n",
"0 = Iris-setosa\n",
"\n",
"1 = Iris-versicolor\n",
"\n",
"2 = Iris-virginica"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 424
},
"id": "C4XXA1hoU30c",
"outputId": "4fbd47ec-88d1-4ef7-baee-3e3894cc29db"
},
"outputs": [],
"source": [
"iris = load_iris()\n",
"dataset = pd.DataFrame(\n",
" data= np.c_[iris['data'], iris['target']],\n",
" columns= iris['feature_names'] + ['target'])\n",
"dataset"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "I8RargmGTWN2"
},
"source": [
"Next, we can begin defining the neural net model. For this dataset we will use a small fully connected neural net.\n",
"\n",
"<br />\n",
"\n",
"**Note:**\n",
"For the 1st layer we use 4x20, because there are 4 features we want as inputs. After which we add a ReLU.\n",
"\n",
"For the 2nd layer we use 20x20, then add a ReLU.\n",
"\n",
"And for the last layer we use 20x3, because there are 3 classes we want to classify, then add a ReLU.\n",
"\n",
"The last ReLU function gives us an array of 3 elements where the position of the largest value gives us the target that we want to classify.\n",
"\n",
"For example, if we get [0, 0.001, 0.002] as the output of the last ReLU. As, 0.002 is the largest value, the inferred value is 2.\n",
"\n",
"\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "dIdQ9U3yTKtP"
},
"outputs": [],
"source": [
"class Model(nn.Module):\n",
" # define nn\n",
" def __init__(self):\n",
" super(Model, self).__init__()\n",
" self.fc1 = nn.Linear(4, 20)\n",
" self.fc2 = nn.Linear(20, 20)\n",
" self.fc3 = nn.Linear(20, 3)\n",
" self.relu = nn.ReLU()\n",
"\n",
" def forward(self, x):\n",
" x = self.fc1(x)\n",
" x = self.relu(x)\n",
" x = self.fc2(x)\n",
" x = self.relu(x)\n",
" x = self.fc3(x)\n",
" x = self.relu(x)\n",
"\n",
" return x\n",
"\n",
"# Initialize Model\n",
"model = Model()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "SfC03XLNXDPZ"
},
"source": [
"We will now need to split the dataset into a training set and testing set for ML. This is done fairly easily with the `train_test_split` helper function from sklearn."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "agmbEdmfUO1-",
"outputId": "87766edd-50db-48af-aa5d-3f4fc164f8b7"
},
"outputs": [],
"source": [
"train_X, test_X, train_y, test_y = train_test_split(\n",
" dataset[dataset.columns[0:4]].values, # use columns 0-4 as X\n",
" dataset.target, # use target as y\n",
" test_size=0.2 # use 20% of data for testing\n",
")\n",
"\n",
"# Uncomment for sanity checks\n",
"# print(\"train_X: \", train_X)\n",
"# print(\"test_X: \", test_X)\n",
"print(\"train_y: \", train_y)\n",
"print(\"test_y: \", test_y)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_FrQXhAGZGS3"
},
"source": [
"We can now define the parameters for training, we will use the [Cross Entropy Loss](https://machinelearningmastery.com/cross-entropy-for-machine-learning/) and [Stochastic Gradient Descent Optimizer](https://en.wikipedia.org/wiki/Stochastic_gradient_descent)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "9PjADXnuXbdk",
"outputId": "81602926-c386-4f68-a9ee-ae2d5837fe47"
},
"outputs": [],
"source": [
"# our loss function\n",
"loss_fn = nn.CrossEntropyLoss()\n",
"\n",
"# our optimizer\n",
"optimizer = torch.optim.SGD(model.parameters(), lr=0.01)\n",
"\n",
"\n",
"# use 800 EPOCHS\n",
"EPOCHS = 800\n",
"\n",
"# Convert training data to pytorch variables\n",
"train_X = Variable(torch.Tensor(train_X).float())\n",
"test_X = Variable(torch.Tensor(test_X).float())\n",
"train_y = Variable(torch.Tensor(train_y.values).long())\n",
"test_y = Variable(torch.Tensor(test_y.values).long())\n",
"\n",
"\n",
"loss_list = np.zeros((EPOCHS,))\n",
"accuracy_list = np.zeros((EPOCHS,))\n",
"\n",
"\n",
"# we use tqdm for nice loading bars\n",
"for epoch in tqdm.trange(EPOCHS):\n",
"\n",
" # To train, we get a prediction from the current network\n",
" predicted_y = model(train_X)\n",
"\n",
" # Compute the loss to see how bad or good we are doing\n",
" loss = loss_fn(predicted_y, train_y)\n",
"\n",
" # Append the loss to keep track of our performance\n",
" loss_list[epoch] = loss.item()\n",
"\n",
" # Afterwards, we will need to zero the gradients to reset\n",
" optimizer.zero_grad()\n",
" loss.backward()\n",
" optimizer.step()\n",
"\n",
" # Calculate the accuracy, call torch.no_grad() to prevent updating gradients\n",
" # while calculating accuracy\n",
" with torch.no_grad():\n",
" y_pred = model(test_X)\n",
" correct = (torch.argmax(y_pred, dim=1) == test_y).type(torch.FloatTensor)\n",
" accuracy_list[epoch] = correct.mean()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 546
},
"id": "2fHJAgvwboCe",
"outputId": "513c73b7-2663-4bb3-f7b4-cae208940070"
},
"outputs": [],
"source": [
"# Plot the Accuracy and Loss\n",
"\n",
"# import matplotlib\n",
"import matplotlib.pyplot as plt\n",
"\n",
"plt.style.use('ggplot')\n",
"\n",
"\n",
"fig, (ax1, ax2) = plt.subplots(2, figsize=(12, 6), sharex=True)\n",
"\n",
"ax1.plot(accuracy_list)\n",
"ax1.set_ylabel(\"Accuracy\")\n",
"ax2.plot(loss_list)\n",
"ax2.set_ylabel(\"Loss\")\n",
"ax2.set_xlabel(\"epochs\");"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "djB-UtvgYbF2"
},
"source": [
"## Congratulations! You've just trained a neural network\n",
"\n",
"**Exercise:** The model provided is very simplistic, what are other ways the model can be improved upon?"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "JgtwrbMZcgla"
},
"source": [
"# Step 2: ZK the Neural Network\n",
"\n",
"Now that we have the Neural Network trained, we can use ezkl to easily ZK our model.\n",
"\n",
"To proceed we will now need to install `ezkl`\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "C_YiqknhdDwN"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"import os\n",
"import json\n",
"import ezkl"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-b_z_d2FdVTB"
},
"source": [
"Next, we will need to export the neural network to a `.onnx` file. ezkl reads this `.onnx` file and converts it into a circuit which then allows you to generate proofs as well as verify proofs"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "YeKWP0tFeCpq"
},
"outputs": [],
"source": [
"# Specify all the files we need\n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.ezkl')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')\n",
"cal_data_path = os.path.join('cal_data.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "cQeNw_qndQ8g",
"outputId": "2d40f14e-7fbb-4377-e9ee-0e7678edb2ce"
},
"outputs": [],
"source": [
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"\n",
"# create a random input\n",
"x = test_X[0].reshape(1, 4)\n",
"\n",
"# Flips the neural net into inference mode\n",
"model.eval()\n",
"\n",
"# Export the model\n",
"torch.onnx.export(model, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump(data, open(data_path, 'w'))\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9P4x79hIeiLO"
},
"source": [
"After which we can proceed to generate the settings file for `ezkl` and run calibrate settings to find the optimal settings for `ezkl`"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "cY25BIyreIX8"
},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# use the test set to calibrate the circuit\n",
"cal_data = dict(input_data = test_X.flatten().tolist())\n",
"\n",
"# Serialize calibration data into file:\n",
"json.dump(data, open(cal_data_path, 'w'))\n",
"\n",
"# Optimize for resources, we cap logrows at 12 to reduce setup and proving time, at the expense of accuracy\n",
"# You may want to increase the max logrows if accuracy is a concern\n",
"res = ezkl.calibrate_settings(cal_data_path, model_path, settings_path, \"resources\", max_logrows = 12, scales = [2])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MFmPMBQ1jYao"
},
"source": [
"Next, we will compile the model. The compilation step allow us to generate proofs faster."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "De5XtpGUerkZ"
},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "UbkuSVKljmhA"
},
"source": [
"Before we can setup the circuit params, we need a SRS (Structured Reference String). The SRS is used to generate the proofs."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "amaTcWG6f2GI"
},
"outputs": [],
"source": [
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Y92p3GhVj1Jd"
},
"source": [
"Now run setup, this will generate a proving key (pk) and verification key (vk). The proving key is used for proving while the verification key is used for verificaton."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "fdsteit9jzfK"
},
"outputs": [],
"source": [
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" )\n",
"\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "QYlqpP3jkExm"
},
"source": [
"Now, we can generate a proof and verify the proof as a sanity check. We will use the \"evm\" transcript. This will allow us to provide proofs to the EVM."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "yoz5Vks5kaHI"
},
"outputs": [],
"source": [
"# Generate the Witness for the proof\n",
"\n",
"# now generate the witness file\n",
"witness_path = os.path.join('witness.json')\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "eKkFBZX1kBdE",
"outputId": "48c67e19-a491-4515-f09c-a560df8c3834"
},
"outputs": [],
"source": [
"# Generate the proof\n",
"\n",
"proof_path = os.path.join('proof.json')\n",
"\n",
"proof = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \"single\",\n",
" )\n",
"\n",
"print(proof)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "DuuH-qcOkQf1",
"outputId": "375fdd63-1c0b-4c3c-eddd-f890a752923c"
},
"outputs": [],
"source": [
"# verify our proof\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TOSRigalkwH-"
},
"source": [
"## Congratulations! You have just turned your Neural Network into a Halo2 Circuit!\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "flrg3NOGwsJh"
},
"source": [
"\n",
"# Part 3: Deploying the Verifier\n",
"Now that we have the circuit setup, we can proceed to deploy the verifier onchain.\n",
"\n",
"We will need to setup `solc=0.8.20` for this."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "CVqMeMYqktvl",
"outputId": "60ef81a5-867e-4a27-a0a1-0a492244e7f7"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"solc-select\"])\n",
" !solc-select install 0.8.20\n",
" !solc-select use 0.8.20\n",
" !solc --version\n",
"\n",
"# rely on local installation if the notebook is not in colab\n",
"except:\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HRHvkMjVlfWU"
},
"source": [
"With solc in our environment we can now create the evm verifier."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "gYlw20VZkva7"
},
"outputs": [],
"source": [
"sol_code_path = os.path.join('Verifier.sol')\n",
"abi_path = os.path.join('Verifier.abi')\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" \n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path\n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(sol_code_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "jQSAVMvxrBQD",
"outputId": "691484fa-ef21-4b40-e179-9d2d90abd3d0"
},
"outputs": [],
"source": [
"onchain_input_array = []\n",
"\n",
"# using a loop\n",
"# avoiding printing last comma\n",
"formatted_output = \"[\"\n",
"for i, value in enumerate(proof[\"instances\"]):\n",
" for j, field_element in enumerate(value):\n",
" onchain_input_array.append(ezkl.felt_to_big_endian(field_element))\n",
" formatted_output += '\"' + str(onchain_input_array[-1]) + '\"'\n",
" if j != len(value) - 1:\n",
" formatted_output += \", \"\n",
" if i != len(proof[\"instances\"]) - 1:\n",
" formatted_output += \", \"\n",
"formatted_output += \"]\"\n",
"\n",
"# This will be the values you use onchain\n",
"# copy them over to remix and see if they verify\n",
"# What happens when you change a value?\n",
"print(\"pubInputs: \", formatted_output)\n",
"print(\"proof: \", proof[\"proof\"])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zrzPxPvZmX9b"
},
"source": [
"We will exit colab for the next steps. At the left of colab you can see a folder icon. Click on that.\n",
"\n",
"\n",
"You should see a `Verifier.sol`. Right-click and save it locally.\n",
"\n",
"Now go to [https://remix.ethereum.org](https://remix.ethereum.org).\n",
"\n",
"Create a new file within remix and copy the verifier code over.\n",
"\n",
"Finally, compile the code and deploy. For the demo you can deploy to the test environment within remix.\n",
"\n",
"If everything works, you would have deployed your verifer onchain! Copy the values in the cell above to the respective fields to test if the verifier is working.\n",
"\n",
"**Note that right now this setup accepts random values!**\n",
"\n",
"This might not be great for some applications. For that we will want to use a data attested verifier instead. [See this tutorial.](https://github.com/zkonduit/ezkl/blob/main/examples/notebooks/data_attest.ipynb)\n",
"\n",
"## Congratulations for making it this far!\n",
"\n",
"If you have followed the whole tutorial, you would have deployed a neural network inference model onchain! That's no mean feat!"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/gcn.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "5fe9feb6-2b35-414a-be9d-771eabdbb0dc",
"metadata": {
"id": "5fe9feb6-2b35-414a-be9d-771eabdbb0dc"
},
"source": [
"## EZKL GCN Notebook"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "nGcl_1sltpRq",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "nGcl_1sltpRq",
"outputId": "642693ac-970f-4ad9-80f5-e58c69f04ee9"
},
"outputs": [],
"source": [
"!pip install torch-scatter torch-sparse torch-geometric"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1005303a-cd48-4766-9c43-2116f94ed381",
"metadata": {
"id": "1005303a-cd48-4766-9c43-2116f94ed381"
},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"import torch\n",
"from torch import nn\n",
"import torch.nn.functional as F\n",
"\n",
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" for e in [\"ezkl\", \"onnx\", \"torch\", \"torchvision\", \"torch-scatter\", \"torch-sparse\", \"torch-geometric\"]:\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", e])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "89e5732e-a97b-445e-9174-69689e37e72c",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "89e5732e-a97b-445e-9174-69689e37e72c",
"outputId": "24049b0a-439b-4327-a829-4b4045490f0f"
},
"outputs": [],
"source": [
"import torch\n",
"from torch_geometric.data import Data\n",
"\n",
"edge_index = torch.tensor([[2, 1, 3],\n",
" [0, 0, 2]], dtype=torch.long)\n",
"x = torch.tensor([[1], [1], [1]], dtype=torch.float)\n",
"\n",
"data = Data(x=x, edge_index=edge_index)\n",
"data"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "73b34e81-63cb-44b0-9f95-f8490e844676",
"metadata": {
"id": "73b34e81-63cb-44b0-9f95-f8490e844676"
},
"outputs": [],
"source": [
"import torch\n",
"import math\n",
"from torch_geometric.nn import MessagePassing\n",
"from torch.nn.modules.module import Module\n",
"\n",
"def glorot(tensor):\n",
" if tensor is not None:\n",
" stdv = math.sqrt(6.0 / (tensor.size(-2) + tensor.size(-1)))\n",
" tensor.data.uniform_(-stdv, stdv)\n",
"\n",
"\n",
"def zeros(tensor):\n",
" if tensor is not None:\n",
" tensor.data.fill_(0)\n",
"\n",
"class GCNConv(Module):\n",
" def __init__(self, in_channels, out_channels):\n",
" super(GCNConv, self).__init__() # \"Add\" aggregation.\n",
" self.lin = torch.nn.Linear(in_channels, out_channels)\n",
"\n",
" self.reset_parameters()\n",
"\n",
" def reset_parameters(self):\n",
" glorot(self.lin.weight)\n",
" zeros(self.lin.bias)\n",
"\n",
" def forward(self, x, adj_t, deg):\n",
" x = self.lin(x)\n",
" adj_t = self.normalize_adj(adj_t, deg)\n",
" x = adj_t @ x\n",
"\n",
" return x\n",
"\n",
" def normalize_adj(self, adj_t, deg):\n",
" deg.masked_fill_(deg == 0, 1.)\n",
" deg_inv_sqrt = deg.pow_(-0.5)\n",
" deg_inv_sqrt.masked_fill_(deg_inv_sqrt == 1, 0.)\n",
" adj_t = adj_t * deg_inv_sqrt.view(-1, 1) # N, 1\n",
" adj_t = adj_t * deg_inv_sqrt.view(1, -1) # 1, N\n",
"\n",
" return adj_t"
]
},
{
"cell_type": "markdown",
"id": "ae70bc34-def7-40fd-9558-2500c6f29323",
"metadata": {
"id": "ae70bc34-def7-40fd-9558-2500c6f29323"
},
"source": [
"## Train Pipeline"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7ca117a1-7473-42a6-be95-dc314eb3e251",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "7ca117a1-7473-42a6-be95-dc314eb3e251",
"outputId": "edacee52-8a88-4c02-9a71-fd094e89c7b9"
},
"outputs": [],
"source": [
"import os\n",
"import os.path as osp\n",
"import torch\n",
"import torch.nn.functional as F\n",
"from torch_geometric.datasets import Planetoid\n",
"import torch_geometric.transforms as T\n",
"\n",
"path = osp.join(os.getcwd(), 'data', 'Cora')\n",
"dataset = Planetoid(path, 'Cora')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "807f4d87-6acc-4cbb-80e4-8eb09feb994c",
"metadata": {
"id": "807f4d87-6acc-4cbb-80e4-8eb09feb994c"
},
"outputs": [],
"source": [
"import time\n",
"\n",
"from torch import tensor\n",
"from torch.optim import Adam\n",
"\n",
"# define num feat to use for training here\n",
"num_feat = 10\n",
"\n",
"def run(dataset, model, runs, epochs, lr, weight_decay, early_stopping):\n",
"\n",
" val_losses, accs, durations = [], [], []\n",
" for _ in range(runs):\n",
" data = dataset[0]\n",
" data = data.to(device)\n",
"\n",
" model.to(device).reset_parameters()\n",
" optimizer = Adam(model.parameters(), lr=lr, weight_decay=weight_decay)\n",
"\n",
" if torch.cuda.is_available():\n",
" torch.cuda.synchronize()\n",
"\n",
" t_start = time.perf_counter()\n",
"\n",
" best_val_loss = float('inf')\n",
" test_acc = 0\n",
" val_loss_history = []\n",
"\n",
" for epoch in range(1, epochs + 1):\n",
" train(model, optimizer, data)\n",
" eval_info = evaluate(model, data)\n",
" eval_info['epoch'] = epoch\n",
"\n",
" if eval_info['val_loss'] < best_val_loss:\n",
" best_val_loss = eval_info['val_loss']\n",
" test_acc = eval_info['test_acc']\n",
"\n",
" val_loss_history.append(eval_info['val_loss'])\n",
" if early_stopping > 0 and epoch > epochs // 2:\n",
" tmp = tensor(val_loss_history[-(early_stopping + 1):-1])\n",
" if eval_info['val_loss'] > tmp.mean().item():\n",
" break\n",
"\n",
" if torch.cuda.is_available():\n",
" torch.cuda.synchronize()\n",
"\n",
" t_end = time.perf_counter()\n",
"\n",
" val_losses.append(best_val_loss)\n",
" accs.append(test_acc)\n",
" durations.append(t_end - t_start)\n",
"\n",
" loss, acc, duration = tensor(val_losses), tensor(accs), tensor(durations)\n",
"\n",
" print('Val Loss: {:.4f}, Test Accuracy: {:.3f} ± {:.3f}, Duration: {:.3f}'.\n",
" format(loss.mean().item(),\n",
" acc.mean().item(),\n",
" acc.std().item(),\n",
" duration.mean().item()))\n",
"\n",
"\n",
"def train(model, optimizer, data):\n",
" model.train()\n",
" optimizer.zero_grad()\n",
"\n",
" E = data.edge_index.size(1)\n",
" N = data.x.size(0)\n",
" x = data.x[:, :num_feat]\n",
" adj_t = torch.sparse_coo_tensor(data.edge_index, torch.ones(E), size=(N, N)).to_dense().T\n",
" deg = torch.sum(adj_t, dim=1)\n",
" out = model(x, adj_t, deg)\n",
" loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])\n",
" loss.backward()\n",
" optimizer.step()\n",
"\n",
"\n",
"def evaluate(model, data):\n",
" model.eval()\n",
"\n",
" with torch.no_grad():\n",
"\n",
" E = data.edge_index.size(1)\n",
" N = data.x.size(0)\n",
" x = data.x[:, :num_feat]\n",
" adj_t = torch.sparse_coo_tensor(data.edge_index, torch.ones(E), size=(N, N)).to_dense().T\n",
" deg = torch.sum(adj_t, dim=1)\n",
" logits = model(x, adj_t, deg)\n",
"\n",
" outs = {}\n",
" for key in ['train', 'val', 'test']:\n",
" mask = data['{}_mask'.format(key)]\n",
" loss = F.nll_loss(logits[mask], data.y[mask]).item()\n",
" pred = logits[mask].max(1)[1]\n",
" acc = pred.eq(data.y[mask]).sum().item() / mask.sum().item()\n",
"\n",
" outs['{}_loss'.format(key)] = loss\n",
" outs['{}_acc'.format(key)] = acc\n",
"\n",
" return outs"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28b3605e-e6fd-45ff-ae4b-607065f4849c",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "28b3605e-e6fd-45ff-ae4b-607065f4849c",
"outputId": "b3ea504c-b57c-46d4-b382-aa54c9a4786f"
},
"outputs": [],
"source": [
"runs = 1\n",
"epochs = 200\n",
"lr = 0.01\n",
"weight_decay = 0.0005\n",
"early_stopping = 10\n",
"hidden = 16\n",
"dropout = 0.5\n",
"device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
"\n",
"\n",
"class Net(torch.nn.Module):\n",
" def __init__(self, dataset, num_feat):\n",
" super(Net, self).__init__()\n",
" # self.conv1 = GCNConv(dataset.num_features, hidden)\n",
" self.conv1 = GCNConv(num_feat, hidden)\n",
" self.conv2 = GCNConv(hidden, dataset.num_classes)\n",
"\n",
"\n",
" def reset_parameters(self):\n",
" self.conv1.reset_parameters()\n",
" self.conv2.reset_parameters()\n",
"\n",
" def forward(self, x, adj_t, deg):\n",
" x = F.relu(self.conv1(x, adj_t, deg))\n",
" x = F.dropout(x, p=dropout, training=self.training)\n",
" x = self.conv2(x, adj_t, deg)\n",
" return F.log_softmax(x, dim=1)\n",
"\n",
"model = Net(dataset, num_feat)\n",
"run(dataset, model, runs, epochs, lr, weight_decay, early_stopping)"
]
},
{
"cell_type": "markdown",
"id": "4cc3ffed-74c2-48e3-86bc-a5e51f44a09a",
"metadata": {
"id": "4cc3ffed-74c2-48e3-86bc-a5e51f44a09a"
},
"source": [
"## EZKL Setup"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "92585631-ff39-402e-bd1c-aaebdce682e5",
"metadata": {
"id": "92585631-ff39-402e-bd1c-aaebdce682e5"
},
"outputs": [],
"source": [
"import os\n",
"import ezkl\n",
"\n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d80d3169-cc70-4aee-bdc2-df9a435b3116",
"metadata": {
"id": "d80d3169-cc70-4aee-bdc2-df9a435b3116"
},
"outputs": [],
"source": [
"# Downsample graph\n",
"num_node = 5\n",
"\n",
"# filter edges so that we only bring adjacencies among downsampled node\n",
"filter_row = []\n",
"filter_col = []\n",
"row, col = dataset[0].edge_index\n",
"for idx in range(row.size(0)):\n",
" if row[idx] < num_node and col[idx] < num_node:\n",
" filter_row.append(row[idx])\n",
" filter_col.append(col[idx])\n",
"filter_edge_index = torch.stack([torch.tensor(filter_row), torch.tensor(filter_col)])\n",
"num_edge = len(filter_row)\n",
"\n",
"\n",
"x = dataset[0].x[:num_node, :num_feat]\n",
"edge_index = filter_edge_index\n",
"\n",
"adj_t = torch.sparse_coo_tensor(edge_index, torch.ones(num_edge), size=(num_node, num_node)).to_dense().T\n",
"deg = torch.sum(adj_t, dim=1)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "46367b2f-951d-403b-9346-e689de0bee3f",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "46367b2f-951d-403b-9346-e689de0bee3f",
"outputId": "f063bf1b-e518-4fdb-b8ad-507c521acaa3"
},
"outputs": [],
"source": [
"import json\n",
"\n",
"# Flips the neural net into inference mode\n",
"model.eval()\n",
"model.to('cpu')\n",
"\n",
"# No dynamic axis for GNN batch\n",
"torch.onnx.export(model, # model being run\n",
" (x, adj_t, deg), # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=11, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['x', 'edge_index'], # the model's input names\n",
" output_names = ['output']) # the model's output names"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9e6da242-540e-48dc-bc20-d08fcd192af4",
"metadata": {
"id": "9e6da242-540e-48dc-bc20-d08fcd192af4"
},
"outputs": [],
"source": [
"torch_out = model(x, adj_t, deg)\n",
"x_shape = x.shape\n",
"adj_t_shape=adj_t.shape\n",
"deg_shape=deg.shape\n",
"\n",
"x = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"adj_t = ((adj_t).detach().numpy()).reshape([-1]).tolist()\n",
"deg = ((deg).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[x_shape, adj_t_shape, deg_shape],\n",
" input_data=[x, adj_t, deg],\n",
" output_data=[((torch_out).detach().numpy()).reshape([-1]).tolist()])\n",
"json.dump(data, open(data_path, 'w'))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3393a884-7a14-435e-bb9e-4fa4fcbdc76b",
"metadata": {
"id": "3393a884-7a14-435e-bb9e-4fa4fcbdc76b",
"tags": []
},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"import ezkl\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_scale = 5\n",
"run_args.param_scale = 5\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8f86fceb",
"metadata": {
"id": "8f86fceb"
},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3b55c925",
"metadata": {
"id": "3b55c925"
},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d6478bab",
"metadata": {
"id": "d6478bab"
},
"outputs": [],
"source": [
"# now generate the witness file\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b500c1ba",
"metadata": {
"id": "b500c1ba"
},
"outputs": [],
"source": [
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ae152a64",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ae152a64",
"outputId": "599cc9b8-ee85-407e-f0da-b2360634d2a8"
},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a2548b00",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "a2548b00",
"outputId": "e2972113-c079-4cb2-bfc5-6f7ad2842195"
},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3.11.4 ('.env': venv)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
},
"vscode": {
"interpreter": {
"hash": "af2b032f4d5a009ff33cd3ba5ac25dedfd7d71c9736fbe82aa90983ec2fc3628"
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/generalized_inverse.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67"
},
"source": [
"\n",
"## Generalized Inverse\n",
"\n",
"We show how to use EZKL to prove that we know matrices $A$ and its generalized inverse $B$. Since these are large we deal with the KZG commitments, with $a$ the polycommit of $A$, $b$ the polycommit of $B$, and $ABA = A$.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {
"id": "95613ee9"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9LgqGF56Qcdz",
"metadata": {
"id": "9LgqGF56Qcdz"
},
"outputs": [],
"source": [
"class GeneralizedInverseProof(nn.Module):\n",
" def __init__(self):\n",
" super(GeneralizedInverseProof, self).__init__()\n",
" self.relu = nn.ReLU()\n",
"\n",
" def forward(self,A,B):\n",
" # some expression of tolerance to error in the inference\n",
" return torch.sum(torch.abs(A@B@A - A)) < 0.1\n",
"\n",
"circuit = GeneralizedInverseProof()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "YRQLvvsXVs9s",
"metadata": {
"id": "YRQLvvsXVs9s"
},
"outputs": [],
"source": [
"gip_run_args = ezkl.PyRunArgs()\n",
"gip_run_args.input_visibility = \"polycommit\" # matrix and generalized inverse commitments\n",
"gip_run_args.output_visibility = \"fixed\" # no parameters used\n",
"gip_run_args.param_visibility = \"fixed\" # should be Tensor(True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {
"id": "b37637c4"
},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {
"id": "82db373a"
},
"outputs": [],
"source": [
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"shape = [10, 10]\n",
"\n",
"A = 0.1*torch.rand(1,*shape, requires_grad=True)\n",
"B = A.inverse()\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" (A,B), # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input1', 'input2'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input1' : {0 : 'batch_size'},\n",
" 'input2' : {0 : 'batch_size'},\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"d0 = ((A).detach().numpy()).reshape([-1]).tolist()\n",
"d1 = ((B).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(\n",
" input_data=[d0, d1],\n",
")\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "HOLcdGx4eQ9n",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "HOLcdGx4eQ9n",
"outputId": "cd0a4f10-251e-492e-9f05-d8af0d79c86a"
},
"outputs": [],
"source": [
"circuit.forward(A,B)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {
"colab": {
"background_save": true,
"base_uri": "https://localhost:8080/"
},
"id": "d5e374a2",
"outputId": "11ae5963-02d4-4939-9c98-d126071a9ba0"
},
"outputs": [],
"source": [
"\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=gip_run_args)\n",
"\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (0.1*torch.rand(20,*shape).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {
"id": "3aa4f090"
},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {
"id": "8b74dcee"
},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {
"id": "18c8b7c7"
},
"outputs": [],
"source": [
"# now generate the witness file\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {
"id": "b1c561a8"
},
"outputs": [],
"source": [
"\n",
"# we pass the witness file to the setup function so as to prepopulate the \"fixed\" columns of the circuit. \n",
"# in this case we want to force the output to be 0 meaning that the difference between the two matrices is 0\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" witness_path = witness_path,\n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {
"id": "c384cbc8"
},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {
"id": "76f00d41"
},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
} | https://github.com/zkonduit/ezkl |
examples/notebooks/gradient_boosted_trees.ipynb | {
"cells": [
{
"attachments": {
"image-2.png": {
"image/png": "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"
},
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## Gradient Boosted Trees\n",
"\n",
"\n",
"Sklearn based models are slightly finicky to get into a suitable onnx format. By default most tree based models will export into something that looks like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Processing such nodes can be difficult and error prone. It would be much better if the operations of the tree were represented as a proper graph, possibly ... like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"This notebook showcases how to do that using the `hummingbird-ml` python package ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.ensemble import GradientBoostingClassifier as Gbc\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"from torch import nn\n",
"from hummingbird.ml import convert\n",
"\n",
"\n",
"NUM_CLASSES = 3\n",
"\n",
"iris = load_iris()\n",
"X, y = iris.data, iris.target\n",
"X = X.astype(np.float32)\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
"clr = Gbc()\n",
"clr.fit(X_train, y_train)\n",
"\n",
"\n",
"\n",
"torch_gbt = convert(clr, \"torch\", X_test[:1])\n",
"# assert predictions from torch are = to sklearn\n",
"diffs = []\n",
"\n",
"for i in range(len(X_test)):\n",
" torch_pred = torch_gbt.predict(torch.tensor(X_test[i].reshape(1, -1)))\n",
" sk_pred = clr.predict(X_test[i].reshape(1, -1))\n",
" diffs.append(torch_pred != sk_pred[0])\n",
"\n",
"print(\"num diff: \", sum(diffs))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"# !!!!!!!!!!!!!!!!! This cell will flash a warning about onnx runtime compat but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"\n",
"\n",
"# Input to the model\n",
"shape = X_train.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=False)\n",
"torch_out = torch_gbt.predict(x)\n",
"# Export the model\n",
"torch.onnx.export(torch_gbt.model, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=18, # the ONNX version to export the model to\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"run_args = ezkl.PyRunArgs()\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20,*shape).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/hashed_vis.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# hashed-ezkl\n",
"\n",
"Here's an example leveraging EZKL whereby the inputs to the model, and the model params themselves, are hashed inside a circuit.\n",
"\n",
"In this setup:\n",
"- the hashes are publicly known to the prover and verifier\n",
"- the hashes serve as \"public inputs\" (a.k.a instances) to the circuit\n",
"\n",
"We leave the outputs of the model as public as well (known to the verifier and prover). \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"First we import the necessary dependencies and set up logging to be as informative as possible. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import logging\n",
"\n",
"# uncomment for more descriptive logging \n",
"FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"logging.basicConfig(format=FORMAT)\n",
"logging.getLogger().setLevel(logging.INFO)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we define our model. It is a humble model with but a conv layer and a $ReLU$ non-linearity, but it is a model nonetheless"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"# Defines the model\n",
"# we got convs, we got relu, \n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=3, out_channels=1, kernel_size=5, stride=4)\n",
" self.relu = nn.ReLU()\n",
"\n",
" def forward(self, x):\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
"\n",
" return x\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# this is where you'd train your model\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
"Now we export the model to onnx and create a corresponding (randomly generated) input file.\n",
"\n",
"You can replace the random `x` with real data if you so wish. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"shape = [3, 8, 8]\n",
"x = torch.rand(1,*shape, requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(\"input.json\", 'w' ))\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"This is where the magic happens. We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
"- `input_visibility` defines the visibility of the model inputs\n",
"- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
"- `output_visibility` defines the visibility of the model outputs\n",
"\n",
"There are currently 6 visibility settings:\n",
"- `public`: known to both the verifier and prover (a subtle nuance is that this may not be the case for model parameters but until we have more rigorous theoretical results we don't want to make strong claims as to this). \n",
"- `private`: known only to the prover\n",
"- `fixed`: known to the prover and verifier (as a commit), but not modifiable by the prover.\n",
"- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
"- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
"- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be inserted directly within the proof bytes. \n",
"\n",
"\n",
"Here we create the following setup:\n",
"- `input_visibility`: \"hashed\"\n",
"- `param_visibility`: \"hashed\"\n",
"- `output_visibility`: public\n",
"\n",
"We encourage you to play around with other setups :) \n",
"\n",
"Shoutouts: \n",
"\n",
"- [summa-solvency](https://github.com/summa-dev/summa-solvency) for their help with the poseidon hashing chip. \n",
"- [timeofey](https://github.com/timoftime) for providing inspiration in our developement of the el-gamal encryption circuit in Halo2. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"data_path = os.path.join('input.json')\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"hashed\"\n",
"run_args.param_visibility = \"hashed\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
"\n",
"You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# generate a bunch of dummy calibration data\n",
"cal_data = {\n",
" \"input_data\": [torch.cat((x, torch.rand(10, *[3, 8, 8]))).flatten().tolist()],\n",
"}\n",
"\n",
"cal_path = os.path.join('val_data.json')\n",
"# save as json file\n",
"with open(cal_path, \"w\") as f:\n",
" json.dump(cal_data, f)\n",
"\n",
"res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
"\n",
"These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.get_srs( settings_path)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We now need to generate the (partial) circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!export RUST_BACKTRACE=1\n",
"\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"As a sanity check you can \"mock prove\" (i.e check that all the constraints of the circuit match without generate a full proof). "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"res = ezkl.mock(witness_path, compiled_model_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a full proof. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"And verify it as a sanity check. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We can now create an EVM / `.sol` verifier that can be deployed on chain to verify submitted proofs using a view function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" \n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"assert res == True\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Verify on the evm"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Make sure anvil is running locally first\n",
"# run with $ anvil -p 3030\n",
"# we use the default anvil node here\n",
"import json\n",
"\n",
"address_path = os.path.join(\"address.json\")\n",
"\n",
"res = ezkl.deploy_evm(\n",
" address_path,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True\n",
"\n",
"with open(address_path, 'r') as file:\n",
" addr = file.read().rstrip()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# make sure anvil is running locally\n",
"# $ anvil -p 3030\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" \"http://127.0.0.1:3030\"\n",
")\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "ezkl",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
} | https://github.com/zkonduit/ezkl |
examples/notebooks/keras_simple_demo.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## EZKL Jupyter Notebook Demo with Keras\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a27b0cd9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"tf2onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import ezkl\n",
"import os\n",
"import json\n",
"from keras.models import Sequential\n",
"from keras.layers import Dense, Dropout, Activation, Flatten\n",
"from keras.layers import Convolution2D, MaxPooling2D\n",
"import logging\n",
"\n",
"# uncomment for more descriptive logging \n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.DEBUG)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# Defines the model\n",
"# we got convs, we got relu, we got linear layers, max pooling layers etc... \n",
"# What else could one want ????\n",
"\n",
"model = Sequential()\n",
"model.add(Convolution2D(2, (3,3), activation='relu', input_shape=(28,28,1)))\n",
"model.add(Convolution2D(2, (3,3), activation='relu'))\n",
"model.add(MaxPooling2D(pool_size=(2,2)))\n",
"model.add(Dropout(0.25))\n",
"model.add(Flatten())\n",
"model.add(Dense(128, activation='relu'))\n",
"model.add(Dropout(0.5))\n",
"model.add(Dense(10, activation='softmax'))\n",
"model.output_names=['output']\n",
"\n",
"\n",
"# Train the model as you like here (skipped for brevity)\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"import numpy as np\n",
"import tf2onnx\n",
"import tensorflow as tf\n",
"\n",
"\n",
"shape = [1, 28, 28]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*np.random.rand(1,*shape)\n",
"\n",
"spec = tf.TensorSpec([1, 28, 28, 1], tf.float32, name='input_0')\n",
"\n",
"\n",
"tf2onnx.convert.from_keras(model, input_signature=[spec], inputs_as_nchw=['input_0'], opset=12, output_path=model_path)\n",
"\n",
"data_array = x.reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (0.1*np.random.rand(20,*shape)).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b6e051d5",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs(settings_path = settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/kmeans.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## K-means\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"sk2torch\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.cluster import KMeans\n",
"from hummingbird.ml import convert\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"\n",
"\n",
"# Create a dataset of two Gaussians. There will be some overlap\n",
"# between the two classes, which adds some uncertainty to the model.\n",
"xs = np.concatenate(\n",
" [\n",
" np.random.random(size=(256, 2)) + [1, 0],\n",
" np.random.random(size=(256, 2)) + [-1, 0],\n",
" ],\n",
" axis=0,\n",
")\n",
"\n",
"# Train an SVM on the data and wrap it in PyTorch.\n",
"sk_model = KMeans()\n",
"sk_model.fit(xs)\n",
"model = convert(sk_model, backend=\"pytorch\").model\n",
"\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# export to onnx format\n",
"# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"# Create a coordinate grid to compute a vector field on.\n",
"spaced = np.linspace(-2, 2, num=25)\n",
"grid_xs = torch.tensor([[x, y] for x in spaced for y in spaced], requires_grad=True)\n",
"\n",
"# Input to the model\n",
"shape = xs.shape[1:]\n",
"x = grid_xs[0:1]\n",
"torch_out = model(x)\n",
"# Export the model\n",
"torch.onnx.export(model, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (grid_xs[0:20].detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/kzg_vis.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# kzg-ezkl\n",
"\n",
"Here's an example leveraging EZKL whereby the inputs to the model, and the model params themselves, are committed to using kzg-commitments inside a circuit.\n",
"\n",
"In this setup:\n",
"- the commitments are publicly known to the prover and verifier\n",
"\n",
"\n",
"We leave the outputs of the model as public as well (known to the verifier and prover). \n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"First we import the necessary dependencies and set up logging to be as informative as possible. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import logging\n",
"\n",
"# uncomment for more descriptive logging \n",
"FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"logging.basicConfig(format=FORMAT)\n",
"logging.getLogger().setLevel(logging.INFO)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we define our model. It is a humble model with but a conv layer and a $ReLU$ non-linearity, but it is a model nonetheless"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"# Defines the model\n",
"# we got convs, we got relu, \n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=3, out_channels=1, kernel_size=5, stride=4)\n",
" self.relu = nn.ReLU()\n",
"\n",
" def forward(self, x):\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
"\n",
" return x\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# this is where you'd train your model\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
"Now we export the model to onnx and create a corresponding (randomly generated) input file.\n",
"\n",
"You can replace the random `x` with real data if you so wish. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = torch.rand(1,*[3, 8, 8], requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(\"input.json\", 'w' ))\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"This is where the magic happens. We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
"- `input_visibility` defines the visibility of the model inputs\n",
"- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
"- `output_visibility` defines the visibility of the model outputs\n",
"\n",
"There are currently 6 visibility settings:\n",
"- `public`: known to both the verifier and prover (a subtle nuance is that this may not be the case for model parameters but until we have more rigorous theoretical results we don't want to make strong claims as to this). \n",
"- `private`: known only to the prover\n",
"- `fixed`: known to the prover and verifier (as a commit), but not modifiable by the prover.\n",
"- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
"- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
"- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes. \n",
"\n",
"Here we create the following setup:\n",
"- `input_visibility`: \"polycommit\"\n",
"- `param_visibility`: \"polycommit\"\n",
"- `output_visibility`: public\n",
"\n",
"We encourage you to play around with other setups :) \n",
"\n",
"Shoutouts: \n",
"\n",
"- [summa-solvency](https://github.com/summa-dev/summa-solvency) for their help with the poseidon hashing chip. \n",
"- [timeofey](https://github.com/timoftime) for providing inspiration in our development of the el-gamal encryption circuit in Halo2. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"data_path = os.path.join('input.json')\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"polycommit\"\n",
"run_args.param_visibility = \"polycommit\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
"\n",
"You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# generate a bunch of dummy calibration data\n",
"cal_data = {\n",
" \"input_data\": [torch.cat((x, torch.rand(10, *[3, 8, 8]))).flatten().tolist()],\n",
"}\n",
"\n",
"cal_path = os.path.join('val_data.json')\n",
"# save as json file\n",
"with open(cal_path, \"w\") as f:\n",
" json.dump(cal_data, f)\n",
"\n",
"res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
"\n",
"These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.get_srs( settings_path)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We now need to generate the (partial) circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!export RUST_BACKTRACE=1\n",
"\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As a sanity check you can \"mock prove\" (i.e check that all the constraints of the circuit match without generate a full proof). "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"res = ezkl.mock(witness_path, compiled_model_path)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a full proof. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we need to swap out the public commitments inside the corresponding proof bytes"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.swap_proof_commitments(proof_path, witness_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"And verify it as a sanity check. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res \n",
"\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We can now create an EVM / `.sol` verifier that can be deployed on chain to verify submitted proofs using a view function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" \n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"assert res == True\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Verify on the evm"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Make sure anvil is running locally first\n",
"# run with $ anvil -p 3030\n",
"# we use the default anvil node here\n",
"import json\n",
"\n",
"address_path = os.path.join(\"address.json\")\n",
"\n",
"res = ezkl.deploy_evm(\n",
" address_path,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True\n",
"\n",
"with open(address_path, 'r') as file:\n",
" addr = file.read().rstrip()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# make sure anvil is running locally\n",
"# $ anvil -p 3030\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" \"http://127.0.0.1:3030\"\n",
")\n",
"assert res == True"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "ezkl",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
} | https://github.com/zkonduit/ezkl |
examples/notebooks/lightgbm.ipynb | {
"cells": [
{
"attachments": {
"image-3.png": {
"image/png": "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"
},
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## LightBGM models\n",
"\n",
"\n",
"LightBGM based models are slightly finicky to get into a suitable onnx format. By default most tree based models will export into something that looks like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Processing such nodes can be difficult and error prone. It would be much better if the operations of the tree were represented as a proper graph, possibly ... like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"This notebook showcases how to do that using the `hummingbird` python package ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a60b90d6",
"metadata": {},
"outputs": [],
"source": [
"!python -m pip install hummingbird_ml"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"lightgbm\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.model_selection import train_test_split\n",
"from lightgbm import LGBMClassifier as Gbc\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"from torch import nn\n",
"from hummingbird.ml import convert\n",
"\n",
"NUM_CLASSES = 3\n",
"\n",
"iris = load_iris()\n",
"X, y = iris.data, iris.target\n",
"X = X.astype(np.float32)\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
"clr = Gbc(n_estimators=12)\n",
"clr.fit(X_train, y_train)\n",
"\n",
"# convert to torch\n",
"\n",
"\n",
"torch_gbt = convert(clr, 'torch', X_test[:1])\n",
"\n",
"print(torch_gbt)\n",
"# assert predictions from torch are = to sklearn\n",
"diffs = []\n",
"\n",
"for i in range(len(X_test)):\n",
" torch_pred = torch_gbt.predict(torch.tensor(X_test[i].reshape(1, -1)))\n",
" sk_pred = clr.predict(X_test[i].reshape(1, -1))\n",
" diffs.append(torch_pred != sk_pred[0])\n",
"\n",
"print(\"num diff: \", sum(diffs))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"# !!!!!!!!!!!!!!!!! This cell will flash a warning about onnx runtime compat but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"\n",
"# export to onnx format\n",
"\n",
"\n",
"# Input to the model\n",
"shape = X_train.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=False)\n",
"torch_out = torch_gbt.predict(x)\n",
"# Export the model\n",
"torch.onnx.export(torch_gbt.model, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=18, # the ONNX version to export the model to\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[(o).reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"run_args = ezkl.PyRunArgs()\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.randn(20, *shape).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1f50a8d0",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/linear_regression.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## Linear Regression\n",
"\n",
"\n",
"Sklearn based models are slightly finicky to get into a suitable onnx format. \n",
"This notebook showcases how to do so using the `hummingbird-ml` python package ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"import os\n",
"import torch\n",
"import ezkl\n",
"import json\n",
"from hummingbird.ml import convert\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import numpy as np\n",
"from sklearn.linear_model import LinearRegression\n",
"X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])\n",
"# y = 1 * x_0 + 2 * x_1 + 3\n",
"y = np.dot(X, np.array([1, 2])) + 3\n",
"reg = LinearRegression().fit(X, y)\n",
"reg.score(X, y)\n",
"\n",
"circuit = convert(reg, \"torch\", X[:1]).model\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# export to onnx format\n",
"# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"# Input to the model\n",
"shape = X.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=True)\n",
"torch_out = circuit(x)\n",
"# Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.randn(20, *shape).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/little_transformer.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "d0a82619",
"metadata": {},
"source": [
"Credits to [geohot](https://github.com/geohot/ai-notebooks/blob/master/mnist_gan.ipynb) for most of this code\n",
"\n",
"## Model Architecture and training"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c22afe46",
"metadata": {},
"outputs": [],
"source": [
"%pip install pytorch_lightning\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "12fb79a8",
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"import math\n",
"import numpy as np\n",
"\n",
"import torch\n",
"from torch import nn\n",
"import torch.nn.functional as F\n",
"\n",
"import pytorch_lightning as pl\n",
"\n",
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# uncomment for more descriptive logging \n",
"# import logging\n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.DEBUG)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8638e94e",
"metadata": {},
"outputs": [],
"source": [
"class BaseDataModule(pl.LightningDataModule):\n",
" def __init__(self, batch_size=32, split=0.8, *args, **kwargs):\n",
" super().__init__()\n",
" self.ds_X, self.ds_Y = self.get_dataset(*args, **kwargs)\n",
" self.split = int(self.ds_X.shape[0]*split)\n",
" self.batch_size = batch_size\n",
"\n",
" def train_dataloader(self):\n",
" ds_X_train, ds_Y_train = self.ds_X[0:self.split], self.ds_Y[0:self.split]\n",
" return torch.utils.data.DataLoader(list(zip(ds_X_train, ds_Y_train)), batch_size=self.batch_size)\n",
"\n",
" def val_dataloader(self):\n",
" ds_X_test, ds_Y_test = self.ds_X[self.split:], self.ds_Y[self.split:]\n",
" return torch.utils.data.DataLoader(list(zip(ds_X_test, ds_Y_test)), batch_size=self.batch_size)\n",
"\n",
"class ReverseDataModule(BaseDataModule):\n",
" def get_dataset(self, cnt=10000, seq_len=6):\n",
" ds = np.random.randint(0, 10, size=(cnt, seq_len))\n",
" return ds, ds[:, ::-1].ravel().reshape(cnt, seq_len)\n",
" \n",
"# dataset idea from https://github.com/karpathy/minGPT/blob/master/play_math.ipynb\n",
"class AdditionDataModule(BaseDataModule):\n",
" def get_dataset(self):\n",
" ret = []\n",
" for i in range(100):\n",
" for j in range(100):\n",
" s = i+j\n",
" ret.append([i//10, i%10, j//10, j%10, s//100, (s//10)%10, s%10])\n",
" ds = np.array(ret)\n",
" return ds[:, 0:6], np.copy(ds[:, 1:]) \n",
"\n",
"# this is the hardest to learn and requires 4 layers\n",
"class ParityDataModule(BaseDataModule):\n",
" def get_dataset(self, seq_len=10):\n",
" ds_X, ds_Y = [], []\n",
" for i in range(2**seq_len):\n",
" x = [int(x) for x in list(bin(i)[2:].rjust(seq_len, '0'))]\n",
" ds_X.append(x)\n",
" ds_Y.append((np.cumsum(x)%2).tolist())\n",
" return np.array(ds_X), np.array(ds_Y)\n",
" \n",
"class WikipediaDataModule(BaseDataModule):\n",
" def get_dataset(self, seq_len=50):\n",
" global enwik8\n",
" if 'enwik8' not in globals():\n",
" import requests\n",
" enwik8_zipped = requests.get(\"https://data.deepai.org/enwik8.zip\").content\n",
" from zipfile import ZipFile\n",
" import io\n",
" enwik8 = ZipFile(io.BytesIO(enwik8_zipped)).read('enwik8')\n",
" en = np.frombuffer(enwik8, dtype=np.uint8).astype(np.int)\n",
" en = en[0:-seq_len+1]\n",
" en[en>127] = 127\n",
" return en[0:-1].reshape(-1, seq_len), en[1:].reshape(-1, seq_len)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "323554ca",
"metadata": {},
"outputs": [],
"source": [
"def attention(queries, keys, values):\n",
" d = queries.shape[-1]\n",
" scores = torch.matmul(queries, keys.transpose(-2,-1))/math.sqrt(d)\n",
" attention_weights = F.softmax(scores, dim=-1)\n",
" return torch.matmul(attention_weights, values)\n",
"\n",
"class MultiHeadAttention(nn.Module):\n",
" def __init__(self, embed_dim, num_heads):\n",
" super(MultiHeadAttention, self).__init__()\n",
" self.embed_dim, self.num_heads = embed_dim, num_heads\n",
" assert embed_dim % num_heads == 0\n",
" self.projection_dim = embed_dim // num_heads\n",
" \n",
" self.W_q = nn.Linear(embed_dim, embed_dim)\n",
" self.W_k = nn.Linear(embed_dim, embed_dim)\n",
" self.W_v = nn.Linear(embed_dim, embed_dim)\n",
" self.W_o = nn.Linear(embed_dim, embed_dim)\n",
"\n",
" def transpose(self, x):\n",
" x = x.reshape(x.shape[0], x.shape[1], self.num_heads, self.projection_dim)\n",
" return x.permute(0, 2, 1, 3)\n",
" \n",
" def transpose_output(self, x):\n",
" x = x.permute(0, 2, 1, 3)\n",
" return x.reshape(x.shape[0], x.shape[1], self.embed_dim)\n",
" \n",
" def forward(self, q, k, v):\n",
" q = self.transpose(self.W_q(q))\n",
" k = self.transpose(self.W_k(k))\n",
" v = self.transpose(self.W_v(v))\n",
" output = attention(q, k, v)\n",
" return self.W_o(self.transpose_output(output))\n",
" \n",
"class TransformerBlock(nn.Module):\n",
" def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1):\n",
" super(TransformerBlock, self).__init__()\n",
" self.att = MultiHeadAttention(embed_dim, num_heads)\n",
" self.ffn = nn.Sequential(\n",
" nn.Linear(embed_dim, ff_dim), nn.ReLU(), nn.Linear(ff_dim, embed_dim)\n",
" )\n",
" self.layernorm1 = nn.LayerNorm(embed_dim)\n",
" self.layernorm2 = nn.LayerNorm(embed_dim)\n",
" self.dropout = nn.Dropout(rate)\n",
" \n",
" def forward(self, x):\n",
" x = self.layernorm1(x + self.dropout(self.att(x, x, x)))\n",
" x = self.layernorm2(x + self.dropout(self.ffn(x)))\n",
" return x\n",
" \n",
"class TokenAndPositionEmbedding(nn.Module):\n",
" def __init__(self, maxlen, vocab_size, embed_dim):\n",
" super(TokenAndPositionEmbedding, self).__init__()\n",
" self.token_emb = nn.Embedding(vocab_size, embed_dim)\n",
" self.pos_emb = nn.Embedding(maxlen, embed_dim)\n",
" def forward(self, x):\n",
" pos = torch.arange(0, x.size(1), dtype=torch.int32, device=x.device)\n",
" return self.token_emb(x) + self.pos_emb(pos).view(1, x.size(1), -1)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "167e42e3",
"metadata": {},
"outputs": [],
"source": [
"class LittleTransformer(pl.LightningModule):\n",
" def __init__(self, seq_len=6, max_value=10, layer_count=2, embed_dim=128, num_heads=4, ff_dim=32):\n",
" super().__init__()\n",
" self.max_value = max_value\n",
" self.model = nn.Sequential(\n",
" TokenAndPositionEmbedding(seq_len, max_value, embed_dim),\n",
" *[TransformerBlock(embed_dim, num_heads, ff_dim) for x in range(layer_count)],\n",
" nn.Linear(embed_dim, max_value),\n",
" nn.LogSoftmax(dim=-1))\n",
" \n",
" def forward(self, x):\n",
" return self.model(x)\n",
" \n",
" def training_step(self, batch, batch_idx):\n",
" x, y = batch\n",
" output = self.model(x)\n",
" loss = F.nll_loss(output.view(-1, self.max_value), y.view(-1))\n",
" self.log(\"train_loss\", loss)\n",
" return loss\n",
" \n",
" def validation_step(self, val_batch, batch_idx):\n",
" x, y = val_batch\n",
" pred = self.model(x).argmax(dim=2)\n",
" val_accuracy = (pred == y).type(torch.float).mean()\n",
" self.log(\"val_accuracy\", val_accuracy, prog_bar=True)\n",
" \n",
" def configure_optimizers(self):\n",
" if self.device.type == 'cuda':\n",
" import apex\n",
" return apex.optimizers.FusedAdam(self.parameters(), lr=3e-4)\n",
" else:\n",
" return torch.optim.Adam(self.parameters(), lr=3e-4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a2f48c98",
"metadata": {},
"outputs": [],
"source": [
"model = LittleTransformer(seq_len=6)\n",
"trainer = pl.Trainer(enable_progress_bar=True, max_epochs=0)\n",
"data = AdditionDataModule(batch_size=64)\n",
"#data = ReverseDataModule(cnt=1000, seq_len=20)\n",
"#data = ParityDataModule(seq_len=14)\n",
"trainer.fit(model, data)"
]
},
{
"cell_type": "markdown",
"id": "fa7d277e",
"metadata": {},
"source": [
"## EZKL "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6f339a28",
"metadata": {},
"outputs": [],
"source": [
"\n",
"import os \n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "27ce542b",
"metadata": {},
"outputs": [],
"source": [
"\n",
"import json\n",
"\n",
"\n",
"shape = [1, 6]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = torch.zeros(shape, dtype=torch.long)\n",
"x = x.reshape(shape)\n",
"\n",
"print(x)\n",
"\n",
"# Flips the neural net into inference mode\n",
"model.eval()\n",
"model.to('cpu')\n",
"\n",
" # Export the model\n",
"torch.onnx.export(model, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data_json = dict(input_data = [data_array])\n",
"\n",
"print(data_json)\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data_json, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "36ddc6f9",
"metadata": {},
"outputs": [],
"source": [
"import ezkl \n",
"\n",
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2fe6d972",
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.randn(20, *shape).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0990f5a8",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1b80dc01",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "54cbde29",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"witness_path = \"gan_witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28760638",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.mock(witness_path, compiled_model_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5e595112",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d37adaef",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5b58acd5",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/lstm.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "d0a82619",
"metadata": {},
"source": [
"\n",
"## Model Architecture and training"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "12fb79a8",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"import torch\n",
"from torch import nn\n",
"import torch.nn.functional as F\n",
"\n",
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a2f48c98",
"metadata": {},
"outputs": [],
"source": [
"model = nn.LSTM(3, 3) # Input dim is 3, output dim is 3\n",
"x = torch.randn(1, 3)\n",
"\n",
"# this is where you'd train the model"
]
},
{
"cell_type": "markdown",
"id": "fa7d277e",
"metadata": {},
"source": [
"## EZKL "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6f339a28",
"metadata": {},
"outputs": [],
"source": [
"\n",
"import os \n",
"import ezkl\n",
"\n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "27ce542b",
"metadata": {},
"outputs": [],
"source": [
"\n",
"import json \n",
"\n",
"\n",
"# Flips the neural net into inference mode\n",
"model.eval()\n",
"model.to('cpu')\n",
"\n",
" # Export the model\n",
"torch.onnx.export(model, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"\n",
"SEQ_LEN = 10\n",
"shape = (SEQ_LEN, 3)\n",
"# sequence of length 10\n",
"x = torch.randn(*shape)\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data_json = dict(input_data = [data_array])\n",
"\n",
"print(data_json)\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data_json, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2fe6d972",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.variables = [(\"batch_size\", SEQ_LEN)]\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.randn(10, *shape).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0990f5a8",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1b80dc01",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "54cbde29",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"witness_path = \"lstmwitness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28760638",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.mock(witness_path, compiled_model_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5e595112",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d37adaef",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5b58acd5",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/mean_postgres.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Mean of ERC20 transfer amounts\n",
"\n",
"This notebook shows how to calculate the mean of ERC20 transfer amounts, pulling data in from a Postgres database. First we install and get the necessary libraries running. \n",
"The first of which is [shovel](https://indexsupply.com/shovel/docs/#getting-started), which is a library that allows us to pull data from the Ethereum blockchain into a Postgres database.\n",
"\n",
"Make sure you install postgres if needed https://indexsupply.com/shovel/docs/#getting-started. \n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import getpass\n",
"import json\n",
"import time\n",
"import subprocess\n",
"\n",
"# swap out for the relevant linux/amd64, darwin/arm64, darwin/amd64, windows/amd64\n",
"os.system(\"curl -LO https://indexsupply.net/bin/1.0/linux/amd64/shovel\")\n",
"os.system(\"chmod +x shovel\")\n",
"\n",
"\n",
"os.environ[\"PG_URL\"] = \"postgres://\" + getpass.getuser() + \":@localhost:5432/shovel\"\n",
"\n",
"# create a config.json file with the following contents\n",
"config = {\n",
" \"pg_url\": \"$PG_URL\",\n",
" \"eth_sources\": [\n",
" {\"name\": \"mainnet\", \"chain_id\": 1, \"url\": \"https://ethereum-rpc.publicnode.com\"},\n",
" {\"name\": \"base\", \"chain_id\": 8453, \"url\": \"https://base-rpc.publicnode.com\"}\n",
" ],\n",
" \"integrations\": [{\n",
" \"name\": \"usdc_transfer\",\n",
" \"enabled\": True,\n",
" \"sources\": [{\"name\": \"mainnet\"}, {\"name\": \"base\"}],\n",
" \"table\": {\n",
" \"name\": \"usdc\",\n",
" \"columns\": [\n",
" {\"name\": \"log_addr\", \"type\": \"bytea\"},\n",
" {\"name\": \"block_num\", \"type\": \"numeric\"},\n",
" {\"name\": \"f\", \"type\": \"bytea\"},\n",
" {\"name\": \"t\", \"type\": \"bytea\"},\n",
" {\"name\": \"v\", \"type\": \"numeric\"}\n",
" ]\n",
" },\n",
" \"block\": [\n",
" {\"name\": \"block_num\", \"column\": \"block_num\"},\n",
" {\n",
" \"name\": \"log_addr\",\n",
" \"column\": \"log_addr\",\n",
" \"filter_op\": \"contains\",\n",
" \"filter_arg\": [\n",
" \"a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\n",
" \"833589fCD6eDb6E08f4c7C32D4f71b54bdA02913\"\n",
" ]\n",
" }\n",
" ],\n",
" \"event\": {\n",
" \"name\": \"Transfer\",\n",
" \"type\": \"event\",\n",
" \"anonymous\": False,\n",
" \"inputs\": [\n",
" {\"indexed\": True, \"name\": \"from\", \"type\": \"address\", \"column\": \"f\"},\n",
" {\"indexed\": True, \"name\": \"to\", \"type\": \"address\", \"column\": \"t\"},\n",
" {\"indexed\": False, \"name\": \"value\", \"type\": \"uint256\", \"column\": \"v\"}\n",
" ]\n",
" }\n",
" }]\n",
"}\n",
"\n",
"# write the config to a file\n",
"with open(\"config.json\", \"w\") as f:\n",
" f.write(json.dumps(config))\n",
"\n",
"\n",
"# print the two env variables\n",
"os.system(\"echo $PG_URL\")\n",
"\n",
"os.system(\"createdb -h localhost -p 5432 shovel\")\n",
"\n",
"os.system(\"echo shovel is now installed. starting:\")\n",
"\n",
"command = [\"./shovel\", \"-config\", \"config.json\"]\n",
"subprocess.Popen(command)\n",
"\n",
"os.system(\"echo shovel started.\")\n",
"\n",
"time.sleep(5)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2wIAHwqH2_mo"
},
"source": [
"**Import Dependencies**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "9Byiv2Nc2MsK"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"import ezkl\n",
"import torch\n",
"import datetime\n",
"import pandas as pd\n",
"import requests\n",
"import json\n",
"import os\n",
"\n",
"import logging\n",
"# # uncomment for more descriptive logging \n",
"FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"logging.basicConfig(format=FORMAT)\n",
"logging.getLogger().setLevel(logging.DEBUG)\n",
"\n",
"print(\"ezkl version: \", ezkl.__version__)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "osjj-0Ta3E8O"
},
"source": [
"**Create Computational Graph**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "x1vl9ZXF3EEW",
"outputId": "bda21d02-fe5f-4fb2-8106-f51a8e2e67aa"
},
"outputs": [],
"source": [
"from torch import nn\n",
"import torch\n",
"\n",
"\n",
"class Model(nn.Module):\n",
" def __init__(self):\n",
" super(Model, self).__init__()\n",
"\n",
" # x is a time series \n",
" def forward(self, x):\n",
" return [torch.mean(x)]\n",
"\n",
"\n",
"\n",
"\n",
"circuit = Model()\n",
"\n",
"\n",
"\n",
"\n",
"x = 0.1*torch.rand(1,*[1,5], requires_grad=True)\n",
"\n",
"# # print(torch.__version__)\n",
"device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
"\n",
"print(device)\n",
"\n",
"circuit.to(device)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
"# Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"lol.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=11, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"# export(circuit, input_shape=[1, 20])\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "E3qCeX-X5xqd"
},
"source": [
"**Set Data Source and Get Data**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "6RAMplxk5xPk",
"outputId": "bd2158fe-0c00-44fd-e632-6a3f70cdb7c9"
},
"outputs": [],
"source": [
"import getpass\n",
"# make an input.json file from the df above\n",
"input_filename = os.path.join('input.json')\n",
"\n",
"pg_input_file = dict(input_data = {\n",
" \"host\": \"localhost\",\n",
" # make sure you replace this with your own username\n",
" \"user\": getpass.getuser(),\n",
" \"dbname\": \"shovel\",\n",
" \"password\": \"\",\n",
" \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 5\",\n",
" \"port\": \"5432\",\n",
"})\n",
"\n",
"json_formatted_str = json.dumps(pg_input_file, indent=2)\n",
"print(json_formatted_str)\n",
"\n",
"\n",
" # Serialize data into file:\n",
"json.dump(pg_input_file, open(input_filename, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# this corresponds to 4 batches\n",
"calibration_filename = os.path.join('calibration.json')\n",
"\n",
"pg_cal_file = dict(input_data = {\n",
" \"host\": \"localhost\",\n",
" # make sure you replace this with your own username\n",
" \"user\": getpass.getuser(),\n",
" \"dbname\": \"shovel\",\n",
" \"password\": \"\",\n",
" \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 20\",\n",
" \"port\": \"5432\",\n",
"})\n",
"\n",
" # Serialize data into file:\n",
"json.dump( pg_cal_file, open(calibration_filename, 'w' ))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eLJ7oirQ_HQR"
},
"source": [
"**EZKL Workflow**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "rNw0C9QL6W88"
},
"outputs": [],
"source": [
"import subprocess\n",
"import os\n",
"\n",
"onnx_filename = os.path.join('lol.onnx')\n",
"compiled_filename = os.path.join('lol.compiled')\n",
"settings_filename = os.path.join('settings.json')\n",
"\n",
"# Generate settings using ezkl\n",
"res = ezkl.gen_settings(onnx_filename, settings_filename)\n",
"\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(input_filename, onnx_filename, settings_filename, \"resources\")\n",
"\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"ezkl.compile_circuit(onnx_filename, compiled_filename, settings_filename)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "4MmE9SX66_Il",
"outputId": "16403639-66a4-4280-ac7f-6966b75de5a3"
},
"outputs": [],
"source": [
"# generate settings\n",
"\n",
"\n",
"# show the settings.json\n",
"with open(\"settings.json\") as f:\n",
" data = json.load(f)\n",
" json_formatted_str = json.dumps(data, indent=2)\n",
"\n",
" print(json_formatted_str)\n",
"\n",
"assert os.path.exists(\"settings.json\")\n",
"assert os.path.exists(\"input.json\")\n",
"assert os.path.exists(\"lol.onnx\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "fULvvnK7_CMb"
},
"outputs": [],
"source": [
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"\n",
"\n",
"# setup the proof\n",
"res = ezkl.setup(\n",
" compiled_filename,\n",
" vk_path,\n",
" pk_path\n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_filename)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"witness_path = \"witness.json\"\n",
"\n",
"# generate the witness\n",
"res = ezkl.gen_witness(\n",
" input_filename,\n",
" compiled_filename,\n",
" witness_path\n",
" )\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Oog3j6Kd-Wed",
"outputId": "5839d0c1-5b43-476e-c2f8-6707de562260"
},
"outputs": [],
"source": [
"# prove the zk circuit\n",
"# GENERATE A PROOF\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"\n",
"proof = ezkl.prove(\n",
" witness_path,\n",
" compiled_filename,\n",
" pk_path,\n",
" proof_path,\n",
" \"single\"\n",
" )\n",
"\n",
"\n",
"print(\"proved\")\n",
"\n",
"assert os.path.isfile(proof_path)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# kill all shovel process \n",
"os.system(\"pkill -f shovel\")"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/mnist_classifier.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "6ypZa6jg0rZy"
},
"source": [
"## Mnist Clan-ssifier ;)\n",
"\n",
"Here we demonstrate how to use the EZKL package to build an MNIST classifier for on-chain handrawn digit recognition.\n",
"The proofs get submitted to a contract that assigns the users account to a digit clan (0-9). The contract keeps track of the member count of each clan. The clan with the most members is the winner!\n",
"\n",
"\n",
"> **A typical ZK application flow**. For all the image classifictiton hackers out there — this is an fairly straight forward example. A user computes a ZKML-proof that they have calculated a valid classification of a hand drawn digit from a MNIST trained lenet model. They submit this proof to a verifier contract which governs a set of clans, along with the output values of the model (length 10 tensor whereby the index with the max value represented the prediction), and the clan count updates according the lenets model's prediction. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "Fm2DMmXW0rZ0"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"torch\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"torchvision\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"tf2onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import time\n",
"import random\n",
"import logging\n",
"\n",
"\n",
"# uncomment for more descriptive logging\n",
"FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"logging.basicConfig(format=FORMAT)\n",
"logging.getLogger().setLevel(logging.INFO)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "jbRkAJLz0rZ1"
},
"outputs": [],
"source": [
"import torch\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"\n",
"class LeNet(nn.Module):\n",
" def __init__(self):\n",
" super(LeNet, self).__init__()\n",
" # Convolutional encoder\n",
" self.conv1 = nn.Conv2d(1, 6, 5) # 1 input channel, 6 output channels, 5x5 kernel\n",
" self.conv2 = nn.Conv2d(6, 16, 5) # 6 input channels, 16 output channels, 5x5 kernel\n",
"\n",
" # Fully connected layers / Dense block\n",
" self.fc1 = nn.Linear(16 * 4 * 4, 120) \n",
" self.fc2 = nn.Linear(120, 84) # 120 inputs, 84 outputs\n",
" self.fc3 = nn.Linear(84, 10) # 84 inputs, 10 outputs (number of classes)\n",
"\n",
" def forward(self, x):\n",
" # Convolutional block\n",
" x = F.avg_pool2d(F.sigmoid(self.conv1(x)), (2, 2)) # Convolution -> Sigmoid -> Avg Pool\n",
" x = F.avg_pool2d(F.sigmoid(self.conv2(x)), (2, 2)) # Convolution -> Sigmoid -> Avg Pool\n",
"\n",
" # Flattening\n",
" x = x.view(x.size(0), -1)\n",
"\n",
" # Fully connected layers\n",
" x = F.sigmoid(self.fc1(x))\n",
" x = F.sigmoid(self.fc2(x))\n",
" x = self.fc3(x) # No activation function here, will use CrossEntropyLoss later\n",
" return x\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "8yYNrvus0rZ2",
"outputId": "d3ae2380-fa03-4368-9bea-46c38a65ddca"
},
"outputs": [],
"source": [
"import numpy as np\n",
"import os\n",
"import torch\n",
"from torchvision.datasets import mnist\n",
"from torch.nn import CrossEntropyLoss\n",
"from torch.optim import Adam # Import Adam\n",
"from torch.utils.data import DataLoader\n",
"from torchvision.transforms import ToTensor\n",
"\n",
"def normalize_img(image, label):\n",
" return torch.round(image), label\n",
"\n",
"device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
"batch_size = 256\n",
"train_dataset = mnist.MNIST(root='./train', train=True, transform=ToTensor(), download=True)\n",
"test_dataset = mnist.MNIST(root='./test', train=False, transform=ToTensor(), download=True)\n",
"train_loader = DataLoader(train_dataset, batch_size=batch_size)\n",
"test_loader = DataLoader(test_dataset, batch_size=batch_size)\n",
"model = LeNet().to(device)\n",
"adam = Adam(model.parameters()) # Using Adam with a learning rate of 1e-3\n",
"loss_fn = CrossEntropyLoss()\n",
"all_epoch = 25\n",
"prev_acc = 0\n",
"for current_epoch in range(all_epoch):\n",
" model.train()\n",
" for idx, (train_x, train_label) in enumerate(train_loader):\n",
" train_x = train_x.to(device)\n",
" # normalize the image to 0 or 1 to reflect the inputs from the drawing board\n",
" train_x = train_x.round()\n",
" train_label = train_label.to(device)\n",
" adam.zero_grad() # Use adam optimizer\n",
" predict_y = model(train_x.float())\n",
" loss = loss_fn(predict_y, train_label.long())\n",
" loss.backward()\n",
" adam.step() # Use adam optimizer\n",
" all_correct_num = 0\n",
" all_sample_num = 0\n",
" model.eval()\n",
"\n",
" for idx, (test_x, test_label) in enumerate(test_loader):\n",
" test_x = test_x.to(device)\n",
" # normalize the image to 0 or 1 to reflect the inputs from the drawing board\n",
" test_x = test_x.round()\n",
" test_label = test_label.to(device)\n",
" predict_y = model(test_x.float()).detach()\n",
" predict_y = torch.argmax(predict_y, dim=-1)\n",
" current_correct_num = predict_y == test_label\n",
" all_correct_num += np.sum(current_correct_num.to('cpu').numpy(), axis=-1)\n",
" all_sample_num += current_correct_num.shape[0]\n",
" acc = all_correct_num / all_sample_num\n",
" print('test accuracy: {:.3f}'.format(acc), flush=True)\n",
" if not os.path.isdir(\"models\"):\n",
" os.mkdir(\"models\")\n",
" torch.save(model, 'models/mnist_{:.3f}.pkl'.format(acc))\n",
" prev_acc = acc\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"from matplotlib import colors\n",
"from scipy import stats\n",
"n_bins = 100\n",
"# whats the smallest parameter in this model ?\n",
"minimum_abs_val = 100000\n",
"params_abs = []\n",
"for param in model.parameters():\n",
" if param.abs().min() < minimum_abs_val:\n",
" minimum_abs_val = param.abs().min()\n",
" params_abs.extend(param.abs().detach().numpy().flatten().tolist())\n",
"\n",
"print(minimum_abs_val)\n",
"\n",
"xx = np.linspace(0, 0.2, 1000)\n",
"\n",
"kde = stats.gaussian_kde(params_abs)\n",
"fig, ax = plt.subplots(figsize = (6,4))\n",
"\n",
"ax.set_xlim(0, 0.2)\n",
"\n",
"# N is the count in each bin, bins is the lower-limit of the bin\n",
"N, bins, patches = ax.hist(params_abs, bins=n_bins, density = True, alpha =0.65)\n",
"ax.plot(xx, kde(xx))\n",
"\n",
"\n",
"ax.set_ylim(0, 14)\n",
"ax.set_yticklabels([])\n",
"ax.set_ylabel(\"\")\n",
"plt.style.use(\"bmh\")\n",
"ax.set_xticks([1.0/128.0, 1.0/32.0, 1.0/16.0])\n",
"ax.set_xticklabels([\"1/2^7\", \"1/2^6\", \"1/2^5\"])\n",
"ax.grid(False)\n",
"# Calculate percentiles\n",
"quant_5, quant_25, quant_50, quant_75, quant_95 = np.quantile(params_abs, 0.05), np.quantile(params_abs, 0.25), np.quantile(params_abs, 0.5), np.quantile(params_abs, 0.75), np.quantile(params_abs, 0.95)\n",
"\n",
"# [quantile, opacity, length]\n",
"quants = [[quant_5, 0.6, 0.16], [quant_25, 0.8, 0.26], [quant_50, 1, 0.36], [quant_75, 0.8, 0.46], [quant_95, 0.6, 0.56]]\n",
"\n",
"# Plot the lines with a loop\n",
"for i in quants:\n",
" ax.axvline(i[0], alpha = i[1], ymax = i[2], linestyle = \":\")\n",
"\n",
"# Annotations\n",
"ax.text(quant_5, 14 * 0.17, \"5th\", size = 10, alpha = 0.8)\n",
"ax.text(quant_25, 14 * 0.27, \"25th\", size = 10, alpha = 0.85)\n",
"ax.text(quant_50, 14 * 0.37, \"50th\", size = 10, alpha = 1)\n",
"ax.text(quant_75, 14 * 0.47, \"75th\", size = 10, alpha = 0.85)\n",
"ax.text(quant_95, 14 * 0.57, \"95th Percentile\", size = 10, alpha =.8)\n",
"\n",
"ax.set_title(\"Absolute value of parameters\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "tmGo25eb0rZ3"
},
"outputs": [],
"source": [
"import os\n",
"\n",
"model_path = os.path.join('network_lenet.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('key.pk')\n",
"vk_path = os.path.join('key.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "RfFjaXrM0rZ3"
},
"outputs": [],
"source": [
"import torch\n",
"import json\n",
"\n",
"model.eval() # Set the model to evaluation mode\n",
"\n",
"# # Fetch a single data point from the train_dataset\n",
"# # Ensure train_dataset is already loaded and accessible\n",
"train_data_point, _ = next(iter(train_dataset))\n",
"train_data_point = train_data_point.unsqueeze(0) # Add a batch dimension\n",
"\n",
"# Verify the device (CPU or CUDA) and transfer the data point to the same device as the model\n",
"device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
"train_data_point = train_data_point.to(device)\n",
"\n",
"# # Export the model to ONNX format\n",
"torch.onnx.export(model, train_data_point, model_path, export_params=True, opset_version=12, do_constant_folding=True, input_names=['input_0'], output_names=['output'])\n",
"\n",
"# Convert the tensor to numpy array and reshape it for JSON serialization\n",
"x = train_data_point.cpu().detach().numpy().reshape([-1]).tolist()\n",
"data = {'input_data': [x]}\n",
"with open('input.json', 'w') as f:\n",
" json.dump(data, f)\n",
"\n",
"print(f\"Model exported to {model_path} and input data saved to input.json\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "dS-yXte30rZ3"
},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"private\"\n",
"run_args.param_visibility = \"fixed\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.num_inner_cols = 2\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"# Capture set of data points\n",
"num_data_points = 8\n",
"\n",
"# Fetch 30 data points from the train_dataset\n",
"data_points = []\n",
"for i, (data_point, _) in enumerate(train_dataset):\n",
" if i >= num_data_points:\n",
" break\n",
" data_points.append(data_point)\n",
"\n",
"# Stack the data points to create a batch\n",
"train_data_batch = torch.stack(data_points)\n",
"\n",
"# Add a batch dimension if not already present\n",
"if train_data_batch.dim() == 3:\n",
" train_data_batch = train_data_batch.unsqueeze(0)\n",
"\n",
"x = train_data_batch.cpu().detach().numpy().reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [x])\n",
"\n",
"cal_path = os.path.join('cal_data.json')\n",
"\n",
"# Serialize data into file:\n",
"json.dump( data, open(cal_path, 'w' ))\n",
"\n",
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[2,7])\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "pGb1nj720rZ3"
},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "umpLxVAI0rZ3"
},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "syLy2Kt90rZ3"
},
"outputs": [],
"source": [
"# now generate the witness file\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "65u_ObBQ0rZ4"
},
"outputs": [],
"source": [
"res = ezkl.mock(witness_path, compiled_model_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "c8GIoMD40rZ4"
},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "vkIutAhR0rZ4"
},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "KmpQBZUT0rZ4"
},
"outputs": [],
"source": [
"# VERIFY IT\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CZ2CYQdm0rZ4"
},
"source": [
"We can now create an EVM / `.sol` verifier that can be deployed on chain to verify submitted proofs using a view function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "jASymUWQ0rZ4"
},
"outputs": [],
"source": [
"\n",
"abi_path = 'test.abi'\n",
"sol_code_path = 'test_1.sol'\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"assert res == True"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-icN2yw60rZ5"
},
"source": [
"## Verify on the evm"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "sTLsLwaC0rZ5"
},
"outputs": [],
"source": [
"# Make sure anvil is running locally first\n",
"# run with $ anvil -p 3030\n",
"# we use the default anvil node here\n",
"import json\n",
"\n",
"address_path = os.path.join(\"address.json\")\n",
"\n",
"res = ezkl.deploy_evm(\n",
" address_path,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True\n",
"\n",
"with open(address_path, 'r') as file:\n",
" addr = file.read().rstrip()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "PrSyQK4B0rZ5"
},
"outputs": [],
"source": [
"# make sure anvil is running locally\n",
"# $ anvil -p 3030\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" \"http://127.0.0.1:3030\"\n",
")\n",
"assert res == True"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/mnist_gan.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Credits to [geohot](https://github.com/geohot/ai-notebooks/blob/master/mnist_gan.ipynb) for most of this code"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"tf2onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import time\n",
"import random\n",
"import logging\n",
"\n",
"import tensorflow as tf\n",
"from tensorflow.keras.optimizers import Adam\n",
"from tensorflow.keras.layers import *\n",
"from tensorflow.keras.models import Model\n",
"from tensorflow.keras.datasets import mnist\n",
"\n",
"# uncomment for more descriptive logging \n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.INFO)\n",
"\n",
"# Can we build a simple GAN that can produce all 10 mnist digits?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
"x_train, x_test = [x/255.0 for x in [x_train, x_test]]\n",
"y_train, y_test = [tf.keras.utils.to_categorical(x) for x in [y_train, y_test]]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"ZDIM = 100\n",
"\n",
"opt = Adam()\n",
"\n",
"\n",
"# discriminator\n",
"# 0 if it's fake, 1 if it's real\n",
"x = in1 = Input((28,28))\n",
"x = Reshape((28,28,1))(x)\n",
"\n",
"x = Conv2D(64, (5,5), padding='same', strides=(2,2))(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"\n",
"x = Conv2D(128, (5,5), padding='same', strides=(2,2))(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"\n",
"x = Flatten()(x)\n",
"x = Dense(128)(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"x = Dense(1, activation='sigmoid')(x)\n",
"dm = Model(in1, x)\n",
"dm.compile(opt, 'binary_crossentropy')\n",
"dm.summary()\n",
"\n",
"# generator, output digits\n",
"x = in1 = Input((ZDIM,))\n",
"\n",
"x = Dense(7*7*64)(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"x = Reshape((7,7,64))(x)\n",
"\n",
"x = Conv2DTranspose(128, (5,5), strides=(2,2), padding='same')(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"\n",
"x = Conv2DTranspose(1, (5,5), strides=(2,2), padding='same')(x)\n",
"x = Activation('sigmoid')(x)\n",
"x = Reshape((28,28))(x)\n",
"\n",
"gm = Model(in1, x)\n",
"gm.compile('adam', 'mse')\n",
"gm.output_names=['output']\n",
"gm.summary()\n",
"\n",
"opt = Adam()\n",
"\n",
"# GAN\n",
"dm.trainable = False\n",
"x = dm(gm.output)\n",
"tm = Model(gm.input, x)\n",
"tm.compile(opt, 'binary_crossentropy')\n",
"\n",
"dlosses, glosses = [], []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"import numpy as np\n",
"from matplotlib.pyplot import figure, imshow, show\n",
"\n",
"BS = 256\n",
"\n",
"# GAN training loop\n",
"# make larger if you want it to look better\n",
"for i in range(1):\n",
" # train discriminator\n",
" dm.trainable = True\n",
" real_i = x_train[np.random.choice(x_train.shape[0], BS)]\n",
" fake_i = gm.predict_on_batch(np.random.normal(0,1,size=(BS,ZDIM)))\n",
" dloss_r = dm.train_on_batch(real_i, np.ones(BS))\n",
" dloss_f = dm.train_on_batch(fake_i, np.zeros(BS))\n",
" dloss = (dloss_r + dloss_f)/2\n",
"\n",
" # train generator\n",
" dm.trainable = False\n",
" gloss_0 = tm.train_on_batch(np.random.normal(0,1,size=(BS,ZDIM)), np.ones(BS))\n",
" gloss_1 = tm.train_on_batch(np.random.normal(0,1,size=(BS,ZDIM)), np.ones(BS))\n",
" gloss = (gloss_0 + gloss_1)/2\n",
"\n",
" if i%50 == 0:\n",
" print(\"%4d: dloss:%8.4f gloss:%8.4f\" % (i, dloss, gloss))\n",
" dlosses.append(dloss)\n",
" glosses.append(gloss)\n",
" \n",
" if i%250 == 0:\n",
" \n",
" figure(figsize=(16,16))\n",
" imshow(np.concatenate(gm.predict(np.random.normal(size=(10,ZDIM))), axis=1))\n",
" show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from matplotlib.pyplot import plot, legend\n",
"figure(figsize=(8,8))\n",
"plot(dlosses[100:], label=\"Discriminator Loss\")\n",
"plot(glosses[100:], label=\"Generator Loss\")\n",
"legend()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = []\n",
"for i in range(10):\n",
" x.append(np.concatenate(gm.predict(np.random.normal(size=(10,ZDIM))), axis=1))\n",
"imshow(np.concatenate(x, axis=0))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os \n",
"\n",
"model_path = os.path.join('gan.onnx')\n",
"compiled_model_path = os.path.join('gan.compiled')\n",
"pk_path = os.path.join('gan.pk')\n",
"vk_path = os.path.join('gan.vk')\n",
"settings_path = os.path.join('gan_settings.json')\n",
"srs_path = os.path.join('gan_kzg.srs')\n",
"witness_path = os.path.join('gan_witness.json')\n",
"data_path = os.path.join('gan_input.json')\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we export the _generator_ to onnx"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"import numpy as np\n",
"import tf2onnx\n",
"import tensorflow as tf\n",
"import json\n",
"\n",
"shape = [1, ZDIM]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*np.random.rand(1,*shape)\n",
"\n",
"spec = tf.TensorSpec(shape, tf.float32, name='input_0')\n",
"\n",
"\n",
"tf2onnx.convert.from_keras(gm, input_signature=[spec], inputs_as_nchw=['input_0'], opset=12, output_path=model_path)\n",
"\n",
"data_array = x.reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"private\"\n",
"run_args.param_visibility = \"fixed\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (0.2 * np.random.rand(20, *shape)).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[0,6])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"witness_path = \"gan_witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# uncomment to mock prove\n",
"# res = ezkl.mock(witness_path, compiled_model_path)\n",
"# assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/mnist_gan_proof_splitting.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# Proof splitting\n",
"\n",
"Here we showcase how to split a larger circuit into multiple smaller proofs. This is useful if you want to prove over multiple machines, or if you want to split a proof into multiple parts to reduce the memory requirements.\n",
"\n",
"We showcase how to do this in the case where:\n",
"- intermediate calculations need to be kept secret (but not blinded !) and we need to use the low overhead kzg commitment scheme detailed [here](https://blog.ezkl.xyz/post/commits/) to stitch the circuits together.\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"First we import the necessary dependencies and set up logging to be as informative as possible. "
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"tf2onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import time\n",
"import random\n",
"import logging\n",
"\n",
"import tensorflow as tf\n",
"from tensorflow.keras.optimizers import Adam\n",
"from tensorflow.keras.layers import *\n",
"from tensorflow.keras.models import Model\n",
"from tensorflow.keras.datasets import mnist\n",
"\n",
"# uncomment for more descriptive logging \n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.INFO)\n",
"\n",
"# Can we build a simple GAN that can produce all 10 mnist digits?"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"\n",
"(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
"x_train, x_test = [x/255.0 for x in [x_train, x_test]]\n",
"y_train, y_test = [tf.keras.utils.to_categorical(x) for x in [y_train, y_test]]"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"functional_1\"</span>\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1mModel: \"functional_1\"\u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ input_layer (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Reshape</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">1,664</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">ELU</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">204,928</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_1 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">ELU</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">6272</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">802,944</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_2 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">ELU</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">129</span> │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
"</pre>\n"
],
"text/plain": [
"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m1,664\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n",
"│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu (\u001b[38;5;33mELU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m204,928\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n",
"│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_1 (\u001b[38;5;33mELU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6272\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m802,944\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n",
"│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_2 (\u001b[38;5;33mELU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m129\u001b[0m │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,010,945</span> (3.86 MB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m1,010,945\u001b[0m (3.86 MB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,010,305</span> (3.85 MB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m1,010,305\u001b[0m (3.85 MB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">640</span> (2.50 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m640\u001b[0m (2.50 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"functional_3\"</span>\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1mModel: \"functional_3\"\u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ input_layer_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3136</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">316,736</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_3 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3136</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">12,544</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">ELU</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3136</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Reshape</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_transpose │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">204,928</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_4 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">ELU</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_transpose_1 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">3,201</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ activation (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Reshape</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
"</pre>\n"
],
"text/plain": [
"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3136\u001b[0m) │ \u001b[38;5;34m316,736\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3136\u001b[0m) │ \u001b[38;5;34m12,544\u001b[0m │\n",
"│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_3 (\u001b[38;5;33mELU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3136\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape_1 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_transpose │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m204,928\u001b[0m │\n",
"│ (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n",
"│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_4 (\u001b[38;5;33mELU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_transpose_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m3,201\u001b[0m │\n",
"│ (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ activation (\u001b[38;5;33mActivation\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape_2 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">537,921</span> (2.05 MB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m537,921\u001b[0m (2.05 MB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">531,393</span> (2.03 MB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m531,393\u001b[0m (2.03 MB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">6,528</span> (25.50 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m6,528\u001b[0m (25.50 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"opt = Adam()\n",
"ZDIM = 100\n",
"\n",
"# discriminator\n",
"# 0 if it's fake, 1 if it's real\n",
"x = in1 = Input((28,28))\n",
"x = Reshape((28,28,1))(x)\n",
"\n",
"x = Conv2D(64, (5,5), padding='same', strides=(2,2))(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"\n",
"x = Conv2D(128, (5,5), padding='same', strides=(2,2))(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"\n",
"x = Flatten()(x)\n",
"x = Dense(128)(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"x = Dense(1, activation='sigmoid')(x)\n",
"dm = Model(in1, x)\n",
"dm.compile(opt, 'binary_crossentropy')\n",
"dm.summary()\n",
"\n",
"# generator, output digits\n",
"x = in1 = Input((ZDIM,))\n",
"\n",
"x = Dense(7*7*64)(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"x = Reshape((7,7,64))(x)\n",
"\n",
"x = Conv2DTranspose(128, (5,5), strides=(2,2), padding='same')(x)\n",
"x = BatchNormalization()(x)\n",
"x = ELU()(x)\n",
"\n",
"x = Conv2DTranspose(1, (5,5), strides=(2,2), padding='same')(x)\n",
"x = Activation('sigmoid')(x)\n",
"x = Reshape((28,28))(x)\n",
"\n",
"gm = Model(in1, x)\n",
"gm.compile('adam', 'mse')\n",
"gm.summary()\n",
"\n",
"opt = Adam()\n",
"\n",
"# GAN\n",
"dm.trainable = False\n",
"x = dm(gm.output)\n",
"tm = Model(gm.input, x)\n",
"tm.compile(opt, 'binary_crossentropy')\n",
"\n",
"dlosses, glosses = [], []"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0: dloss: 0.8063 gloss: 0.6461\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 42ms/step\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1600x1600 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import numpy as np\n",
"from matplotlib.pyplot import figure, imshow, show\n",
"\n",
"BS = 256\n",
"\n",
"# GAN training loop\n",
"# make larger if you want it to look better\n",
"for i in range(1):\n",
" # train discriminator\n",
" dm.trainable = True\n",
" real_i = x_train[np.random.choice(x_train.shape[0], BS)]\n",
" fake_i = gm.predict_on_batch(np.random.normal(0,1,size=(BS,ZDIM)))\n",
" dloss_r = dm.train_on_batch(real_i, np.ones(BS))\n",
" dloss_f = dm.train_on_batch(fake_i, np.zeros(BS))\n",
" dloss = (dloss_r + dloss_f)/2\n",
"\n",
" # train generator\n",
" dm.trainable = False\n",
" gloss_0 = tm.train_on_batch(np.random.normal(0,1,size=(BS,ZDIM)), np.ones(BS))\n",
" gloss_1 = tm.train_on_batch(np.random.normal(0,1,size=(BS,ZDIM)), np.ones(BS))\n",
" gloss = (gloss_0 + gloss_1)/2\n",
"\n",
" if i%50 == 0:\n",
" print(\"%4d: dloss:%8.4f gloss:%8.4f\" % (i, dloss, gloss))\n",
" dlosses.append(dloss)\n",
" glosses.append(gloss)\n",
" \n",
" if i%250 == 0:\n",
" \n",
" figure(figsize=(16,16))\n",
" imshow(np.concatenate(gm.predict(np.random.normal(size=(10,ZDIM))), axis=1))\n",
" show()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<matplotlib.legend.Legend at 0x34f625160>"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 800x800 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from matplotlib.pyplot import plot, legend\n",
"figure(figsize=(8,8))\n",
"plot(dlosses[100:], label=\"Discriminator Loss\")\n",
"plot(glosses[100:], label=\"Generator Loss\")\n",
"legend()"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 32ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 47ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n",
"\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n"
]
},
{
"data": {
"text/plain": [
"<matplotlib.image.AxesImage at 0x34f32bd70>"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = []\n",
"for i in range(10):\n",
" x.append(np.concatenate(gm.predict(np.random.normal(size=(10,ZDIM))), axis=1))\n",
"imshow(np.concatenate(x, axis=0))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we export the _generator_ to onnx"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1mModel: \"sequential\"\u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3136</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">316,736</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_3 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3136</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">12,544</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">ELU</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3136</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
"</pre>\n"
],
"text/plain": [
"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3136\u001b[0m) │ \u001b[38;5;34m316,736\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3136\u001b[0m) │ \u001b[38;5;34m12,544\u001b[0m │\n",
"│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_3 (\u001b[38;5;33mELU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3136\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">329,280</span> (1.26 MB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m329,280\u001b[0m (1.26 MB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">323,008</span> (1.23 MB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m323,008\u001b[0m (1.23 MB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">6,272</span> (24.50 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m6,272\u001b[0m (24.50 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_1\"</span>\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1mModel: \"sequential_1\"\u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ reshape_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Reshape</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">7</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_transpose │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">204,928</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_4 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">ELU</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
"</pre>\n"
],
"text/plain": [
"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ reshape_1 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ conv2d_transpose │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m204,928\u001b[0m │\n",
"│ (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ batch_normalization_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n",
"│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ elu_4 (\u001b[38;5;33mELU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">205,440</span> (802.50 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m205,440\u001b[0m (802.50 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">205,184</span> (801.50 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m205,184\u001b[0m (801.50 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">256</span> (1.00 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m256\u001b[0m (1.00 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_2\"</span>\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1mModel: \"sequential_2\"\u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ conv2d_transpose_1 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">3,201</span> │\n",
"│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ activation (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Reshape</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
"</pre>\n"
],
"text/plain": [
"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ conv2d_transpose_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m3,201\u001b[0m │\n",
"│ (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ │ │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ activation (\u001b[38;5;33mActivation\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
"│ reshape_2 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">3,201</span> (12.50 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m3,201\u001b[0m (12.50 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">3,201</span> (12.50 KB)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m3,201\u001b[0m (12.50 KB)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
"</pre>\n"
],
"text/plain": [
"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"transpose_input for input_0: shape must be rank 4, ignored\n"
]
}
],
"source": [
"\n",
"import numpy as np\n",
"import tf2onnx\n",
"import tensorflow as tf\n",
"import json\n",
"\n",
"# split the model into 3 parts\n",
"gm2 = tf.keras.models.Sequential(gm.layers[0:4])\n",
"# display gm2 \n",
"gm2.summary()\n",
"gm2.output_names=['output']\n",
"\n",
"gm3 = tf.keras.models.Sequential(gm.layers[4:8])\n",
"# display gm3\n",
"gm3.summary() \n",
"gm3.output_names=['output']\n",
"\n",
"gm4 = tf.keras.models.Sequential(gm.layers[8:])\n",
"# display gm4\n",
"gm4.summary()\n",
"gm4.output_names=['output'] \n",
"\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*np.random.rand(1,*[1, ZDIM])\n",
"inter_x1 = gm2(x[0])\n",
"inter_x2 = gm3(inter_x1)\n",
"\n",
"output_path = \"network_split_0.onnx\"\n",
"spec = tf.TensorSpec([1, ZDIM], tf.float32, name='input_0')\n",
"tf2onnx.convert.from_keras(gm2, input_signature=[spec], inputs_as_nchw=['input_0'], opset=12, output_path=output_path)\n",
"output_path = \"network_split_1.onnx\"\n",
"spec = tf.TensorSpec(inter_x1.shape, tf.float32, name='elu1')\n",
"tf2onnx.convert.from_keras(gm3, input_signature=[spec], inputs_as_nchw=['input_1'], opset=12, output_path=output_path)\n",
"output_path = \"network_split_2.onnx\"\n",
"spec = tf.TensorSpec(inter_x2.shape, tf.float32, name='elu2')\n",
"tf2onnx.convert.from_keras(gm4, input_signature=[spec], inputs_as_nchw=['input_2'], opset=12, output_path=output_path)\n",
"\n",
"data_array = x.reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"inter_x1 = inter_x1.numpy().reshape([-1]).tolist()\n",
"inter_x2 = inter_x2.numpy().reshape([-1]).tolist()\n",
"data_2 = dict(input_data = [inter_x1])\n",
"data_3 = dict(input_data = [inter_x2])\n",
"\n",
" # Serialize data into file:\n",
"data_path = os.path.join('gan_input_0.json')\n",
"json.dump( data, open(data_path, 'w' ))\n",
"data_path = os.path.join('gan_input_1.json')\n",
"json.dump( data_2, open(data_path, 'w' ))\n",
"data_path = os.path.join('gan_input_2.json')\n",
"json.dump( data_3, open(data_path, 'w' ))\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### KZG commitment intermediate calculations\n",
"\n",
"the visibility parameters are:\n",
"- `input_visibility`: \"polycommit\"\n",
"- `param_visibility`: \"public\"\n",
"- `output_visibility`: polycommit"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ezkl\n",
"\n",
"srs_path = os.path.join('kzg.srs')\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"polycommit\"\n",
"run_args.param_visibility = \"fixed\"\n",
"run_args.output_visibility = \"polycommit\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"run_args.input_scale = 0\n",
"run_args.param_scale = 0\n",
"run_args.logrows = 18\n",
"\n",
"ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Circuit compilation"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n",
"\n",
" <------------- Numerical Fidelity Report (input_scale: 0, param_scale: 0, scale_input_multiplier: 10) ------------->\n",
"\n",
"+----------------+--------------+-------------+--------------+----------------+------------------+---------------+-----------------+--------------------+--------------------+------------------------+\n",
"| mean_error | median_error | max_error | min_error | mean_abs_error | median_abs_error | max_abs_error | min_abs_error | mean_squared_error | mean_percent_error | mean_abs_percent_error |\n",
"+----------------+--------------+-------------+--------------+----------------+------------------+---------------+-----------------+--------------------+--------------------+------------------------+\n",
"| -0.00045216593 | 0.0071961936 | 0.059581105 | -0.051913798 | 0.011681631 | 0.0071961936 | 0.059581105 | 0.0000062934123 | 0.0002161761 | 1 | 1 |\n",
"+----------------+--------------+-------------+--------------+----------------+------------------+---------------+-----------------+--------------------+--------------------+------------------------+\n",
"\n",
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Setting up split model 0\n",
"Setting up split model 1\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n",
"\n",
" <------------- Numerical Fidelity Report (input_scale: 0, param_scale: 0, scale_input_multiplier: 10) ------------->\n",
"\n",
"+----------------+--------------+-------------+--------------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
"| mean_error | median_error | max_error | min_error | mean_abs_error | median_abs_error | max_abs_error | min_abs_error | mean_squared_error | mean_percent_error | mean_abs_percent_error |\n",
"+----------------+--------------+-------------+--------------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
"| -0.00008474619 | -0.002256453 | 0.003519658 | -0.003081262 | 0.0018818051 | 0.002256453 | 0.003519658 | 0.00017167516 | 0.000003900568 | 1 | 1 |\n",
"+----------------+--------------+-------------+--------------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
"\n",
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Setting up split model 2\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n",
"\n",
" <------------- Numerical Fidelity Report (input_scale: 0, param_scale: 0, scale_input_multiplier: 10) ------------->\n",
"\n",
"+-------------+--------------+-------------+-------------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
"| mean_error | median_error | max_error | min_error | mean_abs_error | median_abs_error | max_abs_error | min_abs_error | mean_squared_error | mean_percent_error | mean_abs_percent_error |\n",
"+-------------+--------------+-------------+-------------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
"| -0.49951223 | -0.49951398 | -0.49951398 | -0.49951398 | 0.49951223 | 0.49951398 | 0.49951398 | 0.49951398 | 0.24951272 | -0.9980509 | 0.9980509 |\n",
"+-------------+--------------+-------------+-------------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
"\n",
"\n"
]
}
],
"source": [
"# iterate over each submodel gen-settings, compile circuit and setup zkSNARK\n",
"\n",
"def setup(i):\n",
" print(\"Setting up split model \"+str(i))\n",
" # file names\n",
" model_path = os.path.join('network_split_'+str(i)+'.onnx')\n",
" settings_path = os.path.join('settings_split_'+str(i)+'.json')\n",
" data_path = os.path.join('gan_input_'+str(i)+'.json')\n",
" compiled_model_path = os.path.join('network_split_'+str(i)+'.compiled')\n",
" pk_path = os.path.join('test_split_'+str(i)+'.pk')\n",
" vk_path = os.path.join('test_split_'+str(i)+'.vk')\n",
" witness_path = os.path.join('witness_split_'+str(i)+'.json')\n",
"\n",
" if i > 0:\n",
" prev_witness_path = os.path.join('witness_split_'+str(i-1)+'.json')\n",
" witness = json.load(open(prev_witness_path, 'r'))\n",
" data = dict(input_data = witness['outputs'])\n",
" # Serialize data into file:\n",
" json.dump(data, open(data_path, 'w' ))\n",
" else:\n",
" data_path = os.path.join('gan_input_0.json')\n",
"\n",
" # generate settings for the current model\n",
" res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
" res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
" assert res == True\n",
"\n",
" # load settings and print them to the console\n",
" settings = json.load(open(settings_path, 'r'))\n",
" settings['run_args']['logrows'] = run_args.logrows\n",
" json.dump(settings, open(settings_path, 'w' ))\n",
"\n",
" res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"\n",
"\n",
" res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" )\n",
"\n",
" assert res == True\n",
" assert os.path.isfile(vk_path)\n",
" assert os.path.isfile(pk_path)\n",
" res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
" run_args.input_scale = settings[\"model_output_scales\"][0]\n",
"\n",
"for i in range(3):\n",
" setup(i)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Proof generation"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"print(\"Proving split models\")\n",
"\n",
"\n",
"def prove_model(i): \n",
" proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
" witness_path = os.path.join('witness_split_'+str(i)+'.json')\n",
" compiled_model_path = os.path.join('network_split_'+str(i)+'.compiled')\n",
" pk_path = os.path.join('test_split_'+str(i)+'.pk')\n",
" vk_path = os.path.join('test_split_'+str(i)+'.vk')\n",
" settings_path = os.path.join('settings_split_'+str(i)+'.json')\n",
"\n",
" res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \"for-aggr\",\n",
" )\n",
"\n",
" print(res)\n",
" assert os.path.isfile(proof_path)\n",
"\n",
" # Verify the proof\n",
" if i > 0:\n",
" # swap the proof commitments if we are not the first model\n",
" prev_witness_path = os.path.join('witness_split_'+str(i-1)+'.json')\n",
" prev_witness = json.load(open(prev_witness_path, 'r'))\n",
"\n",
" witness = json.load(open(witness_path, 'r'))\n",
"\n",
" print(prev_witness[\"processed_outputs\"])\n",
" print(witness[\"processed_inputs\"])\n",
"\n",
" witness[\"processed_inputs\"] = prev_witness[\"processed_outputs\"]\n",
"\n",
" # now save the witness\n",
" with open(witness_path, \"w\") as f:\n",
" json.dump(witness, f)\n",
"\n",
" res = ezkl.swap_proof_commitments(proof_path, witness_path)\n",
"\n",
" res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" )\n",
"\n",
" assert res == True\n",
" print(\"verified\")\n",
"\n",
"\n",
"for i in range(3):\n",
" print(\"----- proving split \"+str(i))\n",
" prove_model(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can also mock aggregate the split proofs into a single proof. This is useful if you want to verify the proof on chain at a lower cost. Here we mock aggregate the proofs to save time. You can use other notebooks to see how to aggregate in full ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# now mock aggregate the proofs\n",
"proofs = []\n",
"for i in range(3):\n",
" proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
" proofs.append(proof_path)\n",
"\n",
"ezkl.mock_aggregate(proofs, logrows=22, split_proofs = True)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "ezkl",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/mnist_vae.ipynb | {
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# what is the variational?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Credits to [geohot](https://github.com/geohot/ai-notebooks/blob/master/mnist_gan.ipynb) for most of this code"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"tf2onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"import os\n",
"import time\n",
"import random\n",
"\n",
"import tensorflow as tf\n",
"import tensorflow.keras.backend as K\n",
"from tensorflow.keras.optimizers import Adam\n",
"from tensorflow.keras.layers import *\n",
"from tensorflow.keras.models import Model\n",
"from tensorflow.keras.losses import mse\n",
"from tensorflow.keras.datasets import mnist\n",
"(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
"x_train, x_test = [x/255.0 for x in [x_train, x_test]]\n",
"y_train, y_test = [tf.keras.utils.to_categorical(x) for x in [y_train, y_test]]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ZDIM = 4\n",
"\n",
"def get_encoder():\n",
" x = in1 = Input((28,28))\n",
" x = Reshape((28,28,1))(x)\n",
"\n",
" x = Conv2D(64, (5,5), padding='same', strides=(2,2))(x)\n",
" x = BatchNormalization()(x)\n",
" x = ELU()(x)\n",
"\n",
" x = Conv2D(128, (5,5), padding='same', strides=(2,2))(x)\n",
" x = BatchNormalization()(x)\n",
" x = ELU()(x)\n",
"\n",
" x = Flatten()(x)\n",
" x = Dense(ZDIM)(x)\n",
" return Model(in1, x)\n",
"\n",
"def get_decoder():\n",
" x = in1 = Input((ZDIM,))\n",
"\n",
" x = Dense(7*7*64)(x)\n",
" x = BatchNormalization()(x)\n",
" x = ELU()(x)\n",
" x = Reshape((7,7,64))(x)\n",
"\n",
" x = Conv2DTranspose(128, (5,5), strides=(2,2), padding='same')(x)\n",
" x = BatchNormalization()(x)\n",
" x = ELU()(x)\n",
"\n",
" x = Conv2DTranspose(1, (5,5), strides=(2,2), padding='same')(x)\n",
" x = Activation('sigmoid')(x)\n",
" x = Reshape((28,28))(x)\n",
" return Model(in1, x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Regular Autoencoder"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# normal autoencoder without the variational\n",
"enc = get_encoder()\n",
"dec = get_decoder()\n",
"ae = Model(enc.input, dec(enc.output))\n",
"ae.compile('adam', 'mse')\n",
"ae.summary()\n",
"# make the epochs larger for better results\n",
"ae.fit(x_train, x_train, batch_size=128, epochs=1, shuffle=1, validation_data=(x_test, x_test))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# while the autoencoder might work without the variational, the sampling doesn't\n",
"import numpy as np\n",
"from matplotlib.pyplot import figure, imshow\n",
"imshow(np.concatenate(ae.predict(np.array([random.choice(x_test) for i in range(10)])), axis=1))\n",
"figure(figsize=(16,16))\n",
"imshow(np.concatenate(ae.layers[-1].predict(np.random.normal(size=(10, ZDIM))), axis=1))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os \n",
"\n",
"model_path = os.path.join('ae.onnx')\n",
"compiled_model_path = os.path.join('ae.compiled')\n",
"pk_path = os.path.join('ae.pk')\n",
"vk_path = os.path.join('ae.vk')\n",
"settings_path = os.path.join('ae_settings.json')\n",
"srs_path = os.path.join('ae_kzg.srs')\n",
"witness_path = os.path.join('ae_witness.json')\n",
"data_path = os.path.join('ae_input.json')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we export the decoder (which presumably is what we want) -- to onnx"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"import numpy as np\n",
"import tf2onnx\n",
"import tensorflow as tf\n",
"import json\n",
"\n",
"shape = [1, ZDIM]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*np.random.rand(1,*shape)\n",
"\n",
"spec = tf.TensorSpec(shape, tf.float32, name='input_0')\n",
"\n",
"\n",
"tf2onnx.convert.from_keras(dec, input_signature=[spec], inputs_as_nchw=['input_0'], opset=12, output_path=model_path)\n",
"\n",
"data_array = x.reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"!RUST_LOG=trace\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (0.1 * np.random.rand(20, *shape)).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file\n",
"witness_path = \"ae_witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.mock(witness_path, compiled_model_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('ae.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Variational Autoencoder"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"in1 = Input((28,28))\n",
"x = get_encoder()(in1)\n",
"\n",
"# add the variational\n",
"z_mu = Dense(ZDIM)(x)\n",
"z_log_var = Dense(ZDIM)(x)\n",
"z = Lambda(lambda x: x[0] + K.exp(0.5 * x[1]) * K.random_normal(shape=K.shape(x[0])))([z_mu, z_log_var])\n",
"dec = get_decoder()\n",
"dec.output_names=['output']\n",
"\n",
"out = dec(z)\n",
"\n",
"mse_loss = mse(Reshape((28*28,))(in1), Reshape((28*28,))(out)) * 28 * 28\n",
"kl_loss = 1 + z_log_var - K.square(z_mu) - K.exp(z_log_var)\n",
"kl_loss = -0.5 * K.mean(kl_loss, axis=-1)\n",
"\n",
"vae = Model(in1, out)\n",
"vae.add_loss(K.mean(mse_loss + kl_loss))\n",
"vae.compile('adam')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# z is sampled from z_mu and z_log_var with gaussian noise\n",
"test = Model(in1, [z, z_mu, z_log_var])\n",
"test.predict(x_train[0:1])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"vae.fit(x_train, batch_size=128, epochs=1, shuffle=1, validation_data=(x_test, None))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"imshow(np.concatenate(vae.predict(np.array([random.choice(x_test) for i in range(10)])), axis=1))\n",
"figure(figsize=(16,16))\n",
"imshow(np.concatenate(vae.layers[5].predict(np.random.normal(size=(10, ZDIM))), axis=1))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os \n",
"\n",
"model_path = os.path.join('vae.onnx')\n",
"compiled_model_path = os.path.join('vae.compiled')\n",
"pk_path = os.path.join('vae.pk')\n",
"vk_path = os.path.join('vae.vk')\n",
"settings_path = os.path.join('vae_settings.json')\n",
"srs_path = os.path.join('vae_kzg.srs')\n",
"witness_path = os.path.join('vae_witness.json')\n",
"data_path = os.path.join('vae_input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"import numpy as np\n",
"import tf2onnx\n",
"import tensorflow as tf\n",
"import json\n",
"\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*np.random.rand(1,*[1, ZDIM])\n",
"\n",
"spec = tf.TensorSpec([1, ZDIM], tf.float32, name='input_0')\n",
"\n",
"\n",
"tf2onnx.convert.from_keras(dec, input_signature=[spec], inputs_as_nchw=['input_0'], opset=12, output_path=model_path)\n",
"\n",
"data_array = x.reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"!RUST_LOG=trace\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"witness_path = \"vae_witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# uncomment to mock prove\n",
"# res = ezkl.mock(witness_path, compiled_model_path)\n",
"# assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/nbeats_timeseries_forecasting.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "TB8jFLoLwZ8K"
},
"source": [
"# N-BEATS Time Series Forecasting\n",
"In this tutorial we utilize the N-BEATS (Neural basis expansion analysis for interpretable time series forecasting\n",
") for forecasting the price of ethereum.\n",
"\n",
"For more details regarding N-BEATS, visit this link [https://arxiv.org/abs/1905.10437](https://arxiv.org/abs/1905.10437)\n",
"\n",
"The code for N-BEATS used is adapted from [nbeats-pytorch](https://pypi.org/project/nbeats-pytorch/)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "Ccy0MgZLwY1Z"
},
"outputs": [],
"source": [
"import pandas as pd\n",
"import torch\n",
"from torch import nn, optim\n",
"from torch.nn import functional as F\n",
"from torch.nn.functional import mse_loss, l1_loss, binary_cross_entropy, cross_entropy\n",
"from torch.optim import Optimizer\n",
"import matplotlib.pyplot as plt\n",
"import requests\n",
"import json\n",
"from torch.utils.data import DataLoader, TensorDataset\n",
"import numpy as np\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ovxRhGv0xS0i"
},
"outputs": [],
"source": [
"# Fetch data\n",
"coins = [\"ETH\"]\n",
"days_ago_to_fetch = 2000 # 7 years\n",
"coin_history = {}\n",
"hist_length = 0\n",
"average_returns = {}\n",
"cumulative_returns = {}\n",
"\n",
"def index_history_coin(hist):\n",
" hist = hist.set_index('time')\n",
" hist.index = pd.to_datetime(hist.index, unit='s')\n",
" return hist\n",
"\n",
"def filter_history_by_date(hist):\n",
" result = hist[hist.index.year >= 2017]\n",
" return result\n",
"\n",
"def fetch_history_coin(coin):\n",
" endpoint_url = \"https://min-api.cryptocompare.com/data/histoday?fsym={}&tsym=USD&limit={:d}\".format(coin, days_ago_to_fetch)\n",
" res = requests.get(endpoint_url)\n",
" hist = pd.DataFrame(json.loads(res.content)['Data'])\n",
" hist = index_history_coin(hist)\n",
" hist = filter_history_by_date(hist)\n",
" return hist\n",
"\n",
"def get_history_from_file(filename):\n",
" return pd.read_csv(filename)\n",
"\n",
"\n",
"for coin in coins:\n",
" coin_history[coin] = fetch_history_coin(coin)\n",
"\n",
"hist_length = len(coin_history[coins[0]])\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "CNeFMmvpx5ig"
},
"outputs": [],
"source": [
"# save to file\n",
"# coin_history['ETH'].to_csv(\"eth_price.csv\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "_wPJcU8EyOsF"
},
"outputs": [],
"source": [
"# read from file\n",
"coin_history['ETH'] = get_history_from_file(\"eth_price.csv\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ij_DBZl7yQqE",
"outputId": "3b7838de-fa00-4560-cbcb-62c11e311a0f"
},
"outputs": [],
"source": [
"# calculate returns\n",
"\n",
"def add_all_returns():\n",
" for coin in coins:\n",
" hist = coin_history[coin]\n",
" hist['return'] = (hist['close'] - hist['open']) / hist['open']\n",
" average = hist[\"return\"].mean()\n",
" average_returns[coin] = average\n",
" cumulative_returns[coin] = (hist[\"return\"] + 1).prod() - 1\n",
" hist['excess_return'] = hist['return'] - average\n",
" coin_history[coin] = hist\n",
"\n",
"add_all_returns()\n",
"\n",
"# display data\n",
"cumulative_returns"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "nW3xWLCNyeGN",
"outputId": "a5d7f42b-447b-4ec4-8b42-4bd845ba3b3b"
},
"outputs": [],
"source": [
"# average return per day\n",
"average_returns"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "J9AOW3czykk-",
"outputId": "23d9564c-ae0e-4bb4-cf3e-bdb46e9e1639"
},
"outputs": [],
"source": [
"# Excess matrix\n",
"excess_matrix = np.zeros((hist_length, len(coins)))\n",
"\n",
"for i in range(0, hist_length):\n",
" for idx, coin in enumerate(coins):\n",
" excess_matrix[i][idx] = coin_history[coin].iloc[i]['excess_return']\n",
"\n",
"excess_matrix"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 424
},
"id": "A3GuFe_-yq_Q",
"outputId": "3313aa46-88ef-4dbb-e07d-6cc6c9584eb9"
},
"outputs": [],
"source": [
"# pretty print excess matrix\n",
"pretty_matrix = pd.DataFrame(excess_matrix).copy()\n",
"pretty_matrix.columns = coins\n",
"pretty_matrix.index = coin_history[coins[0]].index\n",
"\n",
"pretty_matrix"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "rRYQ63frys8K",
"outputId": "d4df3245-f4e6-4511-dd8a-7c7e52cb4982"
},
"outputs": [],
"source": [
"# Risk modelling\n",
"\n",
"# variance co-var matrix\n",
"product_matrix = np.matmul(excess_matrix.transpose(), excess_matrix)\n",
"var_covar_matrix = product_matrix / hist_length\n",
"\n",
"var_covar_matrix"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 81
},
"id": "F_0y258Iz2-1",
"outputId": "f161c55d-5600-41da-f065-821c87340f33"
},
"outputs": [],
"source": [
"# pretty var_covar\n",
"pretty_var_covar = pd.DataFrame(var_covar_matrix).copy()\n",
"pretty_var_covar.columns = coins\n",
"pretty_var_covar.index = coins\n",
"\n",
"pretty_var_covar"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "_HS7sq_Xz4Js"
},
"outputs": [],
"source": [
"# Std dev\n",
"\n",
"std_dev = np.zeros((len(coins), 1))\n",
"neg_std_dev = np.zeros((len(coins), 1))\n",
"\n",
"for idx, coin in enumerate(coins):\n",
" std_dev[idx][0] = np.std(coin_history[coin]['return'])\n",
" coin_history[coin]['downside_return'] = 0\n",
"\n",
" coin_history[coin].loc[coin_history[coin]['return'] < 0,\n",
" 'downside_return'] = coin_history[coin]['return']**2\n",
" neg_std_dev[idx][0] = np.sqrt(coin_history[coin]['downside_return'].mean())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 81
},
"id": "gLpf-k1az77u",
"outputId": "d6dc063f-05b7-4a9f-de59-cc60b0cfee5e"
},
"outputs": [],
"source": [
"# pretty std\n",
"pretty_std = pd.DataFrame(std_dev).copy()\n",
"pretty_neg_std = pd.DataFrame(neg_std_dev).copy()\n",
"pretty_comb = pd.concat([pretty_std, pretty_neg_std], axis=1)\n",
"\n",
"pretty_comb.columns = ['std dev', 'neg std dev']\n",
"pretty_comb.index = coins\n",
"\n",
"pretty_comb"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "MAd19PQcz9A5"
},
"outputs": [],
"source": [
"# std_product_mat\n",
"std_product_matrix = np.matmul(std_dev, std_dev.transpose())\n",
"\n",
"# neg_prod_mat\n",
"neg_std_product_matrix = np.matmul(neg_std_dev, neg_std_dev.transpose())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 81
},
"id": "O8aD5ZiYz-8E",
"outputId": "945391f5-8e3b-4369-cc0c-1cf927f72ef2"
},
"outputs": [],
"source": [
"pretty_std_prod = pd.DataFrame(std_product_matrix).copy()\n",
"pretty_std_prod.columns = coins\n",
"pretty_std_prod.index = coins\n",
"\n",
"pretty_std_prod"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 81
},
"id": "KecwUguO0Ago",
"outputId": "f77f4bd2-3314-4d7e-8525-078825a83a8c"
},
"outputs": [],
"source": [
"# Corr matrix\n",
"corr_matrix = var_covar_matrix / std_product_matrix\n",
"pretty_corr = pd.DataFrame(corr_matrix).copy()\n",
"pretty_corr.columns = coins\n",
"pretty_corr.index = coins\n",
"\n",
"pretty_corr"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 424
},
"id": "m62kaZFu0C0p",
"outputId": "b3c10014-afe1-4cdb-e5a3-3a1361b54501"
},
"outputs": [],
"source": [
"# see additional stuff we have added to the DF\n",
"coin_history['ETH']"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "JdtkDBc90rM6",
"outputId": "19d1c7af-809e-4b1b-a1a0-b50bba67d425"
},
"outputs": [],
"source": [
"def simulate_portfolio_growth(initial_amount, daily_returns):\n",
" portfolio_value = [initial_amount]\n",
" for ret in daily_returns:\n",
" portfolio_value.append(portfolio_value[-1] * (1 + ret))\n",
" return portfolio_value\n",
"\n",
"initial_investment = 100000\n",
"\n",
"eth_portfolio = simulate_portfolio_growth(initial_investment, coin_history[\"ETH\"]['return'])\n",
"\n",
"print(\"ETH Portfolio Growth:\", eth_portfolio)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 564
},
"id": "ADBacxHA27v0",
"outputId": "3f5f8f35-4efc-473d-a5af-12515fa897b6"
},
"outputs": [],
"source": [
"# Plotting the growth\n",
"plt.figure(figsize=(10,6))\n",
"plt.plot(eth_portfolio, label='ETH Portfolio', color='blue')\n",
"plt.title('Portfolio Growth Over Time')\n",
"plt.xlabel('Days')\n",
"plt.ylabel('Portfolio Value')\n",
"plt.legend()\n",
"plt.grid(True)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "fWAx5OZ-302J",
"outputId": "a94346ac-4c16-428d-eac1-d8fbbd9208b4"
},
"outputs": [],
"source": [
"# close dataframe\n",
"eth_df = coin_history['ETH'][['close']].copy()\n",
"\n",
"# Convert to tensor\n",
"close_tensor = torch.tensor(eth_df.values)\n",
"\n",
"# return dataframe\n",
"eth_df = coin_history['ETH'][['return']].copy()\n",
"\n",
"# Convert to tensor\n",
"return_tensor = torch.tensor(eth_df.values)\n",
"\n",
"# return_tensor = torch.tensor(eth_df.values)\n",
"print(close_tensor)\n",
"print(return_tensor)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "4M6hIqZ15aqs"
},
"outputs": [],
"source": [
"# Adapted from https://pypi.org/project/nbeats-pytorch/\n",
"# author = {Philippe Remy},\n",
"\n",
"def squeeze_last_dim(tensor):\n",
" if len(tensor.shape) == 3 and tensor.shape[-1] == 1: # (128, 10, 1) => (128, 10).\n",
" return tensor[..., 0]\n",
" return tensor\n",
"\n",
"\n",
"def seasonality_model(thetas, t, device):\n",
" p = thetas.size()[-1]\n",
" assert p <= thetas.shape[1], 'thetas_dim is too big.'\n",
" p1, p2 = (p // 2, p // 2) if p % 2 == 0 else (p // 2, p // 2 + 1)\n",
" s1 = torch.tensor(np.array([np.cos(2 * np.pi * i * t) for i in range(p1)])).float() # H/2-1\n",
" s2 = torch.tensor(np.array([np.sin(2 * np.pi * i * t) for i in range(p2)])).float()\n",
" S = torch.cat([s1, s2])\n",
" return thetas.mm(S.to(device))\n",
"\n",
"\n",
"def trend_model(thetas, t, device):\n",
" p = thetas.size()[-1]\n",
" assert p <= 4, 'thetas_dim is too big.'\n",
" T = torch.tensor(np.array([t ** i for i in range(p)])).float()\n",
" return thetas.mm(T.to(device))\n",
"\n",
"\n",
"def linear_space(backcast_length, forecast_length, is_forecast=True):\n",
" horizon = forecast_length if is_forecast else backcast_length\n",
" return np.arange(0, horizon) / horizon\n",
"\n",
"class Block(nn.Module):\n",
"\n",
" def __init__(self, units, thetas_dim, device, backcast_length=10, forecast_length=5, share_thetas=False,\n",
" nb_harmonics=None):\n",
" super(Block, self).__init__()\n",
" self.units = units\n",
" self.thetas_dim = thetas_dim\n",
" self.backcast_length = backcast_length\n",
" self.forecast_length = forecast_length\n",
" self.share_thetas = share_thetas\n",
" self.fc1 = nn.Linear(backcast_length, units)\n",
" self.fc2 = nn.Linear(units, units)\n",
" self.fc3 = nn.Linear(units, units)\n",
" self.fc4 = nn.Linear(units, units)\n",
" self.device = device\n",
" self.backcast_linspace = linear_space(backcast_length, forecast_length, is_forecast=False)\n",
" self.forecast_linspace = linear_space(backcast_length, forecast_length, is_forecast=True)\n",
" if share_thetas:\n",
" self.theta_f_fc = self.theta_b_fc = nn.Linear(units, thetas_dim, bias=False)\n",
" else:\n",
" self.theta_b_fc = nn.Linear(units, thetas_dim, bias=False)\n",
" self.theta_f_fc = nn.Linear(units, thetas_dim, bias=False)\n",
"\n",
" def forward(self, x):\n",
" x = squeeze_last_dim(x)\n",
" x = F.relu(self.fc1(x.to(self.device)))\n",
" x = F.relu(self.fc2(x))\n",
" x = F.relu(self.fc3(x))\n",
" x = F.relu(self.fc4(x))\n",
" return x\n",
"\n",
" def __str__(self):\n",
" block_type = type(self).__name__\n",
" return f'{block_type}(units={self.units}, thetas_dim={self.thetas_dim}, ' \\\n",
" f'backcast_length={self.backcast_length}, forecast_length={self.forecast_length}, ' \\\n",
" f'share_thetas={self.share_thetas}) at @{id(self)}'\n",
"\n",
"\n",
"class SeasonalityBlock(Block):\n",
"\n",
" def __init__(self, units, thetas_dim, device, backcast_length=10, forecast_length=5, nb_harmonics=None):\n",
" if nb_harmonics:\n",
" super(SeasonalityBlock, self).__init__(units, nb_harmonics, device, backcast_length,\n",
" forecast_length, share_thetas=True)\n",
" else:\n",
" super(SeasonalityBlock, self).__init__(units, forecast_length, device, backcast_length,\n",
" forecast_length, share_thetas=True)\n",
"\n",
" def forward(self, x):\n",
" x = super(SeasonalityBlock, self).forward(x)\n",
" backcast = seasonality_model(self.theta_b_fc(x), self.backcast_linspace, self.device)\n",
" forecast = seasonality_model(self.theta_f_fc(x), self.forecast_linspace, self.device)\n",
" return backcast, forecast\n",
"\n",
"\n",
"class TrendBlock(Block):\n",
"\n",
" def __init__(self, units, thetas_dim, device, backcast_length=10, forecast_length=5, nb_harmonics=None):\n",
" super(TrendBlock, self).__init__(units, thetas_dim, device, backcast_length,\n",
" forecast_length, share_thetas=True)\n",
"\n",
" def forward(self, x):\n",
" x = super(TrendBlock, self).forward(x)\n",
" backcast = trend_model(self.theta_b_fc(x), self.backcast_linspace, self.device)\n",
" forecast = trend_model(self.theta_f_fc(x), self.forecast_linspace, self.device)\n",
" return backcast, forecast\n",
"\n",
"\n",
"\n",
"class GenericBlock(Block):\n",
"\n",
" def __init__(self, units, thetas_dim, device, backcast_length=10, forecast_length=5, nb_harmonics=None):\n",
" super(GenericBlock, self).__init__(units, thetas_dim, device, backcast_length, forecast_length)\n",
"\n",
" self.backcast_fc = nn.Linear(thetas_dim, backcast_length)\n",
" self.forecast_fc = nn.Linear(thetas_dim, forecast_length)\n",
"\n",
" def forward(self, x):\n",
" # no constraint for generic arch.\n",
" x = super(GenericBlock, self).forward(x)\n",
"\n",
" theta_b = self.theta_b_fc(x)\n",
" theta_f = self.theta_f_fc(x)\n",
"\n",
" backcast = self.backcast_fc(theta_b) # generic. 3.3.\n",
" forecast = self.forecast_fc(theta_f) # generic. 3.3.\n",
"\n",
" return backcast, forecast\n",
"\n",
"\n",
"class NBEATS(nn.Module):\n",
" SEASONALITY_BLOCK = 'seasonality'\n",
" TREND_BLOCK = 'trend'\n",
" GENERIC_BLOCK = 'generic'\n",
"\n",
" def __init__(\n",
" self,\n",
" device=torch.device(\"cpu\"),\n",
" stack_types=(GENERIC_BLOCK, GENERIC_BLOCK),\n",
" nb_blocks_per_stack=1,\n",
" forecast_length=7,\n",
" backcast_length=14,\n",
" theta_dims=(2,2),\n",
" share_weights_in_stack=False,\n",
" hidden_layer_units=32,\n",
" nb_harmonics=None,\n",
" ):\n",
" super(NBEATS, self).__init__()\n",
" self.forecast_length = forecast_length\n",
" self.backcast_length = backcast_length\n",
" self.hidden_layer_units = hidden_layer_units\n",
" self.nb_blocks_per_stack = nb_blocks_per_stack\n",
" self.share_weights_in_stack = share_weights_in_stack\n",
" self.nb_harmonics = nb_harmonics # for seasonal data\n",
" self.stack_types = stack_types\n",
" self.stacks = nn.ModuleList()\n",
" self.thetas_dim = theta_dims\n",
" self.device = device\n",
" print('| N-Beats')\n",
" for stack_id in range(len(self.stack_types)):\n",
" stack = self.create_stack(stack_id)\n",
" self.stacks.append(stack)\n",
" self.to(self.device)\n",
" # self.asset_weight_layer = nn.Softmax(dim=1)\n",
" # self.asset_classes = asset_classes\n",
"\n",
"\n",
" def create_stack(self, stack_id):\n",
" stack_type = self.stack_types[stack_id]\n",
" print(f'| -- Stack {stack_type.title()} (#{stack_id}) (share_weights_in_stack={self.share_weights_in_stack})')\n",
" blocks = nn.ModuleList()\n",
" for block_id in range(self.nb_blocks_per_stack):\n",
" block_init = NBEATS.select_block(stack_type)\n",
" if self.share_weights_in_stack and block_id != 0:\n",
" block = blocks[-1] # pick up the last one when we share weights.\n",
" else:\n",
" block = block_init(\n",
" self.hidden_layer_units, self.thetas_dim[stack_id],\n",
" self.device, self.backcast_length, self.forecast_length,\n",
" self.nb_harmonics\n",
" )\n",
" print(f' | -- {block}')\n",
" blocks.append(block)\n",
" return blocks\n",
"\n",
" @staticmethod\n",
" def select_block(block_type):\n",
" if block_type == NBEATS.SEASONALITY_BLOCK:\n",
" return SeasonalityBlock\n",
" elif block_type == NBEATS.TREND_BLOCK:\n",
" return TrendBlock\n",
" else:\n",
" return GenericBlock\n",
"\n",
"\n",
" def get_generic_and_interpretable_outputs(self):\n",
" g_pred = sum([a['value'][0] for a in self._intermediary_outputs if 'generic' in a['layer'].lower()])\n",
" i_pred = sum([a['value'][0] for a in self._intermediary_outputs if 'generic' not in a['layer'].lower()])\n",
" outputs = {o['layer']: o['value'][0] for o in self._intermediary_outputs}\n",
" return g_pred, i_pred,\n",
"\n",
" def forward(self, backcast):\n",
" self._intermediary_outputs = []\n",
" backcast = squeeze_last_dim(backcast)\n",
" forecast = torch.zeros(size=(backcast.size()[0], self.forecast_length,)) # maybe batch size here.\n",
" for stack_id in range(len(self.stacks)):\n",
" for block_id in range(len(self.stacks[stack_id])):\n",
" b, f = self.stacks[stack_id][block_id](backcast)\n",
" backcast = backcast.to(self.device) - b\n",
" forecast = forecast.to(self.device) + f\n",
" block_type = self.stacks[stack_id][block_id].__class__.__name__\n",
" layer_name = f'stack_{stack_id}-{block_type}_{block_id}'\n",
"\n",
" return backcast, forecast\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "tTH313qbRLMG",
"outputId": "34275438-5548-4a8b-f4a9-d96056ebde1c"
},
"outputs": [],
"source": [
"from torch.utils.data import Dataset, DataLoader\n",
"\n",
"class TimeSeriesDataset(Dataset):\n",
" def __init__(self, close_data, return_data, backcast_length, forecast_length, shuffle=True):\n",
" self.close_data = close_data\n",
" self.return_data = return_data\n",
" self.backcast_length = backcast_length\n",
" self.forecast_length = forecast_length\n",
" self.indices = list(range(len(self.close_data) - self.backcast_length - self.forecast_length + 1))\n",
" if shuffle:\n",
" np.random.shuffle(self.indices)\n",
"\n",
" def __len__(self):\n",
" return len(self.close_data) - self.backcast_length - self.forecast_length + 1\n",
"\n",
" def __getitem__(self, idx):\n",
" start = idx\n",
" end = idx + self.backcast_length\n",
" x = self.close_data[start:end] # Take columns as needed\n",
" y = self.close_data[end:end+self.forecast_length] # Adjust as per forecast columns needed\n",
" return x, y\n",
"\n",
"# Hyperparameters\n",
"BACKCAST_LENGTH = 14\n",
"FORECAST_LENGTH = 7\n",
"\n",
"train_length = round(len(close_tensor) * 0.7)\n",
"train_dataset = TimeSeriesDataset(close_tensor[0:train_length], return_tensor[0:train_length], BACKCAST_LENGTH, FORECAST_LENGTH)\n",
"test_dataset = TimeSeriesDataset(close_tensor[train_length:], return_tensor[train_length:], BACKCAST_LENGTH, FORECAST_LENGTH)\n",
"train_loader = DataLoader(train_dataset)\n",
"\n",
"model = NBEATS(forecast_length=FORECAST_LENGTH, backcast_length=BACKCAST_LENGTH, device=('cuda' if torch.cuda.is_available() else 'cpu'))\n",
"model = model.to('cuda' if torch.cuda.is_available() else 'cpu')\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "JJ8-nh2GLKN_",
"outputId": "0d761daa-0f14-4a50-be41-b17993a4a182"
},
"outputs": [],
"source": [
"EPOCHS = 1\n",
"\n",
"num_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
"print(f\"Number of trainable parameters in model: {num_parameters}\")\n",
"\n",
"criterion = torch.nn.L1Loss()\n",
"optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
"\n",
"for epoch in range(EPOCHS):\n",
" total_loss = 0.0\n",
" for batch_idx, (x, y) in enumerate(train_loader):\n",
" # Zero gradients\n",
" optimizer.zero_grad()\n",
"\n",
" x = x.clone().detach().to(dtype=torch.float)\n",
" x = x.to('cuda' if torch.cuda.is_available() else 'cpu')\n",
" y = y.clone().detach().to(dtype=torch.float)\n",
" y = y.to('cuda' if torch.cuda.is_available() else 'cpu')\n",
"\n",
"\n",
" # Forward pass\n",
" forecast = model(x)\n",
"\n",
" loss = criterion(forecast[0], y)\n",
"\n",
" # Backprop and optimize\n",
" loss.backward()\n",
" optimizer.step()\n",
"\n",
" # add positive gain for logging\n",
" total_loss += loss # add the positive gain_loss for logging\n",
"\n",
" avg_loss = total_loss / len(train_loader)\n",
" print(f\"Epoch {epoch+1}/{EPOCHS}, Average Loss: {avg_loss:.4f}\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "jWLKwNFLYDOk"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"import ezkl\n",
"import os\n",
"import json"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "dhOHiCmt4pUn"
},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "xsZ9xg7I48l4",
"outputId": "6dec08c6-f55e-4df1-b957-55d025286018"
},
"outputs": [],
"source": [
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x_export = None\n",
"for batch_idx, (x, y) in enumerate(train_loader):\n",
" x_export = x.clone().detach().to(dtype=torch.float)\n",
" break\n",
"\n",
"# Flips the neural net into inference mode\n",
"model.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(model, # model being run\n",
" x_export, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "5qdEFK_75GUb"
},
"outputs": [],
"source": [
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"private\"\n",
"run_args.param_visibility = \"fixed\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", max_logrows = 20, scales = [3])\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "pxDJPz-Q5LPF"
},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ptcb4SGA5Qeb"
},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "OE7t0okU5WBQ"
},
"outputs": [],
"source": [
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"id": "12YIcFr85X9-"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"spawning module 2\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"quotient_poly_degree 4\n",
"n 262144\n",
"extended_k 20\n"
]
}
],
"source": [
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "CSbWeZB35awS"
},
"outputs": [],
"source": [
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "aGt8f4LS5dTP"
},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"accelerator": "GPU",
"colab": {
"gpuType": "T4",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/proof_splitting.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# Proof splitting\n",
"\n",
"Here we showcase how to split a larger circuit into multiple smaller proofs. This is useful if you want to prove over multiple machines, or if you want to split a proof into multiple parts to reduce the memory requirements.\n",
"\n",
"We showcase how to do this in the case where:\n",
"- intermediate calculations can be public (i.e. they do not need to be kept secret) and we can stitch the circuits together using instances\n",
"- intermediate calculations need to be kept secret (but not blinded !) and we need to use the low overhead kzg commitment scheme detailed [here](https://blog.ezkl.xyz/post/commits/) to stitch the circuits together. \n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"First we import the necessary dependencies and set up logging to be as informative as possible. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import logging\n",
"\n",
"# uncomment for more descriptive logging \n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.INFO)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we define our model. It is a humble model with but a conv layer and a $ReLU$ non-linearity, but it is a model nonetheless"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"# Defines the model\n",
"# we got convs, we got relu, \n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=3, out_channels=1, kernel_size=2, stride=4)\n",
" self.conv2 = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=2, stride=4)\n",
" self.relu = nn.ReLU()\n",
"\n",
" def forward(self, x):\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
" x = self.conv2(x)\n",
" x = self.relu(x)\n",
"\n",
" return x\n",
" \n",
" def split_1(self, x):\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
" return x\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# this is where you'd train your model\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
"Now we export the model to onnx and create a corresponding (randomly generated) input file.\n",
"\n",
"You can replace the random `x` with real data if you so wish. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = torch.rand(1,*[3, 8, 8], requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"\n",
"data_path = os.path.join(os.getcwd(), \"input_0.json\")\n",
"data = dict(input_data = [((x).detach().numpy()).reshape([-1]).tolist()])\n",
"json.dump( data, open(data_path, 'w' ))\n",
"\n",
"inter_1 = circuit.split_1(x)\n",
"data_path = os.path.join(os.getcwd(), \"input_1.json\")\n",
"data = dict(input_data = [((inter_1).detach().numpy()).reshape([-1]).tolist()])\n",
"json.dump( data, open(data_path, 'w' ))\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we split the model into two parts. The first part is the first conv layer and the second part is the rest of the model."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import onnx\n",
"\n",
"input_path = \"network.onnx\"\n",
"output_path = \"network_split_0.onnx\"\n",
"input_names = [\"input\"]\n",
"output_names = [\"/relu/Relu_output_0\"]\n",
"# first model\n",
"onnx.utils.extract_model(input_path, output_path, input_names, output_names)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import onnx\n",
"\n",
"input_path = \"network.onnx\"\n",
"output_path = \"network_split_1.onnx\"\n",
"input_names = [\"/relu/Relu_output_0\"]\n",
"output_names = [\"output\"]\n",
"# second model\n",
"onnx.utils.extract_model(input_path, output_path, input_names, output_names)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Public intermediate calculations"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"This is where the magic happens. We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
"- `input_visibility` defines the visibility of the model inputs\n",
"- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
"- `output_visibility` defines the visibility of the model outputs\n",
"\n",
"There are currently 5 visibility settings:\n",
"- `public`: known to both the verifier and prover (a subtle nuance is that this may not be the case for model parameters but until we have more rigorous theoretical results we don't want to make strong claims as to this). \n",
"- `private`: known only to the prover\n",
"- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
"- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
"- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes. \n",
"\n",
"Here we create the following setup:\n",
"- `input_visibility`: \"public\"\n",
"- `param_visibility`: \"public\"\n",
"- `output_visibility`: public\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"\n",
"data_path = os.path.join('input.json')\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"public\"\n",
"run_args.param_visibility = \"fixed\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.input_scale = 2\n",
"run_args.logrows = 8\n",
"\n",
"ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
"\n",
"You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. \n",
"\n",
"As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
"\n",
"These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. \n",
"\n",
"We also need to generate the (partial) circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# iterate over each submodel gen-settings, compile circuit and setup zkSNARK\n",
"\n",
"def setup(i):\n",
" # file names\n",
" model_path = os.path.join('network_split_'+str(i)+'.onnx')\n",
" settings_path = os.path.join('settings_split_'+str(i)+'.json')\n",
" data_path = os.path.join('input_'+str(i)+'.json')\n",
" compiled_model_path = os.path.join('network_split_'+str(i)+'.compiled')\n",
" pk_path = os.path.join('test_split_'+str(i)+'.pk')\n",
" vk_path = os.path.join('test_split_'+str(i)+'.vk')\n",
" witness_path = os.path.join('witness_split_'+str(i)+'.json')\n",
"\n",
" if i > 0:\n",
" prev_witness_path = os.path.join('witness_split_'+str(i-1)+'.json')\n",
" witness = json.load(open(prev_witness_path, 'r'))\n",
" data = dict(input_data = witness['outputs'])\n",
" # Serialize data into file:\n",
" json.dump(data, open(data_path, 'w' ))\n",
" else:\n",
" data_path = os.path.join('input_0.json')\n",
"\n",
" # generate settings for the current model\n",
" res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
" res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
" assert res == True\n",
"\n",
" # load settings and print them to the console\n",
" settings = json.load(open(settings_path, 'r'))\n",
" settings['run_args']['logrows'] = run_args.logrows\n",
" json.dump(settings, open(settings_path, 'w' ))\n",
"\n",
" res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"\n",
"\n",
" res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" )\n",
"\n",
" assert res == True\n",
" assert os.path.isfile(vk_path)\n",
" assert os.path.isfile(pk_path)\n",
"\n",
" res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
" run_args.input_scale = settings[\"model_output_scales\"][0]\n",
"\n",
"for i in range(2):\n",
" setup(i)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"def prove_model(i):\n",
" proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
" witness_path = os.path.join('witness_split_'+str(i)+'.json')\n",
" compiled_model_path = os.path.join('network_split_'+str(i)+'.compiled')\n",
" pk_path = os.path.join('test_split_'+str(i)+'.pk')\n",
" vk_path = os.path.join('test_split_'+str(i)+'.vk')\n",
" settings_path = os.path.join('settings_split_'+str(i)+'.json')\n",
"\n",
" res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \"for-aggr\",\n",
" )\n",
"\n",
" print(res)\n",
" res_1_proof = res[\"proof\"]\n",
" assert os.path.isfile(proof_path)\n",
"\n",
" # # Verify the proof\n",
" if i > 0:\n",
" print(\"swapping commitments\")\n",
" # swap the proof commitments if we are not the first model\n",
" prev_witness_path = os.path.join('witness_split_'+str(i-1)+'.json')\n",
" prev_witness = json.load(open(prev_witness_path, 'r'))\n",
"\n",
" witness = json.load(open(witness_path, 'r'))\n",
"\n",
" print(prev_witness[\"processed_outputs\"])\n",
" print(witness[\"processed_inputs\"])\n",
" witness[\"processed_inputs\"] = prev_witness[\"processed_outputs\"]\n",
"\n",
" # now save the witness\n",
" with open(witness_path, \"w\") as f:\n",
" json.dump(witness, f)\n",
"\n",
" res = ezkl.swap_proof_commitments(proof_path, witness_path)\n",
" print(res)\n",
" \n",
" # load proof and then print \n",
" proof = json.load(open(proof_path, 'r'))\n",
" res_2_proof = proof[\"hex_proof\"]\n",
" # show diff in hex strings\n",
" print(res_1_proof)\n",
" print(res_2_proof)\n",
" assert res_1_proof == res_2_proof\n",
"\n",
" res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" )\n",
"\n",
" assert res == True\n",
" print(\"verified\")\n",
"\n",
"for i in range(2):\n",
" prove_model(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### KZG commitment intermediate calculations\n",
"\n",
"This time the visibility parameters are:\n",
"- `input_visibility`: \"polycommit\"\n",
"- `param_visibility`: \"public\"\n",
"- `output_visibility`: polycommit"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"polycommit\"\n",
"run_args.param_visibility = \"fixed\"\n",
"run_args.output_visibility = \"polycommit\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"run_args.input_scale = 2\n",
"run_args.logrows = 8\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for i in range(2):\n",
" setup(i)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for i in range(2):\n",
" prove_model(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can also mock aggregate the split proofs into a single proof. This is useful if you want to verify the proof on chain at a lower cost. Here we mock aggregate the proofs to save time. You can use other notebooks to see how to aggregate in full ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# now mock aggregate the proofs\n",
"proofs = []\n",
"for i in range(2):\n",
" proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
" proofs.append(proof_path)\n",
"\n",
"ezkl.mock_aggregate(proofs, logrows=22, split_proofs = True)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "ezkl",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/random_forest.ipynb | {
"cells": [
{
"attachments": {
"image-2.png": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAokAAARDCAYAAAAEdLvJAAABYmlDQ1BJQ0MgUHJvZmlsZQAAKJF1kDFLw1AUhU9stSAVHRwEHQKKUy01rdi1LSKCQxoVqlvyWlMlTR9JRNTFQRengi5uUhd/gS4OjoKDguAgIoKDP0DsoiXeNGpbxft43I/DvYfDBTrCKudGEEDJdCxlOi3mFpfE0Au60ENPQEBlNk/J8iyN4Lu3V+2O5qhuxzyvq5px+bw3PJi1N6Nscmv173xbdecLNqP+QT/BuOUAQoxYXne4x9vE/RaFIj7wWPf5xGPN5/PGzLySIb4h7mNFNU/8RBzRWnS9hUvGGvvK4KUPF8yFOeoD9IeQRgEmshAxhRzimEAM41D+2Uk0djIog2MDFlagowiHtlOkcBjkJmKGHBmiiBBL5Cch7t369w2bWrkKJN+AQKWpaYfA2S7FvG9qI0dA7w5wes1VS/25rFAL2stxyedwGuh8dN3XUSC0D9Qrrvtedd36Mfk/ABfmJ+uTZFvl1hD0AAAAVmVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAADkoYABwAAABIAAABEoAIABAAAAAEAAAKJoAMABAAAAAEAAARDAAAAAEFTQ0lJAAAAU2NyZWVuc2hvdIWiHYkAAAHXaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA2LjAuMCI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjEwOTE8L2V4aWY6UGl4ZWxZRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpQaXhlbFhEaW1lbnNpb24+NjQ5PC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6VXNlckNvbW1lbnQ+U2NyZWVuc2hvdDwvZXhpZjpVc2VyQ29tbWVudD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CvSCr3YAAEAASURBVHgB7N0HnJxVvf/x3yabZNOzm03vvYeQgksCgtwAERCu8kfEgqKgIIkXEBWuoOhFAa/8QSkq/lVQrBcvoFIEpBMCCSQB0sum97LZJJtNNtn88z34rJOdLdPnKZ/zeg0z+8xTznmfUX6cWlBWVnbUSAgggAACCCCAAAIIxAi0iPnMRwQQQAABBBBAAAEEnABBIj8EBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggABBIr8BBBBAAAEEEEAAgTgBgsQ4Eg4ggAACCCCAAAIIECTyG0AAAQQQQAABBBCIEyBIjCPhAAIIIIAAAggggEAhBAgggAAC/hI4ePCgVVdXW21trbVs2TLnmTty5Ih7buvWra2oqCjnz+eBCCDgDwGCRH/UA7lAAAEErKamxnbv3u0kWrRokZcA0auGQ4cOuUB1z549VlxcbAoYSQggEC0BgsRo1TelRQABnwqo9VABmYKxLl26+CaXFRUVplfnzp2tTZs2vskXGUEAgewLMCYx+8Y8AQEEEGhWYO/evVZYWOirAFGZVsDaqlUrq6ysbLYMnIAAAuESIEgMV31SGgQQCKDA4cOHTS2JJSUlvsy9upvVFa4XCQEEoiNAkBiduqakCCDgUwEFiWqt83NS/pRPEgIIREeAIDE6dU1JEUDAxwIFBQU+zp2Z3/Pnazwyh0BABQgSA1pxZBsBBKIjMH78eDdeMTolpqQIIOAHAYJEP9QCeUAAAQSaEPjwhz+clQktah288MILm3gyXyGAQJQFCBKjXPuUHQEEAiFwxx132I4dOzKeVwWJZ599dsbvyw0RQCAcAi379u17SziKQikQQACBYApoQogWr27fvn2DBbj55pvtrbfeso4dO9qsWbNs+PDh9qlPfcqGDh1qixcvdrOO9feAAQPc8fPOO8/tlLJs2TJ3v9tvv92ee+4597m0tNS+/OUv2+zZs+3rX/+69erVyyZMmGArV65scpmbqqoqt4aj3yfYNAjIQQQQSEmAlsSU2LgIAQQQyJ1Ap06d3MQRbdE3atQoe/bZZ+0b3/iG27Zv8uTJLiMKME844QS79dZb7T//8z9t0qRJNnbsWPdd7OLc2slF91P67//+b7f0zi233GIbNmxwx/gHAggg4AkQJHoSvCOAAAIBENiyZYsL6LSv87vvvmtDhgypy/XLL7/sWhXVKvnqq6/ayJEj677jAwIIIJCsAEFismKcjwACCORRIHatQn2OXZrmyJEjdTnTZ+3gonT06FFTC6KS9+7+4B8IIIBAEwIEiU3g8BUCCCAQJIGysjKXXQWOJ510khtnqAO7d++2wYMHu+80ntFLCh6V2JPZE+EdAQRiBd7/z8zYI3xGAAEEEAikwM6dO+273/2um7SiCS3z5s1z5fjb3/5mX/3qV23z5s22du3aurIpSHzhhRfcOMYf//jHtn79+rrv+IAAAggUHPsvz/f/UxILBBBAAIG8CFRXV9vevXutW7duKT//i1/8ogsKFyxYYJrgUn+fZR3TS+MV6yd1QWuMY1NJS/Bockzbtm2bOo3vEEAgRAK0JIaoMikKAggEV8Dr+k21BAcPHnR7KyvYayjg0xjF2DGLsc9p6PzY7/U53fzVvx9/I4CA/wUIEv1fR+QQAQRCLqAJJvVb/pIt8kMPPZTsJUmdr/x5E2GSupCTEUAgsAJMXAls1ZFxBBAIi4CCL00e2bVrly+LpIkvWkSbhbR9WT1kCoGsCRAkZo2WGyOAAAKJC2g3FS1pU1FRkfhFOThT+VErovJHQgCBaAnQ3Ryt+qa0CCDgUwG1JBYXF7vlarZt2+bWM/Qmm+Q6y974RW8Mo/LVunXrXGeD5yGAQJ4FaEnMcwXweAQQQMATUHdu9+7d3bZ56XbteusievdO9l3P79y5s/Xo0YMAMVk8zkcgJAK0JIakIikGAgiER6CoqMitdZhOiRQkaoxjIjOX03kO1yKAQHgFaEkMb91SMgQQiLBAp06dWLYmwvVP0RHIhABBYiYUuQcCCCCAAAIIIBAyAYLEkFUoxUEAAQQkoMW1tYczCQEEEEhVgCAxVTmuQwABBHwsoNnS7JLi4woiawgEQIAgMQCVRBYRQAABBBBAAIFcCxAk5lqc5yGAAAIIIIAAAgEQIEgMQCWRRQQQQAABBBBAINcCBIm5Fud5CCCAAAIIIIBAAAQIEgNQSWQRAQQQQAABBBDItQBBYq7FeR4CCCCQA4EDBw6wBE4OnHkEAmEWIEgMc+1SNgQQiKxA27ZtWQInsrVPwRHIjABBYmYcuQsCCCCAAAIIIBAqAYLEUFUnhUEAAQQQQAABBDIjQJCYGUfuggACCCCAAAIIhEqAIDFU1UlhEEAAAQQQQACBzAgQJGbGkbsggAACCCCAAAKhEiBIDFV1UhgEEEAAAQQQQCAzAgSJmXHkLggggAACCCCAQKgECBJDVZ0UBgEEEHhfoLa2lsW0+TEggEBaAgSJafFxMQIIIOBPgRYtWrCYtj+rhlwhEBgBgsTAVBUZRQABBBBAAAEEcidAkJg7a56EAAIIIIAAAggERoAgMTBVRUYRQAABBBBAAIHcCRAk5s6aJyGAAAIIIIAAAoERIEgMTFWRUQQQQAABBBBAIHcCBIm5s+ZJCCCAgC8EevfubUVFRRnNS5cuXay4uDiteypP/fv3T+sejV1cUFBgrVq1auxrjiOAQAMCBIkNoHAIAQQQCLPAiSeeaB07dky4iH369LGhQ4c2ef6AAQNs0KBBTZ7T3JetW7e2Dh06NHda0t8rQJw+fbpddtllSZU76QdxAQIhEygMWXkoDgIIIIBAAgKDBw+2c88912pqauyZZ56x7du3W7t27WzGjBmmVsGKigp74oknXNCmY1p3sUePHvbaa6+59zPOOMPatm1ry5Ytc8f0SF13ySWXuPs899xztnbt2kZz0r59ezv77LPdubt27bK///3vrqWvV69etnjxYps8ebINHz7cXa/g8a233rJ3333XxowZY5MmTbLDhw/bCy+8YJs3b7bS0lJTILtw4UJ3/qmnnmpz5sxxZdOBU045xdavX2+dO3d23/MPBBBITIAgMTEnzkIAAQRCJaCA7qGHHjIFZWpl+/3vf++CrQULFtjq1atNgZaCNAVmCrg6depkr7/+ujNQ0PjXv/7VBZLnnHOO9ezZ0x3v2rWr/eEPf3AB27Rp05oMEseNG2crVqxw99dn3V+BqNcNPm/ePNNLXcQf/ehH3bnKs8793e9+54LLCy64wH7zm9+YgswPfvCDtmfPHuvevbvbaUbBr5ICQ+XvlVdesbFjx7pj/AMBBBITIEhMzImzEEAAgVAJqLXu6NGjtmnTJheItWzZ0tatW+cCKgVi6j5WN239pGBu3759LjDTd3/729/cKWplXLNmjbvnxo0bXRBX/9rYv3fu3GllZWXufAWL1dXV1q1bt9hT3GcFf3PnznXfDxkyxLVsqjVRSS2IapHcv3+/Pfnkk3bVVVe5QPFXv/qV+17/mDp1al1LZ91BPiCAQEICjElMiImTEEAAgXAJaG9nL+mzWvHUxXvyySeb/lbr3JEjR7xT6t51Xuy1dV8c++Cdr+BTr6aSAsOnn37adVF/+tOfdgFf/fO9MY7l5eXuq8LCQquqqrKDBw+6l7rJ1e2spBbDAwcOuLypG1xJ4y779evnXh/4wAdca6XGY6r7moQAAs0LECQ2b8QZCCCAQOgENCZRSV24CvzUPdu3b1+bPXu2LVq0qC7g0jkKxNq0aaOProtZ12j8opKCyoZaAN2XTfxDz9czX331Vfc8tUTGJgV6U6ZMsZdffrnusMYfqsVx6dKl7qWuaN1Dk13UZf7b3/7WNBZSYy3VMqrv1EWuwFIvBbcKJJsLYOseyAcEIi5Ad3PEfwAUHwEEoimg1rSLL77YTT55/vnnHcJ7771nGmNYWVnpgjEFZEqa9KGWOHXdKoh88cUX7cILL3TBo87dsWOHaVmdZNKhQ4fs/PPPd93DCvY0FjJ2ZrNaNfW3xh0qaWykJsls2bLFPvnJT7rAdtWqVS7wUwvms88+a3v37nUvjaFUIKj86zovjRw50gWXCh5JCCDQvEDBsTEhTfcJNH8PzkAAAQQQ8JmAWtb+8Y9/NNlqpu5br7vWy75aFTUW0es69o7rXcdjW+Eauj72fI1fbGiyiAI9TY5R8loDY69r7nNTeWzuWr5HAIHEBWhJTNyKMxFAAIFQCdQPEFW4xsYb6rvYAFF/N3S9jntJrYWaxFI/qcXPS6m06jWVR+++vCOAQPoCBInpG3IHBBBAAIEGBNTd29RaiQ1cwiEEEPCRABNXfFQZZAUBBBBAAAEEEPCLAEGiX2qCfCCAAAIIIIAAAj4SIEj0UWWQFQQQQAABBBBAwC8CBIl+qQnygQACCGRQQJM7GtoxJYOP4FYIIBByAYLEkFcwxUMAgWgKaJmY+rORoylBqRFAIFUBgsRU5bgOAQQQQAABBBAIsQBBYogrl6IhgAACCCCAAAKpChAkpirHdQgggAACCCCAQIgFCBJDXLkUDQEEEEAAAQQQSFWAIDFVOa5DAAEEEEAAAQRCLECQGOLKpWgIIIAAAggggECqAgSJqcpxHQIIIIAAAgggEGIBgsQQVy5FQwCB6AocOHCAxbSjW/2UHIGMCBAkZoSRmyCAAAL+Emjbti2LafurSsgNAoETIEgMXJWRYQQQQAABBBBAIPsCBInZN+YJCCCAAAIIIIBA4AQIEgNXZWQYAQQQQAABBBDIvgBBYvaNeQICCCCAAAIIIBA4AYLEwFUZGUYAAQQQQAABBLIvQJCYfWOegAACCORMYMiQIe5ZBw8edEvgeH/nLAM8CAEEQiNAkBiaqqQgCCCAwPsCkydPtjZt2tjEiRMhQQABBFIWIEhMmY4LEUAAAf8JrFq1yoqLi10rot71NwkBBBBIRYAgMRU1rkEAAQR8LLB69WqXu/Lych/nkqwhgIDfBQr9nkHyhwACCARJoKqqyg4fPpzXLM+fP9/27NljXrCYz8wUFhZau3bt8pkFno0AAikKECSmCMdlCCCAQKyAgsOKPRXWolWhtWzTylq2zu//va7cvM5q2xTEZjHnn2sPHbaqqoPOpUvnLgSLOa8BHohAegL5/X+x9PLO1QgggIAvBBQg7q3ab+26d7Gi4o6+yJOfMlFdsc/27trnskSrop9qhrwg0LQAYxKb9uFbBBBAoFmBPZV7rE1xBwLERqSKunSwNiUdraKiopEzOIwAAn4UIEj0Y62QJwQQCIzAgQMHrKBly2MBYofA5DkfGS3q0t5aHOuCV6srCQEEgiFAkBiMeiKXCCDgU4Gamho3BtGn2fNVtloWtTJ5kRBAIBgCBInBqCdyiQACPhbQZBVS8wItW7Vq/iTOQAAB3wgQJPqmKsgIAgiEWaCwZaEVH5vhm2rq37uvde1SnOrlXIcAAggkLcB//iZNxgUIIIBA4gIKDmd+9gobNWS4VVUfsHZFbe3eX//c3l22uMmb9OzW3UYeu+bFOa+686ZPO91WrFllr8x9vcnr+BIBBBDIlABBYqYkuQ8CCCDQgMBnL7zEjcP78reutyNHjtjQAYPt5lnX28xbvm57972/LEwDl1m3klL7wITJdUFiQ+dwDAEEEMimQMu+ffveks0HcG8EEEAgzAIHDx602pYF1rpDUVwxWx3bbeTqz1xu373nB1bzz11Ydu3ZbRs2b3K7slTu22uTxk2w66+YaedPn2Ejhgyz+YvesdLirvaVz33J+vbqbZPGTrAX5rxiJ44Zbx3bd7CPn/vvdvF5H7Pa2tpjLYvvb783YfQ4+4/PXWnnnXGWu9Zrpfzc//mkjRo6wq74xKV24Fgr5tqN6+PymMsDNccW1m5x+KgVFcVb5TIfPAsBBBITYExiYk6chQACCCQtoHGEG7dutoOHDrlrCwoKrEWLFvb2ooXuuA4O7jfQvnffnTbrlm+4wK/sxMm2dcc2+8WffmNLV62wb931/brn9unRy27+v9+3//zhf9knL/g/1rpVa+vcsZNddiwY/MEDP7brvneTde9aah88aaq7pn3bdtajtJtdd+s37aU3Xqu7Dx8QQACBRATobk5EiXMQQACBFATatGlTFyDq8s989GLXctihXXt76sXn7JGnHre/Pf93GzNspHWbUGoTx5xgG7ZsavRJb77zth09etR27t5lG7dsttKSEuvdvZf16t7Tyk6c4q7rcKy1Ua2OL7852/39+ttvum7uRm/KFwgggEAjAgSJjcBwGAEEEEhXYNPWLdavVx9reWyxbY1H/PX//sG9Lr/4UttdWWHqjr7969+y2W/PtXWbNriJKceiwEYfe/ifXdY6wfuse+w+tmf07mPd2EovvP6Kbd+1033WP44cqa37zAcEEEAgGQG6m5PR4lwEEEAgCYGKY9v1qcv44+f8e91V6jKeOHa8vbt08bGWwFIrKGhhf/zb/9qc+XNdd7MXI1YfOmidjrUKNpdWrl1t1Qer7Z2li47dY57pmW1at27uMr5HAAEEmhWgJbFZIk5AAAEEUhf4+R8esi9/+gt2zy132L79+63LsbUSf/U/v7VtO7cfCxALbM2GdfZ/b/qe7a/abzuOdSN7adXacjtce8R+cMN37Ou3f9s7HPeuVsNHn3nCvvfVm44Fi8cm0Ryb0HLnL+6LO48DCCCAQLICBWVlZY33bSR7N85HAAEEIiZQWVlpNa0KrH2PphfKbntsRq/GC+44FtRpXGFsKvrn2MX6x3VOy2MTXY4cC/wSSXrGgerqRE7NyzlV2/dYy+oj1rlz57w8n4cigEByArQkJufF2QgggEBKAgreGgvg1ALYWEo0QNT1jd2/sXtzHAEEEGhKgDGJTenwHQIIIIAAAgggEFEBgsSIVjzFRgABBBBAAAEEmhIgSGxKh+8QQAABBBBAAIGICjAmMaIVT7ERQCBzAjVV1Va1vSJzNwzpnWr2Vx9bM5LleUJavRQrhAIEiSGsVIqEAAK5Fag9WGOHjxw/Yzm3OQjG02qPLShu7QgSg1Fb5BIBM4JEfgUIIIBAmgLaUaU1C1g3q3jon3tYN3siJyCAgC8EGJPoi2ogEwgggAACCCCAgL8ECBL9VR/kBgEEEEAAAQQQ8IUAQaIvqoFMIIAAAggggAAC/hIgSPRXfZAbBBBAIKcCJ510UqPP69ixo40cObLR7/kCAQTCLUCQGO76pXQIIJBHgaFDh9rMmTMTzsGAAQPsYx/7mDv/jDPOsPPPPz/ha1M5sX379lZSUuIuVV7Hjh1b9+rSpYvt3bvXxowZk8qtuQYBBEIgwOzmEFQiRUAAAX8KbNiwwZ544omEM9e5c2cbPny4O3/BggXWqlWrhK9N5cRJkybZ22+/7S49cmx5msOHD7vPkydPtqqqKquoqLD169db//79bd26dak8gmsQQCDAAgSJAa48so4AAv4WGDhwoE2fPt3uvfdeO+uss6xr166mLtyioiL729/+ZqtXr7bi4mK76KKL3HH97SUFcO3atbPHH3/c1MJ47rnnmoLIJUuW2F//+lerra21c845x7X8KZh77LHHbOvWraYA74Mf/KC1aNHC5s6day+99JJ3y+Pe9X23bt3s5ZdfdsfLy8vdu/KmLmgvLwsXLrSzzz6bIPE4Pf5AIBoCdDdHo54pJQII5EFALYEKCpUUfPXs2dMeffRR10L3gQ98wB3/t3/7NysoKLCHH37Y1P3rJZ2vIFFJXdArVqywn/zkJy7Q7Nu3r40fP95GjBhh99xzjwscL7jgAnfu6aefbnPmzLFf/OIXdvDgQXdv90W9fwwaNMjWrFlT76jZ1KlT3fXeF7qHAspst2p6z+MdAQT8I0CQ6J+6ICcIIBBygc2bN9v27dtt7dq11qlTJ1fa0tJSW758uWsFXLx4cZyAFunW+ECdoxZDBX+6vkePHq5l8bOf/ayddtppLnjUxbNnz3YtiV/4whesQ4cOcffzDqgrXMFmbGrbtq3rWtazvKQAUYuF19TUeId4RwCBiAjQ3RyRiqaYCCCQf4GjR+O37lPgp+5kBWhq3auftEvJvn37rF+/frZx40Y777zzXDfyrl27bOfOnfbAAw+4ILJXr16uxU+TTdTi2KdPH7v44ovduXv27Kl/W9fKqFZCtXTqGiW1IirIjE2jR492LZWxx/iMAALREKAlMRr1TCkRQMCnAi+88IJrBfza177mAsWGsqkxiNOmTbMbb7zRtR5u27bNNLFlx44ddv3119sXv/hF152tcYoKJq+66io3XvGdd96xhgJE7xnz5s2zKVOmuD/Vta0JKrGtiPpCS+AsXbrUu4R3BBCIkEBBWVlZ/H/aRgiAoiKAAALpCFRWVtqBAwesTZs26dzGdelqhnFTSV3P9fc/1lhBXacA0UvqHlY3cSJdxDNmzLCnn37au/S4d3WJa1mc+q2Lx52UxB/Ku5w0AYeEAAL+FyBI9H8dkUMEEPCxgIJELRejiSakpgWqq6tdaylBYtNOfIuAXwTobvZLTZAPBBAIpIBa8hoaaxjIwmQ503JilnSWkbk9AhkUIEjMICa3QgCB6AlowomCn0S6dqOn868Sa6FudYl7y/r86xs+IYCAXwUIEv1aM+QLAQQCI6AlajQukECx4SqTi4JELRxOQgCB4AiwBE5w6oqcIoCATwW81jEtZ6NgSItja+JI1JNaDtXKqncFiJ5T1F0oPwJBESBIDEpNkU8EEPC1gAIgvTSJxdsDOZ8ZHjx4cN3WevnMR2FhIcFhPiuAZyOQhgBBYhp4XIoAAgjUF/BLa5mCRC24Hbs0Tv288jcCCCDQlAD9IU3p8B0CCCAQUAGtccis64BWHtlGwCcCBIk+qQiygQACCCCAAAII+EmAINFPtUFeEEAAgQwJaBKNJtCQEEAAgVQFCBJTleM6BBBAwMcCWpaH7mYfVxBZQyAAAgSJAagksogAAggggAACCORagCAx1+I8DwEEEEAAAQQQCIAAQWIAKoksIoAAAggggAACuRYgSMy1OM9DAAEEEEAAAQQCIECQGIBKIosIIIAAAggggECuBQgScy3O8xBAAAEEEEAAgQAIECQGoJLIIgIIIIAAAgggkGsBgsRci/M8BBBAAAEEEEAgAAIEiQGoJLKIAAIIIIAAAgjkWoAgMdfiPA8BBBDIosCQIUPc3b1t+by/s/hIbo0AAiEVIEgMacVSLAQQiK7A5MmTTdvyTZw4MboIlBwBBNIWIEhMm5AbIIAAAv4RWLVqlRUXF1tBQYF7198kBBBAIBUBgsRU1LgGAQQQ8LHA6tWrXe7Ky8t9nEuyhgACfhco9HsGyR8CCCAQRYGDBw/avn37rLa21tq0aZMUwfz5823Pnj3mBYvJXKzntmzZ0tq1a2dFRUXJXMq5CCAQMgGCxJBVKMVBAIHgC+zYscMOHz7sCnL06NGUCrRkyZKUrtNzjxw5YocOHbLCwkIrLS1N6T5chAACwRcgSAx+HVICBBAIkYACRAVpasnLR4pttTxw4IBt377dunXrlo+s8EwEEMizAGMS81wBPB4BBBDwBPbu3Ws1NTXWtm1b71Be35UPtSwqXyQEEIieAEFi9OqcEiOAgE8F1HKn8YB+Supyrqqq8lOWyAsCCORIgCAxR9A8BgEEEGhOQK2Isd29zZ2fi++VH+WLhAAC0RMgSIxenVNiBBDwqUCqk1R8WhyyhQACARcgSAx4BZJ9BBCInkBJSYnvuqWjVwuUGIHwCzC7Ofx1TAkRQCAkAtOmTbNLL73UNHaxc+fO9uyzz9rvf/97S6UFslevXjZq1Ch7/vnnQ6JDMRBAINMCBImZFuV+CCCAQBYE+vXrZ5dffrndfPPNtmHDBrdEzre//W33+eWXX076iVrWZurUqQSJSctxAQLRESBIjE5dU1IEEAiwwGmnnWZPPPGECwpVDM04vu+++6x3796uVH369LGZM2e6/ZorKyvt7rvvtk2bNrlgctasWW6tQ+3n/MADD7jdWL70pS9Zly5d7LbbbrMbb7wxwDJkHQEEsiXQsm/fvrdk6+bcFwEEEEAgcQEFd5pNrGCufrrgggtszpw5tmXLlrqvtPWeWhWVJk6caG+88Yb98pe/dOMVTznlFHvzzTdt+vTp7u877rjDli1bZsOGDbMFCxa467p27WpqjWwuaau+Tp06NXca3yOAQMgEmLgSsgqlOAggEE4BrZ+onVgaS6+88or7asaMGTZhwgQbO3as+3vt2rVWVlZmF110kQsWn3766cZuwXEEEEDgOAGCxOM4+AMBBBDwp0B5ebkNGjTouMxp676ePXu6Y9dcc42dddZZblKLzt23b587vnjxYrvhhhtc9/RVV11lV1555XH34A8EEECgMQGCxMZkOI4AAgj4SOC1114zdTl7+yirZfHqq6+2KVOmuFyOGzfOHnroIXvppZdci6MXJKobunv37m4845133lnXwqgu5I4dO/qohGQFAQT8JsDEFb/VCPlBAAEEGhBYuXKlPfjgg3brrbe6iSfFxcU2b948e+qpp9zZjz76qN1+++22c+dOW7NmTd0d9Pe1117r9l9WUPjwww+771asWOGCybvuust9X3cBHxBAAIF/ChQcG6tyFA0EEEAAgfwLaBKKArmGJq7E5k6tiRUVFXHb5bVq1cqd1tA2euqabmgP5ubGOuqGmlBzbJJjbBb4jAACERCgJTEClUwREUAgGALNBYdeKbZv3+59PO69oeDQO6GhAFHfNTUZxruWdwQQiKYAYxKjWe+UGgEEfCiglkCNFfRTUn68Fko/5Yu8IIBA9gUIErNvzBMQQACBhATatm3ru5a9w4cPuwW5EyoAJyGAQKgECBJDVZ0UBgEEgiyg8YhqtdPezH5IyofywyxoP9QGeUAg9wKMScy9OU9EAAEEGhUoLS21HTt21E0yOXr0qBUW5u7/qtVy6I2N1HOVHxICCERTIHf/zxNNX0qNAAIIJC2gwExjAbXWYW1trduqL9mbDB482FavXp3sZe78Fi1aWIcOHVJ6bkoP5CIEEPClAEGiL6uFTCGAQNQFtIezXqkmBYm7du1yQWaq9+A6BBCItgBjEqNd/5QeAQRCKtCpUydTVzUJAQQQSFWAIDFVOa5DAAEEEEAAAQRCLECQGOLKpWgIIBBdAe3I4k1Aia4CJUcAgXQECBLT0eNaBBBAwKcCXbp0obvZp3VDthAIigBBYlBqinwigAACCCCAAAI5FCBIzCE2j0IAAQQQQAABBIIiQJAYlJoinwgggAACCCCAQA4FCBJziM2jEEAAAQQQQACBoAgQJAalpsgnAggggAACCCCQQwGCxBxi8ygEEEAAAQQQQCAoAgSJQakp8okAAggggAACCORQgCAxh9g8CgEEEEAAAQQQCIoAQWJQaop8IoAAAggggAACORQgSMwhNo9CAAEEsi0wZMgQ9whvWz7v72w/l/sjgED4BAgSw1enlAgBBCIuMHnyZNO2fBMnToy4BMVHAIF0BAgS09HjWgQQQMBnAqtWrbLi4mIrKChw7/qbhAACCKQiQJCYihrXIIAAAj4WWL16tctdeXm5j3NJ1hBAwO8ChX7PIPlDAAEEgiRQVVVlhw8fzmuW58+fb3v27DEvWMxnZgoLC61du3b5zALPRgCBFAUIElOE4zIEEEAgVkDBoTdZpEWLFqZXPtOSJUvy+Xj37NraWtNLLhojSbCY9yohAwgkJUCQmBQXJyOAAALxAgoQKysrrXXr1u4Vf0a0jxw6dMj5SIFAMdq/BUofLIH8/qdusKzILQIIINCggFrK1K2qIJEULyCXVq1a2e7du+O/5AgCCPhWgCDRt1VDxhBAIAgCBw4ccDOJCRCbri0FieqCV6srCQEEgiFAkBiMeiKXCCDgU4GamhoXJPo0e77KloJEeZEQQCAYAgSJwagncokAAj4WyPckFR/THJc1nI7j4A8EfC9AkOj7KiKDCCCAAAIIIIBA7gUIEnNvzhMRQCAiAmo5+8Mf/hCR0lJMBBAImwBBYthqlPIggAACCCCAAAIZEGCdxAwgcgsEEEAgWYGJEyfaJZdcYm3btrU333zTfv3rX7tb9O/f36688korKipyu6b86Ec/cotRT5s2zT72sY+5pXa0UPbPfvYzO3r0aLKP5XwEEEAgYQGCxISpOBEBBBDIjEDnzp3t8ssvt5tuusmtHXj99dfb6aefbi+++KJdfPHF9vjjj9sbb7xhJ598sg0YMMAFiVdccYXNnDnT9u3b54LF0tJS2759e2YyxF0QQACBBgQIEhtA4RACCCCQTYERI0ZY7969berUqe4xHTt2tEmTJrkgUfstf/zjH7fi4mKbN2+e7dixw51TXl5uV199tc2ePdueeuop0/qMJAQQQCCbAoxJzKYu90YAAQQaENDC0rt27ap7Pffcc/bkk0+6M//85z/b/fffb2ptvO222+zUU091x//rv/7LnnnmGRs5cqTde++91qdPnwbuzCEEEEAgcwK0JGbOkjshgAACCQksX77cqqurbcGCBW4HkvHjx1ubNm3ctTNmzLC5c+faH//4R9u5c6eNGTPGdT2fd955rht6/vz51qFDBxs0aJBt3LgxoedxEgIIIJCKAEFiKmpcgwACCCQooODv5z//ed3ZCxcudC2BjzzyiP3gBz9w3ca1tbXus07SmEO1Gmq8oSa1/PjHP7ZDhw65lsW77rrLTWZRgKmuaBICCCCQTYGCsrIypsdlU5h7I4BAqAUqKytdq6BmI6eSFAjWH19YUFDgZjfXP96yZUvTS0FjENPBgwdNe1yrK52EAAL+F6Al0f91RA4RQCDEAvUDQRVVS9s0dPzIkSOmFwkBBBDIhQATV3KhzDMQQAABBBBAAIGACRAkBqzCyC4CCCCAAAIIIJALAYLEXCjzDAQQQAABBBBAIGACjEkMWIWRXQQQ8J/A4cOH3eQVv+VME2D8lOSkiSskBBAIhgBBYjDqiVwigIDPBfy2j7ICRL/lyedVSPYQQKCeAEFiPRD+RAABBJIV0LI03mLYyV4bpfODunRPlOqIsiIQK8CYxFgNPiOAAAIIIIAAAgg4AYJEfggIIIAAAggggAACcQIEiXEkHEAAAQQQQAABBBAgSOQ3gAACCPhM4KSTTmo0Rx07drSRI0c2+j1fIIAAApkSYOJKpiS5DwIIINCIQM+ePW3w4ME2b968Zvddbt++vZWUlLg7DR061O3h7N12w4YNVlFRYWPGjLGlS5d6h3lHAAEEsiJAS2JWWLkpAggg8C+B8847z84++2wbPXr0vw428mnSpEn29ttvu2+1T7PWFtRrwoQJdcHj+vXrrX///o3cgcMIIIBAZgQIEjPjyF0QQACBBgW6dOliffr0sdmzZ9u4ceMaPMc72KJFC+vWrZtt27bNHSovL3cthmvWrDF9t3r1and84cKFLmj0ruMdAQQQyIYAQWI2VLknAggg8E8BBYbqJp4/f77rclZ3cmNp0KBBpoCwfpo6darNmTOn7vDBgwdd0NiqVau6Y3xAAAEEMi1AkJhpUe6HAAIIxAicfvrprmt44sSJLrBrqstZwWTfvn1jrjZr27atu3758uV1x9WqqAW8a2pq6o7xAQEEEMi0AEFipkW5HwIIIPBPAXUdFxYWujGGlZWV7uj48eMb9VELoV6awewltSKqqzo2KdBcsmRJ7CE+I4AAAhkXIEjMOCk3RAABBN4XUFfzrl277PHHH3eB3kMPPWT9+vWzzp07N0qkGdBTpkxx37dr1y6uFVFfaAkcZjc3SsgXCCCQIYGCsrKyoxm6F7dBAAEEIiegFsIDBw5kdO/mGTNm2NNPP92gZadOnWzs2LFxrYsNnuyzg9q7WXtcNxUk+yzLZAeBSAsQJEa6+ik8AgikK6Agsaqq6rj1DNO9Z1ivr66udmMsCRLDWsOUK2wCdDeHrUYpDwII5FRAM4yPHqVDJhF0OTEjOxEpzkHAHwIEif6oB3KBAAIBFdDsYwU/zDRuugK1IHhtba1pnCUJAQSCIUCQGIx6IpcIIOBjAS2Yrd1RCBQbriS5KEgsLi5u+ASOIoCALwXYu9mX1UKmEEAgSAJe65j2VVYwVFBQ4NZEDFIZspFXtRyqlVXvChA9p2w8i3sigEDmBQgSM2/KHRFAIIICCoD00iQWBYr5ToMHD67bxi+fedE6kQSH+awBno1A6gIEianbcSUCCCAQJ+CXgEhBotZoVCseCQEEEEhFgDGJqahxDQIIIOBzAa2nyKxrn1cS2UPA5wIEiT6vILKHAAIIIIAAAgjkQ4AgMR/qPBMBBBDIsoAm0WgCDQkBBBBIVYAgMVU5rkMAAQR8LKBleehu9nEFkTUEAiBAkBiASiKLCCCAAAIIIIBArgUIEnMtzvMQQAABBBBAAIEACBAkBqCSyCICCCCAAAIIIJBrAYLEXIvzPAQQQAABBBBAIAACBIkBqCSyiAACCCCAAAII5FqAIDHX4jwPAQQQQAABBBAIgABBYgAqiSwigAACCCCAAAK5FiBIzLU4z0MAAQQQQAABBAIgQJAYgEoiiwgggAACCCCAQK4FCBJzLc7zEEAAgSwKDBkyxN3d25bP+zuLj+TWCCAQUgGCxJBWLMVCAIHoCkyePNm0Ld/EiROji0DJEUAgbQGCxLQJuQECCCDgH4FVq1ZZcXGxFRQUuHf9TUIAAQRSESBITEWNaxBAAAEfC6xevdrlrry83Me5JGsIIOB3gUK/Z5D8IYAAAlEUOHjwoO3bt89qa2utTZs2SRHMnz/f9uzZY16wmMzFem7Lli2tXbt2VlRUlMylnIsAAiETIEgMWYVSHAQQCL7Ajh077PDhw64gR48eTalAS5YsSek6PffIkSN26NAhKywstNLS0pTuw0UIIBB8AYLE4NchJUAAgRAJKEBUkKaWvHyk2FbLAwcO2Pbt261bt275yArPRACBPAswJjHPFcDjEUAAAU9g7969VlNTY23btvUO5fVd+VDLovJFQgCB6AkQJEavzikxAgj4VEAtdxoP6KekLueqqio/ZYm8IIBAjgQIEnMEzWMQQACB5gTUihjb3dvc+bn4XvlRvkgIIBA9AYLE6NU5JUYAAZ8KpDpJxafFIVsIIBBwAYLEgFcg2UcAgegJlJSU+K5bOnq1QIkRCL8As5vDX8eUEAEEQiIwbdo0u/TSS01jFzt37mzPPvus/f73v7dUWiB79eplo0aNsueffz4kOhQDAQQyLUCQmGlR7ocAAghkQaBfv352+eWX280332wbNmxwS+R8+9vfdp9ffvnlpJ+oZW2mTp1KkJi0HBcgEB0BgsTo1DUlRQCBAAucdtpp9sQTT7igUMXQjOP77rvPevfu7UrVp08fmzlzptuvubKy0u6++27btGmTCyZnzZrl1jrUfs4PPPCA243lS1/6knXp0sVuu+02u/HGGwMsQ9YRQCBbAi379u17S7Zuzn0RQAABBBIXUHCn2cQK5uqnCy64wObMmWNbtmyp+0pb76lVUWnixIn2xhtv2C9/+Us3XvGUU06xN99806ZPn+7+vuOOO2zZsmU2bNgwW7Bggbuua9euptbI5pK26uvUqVNzp/E9AgiETICJKyGrUIqDAALhFND6idqJpbH0yiuvuK9mzJhhEyZMsLFjx7q/165da2VlZXbRRRe5YPHpp59u7BYcRwABBI4TIEg8joM/EEAAAX8KlJeX26BBg47LnLbu69mzpzt2zTXX2FlnneUmtejcffv2ueOLFy+2G264wXVPX3XVVXbllVcedw/+QAABBBoTIEhsTIbjCCCAgI8EXnvtNVOXs7ePsloWr776apsyZYrL5bhx4+yhhx6yl156ybU4ekGiuqG7d+/uxjPeeeeddS2M6kLu2LGjj0pIVhBAwG8CTFzxW42QHwQQQKABgZUrV9qDDz5ot956q5t4UlxcbPPmzbOnnnrKnf3oo4/a7bffbjt37rQ1a9bU3UF/X3vttW7/ZQWFDz/8sPtuxYoVLpi866673Pd1F/ABAQQQ+KdAwbGxKkfRQAABBBDIv4AmoSiQa2jiSmzu1JpYUVERt11eq1at3GkNbaOnrumG9mBubqyjbqgJNccmOcZmgc8IIBABAVoSI1DJFBEBBIIh0Fxw6JVi+/bt3sfj3hsKDr0TGgoQ9V1Tk2G8a3lHAIFoCjAmMZr1TqkRQMCHAmoJ1FhBPyXlx2uh9FO+yAsCCGRfgCAx+8Y8AQEEEGhSQC2I6s7Vgth+a9k7fPiwW7BbO760aMG/MpqsSL5EIGQCdDeHrEIpDgIIBEdA4wQVGOq1a9cut3yNWu20N3Pbtm3zXhDlQ/nRQtranWXo0KG2ceNG99q/f3/e80cGEEAguwJMXMmuL3dHAAEE4gRKSkpsyJAh1qFDB7fziQKv2DGDO3bsMLXgKR09etQKC3P33/N6rjc2Us8tLS2ty78CVwW0avVUkLh69Wo3m7ruBD4ggECoBAgSQ1WdFAYBBPws4LUaqtvWa5Grra1tMMsaC6i1DvW9turLVdJzlT8FsI09V0GkVxblyyuLAloSAgiER4AgMTx1SUkQQMCHAlpiRuP59KqurjbthqKWwrAk7f88ePBg1z2+fv1608trBQ1LGSkHAlEVIEiMas1TbgQQyKpAUVFRXXC4detWFzxpvcGwJq3vqEC4V69erqzr1q1zQXFYy0u5EIiCAEFiFGqZMiKAQM4ENMnD64r1WtZixxvmLCN5epDGLXotp5s3b7ZNmza5hb/zlB0eiwACaQgQJKaBx6UIIICAJ6DgsH///m6ih1rRFCA2tbi1d11Y3zXpRcGiTDRzWyZ79uwJa3EpFwKhFCBIDGW1UigEEMiVgJaxGThwoHXv3t3tmRy7b3Ku8uD35wwYMMAZaSymfFg+x+81Rv4QeF+AIJFfAgIIIJCCgGb4asKGXloKRi9m9zYN6XkpUJRXYzO7m74L3yKAQK4ECBJzJc1zEEAgNALdunVzC0vv3bvXVq5cyQSNJGpWy+poUe7OnTs7u23btiVxNacigEAuBXK3QmsuS8WzEEAAgSwJDB8+3Hr06GHLli0zApzkkbUO46JFi0yB9ogRI6y4uNhZJn8nrkAAgWwL0JKYbWHujwACoRBo3769jRw50hTkLFmyxHd7LAcRWV32o0ePNo3rlKkWDychgIB/BNit3T91QU4QQMCnAuoaPfHEE90WdO+99x4BYobqSWM41aqoFln5qlWRhAAC/hEgSPRPXZATBBDwoYAWiR4/frybaKEJF6TMC6xdu9ZWrFjhnLWUEAkBBPwhQJDoj3ogFwgg4EMBdYeqi1nBoRaFJmVPYMuWLW4iy6hRo9ze0dl7EndGAIFEBQgSE5XiPAQQiJyA1vfTGEQtjE3KvsDGjRvdGooDj607SUIAgfwLECTmvw7IAQII+FSgb9++BIg5rhsF5HInIYBA/gUIEvNfB+QAAQR8JDBkyBA3gaKoqMhatmzpcqZjpOwLyLlFixZuUXLNeNZEFuyz784TEGhMgCVwGpPhOAIIRFbgzDPPdDNuFah06NDBnn322cha5Lrgstci5dXV1W4tRexzXQM8D4F/CdCS+C8LPiGAAAJOQFvGaS9mBYj6TMqdgLw1o1yLbWOfO3eehEBDAgSJDalwDAEEIi2watWquvLHfq47yIesCcR6x37O2gO5MQIINCrAtnyN0vBFVAWqqqrs8OHDUS1+XLk1u1dj89q2betecSdk+IC6Gffv32+1tbWmfX7zlWbPnm1aAqeysjJfWXAzq7HPD3+uf/f5KSVPRaBpAcYkNu3DtxESUHBYUVHhAgMNnteLZHUBswKmwsJCKy0tzRrLjh073PO0E4eSnhfl5P3HCva5/xXk0j73peOJCCQmQJCYmBNnhVxAAaIGy6vVpnXr1iEvberFk5OCZwWKmQyiFRQqQFTroVosSfEC2Meb5OpItuxzlX+eg0CqAjSVpCrHdaESUAsiAWLzVarZvkeOHHEBdfNnJ36GAvSamhoCxCbIsG8CJ8tfZcs+y9nm9gikLUCQmDYhNwi6gFoJ1J1HC2JiNaku4AMHDiR2coJnqQ5atWqV4NnRPQ37/NV9NuzzVxqejEBiAgSJiTlxVogFNPYok12nIaZyRdNkErX6ZTKpDvI5SSWTZcnmvbDPpm7T986GfdNP5FsE8i9AkJj/OiAHPhAgSMxvJXgTVfKbi2g+Hfto1julRiARAYLERJQ4B4E0BQYOHGglJSVp3qXxy3VvWuIa98nkNwMGDLCuXbtm8pbcK0EB7BOE4jQEMiRAkJghSG4TTgG1MD766KP2q1/9yh588EH7+c9/bh/5yEeSLuw555xjo0aNSvq65i7QvrY//elP7Zvf/Kbde++9NnPmzLr9hpu7NijfX3rppXb//ffHZXfw4MH22GOPuZ1R4r6MOTBhwgQbPXp03ZF073fWWWfZ2LFj6+4X5g/pWmEf5l8HZYuCAEFiFGqZMqYloEV1L7vsMvvc5z5nt9xyi1100UWmlkE/pM9//vMugP3qV79qV155pQuYpkyZ4oesZSwPGq/Yu3dvGzp06HH3vOCCC477u7E/FCAOGzas7ut071d3owh8SNcK+wj8SChiqAWivVJtqKuWwmVDYOPGjfbee+9Z//79bc2aNTZx4kS75JJL3NItb775pv361792jy0qKrL/+I//MLV2rV+//rjZwF6Ln07U/rRXXXWVffe733XXffSjH7UPfehDbhHpF1980f70pz+54409p7i42LZv3+7O0dI03//+991MbR1Qq+Kzzz5ry5Ytc9//8Ic/tJtuusntR6zvtm3bZmrpefvtt23lypV2/vnnu+f+6Ec/qrvGXeiDf8hWLXjKp5J8FTR6f+uYguPPfOYzrttdx++55x6bNGmSTZ8+3a2/KOv/9//+n0615u7Xr18/++QnP2l33HGHO//UU0+1Xr161dWHOxiRfzRnJQbsI/JjoJiRE6AlMXJVToHTEVCLlLoalyxZYp07d7bLL7/cbrvtNps1a5b16NHDTj/9dHd7BSubN292rXu//OUvXbDiPVeBnZfUna37KE2ePNlOOukku/766+3aa6+1MWPGuBawpp7zyCOPuNbNL3/5y3byySe7YMhbnqZjx47HLSvTpUsX9xytB6l7qxtdAerIkSOtT58+9pWvfMUFQQoW/Zbeeust12Ws4FDplFNOMW2bp8DYS+p6/853vuPMtSi3PF577TV77rnn7K9//WtdgKjzm7ufjDp16uTd2gWe7du3r/s7Sh+as5IF9lH6RVDWKAkQJEaptilrSgKaEKKxiL/4xS9cQHjnnXe61rsRI0a4btCpU6faueeeawrK1HKlpCDs73//u2nm6KZNm2zhwoXNPvuEE05wAc2hQ4fcnr3f/va3bcWKFdbUc55//nnXYrl27Vr78Ic/7PKpVs7mklpEFcQqyNqwYYO988477hK1jnrBZHP3yOX3CvpeffVVU4uekloH1Uoam/7yl7+4YEV1oYBbLYeNpUTu19i1UTueiBX2UftVUN6oCBAkRqWmKWfKAhqTeMUVV7hWQwVjamVS0uLPu3btqnupxerJJ59032nhXY3n8lJsi5cCR2/JHe9eOk/H9C/k+qmx52gBcG1ht3v3bnviiSfsW9/6liloPPPMM90tYp+jA94z9Tn2ObpPEJZBka+CQ81w1eLb6i73kozUna4uaHl4Xeze9w29N3U/nR/rFfu5oXuF/VhTVtiHvfYpX5QFCBKjXPuUPSkBBVK/+c1v7LOf/awb97d8+XKrrq62BQsWuK5Pbe3nLUOjIEVdokrqLh43blzdsxRYehMpYmfdLl682LWUKWhTUheyxjQ29hwFLhrfqEkdXlKXqPZAVtq5c6cNHz7cfdY5sd3c7mDA/qFyafs+BezPPPPMcblXq6Hcfve737m6UBDsBb4K8mO7jr0Lm7qf7BSMKgBSiq0n7/oovTdlhX2UfgmUNWoCTFyJWo1T3rQEFBBWVlbaGWecYf/4xz9MYwJ/8IMfuIkpCkz0Wemhhx5yy9JoEopavZYuXVr33D//+c928803m7p8y8vL645r/JzGB2riiFoiNUFG3yvYaeg5ap2877773Dg8BTXq7tY9Hzy2VI+SurvVZa3u8HXr1pmC2KAnlUnB89y5c48rirrOZaXJKvv27asLlHXSG2+8YTfAlef7AABAAElEQVTccIMpgNZyQbGpsfspGH3ppZfsgQcesC1bthx3v9jro/S5MSvso/QroKxREygoKys7GrVCU14EYgUU9Km1yWsFjP0u0c/q9vUmjMReo4kWam2sn9TNrEBQz62f9J1axWK7q71zGnqOzi0tLXXBUUN5aNeunQtUvXtk4n3Pnj2mGcCZSpoB7k3gSeee8pap14oYey+5xnb7x37X2Gf9JlQPyV7X2P0ycRz7TCimdo9M26eWC65CIHcCtCTmzponhVigoeBMxW0oQNRxBR2NBR6NHdd1DT1HAZG3DI7OqZ/UkhmV1Ji3yt+Ua2M+DQXxjZ0b9ePYR/0XQPnDKMCYxDDWKmVCAAEEEEAAAQTSFCBITBOQyxFAAAEEEEAAgTAKECSGsVYpEwIIIIAAAgggkKYAYxLTBOTycAhockJDkx3CUbpglKKpMW3BKEFwc4l9cOuOnCOQTQGCxGzqcu/ACChAJEjMb3Xhnz9/7PNnz5MR8LMAQaKfa4e85UxAy9G0bt06Z88L+oO0dWCmUzpLEGU6L36+H/b5q51s2OevNDwZgeYFGJPYvBFnIIAAAggggAACkRMgSIxclVNgBBBAAAEEEECgeQGCxOaNOAMBBBBAAAEEEIicAEFi5KqcAvtZQHs3aw/mTCTdR/eLYsIxf7WOff7seTICmRZg4kqmRblfaAW0b/K///u/21NPPWUVFRVZKeeYMWNs6dKl7t7t27e3YcOGub2Ily9f3uS2ckOHDjXtW+ylDRs2uDzG3s/7LmjvQ4YMMb02bdpk+/fvN+3z3NC+1rHl8srdq1cv69q1a91Xu3fvto0bN9b9Xf+D9ncePny428d7xYoV7nl79+417371zw/739iHvYYpHwJNC9CS2LQP3yJQJ9CqVSvXMtfULNwPfehD9sUvfrHummQ+9O/f3wVAukYzrT/xiU+YAhR9vuiii5q8lfYlVuCk14QJE6ykpMSdr4BK9w1ykum0adNMgfBHP/pR+/SnP91kcWIda2tr61wUMI4YMaLJa+Wsepa7/L0Z72FwbLLgjXyJfSMwHEYgIgIEiRGpaIqZmoCWxrn44ovtG9/4hp1yyil1N1Gr3ac+9Sn75je/aTNnzrTevXtbv3797OSTT7aePXvWBTLjxo2z6667zm688UY777zz6q5v6IOCu4ULF7qv1KKl5TZWr15ty5Ytcy1b+mLgwIGmeyr17dvXTjzxRPe5vLzctUCuWbPGWrRo4a7TF7qf7hvkVFNTY/PmzbPHHnvMXn31VevevXuTxYl13Lp1q3NR62yPHj3sjTfecNeeffbZLgAsKCiwGTNmmOpZSf8BIG+5y1/1oBQGR1eQJP+BfZJgnI5AyATobg5ZhVKczAoo4FCX28MPP+xasry7a7zfqlWr7M9//rNr3SorK7PHH3/c3nrrLRs8eLA7rnMVdDzyyCOuq1gtjK+99pqpy7N+UuuVgruDBw+6rw4cOGBr1661r3zlK65lS/dQ0jG1pnXo0MHl549//KM77v1j6tSpNmfOHO9Pdz/dV/fXv/CDmNSaN3nyZBccKtB74oknGi1GfUfvxEGDBtm2bdtc97GOLVq0yC688EL3twJsr/v6pZdeslmzZjmr+fPnm+pBSfUSdEdXkCT/gX2SYJyOQMgEaEkMWYVSnMwKlJaW2ubNm23dunW2YMGCupsr4FLgcdlll7kuaAWN6vJV65PeveBCLVRqqfK6ixvrqtb91GqlQESpT58+rnXyvvvus5/97Gd25plnukBPO2MokNE91SoWu7ivxkyqq1XjF72k++m+QQ0QVQ7lXS17akl85pln7CMf+Yh17tzZK+Jx7/UdvS9PPfVUF6B7f2vMpups0qRJ9t5777nDCjDlLG+5q3VY9aAUBkdXkCT/gX2SYJyOQMgECBJDVqEUJ7MCavVT96aCEo2J89JJJ51k7dq1s5/+9KcuKPOCNY2BU1e0AjMFhArmnnvuOfvTn/7kXdro+5IlS2z06NHu+y5dutiWLVtcC5fGx+lf1mrV0TPVbX3vvffaBz7wAevWrVvd/dSKOHv27Lq/9UH3032DnBQY79q1y700cUXBnFpSG0uxjjpHLcHqdta1XpKdJqaohfacc85xh+UrZ3mrZVHXqB6UwuDoCpLkP7BPEozTEQiZAN3NIatQipNZAbUeeuMKvVnHeoICjClTptg111xjVVVVLrDQcZ2jLurPf/7z9vOf/9xWrlxpl1xyiesm1vcaA9dY0rUf+9jHXMuWWgP13I9//OMu6FRLpoIcr7t1x44drktb4x+3b9/ugke1Iv7jH/847vZajuR///d/jzsWtD8UdKu7Wa1+1dXVrgVVM50bS7GOOkdjSTUsIDbJ0huf6LU+6picL730UvcctR5qDKRSGBxjy5/oZ+wTleI8BMIpUHBsLNXRcBaNUiGQmEBlZaULCtSS1FhSt7E3bs07x+saVuth/aRgUK0wSg1dW/9872+1Bqr7U3lSUquZuq8beoZ3TWPvnTp1srFjx8a1LjZ2fjLH1dqmiTqZSpo9rO7fTKX6jsnct37XcjYdk8mXdy72nkTu3zNtn/sS8EQEkhMgSEzOi7NDKKCATK2BajUhJSaQ6X9ZZjpITKwUwTwL+/zVW6bt81cSnoxAYgKMSUzMibNCLKCWPq/VL8TFzFjRNP5SZplMajH1ZnZn8r5huxf2+avRbNjnrzQ8GYHEBAgSE3PirBALaDKIgkSNTSM1L6Bud+0Gk8mkOlC3OqlpAeyb9snmt9mwz2Z+uTcCmRAgSMyEIvcIvIBmsSpIIVBsuio1cUStiE3NLm76Dg1/q/GIuq/uT2pYAPuGXXJxNFv2ucg7z0AgHQHGJKajx7WhEtC4RO3JrEknenkTU0JVyBQKo+BZLa0yUbew1o7MVtKsbbXYaKKOnufteJKt5/n9vtjnr4ZyaZ+/UvJkBJoWIEhs2odvIyigYFGBSr6TJtJoD+amlnvJRR693UbUJawFu7Od1Gqj5WgUKDa2+HhDedDsdO3PvHPnTtu3b19Dp/jumEy11uWePXvcf6DUz2BQ7OvnO92/1bKv/0hoaHeidO+d6PW5tk80X5yHQC4FMjv6PJc551kIZElA/+L2Q9K6h1oHMSgBT6bMFBwnO9NcYyS14LUCagUWWrYmKElB8cSJE91QB2/v7nzlPRX7bOR1wIABriVfrXkkBBDInwBjEvNnz5MRaFJAy22ksj5ikzcN4ZfaDUcLmGuHlI0bNwauhNrCcd68ea5L/8QTTwxc/rORYY0NzvQM+mzkk3siEHYBgsSw1zDlQyDkAsOGDXNdzNotJcjpnXfeca3GH/zgBxvdmzrI5Usm7xoPzLJUyYhxLgLZEaC7OTuu3BWBtAU0Hi/qEzeaQ9TWheqOj90ysblr/Py9tntUeVQutYzq7ygmtSLS1RzFmqfMfhOgJdFvNUJ+EPingAbO8y/Kxn8OakHUWMSwBIheSTdv3mzz5883TcQ5+eSTM7pdofcMv7/rP5C0eDUJAQTyK0CQmF9/no4AAikIaEKPZgVrLF8Yk2Z3L1q0yNauXWsnnHCCjRgxIozFbLRMmkWv/0giIYBAfgUIEvPrz9MRQCBJAa3VqKBJLYh+WKooyewndbpma7/11ltupq/GKnbv3j2p64N6slYY0IQeEgII5FeAIDG//jwdAQSSFBgyZIipS3bXrl1JXhnM0xUsLVmyxL0GDhzoZnKrKzrMSd3NBIlhrmHKFhQBgsSg1BT5RAABNwZRC2avXr06chrbt2+3N9980y28fcopp5iC5TDuCqRhBJq8E/ZW4sj9gClwIAWY3RzIaiPTCERToF+/fqalbqIcQJSXl5sCxlGjRlmfPn1Mf69fvz40PwiNR6ysrAxNeSgIAkEWoCUxyLVH3kMt0LFjRxYUjqlhbdOmVsQgLpgdU4yMfFRL29y5c007tHTt2tXKysqsR48eGbl3vm+iLfnyuR1fvsvP8xHwkwAtiX6qDfKCQIyAdlyJcotZDIX7qGBIJtrGjvS+gPZ8XrBggZvpPWjQINOYRXXFq6UxqEnjLanjoNYe+Q6bAEFi2GqU8iAQUgFtv0cLU8OVq6BQr+HDh5uCxcGDB9uGDRsC1+rat29ft4d1RUVFwwXlKAII5FSAIDGn3DwMAQRSFVA3ZJBbyFItdzLXLV++3J1eWlpqCrg0uUXjFbV7S1VVVTK3ytm5xcXF7ln6DwDlOaq7zOQMnAchkIQAYxKTwOJUBBDIvYACHSWNSVR3s/d37nMSnCfu2LHDdUNr55aioiK3zd/IkSOtQ4cOviyE6lSzmmtra90+3L7MJJlCIIICtCRGsNIpMgJBE5g8ebJp1qu24tu5c2fQsp+3/Cqo1hqLWndQrXSTJk1yXfbqivbTOpNqTdRyPspXbMti3uB4MAIIOAFaEvkhIICArwVWrVrlAge1iGlcov4mJSegLe7k9tJLL7ngUDvWTJkyJa5VNp+ttJrNP2bMGJcnxp4mV7+cjUC2BAgSsyXLfRFAIGMC3uLZLH+TPqla615//XUXLHbq1MlOPfVUN9FFXdFqxctXoKiWRNVzWPfjTr/muAMCuReguzn35jwRgYQEtH9ty5YtEzo3CCfV1NS4MYVHjx417b+cTNLYOi33kspC2ocOHXJdmequ1ov0voDXIqtAUYtyjxs3zi09o5nRSt73+ixDrc2oMYPZ2BJQ9at9qhNZ+katogooFdSqG52EAALZEyBIzJ4td0YgLQHNRj1y5Eha9/DLxZpIoSBRk0+UFGwkmzS2LpXkGSrQ2b9/v5WUlIRyO7tUbHSNdjfRSxNH1A2tFBsoagyo6s5LCvIzmbzlexK9p9YO1e9IXdL6jw2tn0lCAIHsCBAkZseVuyKAwD8F9C9zBRlqGfWCxHzhKPDetm2baYmYwkL+78+rB3Uxq6tZLXl6KaDWkkNegKi680uKbT08cOCA6T9AVJ8kBBDIvAD/L5l5U+6IAAL/FFAXpf5F7pelVxTsqDVRL02CIb0vENu17JloZrSCxfbt23uHfPeu4QOqS+VVE19ICCCQWQEmrmTWk7shgECMgMaP+W1cpcbU+XVh6Ri6vH9Ui6Lf6q4hFOWR+mxIhmMIpC9AkJi+IXdAAIFGBNQSFds92MhpOT2scWwap5jKuMicZjTPD/Nj3TVEot8Xe5w3JMMxBNIXIEhM35A7IIBAwATyPTYyYFy+z26mJ9P4vsBkEIEcCRAk5giaxyCAQOMCGk+mxbJJCMQKDBgwgNnLsSB8RiDHAkxcyTE4j0MAgX8JaKu4r371q65LWrONy8vL7e6773aTXf51VmKfevXqZaNGjbLnn38+sQs4K2WBT37yk3b++eebxpx66c4777R33nnH+zMj72eddZYtX77c7RSTkRtyEwQQSEqAIDEpLk5GAIFMCWgs2Te+8Q175JFHXBCgLuDLL7/cLrvsMrv//vuTfozW+Zs6dSpBYtJyqV3whz/8wR577LHULuYqBBAIhABBYiCqiUwiED4Btfrt2rWrrpVI48oefvhhO/PMM11h1f08c+ZMt02cJpk8+OCDNnfuXLfe4qxZs9zizwosH3jgAbcby5e+9CW3tt9tt91mN954Y/jAAlKifv36uXrTTi6vvfaaa92944473JJDaoHUZyVtB6jW3z/96U9uxxfVtdZq1MLeak3WDiwkBBDIrwBBYn79eToCjQponF6YB+QPGjTIVqxYcVz5tabiX/7yF3dMwYa6L3/4wx+aPt90000uSDzttNPcAsoKNjRmTcHm008/bT/72c9cF+itt9563D35IzsC48ePP26JnCeeeMItxK3hAwr2tQfztGnT7MILL3TnaakaBY5eUkuytwbj0KFD7be//a299957NmPGDHfNPffc453KOwII5EmAiSt5guexCDQnoAWCwzwLV0GDt2VeQxYKIDUebfr06TZ58mTr0aOHO23t2rVWVlZmF110kQs+FCCSci+g8YhaLN17qbVXi6Yr8FOAqKSWRLUMNpdeeeUVd4oCxAkTJtjYsWObu4TvEUAgBwIEiTlA5hEIIBAvoEkqak2MTQqKvWOatHDVVVe5fZY3bNhQd9rixYvthhtucAso6/srr7yy7js+5E5g2bJl9ve//73upXUVGwr8Y9cwbNHiX//Kif18zTXXmOpbLcn6XSjwJCGAQP4F/vW/2PznhRwggECEBJYsWWL9+/d3rYResc877zz7xCc+4f4cN26cPfnkk/bMM8+4bde8VseJEyda9+7dTd2bmlHrtTqpZYut2TzJ/Lzv2bPHPXjYsGHufcyYMXVL2GgfaA0P0GLmSqNHj3bv+ofq+qGHHnLjU1XPBIl1NHxAIK8CjEnMKz8PRyC6AtpK7fvf/75dd911dumll7qu9d27d9tdd93lUNSNfO2119o555zjxi56y60o2NBxb79ejX9TUve0Agxdr+9J2RVQd/+5555b95Af//jH9u6777pJJ/LXtn6bN2+2rVu3unNUXy+99JKbaLRlyxY3rtS7+NFHH7Xbb7/dVLdr1qzxDvOOAAJ5Fig4NrbnaJ7zwOMRQKABAbWyaRyeZvQGNSlIaNu2resybqoMmtCgbsn6e/Cq+1kTHBRw1E/t2rWLO1/nNNTlWf9aBSyaWRvb5Vn/nKj/vXHjRjfGMNVxsap3dR/fe++9dvPNN5v+A0DJ20bPaxn2nL0WxpqaGu9QQu+a3KX61JqbJAQQyKwA3c2Z9eRuCGRMoKKiIhRBTCIztDW5oX6AKEhd21CAqO8aOl/H6wcfOkbKvYACRCXVU+w+2WoRbqiOFBwmGyDmvlQ8EYFoCRAkRqu+KW2ABPQv1qC3dLVu3do0ocFPSYGIXINum21Ttex5XfzpPOvrX/+6W8cynXs0da3y6LVCNnUe3yGAQPICBInJm3EFAjkRUGuLuk6DnLQgdkOtRvksk4JEdVWTmhZQd3HszOSmz87ft/p9UZ/58+fJ4RYgSAx3/VK6AAuEIUjUmnkKNtTlmEi3c7arS13XGmPnLeKc7ecF+f6aKa7xg163sR/LorypFZFZ7X6sHfIUBgFmN4ehFilDKAUUJGryQNCTtlrbsWOHCxS9SRC5bCH1WjL1bD23pKSEruYEf1Rdu3atqzvvklzWnffM2HevdVP1WVhYaKWlpbFf8xkBBDIoQJCYQUxuhUAmBTQmceDAgbZy5cpM3jYv99K/yNXN6+2+kcoYMs321n6+XpCQaEE0Zk2BjVo09SIlJ6C607hSzSBWa7DGmaaaunTpUrfUUar30HUaT6rdXdTSSUIAgewJECRmz5Y7I5CWgP6FrMBKAZXeg55UDrVMpZqGDx/ughRvweZU78N1yQsoMEyn7rwnanFttQBqT24SAgj4X4Ag0f91RA4jLKAWHLWWhCFITLcaNQkmE7Nt080H16cuoJ1UmFWeuh9XIpBrASau5Fqc5yGQhIAG5tNFam7smVoiG1szMQlSTkUAAQQQSFCAIDFBKE5DIB8CmhXMTFwzjWXT4uKkYAso0NeLhAACwRAgSAxGPZHLiAqoe47lPczNYE12wkpEfzK+LraGTTB0wtdVROYQOE6AIPE4Dv5AwF8CmqTRuXNnf2Uqx7nRzOSePXva6tWrc/xkHocAAghEW4AgMdr1T+l9LrB//343GzTKO0qMHj3aLX2jJVhICCCAAAK5EyBIzJ01T0IgJQEtRN2tW7eUrg36RSNGjHBrHC5fvjzoRSH/CCCAQOAECBIDV2VkOGoC27dvtx49ekSt2KY19dSC+t5770Wu7BQYAQQQ8IMAQaIfaoE8INCEgFoSNSM0KmMTtZPGSSed5BbOnj9/ftI7rDRByVcIIIAAAkkIECQmgcWpCORLYMOGDaZt6cKeVMaysjLbvHmzLV68OOzFjVz5tOanFkUnIYBAMAQIEoNRT+Qy4gLr1q1zawUWFxeHUkLlmjJlitv6bc6cObZ+/fpQljPqhdLi8CyIHvVfAeUPkgDb8gWptshrZAW0j/OqVats2LBh9uabb4bGQQuFDxo0yAXAWuJm06ZNoSkbBUEAAQSCLkBLYtBrkPxHRkABlPYu1oxfLwW1ZVHBoZa2UeuhlvmZPXs2AaJXqbwjgAACPhEgSPRJRZANBBIRePfdd02BYd++fd3pJSUliVzmm3OU9/Hjx7uJKep2fPXVV628vNxqa2t9k0cyggACCCDwvgDdzfwSEAiQgIKpRYsWuSBLy8MMGDDAdUP7vQha57Ffv35u0oLGG77zzjt+zzL5QwABBCIvQJAY+Z8AAEET0M4j6nr2WhOHDBnim0Cxfl5GjRpVt/e0gkPNWiYhgAACCARDgCAxGPVELhFwAuquVSAWOxZRayj6IU2ePNl2797t1nMsLS21Pn36mALajRs3upcf8kgeEEAAAQQSFyBITNyKMxHIi4DG7ul15MgRq6ystLVr19atNaduXAWJVVVVOVl0Wnlo0aKFax3Uu5e8wFX51Azsffv2mRbCZr9lT4h3CbRp08btRY4GAggEQ4AgMRj1RC4jKHD48GHXMqfATKmgoKBugodmOSvt2bPHvefqHxoTqeV4FPx17NjRtRqecMIJ1r17d5eF1q1b28KFC62mpiZXWeI5ARLQ7zb2Py4ClHWyikAkBQgSI1ntFNrvAocOHbJdu3a5wFATVPyWFMBqYWQtZaNt9NRyqMBQAYCCRnU7a11HEgIIIIBAcAUIEoNbd+Q8xAIKutRi58cAUeyFhYUuINy2bZu98MILphZEEgIIIIBAuAT+NagoXOWiNAgEVkBduhpjqH1u/ZzUatiyZUu2WfNzJZE3BBBAIA0BgsQ08LgUgWwIqCtXwVcQxm4pj4w/zMavgHsigAAC+RcgSMx/HZADBAIroCBR3eIkBBBAAIHwCRAkhq9OKRECGREYN24cYw0zIslNEEAAgWAKMHElmPVGriMscNttt7kt7rylcURxxRVXmGZEZzLpnt/5znds586dmbwt90IAAQQQCIgAQWJAKopsIhArcMstt9jKlStjD/EZAQQQQACBjAoQJGaUk5shkF+BadOm2Sc+8Qk3TvDJJ5+0U0891b75zW/a9OnT3ZqGjz/+uMvg5ZdfbnPnznULX0+ZMsU+85nPuN0wFHjec889zFjObzXydAQQQMAXAgSJvqgGMoFAcgJnnHGGW7RaV2n3k2eeecZKSkrssssusxtvvNF27NhhX/jCF6xLly7uxlpOJ3ZJHS2A7e35rC311K2sxbuvu+46O/nkk93ah8nliLMRaF5Ae44HYdZ+8yXhDASiIcDElWjUM6UMmYDWUdSC23rps9Lw4cPt3Xffte3bt7uWxKeffjqhUv/lL38xBYrnnnuuTZ482bQfNAmBbAhUVFS43XiycW/uiQACmRegJTHzptwRgawLzJkzJ25MotZWjJ3MEvtZy9TEtuB4n9Wa+MMf/tBeffVVW7t2rS1btizreecB0RXQb5R1NaNb/5Q8eAK0JAavzsgxAg0KaDyh9k1WV7LSaaedVneeZigPGzbM/a3AcOjQoe6zWg0LCgrsd7/7nc2ePdu02wvrHtax8SHDAvrtESRmGJXbIZBFAVoSs4jLrRHIloAmo2hnFi9dffXVtnXrVnvsscfszjvvdF3QixYt8r62+fPn2wUXXGA/+clP3HhFjVlU2rx5s5WXl7vJKuq69o7XXcgHBDIooD2+M71UUwazx60QQKCeQEFZWRnbJdRD4U8E8imgf4mq5a99+/YpZUNdenq1a9fOvve975kCSC9p8kp1dXVca2FRUZEdPHgw7rh3XWPvahVSy2NpaWljp3AcgToBTYp677333GSruoN8QAAB3wrQ3ezbqiFjURZIp8tXYxEVaKrr2JvU4lkeOHCgwUCwocDRu6apdz1D3dUkBBIR0H+41P9NJnId5yCAQH4ECBLz485TEWhUoLCw0AV4CsDSSZWVlfa1r30tnVs0e60CUm8pnWZP5oRIC2isrP4jJXZCVaRBKDwCARAgSAxAJZHFaAlo5rG6mtW65+ekf9nrpa5qEgLNCXTq1Ilu5uaQ+B4BnwkQJPqsQsgOAhLwxiOq5cWPSZNmNIZR/+LXZAQSAs0JaGF3rZNIQgCB4Agwuzk4dUVOIySgwEuTQXbv3u266DRGUWP/vPUN80XhLZGjFkR1H3bs2DFfWeG5ARPQbivr1q0LWK7JLgLRFiBIjHb9U3ofC2hsotYxVLezXgrM0hn/17t3b7f1Xjrd2N5EFQWH+Q5YfVx1ZK2egAJE/Xa0zBIJAQSCI0CQGJy6IqcRFdCYv0yM+xs8eLAp8KTLL6I/pDwWe8CAAbZhw4Y85oBHI4BAKgKMSUxFjWsQCKCAH7qrA8hGltMU6Nevn2sBX79+fZp34nIEEMi1AEFirsV5HgJ5ElALorqcSQjkSkDjarUd5NKlS3P1SJ6DAAIZFCBIzCAmt0LAzwLack9jHEkI5EJAAeKECRPs3XffZembXIDzDASyIECQmAVUbomAHwX2799vGzdutNGjR/sxe+QpRAJ9+/a1cePG2YIFC2z79u0hKhlFQSBaAgSJ0apvShtxgTVr1rg9ndUFSEIg0wKa8a7/CNGwhnnz5plar0kIIBBcAYLE4NYdOUcgaQHt6bxo0SIXKE6cODEjs6aTzgQXhFKgR48eNm3aNLdU09y5c+liDmUtU6ioCRSUlZUdjVqhKS8CCJgNHDjQtCyOFjheuXIlJAikJKA1M4cMGWJt2rSxVatW0XqYkiIXIeBPAYJEf9YLuUIgJwLa/q9///7Ws2dPU1d0eXl5Tp7LQ4IvoN+O1j/UZCj9dtauXRv8QlECBBA4ToAg8TgO/kAgmgKdO3e2Pn36WK9evWznzp22YsUK00QXEgL1BfRb0dqHmr2sVmi9tJc3CQEEwidAkBi+OqVECKQsoP2Y1aqogFH7Rms2tIJGEgLe70K7/2j3FL20VSQJAQTCK0CQGN66pWQIpCWgZUz00ozVLVu22LZt29h7Ny3R4F2s8YZqXdarsrLSNm/e7H4LwSsJOUYAgVQECBJTUeMaBCIk0KVLF+vevbt71dTUuHXv9u3b54LGCDFEpqhqKfRaDVXorVu3usBQdU5CAIFoCRAkRqu+KS0CaQkUFxe7YFGBo5JaF/Vi/GJarHm/uGXLli4w1DI2nTp1coGhgsNdu3blPW9kAAEE8idAkJg/e56MQKAFSkpK6loYq6ur7eDBg24JFFqcglGtrVu3tq5du7ohBZqMomBfgaFeJAQQQEACBIn8DhBAIG0BBYxaSkcTX2pra91kF+22waSXtGkzegMFgwoM9VJdqX60wLrWN9RQAhICCCAQK0CQGKvBZwQQSFtAkx20PIoCEXVdKhDR/r16V2sjKXcCrVq1cvWgtQw1VEABoepBL7qSc1cPPAmBoAoQJAa15sg3AgEQ0ILLXuuVAkd1RStAOXDggJspG4AiBC6LCsy91kIvSJe5xo1qWSMSAgggkKgAQWKiUpyHAAJpC6hbWsGigpd27drVtWipVStbrYy6r8ZMak2/wsLCtMvQ1A2OHj3qnqHgOFdJz1IroV7aGk+th15rod5JCCCAQKoCBImpynEdAgikJaAgUUGj91LrooIaBYyZ6ArVGDvdR4FbQUGBy6vWfMxm0nhM76WgTWXMdFJQOGjQIHdbPUPlUwuhXgqGM2GX6TxzPwQQCKYAQWIw641cIxA6AW31phm3Cho1rtELFisqKtxCzskUWK2HCpoUHLZt2zaZSzNyrsb+qeVS5Ug3UPRaCrXskBcUVlVVubULZaPPJAQQQCAbAgSJ2VDlngggkJaAukwVLGqnD83CVVLQqMCrvLzcTcCIfcCQIUPcDF3vmFok1ZKYboDm3S+Vdz1fLXva4jA2KdBramygAksFhHqp+1gvBYO6hqAwVpLPCCCQbQGCxGwLc38EEEhbQK1pChq12LOCKLWeeS2NeldANXnyZJs3b55p6R1tI6jg0utmTjsDKd5A+VR+vdZABbPKY2zyAkK9qyVVC1srGNRLQWZTAWXsffiMAAIIZFqAIDHTotwPAQSyLqCAyhvLqNnTChTVaqjXiy++aOvXr89rK6IHoHGW2uZu4MCBLohVK6iCvtjAUDO+vaBQM5BZjNzT4x0BBPItQJCY7xrg+QggkJaAZiyPGjXKbSunG23evNleeOEF102b1o0zcLHGRqq7+bTTTnN30yQTLyD03g8fPpyBJ3ELBBBAIPMC2V0PIvP55Y4IIIDAcQIDBgxwAaFa6LRziDdp5LiTsvDH+PHjbfHixdZckKcxhV5S97fySBeyJ8I7Agj4WYCWRD/XDnlDAIGkBbyZzc1NWrnpppvcGMdZs2Yl/QxdcP/999sNN9zQ5Mxr5UXjDNUlrgkr6iL3koJFEgIIIOBnAVoS/Vw75A0BBLIioMW8NXNaYwM1kzoX+xar9ZAWxKxUJzdFAIEsCRAkZgmW2yKAgH8Fpk2bZq+99lrdrOjXX3/dZfaUU05x4xs1jrBnz572yiuv2G9/+1v3Xf/+/e3qq692rYLe+f4tITlDAAEE0hfI7vYD6eePOyCAAAIZF9BEkldffdW9Tj/99Lr7a/zgiSeeaHfccYdde+21NnXqVNclrROuu+46+5//+R+78sor3bjC3r17113HBwQQQCCMAgSJYaxVyoQAAo0KaK1FvSorK23Dhg2mCSjegt26aOHChaala/TSxJThw4e777XWobfGoQLMvXv3NvoMvkAAAQTCIEB3cxhqkTIggEDCAh/60IfcJJLrr7/eXaNt+9Ri+Mwzz7i/Y8cnauayZiRrgWvt9hKb6v8d+x2fEUAAgTAIECSGoRYpAwIIJCygcYdf/vKXbdOmTe4arbH46U9/ui5IbOhGe/bscYeHDRtmK1assLFjx7rxjA2dyzEEEEAgLAIEiWGpScqBAALNCmhbPK2j6AWIumDp0qXWvXt369atW5PX33333W6corqh165da1u3bm3yfL5EAAEEgi7AOolBr0HyjwACxwkkuk7icRcl8Ye22dOeyomk2HUSEzmfcxBAAAE/CTBxxU+1QV4QQCAjAtr+Llsp0QBRz6+trc1WNrgvAgggkHUBgsSsE/MABBDIpYD2clZwls1AMdHyKA/KDwkBBBAIogBBYhBrjTwjgECjApqJrC5hjR3MZ9Isac2A1tI5JAQQQCCIAgSJQaw18owAAk0KaN1DLV2Tr0BRAaJe2q+ZhAACCARVgH6QoNYc+UYAgUYFtHNKSUmJ2ytZgaK6n1u0aOFejV6UgS+8bm69a1/odu3aZeCu3AIBBBDIjwBBYn7ceSoCCGRZoNX/Z+9O4KsszsWPP9n3QEIS1iAYWQVFCBgEtKAIWrCCSnFfaltprdXaurS1tct1vdXW//Vqb9XW7aq0VUu9Ci4ogjuILEoAw04QCASy7/mfZ+g5PYRzTrazve/7m48h57zLvDPf4cPnceadmYQEs7SNzjDWySY69NuZ9wPz8/Nlz549ogtqdybpMwgOOyPGtQggEK0CBInR2jKUCwEEgiKgvYr609k0bNgw0/NYXl7e2Vu5HgEEELCFAO8k2qIZqQQCCARbQHsiO7PcTbCfT34IIIBApAUIEiPdAjwfAQQQQAABBBCIQgGCxChsFIqEAAKRF9B3GXUpHRICCCDgVAGCRKe2PPVGAIGAAvoeI8PNAYk4iQACNhcgSLR5A1M9BBBAAAEEEECgKwIEiV1R4x4EEEAAAQQQQMDmAgSJNm9gqocAAggggAACCHRFgCCxK2rcgwACCCCAAAII2FyAINHmDUz1EEAAAQQQQACBrggQJHZFjXsQQAABBBBAAAGbCxAk2ryBqR4CCCCAAAIIINAVAYLErqhxDwIIIIAAAgggYHMBgkSbNzDVQwABBBBAAAEEuiJAkNgVNe5BAAHbCmRlZZm6ubflKygosG1dqRgCCCAQSIAgMZAO5xBAwJEChYWFkpKSIkOGDHFk/ak0AgggoAIEifw9QAABBLwEysvLzbfk5GTp0aOHlJSUeJ3lIwIIIOAcAYJE57Q1NUUAgQ4KuAPD0tLSDt7BZQgggID9BOLtVyVqhAACCIg0NTVJRUWFtLa2SkJCQqdI9L7Y2FjZuXOnyaczNzc0NEhcXJxoT6QOWZMQQAABqwoQJFq15Sg3Agj4FSgrK5PGxkaJiYkx17S0tPi91t+J4uJif6cCHm9ubjaBpQaL1dXVohNhNGgkIYAAAlYTIEi0WotRXgQQCChw6NAhEyCmpqZ6gsSAN4TwZG1trezfv1969erV6d7MEBaLrBFAAIEOCfBOYoeYuAgBBKwgoD13NTU1kpaWFvEAUb10uFmHu7VcJAQQQMBqAgSJVmsxyosAAn4FdG3DaBvaTUxMNIGr30JzAgEEEIhSAYLEKG0YioUAAp0X0PcAOztJpfNP6dwdWh7tTdR3FUkIIICAlQQIEq3UWpQVAQTaFXBPVmn3Qi5AAAEEEAgoQJAYkIeTCCBgR4GMjAyzRI0d60adEEAAgWAJMLs5WJLkgwACUS8wYMAAufnmmyUpKUni4+Nl69at8vvf/150FnJnU9++fWXEiBGydOnSzt7K9QgggIAlBOhJtEQzUUgEEOiugAaGt956q7z88svyve99T7773e+Krqd49dVXdynr3NxcOe2007p0LzchgAACVhCgJ9EKrUQZEUCg2wLa63fw4EFZtmyZyUsnkzzzzDMyffp08113SLn++uuloKBAdPHtv/zlL/LJJ5+Irrf4gx/8QDQo1Pcd/+d//kcOHz5sgsyePXvK3XffLbfffnu3y0cGCCCAQLQJxLmGX+6MtkJRHgQQQKArAlVVVWYYWbfUa5smTpwolZWVsnbtWs8p3bpv48aN5vvgwYNFZ0c/9NBDsm7dOrnxxhvllVdekbPOOsssq3Pvvfeaa4cMGSKfffaZ7Nq1yyyS/ctf/tKTn78Pmm96errZ6s/fNRxHAAEEok2AnsRoaxHKgwACIRHQ9RMDLUOzefNms1OLBoU6saV3796mHNu3b5e5c+eafaBXrVolixcvDkn5yBQBBBCINoFj/3c72kpIeRBAAIEgCOgkFe0t9E46fOw+dvbZZ8uCBQtMb5/2ErrTF198IbfddptZEFvPX3fdde5T/EYAAQRsLUCQaOvmpXIIIOAW2LBhgwwcOFAKCwvdh2TWrFkyf/5883306NHy6quvyuuvv26Gpd29jmPHjpW8vDz5v//7P/nd734no0aNMtfr7i7a40hCAAEE7CrAcLNdW5Z6IYDAUQK6p/Ndd90lP/rRj+SKK64wk1DKy8vlwQcfNNfpMPJNN90k5557rujQswaBmg4cOGCO6/uMGhTqZBdNeo0Gknq/3kdCAAEE7CYQU1RU1Gq3SlEfBBBwpsBXX31l1kBsb//mzMxM0UkrGjh6Jx1+1qVy6urqvA+bzzrLue31eqK9dx31Gg0w+/TpE3X7SmvZSAgggIA/AXoS/clwHAEELCmgS9u0lyoqKnxeovf6ChD1Yl8Boh53D0vrZxICCCBgJwHeSbRTa1IXBBwukJiYaGYoRxNDY2OjGdpur3czmspMWRBAAAEVIEjk7wECCNhGQIeKo61nT9dI1KFqEgIIIGA1AYJEq7UY5UUAAb8CaWlpJiCrrq6Wjgw7+80oSCd06Frfc9RykRBAAAGrCfBOotVajPIigEBAAd0qzz0pRQM0TeEc6vXuyYyPjze7soTz+QFxOIkAAgh0QoAgsRNYXIoAAtYQyMnJMYGiTlDRHsWEhIROFzw/P1/27Nlj8unMzTq8rNsCpqSkmJ/O3Mu1CCCAQDQJECRGU2tQFgQQCJqA9uJlZ2d3Ob9hw4aZYE/XUiQhgAACThTgnUQntjp1RgCBdgW099Hfcjjt3swFCCCAgA0ECBJt0IhUAQEEEEAAAQQQCLYAQWKwRckPAQRsIaDb8iUnJ9uiLlQCAQQQ6IoAQWJX1LgHAQRsL+Bvez7bV5wKIoAAAv8SIEjkrwICCCCAAAIIIIDAMQIEiceQcAABBBBAAAEEEECAIJG/AwgggAACCCCAAALHCBAkHkPCAQQQQAABBBBAAAGCRP4OIIAAAggggAACCBwjQJB4DAkHEEAAAQQQQAABBAgS+TuAAAIIIIAAAgggcIwAQeIxJBxAAAEEEEAAAQQQIEjk7wACCCCAAAIIIIDAMQIEiceQcAABBJwskJWVZarv3pavoKDAyRzUHQEEHCxAkOjgxqfqCCDgW6CwsFBSUlJkyJAhvi/gKAIIIOAAAYJEBzQyVUQAgY4LlJeXm4uTk5OlR48eUlJS0vGbuRIBBBCwkQBBoo0ak6oggEBwBNyBYWlpaXAyJBcEEEDAggLxFiwzRUYAAQSkoaFBKisrjURCQkJQRSoqKiQ2NlZ27twpTU1NQc1byx0XFyfaU6lD2iQEEEAgWgViioqKWqO1cJQLAQQQ8CVQVlYmjY2N5lRMTIwJunxdF43HmpubpbW1Vdzlzs7OtlT5o9GUMiGAQGgE6EkMjSu5IoBAiAQOHjxoAsTU1FQTaIXoMWHJtra2Vvbv3y+9evWSYPeGhqUCPAQBBGwtwDuJtm5eKoeAvQSqqqqkrq5O0tLSLB8gasvocLP2Kmq9SAgggEC0CRAkRluLUB4EEPAroAGivs9np5SUlCQ1NTV2qhJ1QQABmwgQJNqkIakGAk4Q0PcQNaiyU4qPjze9osGeIGMnI+qCAAKRESBIjIw7T0UAAQQQQAABBKJagCAxqpuHwiGAAAIIIIAAApERIEiMjDtPRQCBEAnoXssvv/yy5ObmdukJuj6i3n/qqacec/8vfvELufXWW485zgEEEEDAjgIEiXZsVeqEgIMFzjjjDNm7d6+cfvrp3VKYP3/+UffrMjVjx44VXbaGhAACCDhBgCDRCa1MHRFwiID2AmoP4G9+8xuZMmXKUbW+//77RQO/xx57TPr27SuDBg2Se++9Vx555BG58sor5e6775aMjAxzz4EDB8xOKxoYutOZZ54pn3zyifur2THlxz/+sbn/4YcflvHjx5tz+ow5c+aYz9qreccdd9hiuR5PxfmAAAKOESBIdExTU1EE7C9w0kknyZYtW2TXrl1mWRkNBN2pZ8+eZhu/a6+9Vvbs2SMa4D377LOyYMECKS4uluHDhx8VzL3xxhsyffp0c7vujqJB5zvvvOPOTvLz82Xt2rXm/nvuuUc0X006VD1t2jTp37+/fPvb35ann37arIXouZEPCCCAgEUECBIt0lAUEwEE2hc466yzZP369aIBof7W3j/vtGzZMvM1KyvLrLeoQZ6mjz76SHQnF++0fPlymTRpkgkcx4wZI5s2bZLq6mrPJZs3bzbH9JmFhYXSu3dvc07Xcnz00Uflrrvukk8//VS2bdvmuYcPCCCAgJUE2JbPSq1FWRFAwK9AYmKiTJ48WfLy8mTixIkmUBwwYIA88cQTnp68lpYWc78GcsnJyZ68tKdQdz/xTvru4YYNG8x7iBoIvvTSS6JbAbrT2WefbYLQt956y/Rcuo/rbw0mddFv9/7S3uf4jAACCFhFgJ5Eq7QU5UQAgYAC+i7iu+++K7fccov8/Oc/l+uvv94MB48aNeqY+zQALCkpkauvvlqGDBlihor1fca2acmSJXLhhReamdLak+idRo8eLa+++qq8/vrrZhi7ubnZnNbg8Pvf/755F3Hq1KmigSoJAQQQsKLAsf8qWrEWlBkBBBwvoLOaV6xYcZSDftfjvtIDDzxgevxmz55tJqToZJW2SQNJ7aHU3sK2afHixXL55ZebyS/ag1lfX28umTdvnqxevVq2bt1qejFvuOEG8RWAts2P7wgggEC0CcQUFRW1RluhKA8CCCDgS0AnnOiwcDCCLg0OV61aJaWlpaa3T2dEX3PNNZ6haV/Pb3tMh6l1m0Advu5OqqqqMsPkukUfCQEEEIgWAf5FipaWoBwIINAhgdbW4Px/rc6Avv322z0zmv/whz90KkDUwmpZuhsguisdrHq58+M3Aggg0F0BehK7K8j9CCAQNoGysjLRySfek066+3DtDYxkgNbU1GSW6+nXr19Qeki768H9CCCAgFuAdxLdEvxGAIGoF9ChXQ2qgpkiGSBqPfRdRp01HYwh9GC6kBcCCCBAkMjfAQQQsIyA7oiivYje6xVapvA+Cure4s97aR0fl3EIAQQQiIgA7yRGhJ2HIoBAVwWys7NFh53dgaIOF+uyM1ZJulSO9l5qubX3MCcnRxISEqxSfMqJAAIOEiBIdFBjU1UE7CKggZUO0+qsYH1HMRRBlr4juG/fvqAPb2sbaFCrPaL0INrlbyT1QMCeAgSJ9mxXaoWA7QX0/UT9CVXSxbJ1Ae3y8vJQPYJ8EUAAgagW4J3EqG4eCocAApES0DULg7W8TaTqwHMRQACB7ggQJHZHj3sRQAABBBBAAAGbChAk2rRhqRYCCHRPoKGhIajrMXavNNyNAAIIhF+AIDH85jwRAQQsIKB7NjPcbIGGoogIIBAyAYLEkNGSMQIIIIAAAgggYF0BgkTrth0lRwABBBBAAAEEQiZAkBgyWjJGAAEEEEAAAQSsK0CQaN22o+QIIIAAAggggEDIBAgSQ0ZLxgggYGUBq233Z2Vryo4AAtEpQJAYne1CqRBAIMICur+y7rNMQgABBJwqQJDo1Jan3ggggAACCCCAQAABgsQAOJxCAAEEEEAAAQScKkCQ6NSWp94IIIAAAggggEAAAYLEADicQgAB5wlkZWWZStfX15tt+QoKCkR/SAgggIDTBAgSndbi1BcBBNoVKCwslKSkJMnLyzPXlpSUtHsPFyCAAAJ2EyBItFuLUh8EEOiWQHl5ubk/NTVVBg4c2K28uBkBBBCwsgBBopVbj7IjgEBIBNw9h6WlpeL+HJIHkSkCCCAQxQLxUVw2ioYAAg4S0HcA6+rqzNqECQkJEa15ZWWlJCYmyuHDh0U/RzLpeo26sLeaJCcnR7IoPBsBBBwmQJDosAanughEm0BLS4scOHBAWmJEWmNaJTYuTlrjWiNezC+2bT5ShrjIFkWDxJamJqk6XCMxhw5Jz549CRYj2yQ8HQHHCBAkOqapqSgC0SfQ5Ap+Dhw8ILGpidKjX070FTDKSlSz/7AcrqwwpaJXMcoah+IgYEMB3km0YaNSJQSsIlBZVSWt8bGSQYDYoSZLze0hCZmpcujwoQ5dz0UIIIBAdwQIErujx70IINBlAR1GramplrS8I+sSdjkjh92YmtPDNSwv5v1Nh1Wd6iKAQJgFCBLDDM7jEEDgiIAONce43j9MSE2CpJMCcUmJ0tjY2Mm7uBwBBBDonABBYue8uBoBBIIkcGTWbpAyc1g2sfGuyT2unlgSAgggEEoBgsRQ6pI3Agj4FdBlXTqS9LpePbPMMjAdub7tNVk9esqgATZbFNtF11G/th58RwABBDoqwOzmjkpxHQIIhF1gzoxZMmPKNKmsrpK8Xjny98X/lEVvvhawHBo8zTv3fHnh/14y1w0dfIKMGTla/vi/fw54HycRQAABBI4WIEg82oNvCCAQJQITx06QyeOK5Md33SFVrgkuGenp8h833yG7vyqVVevX+C2lBolfnzbDEyT6vZATCCCAAAIBBQgSA/JwEgEEIiUw8/Rp8tjCp02AqGXQ5XIefPy/JTMjwxQpOSlJrrv0Gjk+f5DogtxPv/yCrFr3mfzs+zdLkmu3lLt+coc88uwT5trUlBS59bobzbDz+o1fyKOu482ue3JdvZPXXXK15GRly849u+Xhpx+X2rpaOc0VoI4cMlyOH3icbN25Q/70/JMmH/5AAAEEnCTAO4lOam3qioBFBLQ3cGD/fCnZvtWUWL/HxsbK9tKdsrb4c3NsQJ/+ss4V8N3wq1vlP//0/+SqCy4xx//j4d9JfUOD/PT+38jO0t3m2NBBBfLwU3+SG399myvfASYA1BM3Xr1AXlryivzw17fL+k0bXHlcbK7XIHP0sBFyzyO/J0A0IvyBAAJOFKAn0YmtTp0RiHKBWFdQGO9aHqex6cgyLxNPGS/fnD1XEuMT5Kv9e+VXD90nX27fYs5Pm3i6ZKSlS++cXL+1+nxzsadH8vNNxdInN09KdmyVIYOOl/x+A8yP9jZOnTjF0/v42Yb1UlEV2X2b/VaIEwgggEAYBAgSw4DMIxBAoHMCOhR8oLxc8vv2lx2lu+T9Tz82P/qe4viTTjGZnTnpDJlaNFne/nCF7NpbGvABja41Gd1J12fUFB935J+/8sPl5rv+fvCJR8xn/aOlucXzmQ8IIICAEwUYbnZiq1NnBCwg8NqyN+WKufNd7xceWWw7JTlZvj51unnvUIs/asgIWfLuUnnrvWVS5Zr9rIGlJl0/UH/c95mDPv7QXsLde/fInn175cPVK2XLju2Snprq40oOIYAAAs4UoCfRme1OrRGIeoE3Vrwt2a71ER/65T2y70CZ9MvrI0uWvyXvrfrIlP111/kbrvyOzDz9TDP03NBQb45rgPjme+/I/bf/2ryrGKiiD/35j3L9Fd82w9YpScmuiTLPBLqccwgggICjBGKKiopYtt9RTU5lEYgOAd1Wrqz8gGSd0D9ggeJc7ybmZPVyDT8flKbmfw8b6006oUUnmdTVHwkQvTPSiS4667kjSXspa+vqOnJpVFxT9dVBSWqOlYx/zfSOikJRCAQQsJ0APYm2a1IqhIC9BJqbm2Vv2T6fldJeQ18Bol7c0QBRr7VSgKjlJSGAAALhEOCdxHAo8wwEEEAAAQQQQMBiAgSJFmswiosAAggggAACCIRDgCAxHMo8AwEEEEAAAQQQsJgA7yRarMEoLgJ2EtC1CGvKDtupSmGpS1Ntg2vCTnJYnsVDEEDAuQIEic5te2qOQMQFWl2zjxvLqyNeDqsVoMU1mUcIEq3WbJQXAcsJECRarskoMAL2EYiNiZWkpCOLZdunVqGvSb2PJX9C/1SegAACThPgnUSntTj1RQABBBBAAAEEOiBAkNgBJC5BAAEEEEAAAQScJkCQ6LQWp74IIIAAAggggEAHBAgSO4DEJQggYG+B7OxsOeGEE8JeSd1Wb/jw4WF/Lg9EAAEEOiJAkNgRJa5BAIGICkyYMEEmT54csjIUFhbK3r17Tf66V/SIESNkzJgxkpaW1u4z3dfrXtGBkvu6k08+WVJTU82llZWVcuKJJwa6jXMIIIBAxAQC/6sWsWLxYAQQQODfAn369JEBAwb8+0CbTzExMXLnnXfKkCFD2pxp/2tiYqIkJyeLBmyaLrroIklISDDf58+fL3reX8rLyxO9ZubMmRIfH3ixiLlz55prqqur5dJLLxV3ULlz504ZOHCgv0dwHAEEEIiYAEFixOh5MAIIBBIYNmyY/PCHP5TrrrtOevTo4bl09OjR8qMf/Uhuv/12mTVrljk+b9480UBRA7HBgweLBpV6389+9jO58sorJSUlxXN/2w/as7d27VrPYV2SZ+PGjbJlyxZpaGgQ7QHUNGPGDBMw6nO8g8K//vWvUl5e7rm/qKhIcnNzzXftAe3du7f5vGTJElm3bp3Jt8W1PqQ7SFyzZo3ptfRkwAcEEEAgSgQIEqOkISgGAggcLXDeeefJ1q1b5R//+Idoj507aRD3t7/9TZ566ikZP368ZGVlyaJFi8zp1157TXbs2CHp6emyYsUKeeCBB8y9OnzsLw0aNEi2bdvmOb1s2TL5wQ9+IDfccINs375damtrzbnPP/9cLrjgApk9e7bs3r1bmpqaZN++fSaQ9Nzs+qAB57nnnmuGx3NycjzD2BUVFTJ16lRZsGCBvP/+++Z+vU/XPNSAUXsvSQgggEA0CRAkRlNrUBYEEDACGghqoKcB1549e0yw6KbRYV3tydNhYU16bV1dnfmsAV2zazcS7anTXjztRdR89Bp/qaysRRK5QwAAQABJREFUzNPzp4Ha9OnT5Y9//KM8/PDD0q9fP+nfv7+5ddeuXaITTcaNGyfr16/3l53U1NSIBpSajwac3untt9+WJ598UiZNmuR5L1EDRO2tbGxs9L6UzwgggEDEBQgSI94EFAABBNoKaO+aBnw641gnj7jfR9RgTwPEN998UxYuXOi5rbW11QSG7okmGqBpL+ATTzwh+g5goLRy5UrRiSua9P1DDdb0/UTtKdTJLD179jTnTj31VNm8ebPpxdSeQn9Jy6rlfuSRR8zwt+apge3ZZ59tbqmqqjL56oxqTSNHjpQNGzaYz/yBAAIIRJNA4Deto6mklAUBBBwloO/wnXPOOTJ27Fg5ePCgqbsGj19++aVcfPHFJgjUg/qOoCYN9vQdRQ3CvvjiC/na175mgjXtWQyUNCDUHkSdvKIBpQ5XX3HFFaZ3Unv5dNhak5776KOPzGcNJLX3z1feOnP5xRdfNMPQS5cuNUGuvrOoQe9ll11mhpf1/tLSUpOXLoGj15MQQACBaBOIcb1k3RpthaI8CCBgfwENlPbv3+8ZdvVVYw3StJdQf7yT9sxpT1/bpAGj+1q9RoM49/e213p/z8/Pl8zMTDNMrMdDNQTcNl995qhRo8w7it7lae+zBssajOrwNwkBBBAIlQA9iaGSJV8EEAgo0JHgTd8t9JV8BYh6nXee/q7xlZ8uQ+Od9Ln+nu19XWc/t81XJ7PoJJbOJu96dvZerkcAAQQ6KsA7iR2V4joEEAiqgHu4NhTBWFALGoWZaZDoXponCotHkRBAwCYCBIk2aUiqgYDVBDTI0SFTHToldVxAh+k1uXdt6fidXIkAAgh0ToAgsXNeXI0AAkEUcM9GJlDsGKoGiPqepffi4h27k6sQQACBzgvwTmLnzbgDAQSCJKAzinXBaZ39q2sd6jCqTj7RCR6kfwvokLza6I8uyUMv4r9t+IQAAqETIEgMnS05I4BABwR0+RndUUWXiNEfDYh0ZnKkky6krTuqdGYCTCjK7A6cdb1FgsNQCJMnAgj4E4j8v8T+SsZxBBBwlIDurxxoj+VwY+ge0Zs2bTpqX+Zwl4HnIYAAApEUYEwnkvo8GwEEolZAezPd2/1FbSEpGAIIIBBCAYLEEOKSNQIIIIAAAgggYFUBgkSrthzlRgCBkAo0NDSYrfpC+hAyRwABBKJYgCAxihuHoiGAQOQEdKIIw82R8+fJCCAQeQGCxMi3ASVAAAEEEEAAAQSiToAgMeqahAIhgAACCCCAAAKRFyBIjHwbUAIEEEAAAQQQQCDqBAgSo65JKBACCCCAAAIIIBB5AYLEyLcBJUAAgSgU0O0B4+LiorBkFAkBBBAIjwBBYniceQoCCFhMQLfDa25utlipKS4CCCAQPAGCxOBZkhMCCCCAAAIIIGAbAYJE2zQlFUEAAQQQQAABBIInQJAYPEtyQgABBBBAAAEEbCNAkGibpqQiCCAQDIGsrCyTTX19vdmWr6CgQPSHhAACCDhNgCDRaS1OfRFAoF2BwsJCSUpKkry8PHNtSUlJu/dwAQIIIGA3AYJEu7Uo9UEAgW4JlJeXm/tTU1Nl4MCB3cqLmxFAAAErCxAkWrn1KDsCCIREwN1zWFpaKu7PIXkQmSKAAAJRLBAfxWWjaAgg4EABfRewoaFBWlpaJDY2Mv8fW1lZKYmJiXL48GHRz5FKboOMjIxIFYHnIoCAgwUIEh3c+FQdgWgS0MDwYPlBkdgYiUmIN7udxMS1RqyIX2zbfOTZEdx0pbm1RVpdLpWllZKeni6ZmZkR8+DBCCDgPAGCROe1OTVGIOoENEAsrzgk8Rkpkt4nO+rKF+kC1VfUSG1ZhcRWVZlgMdLl4fkIIOAMgciM5TjDlloigEAHBQ65hnXjUhIJEP14JWWmSmqfnlJZVSlNTU1+ruIwAgggEFwBgsTgepIbAgh0UkB7EZuamyS9b69O3umsyxNSkyU2KUFqa2udVXFqiwACERMgSIwYPQ9GAAEV0J6xOFfwQ2pfIN7V29rQ2Nj+hVyBAAIIBEGAIDEIiGSBAAJdF3DP4O16Ds65My5Bg+nITeZxjjQ1RQABFSBI5O8BAghEVCAmJkbE9V97Sa/r1TNLzPXtXezjfFaPnjJogMUXxzZOHcDyUX8OIYAAAp0VYHZzZ8W4HgEEwi4wZ8YsmTFlmlRWV0lerxz5++J/yqI3XwtYjj65eTK8YKi88+EKc93QwSfImJGj5Y//++eA93ESAQQQQOCIAEEifxMQQCCqBSaOnSCTxxXJj++6Q6pqqiXDtV7gf9x8h+z+qlRWrV/jt+y52Tly6phCT5Do90JOIIAAAgj4FCBI9MnCQQQQiBaBmadPk8cWPm0CRC1TpWutwAcf/2/J/NcuJP1695EFl14jPTN7SIXr3H89+T/S0toq35p3ufRwLT7965t+Kr948C5TndSUFLn1uhvNsPP6jV/Io88+Ic2unV1yXb2T111yteRkZcvOPbvl4acfl9q6Wrnqwkuk3jX7uuiUQnnR1Xu57KP3ooWFciCAAAIhF+CdxJAT8wAEEOiqgL5/OLB/vpRs32qy0O+6Vd/20p2ytvhzc6xg4GB5/p8vyg/uvNUVxK2Q811D03vL9snjrsCyuGSzJ0DUi4cOKpCHn/qT3Pjr21z5DpCRQ4abPG68eoG8tOQV+eGvb5f1mzbIVRdcbI6npaRK75xc+dFvf0aAaET4AwEEnCRAT6KTWpu6ImAxgVhXUBgfFyeNTUeWfZl4ynj55uy5khifIF/t3yu/eug+eW/VRzLC9e7h2VOmyknDTww4OeXzzcWeHsnPNxWLvrdYsmOrDBl0vOT3G2B+tLdx6sQp8oirl1HTB59+LM3NzRaTo7gIIIBA9wUIErtvSA4IIBAiAR0KPlBeLvl9+8uO0l3yvitg0x99T3H8SaeYp15/xbfN79Wfr5Vtu3a6hoz9L8rd6LVbiXvnkvi4I/8Mlh8uN/no7wefeMRTo+bmFs9nPiCAAAJOEmC42UmtTV0RsKDAa8velCvmzpekxCRT+pTkZPn61Omyat1n5vuJriHjZ19eKMs/+cD1fmGzVNfWmON1DfWSmZbebo0rXFvd7d67R/bs2ysfrl4pW3Zsl/TU1Hbv4wIEEEDA7gL0JNq9hakfAhYXeGPF25LtWh/xoV/eI/sOlEm/vD6yZPlbZphZq7bordfkNzf/zPQ4bt+901NbfY+xyRU03nfbr+SWe37pOe7rw0N//qNoj6QOa6ckJbsmyjzj6zKOIYAAAo4SiCkqKmL5fkc1OZVFILoEqqurpaa5XjIG5AYsWJzr3UQdSj5QftDs9ex9cUL8kf/f9R5Odp+Pc0100WHrjiTtpaytq+vIpRG5pu5QlTQfqpVe2dkReT4PRQABZwnQk+is9qa2CFhWQCeP6KxlX8lXcOi+rqMBol4fzQGiuz78RgABBMIlwDuJ4ZLmOQgggAACCCCAgIUECBIt1FgUFQEEEEAAAQQQCJcAQWK4pHkOAggggAACCCBgIQHeSbRQY1FUBOwq0FTfKDVlh+1avaDVq6muQWJbOzYJJ2gPJSMEEHCsAEGiY5ueiiMQPQKtjc3SWF4dPQWK0pK0uGZpx/xrJneUFpFiIYCAjQQIEm3UmFQFAasK6H7MSUlHFsu2ah3CUe7Gxkazd3U4nsUzEEAAAd5J5O8AAggggAACCCCAwDECBInHkHAAAQQQQAABBBBAgCCRvwMIIIAAAggggAACxwgQJB5DwgEEEEAAAQQQQAABgkT+DiCAQNQK6GSWadOmdbh8U6ZMMdeOGTNG+vbt2+H7gnVhz549pbCwUPLy8oKVJfkggAACERMgSIwYPQ9GAIH2BBoaGuTzzz9v7zLP+aFDh5rP27Ztk4MHD3qOh+NDdna2nHfeeea5U6dOlUGDBoXjsTwDAQQQCJkAS+CEjJaMEUCguwIxMTGiAdfzzz8vl156qezbt0/69+8vJSUlsnz5ctHzGpj16NFD9uzZ43nc6NGjRQPFXbt2ycyZMyUnJ8dc+49//EMOHz4sY8eOlZEjR5pjixcvlv3795t89VmaiouLZeXKlZ78EhMTj+mZLCsrk+rqf6/tOGrUKPnwww9ly5YtUl5ebnpAtQwkBBBAwKoCBIlWbTnKjYADBDQITE5ONjVNS0uTVatWyRtvvCHXXnutvP/++6I9h1VVVaLB33HHHWd+9GIN6nTtxWHDhomuLfj0009Lnz59TKCnvZMa0D311FOSnp4u3/jGN+TZZ58VHaJ+7733THCpeXknzW/w4MHeh6S2tvaoIDErK8sEl3qRBqL6nYQAAghYWYAg0cqtR9kRcJBAc3OzZwhZA0MNHnNzc2Xnzp1GQXsNW1tbjxLRdwN37Nhhjn311VeiP/n5+VJQUCBz5841xzVQ1PTRRx/J9OnTZfLkyfLxxx+bY+4/9HnvvPOO+6vP3xo0ugNaDSrr6up8XsdBBBBAwCoCBIlWaSnKiQACxwjosK72EG7atMlMFtGeR++kQ8I6gUXPa8+eTizRoWX9/uKLL5rhZvcEl7i4OFm4cKEkJCTINddcIxs3bvRkpfdqj6N3WrZsmWzdutVzSIe7tbdRg1L9XVpa6jnHBwQQQMCKAgSJVmw1yowAAkbgiy++kHnz5sn8+fOloqLimJ5EfbdwxIgR8s1vflN0uHrRokVmeFp7Hy+++GITEK5bt84EdL179zbvL1ZWVnqGjd3MGoz+5S9/cX/1+Xv9+vVy0UUXyYUXXmiGsZ977jmf13EQAQQQsIpATFFR0dHjM1YpOeVEAAFbCOjkDw3M3EO1XalUfHy8NDU1+b3V13ntOdTh6ZaWFs99+h6j9kbq0HZXU0pKinlfsav3B7rPvXdzr169Al3GOQQQQCAoAvQkBoWRTBBAIJICgQJELZev874CQe+Asav10XcTQ5W0fBrIkhBAAIFwCPCvTTiUeQYCCPgV0B69YARnfh9goxPqpL2iJAQQQCAcAgSJ4VDmGQgg4FdAh5k1UKyvr/d7DSfEBNIaJOpwNgkBBBAIhwBBYjiUeQYCCAQUyMjIMO8H6hqGpGMFNDjUIFqddHkdEgIIIBAOAcYtwqHMMxBAIKBAamqqedfu0KFDUlNTYyaPuCeRBLzR5ic1ONTJNfr+pAaImZmZNq8x1UMAgWgSIEiMptagLAg4WECHnXXNQw0StUdRA6RITtLo16+f2QbQ16SXcDWTGuhQvC74rb9JCCCAQDgFCBLDqc2zEECgXQHtVdSfSCfd/1kX3dY1EkkIIICAEwV4J9GJrU6dEUCgXQGdRczWeu0ycQECCNhYgCDRxo1L1RBAAAEEEEAAga4KECR2VY77EEDA1gL6XmR3doGxNQ6VQwABRwgQJDqimakkAgh0VkCXmmG4ubNqXI8AAnYSIEi0U2tSFwQQQAABBBBAIEgCBIlBgiQbBBBAAAEEEEDATgIEiXZqTeqCAAIIIIAAAggESYAgMUiQZIMAAggggAACCNhJgCDRTq1JXRBAIGgCMTEx7HISNE0yQgABKwoQJFqx1SgzAgiEXMC9Z3LIH8QDEEAAgSgVIEiM0oahWAgggAACCCCAQCQFCBIjqc+zEUAAAQQQQACBKBUgSIzShqFYCCCAAAIIIIBAJAUIEiOpz7MRQCDqBLKyskyZ6uvrzbZ8BQUFoj8kBBBAwGkCBIlOa3HqiwAC7QoUFhZKUlKS5OXlmWtLSkravYcLEEAAAbsJECTarUWpDwIIdEugvLzc3J+amioDBw7sVl7cjAACCFhZgCDRyq1H2RFAICQC7p7D0tJScX8OyYPIFAEEEIhigfgoLhtFQwABBwrou4ANDQ3S0tIisbGR+f/YyspKSUxMlMOHD4t+jlRyG2RkZESqCDwXAQQcLECQ6ODGp+oIRJOABoblBw9KrGunk4S4WIl3/cRJZIJEddm+udjwxLdGTqmpudkVMLdIqStQTU9Pl8zMzMgVhicjgIDjBAgSHdfkVBiB6BPQALHi0CHpkZIkfbIIhNq2UEVtrew7XC1Vrp5VDRZJCCCAQDgEIve/6eGoHc9AAAFLCFQcPiSpifEEiH5aKzMlRfq6gucqV49iU1OTn6s4jAACCARXgCAxuJ7khgACnRTQXkQNfPpl9+jknc66PC0pUZLi46TW1atIQgABBMIhQJAYDmWegQACfgU0QExOSPB7nhP/Fkh1BYqNjY3/PsAnBBBAIIQCBIkhxCVrBBBoX+DIDN6Y9i/kCklw9SRKawRn0tAGCCDgKAGCREc1N5VFIPoEYlyzmTsSIvbomWWWpfGuwZARIyXB1QupPyNGn+R9ypafdea36A8JAQQQCIMAs5vDgMwjEECg6wL5xw2Sq79/g9TW1Eh6RqZs/GK9vPCXx6XZtTzMhZdeKf/9u3tcQWKifO3sc2TDurVdfxB3IoAAAggcJUCQeBQHXxBAINoE5lx8mbz0/LOy7tNVEhcXJwtuvlVOHHOKrF210lPUsn175ZHf3ev5zgcEEEAAge4LECR235AcEEAghAI9srKk/MAB8wTtPfzTQw8c87TMHj3liuu+J/91713m3JnnzJIJk6ZIfEK8fPzeclmy6GVzfMTok+Xrcy+UpKQkWbf6U1n01+ePyYsDCCCAAAJHBAgS+ZuAAAJRLbDkny/L9398m6xZ9YkUr18nn69ZfcwM35jYGMnIOLKEzihXL+PosePkP3/1c9frezHy7R/eLMXHr5ODZfvlgksvl/93z3+Irst41YLrZfxpk+WT91dEdf0pHAIIIBApASauREqe5yKAQIcEPl6xXO6+4zYp3bVTJk87S+783UPSt/8Av/cOHTlKPnz3HRNI6hqMD99/t2zfUiKDCk6QvD59Zcz4CXL6WWdLWnqGnHjyGL/5cAIBBBBwugA9iU7/G0D9EYhiAe0JTHQNDeuWfe+++br5OW/exTLxjKny4v8+7bPksa6t63RZnbYpPj5BDh8qNz96TgPJgwfK2l7GdwQQQACBfwnQk8hfBQQQiFoBDfh+dtf9ktu7j6eMqWlpUn7wyDuKnoNeH0o2bZRxRRPNULMenn/Vt2SAa4a09ibW19XJxvXr5bNPPnYNOR92LamT5HUnHxFAAAEEvAXoSfTW4DMCCESVgE5Uef4vj8n3b7ldDpcfNEPEe/fskZdds539pdUffyiDTxgit/32HjMb+suNxbJ7x3bXGtSt8sYri+RHd9wp9fX1prfx8f/6vb9sOI4AAgg4XiCmqKiI5fsd/9cAAAQiJ1BdXS0t9bWSn5PltxA67JyV3Uuqq6tMb6DfC71O6HI5uvB0s2vbv7YpKTm5w/m0vTeS3w9V18rB2gbJzs6OZDF4NgIIOESAnkSHNDTVRMDKAtoL2Nn3B7UX0l/SYWcSAggggEBgAd5JDOzDWQQQQAABBBBAwJECBImObHYqjQACCCCAAAIIBBYgSAzsw1kEEEAAAQQQQMCRAryT6Mhmp9IIRJdAXWOT7K+oiq5CRWFpahsapfXYJSCjsKQUCQEE7CBAkGiHVqQOCFhcoLG5RQ5WM5mkvWbURcLj4/lnuz0nziOAQHAE+NcmOI7kggAC3RDQRbOTXDurkAILNDY2ilqREEAAgXAI8K9NOJR5BgIIIIAAAgggYDEBgkSLNRjFRQABBBBAAAEEwiFAkBgOZZ6BAAIIIIAAAghYTIAg0WINRnERQCAyAsOHD5eMjAyfDx8/frxrB8AYn+c4iAACCFhVgCDRqi1HuRFAIKwCJ554olRWVnqeOXjwYE/QWFtbK0OHDvWc4wMCCCBgBwGCRDu0InVAwGECU6dOle985zudqrX29N15550yZMiQTt2nFw8cOFB27txp7tNZ2BdccIFMnz5d+vbta45t2LBBRo4caT7zBwIIIGAXAZbAsUtLUg8EbCiggd3s2bNl2LBhosu/vPrqq6K9dhMnTjTrBV522WXyzDPPyIwZM2TMmDHS3Nwsb731lqxevVrOPvts6dWrl2RlZcmqVatk0KBBZkh47ty5snDhQpPf+eefL6mpqbJ9+3b5+9//Lk1NTT4VNe8lS5aYc7pO4dKlS+Wkk07yXKvPLS8vl5ycHCkrK/Mc5wMCCCBgZQF6Eq3cepQdAZsLZGdny7hx40wg+NJLL0lCQoKUlpaaoG///v0msEtMTJSamhp59NFH5YMPPhDtZdSUnJws+fn5JrBcv369LFq0yBx/7bXXZMeOHVJUVCQHDhyQBx980ASJGiz6SvpMXZuwvr7enK6urjYBYdtr161bJyeffHLbw3xHAAEELCtAkGjZpqPgCNhfQHvn1qxZI9dee63MmjVL4uLiTG9hQ0OD+a29iq2trZKZmSmXXHKJ6T3s0aOHB0aDwW3btokGdnV1R3Z00Xu05+/TTz+V3r17y09+8hMTTPrrRdQeTH1ue4tYH3/88bJlyxbPs/mAAAIIWF2AINHqLUj5EbCxgPbubdq0Se677z4pKSmRadOmmdrq9nTaU6jBm04gGTt2rDz++OPy+uuve4JBvVADSHfSz3pfWlqaOaRD2S+88ILpgdT3FANNPOnIO4c6nL1161b34/iNAAIIWF6AdxIt34RUAAH7CmiP4YQJE2TmzJmmJ++dd94xlS0uLjbvIF5zzTXy3HPPmVnHN910k+zbty/gUjQrV640PZJVVVXmXcSLLrrIBJU67Lx582a/kPo8fZdRh619Je1FJED0JcMxBBCwskCM672cf/+vtpVrQtkRQMCSAjoUrEvLaM+gv6TvHepwsPYEeiftDXT3FuqEEn9Dxv7u0fs1b/f7ht7Xtf182mmnmSCxoqKi7SnTw7l8+XIzGeaYk0E84N67WSfkkBBAAIFQCxAkhlqY/BFAIKBAR4LEgBk46CRBooMam6oiEAUCvJMYBY1AERBAAAEEEEAAgWgTIEiMthahPAgggAACCCCAQBQIECRGQSNQBAQQQAABBBBAINoECBKjrUUoDwIIRFxAZ1T7S4HO+buH4wgggIAVBQgSrdhqlBkBBNoV0GBu8uTJ7V7X9gJdR1F3enEnXYtxxIgRnsW09Zx7rUX3NfxGAAEE7ChAkGjHVqVOCCAgffr0kQEDBnRaQrcB1N1YNOXl5cn8+fPNOo26xI4mPafXkBBAAAG7C7CYtt1bmPohYHEBDchOP/10s0bi22+/LWvXrjXb7+lagRkZGWZ9xVdeecVsiTds2DAT0Om6h7q0ji4Zo0mDxfPPP98soL19+3az57OvNRV1673c3Fx59913PWp//etfzZZ/7gO6YPeUKVNMz2LbdRvd1/AbAQQQsIMAPYl2aEXqgIBNBXQf5tmzZ8vChQvlpZdekjlz5khSUpIJDLWnUI8dOnRITj31VCNw3nnnmZ1P/vGPf5heQDeLa9MA0V1VHnzwQdEgUbf785V0iz/d69mdNCDUXV/aJr1GryUhgAACdhYgSLRz61I3BCwu0Lt3b7PNngZ/X//6103vnft9wT179sj+/ftN0JeZmWmCx/T0dNPTqOe8t8nTIWLN6yc/+Ynk5+f73Zll165dHRqi1p5JvZaEAAII2FmA4WY7ty51Q8DiAtr7p9vuPf/881JTUyMjR46UgwcPmlq5t+NzV1GHmGtra+WEE04wwaMGctoTqEm333vhhRfM9nvXXXedDB06VD777DP3rZ7fmof+6DC2bhXoK2lA6r7O13mOIYAAAnYRIEi0S0tSDwRsKKBB4rJly+S73/2uCfS++OILn8Gdu+pLliyRc845R8aOHesJJvWczka+6KKLpK6uzgw7b9682X3LMb9Xrlwp48ePl6VLlx5zTg8UFhaKXkNCAAEE7C7A3s12b2Hqh0CUC3Rk72ZdhkYnlbgnogSqkl6nvYxtexq1NzExMdH0Aga6X8/NnDlTFi9e7POyQOd83hDEg+zdHERMskIAgXYFCBLbJeICBBAIpUBHgsRQPt9KeRMkWqm1KCsC1hdg4or125AaIIAAAggggAACQRcgSAw6KRkigAACCCCAAALWFyBItH4bUgMEEEAAAQQQQCDoAgSJQSclQwQQsKqATm7R2cu+ki6LM3z4cF+nOIYAAgjYUoAg0ZbNSqUQQKArArp+oi6T4066dE5BQYH5qusmnnjiie5T/EYAAQRsL0CQaPsmpoIIINBRAV2se8OGDebyESNGyKxZs+Sss87y3L5z504ZOHCg5zsfEEAAATsLxLl2JbjTzhWkbgggEN0CuqyL7o8cH+97bf8ZM2bIhRdeKBMnTjQ7qnz11Vdy/vnny6hRo2TTpk1moW3NQ3v6Lr74YrOYtgZyeq65udkMH8+fP18mTZokCQkJZhs/XyK5ublmpxX3dn7Jycny4YcfmoW5V61aZW4pKyuTyZMny8aNG31lEfJjLS0tZlFxf3tPh7wAPAABBBwlQE+io5qbyiJgLQFd/Fq343v00Uflgw8+kKlTp5oKvPvuu6I9fXPmzBENnNatWyfTp083i20/8MADZuHtM844w1z7ta99zQR7jz/+uFlIW9879JVOOukkk4/7nO7N3HZBbt2OTxfr1mCThAACCNhdwPf/utu91tQPAQQsIaBBmu6VfMkll0ifPn08Zdb9m9esWSPjxo0z+zproDh69GgTvH3rW98y1+o+zpref/99Of300+W0004LuKXfli1b5Pjjjzfb9nke1OaDBoi6+4v2XJIQQAABuwvQk2j3FqZ+CFhYYPDgwWa4V3sBX3/9dc+kEp1Qou8P6tCwBn/aO1hcXGyCwEceeUSeeOIJs7+yBnU6DK3HXn31VZkyZYoJOn2RaF6DBg3ydcpzzPudRc9BPiCAAAI2FSBItGnDUi0E7CBQWlpqgrybbrpJdOaxe6hY90/WoO6FF14QfZfwlFNOkTfffFP69esnt956q3mHUd9H1B7G/Px8WbBggZx77rmydu1aOXz4sF8azVN7E/0lXQJHg1ESAggg4AQB9m52QitTRwSiWKAjezfrpJampqYO1SIpKcm8e+h9sQ4Ra69ie8PE+q6h9jYuXbrU+3bzWYe9dbKMDl9HKmn5tR69evWKVBF4LgIIOEiAINFBjU1VEYhGgY4EidFY7kiUiSAxEuo8EwHnCjDc7Ny2p+YIIIAAAggggIBfAYJEvzScQAABBBBAAAEEnCtAkOjctqfmCCCAAAIIIICAXwGCRL80nEAAAQREdEZzRkaGT4rx48d7Zlz7vICDCCCAgIUFCBIt3HgUHQEEQi9w4oknmmV43E/StRvdQaMu2K1L85AQQAABOwoQJNqxVakTAjYX0O35vvOd74S8lroH9M6dO81zdGmdCy64wGz/17dvX3Nsw4YNZlHvkBeEByCAAAIREGBbvgig80gEEOiYgC6ePXv2bBk2bJhZ41B3TdHeu4kTJ4qunXjZZZfJM888Y7bn0633dPHst99+2yyarXs7n3nmmbJ7924ZMmSI2Y1Fd23R3Vouuugi6d27t5SXl8vf/vY30W3+fKUxY8bIkiVLzCl9nq6fqHs8u5Mu2K155OTkSFlZmfswvxFAAAFbCNCTaItmpBII2FMgOzvbBIAaCL700ktmb2bdhWXVqlWyf/9++fvf/y49evQwgeTChQvNNXPmzBHt9dOFsXU3lpKSEnnllVdk0qRJMmDAANHgUYO63//+9/LBBx9IamqqTzy9Xxeurq+vN+d1PUcNCNumdevWycknn9z2MN8RQAABywvQk2j5JqQCCNhXQIOyNWvWyLXXXmt6+5YvXy7ae9fQ0GB+a6+ibrunPY7nnXeegdDAToNLTXqdbsWnSa/V4HDTpk2iPYS33HKL6WVcvHixOd/2D1242r1Ti/ZQ+ku6jd+WLVv8neY4AgggYFkBehIt23QUHAH7C2gvnwZ19913n+kRnDZtmqm0Bm3JyckmiDtw4IC0trbK888/L0888YS8/PLLnuHjxMREOe6440wPYkpKihw6dEj09zvvvCP/+Z//aYLLCRMm+IXsyDuHgwYNMvtI+82EEwgggIBFBehJtGjDUWwEnCCgPYEaxM2cOdMM/Wpwp6m4uNj0Bl5zzTXypz/9SZYtWybf/e53TdD3xRdfmPcP9TodKj7jjDNEe/vWr18v27dvl7y8PDM8rYGl9hTqe4r+kj5n7ty55l5f12i+W7du9XWKYwgggIDlBdi72fJNSAUQsLZAR/Zu1h7BpqYmMzHFu7Y6zKzBnib30LAOE2vSCSbnnHOO3HvvvWaSi97vnbQnsq6uzvuQz8+nnXaaCRIrKiqOOa89mzoE7n7mMRcE+QB7NwcZlOwQQCCgAD2JAXk4iQAC0SCgPYq+kjtA1HP6rqL+uJPOWNb3GTW1DRD1WEcCRL3u/fff118+k852DmfSYXZ955KEAAIIhEOAIDEcyjwDAQT8CmgPYKCJIX5vbOfErl27RH/slNRJl+IhIYAAAuEQ4H9Jw6HMMxBAwK+AewKKe6kZvxc6/IQGiPqjE29ICCCAQDgECBLDocwzEEAgoIBuc6dDx/6GlQPe7ICTGhxqEK1O+n4mCQEEEAiHAOMW4VDmGQggEFBAl7rRd+10iZqamhozS1m/68QUJycNDjV41nctNUDMzMx0Mgd1RwCBMAsQJIYZnMchgIBvAR127tOnjwkStUdRA6RITtLo16+f7Nu3z+ekF981CP5RNdB3NtPT083v4D+BHBFAAAH/AgSJ/m04gwACERDQXkV/W+WFszijR482C3n72oovnOXgWQgggECkBHgnMVLyPBcBBKJaQGcRd3SZnKiuCIVDAAEEuihAkNhFOG5DAAEEEEAAAQTsLECQaOfWpW4IINBlAX0vUt+TJCGAAAJOFSBIdGrLU28EEAgooEvNMNwckIiTCCBgcwGCRJs3MNVDAAEEEEAAAQS6IkCQ2BU17kEAAQQQQAABBGwuQJBo8wameggggAACCCCAQFcECBK7osY9CCCAAAIIIICAzQUIEm3ewFQPAQS6JqBbAupuJyQEEEDAqQIEiU5teeqNAAIBBdx7Jge8iJMIIICAjQUIEm3cuFQNAQQQQAABBBDoqgBBYlfluA8BBBBAAAEEELCxAEGijRuXqiGAAAIIIIAAAl0VIEjsqhz3IYCALQWysrJMverr6822fAUFBaI/JAQQQMBpAgSJTmtx6osAAu0KFBYWSlJSkuTl5ZlrS0pK2r2HCxBAAAG7CRAk2q1FqQ8CCHRLoLy83NyfmpoqAwcO7FZe3IwAAghYWYAg0cqtR9kRQCAkAu6ew9LSUnF/DsmDyBQBBBCIYoH4KC4bRUMAAQT8CjQ1NUlFRYXoeoaJiYl+r+vKicrKSpPn4cOHRT8HMzU0NJhFupOTk807j8HMm7wQQACBYAoQJAZTk7wQQCAsAmVlZdLY2GiepTujNDc3B/2569atC3qemqGWVQPburo6EyxmZ2ezs0tIpMkUAQS6K0CQ2F1B7kcAgbAKHDx40ASI+s6gBohWTrW1tbJ//37JycmR+Hj+ObZyW1J2BOwowDuJdmxV6oSATQWqq6tND1xaWprlA0RtopSUFGlpaRGtFwkBBBCINgGCxGhrEcqDAAJ+BbTnLS4uzu95K57QdxOrqqqsWHTKjAACNhcgSLR5A1M9BOwkoO8h6vqFdkruYWadiENCAAEEokmAIDGaWoOyIIBAuwI66cOOya71smNbUScEnCJAkOiUlqaeCNhEwOqTVXw1g9bJjvXyVVeOIYCAdQQIEq3TVpQUAQQ6IKD7LL/88suSm5vbgauPvSQ2Ntbcf+qppx5z8he/+IXceuutxxznAAIIIGBHAYJEO7YqdULAwQJnnHGG7N27V04//fRuKcyfP/+o+3v16iVjx44VnTxDQgABBJwgQJDohFamjgg4REB7AbUH8De/+Y1MmTLlqFrff//9ooHfY489Jn379pVBgwbJvffeK4888ohceeWVcvfdd0tGRoa558CBA6ITSTQwdKczzzxTPvnkE/dXs1vKj3/8Y3P/ww8/LOPHjzfn9Blz5swxn7VX84477mAo2aPGBwQQsJIAQaKVWouyIoBAQIGTTjpJtmzZIrt27ZKamhoTCLpv6Nmzp9li79prr5U9e/aIBnjPPvusLFiwQIqLi2X48OFHBXNvvPGGTJ8+3dyu7wtq0PnOO++4s5P8/HxZu3atuf+ee+4RzVeTDnVPmzZN+vfvL9/+9rfl6aefNjuseG7kAwIIIGARAYJEizQUxUQAgfYFzjrrLFm/fr1oQKi/tffPOy1btsx8zcrKMustapCn6aOPPhLdycU7LV++XCZNmmQCxzFjxsimTZuOWvR68+bN5pg+s7CwUHr37m1u1+32Hn30Ubnrrrvk008/lW3btnlny2cEEEDAMgLsA2WZpqKgCCAQSCAxMVEmT54seXl5MnHiRBMoDhgwQJ544glPT57ubqJJAzldxNqdtKdQdz/xTvru4YYNG8x7iBoIvvTSS6JbAbrT2WefbYLQt956y/Rcuo/rb91BRRf9du8v7X2OzwgggIBVBOhJtEpLUU4EEAgooO8ivvvuu3LLLbfIz3/+c7n++uvNcPCoUaOOuU8DwJKSErn66qtlyJAhZqhY32dsm5YsWSIXXnihmSmtPYneafTo0fLqq6/K66+/boaxm5ubzWkNDr///e+bdxGnTp0qGqiSEEAAASsKHPuvohVrQZkRQMDxAjqrecWKFUc56Hc97is98MADpsdv9uzZZkKKTlZpmzSQ1B5K7S1smxYvXiyXX365mfyiPZj19fXmknnz5snq1atl69atphfzhhtuEF8BaNv8+I4AAghEm0BMUVGRPbcviDZpyoMAAt0W0AknOiwcjKBLg8NVq1ZJaWmp6e3TGdHXXHONZ2i6I4XVYWrdJlCHr7uTdO9mHSZ3b9HXnby4FwEEEAiWAO8kBkuSfBBAICwCwdq+TmdA33777Z4ZzX/4wx86FSBqZbUs3Q0Q3fkEq15haQQeggACjhCgJ9ERzUwlEbCHwL59+0xFvCeddLdm2hsYyQBN12PU5Xp07UZ9n5GEAAIIRIsA7yRGS0tQDgQQaFdAg0P3BJF2L+7gBZEMELWI+i6jDqETIHawwbgMAQTCJkCQGDZqHoQAAt0VyMzMlISEhKPWK+xunpG8X2dZa5DqvbROJMvDsxFAAAFvAd5J9NbgMwIIRL1ATk6O7N+/3wSKOlSsP1bqhdPhZXfScuvC3zr5hYQAAghEmwBBYrS1COVBAIF2BXJzc0V74fRdPl0gOxRBos421mVxQjG8rYGtDjGnpaW1W1cuQAABBCIlQJAYKXmeiwAC3RLQIEt/QpXGjRsnGzdulPLy8lA9gnwRQACBqBbgncSobh4KhwACkRLQ3slgLG8TqfLzXAQQQKC7AgSJ3RXkfgQQQAABBBBAwIYCBIk2bFSqhAAC3RdobGyUYK7H2P0SkQMCCCAQXgGCxPB68zQEELCIgC61w3CzRRqLYiKAQEgECBJDwkqmCCCAAAIIIICAtQUIEq3dfpQeAQQQQAABBBAIiQBBYkhYyRQBBBBAAAEEELC2AEGitduP0iOAAAIIIIAAAiERIEgMCSuZIoCA1QV0V5TExESrV4PyI4AAAl0WIEjsMh03IoCAnQVaW1uloaHBzlWkbggggEBAAYLEgDycRAABBBBAAAEEnClAkOjMdqfWCCCAAAIIIIBAQAGCxIA8nEQAAQQQQAABBJwpQJDozHan1ggg4EegoKDAnNHdVnRbPv3uPubnFg4jgAACthQgSLRls1IpBBDojkBhYaEJEPPy8kw2JSUl3cmOexFAAAFLChAkWrLZKDQCCIRKQAPCrKwsSU1NlYEDB4bqMeSLAAIIRL0AQWLUNxEFRACBcAts2bLFPLK0tFToRQy3Ps9DAIFoEYiPloJQDgQQQEAFdG1C/WlpaZHY2Mj8f+yaNWukvr5eysvLpaqqKmIN4zZIT0+PWBl4MAIIOFeAING5bU/NEYgqgcbGRjlYflBaXaWKSYiT2PhYiYmJTJCoMOu+3CAtzS3SGqMlikxqaW2WlrpmqaiqlPTUNMnMzIxMQXgqAgg4UoAg0ZHNTqURiC4BEyAePiRxaUmS3rdXdBUuCkpTf6hKag5WSlx1nKSlpUVBiSgCAgg4QSBy/5vuBF3qiAACHRIo1wAxOYEA0Y9WUs90Sc3LMj2KTU1Nfq7iMAIIIBBcAYLE4HqSGwIIdFJAexGbm5slvR89iIHoEtOTJdY1DF9bWxvoMs4hgAACQRMgSAwaJRkhgEBXBDRI1OCH1L5AfEqSNLi8SAgggEA4BAgSw6HMMxBAwK+AzuCNieOfIr9AXic0mG5tjdxEGq+i8BEBBBwgwL/MDmhkqohANAvExMS4ZjHHtFtEvaZXz6wOXesrs6wePWXQAGsvjh3jWhKoI1a+6s8xBBBAoLMCzG7urBjXI4BA2AXmzJglM6ZMk8rqKsnrlSN/X/xPWfTmawHL0Sc3T4YXDJV3Plxhrhs6+AQZM3K0/PF//xzwPk4igAACCBwRIEjkbwICCES1wMSxE2TyuCL58V13SFVNtWS4Fpb+j5vvkN1flcqq9Wv8lj03O0dOHVPoCRL9XsgJBBBAAAGfAgSJPlk4iAAC0SIw8/Rp8tjCp02AqGWqdO2A8uDj/y2ZGRmmiP1695EFl14jPTN7uJaIqZL/evJ/pMX13t635l0uPVyLT//6pp/KLx68y1ybmpIit153oxl2Xr/xC3n02Sek2fVOZK6rd/K6S66WnKxs2blntzz89ONSW1crV114idS7dn8pOqVQXnT1Xi776D2TD38ggAACThDgnUQntDJ1RMCiAvr+3cD++VKyfaupgX7Xrfq2l+6UtcWfm2MFAwfL8/98UX5w562uIG6FnO8amt5btk8edwWWxSWbPQGiXjx0UIE8/NSf5MZf3+bKd4CMHDLc5HHj1QvkpSWvyA9/fbus37RBrrrgYnM8LSVVeufkyo9++zMCRCPCHwgg4CQBehKd1NrUFQGLCcS6gsL4uDhpbDqy7MvEU8bLN2fPlcT4BPlq/1751UP3yXurPpIRrncPz54yVU4afmLAySmfby729Eh+vqlY9L3Fkh1bZcig4yW/3wDzo72NUydOkUdcvYyaPvj0Y7OOo8XoKC4CCCDQbQGCxG4TkgECCIRKQIeCD5SXS37f/rKjdJe87wrY9EffUxx/0inmsddf8W3ze/Xna2Xbrp2uIWP/i3I3eu1W4t65JD7uyD+D5YfLTT76+8EnHvFUqdm1fzMJAQQQcKIAw81ObHXqjICFBF5b9qZcMXe+JCUmmVKnJCfL16dOl1XrPjPfT3QNGT/78kJZ/skHrvcLm6W6tsYcr2uol8y09HZrWlFVKbv37pE9+/bKh6tXypYd2yU9NbXd+7gAAQQQsLsAPYl2b2Hqh4DFBd5Y8bZku9ZHfOiX98i+A2XSL6+PLFn+lhlm1qoteus1+c3NPzM9jtt37/TUVt9jbHIFjffd9iu55Z5feo77+vDQn/8o2iOpw9opScmuiTLP+LqMYwgggICjBGKKiopYvt9RTU5lEYgugerqaqlprpeMAbkBCxbnejdRh5IPlB+Upuamo65NiD/y/7vew8nuC+JcE1102LojSXspa+vqOnJpRK6pO1QlzYdqpVd2dkSez0MRQMBZAvQkOqu9qS0ClhVobm42s5Z9VcBXcOi+rqMBol4fzQGiuz78RgABBMIlwDuJ4ZLmOQgggAACCCCAgIUECBIt1FgUFQEEEEAAAQQQCJcAQWK4pHkOAggggAACCCBgIQHeSbRQY1FUBOwq0NzQJLUHK+1avaDVq6m2XmJaOzYJJ2gPJSMEEHCsAEGiY5ueiiMQPQLN9Y1SX1Yhuu0eybdAq2s/6hbXLO2EhATfF3AUAQQQCLIAQWKQQckOAQQ6L6DL2yS7lp8hBRZobGw0e1cHvoqzCCCAQHAEeCcxOI7kggACCCCAAAII2EqAINFWzUllEEAAAQQQQACB4AgQJAbHkVwQQAABBBBAAAFbCRAk2qo5qQwCCHRHYPjw4ZKRkeE3ixNOOEGy2RLPrw8nEEDAXgIEifZqT2qDgK0FZs2aJUOHDg1ZHU888USprDyyFE9aWpqMGTNGRowYITqxRtPevXtl3LhxIXs+GSOAAALRJECQGE2tQVkQQCCgQEFBgWRlZfm9ZtCgQXLnnXd2aZmYgQMHys6dO03eSUlJcuGFF5qAUWddn3/++ea4BpApKSmSmJjotwycQAABBOwiwBI4dmlJ6oGATQW+9rWvyfjx42X79u1HLf8yY8YM09PX3Nwsb731lqxevVq++c1vmrUWf/jDH8of/vAH0eHj6dOniwZ969atk1deecWvkvYaLlmyxJzXPP/6179KTU2NpKeni/YwutPatWvl5JNPlk8++cR9iN8IIICALQXoSbRls1IpBOwhkJOTI1OnTpWlS5fKmjVrpEePHqZi2pOnAdyjjz4qH3zwgblGTyxatMicf+yxx0TXFNTg8G9/+5s89dRTJtD01wupC1THxsZKfX29ub+pqcnkf/HFF8vll18ur732mjmuf2zbtk20x5KEAAII2F2AnkS7tzD1Q8DCAr169RLdaeTTTz81v93vC+qxzMxMueSSS6RPnz6eGtbV1ZnP1dXV5nd8fLzMnDlTUlNTzXcNGn0lDSj1vUMNFHVXE3d67rnnTP463Pz444+bw7m5uVJWVua+hN8IIICAbQXoSbRt01IxBKwvcOjQITN8rLOK+/bta4Z+tVaDBw+WsWPHmsDt9ddfF3dwqMPEmnTSiQaEGiC++eabsnDhQnM80B8bNmyQkSNHmkv0Waeccor5rJNVNNjUAFJTYWGhrFy50nzmDwQQQMDOAvQk2rl1qRsCFhfQAE3f/dMewz179oi7h7C0tNRMKrnppptk3759nj2fd+/eLbt27ZIbbrhB7r77bvnyyy9Fh4z1fUZNgfaGLi4ulrlz58r69etNnpMmTRKdKKO9kPq+o/Yw6iQWHZp292hanJfiI4AAAgEFYoqKiloDXsFJBBBAIIQCGvhp0BVo72btydP3BNsmf8c1GNQhaU3+rmmbl34/7bTTTJBYUVFhTmtAqL2T7iFoncCi59yzoH3lEcpj7r2bdRiehAACCIRagCAx1MLkjwACAQWqqqpEfwIFiQEzcNBJnVij707qhB4SAgggEGoB3kkMtTD5I4BAQAENetw9dQEv5KRx0p5REgIIIBAOAYLEcCjzDAQQ8Cugi1N7Lz/j90KHn9Dhcw2m3TO1Hc5B9RFAIAwCBIlhQOYRCCAQWED3S9YgSN+5Ix0roMGhDjWrE7u9HOvDEQQQCI0A4xahcSVXBBDohIAuWaO9iYcPHzaBon7Wn0CzkTuRvWUv1UkzGjzrpB1dF1J/SAgggEC4BAgSwyXNcxBAIKCADjvrj852bmhoMEOrGihGKuXl5cmBAwfM7OZIlUHrr+9sahCtM61JCCCAQDgFCBLDqc2zEECgXQENiPQn0mnChAlmp5fa2tpIF4XnI4AAAhERiNz/pkekujwUAQQQQAABBBBAoCMCBIkdUeIaBBBwnIBOFGHtRsc1OxVGAAEvAYJELww+IoAAAm4B3fvZvSe0+xi/EUAAAScJECQ6qbWpKwIIIIAAAggg0EEBgsQOQnEZAgg4S0DXJmS42VltTm0RQOBoAYLEoz34hgACCBgBXX6G4Wb+MiCAgJMFCBKd3PrUHQEEEEAAAQQQ8CNAkOgHhsMIIIAAAggggICTBQgSndz61B0BBBBAAAEEEPAjQJDoB4bDCCCAgNP3juZvAAIIOFuAINHZ7U/tEUAggEBra2uAs5xCAAEE7C1AkGjv9qV2CCCAAAIIIIBAlwQIErvExk0IIIAAAggggIC9BQgS7d2+1A4BBLohwGLa3cDjVgQQsLwAQaLlm5AKIIBAqARYTDtUsuSLAAJWECBItEIrUUYEEIgqgZ49e0pWVlZQy5SYmCj9+/fvdp5Dhw7tdh5kgAACCKgAQSJ/DxBAAIFOChx33HEyePDgDt+lwd8JJ5wQ8Pr09HQZN25cwGvaO6lbCfbo0UNYuqc9Kc4jgEBHBOI7chHXIIAAAggcLaC9iRdffLHoe4sffPCBFBcXmwvOPPNMGThwoDQ1Nclrr70muozOzJkzRQO43r17y3vvvWd+T5s2TVJSUmTjxo3mmN4cHx8v5513njn/2WefySeffHL0Q72+paWlyYwZMyQ1NVUOHjwoS5YskebmZhO86n2FhYXi7lXUXspVq1bJunXrPM9OSEiQ1atXm2Ne2fIRAQQQ8AgQJHoo+IAAAgh0XCA/P1+ee+45iYuLk/nz58v27dtNkHfo0CF56623ZNCgQTJhwgR59dVX5cMPP5TMzEwTTOoTNGj85z//KXrtueeeK3369JGGhgYTwD355JPS0tIiV111lXz66acm8PNVqtGjR8vmzZtNkKefNf/y8nITNOr1K1euND8aDM6ZM8dcq8enT59unl1VVSUXXXSR7Ny505RDz5EQQAABbwGCRG8NPiOAAAL/EtAhW+2Bq62t9WmiAZoGdpp27Nghubm55veXX34pI0eOlJycHNOj2PZmDeY0QNPeP02vvPKK+Z2dnS1fffWV1NTUmO/79++XjIwMvwHcgQMHpKioyPRUaln8TbI5/fTTTY+kntf8tJwawGrSXlDt3dRglYQAAgi0FeCdxLYifEcAAQRcAjpM7A4CfYHo0K476WftUezXr5/Mnj3bBJeHDx/2GbjpsLP2FPpKbfP0dY37mAaGixcvFh32vuyyy0xQ6j7n/u1+b3Lr1q3mkA5n6zB4fX29+dFh6X379rkv5zcCCCBwlABB4lEcfEEAAQQ6JqABmPY2anCo7yBqz58Gifpuor5PqD2C7l5BDcySkpJMxtprp4GdvkuoaeLEiaZ3z3zpxB/HH3+8NDY2yooVK+Tzzz83PYLet+v7juPHj5d3333Xc1ifXVlZKdu2bTPl1N5Fth708PABAQTaCDDc3AaErwgggEBHBCoqKmTevHkm+NuwYYMZQtah5vPPP98M5+r7ge6k7/2deuqpctppp8n7778v77zzjlxwwQWmV0/zKSsr6/SSOtrLqZNctMdS3zvUwNQ76cQVnTH9jW98wxzWSSs6SWb58uXmXUS9X4NE93C39718RgABBFQgxvVOCzvY83cBAQQQaCMwadIkM3HE3zuJern2JOrwsfcwsR7XoE17+domvd675849/Nv2Ou/vGli2TdpD6Q4K/T2r7T1tv3f1vrb58B0BBOwrQE+ifduWmiGAQDcENMjTiR2BgkQN+NoGiPpIXwGiHvcOEPW7DkO3l3bv3n3MJd75e38+5sIAB7p6X4AsOYUAAjYTIEi0WYNSHQQQCI6A9rT5mzEcnCd0LBddWoeEAAIIREKAiSuRUOeZCCCAAAIIIIBAlAsQJEZ5A1E8BBBAAAEEEEAgEgIEiZFQ55kIIIAAAggggECUCxAkRnkDUTwEEIiMgM5E1okrJAQQQMCpAgSJTm156o0AAgEFdCZyNExcCVhITiKAAAIhFCBIDCEuWSOAAAIIIIAAAlYVIEi0astRbgQQQAABBBBAIIQCBIkhxCVrBBCwtoDuy0xCAAEEnCpAkOjUlqfeCCDQroCv3VTavYkLEEAAAZsIECTapCGpBgIIBEegoKDgqIz0e9tjR13AFwQQQMCmAgSJNm1YqoUAAl0XKCwslPr6ejn++ONNJiUlJV3PjDsRQAABiwoQJFq04Sg2AgiERkADwqysLPPTr1+/0DyEXBFAAAELCBAkWqCRKCICCIRXYMuWLeaBO3bsEHoRw2vP0xBAIHoE4qOnKJQEAQQQ6JpAQ0OD1NTUiE40SUpK6lomXnetWbPGDDeXl5dLVVWV15mufWxpaZHY2FhJTEw0P13LhbsQQACB8AoQJIbXm6chgECQBcrKyhNNSOoAAArGSURBVESDMHcg1tjYGJQnrFu3Lij5aCbu8lVXV5s8s7OzJSEhIWj5kxECCCAQCgGCxFCokicCCIRcQAMvDRC1hy4nJ8f8DvlDg/AA7Z3UH33vkUAxCKBkgQACIRPgncSQ0ZIxAgiEUkB75TRQtFKAqB4aHMbHx8uhQ4dCyUPeCCCAQLcFCBK7TUgGCCAQCQF9VzAjIyMSj+72M3W4uampSYI1NN7tApEBAggg4EOAINEHCocQQCC6BbQHsbW1VdLS0qK7oAFKp72JBIkBgDiFAAIRFyBIjHgTUAAEEOisgDtI7Ox90XS9vkup9SAhgAAC0SpAkBitLUO5EEDAr4AGWHZIdqmHHdqCOiCAwLEC9viX9th6cQQBBBDolEDv3r1lypQpnbqn7cUxMTFywQUXtD3MdwQQQMCSAgSJlmw2Co0AAsEW0FnS48eP71a2GiTOmDGjW3lwMwIIIBAtAnEDBgy4M1oKQzkQQACBjgjopBWd3ZyZmenzcp0Ucu2118q8efNM76CuS7h3717p37+/XHXVVfLxxx+b+4qKimTcuHFm3cIFCxaY82PGjJF3331XLr30UjnuuOPM71mzZklycrJs3LjR3HfPPffIm2++aT5rcPm9731P3n//fbnlllukb9++onl8+eWXUlFR4bN8erC2ttask8haiX6JOIEAAhEWoCcxwg3A4xFAIPgCGhzqOoS33XabPPTQQ3LllVdKjx49JC4u7qhlc3SbvNTUVNm3b5889dRTsmnTJvntb39rCqQzp08++WTz/ac//akJJkeNGmXO9ezZ01Nofa/QHazef//9Zju/O++8U3bt2uW5hg8IIICAFQUIEq3YapQZAQQCCowcOVLefvtts0zOgQMHpLi4WAoKCgLe4+uk9ijqMjW6N/SKFStk+PDhvi7jGAIIIGBLAYJEWzYrlULA2QLaY9jc3OxB0M96TIepvWcUe3/2XOz1oW0eOoytyTuf9vLwyo6PCCCAgKUECBIt1VwUFgEEOiKgw8YTJkwwl+pw8ogRI6SkpMS8e5ifn2+2xdOTw4YN82RXX18v6enpnu/6Qd9Z1KQTUjQ/fc9Qk77jePzxx5vPQ4cONb/1Dw0eNSUlJZnf/IEAAghYWYCJK1ZuPcqOgEMF2pu4okHi7NmzzUzjadOmyaJFi8ykEx027tWrl1xzzTVSWFhoJo/U1dXJ+vXrzTuMkyZNMvcsXbrUvINYWVlplrQ555xzZOvWrfLqq68acZ10ct1115lrNIDUbfZ0eFuTBpo66UWHuJm4Ykj4AwEELCoQ4/o/5SP/62vRClBsBBBwnoDuVLJnzx4zGzlQ7XViigaGbZMe16Fk7+Fk9zXuoervfOc7snLlSvnss8/MUHXbLfT0Ov3xlb8OQbe3m4q+K5mSkmImzrifzW8EEEAgmgSOvGATTSWiLAgggEA7AhqAaQ9ee8lXAKf3+Duu59yBow4/NzU1mWDPV8DnL8jUPHxdr8e9k/aGduQ673v4jAACCIRTgCAxnNo8CwEEgiLgniyiw77aGxeK9OSTT4YiW0+eGoBqTyQJAQQQiFYBJq5Ea8tQLgQQ8CugQaIGh/rOoBWTvquoPaGhCnCtaEKZEUAg+gQIEqOvTSgRAgh0QEBnLetwrc40tlLSnWJ0skzbmdRWqgNlRQABZwgw3OyMdqaWCNhOQJeZ0VnF2iunO6a4h26jcfkZDWb1HUad/KLvIuoOLfQi2u6vJBVCwHYCBIm2a1IqhIBzBHSWsu6dXF1dbZaz0WCs7SzkaNDQcukQufYeag8oCQEEELCCAEGiFVqJMiKAQEAB3WdZf0gIIIAAAsET4J3E4FmSEwIIIIAAAgggYBsBgkTbNCUVQQABBBBAAAEEgidAkBg8S3JCAAEEEEAAAQRsI0CQaJumpCIIIIAAAggggEDwBAgSg2dJTggggAACCCCAgG0ECBJt05RUBAEEEEAAAQQQCJ4AQWLwLMkJAQQQQAABBBCwjQBBom2akooggAACCCCAAALBEyBIDJ4lOSGAAAIIIIAAArYRIEi0TVNSEQQQQAABBBBAIHgCBInBsyQnBBBAAAEEEEDANgIEibZpSiqCAAIIIIAAAggET4AgMXiW5IQAAggggAACCNhGgCDRNk1JRRBAAAEEEEAAgeAJECQGz5KcEEAAAQQQQAAB2wgQJNqmKakIAggggAACCCAQPAGCxOBZkhMCCCCAAAIIIGAbAYJE2zQlFUEAAQQQQAABBIInQJAYPEtyQgABBBBAAAEEbCNAkGibpqQiCCCAAAIIIIBA8AQIEoNnSU4IIIAAAggggIBtBAgSbdOUVAQBBBBAAAEEEAieAEFi8CzJCQEEEEAAAQQQsI0AQaJtmpKKIIAAAggggAACwRMgSAyeJTkhgAACCCCAAAK2ESBItE1TUhEEEEAAAQQQQCB4AgSJwbMkJwQQQAABBBBAwDYCBIm2aUoqggACCCCAAAIIBE+AIDF4luSEAAIIIIAAAgjYRoAg0TZNSUUQQAABBBBAAIHgCRAkBs+SnBBAAAEEEEAAAdsIECTapimpCAIIIIAAAgggEDwBgsTgWZITAggggAACCCBgGwGCRNs0JRVBAAEEEEAAAQSCJ0CQGDxLckIAAQQQQAABBGwjQJBom6akIggggAACCCCAQPAECBKDZ0lOCCCAAAIIIICAbQQIEm3TlFQEAQQQQAABBBAIngBBYvAsyQkBBBBAAAEEELCNAEGibZqSiiCAAAIIIIAAAsETIEgMniU5IYAAAggggAACthEgSLRNU1IRBBBAAAEEEEAgeAIEicGzJCcEEEAAAQQQQMA2AgSJtmlKKoIAAggggAACCARPgCAxeJbkhAACCCDw/9utYxoAAACEYf5dY4JrqQESygMBAgQyAk5iZkpFCBAgQIAAAQI/ASfxZymJAAECBAgQIJARcBIzUypCgAABAgQIEPgJOIk/S0kECBAgQIAAgYyAk5iZUhECBAgQIECAwE/ASfxZSiJAgAABAgQIZAScxMyUihAgQIAAAQIEfgJO4s9SEgECBAgQIEAgI+AkZqZUhAABAgQIECDwE3ASf5aSCBAgQIAAAQIZAScxM6UiBAgQIECAAIGfgJP4s5REgAABAgQIEMgIOImZKRUhQIAAAQIECPwEnMSfpSQCBAgQIECAQEbAScxMqQgBAgQIECBA4CfgJP4sJREgQIAAAQIEMgJOYmZKRQgQIECAAAECPwEn8WcpiQABAgQIECCQEXASM1MqQoAAAQIECBD4CTiJP0tJBAgQIECAAIGMgJOYmVIRAgQIECBAgMBPwEn8WUoiQIAAAQIECGQEnMTMlIoQIECAAAECBH4CTuLPUhIBAgQIECBAICPgJGamVIQAAQIECBAg8BNwEn+WkggQIECAAAECGQEnMTOlIgQIECBAgACBn4CT+LOURIAAAQIECBDICDiJmSkVIUCAAAECBAj8BJzEn6UkAgQIECBAgEBGwEnMTKkIAQIECBAgQOAn4CT+LCURIECAAAECBDICTmJmSkUIECBAgAABAj8BJ/FnKYkAAQIECBAgkBFwEjNTKkKAAAECBAgQ+Ak4iT9LSQQIECBAgACBjICTmJlSEQIECBAgQIDAT8BJ/FlKIkCAAAECBAhkBJzEzJSKECBAgAABAgR+Ak7iz1ISAQIECBAgQCAjMOcXwdcGhnZMAAAAAElFTkSuQmCC"
},
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## Random forest\n",
"\n",
"\n",
"Sklearn based models are slightly finicky to get into a suitable onnx format. By default most tree based models will export into something that looks like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Processing such nodes can be difficult and error prone. It would be much better if the operations of the tree were represented as a proper graph, possibly ... like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"This notebook showcases how to do that using the `sk2torch` python package ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"sk2torch\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.ensemble import RandomForestClassifier as Rf\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"from hummingbird.ml import convert\n",
"\n",
"\n",
"\n",
"iris = load_iris()\n",
"X, y = iris.data, iris.target\n",
"X = X.astype(np.float32)\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
"clr = Rf()\n",
"clr.fit(X_train, y_train)\n",
"\n",
"\n",
"\n",
"torch_rf = convert(clr, 'torch')\n",
"# assert predictions from torch are = to sklearn \n",
"diffs = []\n",
"for i in range(len(X_test)):\n",
" torch_pred = torch_rf.predict(torch.tensor(X_test[i].reshape(1, -1)))\n",
" sk_pred = clr.predict(X_test[i].reshape(1, -1))\n",
" diffs.append(torch_pred[0].round() - sk_pred[0])\n",
"\n",
"print(\"num diffs\", sum(diffs))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"# !!!!!!!!!!!!!!!!! This cell will flash a warning about onnx runtime compat but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"\n",
"# export to onnx format\n",
"\n",
"# Input to the model\n",
"shape = X_train.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=False)\n",
"torch_out = torch_rf.predict(x)\n",
"# Export the model\n",
"torch.onnx.export(torch_rf.model, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=11, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20, *shape, requires_grad=True).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/set_membership.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67"
},
"source": [
"## Hash set membership demo"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {
"id": "95613ee9"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"pytest\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"import logging\n",
"FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"logging.basicConfig(format=FORMAT)\n",
"logging.getLogger().setLevel(logging.DEBUG)\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" def forward(self, x, y):\n",
" diff = (x - y)\n",
" membership_test = torch.prod(diff, dim=1)\n",
" return (membership_test,y)\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# Train the model as you like here (skipped for brevity)\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {
"id": "b37637c4"
},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c833f08c",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "c833f08c",
"outputId": "b5c794e1-c787-4b65-e267-c005e661df1b"
},
"outputs": [],
"source": [
"# print pytorch version\n",
"print(torch.__version__)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {
"id": "82db373a"
},
"outputs": [],
"source": [
"\n",
"\n",
"x = torch.zeros(1,*[1], requires_grad=True)\n",
"y = torch.tensor([0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], requires_grad=True)\n",
"\n",
"y_input = [0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]\n",
"\n",
"# Create an empty list to store the results\n",
"result = []\n",
"\n",
"# Loop through each element in the y tensor\n",
"for e in y_input:\n",
" # Apply the custom function and append the result to the list\n",
" print(ezkl.float_to_felt(e,7))\n",
" result.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 7)])[0])\n",
"\n",
"y = y.unsqueeze(0)\n",
"y = y.reshape(1, 9)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" (x,y), # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=14, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array_x = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"data_array_y = result\n",
"print(data_array_y)\n",
"\n",
"data = dict(input_data = [data_array_x, data_array_y])\n",
"\n",
"print(data)\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {
"id": "d5e374a2"
},
"outputs": [],
"source": [
"run_args = ezkl.PyRunArgs()\n",
"# \"hashed/private\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
"run_args.input_visibility = \"hashed/private/0\"\n",
"# we set it to fix the set we want to check membership for\n",
"run_args.param_visibility = \"fixed\"\n",
"# the output is public -- set membership fails if it is not = 0\n",
"run_args.output_visibility = \"fixed\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"# never rebase the scale\n",
"run_args.scale_rebase_multiplier = 1000\n",
"# logrows\n",
"run_args.logrows = 11\n",
"\n",
"# this creates the following sequence of ops:\n",
"# 1. hash the input -> poseidon(x)\n",
"# 2. compute the set difference -> poseidon(x) - set\n",
"# 3. compute the product of the set difference -> prod(poseidon(x) - set)\n",
"\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {
"id": "3aa4f090"
},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "8b74dcee",
"outputId": "f7b9198c-2b3d-48bb-c67e-8478333cedb5"
},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {
"id": "18c8b7c7"
},
"outputs": [],
"source": [
"# now generate the witness file\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "Y94vCo5Znrim",
"metadata": {
"id": "Y94vCo5Znrim"
},
"outputs": [],
"source": [
"# now generate a faulty input + witness file (x input not in the set)\n",
"\n",
"data_path_faulty = os.path.join('input_faulty.json')\n",
"\n",
"witness_path_faulty = os.path.join('witness_faulty.json')\n",
"\n",
"x = torch.ones(1,*[1], requires_grad=True)\n",
"y = torch.tensor([0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], requires_grad=True)\n",
"\n",
"y = y.unsqueeze(0)\n",
"y = y.reshape(1, 9)\n",
"\n",
"data_array_x = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"data_array_y = result\n",
"print(data_array_y)\n",
"\n",
"data = dict(input_data = [data_array_x, data_array_y])\n",
"\n",
"print(data)\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path_faulty, 'w' ))\n",
"\n",
"res = ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path_faulty)\n",
"assert os.path.isfile(witness_path_faulty)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "FQfGdcUNpvuK",
"metadata": {
"id": "FQfGdcUNpvuK"
},
"outputs": [],
"source": [
"# now generate a truthy input + witness file (x input not in the set)\n",
"import random\n",
"\n",
"# Generate a random integer between 1 and 8, inclusive\n",
"random_value = random.randint(1, 8)\n",
"\n",
"data_path_truthy = os.path.join('input_truthy.json')\n",
"\n",
"witness_path_truthy = os.path.join('witness_truthy.json')\n",
"\n",
"set = [0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]\n",
"\n",
"x = torch.tensor([set[random_value]])\n",
"y = torch.tensor(set, requires_grad=True)\n",
"\n",
"y = y.unsqueeze(0)\n",
"y = y.reshape(1, 9)\n",
"\n",
"x = x.unsqueeze(0)\n",
"x = x.reshape(1,1)\n",
"\n",
"data_array_x = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"data_array_y = result\n",
"print(data_array_y)\n",
"\n",
"data = dict(input_data = [data_array_x, data_array_y])\n",
"\n",
"print(data)\n",
"\n",
"# Serialize data into file:\n",
"json.dump( data, open(data_path_truthy, 'w' ))\n",
"\n",
"res = ezkl.gen_witness(data_path_truthy, compiled_model_path, witness_path_truthy)\n",
"assert os.path.isfile(witness_path_truthy)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "41fd15a8",
"metadata": {},
"outputs": [],
"source": [
"witness = json.load(open(witness_path, \"r\"))\n",
"witness"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {
"id": "b1c561a8"
},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"# we force the output to be 0 this corresponds to the set membership test being true -- and we set this to a fixed vis output\n",
"# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
"witness = json.load(open(witness_path, \"r\"))\n",
"witness[\"outputs\"][0] = [\"0000000000000000000000000000000000000000000000000000000000000000\"]\n",
"json.dump(witness, open(witness_path, \"w\"))\n",
"\n",
"witness = json.load(open(witness_path, \"r\"))\n",
"print(witness[\"outputs\"][0])\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" witness_path = witness_path,\n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {
"id": "c384cbc8"
},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "XAC73EvtpM-W",
"metadata": {
"id": "XAC73EvtpM-W"
},
"outputs": [],
"source": [
"# GENERATE A FAULTY PROOF\n",
"\n",
"\n",
"proof_path_faulty = os.path.join('test_faulty.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path_faulty,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path_faulty,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path_faulty)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "_x19Q4FUrKb6",
"metadata": {
"id": "_x19Q4FUrKb6"
},
"outputs": [],
"source": [
"# GENERATE A TRUTHY PROOF\n",
"\n",
"\n",
"proof_path_truthy = os.path.join('test_truthy.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path_truthy,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path_truthy,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path_truthy)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {
"id": "76f00d41"
},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"assert res == True\n",
"\n",
"res = ezkl.verify(\n",
" proof_path_truthy,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4nqEx7-qpciQ",
"metadata": {
"id": "4nqEx7-qpciQ"
},
"outputs": [],
"source": [
"import pytest\n",
"def test_verification():\n",
" with pytest.raises(RuntimeError, match='Failed to run verify: The constraint system is not satisfied'):\n",
" ezkl.verify(\n",
" proof_path_faulty,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"# Run the test function\n",
"test_verification()"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/simple_demo_aggregated_proofs.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## EZKL Jupyter Notebook Demo (Aggregated Proofs) \n",
"\n",
"Demonstrates how to use EZKL with aggregated proofs"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch\n",
"\n",
"\n",
"# Defines the model\n",
"# we got convs, we got relu, we got linear layers\n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=5, stride=2)\n",
" self.conv2 = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=5, stride=2)\n",
"\n",
" self.relu = nn.ReLU()\n",
"\n",
" self.d1 = nn.Linear(48, 48)\n",
" self.d2 = nn.Linear(48, 10)\n",
"\n",
" def forward(self, x):\n",
" # 32x1x28x28 => 32x32x26x26\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
" x = self.conv2(x)\n",
" x = self.relu(x)\n",
"\n",
" # flatten => 32 x (32*26*26)\n",
" x = x.flatten(start_dim = 1)\n",
"\n",
" # 32 x (32*26*26) => 32x128\n",
" x = self.d1(x)\n",
" x = self.relu(x)\n",
"\n",
" # logits => 32x10\n",
" logits = self.d2(x)\n",
"\n",
" return logits\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# Train the model as you like here (skipped for brevity)\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"proof_path = os.path.join('test.pf')\n",
"settings_path = os.path.join('settings.json')\n",
"srs_path = os.path.join('kzg.srs')\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')\n",
"aggregate_proof_path = os.path.join('aggr.pf')\n",
"aggregate_vk_path = os.path.join('aggr.vk')\n",
"aggregate_pk_path = os.path.join('aggr.pk')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"shape = [1, 28, 28]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*torch.rand(1,*shape, requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20, *shape, requires_grad=True).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"for-aggr\", # IMPORTANT NOTE: To produce an aggregated EVM proof you will want to use poseidon for the smaller proofs\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0832b909",
"metadata": {},
"outputs": [],
"source": [
"# Generate a larger SRS. This is needed for the aggregated proof\n",
"\n",
"res = ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c5a64be6",
"metadata": {},
"outputs": [],
"source": [
"# Run mock aggregate to check whether the proof works\n",
"# Use mock to check for validity as it takes a shorter time to check compared to a full aggregated proof\n",
"\n",
"res = ezkl.mock_aggregate([proof_path], 21)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fee8acc6",
"metadata": {},
"outputs": [],
"source": [
"# Setup the vk and pk for aggregate\n",
"res = ezkl.setup_aggregate(\n",
" [proof_path],\n",
" aggregate_vk_path,\n",
" aggregate_pk_path,\n",
" 21\n",
")\n",
"\n",
"assert os.path.isfile(aggregate_vk_path)\n",
"assert os.path.isfile(aggregate_pk_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "171702d3",
"metadata": {},
"outputs": [],
"source": [
"# Run aggregate proof\n",
"res = ezkl.aggregate(\n",
" [proof_path],\n",
" aggregate_proof_path,\n",
" aggregate_pk_path,\n",
" \"evm\",\n",
" 21,\n",
" \"safe\"\n",
")\n",
"\n",
"assert os.path.isfile(aggregate_proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "671dfdd5",
"metadata": {},
"outputs": [],
"source": [
"# Check if the proof is valid\n",
"res = ezkl.verify_aggr(\n",
" aggregate_proof_path,\n",
" aggregate_vk_path,\n",
" 21,\n",
")\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "50eba2f4",
"metadata": {},
"outputs": [],
"source": [
"# Create a smart contract verifier for the aggregated proof\n",
"\n",
"sol_code_path = os.path.join(\"Verifier.sol\")\n",
"abi_path = os.path.join(\"Verifier_ABI.json\")\n",
"\n",
"res = ezkl.create_evm_verifier_aggr(\n",
" [settings_path],\n",
" aggregate_vk_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" logrows=21)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/simple_demo_all_public.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## EZKL Jupyter Notebook Demo \n",
"\n",
"Here we demonstrate the use of the EZKL package in a Jupyter notebook whereby all components of the circuit are public or pre-committed to. This is the simplest case of using EZKL (proof of computation)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch\n",
"\n",
"\n",
"# Defines the model\n",
"# we got convs, we got relu, we got linear layers\n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=5, stride=2)\n",
" self.conv2 = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=5, stride=2)\n",
"\n",
" self.relu = nn.ReLU()\n",
"\n",
" self.d1 = nn.Linear(48, 48)\n",
" self.d2 = nn.Linear(48, 10)\n",
"\n",
" def forward(self, x):\n",
" # 32x1x28x28 => 32x32x26x26\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
" x = self.conv2(x)\n",
" x = self.relu(x)\n",
"\n",
" # flatten => 32 x (32*26*26)\n",
" x = x.flatten(start_dim = 1)\n",
"\n",
" # 32 x (32*26*26) => 32x128\n",
" x = self.d1(x)\n",
" x = self.relu(x)\n",
"\n",
" # logits => 32x10\n",
" logits = self.d2(x)\n",
"\n",
" return logits\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# Train the model as you like here (skipped for brevity)\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"shape = [1, 28, 28]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*torch.rand(1,*shape, requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"\n",
"py_run_args = ezkl.PyRunArgs()\n",
"py_run_args.input_visibility = \"public\"\n",
"py_run_args.output_visibility = \"public\"\n",
"py_run_args.param_visibility = \"fixed\" # \"fixed\" for params means that the committed to params are used for all proofs\n",
"\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20, *shape, requires_grad=True).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/simple_demo_public_input_output.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## EZKL Jupyter Notebook Demo \n",
"\n",
"Here we demonstrate how to use the EZKL package to run a private network on public data to produce a public output.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch\n",
"\n",
"\n",
"# Defines the model\n",
"# we got convs, we got relu, we got linear layers\n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=5, stride=2)\n",
" self.conv2 = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=5, stride=2)\n",
"\n",
" self.relu = nn.ReLU()\n",
"\n",
" self.d1 = nn.Linear(48, 48)\n",
" self.d2 = nn.Linear(48, 10)\n",
"\n",
" def forward(self, x):\n",
" # 32x1x28x28 => 32x32x26x26\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
" x = self.conv2(x)\n",
" x = self.relu(x)\n",
"\n",
" # flatten => 32 x (32*26*26)\n",
" x = x.flatten(start_dim = 1)\n",
"\n",
" # 32 x (32*26*26) => 32x128\n",
" x = self.d1(x)\n",
" x = self.relu(x)\n",
"\n",
" # logits => 32x10\n",
" logits = self.d2(x)\n",
"\n",
" return logits\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# Train the model as you like here (skipped for brevity)\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"shape = [1, 28, 28]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*torch.rand(1,*shape, requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"py_run_args = ezkl.PyRunArgs()\n",
"py_run_args.input_visibility = \"public\"\n",
"py_run_args.output_visibility = \"public\"\n",
"py_run_args.param_visibility = \"private\" # private by default\n",
"\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20, *shape, requires_grad=True).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/simple_demo_public_network_output.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## EZKL Jupyter Notebook Demo \n",
"\n",
"Here we demonstrate how to use the EZKL package to run a publicly known / committed to network on some private data, producing a public output.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch\n",
"\n",
"\n",
"# Defines the model\n",
"# we got convs, we got relu, we got linear layers\n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=5, stride=2)\n",
" self.conv2 = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=5, stride=2)\n",
"\n",
" self.relu = nn.ReLU()\n",
"\n",
" self.d1 = nn.Linear(48, 48)\n",
" self.d2 = nn.Linear(48, 10)\n",
"\n",
" def forward(self, x):\n",
" # 32x1x28x28 => 32x32x26x26\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
" x = self.conv2(x)\n",
" x = self.relu(x)\n",
"\n",
" # flatten => 32 x (32*26*26)\n",
" x = x.flatten(start_dim = 1)\n",
"\n",
" # 32 x (32*26*26) => 32x128\n",
" x = self.d1(x)\n",
" x = self.relu(x)\n",
"\n",
" # logits => 32x10\n",
" logits = self.d2(x)\n",
"\n",
" return logits\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"# Train the model as you like here (skipped for brevity)\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"shape = [1, 28, 28]\n",
"# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
"x = 0.1*torch.rand(1,*shape, requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"py_run_args = ezkl.PyRunArgs()\n",
"py_run_args.input_visibility = \"private\"\n",
"py_run_args.output_visibility = \"public\"\n",
"py_run_args.param_visibility = \"fixed\" # private by default\n",
"\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)\n",
"\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20, *shape, requires_grad=True).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/sklearn_mlp.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## Sklearn MLP to ONNX\n",
"\n",
"\n",
"Sklearn based models are slightly finicky to get into a suitable onnx format. \n",
"\n",
"This notebook showcases how to do that using the `hummingbird-ml` python package ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.neural_network import MLPClassifier\n",
"from hummingbird.ml import convert\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"\n",
"\n",
"\n",
"iris = load_iris()\n",
"X, y = iris.data, iris.target\n",
"X = X.astype(np.float32)\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
"clr = MLPClassifier()\n",
"clr.fit(X_train, y_train)\n",
"\n",
"circuit = convert(clr, \"torch\", X_test[:1]).model\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# export to onnx format\n",
"# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"# Input to the model\n",
"shape = X_train.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=True)\n",
"torch_out = circuit(x)\n",
"# Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20, *shape, requires_grad=True).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/solvency.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67"
},
"source": [
"## Solvency demo\n",
"\n",
"Here we create a demo of a solvency calculation in the manner of [summa-solvency](https://github.com/summa-dev/summa-solvency). The aim here is to demonstrate the use of the new polycommit method detailed [here](https://blog.ezkl.xyz/post/commits/). \n",
"\n",
"In this setup:\n",
"- the commitments to users, respective balances, and total balance are known are publicly known to the prover and verifier. \n",
"- We leave the outputs of the model as public as well (known to the verifier and prover). \n",
"\n",
"The circuit calculates the total sum of the balances, and checks that it is less than the total balance which is precommited to."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {
"id": "95613ee9"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"pytest\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"# uncomment to enable logging\n",
"# import logging\n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.DEBUG)\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch\n",
"\n",
"class Circuit(nn.Module):\n",
" def __init__(self):\n",
" super(Circuit, self).__init__()\n",
"\n",
" def forward(self, users, balances, total):\n",
" nil = torch.nn.Parameter(torch.tensor([0.0]))\n",
" # calculate the total balance across all users second term will be ignored by the optimizer but will force it to be included in a separate col for commitment\n",
" balances = torch.sum(balances, dim=1) + nil * users\n",
" # now check if the total balance is less than the total\n",
" return (balances[:,0] <= total)\n",
"\n",
"\n",
"circuit = Circuit()\n",
"\n",
"# Train the model as you like here (skipped for brevity)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {
"id": "b37637c4"
},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "markdown",
"id": "1c21e56e",
"metadata": {},
"source": [
"We create dummy data here for the sake of demonstration. In a real world scenario, the data would be provided by the users, and the commitments would be made by some trusted party.\n",
"\n",
"The users are generated as hashes of the integers 0 to 9. The balances are generated as integers between 0 and 10. \n",
"\n",
"The total balance is the sum of the balances."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dfd6c7e7",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"user_preimages = [0.0, 1.0, 2.0, 3.0, 4.0, 9.0]\n",
"balances = torch.tensor([0, 2, 3, 4, 5, 10])\n",
"balances = balances.reshape(1, 6)\n",
"\n",
"\n",
"# Create an empty list to store the hashes of float -- which I guess we'll call the users here\n",
"users = []\n",
"\n",
"# Loop through each element in the y tensor\n",
"for e in user_preimages:\n",
" # Apply the custom function and append the result to the list\n",
" users.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 0)])[0])\n",
"\n",
"users_t = torch.tensor(user_preimages)\n",
"users_t = users_t.reshape(1, 6)\n",
"\n",
"total = torch.tensor([25])\n",
"total = total.reshape(1, 1)\n",
"\n",
"# Flips thegraph into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" (users_t,balances,total), # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=17, # the ONNX version to export the model to\n",
" do_constant_folding=False, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"\n",
" \n",
"data_array_x = users\n",
"data_array_y = ((balances).detach().numpy()).reshape([-1]).tolist()\n",
"data_array_z = ((total).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array_x, data_array_y, data_array_z])\n",
"\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "markdown",
"id": "22d3d8df",
"metadata": {},
"source": [
"This is where the magic happens. We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
"- `input_visibility` defines the visibility of the model inputs\n",
"- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
"- `output_visibility` defines the visibility of the model outputs\n",
"\n",
"There are currently 5 visibility settings:\n",
"- `public`: known to both the verifier and prover (a subtle nuance is that this may not be the case for model parameters but until we have more rigorous theoretical results we don't want to make strong claims as to this). \n",
"- `private`: known only to the prover\n",
"- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
"- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
"- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes. \n",
"\n",
"Here we create the following setup:\n",
"- `input_visibility`: \"polycommit\"\n",
"- `param_visibility`: \"public\"\n",
"- `output_visibility`: public\n",
"\n",
"We encourage you to play around with other setups :) \n",
"\n",
"Shoutouts: \n",
"\n",
"- [summa-solvency](https://github.com/summa-dev/summa-solvency) for their help with the poseidon hashing chip. \n",
"- [timeofey](https://github.com/timoftime) for providing inspiration in our developement of the el-gamal encryption circuit in Halo2. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {
"id": "d5e374a2"
},
"outputs": [],
"source": [
"run_args = ezkl.PyRunArgs()\n",
"# \"polycommit\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
"run_args.input_visibility = \"polycommit\"\n",
"# the parameters are public\n",
"run_args.param_visibility = \"fixed\"\n",
"# the output is public (this is the inequality test)\n",
"run_args.output_visibility = \"public\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"# never rebase the scale\n",
"run_args.scale_rebase_multiplier = 1000\n",
"# logrows\n",
"run_args.logrows = 11\n",
"run_args.lookup_range = (-1000,1000)\n",
"run_args.input_scale = 0\n",
"run_args.param_scale = 0\n",
"\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {
"id": "3aa4f090"
},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "8b74dcee",
"outputId": "f7b9198c-2b3d-48bb-c67e-8478333cedb5"
},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "markdown",
"id": "f7c98c96",
"metadata": {},
"source": [
"We'll generate two proofs, one with the correct total balance, and one with an incorrect total balance.\n",
"\n",
"## Correct total balance\n",
"\n",
"The data file above has a total balance of above the user total balance. We'll generate a proof with this total balance."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "93e90079",
"metadata": {},
"outputs": [],
"source": [
"# setup keypair\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "efa0ac91",
"metadata": {},
"outputs": [],
"source": [
"!export RUST_BACKTRACE=1\n",
"\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
"assert os.path.isfile(witness_path)\n",
"\n",
"# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
"# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
"witness = json.load(open(witness_path, \"r\"))\n",
"witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
"json.dump(witness, open(witness_path, \"w\"))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "90973daf",
"metadata": {},
"outputs": [],
"source": [
"proof_path = os.path.join('proof.json')\n",
"# proof path\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"assert os.path.isfile(proof_path)\n",
"\n",
"print(res)\n"
]
},
{
"cell_type": "markdown",
"id": "ef79b4ee",
"metadata": {},
"source": [
"- now we swap the commitments of the proof as a way to demonstrate that the proof is valid given some public inputs \n",
"- this is just for testing purposes and would require fetching public commits from the blockchain or some other source\n",
"- see https://blog.ezkl.xyz/post/commits/ for more details"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8bb46735",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"res = ezkl.swap_proof_commitments(proof_path, witness_path)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "59f3b1e9",
"metadata": {},
"outputs": [],
"source": [
"# verify the proof\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"assert res == True"
]
},
{
"cell_type": "markdown",
"id": "77dec3dd",
"metadata": {},
"source": [
"### Faulty proof\n",
"\n",
"We'll generate a proof with a total balance of 10. This is below the user total balance."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "FQfGdcUNpvuK",
"metadata": {
"id": "FQfGdcUNpvuK"
},
"outputs": [],
"source": [
"# now generate a truthy input + witness file (x input not in the set)\n",
"import random\n",
"\n",
"data_path_truthy = os.path.join('input.json')\n",
"data = json.load(open(data_path, 'r' ))\n",
"data['input_data'][2] = [10]\n",
"\n",
"data_path_faulty = os.path.join('input_faulty.json')\n",
"# Serialize data into file:\n",
"json.dump( data, open(data_path_faulty, 'w' ))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {
"id": "b1c561a8"
},
"outputs": [],
"source": [
"# now generate the witness file\n",
"\n",
"res = ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path, vk_path)\n",
"assert os.path.isfile(witness_path)\n",
"\n",
"# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
"# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
"witness = json.load(open(witness_path, \"r\"))\n",
"witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
"json.dump(witness, open(witness_path, \"w\"))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {
"id": "c384cbc8"
},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4edaca46",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.swap_proof_commitments(proof_path, witness_path)\n"
]
},
{
"cell_type": "markdown",
"id": "638d776f",
"metadata": {},
"source": [
"Now we test that verification fails"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4nqEx7-qpciQ",
"metadata": {
"id": "4nqEx7-qpciQ"
},
"outputs": [],
"source": [
"import pytest\n",
"\n",
"def test_verification():\n",
" with pytest.raises(RuntimeError, match='Failed to run verify: The constraint system is not satisfied'):\n",
" ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"# Run the test function\n",
"test_verification()"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
} | https://github.com/zkonduit/ezkl |
examples/notebooks/stacked_regression.ipynb | {
"cells": [
{
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## Stacked Regression\n",
"\n",
"\n",
"Sklearn based models are slightly finicky to get into a suitable onnx format.\n",
"This notebook showcases how to do so using the `hummingbird-ml` python package !\n",
"\n",
"We're going to combine a few models to create a stacked regression model.\n",
"1. Linear Ridge Regression\n",
"2. Support Vector Regression\n",
"3. Random Forest Regression as a meta-estimator\n",
"\n",
"We then use hummingbird to convert the model to Torch and ONNX formats.\n",
"\n",
"\n",
"\n",
"We then use ezkl to run zk-proofs.\n",
"\n",
"The generated onnx should look like this:\n",
"\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"scikit-learn==1.3.1\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"import os\n",
"import torch\n",
"import ezkl\n",
"import json\n",
"from hummingbird.ml import convert\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import numpy as np\n",
"from sklearn.linear_model import RidgeCV\n",
"from sklearn.svm import LinearSVR\n",
"from sklearn.ensemble import RandomForestRegressor\n",
"from sklearn.ensemble import StackingRegressor\n",
"\n",
"estimators = [\n",
" ('lr', RidgeCV()),\n",
" ('svr', LinearSVR(dual=\"auto\", random_state=42))\n",
"]\n",
"\n",
"X = np.array([[1, 1], [1, 2], [2, 2], [2, 3], [3, 3], [4, 4], [6, 8]])\n",
"# y = 1 * x_0 + 2 * x_1 + 3\n",
"y = np.dot(X, np.array([1, 2])) + 3\n",
"\n",
"reg = StackingRegressor(\n",
" estimators=estimators,\n",
" final_estimator=RandomForestRegressor(n_estimators=2,\n",
" random_state=42)\n",
")\n",
"reg.fit(X, y)\n",
"reg.score(X, y)\n",
"\n",
"circuit = convert(reg, \"torch\", X[:1]).model\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b0a6f4b",
"metadata": {},
"outputs": [],
"source": [
"print(circuit)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# export to onnx format\n",
"# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"# Input to the model\n",
"shape = X.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=True)\n",
"torch_out = circuit(x)\n",
"# Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = (torch.rand(20, *shape, requires_grad=True).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/svm.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## Support Vector Machines\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"sk2torch\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.svm import SVC\n",
"import sk2torch\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"\n",
"\n",
"# Create a dataset of two Gaussians. There will be some overlap\n",
"# between the two classes, which adds some uncertainty to the model.\n",
"xs = np.concatenate(\n",
" [\n",
" np.random.random(size=(256, 2)) + [1, 0],\n",
" np.random.random(size=(256, 2)) + [-1, 0],\n",
" ],\n",
" axis=0,\n",
")\n",
"ys = np.array([False] * 256 + [True] * 256)\n",
"\n",
"# Train an SVM on the data and wrap it in PyTorch.\n",
"sk_model = SVC(probability=True)\n",
"sk_model.fit(xs, ys)\n",
"model = sk2torch.wrap(sk_model)\n",
"\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7f0ca328",
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"# Create a coordinate grid to compute a vector field on.\n",
"spaced = np.linspace(-2, 2, num=25)\n",
"grid_xs = torch.tensor([[x, y] for x in spaced for y in spaced], requires_grad=True)\n",
"\n",
"\n",
"# Compute the gradients of the SVM output.\n",
"outputs = model.predict_proba(grid_xs)[:, 1]\n",
"(input_grads,) = torch.autograd.grad(outputs.sum(), (grid_xs,))\n",
"\n",
"\n",
"# Create a quiver plot of the vector field.\n",
"plt.quiver(\n",
" grid_xs[:, 0].detach().numpy(),\n",
" grid_xs[:, 1].detach().numpy(),\n",
" input_grads[:, 0].detach().numpy(),\n",
" input_grads[:, 1].detach().numpy(),\n",
")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# export to onnx format\n",
"# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"# Input to the model\n",
"shape = xs.shape[1:]\n",
"x = grid_xs[0:1]\n",
"torch_out = model.predict(x)\n",
"# Export the model\n",
"torch.onnx.export(model, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = ((grid_xs[0:20]).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "markdown",
"id": "760580d4",
"metadata": {},
"source": [
"# Linear SVC"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "481824fe",
"metadata": {},
"outputs": [],
"source": [
"### Linear SVC\n",
"\n",
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"sk2torch\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.svm import LinearSVC\n",
"import sk2torch\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"\n",
"\n",
"xs = np.concatenate(\n",
" [\n",
" np.random.random(size=(256, 2)) + [1, 0],\n",
" np.random.random(size=(256, 2)) + [-1, 0],\n",
" ],\n",
" axis=0,\n",
")\n",
"ys = np.array([False] * 256 + [True] * 256)\n",
"\n",
"# Train an SVM on the data and wrap it in PyTorch.\n",
"sk_model = LinearSVC()\n",
"sk_model.fit(xs, ys)\n",
"model = sk2torch.wrap(sk_model)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7d1d47fe",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# export to onnx format\n",
"# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"# Input to the model\n",
"shape = xs.shape[1:]\n",
"x = grid_xs[0:1]\n",
"torch_out = model.predict(x)\n",
"# Export the model\n",
"torch.onnx.export(model, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7c00b3f6",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "69536185",
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path)\n",
"assert res == True\n",
"\n",
"res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
"assert res == True"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/tictactoe_autoencoder.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Autoencoder Tic Tac Toe Verifier\n",
"\n",
"This is another approach of verifying games but using an anomaly detection approach instead of classification.\n",
"\n",
"Make sure to use a GPU otherwise you'll take a super long time to train"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"!RUST_LOG=trace"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Create TicTacToe Game States\n",
"\n",
"The game states are in the form of\n",
"```json\n",
"[\n",
" {\n",
" \"history\": [\n",
" [null, null, null, null, null, null, null, null, null],\n",
" [\"X\", null, null, null, null, null, null, null, null],\n",
" ...\n",
" ],\n",
" \"outcome\": \"X\"\n",
" }\n",
"]\n",
"```\n",
"\n",
"To create the game states for tic tac toe, do a recursive a tree search of possible gameplay."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"\n",
"def check_winner(board):\n",
" winning_combinations = [\n",
" [0, 1, 2], [3, 4, 5], [6, 7, 8], # rows\n",
" [0, 3, 6], [1, 4, 7], [2, 5, 8], # columns\n",
" [0, 4, 8], [2, 4, 6] # diagonals\n",
" ]\n",
" for combo in winning_combinations:\n",
" if board[combo[0]] == board[combo[1]] == board[combo[2]] and board[combo[0]] is not None:\n",
" return board[combo[0]]\n",
" return None\n",
"\n",
"def generate_games(board, player):\n",
" winner = check_winner(board)\n",
" if winner or None not in board:\n",
" # Game is over, save the outcome and board state\n",
" return [{\n",
" \"history\": [list(board)],\n",
" \"outcome\": winner if winner else \"Draw\"\n",
" }]\n",
"\n",
" games = []\n",
" for i in range(9):\n",
" if board[i] is None:\n",
" new_board = board.copy()\n",
" new_board[i] = player\n",
" next_player = 'O' if player == 'X' else 'X'\n",
" next_games = generate_games(new_board, next_player)\n",
" for game in next_games:\n",
" game[\"history\"].insert(0, list(board))\n",
" games.extend(next_games)\n",
"\n",
" return games\n",
"\n",
"initial_board = [None for _ in range(9)]\n",
"games = generate_games(initial_board, 'X')\n",
"\n",
"with open(\"tic_tac_toe_games.json\", \"w\") as file:\n",
" file.write(\"[\\n\") # Start of the list\n",
" for i, game in enumerate(games):\n",
" json.dump(game, file, separators=(',', ': '))\n",
" if i != len(games) - 1: # If it's not the last game, add a comma\n",
" file.write(\",\\n\")\n",
" else:\n",
" file.write(\"\\n\")\n",
" file.write(\"]\\n\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, let's make a list of illegal game play by running through the legal games and making bad games."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"with open(\"tic_tac_toe_games_bad.json\", \"w\") as file:\n",
" file.write(\"[\\n\")\n",
" for i, game in enumerate(games):\n",
" # we the permute the games\n",
" game_history = game['history']\n",
" new_game_history = []\n",
" for moves in game_history:\n",
" new_moves = []\n",
" for move in moves:\n",
" if move is None:\n",
" new_moves.append('X')\n",
" elif move == 'X':\n",
" new_moves.append('O')\n",
" else:\n",
" new_moves.append(None)\n",
" new_game_history.append(new_moves)\n",
" game['history'] = new_game_history\n",
"\n",
" json.dump(game, file, separators=(',', ': '))\n",
"\n",
" if i != len(games) - 1: # If it's not the last game, add a comma\n",
" file.write(\",\\n\")\n",
" else:\n",
" file.write(\"\\n\")\n",
" file.write(\"]\\n\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Create a neural net to verify the execution of the tic tac toe model\n",
"\n",
"1. We use an autoencoder to verify the execution. An autoencoder is essentially a fan-in, fan-out architecture. It can be used for generative tasks, but in this case we use it as an anomaly detection approach.\n",
"\n",
"2. The autoencoder helps us extract out the latent distribution of normal tic tac toe games. If there's a weird tic tac toe game, we can then reject it if the distribution is not within some threshold we want. We can quantify this distribution via the mean absolute error between the data point and the reconstructed data."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import torch.nn as nn\n",
"from torch.utils.data import DataLoader, IterableDataset, random_split\n",
"import torch.optim as optim\n",
"import json\n",
"import torch.nn.functional as F\n",
"\n",
"class TicTacToeNet(nn.Module):\n",
" def __init__(self):\n",
" super(TicTacToeNet, self).__init__()\n",
" self.return_x = True\n",
" self.dense = nn.Linear(11 * 9 * 3, 50)\n",
" self.dense1 = nn.Linear(50, 20)\n",
" self.dense2 = nn.Linear(20, 10)\n",
" self.dense3 = nn.Linear(10, 20)\n",
" self.dense4 = nn.Linear(20, 50)\n",
" self.dense5 = nn.Linear(50, 11 * 9 * 3)\n",
"\n",
" def forward(self, x):\n",
" # Store original input\n",
" original_x = x.clone()\n",
"\n",
" # Neural network operations\n",
" x = F.relu(self.dense(x))\n",
" x = F.relu(self.dense1(x))\n",
" x = F.relu(self.dense2(x))\n",
" x = F.relu(self.dense3(x))\n",
" x = F.relu(self.dense4(x))\n",
" x = self.dense5(x) # Not applying activation on final layer\n",
"\n",
" # Calculate L1 loss\n",
" l1_loss = torch.mean(torch.abs(x - original_x))\n",
"\n",
" if self.return_x:\n",
" return x, l1_loss\n",
" else:\n",
" return l1_loss"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Load all possible tictactoe games\n",
"\n",
"We want to load good games and bad games for the classification later."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"class JsonDataset(IterableDataset):\n",
" def __init__(self, file):\n",
" self.file_good = file\n",
" self.length = self.compute_length(self.file_good)\n",
" self.data = self.load_data(self.file_good)\n",
"\n",
" def __iter__(self):\n",
" for i in range(len(self.data)):\n",
" yield self.data[i]\n",
"\n",
" def parse_json_object(self, line):\n",
" try:\n",
" return json.loads(line)\n",
" except json.JSONDecodeError:\n",
" return None\n",
"\n",
" def encode_board(self, board):\n",
" encoding = []\n",
" for cell in board:\n",
" if cell == 'X':\n",
" encoding.extend([1,0,0])\n",
" elif cell == 'O':\n",
" encoding.extend([0,1,0])\n",
" else:\n",
" encoding.extend([0,0,1])\n",
"\n",
" return encoding\n",
"\n",
"\n",
" def encode_outcome(self, outcome):\n",
" if outcome == 'X':\n",
" return [1,0,0]\n",
" elif outcome == 'O':\n",
" return [0,1,0]\n",
" else:\n",
" return [0,0,1]\n",
"\n",
" def compute_length(self, file_good):\n",
" count = 0\n",
" with open(file_good, 'r') as f:\n",
" # Skip the first line (which is \"[\")\n",
" next(f)\n",
" for line in f:\n",
" if line.strip() not in [\",\", \"]\"]:\n",
" count += 1\n",
"\n",
" return count\n",
"\n",
" def __len__(self):\n",
" return self.length\n",
"\n",
" def __getitem__(self, idx):\n",
" padded_history, sample_outcome = self.data[idx]\n",
"\n",
" return torch.tensor(padded_history, dtype=torch.float), torch.tensor(sample_outcome, dtype=torch.float)\n",
"\n",
" def process_file(self, file, is_good):\n",
" data = []\n",
" with open(file, 'r') as f:\n",
" next(f)\n",
" for line in f:\n",
" # Remove the trailing comma for all lines except the last one (which is \"]\")\n",
" if line.endswith(\",\\n\"):\n",
" line = line[:-2]\n",
" sample = self.parse_json_object(line)\n",
" if sample is not None:\n",
" max_length = 10 # Maximum length of a Tic Tac Toe game\n",
" history = sample['history']\n",
"\n",
" if len(history) == max_length:\n",
" padded_history = history\n",
" else:\n",
" padded_history = history + [[None] * 9 for _ in range(max_length - len(history))]\n",
"\n",
" padded_history = [self.encode_board(x) for x in padded_history]\n",
" sample_outcome = self.encode_outcome(sample['outcome'])\n",
" sample_outcome.extend([0,0,1] * 8)\n",
" padded_history.append(sample_outcome)\n",
"\n",
" if is_good:\n",
" # data.append((padded_history, sample_outcome, 0))\n",
" data.append((padded_history, [1, 0]))\n",
" else:\n",
" # data.append((padded_history, sample_outcome, 1))\n",
" data.append((padded_history, [0, 1]))\n",
"\n",
" return data\n",
"\n",
"\n",
" def load_data(self, file_good):\n",
" data_good = self.process_file(file_good, True)\n",
" # data_bad = self.process_file(file_bad, False)\n",
" # data_good.extend(data_bad)\n",
"\n",
" return data_good\n",
"\n",
"def collate_fn(batch):\n",
" histories, outcomes = zip(*batch)\n",
"\n",
" # Convert nested lists to tensor\n",
" histories_tensor = torch.tensor(histories, dtype=torch.float32)\n",
" outcomes_tensor = torch.tensor(outcomes, dtype=torch.int64)\n",
"\n",
" return histories_tensor, outcomes_tensor\n",
"\n",
"dataset = JsonDataset('tic_tac_toe_games.json')\n",
"\n",
"total_size = len(dataset)\n",
"train_size = int(0.8 * total_size)\n",
"test_size = total_size - train_size\n",
"\n",
"train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
"\n",
"\n",
"train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
"test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Train\n",
"\n",
"Note that during training we want to neural network to try to recreate its inputs. To do this we compare the L1Loss or Mean Absolute Error between the prediction and the input."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
"model = TicTacToeNet().to(device)\n",
"criterion = nn.L1Loss()\n",
"optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
"\n",
"# You may want to increase this\n",
"MAX_EPOCH = 1\n",
"\n",
"for epoch in range(MAX_EPOCH):\n",
" model.train()\n",
"\n",
" for history, valid in train_loader:\n",
"\n",
" history = history.to(device)\n",
" optimizer.zero_grad()\n",
" history = history.view(history.size(0), -1)\n",
" prediction, _ = model(history)\n",
" loss = criterion(prediction, history)\n",
" loss.backward()\n",
" optimizer.step()\n",
"\n",
" # Gather data and report\n",
"\n",
" # Validation phase\n",
" model.eval()\n",
"\n",
"\n",
" with torch.no_grad():\n",
" total_count = 0\n",
" total_loss = 0\n",
" for history, valid in test_loader:\n",
" history = history.to(device)\n",
" history = history.view(history.size(0), -1)\n",
"\n",
" valid = valid.to(device)\n",
" prediction, _ = model(history)\n",
" loss = criterion(prediction, history)\n",
"\n",
" total_loss += loss\n",
"\n",
" total_count += 1\n",
"\n",
" # get values for the accuracy\n",
"\n",
"\n",
" avg_loss = total_loss / total_count\n",
" print(f\"Epoch {epoch + 1}/{MAX_EPOCH} - Loss: {avg_loss:.2f}\")\n",
" print(history[-1])\n",
" print(prediction[-1])\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Get the ranges for normal data\n",
"\n",
"We plot the range of possible losses for normal data.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# set model to get loss out\n",
"model.eval()\n",
"model.return_x = False\n",
"\n",
"\n",
"loss_list = []\n",
"\n",
"for history, valid in test_loader:\n",
" history = history.to(device)\n",
" history = history.view(history.size(0), -1)\n",
" loss = model(history)\n",
" loss_list.append(loss.cpu().detach().numpy())\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# visualize\n",
"import matplotlib.pyplot as plt\n",
"\n",
"plt.hist(loss_list, bins=50)\n",
"plt.xlabel(\"Normal loss\")\n",
"plt.ylabel(\"No of examples\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Get the ranges for bad data\n",
"\n",
"Likewise, we plot the ranges of losses for bad data."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# load bad data\n",
"bad_dataset = JsonDataset('tic_tac_toe_games_bad.json')\n",
"\n",
"bad_total_size = len(bad_dataset)\n",
"bad_train_size = int(0.8 * bad_total_size)\n",
"bad_test_size = bad_total_size - bad_train_size\n",
"\n",
"bad_train_dataset, bad_test_dataset = random_split(bad_dataset, [bad_train_size, bad_test_size])\n",
"\n",
"bad_train_loader = DataLoader(bad_train_dataset, batch_size=32, shuffle=True)\n",
"bad_test_loader = DataLoader(bad_test_dataset, batch_size=32, shuffle=False)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"bad_loss_list = []\n",
"\n",
"for history, valid in bad_test_loader:\n",
" history = history.to(device)\n",
" history = history.view(history.size(0), -1)\n",
" loss = model(history)\n",
" bad_loss_list.append(loss.cpu().detach().numpy())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"plt.hist(bad_loss_list, bins=50)\n",
"plt.xlabel(\"Normal loss\")\n",
"plt.ylabel(\"No of examples\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** By visual inspection we can see that if the loss is greater than `~0.200` the data is likely anomalous (this value will probably change depending on the runs). There seems to be no overlap in loss between good gameplay and bad gameplay.\n",
"\n",
"We could alternatively set the threshold to 4 standard deviation away from the mean of normal values. Or you can vary this according to the error tolerance required."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"threshold = np.mean(loss_list)+ 4 * np.std(loss_list)\n",
"print(threshold)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Export Onnx and Data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Set the model to evaluation mode\n",
"model = model.cpu()\n",
"model.eval()\n",
"\n",
"# Obtain a sample datapoint from the DataLoader\n",
"sample_data_iter = iter(train_loader)\n",
"sample_history, _ = next(sample_data_iter)\n",
"\n",
"# Move the sample datapoint to the cpu so it is the same as the model\n",
"x = sample_history.to('cpu')\n",
"x = x.view(x.size(0), -1)\n",
"\n",
"# Export the model using ONNX\n",
"torch.onnx.export(\n",
" model, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"tictactoe_network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={\n",
" 'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}\n",
" }\n",
")\n",
"\n",
"data_array = ((x[0]).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"data.json\", 'w'))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Prove the Tic Tac Toe Anomaly Detection Model\n",
"\n",
"We import the ezkl library to setup the zk system."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import ezkl\n",
"\n",
"data_path = os.path.join(\"data.json\")\n",
"model_path = os.path.join('tictactoe_network.onnx')\n",
"compiled_model_path = os.path.join('network.ezkl')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"proof_path = os.path.join('proof.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.gen_settings(model_path, settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# IMPORTANT NOTE: You may want to set the scale ranges and set to \"accuracy\"\n",
"# In it's current state, it will likely truncate values\n",
"# For testing we will just stick to resources to reduce computational costs\n",
"# Example:\n",
"# ezkl.calibrate_settings(data_path, model_path, settings_path, \"accuracy\", scales = [2,9])\n",
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = ((x[0:20]).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.compile_circuit(model_path, compiled_model_path, settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"\n",
"with open(data_path, \"r\") as f:\n",
" data = json.load(f)\n",
" print(len(data['input_data'][0]))\n",
"\n",
"ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.mock(witness_path, compiled_model_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"accelerator": "GPU",
"colab": {
"gpuType": "V100",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/tictactoe_binary_classification.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Binary Classification Tic Tac Toe Verifier\n",
"\n",
"We create an ML model that verifies TicTacToe Games\n",
"\n",
"Make sure to use a GPU otherwise you'll take a super long time to train"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Create TicTacToe Game States\n",
"\n",
"The game states are in the form of\n",
"```json\n",
"[\n",
" {\n",
" \"history\": [\n",
" [null, null, null, null, null, null, null, null, null],\n",
" [\"X\", null, null, null, null, null, null, null, null],\n",
" ...\n",
" ],\n",
" \"outcome\": \"X\"\n",
" }\n",
"]\n",
"```\n",
"\n",
"To create the game states for tic tac toe, do a recursive a tree search of possible gameplay."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"\n",
"def check_winner(board):\n",
" winning_combinations = [\n",
" [0, 1, 2], [3, 4, 5], [6, 7, 8], # rows\n",
" [0, 3, 6], [1, 4, 7], [2, 5, 8], # columns\n",
" [0, 4, 8], [2, 4, 6] # diagonals\n",
" ]\n",
" for combo in winning_combinations:\n",
" if board[combo[0]] == board[combo[1]] == board[combo[2]] and board[combo[0]] is not None:\n",
" return board[combo[0]]\n",
" return None\n",
"\n",
"def generate_games(board, player):\n",
" winner = check_winner(board)\n",
" if winner or None not in board:\n",
" # Game is over, save the outcome and board state\n",
" return [{\n",
" \"history\": [list(board)],\n",
" \"outcome\": winner if winner else \"Draw\"\n",
" }]\n",
"\n",
" games = []\n",
" for i in range(9):\n",
" if board[i] is None:\n",
" new_board = board.copy()\n",
" new_board[i] = player\n",
" next_player = 'O' if player == 'X' else 'X'\n",
" next_games = generate_games(new_board, next_player)\n",
" for game in next_games:\n",
" game[\"history\"].insert(0, list(board))\n",
" games.extend(next_games)\n",
"\n",
" return games\n",
"\n",
"initial_board = [None for _ in range(9)]\n",
"games = generate_games(initial_board, 'X')\n",
"\n",
"with open(\"tic_tac_toe_games.json\", \"w\") as file:\n",
" file.write(\"[\\n\") # Start of the list\n",
" for i, game in enumerate(games):\n",
" json.dump(game, file, separators=(',', ': '))\n",
" if i != len(games) - 1: # If it's not the last game, add a comma\n",
" file.write(\",\\n\")\n",
" else:\n",
" file.write(\"\\n\")\n",
" file.write(\"]\\n\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, let's make a list of illegal game play by running through the legal games and making bad games."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"with open(\"tic_tac_toe_games_bad.json\", \"w\") as file:\n",
" file.write(\"[\\n\")\n",
" for i, game in enumerate(games):\n",
" # we the permute the games\n",
" game_history = game['history']\n",
" new_game_history = []\n",
" for moves in game_history:\n",
" new_moves = []\n",
" for move in moves:\n",
" if move is None:\n",
" new_moves.append('X')\n",
" elif move == 'X':\n",
" new_moves.append('O')\n",
" else:\n",
" new_moves.append(None)\n",
" new_game_history.append(new_moves)\n",
" game['history'] = new_game_history\n",
"\n",
" json.dump(game, file, separators=(',', ': '))\n",
"\n",
" if i != len(games) - 1: # If it's not the last game, add a comma\n",
" file.write(\",\\n\")\n",
" else:\n",
" file.write(\"\\n\")\n",
" file.write(\"]\\n\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Create a neural net to verify the execution of the tic tac toe model\n",
"\n",
"1. Given the data generated above classify whether the tic tac toe games are valid. This approach uses a binary classification as the tic tac toe state space is fairly small. For larger state spaces, we will want to use anomaly detection based approaches."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import torch.nn as nn\n",
"from torch.utils.data import DataLoader, IterableDataset, random_split\n",
"import torch.optim as optim\n",
"import json\n",
"import torch.nn.functional as F\n",
"\n",
"class TicTacToeNet(nn.Module):\n",
" def __init__(self):\n",
" super(TicTacToeNet, self).__init__()\n",
" self.dense = nn.Linear(11 * 9 * 3, 50) # Adjusted for 11*9 input features\n",
" self.dense1 = nn.Linear(50, 20)\n",
" self.dense2 = nn.Linear(20, 10)\n",
" self.dense3 = nn.Linear(10, 2)\n",
"\n",
" def forward(self, x):\n",
" x = x.view(x.size(0), -1) # Flatten the input\n",
" x = F.relu(self.dense(x))\n",
" x = F.relu(self.dense1(x))\n",
" x = F.relu(self.dense2(x))\n",
" x = F.relu(self.dense3(x))\n",
" return x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Load all possible tictactoe games\n",
"\n",
"We want to load good games and bad games for the classification later."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class JsonDataset(IterableDataset):\n",
" def __init__(self, file_good, file_bad):\n",
" self.file_good = file_good\n",
" self.file_bad = file_bad\n",
" self.length = self.compute_length(self.file_good, self.file_bad)\n",
" self.data = self.load_data(self.file_good, self.file_bad)\n",
"\n",
" def __iter__(self):\n",
" for i in range(len(self.data)):\n",
" yield self.data[i]\n",
"\n",
"\n",
" def parse_json_object(self, line):\n",
" try:\n",
" return json.loads(line)\n",
" except json.JSONDecodeError:\n",
" return None\n",
"\n",
" def encode_board(self, board):\n",
" encoding = []\n",
" for cell in board:\n",
" if cell == 'X':\n",
" encoding.extend([1,0,0])\n",
" elif cell == 'O':\n",
" encoding.extend([0,1,0])\n",
" else:\n",
" encoding.extend([0,0,1])\n",
"\n",
" return encoding\n",
"\n",
"\n",
" def encode_outcome(self, outcome):\n",
" if outcome == 'X':\n",
" return [1,0,0]\n",
" elif outcome == 'O':\n",
" return [0,1,0]\n",
" else:\n",
" return [0,0,1]\n",
"\n",
" def compute_length(self, file_good, file_bad):\n",
" count = 0\n",
" with open(file_good, 'r') as f:\n",
" # Skip the first line (which is \"[\")\n",
" next(f)\n",
" for line in f:\n",
" if line.strip() not in [\",\", \"]\"]:\n",
" count += 1\n",
" with open(file_bad, 'r') as f:\n",
" # Skip the first line (which is \"[\")\n",
" next(f)\n",
" for line in f:\n",
" if line.strip() not in [\",\", \"]\"]:\n",
" count += 1\n",
"\n",
" return count\n",
"\n",
" def __len__(self):\n",
" return self.length\n",
"\n",
" def __getitem__(self, idx):\n",
" padded_history, sample_outcome = self.data[idx]\n",
" return torch.tensor(padded_history, dtype=torch.float), torch.tensor(sample_outcome, dtype=torch.float)\n",
"\n",
" def process_file(self, file, is_good):\n",
" data = []\n",
" with open(file, 'r') as f:\n",
" next(f)\n",
" for line in f:\n",
" # Remove the trailing comma for all lines except the last one (which is \"]\")\n",
" if line.endswith(\",\\n\"):\n",
" line = line[:-2]\n",
" sample = self.parse_json_object(line)\n",
" if sample is not None:\n",
" max_length = 10 # Maximum length of a Tic Tac Toe game\n",
" history = sample['history']\n",
"\n",
" if len(history) == max_length:\n",
" padded_history = history\n",
" else:\n",
" padded_history = history + [[None] * 9 for _ in range(max_length - len(history))]\n",
"\n",
" padded_history = [self.encode_board(x) for x in padded_history]\n",
" sample_outcome = self.encode_outcome(sample['outcome'])\n",
" sample_outcome.extend([0,0,1] * 8)\n",
" padded_history.append(sample_outcome)\n",
"\n",
" if is_good:\n",
" # data.append((padded_history, sample_outcome, 0))\n",
" data.append((padded_history, [1, 0]))\n",
" else:\n",
" # data.append((padded_history, sample_outcome, 1))\n",
" data.append((padded_history, [0, 1]))\n",
"\n",
" return data\n",
"\n",
"\n",
" def load_data(self, file_good, file_bad):\n",
" data_good = self.process_file(file_good, True)\n",
" data_bad = self.process_file(file_bad, False)\n",
" data_good.extend(data_bad)\n",
"\n",
" return data_good\n",
"\n",
"def collate_fn(batch):\n",
" histories, outcomes = zip(*batch)\n",
"\n",
" # Convert nested lists to tensor\n",
" histories_tensor = torch.tensor(histories, dtype=torch.float32)\n",
" outcomes_tensor = torch.tensor(outcomes, dtype=torch.int64)\n",
"\n",
" return histories_tensor, outcomes_tensor\n",
"\n",
"dataset = JsonDataset('tic_tac_toe_games.json', 'tic_tac_toe_games_bad.json')\n",
"\n",
"total_size = len(dataset)\n",
"train_size = int(0.8 * total_size)\n",
"test_size = total_size - train_size\n",
"\n",
"train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
"\n",
"\n",
"train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
"test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Train\n",
"\n",
"In this training step we'll just use the CrossEntropyLoss and have the neural network classify good games and bad games."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
"model = TicTacToeNet().to(device)\n",
"criterion = nn.CrossEntropyLoss()\n",
"optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
"\n",
"# you may want to increase this\n",
"MAX_EPOCH = 1\n",
"\n",
"for epoch in range(MAX_EPOCH):\n",
" model.train()\n",
"\n",
" for history, valid in train_loader:\n",
"\n",
" history = history.to(device)\n",
" valid = valid.to(device)\n",
" optimizer.zero_grad()\n",
" prediction = model(history)\n",
" loss = criterion(prediction, valid)\n",
" loss.backward()\n",
" optimizer.step()\n",
"\n",
"\n",
" # Validation phase\n",
" model.eval()\n",
" total_count = 0\n",
" correct_count = 0\n",
"\n",
" with torch.no_grad():\n",
" for history, valid in test_loader:\n",
" history = history.to(device)\n",
" valid = valid.to(device)\n",
" prediction = model(history)\n",
"\n",
" # Convert predictions to class labels\n",
" _, predicted_labels = torch.max(prediction, 1)\n",
"\n",
" # Convert true labels to class labels\n",
" _, true_class_labels = torch.max(valid, 1)\n",
"\n",
" # Count correct predictions\n",
" correct_predictions = (predicted_labels == true_class_labels).sum().item()\n",
"\n",
" total_predictions = prediction.shape[0]\n",
"\n",
" # get values for the accuracy\n",
" correct_count += correct_predictions\n",
" total_count += total_predictions\n",
"\n",
"\n",
" accuracy = 100 * correct_count / total_count\n",
" print(f\"Epoch {epoch + 1}/{MAX_EPOCH} - Accuracy: {accuracy:.2f}%\")\n",
" print(history[-1])\n",
" print(valid[-1])\n",
" print(predicted_labels[-1])\n",
" print(true_class_labels[-1])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(prediction)\n",
"print(valid)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** It's reasonable for the tic tac toe model to approach 100% classification accuracy as the state space of the game is fairly small"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Export Onnx and Data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Set the model to evaluation mode\n",
"model = model.cpu()\n",
"model.eval()\n",
"\n",
"# Obtain a sample datapoint from the DataLoader\n",
"sample_data_iter = iter(train_loader)\n",
"sample_history, _ = next(sample_data_iter)\n",
"\n",
"# Move the sample datapoint to the cpu so it is the same as the model\n",
"x = sample_history.to('cpu')\n",
"\n",
"# Export the model using ONNX\n",
"torch.onnx.export(\n",
" model, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"tictactoe_network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={\n",
" 'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}\n",
" }\n",
")\n",
"\n",
"data_array = ((x[0]).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"data.json\", 'w'))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Prove the Tic Tac Toe Classification Model"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!RUST_LOG=trace"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import ezkl\n",
"\n",
"data_path = os.path.join(\"data.json\")\n",
"model_path = os.path.join('tictactoe_network.onnx')\n",
"compiled_model_path = os.path.join('network.ezkl')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"proof_path = os.path.join('proof.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.gen_settings(model_path, settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cal_path = os.path.join(\"calibration.json\")\n",
"\n",
"data_array = ((x[0:20]).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(cal_path, 'w'))\n",
"\n",
"\n",
"ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.get_srs(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.compile_circuit(model_path, compiled_model_path, settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"\n",
"with open(data_path, \"r\") as f:\n",
" data = json.load(f)\n",
" print(len(data['input_data'][0]))\n",
"\n",
"ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.mock(witness_path, compiled_model_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"accelerator": "GPU",
"colab": {
"gpuType": "T4",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/variance.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "uKQPd7_5ANe-"
},
"source": [
"# Calculate the variance of an asset \n",
"\n",
"In this example we will calculate the variance of an asset using ezkl. Here's a diagram of the process:\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2wIAHwqH2_mo"
},
"source": [
"**Import Dependencies**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "9Byiv2Nc2MsK"
},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"import ezkl\n",
"import torch\n",
"import datetime\n",
"import pandas as pd\n",
"import requests\n",
"import json\n",
"import os"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "osjj-0Ta3E8O"
},
"source": [
"**Create Computational Graph**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "x1vl9ZXF3EEW",
"outputId": "bda21d02-fe5f-4fb2-8106-f51a8e2e67aa"
},
"outputs": [],
"source": [
"from torch import nn\n",
"import torch\n",
"\n",
"\n",
"class Model(nn.Module):\n",
" def __init__(self):\n",
" super(Model, self).__init__()\n",
"\n",
" # x is a time series maybe the ETH/USDC price, that we get from Uni Oracle\n",
" def forward(self, x):\n",
" # return [torch.var(x, unbiased=False, dim=[1,2])]\n",
" return [torch.mean(x)]\n",
"\n",
"\n",
"\n",
"\n",
"circuit = Model()\n",
"\n",
"\n",
"\n",
"\n",
"x = 0.1*torch.rand(1,*[1,20], requires_grad=True)\n",
"\n",
"# # print(torch.__version__)\n",
"device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
"\n",
"print(device)\n",
"\n",
"circuit.to(device)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
"# Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" \"lol.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=11, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"# export(circuit, input_shape=[1, 20])\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "E3qCeX-X5xqd"
},
"source": [
"**Set Data Source and Get Data**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "6RAMplxk5xPk",
"outputId": "bd2158fe-0c00-44fd-e632-6a3f70cdb7c9"
},
"outputs": [],
"source": [
"\n",
"def get_url(coin, currency, start, end):\n",
" url = f\"https://api.coingecko.com/api/v3/coins/{coin}/market_chart/range?vs_currency={currency}&from={start}&to={end}\"\n",
" return url\n",
"\n",
"\n",
"timenow = datetime.datetime.now()\n",
"timenow_unix_sec = int(datetime.datetime.timestamp(timenow))\n",
"time7days = timenow - datetime.timedelta(days=7)\n",
"time7days_unix_sec = int(datetime.datetime.timestamp(time7days))\n",
"\n",
"print(timenow_unix_sec)\n",
"print(time7days_unix_sec)\n",
"\n",
"eth_price_url = get_url(\"ethereum\", \"usd\", time7days_unix_sec, timenow_unix_sec)\n",
"print(eth_price_url)\n",
"\n",
"data = requests.get(eth_price_url)\n",
"print(data)\n",
"\n",
"new_data = {\"time\": [], \"prices\": []}\n",
"\n",
"for k, v in data.json().items():\n",
" if k == \"prices\":\n",
" for x in v:\n",
" new_data[\"time\"].append(x[0])\n",
" new_data[\"prices\"].append(x[1])\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 424
},
"id": "WSj1Uxln65vf",
"outputId": "51422d71-9680-4b51-c4df-e400d20f988b"
},
"outputs": [],
"source": [
"df = pd.DataFrame(new_data)\n",
"df\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eLJ7oirQ_HQR"
},
"source": [
"**EZKL Workflow**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# make an input.json file from the df above\n",
"input_filename = os.path.join('input.json')\n",
"# get the last 20 prices and make a list\n",
"df_prices = df['prices'].tail(20).tolist()\n",
"\n",
"data = dict(input_data = [df_prices])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(input_filename, 'w' ))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "4MmE9SX66_Il",
"outputId": "16403639-66a4-4280-ac7f-6966b75de5a3"
},
"outputs": [],
"source": [
"# generate settings\n",
"onnx_filename = os.path.join('lol.onnx')\n",
"compiled_filename = os.path.join('lol.compiled')\n",
"settings_filename = os.path.join('settings.json')\n",
"srs_path = os.path.join('kzg.params')\n",
"\n",
"\n",
"\n",
"ezkl.gen_settings(onnx_filename, settings_filename)\n",
"ezkl.calibrate_settings(\n",
" input_filename, onnx_filename, settings_filename, \"resources\", scales = [4])\n",
"res = ezkl.get_srs(settings_filename)\n",
"ezkl.compile_circuit(onnx_filename, compiled_filename, settings_filename)\n",
"\n",
"# show the settings.json\n",
"with open(\"settings.json\") as f:\n",
" data = json.load(f)\n",
" json_formatted_str = json.dumps(data, indent=2)\n",
"\n",
" print(json_formatted_str)\n",
"\n",
"assert os.path.exists(\"settings.json\")\n",
"assert os.path.exists(\"input.json\")\n",
"assert os.path.exists(\"lol.onnx\")"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"id": "fULvvnK7_CMb"
},
"outputs": [],
"source": [
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"\n",
"\n",
"# setup the proof\n",
"res = ezkl.setup(\n",
" compiled_filename,\n",
" vk_path,\n",
" pk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_filename)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Oog3j6Kd-Wed",
"outputId": "5839d0c1-5b43-476e-c2f8-6707de562260"
},
"outputs": [],
"source": [
"# prove the zk circuit\n",
"# GENERATE A PROOF\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"\n",
"proof = ezkl.prove(\n",
" witness_path,\n",
" compiled_filename,\n",
" pk_path,\n",
" proof_path,\n",
" \"single\",\n",
" )\n",
"\n",
"\n",
"assert os.path.isfile(proof_path)\n",
"\n",
"# verify\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_filename,\n",
" vk_path,\n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "W7tAa-DFAtvS"
},
"source": [
"# Part 2 (Using the ZK Computational Graph Onchain!)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8Ym91kaVAIB6"
},
"source": [
"**Now How Do We Do It Onchain?????**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 339
},
"id": "fodkNgwS70FM",
"outputId": "827b5efd-f74f-44de-c114-861b3a86daf2"
},
"outputs": [],
"source": [
"# first we need to create evm verifier\n",
"print(vk_path)\n",
"print(settings_filename)\n",
"\n",
"\n",
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" settings_filename,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Make sure anvil is running locally first\n",
"# run with $ anvil -p 3030\n",
"# we use the default anvil node here\n",
"import json\n",
"\n",
"address_path = os.path.join(\"address.json\")\n",
"\n",
"res = ezkl.deploy_evm(\n",
" address_path,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True\n",
"\n",
"with open(address_path, 'r') as file:\n",
" addr = file.read().rstrip()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# read the address from addr_path\n",
"addr = None\n",
"with open(address_path, 'r') as f:\n",
" addr = f.read()\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" \"http://127.0.0.1:3030\"\n",
")\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "mPFmUizd_gCp"
},
"outputs": [],
"source": []
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/voice_judge.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# Voice judgoor\n",
"\n",
"Here we showcase a full-end-to-end flow of:\n",
"1. training a model for a specific task (judging voices)\n",
"2. creating a proof of judgment\n",
"3. creating and deploying an evm verifier\n",
"4. verifying the proof of judgment using the verifier\n",
"\n",
"First we download a few voice related datasets from kaggle, which are all labelled using the same emotion and tone labelling standard.\n",
"\n",
"We have 8 emotions in both speaking and singing datasets: neutral, calm, happy, sad, angry, fear, disgust, surprise.\n",
"\n",
"To download the dataset make sure you have the kaggle cli installed in your local env `pip install kaggle`. Make sure you set up your `kaggle.json` file as detailed [here](https://www.kaggle.com/docs/api#getting-started-installation-&-authentication).\n",
"Then run the associated `voice_data.sh` data download script: `sh voice_data.sh`.\n",
"\n",
"Make sure you set the `VOICE_DATA_DIR` variables to point to the directory the `voice_data.sh` script has downloaded to. This script also accepts an argument to download to a specific directory: `sh voice_data.sh /path/to/voice/data`.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"import os\n",
"# os.environ[\"VOICE_DATA_DIR\"] = \".\"\n",
"\n",
"voice_data_dir = os.environ.get('VOICE_DATA_DIR')\n",
"\n",
"# if is none set to \"\"\n",
"if voice_data_dir is None:\n",
" voice_data_dir = \"\"\n",
"\n",
"print(\"voice_data_dir: \", voice_data_dir)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### TESS Dataset"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import pandas as pd\n",
"import logging\n",
"\n",
"# read in VOICE_DATA_DIR from environment variable\n",
"\n",
"# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
"# logging.basicConfig(format=FORMAT)\n",
"# logging.getLogger().setLevel(logging.INFO)\n",
"\n",
"\n",
"Tess = os.path.join(voice_data_dir, \"data/TESS/\")\n",
"\n",
"tess = os.listdir(Tess)\n",
"\n",
"emotions = []\n",
"files = []\n",
"\n",
"for item in tess:\n",
" items = os.listdir(Tess + item)\n",
" for file in items:\n",
" part = file.split('.')[0]\n",
" part = part.split('_')[2]\n",
" if part == 'ps':\n",
" emotions.append('surprise')\n",
" else:\n",
" emotions.append(part)\n",
" files.append(Tess + item + '/' + file)\n",
"\n",
"tess_df = pd.concat([pd.DataFrame(emotions, columns=['Emotions']), pd.DataFrame(files, columns=['Files'])], axis=1)\n",
"tess_df"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### RAVDESS SONG dataset"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"Ravdess = os.path.join(voice_data_dir, \"data/RAVDESS_SONG/audio_song_actors_01-24/\")\n",
"\n",
"ravdess_list = os.listdir(Ravdess)\n",
"\n",
"files = []\n",
"emotions = []\n",
"\n",
"for item in ravdess_list:\n",
" actor = os.listdir(Ravdess + item)\n",
" for file in actor:\n",
" name = file.split('.')[0]\n",
" parts = name.split('-')\n",
" emotions.append(int(parts[2]))\n",
" files.append(Ravdess + item + '/' + file)\n",
"\n",
"emotion_data = pd.DataFrame(emotions, columns=['Emotions'])\n",
"files_data = pd.DataFrame(files, columns=['Files'])\n",
"\n",
"ravdess_song_df = pd.concat([emotion_data, files_data], axis=1)\n",
"\n",
"ravdess_song_df.Emotions.replace({1:'neutral', 2:'calm', 3:'happy', 4:'sad', 5:'angry', 6:'fear', 7:'disgust', 8:'surprise'}, inplace=True)\n",
"\n",
"ravdess_song_df"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### RAVDESS SPEECH Dataset"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"Ravdess = os.path.join(voice_data_dir, \"data/RAVDESS_SPEECH/audio_speech_actors_01-24/\")\n",
"\n",
"ravdess_list = os.listdir(Ravdess)\n",
"\n",
"files = []\n",
"emotions = []\n",
"\n",
"for item in ravdess_list:\n",
" actor = os.listdir(Ravdess + item)\n",
" for file in actor:\n",
" name = file.split('.')[0]\n",
" parts = name.split('-')\n",
" emotions.append(int(parts[2]))\n",
" files.append(Ravdess + item + '/' + file)\n",
" \n",
"emotion_data = pd.DataFrame(emotions, columns=['Emotions'])\n",
"files_data = pd.DataFrame(files, columns=['Files'])\n",
"\n",
"ravdess_df = pd.concat([emotion_data, files_data], axis=1)\n",
"\n",
"ravdess_df.Emotions.replace({1:'neutral', 2:'calm', 3:'happy', 4:'sad', 5:'angry', 6:'fear', 7:'disgust', 8:'surprise'}, inplace=True)\n",
"\n",
"ravdess_df"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### CREMA Dataset"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"Crema = os.path.join(voice_data_dir, \"data/CREMA-D/\")\n",
"\n",
"crema = os.listdir(Crema)\n",
"emotions = []\n",
"files = []\n",
"\n",
"for item in crema:\n",
" files.append(Crema + item)\n",
" \n",
" parts = item.split('_')\n",
" if parts[2] == 'SAD':\n",
" emotions.append('sad')\n",
" elif parts[2] == 'ANG':\n",
" emotions.append('angry')\n",
" elif parts[2] == 'DIS':\n",
" emotions.append('disgust')\n",
" elif parts[2] == 'FEA':\n",
" emotions.append('fear')\n",
" elif parts[2] == 'HAP':\n",
" emotions.append('happy')\n",
" elif parts[2] == 'NEU':\n",
" emotions.append('neutral')\n",
" else :\n",
" emotions.append('unknown')\n",
" \n",
"emotions_data = pd.DataFrame(emotions, columns=['Emotions'])\n",
"files_data = pd.DataFrame(files, columns=['Files'])\n",
"\n",
"crema_df = pd.concat([emotions_data, files_data], axis=1)\n",
"\n",
"crema_df"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### SAVEE Dataset"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"Savee = os.path.join(voice_data_dir,\"data/SAVEE/\")\n",
"\n",
"savee = os.listdir(Savee)\n",
"\n",
"emotions = []\n",
"files = []\n",
"\n",
"for item in savee:\n",
" files.append(Savee + item)\n",
" part = item.split('_')[1]\n",
" ele = part[:-6]\n",
" if ele == 'a':\n",
" emotions.append('angry')\n",
" elif ele == 'd':\n",
" emotions.append('disgust')\n",
" elif ele == 'f':\n",
" emotions.append('fear')\n",
" elif ele == 'h':\n",
" emotions.append('happy')\n",
" elif ele == 'n':\n",
" emotions.append('neutral')\n",
" elif ele == 'sa':\n",
" emotions.append('sad')\n",
" else:\n",
" emotions.append('surprise')\n",
"\n",
"savee_df = pd.concat([pd.DataFrame(emotions, columns=['Emotions']), pd.DataFrame(files, columns=['Files'])], axis=1)\n",
"savee_df"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Combining all datasets"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"df = pd.concat([ravdess_df, ravdess_song_df, crema_df, tess_df, savee_df], axis = 0)\n",
"# relabel indices\n",
"df.index = range(len(df.index))\n",
"df.to_csv(\"df.csv\",index=False)\n",
"df\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import seaborn as sns\n",
"sns.histplot(data=df, x=\"Emotions\")\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Training \n",
"\n",
"Here we convert all audio files into 2D frequency-domain spectrograms so that we can leverage convolutional neural networks, which tend to be more efficient than time-series model like RNNs or LSTMs.\n",
"We thus: \n",
"1. Extract the mel spectrogram from each of the audio recordings. \n",
"2. Rescale each of these to the decibel (DB) scale. \n",
"3. Define the model as the following model: `(x) -> (conv) -> (relu) -> (linear) -> (y)`\n",
"\n",
"\n",
"You may notice that we introduce a second computational graph `(key) -> (key)`. The reasons for this are to do with MEV, and if you are not interested you can skip the following paragraph. \n",
"\n",
"Let's say that obtaining a high score from the judge and then submitting said score to the EVM verifier could result in the issuance of a reward (financial or otherwise). There is an incentive then for MEV bots to scalp any issued valid proof and submit a duplicate transaction with the same proof to the verifier contract in the hopes of obtaining the reward before the original issuer. Here we add `(key) -> (key)` such that the transaction creator's public key / address is both a private input AND a public input to the proof. As such the on-chain verification only succeeds if the key passed in during proof time is also passed in as a public input to the contract. The reward issued by the contract can then be irrevocably tied to that key such that even if the proof is submitted by another actor, the reward would STILL go to the original singer / transaction issuer. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"import librosa\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"#stft extraction from augmented data\n",
"def extract_mel_spec(filename):\n",
" x,sr=librosa.load(filename,duration=3,offset=0.5)\n",
" X = librosa.feature.melspectrogram(y=x, sr=sr)\n",
" Xdb = librosa.power_to_db(X, ref=np.max)\n",
" Xdb = Xdb.reshape(1,128,-1)\n",
" return Xdb\n",
"\n",
"Xdb=df.iloc[:,1].apply(lambda x: extract_mel_spec(x))\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we convert label to a number between 0 and 1 where 1 is pleasant surprised and 0 is disgust and the rest are floats in between. The model loves pleasantly surprised voices and hates disgust ;) "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# get max size\n",
"max_size = 0\n",
"for i in range(len(Xdb)):\n",
" if Xdb[i].shape[2] > max_size:\n",
" max_size = Xdb[i].shape[2]\n",
"\n",
"# 0 pad 2nd dim to max size\n",
"Xdb=Xdb.apply(lambda x: np.pad(x,((0,0),(0,0),(0,max_size-x.shape[2]))))\n",
"\n",
"Xdb=pd.DataFrame(Xdb)\n",
"Xdb['label'] = df['Emotions']\n",
"# convert label to a number between 0 and 1 where 1 is pleasant surprised and 0 is disgust and the rest are floats in betwee\n",
"Xdb['label'] = Xdb['label'].apply(lambda x: 1 if x=='surprise' else 0 if x=='disgust' else 0.2 if x=='fear' else 0.4 if x=='happy' else 0.6 if x=='sad' else 0.8)\n",
"\n",
"Xdb.iloc[0,0][0].shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"# Defines the model\n",
"# we got convs, we got relu, we got linear layers\n",
"# What else could one want ????\n",
"\n",
"class MyModel(nn.Module):\n",
" def __init__(self):\n",
" super(MyModel, self).__init__()\n",
"\n",
" self.conv1 = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=5, stride=4)\n",
"\n",
" self.d1 = nn.Linear(992, 1)\n",
"\n",
" self.sigmoid = nn.Sigmoid()\n",
" self.relu = nn.ReLU()\n",
"\n",
" def forward(self, key, x):\n",
" # 32x1x28x28 => 32x32x26x26\n",
" x = self.conv1(x)\n",
" x = self.relu(x)\n",
" x = x.flatten(start_dim=1)\n",
" x = self.d1(x)\n",
" x = self.sigmoid(x)\n",
"\n",
" return [key, x]\n",
"\n",
"\n",
"circuit = MyModel()\n",
"\n",
"output = circuit(0, torch.tensor(Xdb.iloc[0,0][0].reshape(1,1,128,130)))\n",
"\n",
"output\n",
"\n",
"\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we leverage the classic Adam optimizer, coupled with 0.001 weight decay so as to regularize the model. The weight decay (a.k.a L2 regularization) can also help on the zk-circuit end of things in that it prevents inputs to Halo2 lookup tables from falling out of range (lookup tables are how we represent non-linearities like ReLU and Sigmoid inside our circuits). "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from tqdm import tqdm\n",
"\n",
"# Train the model using pytorch\n",
"n_epochs = 10 # number of epochs to run\n",
"batch_size = 10 # size of each batch\n",
"\n",
"\n",
"loss_fn = nn.MSELoss() #MSE\n",
"# adds l2 regularization\n",
"optimizer = torch.optim.Adam(circuit.parameters(), lr=0.001, weight_decay=0.001)\n",
"\n",
"# randomly shuffle dataset\n",
"Xdb = Xdb.sample(frac=1).reset_index(drop=True)\n",
"\n",
"# split into train and test and validation sets with 80% train, 10% test, 10% validation\n",
"train = Xdb.iloc[:int(len(Xdb)*0.8)]\n",
"test = Xdb.iloc[int(len(Xdb)*0.8):int(len(Xdb)*0.9)]\n",
"val = Xdb.iloc[int(len(Xdb)*0.9):]\n",
"\n",
"batches_per_epoch = len(train)\n",
"\n",
"\n",
"def get_loss(Xbatch, ybatch):\n",
" y_pred = circuit(0, Xbatch)[1]\n",
" loss = loss_fn(y_pred, ybatch)\n",
" return loss\n",
"\n",
"for epoch in range(n_epochs):\n",
" # X is a torch Variable\n",
" permutation = torch.randperm(batches_per_epoch)\n",
"\n",
" with tqdm(range(batches_per_epoch), unit=\"batch\", mininterval=0) as bar:\n",
" bar.set_description(f\"Epoch {epoch}\")\n",
" for i in bar:\n",
" start = i * batch_size\n",
" # take a batch\n",
" indices = np.random.choice(batches_per_epoch, batch_size)\n",
"\n",
" data = np.concatenate(train.iloc[indices.tolist(),0].values)\n",
" labels = train.iloc[indices.tolist(),1].values.astype(np.float32)\n",
"\n",
" data = data.reshape(batch_size,1,128,130)\n",
" labels = labels.reshape(batch_size,1)\n",
"\n",
" # convert to tensors\n",
" Xbatch = torch.tensor(data)\n",
" ybatch = torch.tensor(labels)\n",
"\n",
" # forward pass\n",
" loss = get_loss(Xbatch, ybatch)\n",
" # backward pass\n",
" optimizer.zero_grad()\n",
" loss.backward()\n",
" # update weights\n",
" optimizer.step()\n",
"\n",
" bar.set_postfix(\n",
" batch_loss=float(loss),\n",
" )\n",
" # get validation loss\n",
" val_data = np.concatenate(val.iloc[:,0].values)\n",
" val_labels = val.iloc[:,1].values.astype(np.float32)\n",
" val_data = val_data.reshape(len(val),1,128,130)\n",
" val_labels = val_labels.reshape(len(val),1)\n",
" val_loss = get_loss(torch.tensor(val_data), torch.tensor(val_labels))\n",
" print(f\"Validation loss: {val_loss}\")\n",
"\n",
"\n",
"\n",
"# get validation loss\n",
"test_data = np.concatenate(test.iloc[:,0].values)\n",
"test_labels = val.iloc[:,1].values.astype(np.float32)\n",
"test_data = val_data.reshape(len(val),1,128,130)\n",
"test_labels = val_labels.reshape(len(val),1)\n",
"test_loss = get_loss(torch.tensor(test_data), torch.tensor(test_labels))\n",
"print(f\"Test loss: {test_loss}\")\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#\n",
"val_data = {\n",
" \"input_data\": [np.zeros(100).tolist(), np.concatenate(val.iloc[:100,0].values).flatten().tolist()],\n",
"}\n",
"# save as json file\n",
"with open(\"val_data.json\", \"w\") as f:\n",
" json.dump(val_data, f)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 0.1*torch.rand(1,*[1, 128, 130], requires_grad=True)\n",
"key = torch.rand(1,*[1], requires_grad=True)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" (key, x), # model input (or a tuple for multiple inputs)\n",
" \"network.onnx\", # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" dynamic_axes={'input' : {0 : 'batch_size'},\n",
" 'input.1' : {0 : 'batch_size'}, # variable length axes\n",
" 'output' : {0 : 'batch_size'}})\n",
"\n",
"key_array = ((key).detach().numpy()).reshape([-1]).tolist()\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [key_array, data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(\"input.json\", 'w' ))\n",
"\n",
"\n",
"# ezkl.export(circuit, input_shape = [[1], [1025, 130]], run_gen_witness=False, run_calibrate_settings=False)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we set the visibility of the different parts of the circuit, whereby the model params and the outputs of the computational graph (the key and the judgment) are public"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import ezkl\n",
"import os \n",
"\n",
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"srs_path = os.path.join('kzg.params')\n",
"data_path = os.path.join('input.json')\n",
"val_data = os.path.join('val_data.json')\n",
"\n",
"run_args = ezkl.PyRunArgs()\n",
"run_args.input_visibility = \"private\"\n",
"run_args.param_visibility = \"fixed\"\n",
"run_args.output_visibility = \"public\"\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
"\n",
"You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we use the validation dataset we used during training. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
"assert res == True\n",
"print(\"verified\")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
"\n",
"These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.get_srs(settings_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"We now need to generate the (partial) circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"witness_path = \"witness.json\"\n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"As a sanity check we can run a mock proof. This just checks that all the constraints are valid. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"res = ezkl.mock(witness_path, compiled_model_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!export RUST_LOG=trace\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we generate a full proof. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"And verify it as a sanity check. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"vk_path = os.path.join('test.vk')\n",
"srs_path = os.path.join('kzg.params')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" \n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"\n",
"assert res == True"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Verify if the Verifier Works Locally"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Deploy The Contract"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Make sure anvil is running locally first\n",
"# run with $ anvil -p 3030\n",
"# we use the default anvil node here\n",
"import json\n",
"\n",
"address_path = os.path.join(\"address.json\")\n",
"\n",
"res = ezkl.deploy_evm(\n",
" address_path,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True\n",
"\n",
"with open(address_path, 'r') as file:\n",
" addr = file.read().rstrip()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# make sure anvil is running locally\n",
"# $ anvil -p 3030\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" \"http://127.0.0.1:3030\"\n",
")\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/world_rotation.ipynb | {
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## World rotation\n",
"\n",
"Here we demonstrate how to use the EZKL package to rotate an on-chain world. \n",
"\n",
"\n",
"> **A typical ZK application flow**. For the shape rotators out there — this is an easily digestible example. A user computes a ZK-proof that they have calculated a valid rotation of a world. They submit this proof to a verifier contract which governs an on-chain world, along with a new set of coordinates, and the world rotation updates. Observe that it’s possible for one player to initiate a *global* change.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from torch import nn\n",
"import ezkl\n",
"import os\n",
"import json\n",
"import torch\n",
"import math\n",
"\n",
"# these are constants for the rotation\n",
"phi = torch.tensor(5 * math.pi / 180)\n",
"s = torch.sin(phi)\n",
"c = torch.cos(phi)\n",
"\n",
"\n",
"class RotateStuff(nn.Module):\n",
" def __init__(self):\n",
" super(RotateStuff, self).__init__()\n",
"\n",
" # create a rotation matrix -- the matrix is constant and is transposed for convenience\n",
" self.rot = torch.stack([torch.stack([c, -s]),\n",
" torch.stack([s, c])]).t()\n",
"\n",
" def forward(self, x):\n",
" x_rot = x @ self.rot # same as x_rot = (rot @ x.t()).t() due to rot in O(n) (SO(n) even)\n",
" return x_rot\n",
"\n",
"\n",
"circuit = RotateStuff()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This will showcase the principle directions of rotation by plotting the rotation of a single unit vector."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from matplotlib import pyplot\n",
"pyplot.figure(figsize=(3, 3))\n",
"pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
"pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
"pyplot.arrow(0, 0, circuit.rot[0, 0].item(), circuit.rot[0, 1].item(), width=0.02)\n",
"pyplot.arrow(0, 0, circuit.rot[1, 0].item(), circuit.rot[1, 1].item(), width=0.02)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"srs_path = os.path.join('kzg.srs')\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# initial principle vectors for the rotation are as in the plot above\n",
"x = torch.tensor([[1, 0], [0, 1]], dtype=torch.float32)\n",
"\n",
"# Flips the neural net into inference mode\n",
"circuit.eval()\n",
"\n",
" # Export the model\n",
"torch.onnx.export(circuit, # model being run\n",
" x, # model input (or a tuple for multiple inputs)\n",
" model_path, # where to save the model (can be a file or file-like object)\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=10, # the ONNX version to export the model to\n",
" do_constant_folding=True, # whether to execute constant folding for optimization\n",
" input_names = ['input'], # the model's input names\n",
" output_names = ['output'], # the model's output names\n",
" )\n",
"\n",
"data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_data = [data_array])\n",
"\n",
" # Serialize data into file:\n",
"json.dump( data, open(data_path, 'w' ))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### World rotation in 2D on-chain"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For demo purposes we deploy these coordinates to a contract running locally using Anvil. This creates our on-chain world. We then rotate the world using the EZKL package and submit the proof to the contract. The contract then updates the world rotation. For demo purposes we do this repeatedly, rotating the world by 1 transform each time."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import subprocess\n",
"import time\n",
"import threading\n",
"\n",
"# make sure anvil is running locally\n",
"# $ anvil -p 3030\n",
"\n",
"RPC_URL = \"http://localhost:3030\"\n",
"\n",
"# Save process globally\n",
"anvil_process = None\n",
"\n",
"def start_anvil():\n",
" global anvil_process\n",
" if anvil_process is None:\n",
" anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
" if anvil_process.returncode is not None:\n",
" raise Exception(\"failed to start anvil process\")\n",
" time.sleep(3)\n",
"\n",
"def stop_anvil():\n",
" global anvil_process\n",
" if anvil_process is not None:\n",
" anvil_process.terminate()\n",
" anvil_process = None\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
"- `input_visibility` defines the visibility of the model inputs\n",
"- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
"- `output_visibility` defines the visibility of the model outputs\n",
"\n",
"Here we create the following setup:\n",
"- `input_visibility`: \"public\"\n",
"- `param_visibility`: \"fixed\"\n",
"- `output_visibility`: public"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5e374a2",
"metadata": {},
"outputs": [],
"source": [
"py_run_args = ezkl.PyRunArgs()\n",
"py_run_args.input_visibility = \"public\"\n",
"py_run_args.output_visibility = \"public\"\n",
"py_run_args.param_visibility = \"private\" # private by default\n",
"py_run_args.scale_rebase_multiplier = 10\n",
"\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We also define a contract that holds out test data. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ezkl.setup_test_evm_witness(\n",
" data_path,\n",
" compiled_model_path,\n",
" # we write the call data to the same file as the input data\n",
" data_path,\n",
" input_source=ezkl.PyTestDataSource.OnChain,\n",
" output_source=ezkl.PyTestDataSource.File,\n",
" rpc_url=RPC_URL)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
"\n",
"These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"witness = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can now create an EVM verifier contract from our circuit. This contract will be deployed to the chain we are using. In this case we are using a local anvil instance."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"\n",
"res = ezkl.create_evm_verifier(\n",
" vk_path,\n",
" \n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"\n",
"addr_path_verifier = \"addr_verifier.txt\"\n",
"\n",
"res = ezkl.deploy_evm(\n",
" addr_path_verifier,\n",
" sol_code_path,\n",
" 'http://127.0.0.1:3030'\n",
")\n",
"\n",
"assert res == True"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. \n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"abi_path = 'test.abi'\n",
"sol_code_path = 'test.sol'\n",
"input_path = 'input.json'\n",
"\n",
"res = ezkl.create_evm_data_attestation(\n",
" input_path,\n",
" settings_path,\n",
" sol_code_path,\n",
" abi_path,\n",
" )"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"addr_path_da = \"addr_da.txt\"\n",
"\n",
"res = ezkl.deploy_da_evm(\n",
" addr_path_da,\n",
" input_path,\n",
" settings_path,\n",
" sol_code_path,\n",
" RPC_URL,\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we can pull in the data from the contract and calculate a new set of coordinates. We then rotate the world by 1 transform and submit the proof to the contract. The contract could then update the world rotation (logic not inserted here). For demo purposes we do this repeatedly, rotating the world by 1 transform. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# read the verifier address\n",
"addr_verifier = None\n",
"with open(addr_path_verifier, 'r') as f:\n",
" addr = f.read()\n",
"#read the data attestation address\n",
"addr_da = None\n",
"with open(addr_path_da, 'r') as f:\n",
" addr_da = f.read()\n",
"\n",
"res = ezkl.verify_evm(\n",
" addr,\n",
" proof_path,\n",
" RPC_URL,\n",
" addr_da,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As a sanity check lets plot the rotations of the unit vectors. We can see that the unit vectors rotate as expected by the output of the circuit. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"witness['outputs'][0][0]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"settings = json.load(open(settings_path, 'r'))\n",
"out_scale = settings[\"model_output_scales\"][0]\n",
"\n",
"from matplotlib import pyplot\n",
"pyplot.figure(figsize=(3, 3))\n",
"pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
"pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
"\n",
"arrow_x = ezkl.felt_to_float(witness['outputs'][0][0], out_scale)\n",
"arrow_y = ezkl.felt_to_float(witness['outputs'][0][1], out_scale)\n",
"pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)\n",
"arrow_x = ezkl.felt_to_float(witness['outputs'][0][2], out_scale)\n",
"arrow_y = ezkl.felt_to_float(witness['outputs'][0][3], out_scale)\n",
"pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/notebooks/xgboost.ipynb | {
"cells": [
{
"attachments": {
"image-3.png": {
"image/png": "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"
},
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
"metadata": {},
"source": [
"## XGBoost models\n",
"\n",
"\n",
"XGBoost based models are slightly finicky to get into a suitable onnx format. By default most tree based models will export into something that looks like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Processing such nodes can be difficult and error prone. It would be much better if the operations of the tree were represented as a proper graph, possibly ... like this: \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"This notebook showcases how to do that using the `hummingbird` python package ! "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a60b90d6",
"metadata": {},
"outputs": [],
"source": [
"!python -m pip install hummingbird_ml"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95613ee9",
"metadata": {},
"outputs": [],
"source": [
"# check if notebook is in colab\n",
"try:\n",
" # install ezkl\n",
" import google.colab\n",
" import subprocess\n",
" import sys\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
" subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"xgboost\"])\n",
"\n",
"# rely on local installation of ezkl if the notebook is not in colab\n",
"except:\n",
" pass\n",
"\n",
"\n",
"# here we create and (potentially train a model)\n",
"\n",
"# make sure you have the dependencies required here already installed\n",
"import json\n",
"import numpy as np\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.model_selection import train_test_split\n",
"from xgboost import XGBClassifier as Gbc\n",
"import torch\n",
"import ezkl\n",
"import os\n",
"from torch import nn\n",
"import xgboost as xgb\n",
"from hummingbird.ml import convert\n",
"\n",
"NUM_CLASSES = 3\n",
"\n",
"iris = load_iris()\n",
"X, y = iris.data, iris.target\n",
"X = X.astype(np.float32)\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
"clr = Gbc(n_estimators=12)\n",
"clr.fit(X_train, y_train)\n",
"\n",
"# convert to torch\n",
"\n",
"\n",
"torch_gbt = convert(clr, 'torch')\n",
"\n",
"print(torch_gbt)\n",
"# assert predictions from torch are = to sklearn\n",
"diffs = []\n",
"\n",
"for i in range(len(X_test)):\n",
" torch_pred = torch_gbt.predict(torch.tensor(X_test[i].reshape(1, -1)))\n",
" sk_pred = clr.predict(X_test[i].reshape(1, -1))\n",
" diffs.append(torch_pred != sk_pred[0])\n",
"\n",
"print(\"num diff: \", sum(diffs))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b37637c4",
"metadata": {},
"outputs": [],
"source": [
"model_path = os.path.join('network.onnx')\n",
"compiled_model_path = os.path.join('network.compiled')\n",
"pk_path = os.path.join('test.pk')\n",
"vk_path = os.path.join('test.vk')\n",
"settings_path = os.path.join('settings.json')\n",
"\n",
"witness_path = os.path.join('witness.json')\n",
"data_path = os.path.join('input.json')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82db373a",
"metadata": {},
"outputs": [],
"source": [
"# !!!!!!!!!!!!!!!!! This cell will flash a warning about onnx runtime compat but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
"\n",
"\n",
"# export to onnx format\n",
"\n",
"\n",
"# Input to the model\n",
"shape = X_train.shape[1:]\n",
"x = torch.rand(1, *shape, requires_grad=False)\n",
"torch_out = torch_gbt.predict(x)\n",
"# Export the model\n",
"torch.onnx.export(torch_gbt.model, # model being run\n",
" # model input (or a tuple for multiple inputs)\n",
" x,\n",
" # where to save the model (can be a file or file-like object)\n",
" \"network.onnx\",\n",
" export_params=True, # store the trained parameter weights inside the model file\n",
" opset_version=18, # the ONNX version to export the model to\n",
" input_names=['input'], # the model's input names\n",
" output_names=['output'], # the model's output names\n",
" dynamic_axes={'input': {0: 'batch_size'}, # variable length axes\n",
" 'output': {0: 'batch_size'}})\n",
"\n",
"d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
"\n",
"data = dict(input_shapes=[shape],\n",
" input_data=[d],\n",
" output_data=[(o).reshape([-1]).tolist() for o in torch_out])\n",
"\n",
"# Serialize data into file:\n",
"json.dump(data, open(\"input.json\", 'w'))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"run_args = ezkl.PyRunArgs()\n",
"run_args.variables = [(\"batch_size\", 1)]\n",
"\n",
"# TODO: Dictionary outputs\n",
"res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
"assert res == True\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# generate a bunch of dummy calibration data\n",
"cal_data = {\n",
" \"input_data\": [(torch.rand(20, *shape)).flatten().tolist()],\n",
"}\n",
"\n",
"cal_path = os.path.join('calibration.json')\n",
"# save as json file\n",
"with open(cal_path, \"w\") as f:\n",
" json.dump(cal_data, f)\n",
"\n",
"res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aa4f090",
"metadata": {},
"outputs": [],
"source": [
"res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
"assert res == True"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b74dcee",
"metadata": {},
"outputs": [],
"source": [
"# srs path\n",
"res = ezkl.get_srs( settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18c8b7c7",
"metadata": {},
"outputs": [],
"source": [
"# now generate the witness file \n",
"\n",
"res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
"assert os.path.isfile(witness_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1c561a8",
"metadata": {},
"outputs": [],
"source": [
"\n",
"# HERE WE SETUP THE CIRCUIT PARAMS\n",
"# WE GOT KEYS\n",
"# WE GOT CIRCUIT PARAMETERS\n",
"# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
"\n",
"\n",
"\n",
"res = ezkl.setup(\n",
" compiled_model_path,\n",
" vk_path,\n",
" pk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"assert os.path.isfile(vk_path)\n",
"assert os.path.isfile(pk_path)\n",
"assert os.path.isfile(settings_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c384cbc8",
"metadata": {},
"outputs": [],
"source": [
"# GENERATE A PROOF\n",
"\n",
"\n",
"proof_path = os.path.join('test.pf')\n",
"\n",
"res = ezkl.prove(\n",
" witness_path,\n",
" compiled_model_path,\n",
" pk_path,\n",
" proof_path,\n",
" \n",
" \"single\",\n",
" )\n",
"\n",
"print(res)\n",
"assert os.path.isfile(proof_path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f00d41",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1f50a8d0",
"metadata": {},
"outputs": [],
"source": [
"# VERIFY IT\n",
"\n",
"res = ezkl.verify(\n",
" proof_path,\n",
" settings_path,\n",
" vk_path,\n",
" \n",
" )\n",
"\n",
"assert res == True\n",
"print(\"verified\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_average/gen.py | from torch import nn
from ezkl import export
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.AvgPool2d(2, 1, (1, 1))
def forward(self, x):
return self.layer(x)[0]
circuit = Model()
export(circuit, input_shape=[3, 2, 2])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_batch_norm/gen.py | from torch import nn
from ezkl import export
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.BatchNorm2d(3)
def forward(self, x):
return self.layer(x)
circuit = Model()
export(circuit, input_shape=[3, 2, 2])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_concat/gen.py | import torch
from torch import nn
from ezkl import export
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
def forward(self, x):
return torch.concat([x, x], 2)
circuit = MyModel()
export(circuit, input_shape=[3, 2, 3, 2, 2])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_conv/gen.py | from torch import nn
from ezkl import export
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.Conv2d(3, 1, (1, 1), 1, 1)
def forward(self, x):
return self.layer(x)
circuit = Model()
export(circuit, input_shape = [3, 1, 1])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_conv_transpose/gen.py | import io
import numpy as np
from torch import nn
import torch.onnx
import torch.nn as nn
import torch.nn.init as init
import json
class Circuit(nn.Module):
def __init__(self, inplace=False):
super(Circuit, self).__init__()
self.convtranspose = nn.ConvTranspose2d(3, 3, (5, 5), stride=2, padding=2, output_padding=1)
def forward(self, x):
y = self.convtranspose(x)
return y
def main():
torch_model = Circuit()
# Input to the model
shape = [3, 5, 5]
x = 0.1*torch.rand(1,*shape, requires_grad=True)
torch_out = torch_model(x)
# Export the model
torch.onnx.export(torch_model, # model being run
(x), # model input (or a tuple for multiple inputs)
"network.onnx", # where to save the model (can be a file or file-like object)
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names = ['input'], # the model's input names
output_names = ['output'], # the model's output names
dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes
'output' : {0 : 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_shapes = [shape],
input_data = [d],
output_data = [((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])
# Serialize data into file:
json.dump(data, open("input.json", 'w'))
if __name__ == "__main__":
main() | https://github.com/zkonduit/ezkl |
examples/onnx/1l_div/gen.py | from torch import nn
from ezkl import export
class Circuit(nn.Module):
def __init__(self, inplace=False):
super(Circuit, self).__init__()
def forward(self, x):
return x/ 10
circuit = Circuit()
export(circuit, input_shape = [1])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_downsample/gen.py | from torch import nn
from ezkl import export
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.Conv2d(3, 1, (1, 1), 2, 1)
def forward(self, x):
return self.layer(x)
circuit = Model()
export(circuit, input_shape=[3, 6, 6])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_eltwise_div/gen.py | from torch import nn
from ezkl import export
class Circuit(nn.Module):
def __init__(self, inplace=False):
super(Circuit, self).__init__()
def forward(self, x):
return x/(2*x)
circuit = Circuit()
export(circuit, input_shape=[1])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_elu/gen.py | from torch import nn
import torch
import json
class Circuit(nn.Module):
def __init__(self):
super(Circuit, self).__init__()
self.layer = nn.ELU()
def forward(self, x):
return self.layer(x)
def main():
torch_model = Circuit()
# Input to the model
shape = [3, 2, 3]
x = 0.1*torch.rand(1, *shape, requires_grad=True)
torch_out = torch_model(x)
# Export the model
torch.onnx.export(torch_model, # model being run
# model input (or a tuple for multiple inputs)
x,
# where to save the model (can be a file or file-like object)
"network.onnx",
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names=['input'], # the model's input names
output_names=['output'], # the model's output names
dynamic_axes={'input': {0: 'batch_size'}, # variable length axes
'output': {0: 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_shapes=[shape, shape, shape],
input_data=[d],
output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])
# Serialize data into file:
json.dump(data, open("input.json", 'w'))
if __name__ == "__main__":
main()
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_erf/gen.py | import json
import torch
from torch import nn
class Circuit(nn.Module):
def __init__(self):
super(Circuit, self).__init__()
def forward(self, x):
return torch.special.erf(x)
def main():
torch_model = Circuit()
# Input to the model
shape = [3]
x = torch.rand(1,*shape, requires_grad=True)
torch_out = torch_model(x)
# Export the model
torch.onnx.export(torch_model, # model being run
x, # model input (or a tuple for multiple inputs)
"network.onnx", # where to save the model (can be a file or file-like object)
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names = ['input'], # the model's input names
output_names = ['output'], # the model's output names
dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes
'output' : {0 : 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_shapes = [shape],
input_data = [d],
output_data = [((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])
# Serialize data into file:
json.dump( data, open( "input.json", 'w' ) )
if __name__ == "__main__":
main()
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_flatten/gen.py | import io
import numpy as np
from torch import nn
import torch.onnx
import torch.nn as nn
import torch.nn.init as init
import json
class Circuit(nn.Module):
def __init__(self):
super(Circuit, self).__init__()
self.flatten = nn.Flatten()
def forward(self, x):
return self.flatten(x)
def main():
torch_model = Circuit()
# Input to the model
shape = [3, 2, 3]
x = 0.1*torch.rand(1,*shape, requires_grad=True)
torch_out = torch_model(x)
# Export the model
torch.onnx.export(torch_model, # model being run
x, # model input (or a tuple for multiple inputs)
"network.onnx", # where to save the model (can be a file or file-like object)
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names = ['input'], # the model's input names
output_names = ['output'], # the model's output names
dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes
'output' : {0 : 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_shapes = [shape, shape, shape],
input_data = [d],
output_data = [((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])
# Serialize data into file:
json.dump( data, open( "input.json", 'w' ) )
if __name__ == "__main__":
main()
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_gelu_noappx/gen.py | import json
import torch
from torch import nn
class Circuit(nn.Module):
def __init__(self):
super(Circuit, self).__init__()
self.layer = nn.GELU() # approximation = false in our case
def forward(self, x):
return self.layer(x)
def main():
torch_model = Circuit()
# Input to the model
shape = [3]
x = torch.rand(1,*shape, requires_grad=True)
torch_out = torch_model(x)
# Export the model
torch.onnx.export(torch_model, # model being run
x, # model input (or a tuple for multiple inputs)
"network.onnx", # where to save the model (can be a file or file-like object)
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names = ['input'], # the model's input names
output_names = ['output'], # the model's output names
dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes
'output' : {0 : 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_shapes = [shape],
input_data = [d],
output_data = [((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])
# Serialize data into file:
json.dump( data, open( "input.json", 'w' ) )
if __name__ == "__main__":
main()
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_gelu_tanh_appx/gen.py | import json
import torch
from torch import nn
class Circuit(nn.Module):
def __init__(self):
super(Circuit, self).__init__()
self.layer = nn.GELU('tanh') # approximation = false in our case
def forward(self, x):
return self.layer(x)
def main():
torch_model = Circuit()
# Input to the model
shape = [3]
x = torch.rand(1,*shape, requires_grad=True)
torch_out = torch_model(x)
# Export the model
torch.onnx.export(torch_model, # model being run
x, # model input (or a tuple for multiple inputs)
"network.onnx", # where to save the model (can be a file or file-like object)
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names = ['input'], # the model's input names
output_names = ['output'], # the model's output names
dynamic_axes={'input' : {0 : 'batch_size'}, # variable length axes
'output' : {0 : 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_shapes = [shape],
input_data = [d],
output_data = [((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])
# Serialize data into file:
json.dump( data, open( "input.json", 'w' ) )
if __name__ == "__main__":
main() | https://github.com/zkonduit/ezkl |
examples/onnx/1l_identity/gen.py | import torch
from torch import nn
import json
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
def forward(self, x):
return x
circuit = MyModel()
x = 0.1*torch.rand(1, *[2], requires_grad=True)
# Flips the neural net into inference mode
circuit.eval()
# Export the model
torch.onnx.export(circuit, # model being run
# model input (or a tuple for multiple inputs)
x,
# where to save the model (can be a file or file-like object)
"network.onnx",
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names=['input'], # the model's input names
output_names=['output'], # the model's output names
dynamic_axes={'input': {0: 'batch_size'}, # variable length axes
'output': {0: 'batch_size'}})
data_array = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_data=[data_array])
# Serialize data into file:
json.dump(data, open("input.json", 'w'))
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_instance_norm/gen.py | from torch import nn
from ezkl import export
import torch
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.layer = nn.InstanceNorm2d(3).eval()
def forward(self, x):
return [self.layer(x)]
circuit = MyModel()
export(circuit, input_shape=[3, 2, 2])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_leakyrelu/gen.py | from torch import nn
from ezkl import export
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.LeakyReLU(negative_slope=0.05)
def forward(self, x):
return self.layer(x)
circuit = Model()
export(circuit, input_shape = [3])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_linear/gen.py | import random
import math
import numpy as np
import torch
from torch import nn
import torch.nn.functional as F
import json
model = nn.Linear(1, 1)
x = torch.randn(1, 1)
print(x)
# Flips the neural net into inference mode
model.eval()
model.to('cpu')
# Export the model
torch.onnx.export(model, # model being run
# model input (or a tuple for multiple inputs)
x,
# where to save the model (can be a file or file-like object)
"network.onnx",
export_params=True, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names=['input'], # the model's input names
output_names=['output'], # the model's output names
dynamic_axes={'input': {0: 'batch_size'}, # variable length axes
'output': {0: 'batch_size'}})
data_array = ((x).detach().numpy()).reshape([-1]).tolist()
data_json = dict(input_data=[data_array])
print(data_json)
# Serialize data into file:
json.dump(data_json, open("input.json", 'w'))
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_lppool/gen.py | from torch import nn
import torch
import json
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.LPPool2d(2, 1, (1, 1))
def forward(self, x):
return self.layer(x)[0]
circuit = Model()
x = torch.empty(1, 3, 2, 2).uniform_(0, 1)
out = circuit(x)
print(out)
torch.onnx.export(circuit, x, "network.onnx",
export_params=True, # store the trained parameter weights inside the model file
opset_version=17, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names=['input'], # the model's input names
output_names=['output'], # the model's output names
dynamic_axes={'input': {0: 'batch_size'}, # variable length axes
'output': {0: 'batch_size'}})
d1 = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(
input_data=[d1],
)
# Serialize data into file:
json.dump(data, open("input.json", 'w'))
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_max_pool/gen.py | from torch import nn
from ezkl import export
import torch
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.MaxPool2d(2, 1, (1, 1), 1, 1)
def forward(self, x):
return self.layer(x)[0]
circuit = Model()
# Input to the model
shape = [3, 2, 2]
x = torch.rand(1, *shape, requires_grad=False)
torch_out = circuit(x)
# Export the model
torch.onnx.export(circuit, # model being run
# model input (or a tuple for multiple inputs)
x,
# where to save the model (can be a file or file-like object)
"network.onnx",
export_params=True, # store the trained parameter weights inside the model file
opset_version=14, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names=['input'], # the model's input names
output_names=['output'], # the model's output names
dynamic_axes={'input': {0: 'batch_size'}, # variable length axes
'output': {0: 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(input_shapes=[shape],
input_data=[d],
output_data=[(o).reshape([-1]).tolist() for o in torch_out])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_pad/gen.py | from torch import nn
from ezkl import export
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
def forward(self, x):
return nn.functional.pad(x, (1,1))
circuit = Model()
export(circuit, input_shape = [3, 2, 2])
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_powf/gen.py | from torch import nn
import torch
import json
import numpy as np
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
def forward(self, x):
return torch.pow(x, -0.1)
circuit = MyModel()
x = torch.rand(1, 4)
torch.onnx.export(circuit, (x), "network.onnx",
export_params=True, # store the trained parameter weights inside the model file
opset_version=15, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding for optimization
input_names=['input'], # the model's input names
output_names=['output'], # the model's output names
dynamic_axes={'input': {0: 'batch_size'}, # variable length axes
'output': {0: 'batch_size'}})
d = ((x).detach().numpy()).reshape([-1]).tolist()
data = dict(
input_data=[d],
)
# Serialize data into file:
json.dump(data, open("input.json", 'w'))
| https://github.com/zkonduit/ezkl |
examples/onnx/1l_prelu/gen.py | from torch import nn
from ezkl import export
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.layer = nn.PReLU(num_parameters=3, init=0.25)
def forward(self, x):
return self.layer(x)
circuit = Model()
export(circuit, input_shape = [3, 2, 2])
| https://github.com/zkonduit/ezkl |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.