C++ API Reference

struct aeon_DataLoader

Public Members

PyObject_HEAD PyObject* aeon_DataLoader::ndata
PyObject *aeon_DataLoaderbatch_size
PyObject *aeon_DataLoaderaxes_info
PyObject *aeon_DataLoaderconfig
PyObject *aeon_DataLoadersession_id
loader *aeon_DataLoaderm_loader
uint32_t aeon_DataLoaderm_i
bool aeon_DataLoaderm_first_iteration
struct aeon_state

Public Members

PyObject *aeon_stateerror
struct nervana::pythonallow_threads
#include <python_utils.hpp>
class nervana::localization::rcnnanchor
#include <etl_localization_rcnn.hpp>

Public Static Functions

vector<box> localization::rcnn::anchorgenerate(const localization::rcnn::config &cfg)
vector<int> localization::rcnn::anchorinside_image_bounds(int width, int height, const std::vector<box> &all_anchors)

Private Functions

nervana::localization::rcnn::anchoranchor()

Private Static Functions

vector<box> localization::rcnn::anchorgenerate_anchors(size_t base_size, const std::vector<float> &ratios, const std::vector<float> &scales)
vector<box> localization::rcnn::anchorratio_enum(const box &anchor, const std::vector<float> &ratios)
vector<box> localization::rcnn::anchormkanchors(const std::vector<float> &ws, const std::vector<float> &hs, float x_ctr, float y_ctr)
vector<box> localization::rcnn::anchorscale_enum(const box &anchor, const std::vector<float> &scales)
template <typename INPUT, typename OUTPUT>
class nervanaasync_manager
#include <async_manager.hpp>

Inherits from nervana::async_manager_source< OUTPUT >, nervana::async_manager_info

Public Functions

nervana::async_managerasync_manager(std::shared_ptr<async_manager_source<INPUT>> source, const std::string &name)
virtual nervana::async_manager~async_manager()
OUTPUT *nervana::async_managernext()
virtual OUTPUT *nervana::async_managerfiller() = 0
virtual void nervana::async_managerreset()
virtual void nervana::async_managerinitialize()
void nervana::async_managerfinalize()
virtual void nervana::async_managersuspend_output()
async_state nervana::async_managerget_state() const
const std::string &nervana::async_managerget_name() const

Protected Types

typedef std::tuple<OUTPUT *, std::exception_ptr> nervana::async_managerinner_buffer_t

Protected Functions

nervana::async_managerasync_manager(const async_manager&)
void nervana::async_managerrun_filler()
OUTPUT *nervana::async_managerget_pending_buffer()

Protected Attributes

template<>
OUTPUT nervana::async_manager<INPUT, OUTPUT>m_containers[2]
OUTPUT *nervana::async_managerm_pending_buffer
std::shared_ptr<async_manager_source<INPUT>> nervana::async_managerm_source
async_state nervana::async_managerm_state = async_state::idle
std::string nervana::async_managerm_name
BlockingQueue<inner_buffer_t> nervana::async_managerm_bq_input
BlockingQueue<inner_buffer_t> nervana::async_managerm_bq_output
std::shared_ptr<std::thread> nervana::async_managerfill_thread
bool nervana::async_managerm_bfirst_next = {true}
volatile bool nervana::async_managerm_active_thread = {false}
std::mutex nervana::async_managerm_mutex
class nervanaasync_manager_info
#include <async_manager.hpp>

Subclassed by nervana::async_manager< encoded_record_list, encoded_record_list >, nervana::async_manager< encoded_record_list, fixed_buffer_map >, nervana::async_manager< fixed_buffer_map, fixed_buffer_map >, nervana::async_manager< std::vector< std::vector< std::string > >, encoded_record_list >, nervana::async_manager< INPUT, OUTPUT >

Public Functions

virtual nervana::async_manager_info~async_manager_info()
virtual async_state nervana::async_manager_infoget_state() const = 0
virtual const std::string &nervana::async_manager_infoget_name() const = 0
template <typename OUTPUT>
class nervanaasync_manager_source
#include <async_manager.hpp>

Subclassed by nervana::async_manager< INPUT, OUTPUT >

Public Functions

nervana::async_manager_sourceasync_manager_source()
virtual nervana::async_manager_source~async_manager_source()
virtual OUTPUT *nervana::async_manager_sourcenext() = 0
virtual size_t nervana::async_manager_sourcerecord_count() const = 0
virtual size_t nervana::async_manager_sourceelements_per_record() const = 0
virtual void nervana::async_manager_sourcereset() = 0
virtual void nervana::async_manager_sourcesuspend_output()
nervana::async_manager_sourceasync_manager_source(const async_manager_source&)
class nervana::provideraudio
#include <provider.hpp>

Inherits from nervana::provider::interface

Public Functions

provider::audioaudio(nlohmann::json js, nlohmann::json aug)
virtual nervana::provider::audio~audio()
void provider::audioprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation &aug) const

Private Members

nervana::audio::config nervana::provider::audiom_config
nervana::audio::extractor nervana::provider::audiom_extractor
nervana::audio::transformer nervana::provider::audiom_transformer
nervana::audio::loader nervana::provider::audiom_loader
augment::audio::param_factory nervana::provider::audiom_augmentation_factory
const std::string nervana::provider::audiom_buffer_name
const std::string nervana::provider::audiom_length_name
class nervanaaugmentation
#include <provider.hpp>

Public Members

std::shared_ptr<augment::image::params> nervana::augmentationm_image_augmentations
std::shared_ptr<augment::audio::params> nervana::augmentationm_audio_augmentations
struct nervanaAviIndex
#include <avi.hpp>

Public Members

uint32_t nervana::AviIndexckid
uint32_t nervana::AviIndexdwFlags
uint32_t nervana::AviIndexdwChunkOffset
uint32_t nervana::AviIndexdwChunkLength
struct nervanaAviMainHeader
#include <avi.hpp>

Public Members

uint32_t nervana::AviMainHeaderdwMicroSecPerFrame
uint32_t nervana::AviMainHeaderdwMaxBytesPerSec
uint32_t nervana::AviMainHeaderdwReserved1
uint32_t nervana::AviMainHeaderdwFlags
uint32_t nervana::AviMainHeaderdwTotalFrames
uint32_t nervana::AviMainHeaderdwInitialFrames
uint32_t nervana::AviMainHeaderdwStreams
uint32_t nervana::AviMainHeaderdwSuggestedBufferSize
uint32_t nervana::AviMainHeaderdwWidth
uint32_t nervana::AviMainHeaderdwHeight
uint32_t nervana::AviMainHeaderdwReserved[4]
class nervanaAviMjpegStream
#include <avi.hpp>

Public Functions

nervana::AviMjpegStreamAviMjpegStream()
bool nervana::AviMjpegStreamparseAvi(std::istream &in_str)
bool nervana::AviMjpegStreamparseAvi(std::istream &in_str, frame_list &in_frame_list)
size_t nervana::AviMjpegStreamgetFramesCount()
frame_list &nervana::AviMjpegStreamgetFrames()
uint32_t nervana::AviMjpegStreamgetWidth()
uint32_t nervana::AviMjpegStreamgetHeight()
double nervana::AviMjpegStreamgetFps()

Protected Functions

bool nervana::AviMjpegStreamparseAviWithFrameList(std::istream &in_str, frame_list &in_frame_list)
void nervana::AviMjpegStreamskipJunk(RiffChunk &chunk, std::istream &in_str)
void nervana::AviMjpegStreamskipJunk(RiffList &list, std::istream &in_str)
bool nervana::AviMjpegStreamparseHdrlList(std::istream &in_str)
bool nervana::AviMjpegStreamparseIndex(std::istream &in_str, uint32_t index_size, frame_list &in_frame_list)
bool nervana::AviMjpegStreamparseMovi(std::istream &in_str, frame_list &in_frame_list)
bool nervana::AviMjpegStreamparseStrl(std::istream &in_str, uint8_t stream_id)
bool nervana::AviMjpegStreamparseInfo(std::istream &in_str)
void nervana::AviMjpegStreamprintError(std::istream &in_str, RiffList &list, uint32_t expected_fourcc)
void nervana::AviMjpegStreamprintError(std::istream &in_str, RiffChunk &chunk, uint32_t expected_fourcc)

Protected Attributes

uint32_t nervana::AviMjpegStreamm_stream_id
uint64_t nervana::AviMjpegStreamm_movi_start
uint64_t nervana::AviMjpegStreamm_movi_end
frame_list nervana::AviMjpegStreamm_frame_list
uint32_t nervana::AviMjpegStreamm_width
uint32_t nervana::AviMjpegStreamm_height
double nervana::AviMjpegStreamm_fps
bool nervana::AviMjpegStreamm_is_indx_present
struct nervanaAviStreamHeader
#include <avi.hpp>

Public Members

uint32_t nervana::AviStreamHeaderfccType
uint32_t nervana::AviStreamHeaderfccHandler
uint32_t nervana::AviStreamHeaderdwFlags
uint32_t nervana::AviStreamHeaderdwPriority
uint32_t nervana::AviStreamHeaderdwInitialFrames
uint32_t nervana::AviStreamHeaderdwScale
uint32_t nervana::AviStreamHeaderdwRate
uint32_t nervana::AviStreamHeaderdwStart
uint32_t nervana::AviStreamHeaderdwLength
uint32_t nervana::AviStreamHeaderdwSuggestedBufferSize
uint32_t nervana::AviStreamHeaderdwQuality
uint32_t nervana::AviStreamHeaderdwSampleSize
int16_t nervana::AviStreamHeaderleft
int16_t nervana::AviStreamHeadertop
int16_t nervana::AviStreamHeaderright
int16_t nervana::AviStreamHeaderbottom
struct nervana::AviStreamHeader::@0 nervana::AviStreamHeader::rcFrame
class nervanabase64
#include <base64.hpp>

Public Static Functions

static std::vector<char> nervana::base64encode(const std::vector<char> &data)
vector<char> nervana::base64encode(const char *data, size_t size)
static std::vector<char> nervana::base64decode(const std::vector<char> &data)
vector<char> nervana::base64decode(const char *data, size_t size)
string nervana::base64gen_decode_table()

