apollo::perception::inference 命名空间参考

类
struct	AccuracyParameter
struct	AnchorBox
struct	AnnotatedDataParameter
struct	AnnotatedDatum
struct	Annotation
struct	AnnotationGroup
struct	ArgMaxParameter
struct	BatchNormParameter
struct	BatchSampler
class	BatchStream
struct	BBox3D
struct	BBoxRegParameter
struct	BiasParameter
struct	BlobProto
struct	BlobShape
struct	ConcatParameter
struct	ContrastiveLossParameter
struct	ConvolutionParameter
struct	ConvParam
struct	CropParameter
class	CudaUtil
struct	DataParameter
struct	DatasetParameter
struct	Datum
struct	DetectionEvaluateParameter
struct	DetectionOutputParameter
struct	DetectionOutputSSDParameter
struct	dfmb_psroi_align_op
struct	DFMBPSROIAlignParameter
class	DFMBPSROIAlignPlugin
struct	DimensionStatistics
struct	DistortionParameter
struct	DropoutParameter
struct	DummyDataParameter
struct	EltwiseParameter
struct	ELUParameter
struct	EmbedParameter
struct	EmitConstraint
struct	ExpansionParameter
struct	ExpParameter
struct	FillerParameter
struct	FlattenParameter
	Message that stores parameters used by FlattenLayer 更多...
struct	GenAnchorParameter
class	GPUL2Norm
struct	HDF5DataParameter
struct	HDF5OutputParameter
struct	HingeLossParameter
struct	ImageDataParameter
class	Inference
struct	InfogainLossParameter
struct	InnerProductParameter
struct	InputParameter
struct	LabelMap
struct	LabelMapItem
class	Layer
struct	LayerParameter
struct	LogParameter
struct	LossParameter
struct	LRNParameter
struct	MemoryDataParameter
class	MINet
struct	MultiBoxLossParameter
struct	MVNParameter
struct	NetParameter
struct	NetState
struct	NetStateRule
struct	NMSSSDParameter
struct	NoiseParameter
struct	NonMaximumSuppressionParameter
struct	NormalizedBBox
struct	NormalizeParameter
class	ObstacleDetector
struct	PaddingParameter
class	PaddleNet
struct	ParameterParameter
struct	ParamSpec
struct	PermuteParameter
struct	PoolingParameter
struct	PowerParameter
struct	PReLUParameter
struct	PriorBoxParameter
struct	PythonParameter
struct	rcnn_proposal_op
class	RCNNProposalPlugin
struct	RecurrentParameter
struct	ReductionParameter
struct	RegionOutputParameter
struct	RegionParameter
struct	RegionProposalParameter
struct	ReLUParameter
struct	ReorgParameter
struct	RepeatedList
struct	ReshapeParameter
struct	ResizeParameter
class	ROIPoolingLayer
struct	ROIPoolingParameter
struct	rpn_proposal_ssd_op
class	RPNProposalSSDPlugin
class	RTNet
struct	SaltPepperParameter
struct	SampleConstraint
struct	Sampler
struct	SaveOutputParameter
struct	ScaleParameter
struct	SigmoidParameter
class	SingleBatchInference
struct	SliceParameter
struct	SoftmaxParameter
struct	SPPParameter
struct	TanHParameter
struct	ThresholdParameter
struct	TileParameter
class	TorchNet
struct	TransformationParameter
struct	V0LayerParameter
struct	V1LayerParameter
struct	VideoDataParameter
struct	Weights
struct	WindowDataParameter
struct	YoloAnchorsParameter
struct	YoloDumpParameter
struct	YoloLossParameter
struct	YoloTargetParameter

类型定义
typedef std::map< std::string, base::BlobPtr< float > >	BlobMap
typedef std::vector< int >	TensorDims
typedef std::map< std::string, TensorDims >	TensorDimsMap
typedef migraphx::instruction_ref	Tensor
typedef migraphx::shape	Shape
typedef migraphx::operation	Operation
typedef std::map< std::string, std::vector< Weights > >	WeightMap
typedef std::map< std::string, Tensor >	TensorMap
typedef std::map< std::string, std::string >	TensorModifyMap
using	BlobPtr = std::shared_ptr< apollo::perception::base::Blob< float > >

枚举
enum	Phase { TRAIN = 0 , TEST = 1 }

