kord 0.7.1

A tool to easily explore music theory principles.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Generic data structures and functions for training or inference.

use burn::tensor::{backend::Backend, Data, Tensor};

use super::{
    helpers::{get_deterministic_guess, mel_filter_banks_from, note_binned_convolution, u128_to_binary},
    KordItem, INPUT_SPACE_SIZE, NUM_CLASSES,
};

/// Takes a loaded kord item and converts it to a sample tensor that is ready for classification.
pub fn kord_item_to_sample_tensor<B: Backend>(item: &KordItem) -> Tensor<B, 2> {
    //kord_item_to_large_sample_tensor(item)
    kord_item_to_note_binned_convolution_tensor(item)
    //kord_item_to_mel_sample_tensor(item)
    //kord_item_to_bins_sample_tensor(item)
}

/// Takes a loaded kord item and converts it to a sample tensor that is ready for classification.
#[allow(dead_code)]
fn kord_item_to_mel_sample_tensor<B: Backend>(item: &KordItem) -> Tensor<B, 2> {
    let frequency_space = item.frequency_space;
    let mut mel_space = mel_filter_banks_from(&frequency_space);

    // Normalize the mel space peaks.
    normalize(&mut mel_space);

    // Get the "deterministic guess".
    let deterministic_guess: [f32; 128] = u128_to_binary(get_deterministic_guess(item)).iter().map(|v| v * 1.0).collect::<Vec<_>>().try_into().unwrap();
    //let deterministic_guess = fold_binary(&deterministic_guess);

    let mut result: [f32; INPUT_SPACE_SIZE] = [&deterministic_guess[..], &mel_space[..]].concat().try_into().unwrap();
    //let mut result = mel_space;

    // Convert the result values to zero-mean and unit-variance.
    to_zero_mean_unit_variance(&mut result);

    let data = Data::<f32, 1>::from(result);
    let tensor = Tensor::<B, 1>::from_data(data.convert());

    tensor.reshape([1, INPUT_SPACE_SIZE])
}

/// Takes a loaded kord item and converts it to a sample tensor that is ready for classification.
#[allow(dead_code)]
fn kord_item_to_large_sample_tensor<B: Backend>(item: &KordItem) -> Tensor<B, 2> {
    let mut frequency_space = item.frequency_space;

    // Normalize the mel space peaks.
    normalize(&mut frequency_space);

    // Get the "deterministic guess".
    let deterministic_guess: [f32; 128] = u128_to_binary(get_deterministic_guess(item)).iter().map(|v| v * 1.0).collect::<Vec<_>>().try_into().unwrap();
    //let deterministic_guess = fold_binary(&deterministic_guess);

    let mut result: [f32; INPUT_SPACE_SIZE] = [&deterministic_guess[..], &frequency_space[..]].concat().try_into().unwrap();
    //let mut result = frequency_space;

    // Convert the result values to zero-mean and unit-variance.
    to_zero_mean_unit_variance(&mut result);

    let data = Data::<f32, 1>::from(result);
    let tensor = Tensor::<B, 1>::from_data(data.convert());

    tensor.reshape([1, INPUT_SPACE_SIZE])
}

fn kord_item_to_note_binned_convolution_tensor<B: Backend>(item: &KordItem) -> Tensor<B, 2> {
    let frequency_space = item.frequency_space;

    let mut convolution = note_binned_convolution(&frequency_space);

    // Normalize the mel space peaks.
    normalize(&mut convolution);

    // Get the "deterministic guess".
    let deterministic_guess: [f32; 128] = u128_to_binary(get_deterministic_guess(item)).iter().map(|v| v * 1.0).collect::<Vec<_>>().try_into().unwrap();
    //let deterministic_guess = fold_binary(&deterministic_guess);

    let mut result: [f32; INPUT_SPACE_SIZE] = [&deterministic_guess[..], &convolution[..]].concat().try_into().unwrap();
    //let mut result = convolution;

    // Convert the result values to zero-mean and unit-variance.
    to_zero_mean_unit_variance(&mut result);

    let data = Data::<f32, 1>::from(result);
    let tensor = Tensor::<B, 1>::from_data(data.convert());

    tensor.reshape([1, INPUT_SPACE_SIZE])
}

/// Takes a loaded kord item and converts it to a target tensor that is ready for classification.
pub fn kord_item_to_target_tensor<B: Backend>(item: &KordItem) -> Tensor<B, 2> {
    let binary = u128_to_binary(item.label);

    //let binary = fold_binary(&binary);

    let data = Data::<f32, 1>::from(binary);
    let tensor = Tensor::<B, 1>::from_data(data.convert());

    tensor.reshape([1, NUM_CLASSES])
}

/// Modifies a slice in place to convert values to zero mean and unit variance.
pub fn to_zero_mean_unit_variance(slice: &mut [f32]) {
    let mean = slice.iter().sum::<f32>() / slice.len() as f32;
    let variance = slice.iter().map(|x| (x - mean).powf(2.0)).sum::<f32>() / slice.len() as f32;
    let std = variance.sqrt();

    slice.iter_mut().for_each(|x| *x = (*x - mean) / std);
}

/// Normalizes a slice in place.
pub fn normalize(slice: &mut [f32]) {
    let max = slice.iter().fold(0f32, |acc, &x| acc.max(x));

    slice.iter_mut().for_each(|x| *x /= max);
}