如何用PYTHON做分词处理?请各路大神指教，谢谢 - 知乎7被浏览1618分享邀请回答0添加评论分享收藏感谢收起0添加评论分享收藏感谢收起没用过DSP，不知道用两个DSP做一个有线视频通话设备难不难，求分享经验！！！ - DSP论坛 -
中国电子技术论坛 -
最好最受欢迎电子论坛!
后使用快捷导航没有帐号？
没用过DSP，不知道用两个DSP做一个有线视频通话设备难不难，求分享经验！！！
22:52:14　　
& & 先谢过了！！！
& && & & & 有建议的随便提。
& && && && && && &&&主要是用在密闭环境没有网络的情况下。
& && &谁知道淘宝上卖的普通摄像头（不需要安装驱动的）是怎样把数据输出来的。这个数据是怎样被显示器显示出来的。
& && &我知道单片机的摄像头图像是怎样显示在液晶显示屏上的，和上面的方式是一样的吗?
22:59:38　　
从单片机跨越到DSP挺难的
00:11:04　　
PCB在线计价下单
板子大小：
板子数量：
PCB 在线计价
从单片机跨越到DSP挺难的
&&确实DSP比较难，那要做成一个视频通话设备需要用到DSP哪些部分的知识？
几个月能入门？
13:18:38　　
从单片机跨越到DSP挺难的
DSP传输视频数据速度够不够？
13:02:18　　
DSP传输视频数据速度够不够？
够的，一般视频处理用c6000系列的
发表于 7&天前　　
路过，学习学习
发表于 6&天前　　
够的，一般视频处理用c6000系列的
如果用DSP做视频通话设备，用哪种通信方式做好呢？
发表于 6&天前　　
如果用DSP做视频通话设备，用哪种通信方式做好呢？
这个就不太清楚了，没研究过。
你可以去DSP板块发帖问问，或者和DSP的版主私信交流下
发表于 5&小时前　　
Powered by
供应链服务
商务及广告合作
Jeffery Guo
关注我们的微信
供应链服务 PCB/IC/PCBA
下载发烧友APP
版权所有 (C) 深圳华强聚丰电子科技有限公司用c++怎么去调用你训练好的caffe模型啊？我一点头绪都没有，求大神指教 - 知乎81被浏览6689分享邀请回答92 条评论分享收藏感谢收起net = caffe.Net(model_def, model_weights, caffe.TEST)
2. 填充第零层（data层）数据net.blobs['data'].data[...] = transformed_image#c++ 就是用了caffe_copy,本质是memcpy
这里‘data' 要和网络的第零层的name一致3. 前向，取出结果 output = net.forward()
output_prob = output['prob'][0]
这里的’prob' 要和网络的最后一层的name一致。这时output_prob（值的范围是[0, 1]）就是结果矩阵， 取出top_k即可。----------------------------------------详细用法-----------------------------caffe 提供了三个接口python，matlab，c++。前两个更多是算法验证的时候用到，真正的把caffe应用到工程上必然需要使用c++接口，即使用从c++代码的层次去调用caffe。其实caffe里边提供了一个classification的demo（///classification.cpp），如果把这部分代码看懂了，直接使用c++接口就没有什么难度了。提供一种研究caffe代码的方法，下载windows版本caffe，完成vs 上的调试和代码研读，很方面的。提供一个针对我自己业务在classification.cpp基础上修改的代码。CNNClassifier.h// CNNClassifier
// use caffe c++ interface to complete the task that recognise the cloud.
// author ：visint::zhangzhen
#pragma once
#include &caffe\caffe.hpp&
#include &opencv2/core/core.hpp&
#include &opencv2/highgui/highgui.hpp&
#include &opencv2/imgproc/imgproc.hpp&
#include &string&
#include &vector&
#include &memory&
#include "params.hpp" //参数类，所有的参数都保存在这个类中，单例模式
class CNNClassifier
CNNClassifier(const parameter& params);
~CNNClassifier();
void put(int index, const cv::Mat& src);
void reshape(int n);
void pridict(const std::vector&std::string&& imgpath, std::vector&int&& labels);
void pridict(const std::vector&cv::Mat&& imgs, std::vector&int&& labels);
void initCNN();
std::vector&int& argmax(const std::vector&float&& v, const int N);
void setMean(const std::string& mean_file);
void predict(std::vector&int&& labels, std::vector&float&& confidences);
boost::shared_ptr&caffe::Net&float& & net_;
cv::Mat mean_;
int num_channels_;
bool hasmean_;
cv::Size input_geometry_;
int stdHeight_;
int stdWidth_;
const parameter& params_;
CNNClassifier.cpp#include "CNNClassifier.h"
//CNNClassifier::CNNClassifier(const std::string& model_file,
// const std::string& trained_file,
// const std::string& mean_file = "") : BATCHNUM(10){
// LOG(INFO) && "init caffe model";
//#ifdef CPU_ONLY
// LOG(INFO) && "CPU mode";
// Caffe::set_mode(Caffe::CPU);
// LOG(INFO) && "GPU mode";
// Caffe::set_mode(Caffe::GPU);
// net_.reset(new Net&float&(model_file, TEST));
// net_-&CopyTrainedLayersFrom(trained_file);
// Blob&float&* input_layer = net_-&input_blobs()[0];
// num_channels_ = input_layer-&channels();
// stdHeight_ = input_layer-&height();
// stdWidth_ = input_layer-&width();
// input_geometry_ = cv::Size(input_layer-&width(), input_layer-&height());
// hasmean_ =
// setMean(mean_file);
CNNClassifier::CNNClassifier(const parameter& params): params_(params){
initCNN();
void CNNClassifier::initCNN(){
LOG(INFO) && "init cnn";
#ifdef CPU_ONLY
LOG(INFO) && "CPU mode";
Caffe::set_mode(Caffe::CPU);
LOG(INFO) && "GPU mode";
Caffe::set_mode(Caffe::GPU);
net_.reset(new Net&float&(params_.model_file_, TEST));
net_-&CopyTrainedLayersFrom(params_.trained_file_);
Blob&float&* input_layer = net_-&input_blobs()[0];
num_channels_ = input_layer-&channels();
stdHeight_ = input_layer-&height();
stdWidth_ = input_layer-&width();
input_geometry_ = cv::Size(input_layer-&width(), input_layer-&height());
hasmean_ =
setMean(params_.mean_file_);
CNNClassifier::~CNNClassifier(){
void CNNClassifier::setMean(const std::string& mean_file) {
if (mean_file != ""){
LOG(INFO) && "set Mean";
BlobProto blob_
ReadProtoFromBinaryFileOrDie(mean_file.c_str(), &blob_proto);
/* Convert from BlobProto to Blob&float& */
Blob&float& mean_
mean_blob.FromProto(blob_proto);
CHECK_EQ(mean_blob.channels(), num_channels_)
&& "Number of channels of mean file doesn't match input layer.";
/* The format of the mean file is planar 32-bit float BGR or grayscale. */
std::vector&cv::Mat&
float* data = mean_blob.mutable_cpu_data();
for (int i = 0; i & num_channels_; ++i) {
/* Extract an individual channel. */
cv::Mat channel(mean_blob.height(), mean_blob.width(), CV_32FC1, data);
channels.push_back(channel);
data += mean_blob.height() * mean_blob.width();
/* Merge the separate channels into a single image. */
cv::merge(channels, mean);
/* Compute the global mean pixel value and create a mean image
* filled with this value. */
//cv::Scalar channel_mean = cv::mean(mean);
//mean_ = cv::Mat(input_geometry_, mean.type(), channel_mean);
cv::resize(mean, mean_, input_geometry_, 0.0, 0.0, INTER_CUBIC);
hasmean_ =
void CNNClassifier::put(int index, const cv::Mat& src){
CHECK_EQ(src.channels(), num_channels_);
Blob&float&* input_layer = net_-&input_blobs()[0];
if (hasmean_){
if (num_channels_ == 3){
src.convertTo(wrapimg, CV_32FC3);
src.convertTo(wrapimg, CV_32FC1);
wrapimg = wrapimg - mean_;
if (num_channels_ == 3){
src.convertTo(wrapimg, CV_32FC3);
src.convertTo(wrapimg, CV_32FC1);
wrapimg /= 255.0;
//int width = input_layer-&width();
//int height = input_layer-&height();
float* input_data = input_layer-&mutable_cpu_data();
vector&cv::Mat&
cv::split(wrapimg, wrapimginchannel);
int offset = input_layer-&offset(index);
for (size_t i = 0; i & wrapimginchannel.size(); ++i){
caffe::caffe_copy(input_layer-&count(2), wrapimginchannel[i].ptr&float&(0), input_data + offset + i * input_layer-&count(2));
inline void CNNClassifier::reshape(int n){
Blob&float&* input = net_-&input_blobs()[0];
if (input-&num() != n){
LOG(INFO) && "reshape :" &&
input-&Reshape(n, num_channels_, input-&height(), input-&width());
net_-&Reshape();
void CNNClassifier::pridict(const std::vector&std::string&& imgpath, std::vector&int&& labels){
const int BATCHNUM = params_.batchnum_;
size_t N = imgpath.size();
size_t cnt = (int)ceil(1.0 * N / BATCHNUM);
for (size_t i = 0; i & ++i){
size_t start = i * BATCHNUM;
size_t end = std::min(N, (i + 1) * BATCHNUM);
reshape(end - start);
for (size_t j = j & ++j){
cv::Mat src = cv::imread(imgpath[j]);
cv::Mat roiCloud = src(cv::Rect(params_.center_.first - params_.radius_, params_.center_.second - params_.radius_, params_.radius_ * 2, params_.radius_*2));
cv::Mat stdRoiC
cv::resize(roiCloud, stdRoiCloud, input_geometry_);
put(j % BATCHNUM, stdRoiCloud);
vector&int&
vector&float&
//LOG(INFO) && "predict start :" && start && " end :" &&
predict(tmplabels, tmpconfidences);
labels.insert(labels.end(), tmplabels.begin(), tmplabels.end());
void CNNClassifier::pridict(const std::vector&cv::Mat&& imgs, std::vector&int&& labels){
const int BATCHNUM = params_.batchnum_;
size_t N = imgs.size();
size_t cnt = (int)ceil(1.0 * N / BATCHNUM);
for (size_t i = 0; i & ++i){
size_t start = i * BATCHNUM;
size_t end = std::min(N, (i + 1) * BATCHNUM);
reshape(end - start);
for (size_t j = j & ++j){
cv::Mat src = imgs[j];
cv::Mat roiCloud = src(cv::Rect(params_.center_.first - params_.radius_, params_.center_.second - params_.radius_, params_.radius_ * 2, params_.radius_ * 2));
//std::vector&cv::Mat& roiCloudC
//cv::split(roiCloud, roiCloudChannels);
//for (size_t i = 0; i & roiCloudChannels.size(); ++i){
// //roiCloudChannels[i] = roiCloudChannels[i] * params_.mask_;
// cv::multiply(roiCloudChannels[i], params_.mask_, roiCloudChannels[i]);
cv::Mat stdRoiC
//cv::merge(roiCloudChannels, stdRoiCloud);
//cv::resize(stdRoiCloud, stdRoiCloud, input_geometry_);
cv::resize(roiCloud, stdRoiCloud, input_geometry_);
put(j % BATCHNUM, stdRoiCloud);
vector&int&
vector&float&
//LOG(INFO) && "predict start :" && start && " end :" &&
predict(tmplabels, tmpconfidences);
labels.insert(labels.end(), tmplabels.begin(), tmplabels.end());
void CNNClassifier::predict(vector&int&& labels, vector&float&& confidences) {
std::vector&Blob&float& *& result = net_-&Forward();
Blob&float&* output_layer = net_-&output_blobs()[0];
for (int i = 0; i & output_layer-&shape(0); i++) {
int start = i* output_layer-&channels();
const float* begin = output_layer-&cpu_data() +
const float* end = begin + output_layer-&channels();
vector&float& confidence_result(begin, end);
const int topN = 1;
vector&int& label_result = argmax(confidence_result, topN);
label = label_result[0];
confidence = confidence_result[label];
confidences.emplace_back(confidence);
labels.emplace_back(label);
std::vector&int& CNNClassifier::argmax(const std::vector&float&& v, const int N){
std::vector&std::pair&float, int& &
for (size_t i = 0; i & v.size(); ++i)
pairs.push_back(std::make_pair(v[i], static_cast&int&(i)));
std::partial_sort(pairs.begin(), pairs.begin() + N, pairs.end(), [](std::pair&float, int& p1, std::pair&float, int& p2){return p1.first& p2. });
std::vector&int&
for (int i = 0; i & N; ++i)
result.push_back(pairs[i].second);
411 条评论分享收藏感谢收起查看更多回答}