函数
Inference *	CreateInferenceByName (const std::string &frame_work, const std::string &proto_file, const std::string &weight_file, const std::vector< std::string > &outputs, const std::vector< std::string > &inputs, const std::string &model_root)
Inference *	CreateInferenceByName (const common::Framework &frame_work, const std::string &proto_file, const std::string &weight_file, const std::vector< std::string > &outputs, const std::vector< std::string > &inputs, const std::string &model_root)
void	ParseNetParam (const NetParameter &net_param, TensorDimsMap *tensor_dims_map, std::map< std::string, std::string > *tensor_modify_map, std::vector< LayerParameter > *order)
bool	ParserConvParam (const ConvolutionParameter &conv, ConvParam *param)
bool	modify_pool_param (PoolingParameter *pool_param)
Dims	GetDims (std::vector< size_t > lens, bool remove_batch=true)
bool	ReadProtoFromTextFile (const std::string &filename, google::protobuf::Message *proto)
bool	ReadProtoFromBinaryFile (const std::string &filename, google::protobuf::Message *proto)
bool	loadNetParams (const std::string &param_file, NetParameter *param)
std::string	locateFile (const std::string &network, const std::string &input)
void	bbox_transform_inv_cuda (int block_size, int thread_size, int shared_mem, cudaStream_t stream, const int nthreads, const float *boxes, const float *deltas, const int num_box, const int num_channel, float *out_boxes)
void	clip_boxes_cuda (int block_size, int thread_size, int shared_mem, cudaStream_t stream, const int nthreads, float *boxes, const float height, const float width)
void	filter_boxes_cuda (int block_size, int thread_size, int shared_mem, cudaStream_t stream, const int nthreads, const float *boxes, const float *scores, const float *all_probs, const int num_box, const int num_channel, const int num_class, const int num_prob, const int filter_channel, const int filter_class, const int min_size_mode, const float min_size_h, const float min_size_w, const float threshold_score, float *filtered_boxes, float *filtered_scores, float *filtered_all_probs, int *filtered_count)
void	keep_topN_boxes_cuda (int block_size, int thread_size, int shared_mem, cudaStream_t stream, const int nthreads, const float *boxes, const float *scores, const float *all_probs, const int *indexes, const int *count, const bool keep_score, const int num_box, const int num_prob, const int topN, float *out_boxes, float *out_scores, float *out_all_probs)
void	repeatedly_add_cuda (int block_size, int thread_size, int shared_mem, cudaStream_t stream, const int nthreads, const float *in_data, float *out_data, const float *add_vec, int add_vec_size)
void	repeatedly_mul_cuda (int block_size, int thread_size, int shared_mem, cudaStream_t stream, const int nthreads, const float *in_data, float *out_data, const float *mul_vec, int mul_vec_size)
void	slice2d_cuda (int block_size, int thread_size, int shared_mem, cudaStream_t stream, const int nthreads, const float *in_data, float *out_data, const int *slice_axises, int slice_axis_num, int input_axis_size)
void	NmsForward (bool rpn_proposal_output_score, int host_filter_count, int num_box_corners, float nms_overlap_threshold, int num_candidate, int top_n, int batch_id, int num_prob, float *dev_sorted_box_for_nms, float *scores, float *all_probs, float *out_boxes, int *acc_box_num, cudaStream_t stream)
	GPU Non-Maximum Suppresion for network output
std::vector< std::string >	GetBlobNames (const google::protobuf::RepeatedPtrField< common::ModelBlob > &model_blobs)
void	AddShape (std::map< std::string, std::vector< int > > *shape_map, const google::protobuf::RepeatedPtrField< common::ModelBlob > &model_blobs)
nvinfer1::DimsCHW	ReshapeDims (const nvinfer1::DimsCHW &dims, const nvinfer1::DimsCHW &inputDims)
nvinfer1::DimsCHW	getCHW (const nvinfer1::Dims &d)
std::string	get_dtype (const base::Blob< double > &blob)
std::string	get_dtype (const base::Blob< float > &blob)
size_t	BinaryReadString (FILE *fp, char *name)
size_t	BinaryWriteString (FILE *fp, const std::string &str)
template<typename Dtype >
std::shared_ptr< base::Blob< Dtype > >	BinaryReadBlob (FILE *fp)
template<typename Dtype >
void	BinaryWriteBlob (FILE *fp, const base::Blob< Dtype > &blob)
template std::shared_ptr< base::Blob< float > >	BinaryReadBlob (FILE *fp)
template void	BinaryWriteBlob (FILE *fp, const base::Blob< float > &blob)
template void	BinaryWriteBlob (FILE *fp, const base::Blob< double > &blob)
template<typename Dtype >
std::map< std::string, std::shared_ptr< base::Blob< Dtype > > >	BinaryReadFile (const char *file_path)
template<typename Btype >
bool	BinaryWriteFile (const char *file_path, const std::map< std::string, Btype > &data_dict)
template std::map< std::string, std::shared_ptr< base::Blob< float > > >	BinaryReadFile (const char *file_path)
template bool	BinaryWriteFile (const char *file_path, const std::map< std::string, std::shared_ptr< base::Blob< float > > > &data_dict)
template bool	BinaryWriteFile (const char *file_path, const std::map< std::string, std::shared_ptr< base::Blob< double > > > &data_dict)
template bool	BinaryWriteFile (const char *file_path, const std::map< std::string, base::Blob< float > * > &data_dict)
template bool	BinaryWriteFile (const char *file_path, const std::map< std::string, base::Blob< double > * > &data_dict)
void	GPUGemmFloat (const CBLAS_TRANSPOSE TransA, const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const float alpha, const float *A, const float *B, const float beta, float *C)
void	GPUMultiFloat (const int n, const float *a, const float *b, float *result)
void	GPUMSetFloat (const int n, const float alpha, float *result)
bool	ResizeGPU (const base::Image8U &src, std::shared_ptr< apollo::perception::base::Blob< float > > dst, int stepwidth, int start_axis)
bool	ResizeGPU (const apollo::perception::base::Blob< uint8_t > &src_gpu, std::shared_ptr< apollo::perception::base::Blob< float > > dst, int stepwidth, int start_axis, int mean_b, int mean_g, int mean_r, bool channel_axis, float scale)
bool	ResizeGPU (const base::Image8U &src, std::shared_ptr< apollo::perception::base::Blob< float > > dst, int stepwidth, int start_axis, float mean_b, float mean_g, float mean_r, bool channel_axis, float scale)
bool	ResizeGPU (const base::Image8U &src, std::shared_ptr< apollo::perception::base::Blob< float > > dst, int stepwidth, int start_axis, float mean_b, float mean_g, float mean_r, bool channel_axis, float std_b, float std_g, float std_r)
bool	ImageZeroPadding (const base::Image8U &src, base::Image8U *dst, int stepwidth, int left_pad, int right_pad, int top_pad, int bottom_pad, int value, cudaStream_t stream, bool same_order)
std::shared_ptr< float >	load_binary_data (const std::string &filename)
bool	write_result (const std::string &out_path, const std::vector< float > &results)
template<typename T >
void	load_data (const std::string &filename, std::vector< T > *outputs)
bool	write_result (const std::string &out_path, const std::map< std::string, std::vector< float > > &results)

