Updated how activations are initialized from config. Passing an object instead of a string is now supported.

Author: João Felipe Santos

NAM/activations.cpp

@@ -31,6 +31,59 @@ nam::activations::Activation* nam::activations::Activation::get_activation(const
   return _activations[name];
 }
 
+nam::activations::Activation* nam::activations::Activation::get_activation(const nlohmann::json& activation_config)
+{
+  // If it's a string, use the existing string-based lookup
+  if (activation_config.is_string())
+  {
+    std::string name = activation_config.get<std::string>();
+    return get_activation(name);
+  }
+  
+  // If it's an object, parse the activation type and parameters
+  if (activation_config.is_object())
+  {
+    std::string type = activation_config["type"].get<std::string>();
+    
+    // Handle different activation types with parameters
+    if (type == "PReLU")
+    {
+      if (activation_config.find("negative_slope") != activation_config.end())
+      {
+        float negative_slope = activation_config["negative_slope"].get<float>();
+        return new ActivationPReLU(negative_slope);
+      }
+      else if (activation_config.find("negative_slopes") != activation_config.end())
+      {
+        std::vector<float> negative_slopes = activation_config["negative_slopes"].get<std::vector<float>>();
+        return new ActivationPReLU(negative_slopes);
+      }
+      // If no parameters provided, use default
+      return new ActivationPReLU(0.01);
+    }
+    else if (type == "LeakyReLU")
+    {
+      float negative_slope = activation_config.value("negative_slope", 0.01f);
+      return new ActivationLeakyReLU(negative_slope);
+    }
+    else if (type == "LeakyHardTanh")
+    {
+      float min_val = activation_config.value("min_val", -1.0f);
+      float max_val = activation_config.value("max_val", 1.0f);
+      float min_slope = activation_config.value("min_slope", 0.01f);
+      float max_slope = activation_config.value("max_slope", 0.01f);
+      return new ActivationLeakyHardTanh(min_val, max_val, min_slope, max_slope);
+    }
+    else
+    {
+      // For other activation types without parameters, use the default string-based lookup
+      return get_activation(type);
+    }
+  }
+  
+  return nullptr;
+}
+
 void nam::activations::Activation::enable_fast_tanh()
 {
   nam::activations::Activation::using_fast_tanh = true;

NAM/activations.h

@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include <Eigen/Dense>
 #include <functional>
+#include "json.hpp"
 
 namespace nam
 {
@@ -102,6 +103,7 @@ class Activation
   virtual void apply(float* data, long size) {}
 
   static Activation* get_activation(const std::string name);
+  static Activation* get_activation(const nlohmann::json& activation_config);
   static void enable_fast_tanh();
   static void disable_fast_tanh();
   static bool using_fast_tanh;
@@ -226,20 +228,31 @@ class ActivationPReLU : public Activation
   void apply(Eigen::MatrixXf& matrix) override
   {
     // Matrix is organized as (channels, time_steps)
-    int n_channels = negative_slopes.size();
-    int actual_channels = matrix.rows();
-
-    // NOTE: check not done during runtime on release builds
-    // model loader should make sure dimensions match
-    assert(actual_channels == n_channels);
-
+    unsigned long actual_channels = static_cast<unsigned long>(matrix.rows());
+    
+    // Prepare the slopes for the current matrix size
+    std::vector<float> slopes_for_channels = negative_slopes;
+    
+    if (slopes_for_channels.size() == 1 && actual_channels > 1)
+    {
+      // Broadcast single slope to all channels
+      float slope = slopes_for_channels[0];
+      slopes_for_channels.clear();
+      slopes_for_channels.resize(actual_channels, slope);
+    }
+    else if (slopes_for_channels.size() != actual_channels)
+    {
+      // This should not happen in normal usage, but handle gracefully
+      slopes_for_channels.resize(actual_channels, 0.01f); // Default slope
+    }
+    
     // Apply each negative slope to its corresponding channel
-    for (int channel = 0; channel < std::min(n_channels, actual_channels); channel++)
+    for (unsigned long channel = 0; channel < actual_channels; channel++)
     {
       // Apply the negative slope to all time steps in this channel
-      for (int time_step = 0; time_step < matrix.rows(); time_step++)
+      for (int time_step = 0; time_step < matrix.cols(); time_step++)
       {
-        matrix(channel, time_step) = leaky_relu(matrix(channel, time_step), negative_slopes[channel]);
+        matrix(channel, time_step) = leaky_relu(matrix(channel, time_step), slopes_for_channels[channel]);
       }
     }
   }

NAM/convnet.cpp

@@ -48,15 +48,15 @@ void nam::convnet::BatchNorm::process_(Eigen::MatrixXf& x, const long i_start, c
 }
 
 void nam::convnet::ConvNetBlock::set_weights_(const int in_channels, const int out_channels, const int _dilation,
-                                              const bool batchnorm, const std::string activation, const int groups,
+                                              const bool batchnorm, const nlohmann::json activation_config, const int groups,
                                               std::vector<float>::iterator& weights)
 {
   this->_batchnorm = batchnorm;
   // HACK 2 kernel
   this->conv.set_size_and_weights_(in_channels, out_channels, 2, _dilation, !batchnorm, groups, weights);
   if (this->_batchnorm)
     this->batchnorm = BatchNorm(out_channels, weights);
-  this->activation = activations::Activation::get_activation(activation);
+  this->activation = activations::Activation::get_activation(activation_config);
 }
 
 void nam::convnet::ConvNetBlock::SetMaxBufferSize(const int maxBufferSize)
@@ -173,7 +173,7 @@ void nam::convnet::_Head::process_(const Eigen::MatrixXf& input, Eigen::MatrixXf
 }
 
 nam::convnet::ConvNet::ConvNet(const int in_channels, const int out_channels, const int channels,
-                               const std::vector<int>& dilations, const bool batchnorm, const std::string activation,
+                               const std::vector<int>& dilations, const bool batchnorm, const nlohmann::json activation_config,
                                std::vector<float>& weights, const double expected_sample_rate, const int groups)
 : Buffer(in_channels, out_channels, *std::max_element(dilations.begin(), dilations.end()), expected_sample_rate)
 {
@@ -183,7 +183,7 @@ nam::convnet::ConvNet::ConvNet(const int in_channels, const int out_channels, co
   // First block takes in_channels input, subsequent blocks take channels input
   for (size_t i = 0; i < dilations.size(); i++)
     this->_blocks[i].set_weights_(
-      i == 0 ? in_channels : channels, channels, dilations[i], batchnorm, activation, groups, it);
+      i == 0 ? in_channels : channels, channels, dilations[i], batchnorm, activation_config, groups, it);
   // Only need _block_vals for the head (one entry)
   // Conv1D layers manage their own buffers now
   this->_block_vals.resize(1);
@@ -327,13 +327,13 @@ std::unique_ptr<nam::DSP> nam::convnet::Factory(const nlohmann::json& config, st
   const int channels = config["channels"];
   const std::vector<int> dilations = config["dilations"];
   const bool batchnorm = config["batchnorm"];
-  const std::string activation = config["activation"];
+  const nlohmann::json activation_config = config["activation"];
   const int groups = config.value("groups", 1); // defaults to 1
   // Default to 1 channel in/out for backward compatibility
   const int in_channels = config.value("in_channels", 1);
   const int out_channels = config.value("out_channels", 1);
   return std::make_unique<nam::convnet::ConvNet>(
-    in_channels, out_channels, channels, dilations, batchnorm, activation, weights, expectedSampleRate, groups);
+    in_channels, out_channels, channels, dilations, batchnorm, activation_config, weights, expectedSampleRate, groups);
 }
 
 namespace

NAM/convnet.h

@@ -44,7 +44,7 @@ class ConvNetBlock
 public:
   ConvNetBlock() {};
   void set_weights_(const int in_channels, const int out_channels, const int _dilation, const bool batchnorm,
-                    const std::string activation, const int groups, std::vector<float>::iterator& weights);
+                    const nlohmann::json activation_config, const int groups, std::vector<float>::iterator& weights);
   void SetMaxBufferSize(const int maxBufferSize);
   // Process input matrix directly (new API, similar to WaveNet)
   void Process(const Eigen::MatrixXf& input, const int num_frames);
@@ -78,7 +78,7 @@ class ConvNet : public Buffer
 {
 public:
   ConvNet(const int in_channels, const int out_channels, const int channels, const std::vector<int>& dilations,
-          const bool batchnorm, const std::string activation, std::vector<float>& weights,
+          const bool batchnorm, const nlohmann::json activation_config, std::vector<float>& weights,
           const double expected_sample_rate = -1.0, const int groups = 1);
   ~ConvNet() = default;
 

NAM/wavenet.cpp

@@ -113,7 +113,7 @@ void nam::wavenet::_Layer::Process(const Eigen::MatrixXf& input, const Eigen::Ma
 
 nam::wavenet::_LayerArray::_LayerArray(const int input_size, const int condition_size, const int head_size,
                                        const int channels, const int bottleneck, const int kernel_size,
-                                       const std::vector<int>& dilations, const std::string activation,
+                                       const std::vector<int>& dilations, const nlohmann::json activation_config,
                                        const GatingMode gating_mode, const bool head_bias, const int groups_input,
                                        const int groups_1x1, const Head1x1Params& head1x1_params,
                                        const std::string& secondary_activation)
@@ -122,7 +122,7 @@ nam::wavenet::_LayerArray::_LayerArray(const int input_size, const int condition
 , _bottleneck(bottleneck)
 {
   for (size_t i = 0; i < dilations.size(); i++)
-    this->_layers.push_back(_Layer(condition_size, channels, bottleneck, kernel_size, dilations[i], activation,
+    this->_layers.push_back(_Layer(condition_size, channels, bottleneck, kernel_size, dilations[i], activation_config,
                                    gating_mode, groups_input, groups_1x1, head1x1_params, secondary_activation));
 }
 
@@ -273,7 +273,7 @@ nam::wavenet::WaveNet::WaveNet(const int in_channels,
     this->_layer_arrays.push_back(nam::wavenet::_LayerArray(
       layer_array_params[i].input_size, layer_array_params[i].condition_size, layer_array_params[i].head_size,
       layer_array_params[i].channels, layer_array_params[i].bottleneck, layer_array_params[i].kernel_size,
-      layer_array_params[i].dilations, layer_array_params[i].activation, layer_array_params[i].gating_mode,
+      layer_array_params[i].dilations, layer_array_params[i].activation_config, layer_array_params[i].gating_mode,
       layer_array_params[i].head_bias, layer_array_params[i].groups_input, layer_array_params[i].groups_1x1,
       layer_array_params[i].head1x1_params, layer_array_params[i].secondary_activation));
     if (i > 0)
@@ -477,7 +477,7 @@ std::unique_ptr<nam::DSP> nam::wavenet::Factory(const nlohmann::json& config, st
     const int head_size = layer_config["head_size"];
     const int kernel_size = layer_config["kernel_size"];
     const auto dilations = layer_config["dilations"];
-    const std::string activation = layer_config["activation"].get<std::string>();
+    const nlohmann::json activation_config = layer_config["activation"];
     // Parse gating mode - support both old "gated" boolean and new "gating_mode" string
     GatingMode gating_mode = GatingMode::NONE;
     std::string secondary_activation;
@@ -531,7 +531,7 @@ std::unique_ptr<nam::DSP> nam::wavenet::Factory(const nlohmann::json& config, st
     nam::wavenet::Head1x1Params head1x1_params(head1x1_active, head1x1_out_channels, head1x1_groups);
 
     layer_array_params.push_back(nam::wavenet::LayerArrayParams(
-      input_size, condition_size, head_size, channels, bottleneck, kernel_size, dilations, activation, gating_mode,
+      input_size, condition_size, head_size, channels, bottleneck, kernel_size, dilations, activation_config, gating_mode,
       head_bias, groups, groups_1x1, head1x1_params, secondary_activation));
   }
   const bool with_head = !config["head"].is_null();

NAM/wavenet.h

@@ -50,12 +50,12 @@ class _Layer
 public:
   // New constructor with GatingMode enum and configurable activations
   _Layer(const int condition_size, const int channels, const int bottleneck, const int kernel_size, const int dilation,
-         const std::string activation, const GatingMode gating_mode, const int groups_input, const int groups_1x1,
+         const nlohmann::json activation_config, const GatingMode gating_mode, const int groups_input, const int groups_1x1,
          const Head1x1Params& head1x1_params, const std::string& secondary_activation)
   : _conv(channels, (gating_mode != GatingMode::NONE) ? 2 * bottleneck : bottleneck, kernel_size, true, dilation)
   , _input_mixin(condition_size, (gating_mode != GatingMode::NONE) ? 2 * bottleneck : bottleneck, false)
   , _1x1(bottleneck, channels, groups_1x1)
-  , _activation(activations::Activation::get_activation(activation)) // needs to support activations with parameters
+  , _activation(activations::Activation::get_activation(activation_config)) // now supports activations with parameters
   , _gating_mode(gating_mode)
   , _bottleneck(bottleneck)
   {
@@ -148,7 +148,7 @@ class LayerArrayParams
 public:
   LayerArrayParams(const int input_size_, const int condition_size_, const int head_size_, const int channels_,
                    const int bottleneck_, const int kernel_size_, const std::vector<int>&& dilations_,
-                   const std::string activation_, const GatingMode gating_mode_, const bool head_bias_,
+                   const nlohmann::json activation_, const GatingMode gating_mode_, const bool head_bias_,
                    const int groups_input, const int groups_1x1_, const Head1x1Params& head1x1_params_,
                    const std::string& secondary_activation_)
   : input_size(input_size_)
@@ -158,7 +158,7 @@ class LayerArrayParams
   , bottleneck(bottleneck_)
   , kernel_size(kernel_size_)
   , dilations(std::move(dilations_))
-  , activation(activation_)
+  , activation_config(activation_)
   , gating_mode(gating_mode_)
   , head_bias(head_bias_)
   , groups_input(groups_input)
@@ -175,7 +175,7 @@ class LayerArrayParams
   const int bottleneck;
   const int kernel_size;
   std::vector<int> dilations;
-  const std::string activation;
+  const nlohmann::json activation_config;
   const GatingMode gating_mode;
   const bool head_bias;
   const int groups_input;
@@ -191,7 +191,7 @@ class _LayerArray
   // New constructor with GatingMode enum and configurable activations
   _LayerArray(const int input_size, const int condition_size, const int head_size, const int channels,
               const int bottleneck, const int kernel_size, const std::vector<int>& dilations,
-              const std::string activation, const GatingMode gating_mode, const bool head_bias, const int groups_input,
+              const nlohmann::json activation_config, const GatingMode gating_mode, const bool head_bias, const int groups_input,
               const int groups_1x1, const Head1x1Params& head1x1_params, const std::string& secondary_activation);
 
   void SetMaxBufferSize(const int maxBufferSize);

build/.gitignore

@@ -44,6 +44,15 @@ int main()
   // This is enforced by an assert so it doesn't need to be tested
   // test_activations::TestPReLU::test_wrong_number_of_channels();
 
+  // JSON activation parsing tests
+  test_activations::TestJSONActivationParsing::test_string_activation();
+  test_activations::TestJSONActivationParsing::test_json_prelu_single_slope();
+  test_activations::TestJSONActivationParsing::test_json_prelu_multi_slope();
+  test_activations::TestJSONActivationParsing::test_json_leaky_relu();
+  test_activations::TestJSONActivationParsing::test_json_leaky_hardtanh();
+  test_activations::TestJSONActivationParsing::test_json_unknown_activation();
+  test_activations::TestJSONActivationParsing::test_functional_verification();
+
   test_dsp::test_construct();
   test_dsp::test_get_input_level();
   test_dsp::test_get_output_level();