keras::LayerConv2D Class Reference

#include <keras_model.h>

Inheritance diagram for keras::LayerConv2D:

Public Member Functions
	LayerConv2D ()
void	load_weights (std::ifstream &fin)
keras::DataChunk *	compute_output (keras::DataChunk *)
virtual unsigned int	get_input_rows () const
virtual unsigned int	get_input_cols () const
virtual unsigned int	get_output_units () const
Public Member Functions inherited from keras::Layer
	Layer (std::string name)
virtual	~Layer ()
std::string	get_name ()

Public Attributes
std::vector< std::vector< std::vector< std::vector< float > > > >	m_kernels
std::vector< float >	m_bias
std::string	m_border_mode
int	m_kernels_cnt
int	m_depth
int	m_rows
int	m_cols
Public Attributes inherited from keras::Layer
std::string	m_name

Detailed Description

Definition at line 177 of file keras_model.h.

Constructor & Destructor Documentation

keras::LayerConv2D::LayerConv2D ( )

inline

Definition at line 179 of file keras_model.h.

: Layer("Conv2D") {}

Member Function Documentation

keras::DataChunk * keras::LayerConv2D::compute_output ( keras::DataChunk *  dc )

virtual

Implements keras::Layer.

Definition at line 307 of file keras_model.cc.

                                                                   {
  unsigned int st_x = (m_kernels[0][0].size()-1) >> 1;
  unsigned int st_y = (m_kernels[0][0][0].size()-1) >> 1;
  auto const & im = dc->get_3d();

  size_t size_x = (m_border_mode == "valid")? im[0].size() - 2 * st_x : im[0].size();
  size_t size_y = (m_border_mode == "valid")? im[0][0].size() - 2 * st_y: im[0][0].size();

  //                                                    depth         rows    cols
  keras::DataChunk2D *out = new keras::DataChunk2D(m_kernels.size(), size_x, size_y, 0);
  auto & y_ret = out->get_3d_rw();

  //auto t1 = std::chrono::high_resolution_clock::now();

  // Parallelize the kernal calculation
  tbb::parallel_for( size_t(0), size_t(m_kernels.size()), [&]( size_t j ) {

      for(unsigned int m = 0; m < im.size(); ++m) { // loop over image depth
        if (m_border_mode == "valid")
          keras::conv_single_depth_valid(y_ret[j], im[m], m_kernels[j][m]);
        else
          keras::conv_single_depth_same(y_ret[j], im[m], m_kernels[j][m]);
      }

      for(unsigned int x = 0; x < y_ret[0].size(); ++x) {

        size_t size = y_ret[0][0].size();
        float bias = m_bias[j];
        size_t k = 0;

        for(unsigned int y = 0; y < size/8; ++y) {
          y_ret[j][x][k] += bias;
          y_ret[j][x][k+1] += bias;
          y_ret[j][x][k+2] += bias;
          y_ret[j][x][k+3] += bias;
          y_ret[j][x][k+4] += bias;
          y_ret[j][x][k+5] += bias;
          y_ret[j][x][k+6] += bias;
          y_ret[j][x][k+7] += bias;
          k += 8;
        }
        while (k < size) { y_ret[j][x][k] += bias; ++k; }

      }
    });

  //auto t2 = std::chrono::high_resolution_clock::now();
  /*
  cout << "Parallal : "
       << std::chrono::duration_cast<std::chrono::microseconds>(t2-t1).count()
       << " microseconds." << endl;
  */

  return out;
}

virtual unsigned int keras::LayerConv2D::get_input_cols ( ) const

inlinevirtual

Implements keras::Layer.

Definition at line 187 of file keras_model.h.

{ return m_cols; }

virtual unsigned int keras::LayerConv2D::get_input_rows ( ) const

inlinevirtual

Implements keras::Layer.

Definition at line 186 of file keras_model.h.

{ return m_rows; }

virtual unsigned int keras::LayerConv2D::get_output_units ( ) const

inlinevirtual

Implements keras::Layer.

Definition at line 188 of file keras_model.h.

{ return m_kernels_cnt; }

void keras::LayerConv2D::load_weights ( std::ifstream &  fin )

virtual

Implements keras::Layer.

Definition at line 40 of file keras_model.cc.

                                                    {
  char tmp_char = ' ';
  string tmp_str = "";
  float tmp_float;
  bool skip = false;
  fin >> m_kernels_cnt >> m_depth >> m_rows >> m_cols >> m_border_mode;
  if (m_border_mode == "[") { m_border_mode = "valid"; skip = true; }

  cout << "LayerConv2D " << m_kernels_cnt
    << "x" << m_depth << "x" << m_rows << "x" << m_cols << " border_mode " << m_border_mode << endl;
  // reading kernel weights
  for(int k = 0; k < m_kernels_cnt; ++k) {
    vector<vector<vector<float> > > tmp_depths;
    for(int d = 0; d < m_depth; ++d) {
      vector<vector<float> > tmp_single_depth;
      for(int r = 0; r < m_rows; ++r) {
        if (!skip) { fin >> tmp_char; } // for '['
        else { skip = false; }
        vector<float> tmp_row;
        for(int c = 0; c < m_cols; ++c) {
          fin >> tmp_float;
          //cout << tmp_float << " ";
          tmp_row.push_back(tmp_float);
        }
        fin >> tmp_char; // for ']'
        tmp_single_depth.push_back(tmp_row);
      }
      tmp_depths.push_back(tmp_single_depth);
    }
    m_kernels.push_back(tmp_depths);
  }
  // reading kernel biases
  fin >> tmp_char; // for '['
  for(int k = 0; k < m_kernels_cnt; ++k) {
    fin >> tmp_float;
    m_bias.push_back(tmp_float);
  }
  fin >> tmp_char; // for ']'

}

Member Data Documentation

std::vector<float> keras::LayerConv2D::m_bias

Definition at line 184 of file keras_model.h.

std::string keras::LayerConv2D::m_border_mode

Definition at line 190 of file keras_model.h.

int keras::LayerConv2D::m_cols

Definition at line 194 of file keras_model.h.

int keras::LayerConv2D::m_depth

Definition at line 192 of file keras_model.h.

std::vector<std::vector<std::vector<std::vector<float> > > > keras::LayerConv2D::m_kernels

Definition at line 183 of file keras_model.h.

int keras::LayerConv2D::m_kernels_cnt

Definition at line 191 of file keras_model.h.

int keras::LayerConv2D::m_rows

Definition at line 193 of file keras_model.h.

---

The documentation for this class was generated from the following files:

• larrecodnn/larrecodnn/ImagePatternAlgs/Keras/keras_model.h
• larrecodnn/larrecodnn/ImagePatternAlgs/Keras/keras_model.cc