变量
const std::map< std::string, std::string >	active_map
const std::map< EltwiseParameter::EltwiseOp, std::string >	eltwise_map
constexpr uint64_t	MemoryPoolInitSizeMb = 1000
const std::vector< std::string >	_gpu_checklist
constexpr size_t	kMaxStrLen = 64
constexpr int	kMinDim = 1
constexpr int	kMaxDim = std::numeric_limits<int>::max()

类型定义说明

BlobMap

typedef std::map<std::string, base::BlobPtr<float> > apollo::perception::inference::BlobMap

在文件 inference.h 第 39 行定义.

BlobPtr

using apollo::perception::inference::BlobPtr = typedef std::shared_ptr<apollo::perception::base::Blob<float> >

在文件 onnx_single_batch_infer.h 第 43 行定义.

Operation

typedef migraphx::operation apollo::perception::inference::Operation

在文件 mi_net.h 第 62 行定义.

Shape

typedef migraphx::shape apollo::perception::inference::Shape

在文件 mi_net.h 第 61 行定义.

Tensor

typedef migraphx::instruction_ref apollo::perception::inference::Tensor

在文件 mi_net.h 第 60 行定义.

TensorDims

typedef std::vector<int> apollo::perception::inference::TensorDims

在文件 mi_common.h 第 32 行定义.

TensorDimsMap

typedef std::map< std::string, nvinfer1::DimsCHW > apollo::perception::inference::TensorDimsMap

在文件 mi_common.h 第 33 行定义.

TensorMap

typedef std::map< std::string, nvinfer1::ITensor * > apollo::perception::inference::TensorMap

在文件 mi_net.h 第 64 行定义.

TensorModifyMap

typedef std::map< std::string, std::string > apollo::perception::inference::TensorModifyMap

在文件 mi_net.h 第 66 行定义.

WeightMap

typedef std::map< std::string, std::vector< nvinfer1::Weights > > apollo::perception::inference::WeightMap

在文件 mi_net.h 第 63 行定义.

枚举类型说明

Phase

enum apollo::perception::inference::Phase

枚举值
TRAIN
TEST

在文件 rt.proto 第 223 行定义.

           {
  TRAIN = 0;
  TEST = 1;
}

函数说明

AddShape()

void apollo::perception::inference::AddShape	(	std::map< std::string, std::vector< int > > *	shape_map,
		const google::protobuf::RepeatedPtrField< common::ModelBlob > &	model_blobs
	)

在文件 model_util.cc 第 32 行定义.

                                                                        {
  for (const auto& blob : model_blobs) {
    std::vector<int> shape(blob.shape().begin(), blob.shape().end());
    shape_map->insert(std::make_pair(blob.name(), shape));
  }
}

bbox_transform_inv_cuda()

void apollo::perception::inference::bbox_transform_inv_cuda	(	int	block_size,
		int	thread_size,
		int	shared_mem,
		cudaStream_t	stream,
		const int	nthreads,
		const float *	boxes,
		const float *	deltas,
		const int	num_box,
		const int	num_channel,
		float *	out_boxes
	)

BinaryReadBlob() [1/2]

template<typename Dtype >

std::shared_ptr< base::Blob< Dtype > > apollo::perception::inference::BinaryReadBlob

(

FILE *

fp

)

在文件 binary_data.cc 第 56 行定义.

                                                        {
  int ndim;
  std::shared_ptr<base::Blob<Dtype>> blob(new base::Blob<Dtype>());
  char dtype[kMaxStrLen];
 
  // read dtype
  size_t nmemb = BinaryReadString(fp, dtype);
  CHECK_GT(nmemb, 0U);
  CHECK_EQ(get_dtype(*blob), dtype);
 
  // read dims
  nmemb = fread(&ndim, sizeof(ndim), 1, fp);
  CHECK_EQ(nmemb, 1U);
  std::vector<int> shape(ndim);
  for (int i = 0; i < ndim; ++i) {
    nmemb = fread(&shape[i], sizeof(shape[i]), 1, fp);
    CHECK_EQ(nmemb, 1U);
  }
  if (ndim == 0) {
    return blob;
  }
 
  // init blob
  blob->Reshape(shape);
  CHECK_GE(blob->count(), kMinDim);
 
  // read data
  nmemb = fread(blob->mutable_cpu_data(), sizeof(Dtype), blob->count(), fp);
  CHECK_EQ(static_cast<int>(nmemb), blob->count());
 
  return blob;
}

