Python爬虫爬取网页表格 (商品房登记信息实时统计)

Posted on 2016-02-22 Edited on 2023-09-14 In Python基础

利用pandas库中的read_html方法快速抓取网页中常见的表格型数据

table型表格

我们在网页上会经常看到这样一些表格，比如：

QS2018世界大学排名：

从中可以看到table类型的表格网页结构大致如下：

<table class="..." id="...">
    <thead>
    <tr>
    <th>...</th>
    </tr>
    </thead>
    <tbody>
        <tr>
            <td>...</td>
        </tr>
        <tr>...</tr>
        <tr>...</tr>
        <tr>...</tr>
        <tr>...</tr>
        ...
        <tr>...</tr>
        <tr>...</tr>
        <tr>...</tr>
        <tr>...</tr>        
    </tbody>
</table>

先来简单解释一下上文出现的几种标签含义：

<table>	: 定义表格
<thead>	: 定义表格的页眉
<tbody>	: 定义表格的主体
<tr>	: 定义表格的行
<th>	: 定义表格的表头
<td>	: 定义表格单元

这样的表格数据，就可以利用pandas模块里的read_html函数方便快捷地抓取下来。下面我们就来操作一下。

CUDA 总体优化策略--GPU应用优化策略

Posted on 2016-02-10 Edited on 2023-09-14 In 并行计算

CUDA 总体优化策略

1、选择程序中最耗时的部分，对它进行并行化，道理就是如果你选择了消耗运行时间 10%的部分来并行化，就算你达到了 10 倍的加速，现在的运行时间还是以前的 91%，但是如果你并行的是消耗运行时间 90%的部分，则现在的时间是以前的 19%。

2、最大化并行，就是在你选择的部分，使用尽可能多的线程来处理它，并且让每个线程尽可能多的计算，因为如果数据传输的时间太大的话，无论你提高多少倍也没多大作用，对于数据传输，首先要保证传输次数少，其次传输量要小，可以使用 cudaMallocHost 来加速传输。当然，这和问题本身，算法，硬件都有关系。

3、尽量保证全局内存融合，尽量使用 cuda 已经定义好的向量，他们往往已经对齐了，而且 cutil_math.h 中还有相关的操作符重载，对自己定义的结构体要使用对齐，如果实在无法实现内存融合的话，使用 texture。字节对齐以后方便访问。

4、使用 share，constant 存储器，同时保证 share 不出现 memory bank,就算有严重的bank conflict，shared 通常也快于 global。

5、优化 register 的使用，可以查看 cubin 文件，如果使用了 lmem，那么你就得考虑这个问题了，解决这个问题的方法，使用 share，减小 block 尺寸，后一条可能更实用。

6、注意条件分支语句，尽量少用分支；展开小循环，使用 inline 减少函数调用。

7、优化指令使用，尽量使用吞吐量大的指令，而不是相反，比如-use_fast_math 编译选项。

8、在Ｃ中判断式是短路的，也就是说如果现在的信息已经能够决定整体的结果，后面的就不用算了。如 if(a && b),如果ａ为假，那么 if 里语句就一定不能执行，故ｂ不用再求值，这样如果ａ，ｂ中有一个是计算量相当大的，就应当将它放在后面，如果计算量差不多，就把ａ，ｂ中为假概率大的放在前面。对于||可以类推。

9、查表在图形学非常常用。比如有一批数据，我们要知道每个数据出现的次数，我们就没有必要每次都去统计，只要统计一次，然后记录结果，在每次查的时候，只要查记录的结果就行了。

Python文件合并--读取文件夹文本文件合并至目标文件

Posted on 2016-01-20 Edited on 2023-09-14 In Python基础

直接上代码：

import glob
import os
import numpy as np


path = 'D://input_dic'
f = 'D://total.dic'

def read_writeFile(path, f):
    cate = [path + '/' + x for x in os.listdir(path)]
    print(cate)
    f2 = open(f, 'a+',encoding='utf-8')
    for idx, folder in enumerate(cate):
        print(folder)
        for im in glob.glob(folder):
            f1 = open(im,encoding='utf-8')
            line = f1.readline()
            while line:
                print(line)
                line = f1.readline()
                arr = line.split("\t")
                if(len(arr) >= 2):
                    s=arr[1].replace("\n","").replace("\t","").replace(" ","").strip()
                    if(len(s)>=1):
                        f2.write(s+"\n")
            f1.close()
    f2.close()