Private Static Attributes

const uint8_t nervana::base64character_codes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
const uint8_t nervana::base64decode_codes = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00}
class nervanabatch_decoder
#include <batch_decoder.hpp>

Inherits from nervana::async_manager< encoded_record_list, fixed_buffer_map >

Public Functions

batch_decoderbatch_decoder(std::shared_ptr<batch_iterator> b_itor, size_t batch_size, uint32_t thread_count, bool pinned, const std::shared_ptr<provider_interface> &prov, uint32_t seed = 0)
batch_decoder~batch_decoder()
virtual size_t nervana::batch_decoderrecord_count() const
virtual size_t nervana::batch_decoderelements_per_record() const
fixed_buffer_map *batch_decoderfiller()
void nervana::batch_decoderregister_info_handler(std::function<void(const fixed_buffer_map *)> &f)
void batch_decoderprocess(const int index)

Private Members

size_t nervana::batch_decoderm_batch_size
size_t nervana::batch_decoderm_number_elements_in
size_t nervana::batch_decoderm_number_elements_out
std::shared_ptr<const provider_interface> nervana::batch_decoderm_provider
encoded_record_list *nervana::batch_decoderm_inputs = {nullptr}
fixed_buffer_map *nervana::batch_decoderm_outputs = {nullptr}
std::shared_ptr<thread_pool_queue<batch_decoder, &batch_decoder::process>> nervana::batch_decoderm_thread_pool
std::function<void(const fixed_buffer_map *)> nervana::batch_decoderm_info_handler
size_t nervana::batch_decoderm_iteration_number = {0}
std::vector<nervana::random_engine_t> nervana::batch_decoderm_random
bool nervana::batch_decoderm_deterministic_mode
class nervanabatch_iterator
#include <batch_iterator.hpp>

Inherits from nervana::async_manager< encoded_record_list, encoded_record_list >

Public Functions

batch_iteratorbatch_iterator(std::shared_ptr<block_manager>, size_t batch_size)
nervana::batch_iterator~batch_iterator()
encoded_record_list *batch_iteratorfiller()
size_t nervana::batch_iteratorrecord_count() const
size_t nervana::batch_iteratorelements_per_record() const
void nervana::batch_iteratorinitialize()

Private Members

size_t nervana::batch_iteratorm_batch_size
size_t nervana::batch_iteratorm_element_count
encoded_record_list *nervana::batch_iteratorm_input_ptr = {nullptr}
class nervanabatch_iterator_fbm
#include <batch_iterator.hpp>

Inherits from nervana::async_manager< fixed_buffer_map, fixed_buffer_map >

Public Functions

batch_iterator_fbmbatch_iterator_fbm(std::shared_ptr<batch_decoder> blkl, size_t batch_size, const std::shared_ptr<provider_interface> &prov, bool transpose)
nervana::batch_iterator_fbm~batch_iterator_fbm()
fixed_buffer_map *batch_iterator_fbmfiller()
size_t nervana::batch_iterator_fbmrecord_count() const
size_t nervana::batch_iterator_fbmelements_per_record() const
void nervana::batch_iterator_fbminitialize()

Private Members

size_t nervana::batch_iterator_fbmm_batch_size
bool nervana::batch_iterator_fbmm_transpose
size_t nervana::batch_iterator_fbmm_element_count
fixed_buffer_map *nervana::batch_iterator_fbmm_input_ptr = {nullptr}
size_t nervana::batch_iterator_fbmm_src_index = 0
size_t nervana::batch_iterator_fbmm_dst_index = 0
class nervana::augment::imagebatch_sampler
#include <augment_image.hpp>

Inherits from nervana::json_configurable

Public Functions

nervana::augment::image::batch_samplerbatch_sampler()
augment::image::batch_samplerbatch_sampler(const nlohmann::json &config)
void augment::image::batch_samplersample_patches(const std::vector<normalized_box::box> &normalized_object_bboxes, std::vector<normalized_box::box> &normalized_output) const

Private Functions

bool nervana::augment::image::batch_samplerhas_max_sample() const

Private Members

int nervana::augment::image::batch_samplerm_max_sample = -1
unsigned int nervana::augment::image::batch_samplerm_max_trials = 100
nlohmann::json nervana::augment::image::batch_samplerm_sampler_json
sampler nervana::augment::image::batch_samplerm_sampler
nlohmann::json nervana::augment::image::batch_samplerm_sample_constraint_json
sample_constraint nervana::augment::image::batch_samplerm_sample_constraint
std::vector<std::shared_ptr<interface::config_info_interface>> nervana::augment::image::batch_samplerconfig_list = { ADD_SCALAR_WITH_KEY( m_max_sample, "max_sample", mode::OPTIONAL, [](int x) { return x >= 0; }), ADD_SCALAR_WITH_KEY(m_max_trials, "max_trials", mode::OPTIONAL), ADD_JSON(m_sampler_json, "sampler", mode::OPTIONAL), ADD_JSON(m_sample_constraint_json, "sample_constraint", mode::OPTIONAL)}
struct nervanaBitmapInfoHeader
#include <avi.hpp>

Public Members

uint32_t nervana::BitmapInfoHeaderbiSize
int32_t nervana::BitmapInfoHeaderbiWidth
int32_t nervana::BitmapInfoHeaderbiHeight
uint16_t nervana::BitmapInfoHeaderbiPlanes
uint16_t nervana::BitmapInfoHeaderbiBitCount
uint32_t nervana::BitmapInfoHeaderbiCompression
uint32_t nervana::BitmapInfoHeaderbiSizeImage
int32_t nervana::BitmapInfoHeaderbiXPelsPerMeter
int32_t nervana::BitmapInfoHeaderbiYPelsPerMeter
uint32_t nervana::BitmapInfoHeaderbiClrUsed
uint32_t nervana::BitmapInfoHeaderbiClrImportant
class nervana::providerblob
#include <provider.hpp>

Inherits from nervana::provider::interface

Public Functions

provider::blobblob(nlohmann::json js)
virtual nervana::provider::blob~blob()
void provider::blobprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation&) const

Private Functions

nervana::provider::blobblob()

Private Members

nervana::blob::config nervana::provider::blobm_config
nervana::blob::extractor nervana::provider::blobm_extractor
nervana::blob::loader nervana::provider::blobm_loader
const std::string nervana::provider::blobm_buffer_name
class nervanablock_info
#include <block.hpp>

Public Functions

nervana::block_infoblock_info(size_t start, size_t count)
size_t nervana::block_infostart() const
size_t nervana::block_infocount() const
size_t nervana::block_infoend() const

Private Members

size_t nervana::block_infom_start
size_t nervana::block_infom_count
class nervanablock_loader_file
#include <block_loader_file.hpp>

Inherits from nervana::block_loader_source, nervana::async_manager< std::vector< std::vector< std::string > >, encoded_record_list >

Public Functions

block_loader_fileblock_loader_file(std::shared_ptr<manifest_file> mfst, size_t block_size)
virtual nervana::block_loader_file~block_loader_file()
nervana::encoded_record_list *block_loader_filefiller()
size_t nervana::block_loader_fileblock_count() const
size_t nervana::block_loader_filerecord_count() const
size_t nervana::block_loader_fileblock_size() const
size_t nervana::block_loader_fileelements_per_record() const
source_uid_t nervana::block_loader_fileget_uid() const
async_state nervana::block_loader_fileget_state() const
const std::string &nervana::block_loader_fileget_name() const

Private Members

size_t nervana::block_loader_filem_block_size
size_t nervana::block_loader_filem_block_count
size_t nervana::block_loader_filem_record_count
size_t nervana::block_loader_filem_elements_per_record
std::shared_ptr<manifest_file> nervana::block_loader_filem_manifest
class nervanablock_loader_nds
#include <block_loader_nds.hpp>

Inherits from nervana::block_loader_source, nervana::async_manager< encoded_record_list, encoded_record_list >

Public Functions

block_loader_ndsblock_loader_nds(std::shared_ptr<manifest_nds>, size_t block_size)
virtual nervana::block_loader_nds~block_loader_nds()
encoded_record_list *nervana::block_loader_ndsfiller()
size_t nervana::block_loader_ndsrecord_count() const
size_t nervana::block_loader_ndsblock_size() const
size_t nervana::block_loader_ndsblock_count() const
size_t nervana::block_loader_ndselements_per_record() const
source_uid_t nervana::block_loader_ndsget_uid() const

Private Members

size_t nervana::block_loader_ndsm_block_size
size_t nervana::block_loader_ndsm_block_count
size_t nervana::block_loader_ndsm_record_count
size_t nervana::block_loader_ndsm_elements_per_record
class nervanablock_loader_source
#include <block_loader_source.hpp>

Inherits from nervana::async_manager_source< encoded_record_list >

Subclassed by nervana::block_loader_file, nervana::block_loader_nds

Public Functions

virtual nervana::block_loader_source~block_loader_source()
virtual size_t nervana::block_loader_sourceblock_size() const = 0
virtual size_t nervana::block_loader_sourceblock_count() const = 0
virtual source_uid_t nervana::block_loader_sourceget_uid() const = 0
class nervanablock_manager
#include <block_manager.hpp>

Inherits from nervana::async_manager< encoded_record_list, encoded_record_list >

Public Functions

nervana::block_managerblock_manager(std::shared_ptr<block_loader_source> file_loader, size_t block_size, const std::string &cache_root, bool enable_shuffle, uint32_t seed = 0)
virtual nervana::block_manager~block_manager()
encoded_record_list *nervana::block_managerfiller()
virtual void nervana::block_managerinitialize()
size_t nervana::block_managerrecord_count() const
size_t nervana::block_managerelements_per_record() const

Private Members

std::unique_ptr<cache_system> nervana::block_managerm_cache
size_t nervana::block_managerm_current_block_number
size_t nervana::block_managerm_block_size
size_t nervana::block_managerm_block_count
size_t nervana::block_managerm_record_count
size_t nervana::block_managerm_elements_per_record
struct nervana::pythonblock_threads
#include <python_utils.hpp>