BinaryReadBlob() [2/2]

template std::shared_ptr< base::Blob< float > > apollo::perception::inference::BinaryReadBlob

(

FILE *

fp

)

BinaryReadFile() [1/2]

template<typename Dtype >

std::map< std::string, std::shared_ptr< base::Blob< Dtype > > > apollo::perception::inference::BinaryReadFile

(

const char *

file_path

)

在文件 binary_data.cc 第 115 行定义.

                           {
  char name[kMaxStrLen];
  std::map<std::string, std::shared_ptr<base::Blob<Dtype>>> data_dict;
 
  FILE *fp = fopen(file_path, "rb");
  if (NULL == fp) {
    AERROR << "Failed opening Binaryary file: " << file_path;
    return data_dict;
  }
 
  // read blob name
  while (BinaryReadString(fp, name)) {
    // insert into data_dict
    data_dict[name] = BinaryReadBlob<Dtype>(fp);
  }
 
  fclose(fp);
  return data_dict;
}

BinaryReadFile() [2/2]

template std::map< std::string, std::shared_ptr< base::Blob< float > > > apollo::perception::inference::BinaryReadFile

(

const char *

file_path

)

BinaryReadString()

size_t apollo::perception::inference::BinaryReadString	(	FILE *	fp,
		char *	name
	)

在文件 binary_data.cc 第 35 行定义.

                                              {
  size_t len = 0;
  size_t nmemb = fread(&len, sizeof(len), 1, fp);
  if (nmemb != 1 || len == 0) {
    return 0;
  }
  CHECK_LT(len, kMaxStrLen);
  nmemb = fread(name, sizeof(name[0]), len, fp);
  CHECK_EQ(nmemb, len);
  name[len] = 0;
  return len;
}

BinaryWriteBlob() [1/3]

template void apollo::perception::inference::BinaryWriteBlob	(	FILE *	fp,
		const base::Blob< double > &	blob
	)

BinaryWriteBlob() [2/3]

template<typename Dtype >

void apollo::perception::inference::BinaryWriteBlob	(	FILE *	fp,
		const base::Blob< Dtype > &	blob
	)

在文件 binary_data.cc 第 90 行定义.

                                                            {
  int ndim, dim;
  // write dtype
  BinaryWriteString(fp, get_dtype(blob));
  // write dims
  ndim = blob.num_axes();
  fwrite(&ndim, sizeof(ndim), 1, fp);
  for (int i = 0; i < ndim; ++i) {
    dim = blob.shape(i);
    fwrite(&dim, sizeof(dim), 1, fp);
  }
 
  // write data
  if (blob.count() > 0) {
    fwrite(blob.cpu_data(), sizeof(Dtype), blob.count(), fp);
  }
}

BinaryWriteBlob() [3/3]

template void apollo::perception::inference::BinaryWriteBlob	(	FILE *	fp,
		const base::Blob< float > &	blob
	)

BinaryWriteFile() [1/5]

template bool apollo::perception::inference::BinaryWriteFile	(	const char *	file_path,
		const std::map< std::string, base::Blob< double > * > &	data_dict
	)

BinaryWriteFile() [2/5]

template bool apollo::perception::inference::BinaryWriteFile	(	const char *	file_path,
		const std::map< std::string, base::Blob< float > * > &	data_dict
	)

BinaryWriteFile() [3/5]

template<typename Btype >

bool apollo::perception::inference::BinaryWriteFile	(	const char *	file_path,
		const std::map< std::string, Btype > &	data_dict
	)

在文件 binary_data.cc 第 137 行定义.

                                                                {
  FILE *fp = fopen(file_path, "wb");
  if (NULL == fp) {
    AERROR << "Failed opening Binaryary file: " << file_path;
    return false;
  }
 
  typename std::map<std::string, Btype>::const_iterator it = data_dict.begin();
  while (it != data_dict.end()) {
    // write blob name
    BinaryWriteString(fp, it->first);
    // write blob
    BinaryWriteBlob(fp, *it->second);
 
    ++it;
  }
  int end = 0;
  fwrite(&end, sizeof(end), 1, fp);
 
  fclose(fp);
  return true;
}

BinaryWriteFile() [4/5]

template bool apollo::perception::inference::BinaryWriteFile	(	const char *	file_path,
		const std::map< std::string, std::shared_ptr< base::Blob< double > > > &	data_dict
	)

BinaryWriteFile() [5/5]

template bool apollo::perception::inference::BinaryWriteFile	(	const char *	file_path,
		const std::map< std::string, std::shared_ptr< base::Blob< float > > > &	data_dict
	)

BinaryWriteString()

size_t apollo::perception::inference::BinaryWriteString	(	FILE *	fp,
		const std::string &	str
	)

在文件 binary_data.cc 第 48 行定义.

                                                         {
  size_t len = str.length();
  fwrite(&len, sizeof(len), 1, fp);
  fwrite(str.c_str(), sizeof(str[0]), len, fp);
  return len;
}

clip_boxes_cuda()

void apollo::perception::inference::clip_boxes_cuda	(	int	block_size,
		int	thread_size,
		int	shared_mem,
		cudaStream_t	stream,
		const int	nthreads,
		float *	boxes,
		const float	height,
		const float	width
	)