read_writeFile(path, f)

深度学习开源框架caffe解决回归问题车牌定位

Posted on 2015-12-15 Edited on 2023-09-14 In 图像处理

最近在基于caffe做目标检测的问题，需要利用caffe来训练一个回归网络，用来预测object在图像中的位置（x1,y1,width,height）。但是现有的caffe版本（happynear版本）只适用于二分类问题的数据集转换，所以需要修改caffe源码，使之也可以转换回归问题的数据集。

主要是参照 http://blog.csdn.net/baobei0112/article/details/47606559 进行修改。但是这份博客使用的不是happynear的caffe版本，所以源码改动的地方差异较大。下面我会记录我改动的地方。

一.源码修改

1.修改caffe.proto，位于/src/caffe/proto

36行改成 repeated float label = 5;，然后运行extract_proto.bat

2.修改data_layer.hpp

#ifndef CAFFE_DATA_LAYERS_HPP_  
#define CAFFE_DATA_LAYERS_HPP_  
#include <string>  
#include <utility>  
#include <vector>  
#include "hdf5/hdf5.h"  
#include "caffe/blob.hpp"  
#include "caffe/common.hpp"  
#include "caffe/data_reader.hpp"  
#include "caffe/data_transformer.hpp"  
#include "caffe/filler.hpp"  
#include "caffe/internal_thread.hpp"  
#include "caffe/layer.hpp"  
#include "caffe/proto/caffe.pb.h"  
#include "caffe/util/blocking_queue.hpp"  
#include "caffe/util/db.hpp"  
#define HDF5_DATA_DATASET_NAME "data"  
#define HDF5_DATA_LABEL_NAME "label"  
namespace caffe {  
/** 
* @brief Provides base for data layers that feed blobs to the Net. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class BaseDataLayer : public Layer<Dtype> {  
public:  
explicit BaseDataLayer(const LayerParameter& param);  
// LayerSetUp: implements common data layer setup functionality, and calls  
// DataLayerSetUp to do special data layer setup for individual layer types.  
// This method may not be overridden except by the BasePrefetchingDataLayer.  
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
// Data layers should be shared by multiple solvers in parallel  
virtual inline bool ShareInParallel() const { return true; }  
virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top) {  
}  
// Data layers have no bottoms, so reshaping is trivial.  
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top) {  
}  
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
}  
virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
}  
protected:  
TransformationParameter transform_param_;  
shared_ptr<DataTransformer<Dtype> > data_transformer_;  
bool output_labels_;  
};  
template <typename Dtype>  
class Batch {  
public:  
Blob<Dtype> data_, label_;  
};  
template <typename Dtype>  
class BasePrefetchingDataLayer :  
public BaseDataLayer<Dtype>, public InternalThread {  
public:  
explicit BasePrefetchingDataLayer(const LayerParameter& param);  
// LayerSetUp: implements common data layer setup functionality, and calls  
// DataLayerSetUp to do special data layer setup for individual layer types.  
// This method may not be overridden.  
void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
// Prefetches batches (asynchronously if to GPU memory)  
static const int PREFETCH_COUNT = 3;  
protected:  
virtual void InternalThreadEntry();  
virtual void load_batch(Batch<Dtype>* batch) = 0;  
Batch<Dtype> prefetch_[PREFETCH_COUNT];  
BlockingQueue<Batch<Dtype>*> prefetch_free_;  
BlockingQueue<Batch<Dtype>*> prefetch_full_;  
Blob<Dtype> transformed_data_;  
};  
template <typename Dtype>  
class DataLayer : public BasePrefetchingDataLayer<Dtype> {  
public:  
explicit DataLayer(const LayerParameter& param);  
virtual ~DataLayer();  
virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
// DataLayer uses DataReader instead for sharing for parallelism  
virtual inline bool ShareInParallel() const { return false; }  
virtual inline const char* type() const { return "Data"; }  
virtual inline int ExactNumBottomBlobs() const { return 0; }  
virtual inline int MinTopBlobs() const { return 1; }  
virtual inline int MaxTopBlobs() const { return 2; }  
protected:  
virtual void load_batch(Batch<Dtype>* batch);  
DataReader reader_;  
};  
/** 
* @brief Provides data to the Net generated by a Filler. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class DummyDataLayer : public Layer<Dtype> {  
public:  
explicit DummyDataLayer(const LayerParameter& param)  
: Layer<Dtype>(param) {}  
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
// Data layers should be shared by multiple solvers in parallel  
virtual inline bool ShareInParallel() const { return true; }  
// Data layers have no bottoms, so reshaping is trivial.  
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top) {  
}  
virtual inline const char* type() const { return "DummyData"; }  
virtual inline int ExactNumBottomBlobs() const { return 0; }  
virtual inline int MinTopBlobs() const { return 1; }  
protected:  
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
}  
virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
}  
vector<shared_ptr<Filler<Dtype> > > fillers_;  
vector<bool> refill_;  
};  
/** 
* @brief Provides data to the Net from HDF5 files. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class HDF5DataLayer : public Layer<Dtype> {  
public:  
explicit HDF5DataLayer(const LayerParameter& param)  
: Layer<Dtype>(param) {}  
virtual ~HDF5DataLayer();  
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
// Data layers should be shared by multiple solvers in parallel  
virtual inline bool ShareInParallel() const { return true; }  
// Data layers have no bottoms, so reshaping is trivial.  
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top) {  
}  
virtual inline const char* type() const { return "HDF5Data"; }  
virtual inline int ExactNumBottomBlobs() const { return 0; }  
virtual inline int MinTopBlobs() const { return 1; }  
protected:  
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
}  
virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
}  
virtual void LoadHDF5FileData(const char* filename);  
std::vector<std::string> hdf_filenames_;  
unsigned int num_files_;  
unsigned int current_file_;  
hsize_t current_row_;  
std::vector<shared_ptr<Blob<Dtype> > > hdf_blobs_;  
std::vector<unsigned int> data_permutation_;  
std::vector<unsigned int> file_permutation_;  
};  
/** 
* @brief Write blobs to disk as HDF5 files. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class HDF5OutputLayer : public Layer<Dtype> {  
public:  
explicit HDF5OutputLayer(const LayerParameter& param)  
: Layer<Dtype>(param), file_opened_(false) {}  
virtual ~HDF5OutputLayer();  
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
// Data layers should be shared by multiple solvers in parallel  
virtual inline bool ShareInParallel() const { return true; }  
// Data layers have no bottoms, so reshaping is trivial.  
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top) {  
}  
virtual inline const char* type() const { return "HDF5Output"; }  
// TODO: no limit on the number of blobs  
virtual inline int ExactNumBottomBlobs() const { return 2; }  
virtual inline int ExactNumTopBlobs() const { return 0; }  
inline std::string file_name() const { return file_name_; }  
protected:  
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
virtual void SaveBlobs();  
bool file_opened_;  
std::string file_name_;  
hid_t file_id_;  
Blob<Dtype> data_blob_;  
Blob<Dtype> label_blob_;  
};  
/** 
* @brief Provides data to the Net from image files. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class ImageDataLayer : public BasePrefetchingDataLayer<Dtype> {  
public:  
explicit ImageDataLayer(const LayerParameter& param)  
: BasePrefetchingDataLayer<Dtype>(param) {}  
virtual ~ImageDataLayer();  
virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual inline const char* type() const { return "ImageData"; }  
virtual inline int ExactNumBottomBlobs() const { return 0; }  
virtual inline int ExactNumTopBlobs() const { return 2; }  
vector<std::pair<std::string, std:: vector<float>> > lines_;  
shared_ptr<Caffe::RNG> prefetch_rng_;  
virtual void ShuffleImages();  
virtual void load_batch(Batch<Dtype>* batch);  
int lines_id_;  
};  
/** 
* @brief Provides data to the Net from memory. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class MemoryDataLayer : public BaseDataLayer<Dtype> {  
public:  
explicit MemoryDataLayer(const LayerParameter& param)  
: BaseDataLayer<Dtype>(param), has_new_data_(false) {}  
virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual inline const char* type() const { return "MemoryData"; }  
virtual inline int ExactNumBottomBlobs() const { return 0; }  
virtual inline int ExactNumTopBlobs() const { return 2; }  
virtual void AddDatumVector(const vector<Datum>& datum_vector);  
#ifdef USE_OPENCV  
virtual void AddMatVector(const vector<cv::Mat>& mat_vector,  
const vector<int>& labels);  
#endif // USE_OPENCV  
// Reset should accept const pointers, but can't, because the memory  
// will be given to Blob, which is mutable  
void Reset(Dtype* data, Dtype* label, int n);  
void set_batch_size(int new_size);  
int batch_size() { return batch_size_; }  
int channels() { return channels_; }  
int height() { return height_; }  
int width() { return width_; }  
protected:  
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
int batch_size_, channels_, height_, width_, size_;  
Dtype* data_;  
Dtype* labels_;  
int n_;  
size_t pos_;  
Blob<Dtype> added_data_;  
Blob<Dtype> added_label_;  
bool has_new_data_;  
};  
/** 
* @brief Provides data to the Net from windows of images files, specified 
* by a window data file. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class WindowDataLayer : public BasePrefetchingDataLayer<Dtype> {  
public:  
explicit WindowDataLayer(const LayerParameter& param)  
: BasePrefetchingDataLayer<Dtype>(param) {}  
virtual ~WindowDataLayer();  
virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual inline const char* type() const { return "WindowData"; }  
virtual inline int ExactNumBottomBlobs() const { return 0; }  
virtual inline int ExactNumTopBlobs() const { return 2; }  
protected:  
virtual unsigned int PrefetchRand();  
virtual void load_batch(Batch<Dtype>* batch);  
shared_ptr<Caffe::RNG> prefetch_rng_;  
vector<std::pair<std::string, vector<int> > > image_database_;  
enum WindowField { IMAGE_INDEX, LABEL, OVERLAP, X1, Y1, X2, Y2, NUM };  
vector<vector<float> > fg_windows_;  
vector<vector<float> > bg_windows_;  
Blob<Dtype> data_mean_;  
vector<Dtype> mean_values_;  
bool has_mean_file_;  
bool has_mean_values_;  
bool cache_images_;  
vector<std::pair<std::string, Datum > > image_database_cache_;  
};  
/** 
* @brief Provides data to the Net from image files. 
* 
* TODO(dox): thorough documentation for Forward and proto params. 
*/  
template <typename Dtype>  
class MultiLabelImageDataLayer : public BasePrefetchingDataLayer<Dtype> {  
public:  
explicit MultiLabelImageDataLayer(const LayerParameter& param)  
: BasePrefetchingDataLayer<Dtype>(param) {}  
virtual ~MultiLabelImageDataLayer();  
virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,  
const vector<Blob<Dtype>*>& top);  
virtual inline const char* type() const { return "MultiLabelImageData"; }  
virtual inline int ExactNumBottomBlobs() const { return 0; }  
virtual inline int ExactNumTopBlobs() const { return 2; }  
protected:  
shared_ptr<Caffe::RNG> prefetch_rng_;  
virtual void ShuffleImages();  
virtual void load_batch(Batch<Dtype>* batch);  
vector<std::pair<std::string, shared_ptr<vector<Dtype> > > > lines_;  
int label_count;  
int lines_id_;  
};  
} // namespace caffe  
#endif // CAFFE_DATA_LAYERS_HPP_