Public Functions

nervana::python::block_threadsblock_threads(allow_threads&)
template <typename T>
class BlockingQueue
#include <blocking_queue.h>

Public Functions

T BlockingQueuepop()
void BlockingQueuepop(T &item)
void BlockingQueuetop(T &item)
void BlockingQueuepush(const T &item)
void BlockingQueuepush(T &&item)
void BlockingQueueclear()

Private Members

std::queue<T> BlockingQueuem_queue
std::mutex BlockingQueuem_mutex
std::condition_variable BlockingQueuem_cond
class nervana::providerboundingbox
#include <provider.hpp>

Inherits from nervana::provider::interface

Public Functions

provider::boundingboxboundingbox(nlohmann::json js, nlohmann::json aug)
virtual nervana::provider::boundingbox~boundingbox()
void provider::boundingboxprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation &aug) const

Private Functions

nervana::provider::boundingboxboundingbox()
class nervana::boundingboxbox
#include <boundingbox.hpp>

Inherits from nervana::box

Public Functions

nervana::boundingbox::boxbox()
nervana::boundingbox::boxbox(float xmin, float ymin, float xmax, float ymax, int label = default_label, bool difficult = default_difficult, bool truncated = default_truncated)
nervana::boundingbox::box~box()
float nervana::boundingbox::boxjaccard_overlap(const nervana::boundingbox::box &second_bbox) const
float nervana::boundingbox::boxcoverage(const nervana::boundingbox::box &second_bbox) const
nervana::boundingbox::box nervana::boundingbox::boxintersect(const nervana::boundingbox::box &second_bbox) const
bool nervana::boundingbox::boxoperator==(const nervana::boundingbox::box &b) const
bool nervana::boundingbox::boxoperator!=(const nervana::boundingbox::box &b) const
boundingbox::box &nervana::boundingbox::boxoperator=(const nervana::boundingbox::box &b)
boundingbox::box nervana::boundingbox::boxoperator+(const cv::Point &s) const
boundingbox::box nervana::boundingbox::boxoperator+(const boundingbox::box &b) const
boundingbox::box nervana::boundingbox::boxrescale(float x, float y) const
boundingbox::box nervana::boundingbox::boxexpand(const cv::Size2i &expand_offset, const cv::Size2i &expand_size, const float expand_ratio) const
int nervana::boundingbox::boxlabel() const
bool nervana::boundingbox::boxdifficult() const
bool nervana::boundingbox::boxtruncated() const
nervana::normalized_box::box nervana::boundingbox::boxnormalize(float width, float height) const

Public Static Attributes

const int nervana::boundingbox::boxdefault_label = -1
const bool nervana::boundingbox::boxdefault_difficult = false
const bool nervana::boundingbox::boxdefault_truncated = false

Protected Attributes

int nervana::boundingbox::boxm_label = default_label
bool nervana::boundingbox::boxm_difficult = default_difficult
bool nervana::boundingbox::boxm_truncated = default_truncated
class nervanabox
#include <box.hpp>

Subclassed by nervana::boundingbox::box, nervana::normalized_box::box

Public Functions

nervana::boxbox()
nervana::boxbox(float xmin, float ymin, float xmax, float ymax)
virtual nervana::box~box()
virtual float nervana::boxwidth() const
virtual float nervana::boxheight() const
virtual cv::Rect nervana::boxrect() const
float nervana::boxsize() const
nervana::box nervana::boxoperator+(const nervana::box &b) const
nervana::box nervana::boxoperator*(float v) const
bool nervana::boxoperator==(const nervana::box &b) const
bool nervana::boxoperator!=(const nervana::box &b) const
nervana::box &nervana::boxoperator=(const nervana::box &b)
float nervana::boxymin() const
float nervana::boxxmin() const
float nervana::boxymax() const
float nervana::boxxmax() const
float nervana::boxxcenter() const
float nervana::boxycenter() const
void nervana::boxset_xmin(float x)
void nervana::boxset_ymin(float y)
void nervana::boxset_xmax(float xmax)
void nervana::boxset_ymax(float ymax)

Protected Attributes

float nervana::boxm_xmin = 0
float nervana::boxm_ymin = 0
float nervana::boxm_xmax = -1
float nervana::boxm_ymax = -1
class nervana::normalized_boxbox
#include <normalized_box.hpp>

Inherits from nervana::box

Public Functions

nervana::normalized_box::boxbox()
nervana::normalized_box::boxbox(float xmin, float ymin, float xmax, float ymax)
nervana::normalized_box::box~box()
nbox &nboxoperator=(const box &b)
float nervana::normalized_box::boxwidth() const
float nervana::normalized_box::boxheight() const
cv::Rect nervana::normalized_box::boxrect() const
float nboxjaccard_overlap(const nervana::normalized_box::box &second_box) const
float nboxcoverage(const nervana::normalized_box::box &second_box) const
nbox nboxintersect(const nervana::normalized_box::box &second_box) const
nervana::boundingbox::box nervana::normalized_box::boxunnormalize(float width, float height)
bool nboxis_properly_normalized() const

Protected Functions

void nboxthrow_if_improperly_normalized() const
class nervanabuffer_fixed_size_elements
#include <buffer_batch.hpp>

Public Functions

nervana::buffer_fixed_size_elementsbuffer_fixed_size_elements()
buffer_fixed_size_elementsbuffer_fixed_size_elements(const shape_type &shp_tp, size_t batch_size, bool pinned = false)
buffer_fixed_size_elements~buffer_fixed_size_elements()
buffer_fixed_size_elementsbuffer_fixed_size_elements(const buffer_fixed_size_elements &rhs)
buffer_fixed_size_elementsbuffer_fixed_size_elements(buffer_fixed_size_elements &&other)
buffer_fixed_size_elements &buffer_fixed_size_elementsoperator=(buffer_fixed_size_elements &&other)
void buffer_fixed_size_elementsmove(buffer_fixed_size_elements &second)
void buffer_fixed_size_elementsallocate()
void buffer_fixed_size_elementsdeallocate()
const char *buffer_fixed_size_elementsget_item(size_t index) const
char *buffer_fixed_size_elementsget_item(size_t index)
cv::Mat buffer_fixed_size_elementsget_item_as_mat(size_t index, bool channel_major = false) const
char *nervana::buffer_fixed_size_elementsdata() const
size_t nervana::buffer_fixed_size_elementsget_item_count() const
size_t nervana::buffer_fixed_size_elementssize() const
size_t nervana::buffer_fixed_size_elementsget_stride() const
const shape_type &nervana::buffer_fixed_size_elementsget_shape_type() const
std::ostream &buffer_fixed_size_elementsserialize(std::ostream &out) const
std::istream &buffer_fixed_size_elementsdeserialize(std::istream &in)

Protected Attributes

char *nervana::buffer_fixed_size_elementsm_data = {nullptr}
shape_type nervana::buffer_fixed_size_elementsm_shape_type
size_t nervana::buffer_fixed_size_elementsm_size = {0}
size_t nervana::buffer_fixed_size_elementsm_batch_size = {0}
size_t nervana::buffer_fixed_size_elementsm_stride = {0}
bool nervana::buffer_fixed_size_elementsm_pinned = {false}
class nervanacache_system
#include <cache_system.hpp>

Public Functions

cache_systemcache_system(source_uid_t uid, size_t block_count, size_t elements_per_record, const std::string &cache_root, bool shuffle_enabled, uint32_t seed = 0)
cache_system~cache_system()
void cache_systemload_block(encoded_record_list &buffer)
void cache_systemstore_block(const encoded_record_list &buffer)
bool nervana::cache_systemis_complete()
bool nervana::cache_systemis_ownership()
void cache_systemtry_get_access()
void cache_systemrestart()

Private Types

enum nervana::cache_systemstages

Values:

nervana::cache_systemcomplete
nervana::cache_systemownership
nervana::cache_systemblocked

Private Functions

bool cache_systemcheck_if_complete(const std::string &cache_dir)
void cache_systemmark_cache_complete(const std::string &cache_dir)
bool cache_systemtake_ownership(const std::string &cache_dir, int &lock)
void cache_systemrelease_ownership(const std::string &cache_dir, int lock)
string cache_systemcreate_cache_name(source_uid_t uid)
string cache_systemcreate_cache_block_name(size_t block_number)

Private Members

nervana::cache_system::stages nervana::cache_systemm_stage
size_t nervana::cache_systemm_block_count
std::vector<size_t> nervana::cache_systemm_block_load_sequence
const std::string nervana::cache_systemm_cache_root
std::string nervana::cache_systemm_cache_dir
bool nervana::cache_systemm_shuffle_enabled
size_t nervana::cache_systemm_elements_per_record
size_t nervana::cache_systemm_current_block_number
int nervana::cache_systemm_cache_lock = -1
std::minstd_rand0 nervana::cache_systemm_random

Private Static Attributes

const std::string cache_systemm_owner_lock_filename = "caching_in_progress"
const std::string cache_systemm_cache_complete_filename = "cache_complete"
mutex cache_systemm_mutex
class nervana::providerchar_map
#include <provider.hpp>

Inherits from nervana::provider::interface

Public Functions

provider::char_mapchar_map(nlohmann::json js)
virtual nervana::provider::char_map~char_map()
void provider::char_mapprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation&) const

Private Functions

nervana::provider::char_mapchar_map()

Private Members

nervana::char_map::config nervana::provider::char_mapm_config
nervana::char_map::extractor nervana::provider::char_mapm_extractor
nervana::char_map::loader nervana::provider::char_mapm_loader
const std::string nervana::provider::char_mapm_buffer_name
const std::string nervana::provider::char_mapm_length_name
class nervana::char_mapconfig
#include <etl_char_map.hpp>

Inherits from nervana::interface::config

Public Functions

nervana::char_map::configconfig(nlohmann::json js)
const cmap_t &nervana::char_map::configget_cmap() const

Public Members

uint32_t nervana::char_map::configmax_length

Maximum length of each transcript. Samples with longer transcripts will be truncated

std::string nervana::char_map::configalphabet

Character map alphabet

std::wstring nervana::char_map::configwalphabet

