C++ Net::blobs方法代码示例

//================================================================================================
// Usage: caffe_('blob_set_data_multigpu', BlobIndex, new_data)
//20160215find
static void blob_set_data_multigpu(MEX_ARGS) {
	mxCHECK(nrhs == 2 && mxIsUint32(prhs[0]) && mxIsCell(prhs[1]),
		"Usage: caffe_('blob_set_data_multigpu', hBlob, new_multi_gpu_data_cell)");

	mxCHECK(sync_ptr != NULL,"blob_set_data_multigpu only work on multi-GPU solver");

	unsigned int blob_index = *(unsigned int*)(mxGetPr(prhs[0]));
	blob_index = blob_index - 1;
	//mexPrintf("Real Blob index: %d\n", blob_index);

	vector<shared_ptr<P2PSync<float>>>* sync_vec = sync_ptr->get_syncs();
	//mexPrintf("blob_set_data_multigpu: Number of syncs: %d\n", sync_vec->size());
	
	if (mxGetNumberOfElements(prhs[1]) != sync_vec->size())
		mexErrMsgTxt("blob_set_data_multigpu: input size should be equal to selected gpu number.\n");

	// set root solver
	const mxArray* const elem = mxGetCell(prhs[1], 0);

	mxCHECK(mxIsSingle(elem),"Input data should be single-precision float!!!\n");

	Blob<float>* blob = sync_ptr->solver()->net()->blobs()[blob_index].get();
	//mexPrintf("Size of data for each sync: %d\nSize of blob: %d\n", mxGetNumberOfElements(elem), blob->count());
	//mexPrintf("Blob index: %d\n", blob_index);
	mx_mat_to_blob(elem, blob, DATA);

	int initial_device;
	CUDA_CHECK(cudaGetDevice(&initial_device));

	for (int i = 1; i < sync_vec->size(); i++)
	{
		Solver<float> *solver = (*sync_vec)[i]->solver().get();
		Net<float> *net = solver->net().get();
		blob = net->blobs()[blob_index].get();
		//mexPrintf("sync %d: \tNumber of blobs: %d\n", i, net->blobs().size());

		const mxArray* const elem = mxGetCell(prhs[1], i);
		mxCHECK(mxIsSingle(elem), "Input data should be single-precision float!!!\n");
		//mexPrintf("Size of data for each sync: %d\nSize of blob: %d\n", mxGetNumberOfElements(elem), blob->count());
		//mexPrintf("Blob index: %d\n", blob_index);
		
		CUDA_CHECK(cudaSetDevice(solver->param().device_id()));
		mx_mat_to_blob(elem, blob, DATA);
		CUDA_CHECK(cudaSetDevice(initial_device));
		//(*sync_vec)[i]->solver_->net->blobs()[blob_index];
	}
}

// Usage: caffe_('net_get_attr', hNet)
static void net_get_attr(MEX_ARGS) {
	mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),
		"Usage: caffe_('net_get_attr', hNet)");
	Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);
	const int net_attr_num = 6;
	const char* net_attrs[net_attr_num] = { "hLayer_layers", "hBlob_blobs",
		"input_blob_indices", "output_blob_indices", "layer_names", "blob_names" };
	mxArray* mx_net_attr = mxCreateStructMatrix(1, 1, net_attr_num,
		net_attrs);
	mxSetField(mx_net_attr, 0, "hLayer_layers",
		ptr_vec_to_handle_vec<Layer<float> >(net->layers()));
	mxSetField(mx_net_attr, 0, "hBlob_blobs",
		ptr_vec_to_handle_vec<Blob<float> >(net->blobs()));
	mxSetField(mx_net_attr, 0, "input_blob_indices",
		int_vec_to_mx_vec(net->input_blob_indices()));
	mxSetField(mx_net_attr, 0, "output_blob_indices",
		int_vec_to_mx_vec(net->output_blob_indices()));
	mxSetField(mx_net_attr, 0, "layer_names",
		str_vec_to_mx_strcell(net->layer_names()));
	mxSetField(mx_net_attr, 0, "blob_names",
		str_vec_to_mx_strcell(net->blob_names()));
	plhs[0] = mx_net_attr;
}

EXPORT int caffe_net_blobs_size(void *netAnon)
{
	Net<float> *net = (Net<float> *)netAnon;
	return net->blobs().size();
}

EXPORT void *caffe_net_blob(void *netAnon, int i)
{
	Net<float> *net = (Net<float> *)netAnon;
	return net->blobs()[i].get();
}