3.改动data_layer.cpp

#ifdef USE_OPENCV  
#include <opencv2/core/core.hpp>  
#endif  // USE_OPENCV  
#include <stdint.h>  
  
#include <vector>  
  
#include "caffe/data_layers.hpp"  
#include "caffe/proto/caffe.pb.h"  
#include "caffe/util/benchmark.hpp"  
  
namespace caffe {  
  
template <typename Dtype>  
DataLayer<Dtype>::DataLayer(const LayerParameter& param)  
  : BasePrefetchingDataLayer<Dtype>(param),  
    reader_(param) {  
}  
  
template <typename Dtype>  
DataLayer<Dtype>::~DataLayer() {  
  this->StopInternalThread();  
}  
  
template <typename Dtype>  
void DataLayer<Dtype>::DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,  
      const vector<Blob<Dtype>*>& top) {  
  const int batch_size = this->layer_param_.data_param().batch_size();  
  // Read a data point, and use it to initialize the top blob.  
  Datum& datum = *(reader_.full().peek());  
  
  // Use data_transformer to infer the expected blob shape from datum.  
  vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);  
  this->transformed_data_.Reshape(top_shape);  
  // Reshape top[0] and prefetch_data according to the batch_size.  
  top_shape[0] = batch_size;  
  top[0]->Reshape(top_shape);  
  for (int i = 0; i < this->PREFETCH_COUNT; ++i) {  
    this->prefetch_[i].data_.Reshape(top_shape);  
  }  
  LOG(INFO) << "output data size: " << top[0]->num() << ","  
      << top[0]->channels() << "," << top[0]->height() << ","  
      << top[0]->width();  
  // label  
  if (this->output_labels_) {  
      /* 
      vector<int> label_shape(1, batch_size); 
    top[1]->Reshape(label_shape); 
    for (int i = 0; i < this->PREFETCH_COUNT; ++i) { 
      this->prefetch_[i].label_.Reshape(label_shape); 
    } 
    */  
      top[1]->Reshape(batch_size,4,1,1);  
      for (int i = 0; i < this->PREFETCH_COUNT; ++i) {  
          this->prefetch_[i].label_.Reshape(batch_size, 4, 1, 1);  
      }  
  }  
}  
  
