naibaf7
commented
8 years ago @hughperkins Thanks for your interest.
I do not provide benchmarks yet as the autotuning part is not completely done. Without Autotuning, it performs a little better than OpenCL im2col on AMD hardware, and about the same as CUDA im2col on nVidia hardware (with both OpenCL and CUDA backend). But since the kernels are built similarly to CLBLast, which claim up to 2x performance increase with Autotuning on general Hardware, I expect the same from Greentea-libDNN after I am done autotuning. My current experiments confirm or surpass that expectation though, given random convolution configurations to autotune.
As for using it in other frameworks:
- It currently relies on ViennaCL, but this can be removed.
- It requires the device-wrapper from OpenCL Caffe, which can be stripped down though to fit into other frameworks
- For the parameters, look at the following struct for the initialization:
struct LibDNNConfig {
LibDNNConfig() :
in_shape(3, 1),
out_shape(3, 1),
kernel(1, 1),
pad(1, 0),
stride(1, 1),
dilation(1, 0)
{}
device* dev_ptr = nullptr;
std::vector<int_tp> in_shape;
std::vector<int_tp> out_shape;
std::vector<int_tp> kernel;
std::vector<int_tp> pad;
std::vector<int_tp> stride;
std::vector<int_tp> dilation;
int_tp group = 1;
bool bias_term = false;
bool fast_unsafe_math = false;
bool weights_backward = true;
bool bias_backward = true;
libdnnConvolutionWeightAlgo_t wgalgo = LIBDNN_CONVOLUTION_WG_ALGO_DIRECT;
};The framework is expected to fill out this struct and pass it to libDNN for initialization.
- For forwarding/backwarding and tuning, the following parameters:
void Forward(const Dtype* bottom_data, const Dtype* weight,
const Dtype* bias,
Dtype* top_data, int_tp batch_size);
void Backward(bool prop_down_data, bool prop_down_weights,
const Dtype* top_data, const Dtype* top_diff,
const Dtype* weight, Dtype* weight_diff,
const Dtype* bias, Dtype* bias_diff,
const Dtype* bottom_data, Dtype* bottom_diff,
int_tp batch_size);
void Tune(Dtype* top_data, Dtype* top_diff,
Dtype* weight, Dtype* weight_diff,
Dtype* bias, Dtype* bias_diff,
Dtype* bottom_data, Dtype* bottom_diff,
int_tp batch_size);Here Dtype* is expected to be cl_mem (aka clmem*) on OpenCL platforms and device memory pointers on CUDA hardware.
hughperkins
fsword73
bhack
fmassa
edgarriba
Hi Fabian @naibaf7 how to plug your convolutional layer into other frameworks? What format does it expect the tensor data to be in? Can I just send in a cl_mem object in a certain format? Presumably I'd need to provide a bunch of metadata too, like dimension sizes, strides, offset? Do you have any benchmarks comparing performance on AMD hardware versus eg clBLAS + im2col ? And for any other hardware?
If your convolutional implementations are consistently better, seems no point in duplicating effort, I might just switch my libraries to use yours :-) Should be easy to build though, cross-platform etc, ideally...