Change code-style

NAM/activations.cpp

@@ -6,24 +6,24 @@ nam::activations::ActivationHardTanh _HARD_TANH = nam::activations::ActivationHa
 nam::activations::ActivationReLU _RELU = nam::activations::ActivationReLU();
 nam::activations::ActivationSigmoid _SIGMOID = nam::activations::ActivationSigmoid();
 
-bool nam::activations::Activation::using_fast_tanh = false;
+bool nam::activations::Activation::sUsingFastTanh = false;
 
 std::unordered_map<std::string, nam::activations::Activation*> nam::activations::Activation::_activations =
   {{"Tanh", &_TANH}, {"Hardtanh", &_HARD_TANH}, {"Fasttanh", &_FAST_TANH}, {"ReLU", &_RELU}, {"Sigmoid", &_SIGMOID}};
 
 nam::activations::Activation* tanh_bak = nullptr;
 
-nam::activations::Activation* nam::activations::Activation::get_activation(const std::string name)
+nam::activations::Activation* nam::activations::Activation::GetActivation(const std::string& name)
 {
   if (_activations.find(name) == _activations.end())
     return nullptr;
 
   return _activations[name];
 }
 
-void nam::activations::Activation::enable_fast_tanh()
+void nam::activations::Activation::EnableFastTanh()
 {
-  nam::activations::Activation::using_fast_tanh = true;
+  nam::activations::Activation::sUsingFastTanh = true;
 
   if (_activations["Tanh"] != _activations["Fasttanh"])
   {
@@ -32,9 +32,9 @@ void nam::activations::Activation::enable_fast_tanh()
   }
 }
 