// This function is called on prefetch thread  
template<typename Dtype>  
void DataLayer<Dtype>::load_batch(Batch<Dtype>* batch) {  
  CPUTimer batch_timer;  
  batch_timer.Start();  
  double read_time = 0;  
  double trans_time = 0;  
  CPUTimer timer;  
  CHECK(batch->data_.count());  
  CHECK(this->transformed_data_.count());  
  
  // Reshape according to the first datum of each batch  
  // on single input batches allows for inputs of varying dimension.  
  const int batch_size = this->layer_param_.data_param().batch_size();  
  Datum& datum = *(reader_.full().peek());  
  // Use data_transformer to infer the expected blob shape from datum.  
  vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);  
  this->transformed_data_.Reshape(top_shape);  
  // Reshape batch according to the batch_size.  
  top_shape[0] = batch_size;  
  batch->data_.Reshape(top_shape);  
  
  Dtype* top_data = batch->data_.mutable_cpu_data();  
  Dtype* top_label = NULL;  // suppress warnings about uninitialized variables  
  if (this->output_labels_) {  
      top_label = batch->label_.mutable_cpu_data();  
  }  
  /* 
  if (this->output_labels_) { 
      for (int label_i = 0; label_i < datum.label_size(); label_i++){ 
          top_label[item_id*datum.label_size() + label_i] = datum.label(label_i); 
      } 
  } 
  */  
  for (int item_id = 0; item_id < batch_size; ++item_id) {  
    timer.Start();  
    // get a datum  
    Datum& datum = *(reader_.full().pop("Waiting for data"));  
    read_time += timer.MicroSeconds();  
    timer.Start();  
    // Apply data transformations (mirror, scale, crop...)  
    int offset = batch->data_.offset(item_id);  
    this->transformed_data_.set_cpu_data(top_data + offset);  
    this->data_transformer_->Transform(datum, &(this->transformed_data_));  
    // Copy label.  
    if (this->output_labels_) {  
     // top_label[item_id] = datum.label();  
        for (int label_i = 0; label_i < datum.label_size(); label_i++){  
            top_label[item_id*datum.label_size()+label_i] = datum.label(label_i);  
        }  
    }  
    trans_time += timer.MicroSeconds();  
  
    reader_.free().push(const_cast<Datum*>(&datum));  
  }  
  timer.Stop();  
  batch_timer.Stop();  
  DLOG(INFO) << "Prefetch batch: " << batch_timer.MilliSeconds() << " ms.";  
  DLOG(INFO) << "     Read time: " << read_time / 1000 << " ms.";  
  DLOG(INFO) << "Transform time: " << trans_time / 1000 << " ms.";  
}  
  