Same alphabet in wchar_t

uint32_t nervana::char_map::configunknown_value = 0

Integer value to give to unknown characters. 0 causes them to be discarded.

bool nervana::char_map::configemit_length = false

Whether to also output the number of valid characters per record

std::string nervana::char_map::configoutput_type = {"uint32_t"}

Output data type

std::string nervana::char_map::configname

Private Functions

nervana::char_map::configconfig()
void nervana::char_map::configvalidate()
bool nervana::char_map::configunique_chars(std::wstring test_string)

Friends

friend nervana::char_map::config::extractor
class nervana::imageconfig
#include <etl_image.hpp>

Configuration for image ETL.

An instantiation of this class controls the ETL of image data into the target memory buffers from the source CPIO archives.

Inherits from nervana::interface::config

Public Functions

image::configconfig(nlohmann::json js)
const std::vector<std::shared_ptr<interface::config_info_interface>> &nervana::image::configget_config_list()
nervana::image::configconfig()

Public Members

uint32_t nervana::image::configheight
uint32_t nervana::image::configwidth
std::string nervana::image::configoutput_type = {"uint8_t"}
bool nervana::image::configchannel_major = true
uint32_t nervana::image::configchannels = 3
std::string nervana::image::configname

Private Functions

void image::configvalidate()

Private Members

std::vector<std::shared_ptr<interface::config_info_interface>> nervana::image::configconfig_list = { ADD_SCALAR(height, mode::REQUIRED), ADD_SCALAR(width, mode::REQUIRED), ADD_SCALAR(name, mode::OPTIONAL), ADD_SCALAR(channel_major, mode::OPTIONAL), ADD_SCALAR(channels, mode::OPTIONAL, [](uint32_t v) { return v == 1 || v == 3; }), ADD_SCALAR(output_type, mode::OPTIONAL, [](const std::string& v) { return output_type::is_valid_type(v); })}
bool nervana::image::configflip_enable = false
bool nervana::image::configcenter = true

Friends

friend nervana::image::config::video::config
friend nervana::image::config::multicrop::config
class nervana::labelconfig
#include <etl_label.hpp>

Inherits from nervana::interface::config

Public Functions

nervana::label::configconfig(nlohmann::json js)

Public Members

bool nervana::label::configbinary = false
std::string nervana::label::configoutput_type = {"uint32_t"}
std::string nervana::label::configtype
std::string nervana::label::configname

Private Functions

nervana::label::configconfig()
class nervana::label_mapconfig
#include <etl_label_map.hpp>

Inherits from nervana::interface::config

Public Functions

configconfig(nlohmann::json js)
virtual nervana::label_map::config~config()
int nervana::label_map::configmax_label_count() const

Public Members

std::string nervana::label_map::configoutput_type = "uint32_t"
std::vector<std::string> nervana::label_map::configclass_names
int nervana::label_map::configmax_classes = 100
std::string nervana::label_map::configname

Private Functions

nervana::label_map::configconfig()
class nervana::localization::rcnnconfig
#include <etl_localization_rcnn.hpp>

Inherits from nervana::interface::config

Public Functions

localization::rcnn::configconfig(nlohmann::json js)
size_t nervana::localization::rcnn::configtotal_anchors() const

Public Members

size_t nervana::localization::rcnn::configrois_per_image = 256
size_t nervana::localization::rcnn::configheight
size_t nervana::localization::rcnn::configwidth
size_t nervana::localization::rcnn::configbase_size = 16
float nervana::localization::rcnn::configscaling_factor = 1.0 / 16.
std::vector<float> nervana::localization::rcnn::configratios = {0.5, 1, 2}
std::vector<float> nervana::localization::rcnn::configscales = {8, 16, 32}
float nervana::localization::rcnn::confignegative_overlap = 0.3
float nervana::localization::rcnn::configpositive_overlap = 0.7
float nervana::localization::rcnn::configforeground_fraction = 0.5
size_t nervana::localization::rcnn::configmax_gt_boxes = 64
std::vector<std::string> nervana::localization::rcnn::configclass_names
std::string nervana::localization::rcnn::configname
size_t nervana::localization::rcnn::configoutput_buffer_size
std::unordered_map<std::string, int> nervana::localization::rcnn::configclass_name_map

Private Functions

nervana::localization::rcnn::configconfig()
void localization::rcnn::configvalidate()
class nervana::localization::ssdconfig
#include <etl_localization_ssd.hpp>

Inherits from nervana::interface::config

Public Functions

localization::ssd::configconfig(nlohmann::json js)

Public Members

size_t nervana::localization::ssd::configheight
size_t nervana::localization::ssd::configwidth
size_t nervana::localization::ssd::configmax_gt_boxes = 64
std::vector<std::string> nervana::localization::ssd::configclass_names
std::string nervana::localization::ssd::configname
size_t nervana::localization::ssd::configoutput_buffer_size
std::unordered_map<std::string, int> nervana::localization::ssd::configclass_name_map

Private Functions

nervana::localization::ssd::configconfig()
void nervana::localization::ssd::configvalidate()
class nervana::videoconfig
#include <etl_video.hpp>

Inherits from nervana::interface::config

Public Functions

nervana::video::configconfig(nlohmann::json js)

Public Members

uint32_t nervana::video::configmax_frame_count
nervana::image::config nervana::video::configframe
std::string nervana::video::configname

Private Functions

nervana::video::configconfig()
class nervana::audioconfig
#include <etl_audio.hpp>

Configuration for audio ETL.

An instantiation of this class controls the ETL of audio data into the target memory buffers from the source CPIO archives.

Extract

  • Audio files should be stored in mono, PCM-16 .wav format. If needed, you should create an ingestion script to convert to this format (commonly using sox or ffmpeg)

Transform

  • Audio can be transformed into three different representations: spectrogram, mel-frequency spectral coefficients, or mel-frequency cepstral coefficients

Load

  • Just a simple loading into a memory buffer.

Inherits from nervana::interface::config

Public Functions

nervana::audio::configconfig(nlohmann::json js)

Parses the configuration JSON.

void nervana::audio::configvalidate()

Public Members

std::string nervana::audio::configname
std::string nervana::audio::configmax_duration

Maximum duration of any audio clip in units of “seconds”, “milliseconds”, or “samples” (e.g. “4 seconds”).

std::string nervana::audio::configframe_stride

Interval between consecutive frames in units of “seconds”, “milliseconds”, or “samples” (e.g. .01 seconds).

std::string nervana::audio::configframe_length

Duration of each frame in units of “seconds”, “milliseconds”, or “samples” (e.g. .025 seconds).

uint32_t nervana::audio::confignum_cepstra = {40}

Number of cepstra to use (only for feature_type=”mfcc”)

uint32_t nervana::audio::confignum_filters = {64}

Number of filters to use for mel-frequency transform (used in feature_type=”mfsc”) (Not used for mfcc?)

std::string nervana::audio::configoutput_type = {"uint8_t"}

Input data type. Currently only “uint8_t” is supported.

std::string nervana::audio::configfeature_type = {"specgram"}

Feature space to represent audio. Options are “specgram” - Short-time fourier transform, “mfsc” - Mel-Frequency spectrogram, “mfcc” - Mel-Frequency cepstral coefficients

std::string nervana::audio::configwindow_type = {"hann"}

Window type for spectrogram generation

std::string nervana::audio::confignoise_index_file = {}
std::string nervana::audio::confignoise_root = {}
uint32_t nervana::audio::configsample_freq_hz = {16000}

Sample rate of input audio in hertz

std::uniform_real_distribution<float> nervana::audio::configtime_scale_fraction = {1.0f, 1.0f}

Simple linear time-warping

std::uniform_real_distribution<float> nervana::audio::confignoise_level = {0.0f, 0.5f}

How much noise to add (a value of 1 would be 0 dB SNR)

uint32_t nervana::audio::configtime_steps
uint32_t nervana::audio::configfreq_steps
uint32_t nervana::audio::configmax_duration_tn
uint32_t nervana::audio::configframe_length_tn
uint32_t nervana::audio::configframe_stride_tn
float nervana::audio::configmax_duration_ms
float nervana::audio::configframe_length_ms
float nervana::audio::configframe_stride_ms
std::bernoulli_distribution nervana::audio::configadd_noise = {0.0f}

Probability of adding noise

std::uniform_int_distribution<uint32_t> nervana::audio::confignoise_index = {0, UINT32_MAX}

Index into noise index file

std::uniform_real_distribution<float> nervana::audio::confignoise_offset_fraction = {0.0f, 1.0f}

Offset from start of noise file

bool nervana::audio::configemit_length = false

Whether to also output length of the buffer

Private Functions

nervana::audio::configconfig()
void nervana::audio::configparse_samples_or_seconds(const std::string &unit, float &ms, uint32_t &tn)
class nervana::blobconfig
#include <etl_blob.hpp>

Inherits from nervana::interface::config

Public Functions

nervana::blob::configconfig(nlohmann::json js)

Public Members

std::string nervana::blob::configoutput_type = {"float"}
size_t nervana::blob::configoutput_count
std::string nervana::blob::configname

Private Functions

nervana::blob::configconfig()

Private Members

std::vector<std::shared_ptr<interface::config_info_interface>> nervana::blob::configconfig_list = { ADD_SCALAR(output_count, mode::REQUIRED), ADD_SCALAR(name, mode::OPTIONAL), ADD_SCALAR(output_type, mode::OPTIONAL, [](const std::string& v) { return output_type::is_valid_type(v); })}
class nervana::interfaceconfig
#include <interface.hpp>

Inherits from nervana::json_configurable

Subclassed by nervana::audio::config, nervana::blob::config, nervana::boundingbox::config, nervana::char_map::config, nervana::image::config, nervana::label::config, nervana::label_map::config, nervana::loader_config, nervana::localization::rcnn::config, nervana::localization::ssd::config, nervana::provider_config, nervana::video::config

Public Functions

