caffe相关优化算法、数学函数库、全连层源码阅读

1.优化算法

Caffe的solver类提供了6种优化算法，配置文件中可以通过type关键字设置：

Stochastic Gradient Descent (type: “SGD”)
AdaDelta (type: “AdaDelta”)
Adaptive Gradient (type: “AdaGrad”)
Adam (type: “Adam”)
Nesterov’s Accelerated Gradient (type: “Nesterov”)
RMSprop (type: “RMSProp”)

Solver.prototxt文件:
首先设计好需要优化的对象，以及用于学习的训练网络和测试网络的prototxt文件（通常是train.prototxt和test.prototxt文件）通过forward和backward迭代进行优化来更新参数定期对网络进行评价优化过程中显示模型和solver的状态

solver参数

１）base_lr

这个参数代表的是此网络最开始的学习速率（Beginning Learning rate），一般是个浮点数，根据机器学习中的知识，lr过大会导致不收敛，过小会导致收敛过慢，所以这个参数设置也很重要。

２）lr_policy
这个参数代表的是learning rate应该遵守什么样的变化规则，这个参数对应的是字符串，选项及说明如下：

3)gamma

这个参数就是和learning rate相关的，lr_policy中包含此参数的话，需要进行设置，一般是一个实数。

4)stepsize

This parameter indicates how often (at some iteration count) that we should move onto the next “step” of training. This value is a positive integer.

5)stepvalue

This parameter indicates one of potentially many iteration counts that we should move onto the next “step” of training. This value is a positive integer. There are often more than one of these parameters present, each one indicated the next step iteration.

6)max_iter）
最大迭代次数，这个数值告诉网络何时停止训练，太小会达不到收敛，太大会导致震荡，为正整数。

7)momentum
上一次梯度更新的权重，real fraction

８）weight_decay
权重衰减项，用于防止过拟合。

９）solver_mode
选择CPU训练或者GPU训练。

１０）snapshot）
训练快照，确定多久保存一次model和solverstate，positive integer。

１１）snapshot_prefix
snapshot的前缀，就是model和solverstate的命名前缀，也代表路径。

１２）net
path to prototxt (train and val)

１３）test_iter
每次test_interval的test的迭代次数，假设测试样本总数为10000张图片，一次性执行全部的话效率很低，所以将测试数据分为几个批次进行测试，每个批次的数量就是batch_size。如果batch_size=100，那么需要迭代100次才能将10000个数据全部执行完，所以test_iter设置为100。

１４）test_interval
测试间隔，每训练多少次进行一次测试。

１５）display）
间隔多久对结果进行输出

１６)iter_size
这个参数乘上train.prototxt中的batch size是你实际使用的batch size。 相当于读取batchsize * itersize个图像才做一下gradient decent。 这个参数可以规避由于gpu内存不足而导致的batchsize的限制 因为你可以用多个iteration做到很大的batch 即使单次batch有限。

17)average_loss
取多次foward的loss作平均，进行显示输出。

２．math function

2.1 caffe_cpu_gemm 函数：

template<>
void caffe_cpu_gemm<float>(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) {
  int lda = (TransA == CblasNoTrans) ? K : M;
  int ldb = (TransB == CblasNoTrans) ? N : K;
  cblas_sgemm(CblasRowMajor, TransA, TransB, M, N, K, alpha, A, lda, B,
      ldb, beta, C, N);
}

template<>
void caffe_cpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
    const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
    const double alpha, const double* A, const double* B, const double beta,
    double* C) {
  int lda = (TransA == CblasNoTrans) ? K : M;
  int ldb = (TransB == CblasNoTrans) ? N : K;
  cblas_dgemm(CblasRowMajor, TransA, TransB, M, N, K, alpha, A, lda, B,
      ldb, beta, C, N);
}

功能： C=alpha*A*B+beta*C
A,B,C 是输入矩阵（一维数组格式）
CblasRowMajor :数据是行主序的（二维数据也是用一维数组储存的）
TransA, TransB：是否要对A和B做转置操作（CblasTrans CblasNoTrans）
M： A、C 的行数
N： B、C 的列数
K： A 的列数， B 的行数
lda ： A的列数（不做转置）行数（做转置）
ldb： B的列数（不做转置）行数（做转置）

2.2 caffe_cpu_gemv 函数：

template <>
void caffe_cpu_gemv<float>(const CBLAS_TRANSPOSE TransA, const int M,
    const int N, const float alpha, const float* A, const float* x,
    const float beta, float* y) {
  cblas_sgemv(CblasRowMajor, TransA, M, N, alpha, A, N, x, 1, beta, y, 1);
}

template <>
void caffe_cpu_gemv<double>(const CBLAS_TRANSPOSE TransA, const int M,
    const int N, const double alpha, const double* A, const double* x,
    const double beta, double* y) {
  cblas_dgemv(CblasRowMajor, TransA, M, N, alpha, A, N, x, 1, beta, y, 1);
}

功能： y=alpha*A*x+beta*y
其中X和Y是向量，A 是矩阵
M：A 的行数
N：A 的列数
cblas_sgemv 中的 参数1 表示对X和Y的每个元素都进行操作

2.3 caffe_axpy 函数：

template <>
void caffe_axpy<float>(const int N, const float alpha, const float* X,
    float* Y) { cblas_saxpy(N, alpha, X, 1, Y, 1); }

template <>
void caffe_axpy<double>(const int N, const double alpha, const double* X,
    double* Y) { cblas_daxpy(N, alpha, X, 1, Y, 1); }

功能： Y=alpha*X+Y
N：为X和Y中element的个数

2.4 caffe_set 函数：

template <typename Dtype>
void caffe_set(const int N, const Dtype alpha, Dtype* Y) {
  if (alpha == 0) {
    memset(Y, 0, sizeof(Dtype) * N);  // NOLINT(caffe/alt_fn)
    return;
  }
  for (int i = 0; i < N; ++i) {
    Y[i] = alpha;
  }
}

template void caffe_set<int>(const int N, const int alpha, int* Y);
template void caffe_set<float>(const int N, const float alpha, float* Y);
template void caffe_set<double>(const int N, const double alpha, double* Y);

功能：用常数 alpha 对 Y 进行初始化
函数 void *memset(void *buffer, char c, unsigned count) 一般为新申请的内存做初始化，功能是将buffer所指向内存中的每个字节的内容全部设置为c指定的ASCII值, count为块的大小

2.5 caffe_add_scalar 函数：

template <>
void caffe_add_scalar(const int N, const float alpha, float* Y) {
  for (int i = 0; i < N; ++i) {
    Y[i] += alpha;
  }
}

template <>
void caffe_add_scalar(const int N, const double alpha, double* Y) {
  for (int i = 0; i < N; ++i) {
    Y[i] += alpha;
  }
}

功能： 给 Y 的每个 element 加上常数 alpha

2.6 caffe_copy 函数：

template <typename Dtype>
void caffe_copy(const int N, const Dtype* X, Dtype* Y) {
  if (X != Y) {
    if (Caffe::mode() == Caffe::GPU) {
#ifndef CPU_ONLY
      // NOLINT_NEXT_LINE(caffe/alt_fn)
      CUDA_CHECK(cudaMemcpy(Y, X, sizeof(Dtype) * N, cudaMemcpyDefault));
#else
      NO_GPU;
#endif
    } else {
      memcpy(Y, X, sizeof(Dtype) * N);  // NOLINT(caffe/alt_fn)
    }
  }
}

template void caffe_copy<int>(const int N, const int* X, int* Y);
template void caffe_copy<unsigned int>(const int N, const unsigned int* X,
    unsigned