INSTANTIATE_CLASS(DataLayer);  
REGISTER_LAYER_CLASS(Data);  
  
}  // namespace caffe

4.修改image_data_layer.cpp中label部分

基于iPhone手机的人脸出勤管理系统

Posted on 2015-10-10 Edited on 2023-09-14 In 图像处理

在现代化的社会中，移动设备进入社会的每一个角落已经势不可挡，越来越多的人已经依赖上这种高科技现代化智能的移动设备，同时它已经在年轻的人群中成为一种时尚的商品。基于iPhone的出勤管理系统的实现使得这种时尚又先进的移动设备能更好的服务于我们的日常工作、学习及生活。

目前在项目实验室已有基于PC键盘输入的出勤管理系统和iPhone手机输入的出勤管理系统，图象声音部人脸识别技术c/c++语言的实现是项目实验室自成立以来重点完成成果之一，获得了广大师生的一致好评，此时基于iPhone手机人脸识别的出勤管理系统应运而生。
人脸识别技术是机器视觉和模式识别领域最具有挑战性的课题之一，同时也具有较为广泛的应用意义，在诸如证件检验、银行系统、军队安全、安全检查方面都具有相当大的应用前景。人脸识别技术是一个非常活跃的研究领域，它覆盖了数字图像处理、模式识别、计算机视觉、神经网络、心理学、生理学、数学等诸多学科的内容。