nervana::interface::configconfig()
const nervana::shape_type &nervana::interface::configget_shape_type(size_t index = 0) const
const std::vector<nervana::shape_type> &nervana::interface::configget_shape_type_list() const
void nervana::interface::configadd_shape_type(const std::vector<size_t> &shape_, const std::string &output_type_)
void nervana::interface::configadd_shape_type(const std::vector<size_t> &shape_, const nervana::output_type &output_type_)
void nervana::interface::configadd_shape_type(const std::vector<size_t> &shape_, const std::vector<std::string> &names_, const nervana::output_type &output_type_)

Private Members

std::vector<nervana::shape_type> nervana::interface::configm_shape_type_list
class nervana::boundingboxconfig
#include <etl_boundingbox.hpp>

Inherits from nervana::interface::config

Public Functions

boundingbox::configconfig(nlohmann::json js)

Public Members

size_t nervana::boundingbox::configheight
size_t nervana::boundingbox::configwidth
size_t nervana::boundingbox::configmax_bbox_count
std::vector<std::string> nervana::boundingbox::configclass_names
std::string nervana::boundingbox::configoutput_type = "float"
std::string nervana::boundingbox::configname
std::unordered_map<std::string, int> nervana::boundingbox::configlabel_map

Private Functions

nervana::boundingbox::configconfig()
void boundingbox::configvalidate()
template <typename T>
class nervana::interfaceconfig_info
#include <interface.hpp>

Inherits from nervana::interface::config_info_interface

Public Functions

nervana::interface::config_infoconfig_info(T &var, const std::string &name, nervana::interface::config::mode m, std::function<void(T&, const std::string&, const nlohmann::json&, nervana::interface::config::mode)> parse, std::function<bool(T)> validate = [](T) -> bool{return true;})
virtual nervana::interface::config_info~config_info()
const std::string &nervana::interface::config_infoname() const
bool nervana::interface::config_inforequired() const
std::string nervana::interface::config_infotype() const
std::string nervana::interface::config_infoget_default_value() const
void nervana::interface::config_infoparse(nlohmann::json js)

Private Functions

nervana::interface::config_infoconfig_info()

Private Members

T &nervana::interface::config_infom_target_variable
const std::string nervana::interface::config_infom_variable_name
nervana::interface::config::mode nervana::interface::config_infom_parse_mode
std::function<void(T&, const std::string&, const nlohmann::json&, nervana::interface::config::mode)> nervana::interface::config_infom_parse_function
std::function<bool(T)> nervana::interface::config_infom_validate_function
T nervana::interface::config_infom_default_value
class nervana::interfaceconfig_info_interface
#include <interface.hpp>

Subclassed by nervana::interface::config_info< T >

Public Functions

virtual nervana::interface::config_info_interface~config_info_interface()
virtual const std::string &nervana::interface::config_info_interfacename() const = 0
virtual void nervana::interface::config_info_interfaceparse(nlohmann::json js) = 0
virtual bool nervana::interface::config_info_interfacerequired() const = 0
virtual std::string nervana::interface::config_info_interfacetype() const = 0
virtual std::string nervana::interface::config_info_interfaceget_default_value() const = 0
class web::tcpconnection
#include <web_server.hpp>

Inherits from streambuf

Public Functions

web::tcp::connectionconnection(uint16_t port)
web::tcp::connection~connection()
void web::tcp::connectionclose()
std::shared_ptr<web::tcp::connection> web::tcp::connectionlisten()
void web::tcp::connectionwrite(const std::string &s)
void web::tcp::connectionwrite(const char *data, size_t size)
void web::tcp::connectionflush()
ostream &web::tcp::connectionget_output_stream()
istream &web::tcp::connectionget_input_stream()

Private Functions

streamsize web::tcp::connectionxsputn(const char *s, std::streamsize n)
int web::tcp::connectionoverflow(std::streambuf::int_type c)
std::streambuf::int_type web::tcp::connectionunderflow()
web::tcp::connectionconnection()

Private Members

int web::tcp::connectionm_socket
std::ostream web::tcp::connectionm_ostream
std::istream web::tcp::connectionm_istream
const std::size_t web::tcp::connectionm_put_back
std::vector<char> web::tcp::connectionm_char_buffer
bool web::tcp::connectionm_is_server
uint16_t web::tcp::connectionm_listening_port
class nervanaconststring
#include <log.hpp>

Public Functions

template <size_t SIZE>
constexpr nervana::conststringconststring(const char (&p)[SIZE])
constexpr char nervana::conststringoperator[](size_t i) const
constexpr const char *nervana::conststringget_ptr(size_t offset) const
constexpr size_t nervana::conststringsize() const

Private Members

const char *nervana::conststring_string
size_t nervana::conststring_size
template <typename T>
struct python::conversionconvert
#include <conversion.hpp>

Public Static Functions

static T python::conversion::convertfrom_pyobject(const PyObject *from)
static PyObject *python::conversion::convertto_pyobject(const T &from)
template <>
template<>
struct python::conversionconvert<cv::Mat>
#include <conversion.hpp>

Public Static Functions

static cv::Mat python::conversion::convertfrom_pyobject(const PyObject *from)
static PyObject *python::conversion::convertto_pyobject(const cv::Mat &from)
template <>
template<>
struct python::conversionconvert<std::vector<nervana::boundingbox::box>>
#include <conversion.hpp>

Public Static Functions

static std::vector<nervana::boundingbox::box> python::conversion::convertfrom_pyobject(const PyObject *from)
static PyObject *python::conversion::convertto_pyobject(const std::vector<nervana::boundingbox::box> &from)
class CryptoPPCRC32
#include <crc.hpp>

CRC-32 Checksum Calculation.

Uses CRC polynomial 0xEDB88320

Inherits from CryptoPP::HashTransformation

Public Functions

CryptoPP::CRC32CRC32()
void CryptoPP::CRC32Update(const byte *input, size_t length)
void CryptoPP::CRC32TruncatedFinal(byte *hash, size_t size)
unsigned int CryptoPP::CRC32DigestSize() const
std::string CryptoPP::CRC32AlgorithmName() const
void CryptoPP::CRC32UpdateByte(byte b)
byte CryptoPP::CRC32GetCrcByte(size_t i) const

Public Static Functions

static CRYPTOPP_CONSTEXPR const char* CryptoPP::CRC32::StaticAlgorithmName()

Protected Functions

void CryptoPP::CRC32Reset()

Private Members

word32 CryptoPP::CRC32m_crc

Private Static Attributes

const word32 CryptoPP::CRC32m_tab
class CryptoPPCRC32C
#include <crc.hpp>

CRC-32C Checksum Calculation.

Uses CRC polynomial 0x82F63B78

Since
Crypto++ 5.6.4

Inherits from CryptoPP::HashTransformation

Public Functions

CryptoPP::CRC32CCRC32C()
void CryptoPP::CRC32CUpdate(const byte *input, size_t length)
void CryptoPP::CRC32CTruncatedFinal(byte *hash, size_t size)
unsigned int CryptoPP::CRC32CDigestSize() const
std::string CryptoPP::CRC32CAlgorithmName() const
void CryptoPP::CRC32CUpdateByte(byte b)
byte CryptoPP::CRC32CGetCrcByte(size_t i) const

Public Static Functions

static CRYPTOPP_CONSTEXPR const char* CryptoPP::CRC32C::StaticAlgorithmName()

Protected Functions

void CryptoPP::CRC32CReset()

Private Members

word32 CryptoPP::CRC32Cm_crc

Private Static Attributes

const word32 CryptoPP::CRC32Cm_tab
struct nervanaDataHeader
#include <wav_data.hpp>

Public Members

uint32_t nervana::DataHeaderdwDataCC
uint32_t nervana::DataHeaderdwDataLen
class nervana::char_mapdecoded
#include <etl_char_map.hpp>

Inherits from nervana::interface::decoded_media

Public Functions

nervana::char_map::decodeddecoded(std::vector<uint32_t> char_ints, uint32_t nvalid)
virtual nervana::char_map::decoded~decoded()
std::vector<uint32_t> nervana::char_map::decodedget_data() const
uint32_t nervana::char_map::decodedget_length() const

Private Members

std::vector<uint32_t> nervana::char_map::decoded_labels
uint32_t nervana::char_map::decoded_nvalid
class nervana::imagedecoded
#include <etl_image.hpp>

Inherits from nervana::interface::decoded_image

Public Functions

nervana::image::decodeddecoded()
nervana::image::decodeddecoded(cv::Mat img)
bool nervana::image::decodedadd(cv::Mat img)
bool nervana::image::decodedadd(const std::vector<cv::Mat> &images)
virtual nervana::image::decoded~decoded()
cv::Mat &nervana::image::decodedget_image(int index)
cv::Size2i nervana::image::decodedget_image_size() const
int nervana::image::decodedget_image_channels() const
size_t nervana::image::decodedget_image_count() const
size_t nervana::image::decodedget_size() const
cv::Size2i nervana::image::decodedimage_size() const

Protected Functions

bool nervana::image::decodedall_images_are_same_size()

Protected Attributes

std::vector<cv::Mat> nervana::image::decoded_images
class nervana::labeldecoded
#include <etl_label.hpp>

Inherits from nervana::interface::decoded_media

Public Functions

nervana::label::decodeddecoded(int index)
virtual nervana::label::decoded~decoded()
int nervana::label::decodedget_index()

Private Functions

nervana::label::decodeddecoded()

Private Members

int nervana::label::decoded_index
class nervana::label_mapdecoded
#include <etl_label_map.hpp>

Inherits from nervana::interface::decoded_media

Public Functions

decodeddecoded()
virtual nervana::label_map::decoded~decoded()
const std::vector<int> &nervana::label_map::decodedget_data() const

Private Members

std::vector<int> nervana::label_map::decodedlabels

Friends

friend nervana::label_map::decoded::label_map::extractor
class nervana::localization::rcnndecoded
#include <etl_localization_rcnn.hpp>

Inherits from nervana::boundingbox::decoded

Public Functions

nervana::localization::rcnn::decodeddecoded()
virtual nervana::localization::rcnn::decoded~decoded()

Public Members