CreateInferenceByName() [1/2]

Inference * apollo::perception::inference::CreateInferenceByName	(	const common::Framework &	frame_work,
		const std::string &	proto_file,
		const std::string &	weight_file,
		const std::vector< std::string > &	outputs,
		const std::vector< std::string > &	inputs,
		const std::string &	model_root
	)

在文件 inference_factory.cc 第 62 行定义.

                                                              {
  switch (frame_work) {
    case common::TensorRT:
      if (model_root.empty()) {
        return new RTNET;
      }
      return new RTNET8;
    case common::PyTorch:
      return new TorchNet(proto_file, outputs, inputs);
    case common::PaddlePaddle:
      return new PaddleNet(proto_file, weight_file, outputs, inputs);
    case common::Obstacle:
      return new ObstacleDetector(proto_file, weight_file, outputs, inputs);
    case common::Onnx:
      return new SingleBatchInference(proto_file, outputs, inputs);
    default:
      break;
  }
  return nullptr;
}

CreateInferenceByName() [2/2]

Inference * apollo::perception::inference::CreateInferenceByName	(	const std::string &	frame_work,
		const std::string &	proto_file,
		const std::string &	weight_file,
		const std::vector< std::string > &	outputs,
		const std::vector< std::string > &	inputs,
		const std::string &	model_root
	)

在文件 inference_factory.cc 第 39 行定义.

                                                              {
  if (frame_work == "RTNet") {
    return new RTNET;
  } else if (frame_work == "RTNetInt8") {
    return new RTNET8;
  } else if (frame_work == "TorchNet") {
    // PyTorch just have model file, we use proto_file as model file
    return new TorchNet(proto_file, outputs, inputs);
  } else if (frame_work == "Obstacle") {
    return new ObstacleDetector(proto_file, weight_file, outputs, inputs);
  } else if (frame_work == "Onnx") {
    return new SingleBatchInference(proto_file, outputs, inputs);
  } else if (frame_work == "PaddleNet") {
    return new PaddleNet(proto_file, weight_file, outputs, inputs);
  }
  return nullptr;
}

filter_boxes_cuda()

void apollo::perception::inference::filter_boxes_cuda	(	int	block_size,
		int	thread_size,
		int	shared_mem,
		cudaStream_t	stream,
		const int	nthreads,
		const float *	boxes,
		const float *	scores,
		const float *	all_probs,
		const int	num_box,
		const int	num_channel,
		const int	num_class,
		const int	num_prob,
		const int	filter_channel,
		const int	filter_class,
		const int	min_size_mode,
		const float	min_size_h,
		const float	min_size_w,
		const float	threshold_score,
		float *	filtered_boxes,
		float *	filtered_scores,
		float *	filtered_all_probs,
		int *	filtered_count
	)

get_dtype() [1/2]

std::string apollo::perception::inference::get_dtype ( const base::Blob< double > &  blob )

inline

在文件 binary_data.cc 第 27 行定义.

                                                         {
  return "float64";
}

get_dtype() [2/2]

std::string apollo::perception::inference::get_dtype ( const base::Blob< float > &  blob )

inline

在文件 binary_data.cc 第 31 行定义.

                                                        {
  return "float32";
}

GetBlobNames()

std::vector< std::string > apollo::perception::inference::GetBlobNames

(

const google::protobuf::RepeatedPtrField< common::ModelBlob > &

model_blobs

)

在文件 model_util.cc 第 23 行定义.

                                                                        {
  std::vector<std::string> blob_names;
  for (const auto& blob : model_blobs) {
    blob_names.push_back(blob.name());
  }
  return blob_names;
}

getCHW()

nvinfer1::DimsCHW apollo::perception::inference::getCHW ( const nvinfer1::Dims &  d )

inline

在文件 rt_common.h 第 85 行定义.

                                                     {
  assert(d.nbDims >= 3);
  return nvinfer1::DimsCHW(d.d[d.nbDims - 3], d.d[d.nbDims - 2],
                           d.d[d.nbDims - 1]);
}

GetDims()

Dims apollo::perception::inference::GetDims	(	std::vector< size_t >	lens,
		bool	remove_batch = true
	)

在文件 mi_net.cc 第 58 行定义.

                                                               {
  Dims dims;
 
  // remove batch dimension for compatibility with Dims
  if (remove_batch) lens.erase(lens.begin());
 
  dims.nbDims = lens.size();
  for (size_t j = 0; j < lens.size(); j++) {
    dims.d[j] = lens[j];
  }
 
  return dims;
}

GPUGemmFloat()

void apollo::perception::inference::GPUGemmFloat	(	const CBLAS_TRANSPOSE	TransA,
		const CBLAS_TRANSPOSE	TransB,
		const int	M,
		const int	N,
		const int	K,
		const float	alpha,
		const float *	A,
		const float *	B,
		const float	beta,
		float *	C
	)

GPUMSetFloat()

void apollo::perception::inference::GPUMSetFloat	(	const int	n,
		const float	alpha,
		float *	result
	)

GPUMultiFloat()

void apollo::perception::inference::GPUMultiFloat	(	const int	n,
		const float *	a,
		const float *	b,
		float *	result
	)

ImageZeroPadding()