本系统采用的是C/S模式的系统体系结构，客户端是iPhone手机，开发语言为Objective-C；服务器是Windows Server2008，采用C++为服务器的开发语言。iPhone手机与Windows Server 2008之间通过Socket实现通信，从而完成人脸出勤管理系统。

（1）用户登陆和注册模块：

用户登陆通过iPhone手机的客户端登陆系统。注册模块，新用户输入用户名（学号），然后输入自己定义的6位密码完成注册。首先，用户输入用户名、密码，确认密码，点击“注册”。当服务器接收到用户名之后会在用户信息表中检索用户信息是否存在，若存在完成注册。

（2）信息检索模块：

用户通过输入登录信息
进入数据库进行检索并写入有关考勤信息。用户登陆成功之后系统会自动检测其拥有的权限，用户可以根据其权限查询其他用户相关的考勤信息。A级权限查询所有人的出勤信息；B级权限查询各部门部长的出勤信息；C级权限查询各部门成员出勤信息。

（3）信息反馈模块

通过手机系统将该人员的相关信息反馈给用户，从而实现信息查询。

（4）数据库设计

深度学习理论知识

Posted on 2015-10-10 Edited on 2023-09-14 In 深度学习

概念

传统的机器学习需要针对不同的任务人工设计大量复杂的特征，对于具有low level的比如图像，语音，文本这样的数据，传统机器学习模型的性能表现很难达到state-of-the-art。那么除了人工设计特征，另一个特征设计的流派就是表示学习。

表示学习通过机器自己学习来发现特征。不仅学习representation到输出的映射（即任务本身），也学习representation本身 。

表示学习优点：

往往比人为设计的特征要好得多。
允许AI系统快速适应新任务，用最少的人工干预。

深度学习就是属于表示学习的一个领域。

深度学习：计算机从经验中学习，以层次化的概念来理解世界。

从经验中学习：避免了人工指定计算机学习所需的所有知识。本质上是从数据样本直接学习，所谓的经验蕴含在数据样本中。
层次化的概念：计算机通过从简单的概念来构建、学习更复杂的概念。
	比如对于图片分类任务，直接学习从一组像素到物体的映射很困难。而通过将所需的复杂映射分解成一系列嵌套的简单映射来解决该问题则相对简单一些。
	即通过组合简单的概念来构建复杂的概念，也就是用低级特征来组合高级特征。

深度学习成功的关键：

海量的训练数据。
硬件和软件的发展。包括更快的 CPU、通用的GUP发展、更大内存、更快的网络连接、更好的软件基础。

MATLAB GUI实现常见图像处理算法与视频跟踪算法

Posted on 2013-11-22 Edited on 2023-09-14 In 图像处理

初学MATLAB GUI编程，设计了一个小型图像处理平台。
软件主界面：

功能一几何变换：

功能二形态学变换：

功能三图像分割：

功能四人脸检测：

功能五车号识别：