std::vector<int> nervana::localization::rcnn::decodedlabels
std::vector<target> nervana::localization::rcnn::decodedbbox_targets
std::vector<int> nervana::localization::rcnn::decodedanchor_index
float nervana::localization::rcnn::decodedimage_scale
cv::Size nervana::localization::rcnn::decodedoutput_image_size
cv::Size nervana::localization::rcnn::decodedinput_image_size
std::vector<boundingbox::box> nervana::localization::rcnn::decodedgt_boxes
class nervana::localization::ssddecoded
#include <etl_localization_ssd.hpp>

Inherits from nervana::boundingbox::decoded

Public Functions

nervana::localization::ssd::decodeddecoded()
virtual nervana::localization::ssd::decoded~decoded()

Public Members

cv::Size nervana::localization::ssd::decodedoutput_image_size
cv::Size nervana::localization::ssd::decodedinput_image_size
std::vector<boundingbox::box> nervana::localization::ssd::decodedgt_boxes

Friends

friend nervana::localization::ssd::decoded::extractor
class nervana::audiodecoded
#include <etl_audio.hpp>

Inherits from nervana::interface::decoded_media

Public Functions

nervana::audio::decodeddecoded(cv::Mat raw)
size_t nervana::audio::decodedsize()
cv::Mat &nervana::audio::decodedget_time_data()
cv::Mat &nervana::audio::decodedget_freq_data()

Public Members

uint32_t nervana::audio::decodedvalid_frames = {0}

Protected Attributes

cv::Mat nervana::audio::decodedtime_rep = {}
cv::Mat nervana::audio::decodedfreq_rep = {}
class nervana::blobdecoded
#include <etl_blob.hpp>

Inherits from nervana::interface::decoded_media

Public Functions

nervana::blob::decodeddecoded(const void *buf, size_t bufSize)
virtual nervana::blob::decoded~decoded()

Private Members

const void *nervana::blob::decodedm_data
size_t nervana::blob::decodedm_data_size

Friends

friend nervana::blob::decoded::loader
class nervana::boundingboxdecoded
#include <etl_boundingbox.hpp>

Inherits from nervana::interface::decoded_image

Subclassed by nervana::localization::rcnn::decoded, nervana::localization::ssd::decoded

Public Functions

boundingbox::decodeddecoded()
bool nervana::boundingbox::decodedextract(const void *data, size_t size, const std::unordered_map<std::string, int> &label_map)
virtual nervana::boundingbox::decoded~decoded()
const std::vector<boundingbox::box> &nervana::boundingbox::decodedboxes() const
int nervana::boundingbox::decodedwidth() const
int nervana::boundingbox::decodedheight() const
int nervana::boundingbox::decodeddepth() const
cv::Size2i nervana::boundingbox::decodedimage_size() const

Protected Attributes

std::vector<boundingbox::box> nervana::boundingbox::decodedm_boxes
int nervana::boundingbox::decodedm_width
int nervana::boundingbox::decodedm_height
int nervana::boundingbox::decodedm_depth

Friends

friend nervana::boundingbox::decoded::transformer
friend nervana::boundingbox::decoded::extractor
class nervana::interfacedecoded_image
#include <interface.hpp>

Inherits from nervana::interface::decoded_media

Subclassed by nervana::boundingbox::decoded, nervana::image::decoded

Public Functions

virtual cv::Size2i nervana::interface::decoded_imageimage_size() const = 0
virtual nervana::interface::decoded_image~decoded_image()
class nervana::interfacedecoded_media
#include <interface.hpp>

Subclassed by nervana::audio::decoded, nervana::blob::decoded, nervana::char_map::decoded, nervana::interface::decoded_image, nervana::label::decoded, nervana::label_map::decoded

Public Functions

virtual nervana::interface::decoded_media~decoded_media()
class nervanaencoded_record
#include <buffer_batch.hpp>

Public Functions

variable_record_field &encoded_recordelement(size_t index)
const variable_record_field &encoded_recordelement(size_t index) const
size_t nervana::encoded_recordsize() const
void nervana::encoded_recordadd_element(const void *data, size_t size)
void nervana::encoded_recordadd_element(const std::vector<char> &data)
void nervana::encoded_recordadd_element(std::vector<char> &&data)
void nervana::encoded_recordadd_exception(std::exception_ptr e)
variable_record_field_list::iterator nervana::encoded_recordbegin()
variable_record_field_list::iterator nervana::encoded_recordend()
void nervana::encoded_recordrethrow_if_exception() const

Private Members

variable_record_field_list nervana::encoded_recordm_elements
std::exception_ptr nervana::encoded_recordm_exception

Friends

friend nervana::encoded_record::encoded_record_list
class nervanaencoded_record_list
#include <buffer_batch.hpp>

Public Functions

encoded_record &nervana::encoded_record_listrecord(size_t index)
const encoded_record &nervana::encoded_record_listrecord(size_t index) const
void nervana::encoded_record_listadd_record(const encoded_record &buffer)
void nervana::encoded_record_listadd_record(encoded_record &&buffer)
size_t nervana::encoded_record_listsize() const
size_t nervana::encoded_record_listelements_per_record() const
void nervana::encoded_record_listswap(encoded_record_list &other)
void nervana::encoded_record_listmove_to(encoded_record_list &target, size_t count)
void nervana::encoded_record_listclear()
std::vector<encoded_record>::iterator nervana::encoded_record_listbegin()
std::vector<encoded_record>::iterator nervana::encoded_record_listend()
std::vector<encoded_record>::const_iterator nervana::encoded_record_listbegin() const
std::vector<encoded_record>::const_iterator nervana::encoded_record_listend() const
void nervana::encoded_record_listshuffle(uint32_t random_seed)

Private Functions

void nervana::encoded_record_listverify(const encoded_record &buffer)

Private Members

std::vector<encoded_record> nervana::encoded_record_listm_records
size_t nervana::encoded_record_listm_elements_per_record = -1
class nervana::pythonensure_gil
#include <python_utils.hpp>

Public Functions

nervana::python::ensure_gilensure_gil()
nervana::python::ensure_gil~ensure_gil()

Private Members

PyGILState_STATE nervana::python::ensure_gil_state
class nervanaevent
#include <event.hpp>

Public Functions

nervana::eventevent()
void nervana::eventwait()
void nervana::eventnotify()
void nervana::eventwait_multiple()
void nervana::eventnotify_all()

Private Members

std::condition_variable nervana::event_condition
std::mutex nervana::event_mutex
bool nervana::event_ready
class nervana::char_mapextractor
#include <etl_char_map.hpp>

Inherits from nervana::interface::extractor< char_map::decoded >

Public Functions

nervana::char_map::extractorextractor(const char_map::config &cfg)
virtual nervana::char_map::extractor~extractor()
std::shared_ptr<char_map::decoded> char_map::extractorextract(const void *in_array, size_t in_sz) const

Private Members

const cmap_t &nervana::char_map::extractor_cmap
uint32_t nervana::char_map::extractor_max_length
const uint32_t nervana::char_map::extractor_unknown_value
class nervana::depthmapextractor
#include <etl_depthmap.hpp>

Inherits from nervana::interface::extractor< image::decoded >

Public Functions

depthmap::extractorextractor(const image::config &config)
depthmap::extractor~extractor()
shared_ptr<image::decoded> depthmap::extractorextract(const void *inbuf, size_t insize) const
class nervana::imageextractor
#include <etl_image.hpp>

Inherits from nervana::interface::extractor< image::decoded >

Public Functions

image::extractorextractor(const image::config &cfg)
nervana::image::extractor~extractor()
shared_ptr<image::decoded> image::extractorextract(const void *inbuf, size_t insize) const
int nervana::image::extractorget_channel_count()

Private Members

int nervana::image::extractor_pixel_type
int nervana::image::extractor_color_mode
class nervana::labelextractor
#include <etl_label.hpp>

Inherits from nervana::interface::extractor< label::decoded >

Public Functions

nervana::label::extractorextractor(const label::config &cfg)
nervana::label::extractor~extractor()
std::shared_ptr<label::decoded> nervana::label::extractorextract(const void *buf, size_t bufSize) const

Private Members

bool nervana::label::extractor_binary
class nervana::label_mapextractor
#include <etl_label_map.hpp>

Inherits from nervana::interface::extractor< label_map::decoded >

Public Functions

extractorextractor(const label_map::config &cfg)
virtual nervana::label_map::extractor~extractor()
shared_ptr<decoded> extractorextract(const void *data, size_t size) const
const std::unordered_map<std::string, int> &nervana::label_map::extractorget_data()

Private Members

std::unordered_map<std::string, int> nervana::label_map::extractordictionary
class nervana::localization::rcnnextractor
#include <etl_localization_rcnn.hpp>

Inherits from nervana::interface::extractor< localization::rcnn::decoded >

Public Functions

localization::rcnn::extractorextractor(const localization::rcnn::config &cfg)
virtual std::shared_ptr<localization::rcnn::decoded> nervana::localization::rcnn::extractorextract(const void *data, size_t size) const
virtual nervana::localization::rcnn::extractor~extractor()

Private Functions

nervana::localization::rcnn::extractorextractor()

Private Members

const boundingbox::extractor nervana::localization::rcnn::extractorbbox_extractor
class nervana::audioextractor
#include <etl_audio.hpp>

Inherits from nervana::interface::extractor< audio::decoded >

Public Functions

nervana::audio::extractorextractor()
nervana::audio::extractor~extractor()
std::shared_ptr<audio::decoded> audio::extractorextract(const void *item, size_t itemSize) const

Extract audio data from a wav file using sox.

class nervana::localization::ssdextractor
#include <etl_localization_ssd.hpp>

Inherits from nervana::interface::extractor< ssd::decoded >

Public Functions

localization::ssd::extractorextractor(const ssd::config &_cfg)
virtual nervana::localization::ssd::extractor~extractor()
std::shared_ptr<localization::ssd::decoded> localization::ssd::extractorextract(const void *data, size_t size) const

Private Functions

nervana::localization::ssd::extractorextractor()
class nervana::pixel_maskextractor
#include <etl_pixel_mask.hpp>

Inherits from nervana::interface::extractor< image::decoded >

Public Functions