bool apollo::perception::inference::ImageZeroPadding	(	const base::Image8U &	src,
		base::Image8U *	dst,
		int	stepwidth,
		int	left_pad,
		int	right_pad,
		int	top_pad,
		int	bottom_pad,
		int	value,
		cudaStream_t	stream,
		bool	same_order
	)

keep_topN_boxes_cuda()

void apollo::perception::inference::keep_topN_boxes_cuda	(	int	block_size,
		int	thread_size,
		int	shared_mem,
		cudaStream_t	stream,
		const int	nthreads,
		const float *	boxes,
		const float *	scores,
		const float *	all_probs,
		const int *	indexes,
		const int *	count,
		const bool	keep_score,
		const int	num_box,
		const int	num_prob,
		const int	topN,
		float *	out_boxes,
		float *	out_scores,
		float *	out_all_probs
	)

load_binary_data()

std::shared_ptr< float > apollo::perception::inference::load_binary_data

(

const std::string &

filename

)

在文件 util.cc 第 24 行定义.

                                                                 {
  std::ifstream ifs(filename, std::ifstream::binary);
  if (!ifs) {
    return nullptr;
  }
 
  ifs.seekg(0, ifs.end);
  int length = static_cast<int>(ifs.tellg() / sizeof(float));
  ifs.seekg(0, ifs.beg);
  std::shared_ptr<float> outputs;
  outputs.reset(new float[length]);
  ifs.read(reinterpret_cast<char *>(outputs.get()), sizeof(float) * length);
  ifs.close();
  return outputs;
}

load_data()

template<typename T >

void apollo::perception::inference::load_data	(	const std::string &	filename,
		std::vector< T > *	outputs
	)

在文件 util.h 第 32 行定义.

                                                                 {
  std::ifstream ifs(filename, std::ifstream::in);
 
  if (ifs.good()) {
    outputs->clear();
    T output;
    while (ifs >> output) {
      outputs->push_back(output);
    }
    ifs.close();
  }
}

loadNetParams()

bool apollo::perception::inference::loadNetParams	(	const std::string &	param_file,
		NetParameter *	param
	)

在文件 mi_utils.cc 第 64 行定义.

                                                                     {
  return ReadProtoFromTextFile(param_file, param);
}

locateFile()

std::string apollo::perception::inference::locateFile	(	const std::string &	network,
		const std::string &	input
	)

在文件 mi_utils.cc 第 67 行定义.

                                                                       {
  return network + "/" + input;
}

modify_pool_param()

bool apollo::perception::inference::modify_pool_param

(

PoolingParameter *

pool_param

)

在文件 mi_common.cc 第 101 行定义.

                                                     {
  if (pool_param->has_kernel_size()) {
    pool_param->set_kernel_h(pool_param->kernel_size());
    pool_param->set_kernel_w(pool_param->kernel_size());
  }
  if (pool_param->kernel_w() == 0 || pool_param->kernel_h() == 0) {
    return false;
  }
  if (pool_param->has_pad()) {
    pool_param->set_pad_h(pool_param->pad());
    pool_param->set_pad_w(pool_param->pad());
  }
  if (pool_param->has_stride()) {
    pool_param->set_stride_h(pool_param->stride());
    pool_param->set_stride_w(pool_param->stride());
  }
  if (pool_param->stride_w() == 0 || pool_param->stride_h() == 0) {
    return false;
  }
  return true;
}

NmsForward()

void apollo::perception::inference::NmsForward	(	bool	rpn_proposal_output_score,
		int	host_filter_count,
		int	num_box_corners,
		float	nms_overlap_threshold,
		int	num_candidate,
		int	top_n,
		int	batch_id,
		int	num_prob,
		float *	dev_sorted_box_for_nms,
		float *	scores,
		float *	all_probs,
		float *	out_boxes,
		int *	acc_box_num,
		cudaStream_t	stream
	)

GPU Non-Maximum Suppresion for network output

参数

[in]	rpn_proposal_output_score	Whether to output scores
[in]	host_filter_count	Number of filtered output
[in]	num_box_corners	Number of corners for 2D box
[in]	nms_overlap_threshold	IOU threshold for NMS
[in]	num_candidate	Pre-defined maximum number of candidates
[in]	top_n	Pre-defined maximum number of output boxes
[in]	batch_id	Id of current batch instance
[in]	num_prob	Number of probs
[in]	dev_sorted_box_for_nms	Bounding box output sorted by score
[in]	scores	Scores of boxes
[in]	all_probs	Probs of boxes for all classes and objectness
[in]	out_boxes	Output boxes
[in]	acc_box_num	Accumulated box num

NMS in GPU and postprocessing for selecting box in CPU

ParseNetParam()

void apollo::perception::inference::ParseNetParam	(	const NetParameter &	net_param,
		TensorDimsMap *	tensor_dims_map,
		std::map< std::string, std::string > *	tensor_modify_map,
		std::vector< LayerParameter > *	order
	)

在文件 mi_common.cc 第 27 行定义.

                                                     {
  for (int i = 0; i < net_param.layer_size(); ++i) {
    LayerParameter tensorrt_layer_param = net_param.layer(i);
    if (tensorrt_layer_param.type() == "Input") {
      InputParameter input = tensorrt_layer_param.input_param();
      for (int j = 0; j < tensorrt_layer_param.top().size(); ++j) {
        TensorDims dims{static_cast<int>(input.shape(j).dim(0)),
                        static_cast<int>(input.shape(j).dim(1)),
                        static_cast<int>(input.shape(j).dim(2)),
                        static_cast<int>(input.shape(j).dim(3))};
        auto name = tensorrt_layer_param.top(j);
        tensor_dims_map->insert(std::make_pair(name, dims));
        tensor_modify_map->insert(
            std::make_pair(name, tensorrt_layer_param.top(j)));
      }
    } else {
      order->push_back(tensorrt_layer_param);
    }
  }
}