-void nam::activations::Activation::disable_fast_tanh()
+void nam::activations::Activation::DisableFastTanh()
 {
-  nam::activations::Activation::using_fast_tanh = false;
+  nam::activations::Activation::sUsingFastTanh = false;
 
   if (_activations["Tanh"] == _activations["Fasttanh"])
   {

NAM/activations.h

@@ -45,18 +45,18 @@ class Activation
 public:
   Activation() = default;
   virtual ~Activation() = default;
-  virtual void apply(Eigen::MatrixXf& matrix) { apply(matrix.data(), matrix.rows() * matrix.cols()); }
-  virtual void apply(Eigen::Block<Eigen::MatrixXf> block) { apply(block.data(), block.rows() * block.cols()); }
-  virtual void apply(Eigen::Block<Eigen::MatrixXf, -1, -1, true> block)
+  virtual void Apply(Eigen::Ref<Eigen::MatrixXf> matrix) { Apply(matrix.data(), matrix.rows() * matrix.cols()); }
+  virtual void Apply(Eigen::Block<Eigen::MatrixXf> block) { Apply(block.data(), block.rows() * block.cols()); }
+  virtual void Apply(Eigen::Block<Eigen::MatrixXf, -1, -1, true> block)
   {
-    apply(block.data(), block.rows() * block.cols());
+    Apply(block.data(), block.rows() * block.cols());
   }
-  virtual void apply(float* data, long size) {}
+  virtual void Apply(float* data, long size) {}
 
-  static Activation* get_activation(const std::string name);
-  static void enable_fast_tanh();
-  static void disable_fast_tanh();
-  static bool using_fast_tanh;
+  static Activation* GetActivation(const std::string& name);
+  static void EnableFastTanh();
+  static void DisableFastTanh();
+  static bool sUsingFastTanh;
 
 protected:
   static std::unordered_map<std::string, Activation*> _activations;
@@ -65,7 +65,7 @@ class Activation
 class ActivationTanh : public Activation
 {
 public:
-  void apply(float* data, long size) override
+  void Apply(float* data, long size) override
   {
     for (long pos = 0; pos < size; pos++)
     {
@@ -77,7 +77,7 @@ class ActivationTanh : public Activation
 class ActivationHardTanh : public Activation
 {
 public:
-  void apply(float* data, long size) override
+  void Apply(float* data, long size) override
   {
     for (long pos = 0; pos < size; pos++)
     {
@@ -89,7 +89,7 @@ class ActivationHardTanh : public Activation
 class ActivationFastTanh : public Activation
 {
 public:
-  void apply(float* data, long size) override
+  void Apply(float* data, long size) override
   {
     for (long pos = 0; pos < size; pos++)
     {
@@ -101,7 +101,7 @@ class ActivationFastTanh : public Activation
 class ActivationReLU : public Activation
 {
 public:
-  void apply(float* data, long size) override
+  void Apply(float* data, long size) override
   {
     for (long pos = 0; pos < size; pos++)
     {
@@ -113,7 +113,7 @@ class ActivationReLU : public Activation
 class ActivationSigmoid : public Activation
 {
 public:
-  void apply(float* data, long size) override
+  void Apply(float* data, long size) override
   {
     for (long pos = 0; pos < size; pos++)
     {

NAM/convnet.cpp

@@ -10,174 +10,174 @@
 #include "dsp.h"
 #include "convnet.h"
 
-nam::convnet::BatchNorm::BatchNorm(const int dim, std::vector<float>::iterator& weights)
+nam::convnet::BatchNorm::BatchNorm(const int dim, weightsIterator& weights)
 {
   // Extract from param buffer
   Eigen::VectorXf running_mean(dim);
   Eigen::VectorXf running_var(dim);
-  Eigen::VectorXf _weight(dim);
-  Eigen::VectorXf _bias(dim);
+  Eigen::VectorXf weight(dim);
+  Eigen::VectorXf bias(dim);
   for (int i = 0; i < dim; i++)
     running_mean(i) = *(weights++);
   for (int i = 0; i < dim; i++)
     running_var(i) = *(weights++);
   for (int i = 0; i < dim; i++)
-    _weight(i) = *(weights++);
+    weight(i) = *(weights++);
   for (int i = 0; i < dim; i++)
-    _bias(i) = *(weights++);
+    bias(i) = *(weights++);
   float eps = *(weights++);
 
   // Convert to scale & loc
-  this->scale.resize(dim);
-  this->loc.resize(dim);
+  mScale.resize(dim);
+  mLoc.resize(dim);
   for (int i = 0; i < dim; i++)
-    this->scale(i) = _weight(i) / sqrt(eps + running_var(i));
-  this->loc = _bias - this->scale.cwiseProduct(running_mean);
+    mScale(i) = weight(i) / sqrt(eps + running_var(i));
+  mLoc = bias - mScale.cwiseProduct(running_mean);
 }
 
-void nam::convnet::BatchNorm::process_(Eigen::MatrixXf& x, const long i_start, const long i_end) const
+void nam::convnet::BatchNorm::Process(Eigen::Ref<Eigen::MatrixXf> x, const long i_start, const long i_end) const
 {
   // todo using colwise?
   // #speed but conv probably dominates
   for (auto i = i_start; i < i_end; i++)
   {
-    x.col(i) = x.col(i).cwiseProduct(this->scale);
-    x.col(i) += this->loc;
+    x.col(i) = x.col(i).cwiseProduct(mScale);
+    x.col(i) += mLoc;
   }
 }
 
-void nam::convnet::ConvNetBlock::set_weights_(const int in_channels, const int out_channels, const int _dilation,
-                                              const bool batchnorm, const std::string activation,
-                                              std::vector<float>::iterator& weights)
+void nam::convnet::ConvNetBlock::SetWeights(const int inChannels, const int outChannels, const int dilation,
+                                              const bool doBatchNorm, const std::string& activation,
+                                              weightsIterator& weights)
 {
-  this->_batchnorm = batchnorm;
+  mDoBatchNorm = doBatchNorm;
   // HACK 2 kernel
-  this->conv.set_size_and_weights_(in_channels, out_channels, 2, _dilation, !batchnorm, weights);
-  if (this->_batchnorm)
-    this->batchnorm = BatchNorm(out_channels, weights);
-  this->activation = activations::Activation::get_activation(activation);
+  conv.SetSizeAndWeights(inChannels, outChannels, 2, dilation, !doBatchNorm, weights);
+  if (mDoBatchNorm)
+    mBatchnorm = BatchNorm(outChannels, weights);
+  mActivation = activations::Activation::GetActivation(activation);
 }
 
-void nam::convnet::ConvNetBlock::process_(const Eigen::MatrixXf& input, Eigen::MatrixXf& output, const long i_start,
+void nam::convnet::ConvNetBlock::Process(const Eigen::Ref<const Eigen::MatrixXf> input, Eigen::Ref<Eigen::MatrixXf> output, const long i_start,
                                           const long i_end) const
 {
   const long ncols = i_end - i_start;
-  this->conv.process_(input, output, i_start, ncols, i_start);
-  if (this->_batchnorm)
-    this->batchnorm.process_(output, i_start, i_end);
+  conv.Process(input, output, i_start, ncols, i_start);
+  if (mDoBatchNorm)
+    mBatchnorm.Process(output, i_start, i_end);
 
-  this->activation->apply(output.middleCols(i_start, ncols));
+  mActivation->Apply(output.middleCols(i_start, ncols));
 }
 
-long nam::convnet::ConvNetBlock::get_out_channels() const
+long nam::convnet::ConvNetBlock::GetOutChannels() const
 {
-  return this->conv.get_out_channels();
+  return conv.GetOutChannels();
 }
 
-nam::convnet::_Head::_Head(const int channels, std::vector<float>::iterator& weights)
+nam::convnet::Head::Head(const int channels, weightsIterator& weights)
 {
-  this->_weight.resize(channels);
+  mWeight.resize(channels);
   for (int i = 0; i < channels; i++)
-    this->_weight[i] = *(weights++);
-  this->_bias = *(weights++);
+    mWeight[i] = *(weights++);
+  mBias = *(weights++);
 }
 
-void nam::convnet::_Head::process_(const Eigen::MatrixXf& input, Eigen::VectorXf& output, const long i_start,
+void nam::convnet::Head::Process(const Eigen::Ref<const Eigen::MatrixXf> input, Eigen::VectorXf& output, const long i_start,
                                    const long i_end) const
 {
   const long length = i_end - i_start;
   output.resize(length);
   for (long i = 0, j = i_start; i < length; i++, j++)
-    output(i) = this->_bias + input.col(j).dot(this->_weight);
+    output(i) = mBias + input.col(j).dot(mWeight);
 }
 
 nam::convnet::ConvNet::ConvNet(const int channels, const std::vector<int>& dilations, const bool batchnorm,
-                               const std::string activation, std::vector<float>& weights,
-                               const double expected_sample_rate)
-: Buffer(*std::max_element(dilations.begin(), dilations.end()), expected_sample_rate)
+                               const std::string& activation, std::vector<float>& weights,
+                               const double expectedSampleRate)
+: Buffer(*std::max_element(dilations.begin(), dilations.end()), expectedSampleRate)
 {
-  this->_verify_weights(channels, dilations, batchnorm, weights.size());
-  this->_blocks.resize(dilations.size());
-  std::vector<float>::iterator it = weights.begin();
+  VerifyWeights(channels, dilations, batchnorm, weights.size());
+  mBlocks.resize(dilations.size());
+  weightsIterator it = weights.begin();
   for (size_t i = 0; i < dilations.size(); i++)
-    this->_blocks[i].set_weights_(i == 0 ? 1 : channels, channels, dilations[i], batchnorm, activation, it);
-  this->_block_vals.resize(this->_blocks.size() + 1);
-  for (auto& matrix : this->_block_vals)
+    mBlocks[i].SetWeights(i == 0 ? 1 : channels, channels, dilations[i], batchnorm, activation, it);
+  mBlockVals.resize(mBlocks.size() + 1);
+  for (auto& matrix : mBlockVals)
     matrix.setZero();
-  std::fill(this->_input_buffer.begin(), this->_input_buffer.end(), 0.0f);
-  this->_head = _Head(channels, it);
+  std::fill(mInputBuffer.begin(), mInputBuffer.end(), 0.0f);
+  mHead = Head(channels, it);
   if (it != weights.end())
     throw std::runtime_error("Didn't touch all the weights when initializing ConvNet");
 
-  _prewarm_samples = 1;
+  mPrewarmSamples = 1;
   for (size_t i = 0; i < dilations.size(); i++)
-    _prewarm_samples += dilations[i];
+    mPrewarmSamples += dilations[i];
 }
 
 
-void nam::convnet::ConvNet::process(NAM_SAMPLE* input, NAM_SAMPLE* output, const int num_frames)
+void nam::convnet::ConvNet::Process(float* input, float* output, const int numFrames)
 
 {
-  this->_update_buffers_(input, num_frames);
+  UpdateBuffers(input, numFrames);
   // Main computation!
-  const long i_start = this->_input_buffer_offset;
-  const long i_end = i_start + num_frames;
+  const long i_start = mInputBufferOffset;
+  const long i_end = i_start + numFrames;
   // TODO one unnecessary copy :/ #speed
   for (auto i = i_start; i < i_end; i++)
-    this->_block_vals[0](0, i) = this->_input_buffer[i];
-  for (size_t i = 0; i < this->_blocks.size(); i++)
-    this->_blocks[i].process_(this->_block_vals[i], this->_block_vals[i + 1], i_start, i_end);
+    mBlockVals[0](0, i) = mInputBuffer[i];
+  for (size_t i = 0; i < mBlocks.size(); i++)
+    mBlocks[i].Process(mBlockVals[i], mBlockVals[i + 1], i_start, i_end);
   // TODO clean up this allocation
-  this->_head.process_(this->_block_vals[this->_blocks.size()], this->_head_output, i_start, i_end);
+  mHead.Process(mBlockVals[mBlocks.size()], mHeadOutput, i_start, i_end);
   // Copy to required output array (TODO tighten this up)
-  for (int s = 0; s < num_frames; s++)
-    output[s] = this->_head_output(s);
+  for (int s = 0; s < numFrames; s++)
+    output[s] = mHeadOutput(s);
 }
 
-void nam::convnet::ConvNet::_verify_weights(const int channels, const std::vector<int>& dilations, const bool batchnorm,
-                                            const size_t actual_weights)
+void nam::convnet::ConvNet::VerifyWeights(const int channels, const std::vector<int>& dilations, const bool batchnorm,
+                                            const size_t actualWeights)
 {
   // TODO
 }
 
-void nam::convnet::ConvNet::_update_buffers_(NAM_SAMPLE* input, const int num_frames)
+void nam::convnet::ConvNet::UpdateBuffers(float* input, const int numFrames)
 {
-  this->Buffer::_update_buffers_(input, num_frames);
+  Buffer::UpdateBuffers(input, numFrames);
 
-  const size_t buffer_size = this->_input_buffer.size();
+  const size_t buffer_size = mInputBuffer.size();
 
-  if (this->_block_vals[0].rows() != 1 || this->_block_vals[0].cols() != buffer_size)
+  if (mBlockVals[0].rows() != Eigen::Index(1) || mBlockVals[0].cols() != Eigen::Index(buffer_size))
   {
-    this->_block_vals[0].resize(1, buffer_size);
-    this->_block_vals[0].setZero();
+    mBlockVals[0].resize(1, buffer_size);
+    mBlockVals[0].setZero();
   }
 
-  for (size_t i = 1; i < this->_block_vals.size(); i++)
+  for (size_t i = 1; i < mBlockVals.size(); i++)
   {
-    if (this->_block_vals[i].rows() == this->_blocks[i - 1].get_out_channels()
-        && this->_block_vals[i].cols() == buffer_size)
+    if (mBlockVals[i].rows() == mBlocks[i - 1].GetOutChannels()
+        && mBlockVals[i].cols() == Eigen::Index(buffer_size))
       continue; // Already has correct size
-    this->_block_vals[i].resize(this->_blocks[i - 1].get_out_channels(), buffer_size);
-    this->_block_vals[i].setZero();
+    mBlockVals[i].resize(mBlocks[i - 1].GetOutChannels(), buffer_size);
+    mBlockVals[i].setZero();
   }
 }
 
-void nam::convnet::ConvNet::_rewind_buffers_()
+void nam::convnet::ConvNet::RewindBuffers()
 {
   // Need to rewind the block vals first because Buffer::rewind_buffers()
   // resets the offset index
   // The last _block_vals is the output of the last block and doesn't need to be
   // rewound.
-  for (size_t k = 0; k < this->_block_vals.size() - 1; k++)
+  for (size_t k = 0; k < mBlockVals.size() - 1; k++)
   {
     // We actually don't need to pull back a lot...just as far as the first
     // input sample would grab from dilation
-    const long _dilation = this->_blocks[k].conv.get_dilation();
-    for (long i = this->_receptive_field - _dilation, j = this->_input_buffer_offset - _dilation;
-         j < this->_input_buffer_offset; i++, j++)
-      for (long r = 0; r < this->_block_vals[k].rows(); r++)
-        this->_block_vals[k](r, i) = this->_block_vals[k](r, j);
+    const long dilation = mBlocks[k].conv.GetDilation();
+    for (long i = mReceptiveField - dilation, j = mInputBufferOffset - dilation;
+         j < mInputBufferOffset; i++, j++)
+      for (long r = 0; r < mBlockVals[k].rows(); r++)
+        mBlockVals[k](r, i) = mBlockVals[k](r, j);
   }
   // Now we can do the rest of the rewind
-  this->Buffer::_rewind_buffers_();
+  Buffer::RewindBuffers();
 }