pixel_mask::extractorextractor(const image::config &config)
pixel_mask::extractor~extractor()
shared_ptr<image::decoded> pixel_mask::extractorextract(const void *inbuf, size_t insize) const
class nervana::videoextractor
#include <etl_video.hpp>

Inherits from nervana::interface::extractor< image::decoded >

Public Functions

nervana::video::extractorextractor(const video::config&)
virtual nervana::video::extractor~extractor()
std::shared_ptr<image::decoded> video::extractorextract(const void *item, size_t itemSize) const

Private Functions

nervana::video::extractorextractor()
template <typename T>
class nervana::interfaceextractor
#include <interface.hpp>

Public Functions

virtual nervana::interface::extractor~extractor()
virtual std::shared_ptr<T> nervana::interface::extractorextract(const void *, size_t) const = 0
class nervana::blobextractor
#include <etl_blob.hpp>

Inherits from nervana::interface::extractor< blob::decoded >

Public Functions

nervana::blob::extractorextractor(const blob::config &cfg)
nervana::blob::extractor~extractor()
std::shared_ptr<blob::decoded> nervana::blob::extractorextract(const void *buf, size_t bufSize) const
class nervana::boundingboxextractor
#include <etl_boundingbox.hpp>

Inherits from nervana::interface::extractor< nervana::boundingbox::decoded >

Public Functions

boundingbox::extractorextractor(const std::unordered_map<std::string, int> &map)
virtual nervana::boundingbox::extractor~extractor()
shared_ptr<boundingbox::decoded> boundingbox::extractorextract(const void *data, size_t size) const
void boundingbox::extractorextract(const void *data, size_t size, std::shared_ptr<boundingbox::decoded> &rc) const

Private Functions

nervana::boundingbox::extractorextractor()
int nervana::boundingbox::extractorget_label(const nlohmann::json &object) const

Private Members

std::unordered_map<std::string, int> nervana::boundingbox::extractorlabel_map
class nervana::cpiofile_header
#include <cpio.hpp>

Public Functions

cpio::file_headerfile_header()
void cpio::file_headerread(std::istream &ifs)
void cpio::file_headerwrite(std::ostream &ofs)

Private Members

char nervana::cpio::file_headerm_magic[4]
uint32_t nervana::cpio::file_headerm_format_version
uint32_t nervana::cpio::file_headerm_writer_version
char nervana::cpio::file_headerm_data_type[8]
uint32_t nervana::cpio::file_headerm_record_count
uint32_t nervana::cpio::file_headerm_elements_per_record
uint8_t nervana::cpio::file_headerm_unused[36]

Friends

friend nervana::cpio::file_header::reader
friend nervana::cpio::file_header::writer
class nervana::cpiofile_trailer
#include <cpio.hpp>

Public Functions

cpio::file_trailerfile_trailer()
void cpio::file_trailerwrite(std::ostream &ofs)
void cpio::file_trailerread(std::istream &ifs)

Private Members

uint32_t nervana::cpio::file_trailerm_unused[4]
class nervanafile_util
#include <file_util.hpp>

Public Static Functions

string nervana::file_utilpath_join(const std::string &s1, const std::string &s2)
size_t nervana::file_utilget_file_size(const std::string &filename)
void nervana::file_utilremove_directory(const std::string &dir)
bool nervana::file_utilmake_directory(const std::string &dir)
string nervana::file_utilmake_temp_directory(const std::string &path = "")
std::string nervana::file_utilget_temp_directory()
void nervana::file_utilremove_file(const std::string &file)
vector<char> nervana::file_utilread_file_contents(const std::string &path)
std::string nervana::file_utilread_file_to_string(const std::string &path)
void nervana::file_utiliterate_files(const std::string &path, std::function<void(const std::string &file, bool is_dir)> func, bool recurse = false, )
string nervana::file_utiltmp_filename(const std::string &extension = "")
void nervana::file_utiltouch(const std::string &filename)
bool nervana::file_utilexists(const std::string &filename)
int nervana::file_utiltry_get_lock(const std::string &filename)
void nervana::file_utilrelease_lock(int fd, const std::string &filename)

Private Static Functions

void nervana::file_utiliterate_files_worker(const std::string &path, std::function<void(const std::string &file, bool is_dir)> func, bool recurse = false, )
class nervanafixed_buffer_map
#include <buffer_batch.hpp>

Public Functions

nervana::fixed_buffer_mapfixed_buffer_map()
nervana::fixed_buffer_mapfixed_buffer_map(const std::vector<std::pair<std::string, shape_type>> &write_sizes, size_t batch_size, bool pinned = false)
nervana::fixed_buffer_mapfixed_buffer_map(fixed_buffer_map &&buffer)
fixed_buffer_map &nervana::fixed_buffer_mapoperator=(fixed_buffer_map &&buffer)
void nervana::fixed_buffer_mapadd_items(const std::vector<std::pair<std::string, shape_type>> &write_sizes, size_t batch_size, bool pinned = false)
void nervana::fixed_buffer_mapadd_item(const std::string &name, const shape_type &shp_tp, size_t batch_size, bool pinned = false)
void nervana::fixed_buffer_mapclear()
nervana::fixed_buffer_map~fixed_buffer_map()
const std::vector<std::string> &nervana::fixed_buffer_mapget_names() const
const buffer_fixed_size_elements *nervana::fixed_buffer_mapoperator[](const std::string &name) const
buffer_fixed_size_elements *nervana::fixed_buffer_mapoperator[](const std::string &name)
void fixed_buffer_mapcopy(fixed_buffer_map &src, size_t src_index, size_t dst_index, size_t count, size_t batch_size, bool transpose)
size_t nervana::fixed_buffer_mapsize() const
std::ostream &fixed_buffer_mapserialize(std::ostream &out) const
std::istream &fixed_buffer_mapdeserialize(std::istream &in)

Private Functions

nervana::fixed_buffer_mapfixed_buffer_map(const fixed_buffer_map&)
const buffer_fixed_size_elements *nervana::fixed_buffer_mapoperator[](int) const
buffer_fixed_size_elements *nervana::fixed_buffer_mapoperator[](int)

Private Members

std::vector<std::string> nervana::fixed_buffer_mapm_names
std::vector<std::pair<std::string, buffer_fixed_size_elements *>> nervana::fixed_buffer_mapm_data
struct nervanaFmtHeader
#include <wav_data.hpp>

Public Members

uint32_t nervana::FmtHeaderdwFmtCC
uint32_t nervana::FmtHeaderdwFmtLen
uint16_t nervana::FmtHeaderhwFmtTag
uint16_t nervana::FmtHeaderhwChannels
uint32_t nervana::FmtHeaderdwSampleRate
uint32_t nervana::FmtHeaderdwBytesPerSec
uint16_t nervana::FmtHeaderhwBlockAlign
uint16_t nervana::FmtHeaderhwBitDepth
class CryptoPPHashTransformation
#include <crc.hpp>

Subclassed by CryptoPP::CRC32, CryptoPP::CRC32C

class nervana::providerimage
#include <provider.hpp>

Inherits from nervana::provider::interface

Public Functions

provider::imageimage(nlohmann::json config, nlohmann::json aug)
virtual nervana::provider::image~image()
void provider::imageprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation &aug) const

Private Members

const nervana::image::config nervana::provider::imagem_config
nervana::image::extractor nervana::provider::imagem_extractor
nervana::image::transformer nervana::provider::imagem_transformer
nervana::augment::image::param_factory nervana::provider::imagem_augmentation_factory
nervana::image::loader nervana::provider::imagem_loader
const std::string nervana::provider::imagem_buffer_name
class nervana::providerinterface
#include <provider.hpp>

Inherits from nervana::provider_interface

Subclassed by nervana::provider::audio, nervana::provider::blob, nervana::provider::boundingbox, nervana::provider::char_map, nervana::provider::image, nervana::provider::label, nervana::provider::label_map, nervana::provider::localization::rcnn, nervana::provider::localization::ssd, nervana::provider::pixelmask, nervana::provider::video

Public Functions

provider::interfaceinterface(nlohmann::json js, size_t input_count)
virtual nervana::provider::interface~interface()
virtual void nervana::provider::interfaceprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation&) const = 0

Public Static Functions

string provider::interfacecreate_name(const std::string &name, const std::string &base_name)

Private Functions

void nervana::provider::interfaceprovide(int idx, nervana::encoded_record_list &in_buf, nervana::fixed_buffer_map &out_buf) const
class nervana::loaderiterator
#include <loader.hpp>

Inherits from std::iterator< std::input_iterator_tag, fixed_buffer_map >

Public Functions

loader::iteratoriterator(loader &ld, bool is_end)
loader::iteratoriterator(const iterator &other)
nervana::loader::iterator~iterator()
loader::iterator &loader::iteratoroperator++()
loader::iterator &loader::iteratoroperator++(int)
bool loader::iteratoroperator==(const iterator &other) const
bool loader::iteratoroperator!=(const iterator &other) const
const fixed_buffer_map &loader::iteratoroperator*() const
const size_t &nervana::loader::iteratorposition() const
bool loader::iteratorpositional_end() const

Private Functions

nervana::loader::iteratoriterator()

Private Members

loader &nervana::loader::iteratorm_current_loader
const bool nervana::loader::iteratorm_is_end

Friends

friend nervana::loader::iterator::loader_local
class nervanajson_configurable
#include <interface.hpp>

Subclassed by nervana::augment::audio::param_factory, nervana::augment::image::batch_sampler, nervana::augment::image::param_factory, nervana::augment::image::sample_constraint, nervana::augment::image::sampler, nervana::interface::config

Public Types

enum nervana::json_configurablemode

Values:

nervana::json_configurableOPTIONAL
nervana::json_configurableREQUIRED

Public Functions

void json_configurableverify_config(const std::string &location, const std::vector<std::shared_ptr<interface::config_info_interface>> &config, nlohmann::json js) const

Public Static Functions