ParserConvParam()

bool apollo::perception::inference::ParserConvParam	(	const ConvolutionParameter &	conv,
		ConvParam *	param
	)

在文件 mi_common.cc 第 51 行定义.

                                                                         {
  if (conv.has_kernel_h() || conv.has_kernel_w()) {
    if (conv.kernel_size_size() != 0) {
      return false;
    }
    param->kernel_h = conv.kernel_h();
    param->kernel_w = conv.kernel_w();
  } else {
    if (conv.kernel_size_size() < 1) {
      return false;
    }
    param->kernel_h = conv.kernel_size(0);
    param->kernel_w = (conv.kernel_size_size() > 1 ? conv.kernel_size(1)
                                                   : conv.kernel_size(0));
  }
  if (param->kernel_h == 0 || param->kernel_w == 0) {
    return false;
  }
 
  if (conv.has_pad_h() || conv.has_pad_w()) {
    if (conv.pad_size() != 0) {
      return false;
    }
    param->padding_h = conv.pad_h();
    param->padding_w = conv.pad_w();
  } else {
    param->padding_h = (conv.pad().empty() ? 0 : conv.pad(0));
    param->padding_w = (conv.pad_size() > 1 ? conv.pad(1) : param->padding_h);
  }
 
  if (conv.has_stride_h() || conv.has_stride_w()) {
    if (conv.stride_size() != 0) {
      return false;
    }
    param->stride_h = conv.stride_h();
    param->stride_w = conv.stride_w();
  } else {
    param->stride_h = (conv.stride().empty() ? 1 : conv.stride(0));
    param->stride_w =
        (conv.stride_size() > 1 ? conv.stride(1) : param->stride_h);
  }
  if (param->stride_h == 0 || param->stride_w == 0) {
    return false;
  }
 
  param->dilation = conv.dilation().empty() ? 1 : conv.dilation(0);
  param->group = conv.has_group() ? conv.group() : 1;
  return true;
}

ReadProtoFromBinaryFile()

bool apollo::perception::inference::ReadProtoFromBinaryFile	(	const std::string &	filename,
		google::protobuf::Message *	proto
	)

在文件 mi_utils.cc 第 44 行定义.

                                                           {
  int fd = open(filename.c_str(), O_RDONLY);
  if (fd < 0) {
    AERROR << "cannot open file " << filename;
    return false;
  }
  google::protobuf::io::FileInputStream raw_input(fd);
  google::protobuf::io::CodedInputStream coded_input(&raw_input);
#if GOOGLE_PROTOBUF_VERSION >= 3002000
  coded_input.SetTotalBytesLimit(std::numeric_limits<int>::max());
#else
  coded_input.SetTotalBytesLimit(std::numeric_limits<int>::max(), 536870912);
#endif
 
  bool success = proto->ParseFromCodedStream(&coded_input);
 
  close(fd);
  return success;
}

ReadProtoFromTextFile()

bool apollo::perception::inference::ReadProtoFromTextFile	(	const std::string &	filename,
		google::protobuf::Message *	proto
	)

在文件 mi_utils.cc 第 29 行定义.

                                                         {
  int fd = open(filename.c_str(), O_RDONLY);
  if (fd < 0) {
    AERROR << "cannot open file " << filename;
    return false;
  }
  google::protobuf::io::FileInputStream raw_input(fd);
 
  bool success = google::protobuf::TextFormat::Parse(&raw_input, proto);
 
  close(fd);
  return success;
}

repeatedly_add_cuda()

void apollo::perception::inference::repeatedly_add_cuda	(	int	block_size,
		int	thread_size,
		int	shared_mem,
		cudaStream_t	stream,
		const int	nthreads,
		const float *	in_data,
		float *	out_data,
		const float *	add_vec,
		int	add_vec_size
	)

repeatedly_mul_cuda()

void apollo::perception::inference::repeatedly_mul_cuda	(	int	block_size,
		int	thread_size,
		int	shared_mem,
		cudaStream_t	stream,
		const int	nthreads,
		const float *	in_data,
		float *	out_data,
		const float *	mul_vec,
		int	mul_vec_size
	)

ReshapeDims()

nvinfer1::DimsCHW apollo::perception::inference::ReshapeDims	(	const nvinfer1::DimsCHW &	dims,
		const nvinfer1::DimsCHW &	inputDims
	)

在文件 rt_common.cc 第 34 行定义.

                                                                {
  nvinfer1::DimsCHW outDims = inputDims;
  int count = inputDims.d[0] * inputDims.d[1] * inputDims.d[2];
  int constant = 1;
  int axis_inference = -1;
  for (int i = 0; i < inputDims.nbDims; ++i) {
    if (dims.d[i] == 0) {
      outDims.d[i] = inputDims.d[i];
      constant *= outDims.d[i];
    } else if (dims.d[i] > 0) {
      constant *= dims.d[i];
    } else if (dims.d[i] == -1) {
      CHECK_EQ(axis_inference, -1);
      outDims.d[i] = count / constant;
      axis_inference = i;
    }
  }
  return outDims;
}