template <typename T, typename S>
static void nervana::json_configurableset_dist_params(T &dist, S &params)
static void nervana::json_configurableset_dist_params(std::bernoulli_distribution &dist, std::vector<bool> &params)
template <typename T>
static void nervana::json_configurableparse_dist(T &value, const std::string &key, const nlohmann::json &js, mode required = mode::OPTIONAL)
template <typename T>
static void nervana::json_configurableparse_value(T &value, const std::string &key, const nlohmann::json &js, mode required = mode::OPTIONAL)
template <typename T>
static void nervana::json_configurableparse_json(T &value, const std::string &key, const nlohmann::json &js, mode required = mode::OPTIONAL)
template <typename T>
static void nervana::json_configurableparse_object(T &value, const std::string &key, const nlohmann::json &js, mode required = mode::OPTIONAL)
template <typename T>
static void nervana::json_configurableparse_enum(T &value, const std::string key, const nlohmann::json &js, mode required = mode::OPTIONAL)
class JsonParser
#include <json_parser.hpp>

Public Functions

nlohmann::json JsonParserparse(PyObject *dictionary)

Private Types

enum JsonParserType

Values:

JsonParserBool
JsonParserInt
JsonParserFloat
JsonParserList
JsonParserTuple
JsonParserDict
JsonParserString
JsonParserNone

Private Functions

std::string JsonParserpy23_string_to_ascii_string(PyObject *py_str)
Type JsonParsergetType(PyObject *object)
void JsonParserpush_value(nlohmann::json &arr, PyObject *value)
nlohmann::json JsonParserparse_list(PyObject *list)
nlohmann::json JsonParserparse_tuple(PyObject *tuple)
void JsonParserparse_dict(nlohmann::json &json, PyObject *dict)
class nervana::providerlabel
#include <provider.hpp>

Inherits from nervana::provider::interface

Public Functions

provider::labellabel(nlohmann::json config)
virtual nervana::provider::label~label()
void provider::labelprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation&) const

Private Members

nervana::label::config nervana::provider::labelm_config
nervana::label::extractor nervana::provider::labelm_extractor
nervana::label::loader nervana::provider::labelm_loader
const std::string nervana::provider::labelm_buffer_name
class nervana::providerlabel_map
#include <provider.hpp>

Inherits from nervana::provider::interface

Public Functions

provider::label_maplabel_map(nlohmann::json js)
virtual nervana::provider::label_map~label_map()
void provider::label_mapprovide(int idx, const std::vector<char> &datum_in, nervana::fixed_buffer_map &out_buf, augmentation&) const

Private Functions

nervana::provider::label_maplabel_map()
class nervana::boundingboxloader
#include <etl_boundingbox.hpp>

Inherits from nervana::interface::loader< nervana::boundingbox::decoded >

Public Functions

boundingbox::loaderloader(const boundingbox::config &cfg)
virtual nervana::boundingbox::loader~loader()
void boundingbox::loaderload(const std::vector<void *>&, std::shared_ptr<boundingbox::decoded>) const

Private Members

const size_t nervana::boundingbox::loadermax_bbox
class nervana::char_maploader
#include <etl_char_map.hpp>

Inherits from nervana::interface::loader< char_map::decoded >

Public Functions

nervana::char_map::loaderloader(const char_map::config &cfg)
virtual nervana::char_map::loader~loader()
void char_map::loaderload(const std::vector<void *>&, std::shared_ptr<char_map::decoded>) const

Private Members

const bool nervana::char_map::loader_emit_length
class nervana::depthmaploader
#include <etl_depthmap.hpp>

Inherits from nervana::interface::loader< image::decoded >

Public Functions

nervana::depthmap::loaderloader(const image::config &cfg)
nervana::depthmap::loader~loader()
void depthmap::loaderload(const std::vector<void *>&, std::shared_ptr<image::decoded>) const

Private Functions

void nervana::depthmap::loadersplit(cv::Mat&, char *)

Private Members

const image::config &nervana::depthmap::loader_cfg
class nervana::imageloader
#include <etl_image.hpp>

Inherits from nervana::interface::loader< image::decoded >

Public Functions

image::loaderloader(const image::config &cfg, bool fixed_aspect_ratio)
nervana::image::loader~loader()
void image::loaderload(const std::vector<void *>&, std::shared_ptr<image::decoded>) const

Private Functions

void nervana::image::loadersplit(cv::Mat&, char *)

Private Members

bool nervana::image::loaderm_channel_major
bool nervana::image::loaderm_fixed_aspect_ratio
shape_type nervana::image::loaderm_stype
uint32_t nervana::image::loaderm_channels
class nervana::labelloader
#include <etl_label.hpp>

Inherits from nervana::interface::loader< label::decoded >

Public Functions

nervana::label::loaderloader(const label::config &cfg)
nervana::label::loader~loader()
void nervana::label::loaderload(const std::vector<void *> &buflist, std::shared_ptr<label::decoded> mp) const

Private Members

const label::config &nervana::label::loader_cfg
class nervana::label_maploader
#include <etl_label_map.hpp>

Inherits from nervana::interface::loader< label_map::decoded >

Public Functions

loaderloader(const label_map::config &cfg)
virtual nervana::label_map::loader~loader()
virtual void nervana::label_map::loaderload(const std::vector<void *>&, std::shared_ptr<label_map::decoded>) const

Private Members

int nervana::label_map::loadermax_label_count
class nervana::localization::rcnnloader
#include <etl_localization_rcnn.hpp>

Inherits from nervana::interface::loader< localization::rcnn::decoded >

Public Functions

localization::rcnn::loaderloader(const localization::rcnn::config &cfg)
virtual nervana::localization::rcnn::loader~loader()
void localization::rcnn::loaderload(const std::vector<void *> &buf_list, std::shared_ptr<localization::rcnn::decoded> mp) const

Private Functions

nervana::localization::rcnn::loaderloader()

Private Members

int nervana::localization::rcnn::loadertotal_anchors
size_t nervana::localization::rcnn::loadermax_gt_boxes
std::vector<shape_type> nervana::localization::rcnn::loadershape_type_list
class nervana::localization::ssdloader
#include <etl_localization_ssd.hpp>

Inherits from nervana::interface::loader< ssd::decoded >

Public Functions

localization::ssd::loaderloader(const ssd::config &cfg)
virtual nervana::localization::ssd::loader~loader()
void localization::ssd::loaderload(const std::vector<void *> &buf_list, std::shared_ptr<ssd::decoded> mp) const

Private Functions

nervana::localization::ssd::loaderloader()

Private Members

size_t nervana::localization::ssd::loadermax_gt_boxes
class nervana::videoloader
#include <etl_video.hpp>

Inherits from nervana::interface::loader< image::decoded >

Public Functions

nervana::video::loaderloader(const video::config &cfg)
virtual nervana::video::loader~loader()
void video::loaderload(const std::vector<void *>&, std::shared_ptr<image::decoded>) const

Private Functions

nervana::video::loaderloader()
class nervana::audioloader
#include <etl_audio.hpp>

Inherits from nervana::interface::loader< audio::decoded >

Public Functions

nervana::audio::loaderloader(const audio::config &cfg)
nervana::audio::loader~loader()
void audio::loaderload(const std::vector<void *>&, std::shared_ptr<audio::decoded>) const

Private Members

const audio::config &nervana::audio::loader_cfg
template <typename T>
class nervana::interfaceloader
#include <interface.hpp>

Public Functions

virtual nervana::interface::loader~loader()
virtual void nervana::interface::loaderload(const std::vector<void *>&, std::shared_ptr<T>) const = 0
class nervana::blobloader
#include <etl_blob.hpp>

Inherits from nervana::interface::loader< blob::decoded >

Public Functions

nervana::blob::loaderloader(const blob::config &cfg)
nervana::blob::loader~loader()
void nervana::blob::loaderload(const std::vector<void *> &buflist, std::shared_ptr<blob::decoded> mp) const
class nervanaloader
#include <loader.hpp>

Subclassed by nervana::loader_local

Public Types

enum nervana::loaderBatchMode

Values:

nervana::loaderINFINITE
nervana::loaderONCE
nervana::loaderCOUNT

Public Functions

virtual nervana::loader~loader()
virtual const std::vector<std::string> &nervana::loaderget_buffer_names() const = 0
virtual const std::vector<std::pair<std::string, shape_type>> &nervana::loaderget_names_and_shapes() const = 0
virtual const shape_t &nervana::loaderget_shape(const std::string &name) const = 0
virtual int nervana::loaderrecord_count() const = 0
virtual int nervana::loaderbatch_size() const = 0
virtual int nervana::loaderbatch_count() const = 0
virtual iterator nervana::loaderbegin() = 0
virtual iterator nervana::loaderend() = 0
virtual iterator &nervana::loaderget_current_iter() = 0
virtual iterator &nervana::loaderget_end_iter() = 0
virtual const fixed_buffer_map *nervana::loaderget_output_buffer() const = 0
virtual const size_t &nervana::loaderposition() = 0
virtual void nervana::loaderreset() = 0
virtual nlohmann::json nervana::loaderget_current_config() const = 0
virtual const char *nervana::loaderget_session_id() const = 0

Protected Functions

virtual void nervana::loaderincrement_position() = 0
class nervanaloader_config
#include <loader.hpp>

Inherits from nervana::interface::config

Public Functions

nervana::loader_configloader_config(nlohmann::json js)

Public Members

std::string nervana::loader_configmanifest_filename
std::string nervana::loader_configmanifest_root
int nervana::loader_configbatch_size
std::string nervana::loader_configcache_directory = ""
int nervana::loader_configblock_size = 5000
float nervana::loader_configsubset_fraction = 1.0
bool nervana::loader_configshuffle_enable = false
bool nervana::loader_configshuffle_manifest = false
bool nervana::loader_configpinned = false
bool nervana::loader_configbatch_major = true
uint32_t nervana::loader_configrandom_seed = 0
uint32_t nervana::loader_configdecode_thread_count = 0
std::string nervana::loader_configiteration_mode = "ONCE"
int nervana::loader_configiteration_mode_count = 0
uint16_t nervana::loader_configweb_server_port = 0
std::vector<nlohmann::json> nervana::loader_configetl
std::vector<nlohmann::json> nervana::loader_configaugmentation

Private Functions

nervana::loader_configloader_config()
void loader_configvalidate()

Private Members

std::vector<std::shared_ptr<nervana::interface::