ResizeGPU() [1/4]

bool apollo::perception::inference::ResizeGPU	(	const apollo::perception::base::Blob< uint8_t > &	src_gpu,
		std::shared_ptr< apollo::perception::base::Blob< float > >	dst,
		int	stepwidth,
		int	start_axis,
		int	mean_b,
		int	mean_g,
		int	mean_r,
		bool	channel_axis,
		float	scale
	)

ResizeGPU() [2/4]

bool apollo::perception::inference::ResizeGPU	(	const base::Image8U &	src,
		std::shared_ptr< apollo::perception::base::Blob< float > >	dst,
		int	stepwidth,
		int	start_axis
	)

ResizeGPU() [3/4]

bool apollo::perception::inference::ResizeGPU	(	const base::Image8U &	src,
		std::shared_ptr< apollo::perception::base::Blob< float > >	dst,
		int	stepwidth,
		int	start_axis,
		float	mean_b,
		float	mean_g,
		float	mean_r,
		bool	channel_axis,
		float	scale
	)

ResizeGPU() [4/4]

bool apollo::perception::inference::ResizeGPU	(	const base::Image8U &	src,
		std::shared_ptr< apollo::perception::base::Blob< float > >	dst,
		int	stepwidth,
		int	start_axis,
		float	mean_b,
		float	mean_g,
		float	mean_r,
		bool	channel_axis,
		float	std_b,
		float	std_g,
		float	std_r
	)

slice2d_cuda()

void apollo::perception::inference::slice2d_cuda	(	int	block_size,
		int	thread_size,
		int	shared_mem,
		cudaStream_t	stream,
		const int	nthreads,
		const float *	in_data,
		float *	out_data,
		const int *	slice_axises,
		int	slice_axis_num,
		int	input_axis_size
	)

write_result() [1/2]

bool apollo::perception::inference::write_result	(	const std::string &	out_path,
		const std::map< std::string, std::vector< float > > &	results
	)

write_result() [2/2]

bool apollo::perception::inference::write_result	(	const std::string &	out_path,
		const std::vector< float > &	results
	)

在文件 util.cc 第 40 行定义.

                                                   {
  std::ofstream outf(out_path, std::ios::binary | std::ios::out);
  if (!outf.is_open()) {
    AINFO << "Cannot open output file: " << out_path;
    return false;
  }
  outf.write(reinterpret_cast<const char *>(results.data()),
             sizeof(float) * results.size());
  outf.close();
  return true;
}

变量说明

_gpu_checklist

const std::vector<std::string> apollo::perception::inference::_gpu_checklist

初始值:

{"GeForce GTX 1080",
                                              "GeForce GTX 1080 Ti",
                                              "Tesla P4",
                                              "Tesla P40",
                                              "GeForce GTX 1070",
                                              "GeForce GTX 1060",
                                              "Tesla V100-SXM2-16GB",
                                              "Orin"}

在文件 rt_net.h 第 64 行定义.

                                         {"GeForce GTX 1080",
                                              "GeForce GTX 1080 Ti",
                                              "Tesla P4",
                                              "Tesla P40",
                                              "GeForce GTX 1070",
                                              "GeForce GTX 1060",
                                              "Tesla V100-SXM2-16GB",
                                              "Orin"};

active_map

const std::map< std::string, nvinfer1::ActivationType > apollo::perception::inference::active_map

初始值:

{
    {"Sigmoid", "sigmoid"},
    {"TanH", "tanh"},
    {"ReLU", "relu"},
    {"LeakyReLU", "leaky_relu"}}

在文件 mi_net.h 第 68 行定义.

                                             {
    {"Sigmoid", "sigmoid"},
    {"TanH", "tanh"},
    {"ReLU", "relu"},
    {"LeakyReLU", "leaky_relu"}};

eltwise_map

const std::map< EltwiseParameter::EltwiseOp, nvinfer1::ElementWiseOperation > apollo::perception::inference::eltwise_map

初始值:

{
    {EltwiseParameter_EltwiseOp_PROD, "mul"},
    {EltwiseParameter_EltwiseOp_SUM, "add"},
    {EltwiseParameter_EltwiseOp_MAX, "max"}}

在文件 mi_net.h 第 74 行定义.

                                                              {
    {EltwiseParameter_EltwiseOp_PROD, "mul"},
    {EltwiseParameter_EltwiseOp_SUM, "add"},
    {EltwiseParameter_EltwiseOp_MAX, "max"}};

kMaxDim

constexpr int apollo::perception::inference::kMaxDim = std::numeric_limits<int>::max()

constexpr

在文件 binary_data.h 第 31 行定义.

kMaxStrLen

constexpr size_t apollo::perception::inference::kMaxStrLen = 64

constexpr

在文件 binary_data.h 第 29 行定义.

kMinDim

constexpr int apollo::perception::inference::kMinDim = 1

constexpr

在文件 binary_data.h 第 30 行定义.

MemoryPoolInitSizeMb

constexpr uint64_t apollo::perception::inference::MemoryPoolInitSizeMb = 1000

constexpr

在文件 paddle_net.h 第 33 行定义.