学习笔记：Caffe上配置和运行MNIST

学习笔记：Caffe上配置和运行MNIST

MNIST，一个经典的手写数字库，包含60000个训练样本和10000个测试样本，图片大小28*28，在Caffe上配置的第一个案例
 
1首先，获取minist的数据包。 这个版本是四个数据包
cd $CAFFE_ROOT
./data/mnist/get_mnist.sh

 

[html]  view plain copy 在CODE上查看代码片
 
  1. #!/usr/bin/env sh  
  2. # This scripts downloads the mnist data and unzips it.  
  3. DIR="$( cd "$(dirname "$0")" ; pwd -P )"  
  4. cd $DIR  
  5. echo "Downloading..."  
  6.   
  7. wget --no-check-certificate http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz  
  8. wget --no-check-certificate http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz  
  9. wget --no-check-certificate http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz  
  10. wget --no-check-certificate http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz  
  11.   
  12. echo "Unzipping..."  
  13.   
  14.   
  15. gunzip train-images-idx3-ubyte.gz  
  16. gunzip train-labels-idx1-ubyte.gz  
  17. gunzip t10k-images-idx3-ubyte.gz  
  18. gunzip t10k-labels-idx1-ubyte.gz  
  19.   
  20.   
  21. # Creation is split out because leveldb sometimes causes segfault  
  22. # and needs to be re-created.  
  23.   
  24. echo "Done."  



然后执行

./examples/mnist/create_mnist.sh

 

[html]  view plain copy 在CODE上查看代码片
 
  1. Creating lmdb...  
  2. Done.  


在这一步做了什么工作呢？
create_mnist.sh是利用caffe-master/build/examples/mnist/的convert_mnist_data.bin工具，将mnist date转化为可用的lmdb格式的文件。并将新生成的2个文件mnist-train-lmdb 和 mnist-test-lmdb放于create_mnist.sh同目录下。

2 数据准备好了，那么接下来的工作就是训练了。

http://caffe.berkeleyvision.org/gathered/examples/mnist.html

给出来的例子是 

./examples/mnist/train_lenet.sh

这个脚本调用的工具如下：

[html]  view plain copy 在CODE上查看代码片
 
  1. ./build/tools/caffe train --solver=examples/mnist/lenet_solver.prototxt  



还有其他的示例，如：

./examples/mnist/train_mnist_autoencoder.sh
这个脚本调用的工具如下： 

[html]  view plain copy 在CODE上查看代码片
 
  1. ./build/tools/caffe train \  
  2.   --solver=examples/mnist/mnist_autoencoder_solver.prototxt  

 

 

运行完结果如下：

生成四个文件

lenet_iter_10000.caffemodel         
lenet_iter_10000.solverstate      
lenet_iter_5000.caffemodel         
lenet_iter_5000.solverstate 

屏幕显示每次
.......................
I0126 17:32:32.171516 18290 solver.cpp:246] Iteration 10000, loss = 0.00453533
I0126 17:32:32.171550 18290 solver.cpp:264] Iteration 10000, Testing net (#0)
I0126 17:32:40.498195 18290 solver.cpp:315]     Test net output #0: accuracy = 0.9903
I0126 17:32:40.498236 18290 solver.cpp:315]     Test net output #1: loss = 0.0309918 (* 1 = 0.0309918 loss)
I0126 17:32:40.498245 18290 solver.cpp:251] Optimization Done.
I0126 17:32:40.498249 18290 caffe.cpp:121] Optimization Done.

 

首先讨论训练的网络模型：LeNet: the MNIST Classification Model   http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf
  
LeNet 模型之前在手写识别上就有非常好的表现。caffe 这里提供的是一个改进版的LeNet模型，其中的 sigmoid 被rectified linear units (ReLUs) 替换。
（标准的sigmoid输出不具备稀疏性，需要用一些惩罚因子来训练出一大堆接近0的冗余数据来，从而产生稀疏数据，例如L1、L1/L2或Student-t作惩罚因子。因此需要进行无监督的预训练。多层的神经网络如果用sigmoid或tanh激活函数也不做pre-training的话会因为 gradient vanishing problem 而会无法收敛。ReLU则这没有这个问题。ReLU是线性修正，公式为：g(x) = max(0, x)，是purelin的折线版。它的作用是如果计算出的值小于0，就让它等于0，否则保持原来的值不变。这是一种简单粗暴地强制某些数据为0的方法，然而经实践证明，训练后的网络完全具备适度的稀疏性。而且训练后的可视化效果和传统方式预训练出的效果很相似，这也说明了ReLU具备引导适度稀疏的能力。 来自讨论 http://tieba.baidu.com/p/3061925556）

LeNet的结构和CNN的结构是由相似之处的，是由两个 convolutional layer 和 pooling layer交错连接 ，然后两个fully connected layers结构组成。  具体可参见http://deeplearning.net/tutorial/lenet.html，此外DeepID 有个简单直观的结构图，可以辅助了解 http://blog.csdn.net/stdcoutzyx/article/details/42091205

定义MNIST网络和MNIST Solver：

从 ./examples/mnist/train_lenet.sh 脚本调用的指令我们就可以看到，solver是定义在了$CAFFE_ROOT/examples/mnist/lenet_solver.prototxt 中。

 

[html]  view plain copy 在CODE上查看代码片
 
  1. # The train/test net protocol buffer definition  
  2. net: "examples/mnist/lenet_train_test.prototxt"        //网络协议具体定义  
  3. # test_iter specifies how many forward passes the test should carry out.  
  4. # In the case of MNIST, we have test batch size 100 and 100 test iterations,  
  5. # covering the full 10,000 testing images.  
  6. test_iter: 100                                         //test迭代次数 如果batch_size =100,则100张图一批，训练100次，则可以覆盖10000张图的需求  
  7. # Carry out testing every 500 training iterations.        
  8. test_interval: 500                                     //训练迭代500次，测试一次  
  9. # The base learning rate, momentum and the weight decay of the network. //网络参数：学习率，动量，权重的衰减  
  10. base_lr: 0.01  
  11. momentum: 0.9  
  12. weight_decay: 0.0005  
  13. # The learning rate policy                            //学习策略：有固定学习率和每步递减学习率  
  14. lr_policy: "inv"  
  15. gamma: 0.0001  
  16. power: 0.75  
  17. # Display every 100 iterations                        //每迭代100次显示一次   
  18. display: 100  
  19. # The maximum number of iterations                    //最大迭代次数  
  20. max_iter: 10000  
  21. # snapshot intermediate results                       // 每5000次迭代存储一次数据，路径前缀是<span style="font-family: Arial, Helvetica, sans-serif;">examples/mnist/lenet</span>  
  22. snapshot: 5000  
  23. snapshot_prefix: "examples/mnist/lenet"  
[html]  view plain copy 在CODE上查看代码片
 
  1. solver_mode: CPU  



 

再看一下./examples/mnist/train_mnist_autoencoder.sh 调用的 mnist_autoencoder_solver.prototxt  的solver定义 

 

[html]  view plain copy 在CODE上查看代码片
 
  1. net: "examples/mnist/mnist_autoencoder.prototxt"  
  2. test_state: { stage: 'test-on-train' }  
  3. test_iter: 500  
  4. test_state: { stage: 'test-on-test' }  
  5. test_iter: 100  
  6. test_interval: 500  
  7. test_compute_loss: true  
  8. base_lr: 0.01  
  9. lr_policy: "step"  
  10. gamma: 0.1  
  11. stepsize: 10000  
  12. display: 100  
  13. max_iter: 65000  
  14. weight_decay: 0.0005  
  15. snapshot: 10000  
  16. snapshot_prefix: "examples/mnist/mnist_autoencoder"  
  17. momentum: 0.9  
  18. # solver mode: CPU or GPU  
  19. solver_mode: GPU  



 

MNIST网络定义在 $CAFFE_ROOT/examples/mnist/lenet_train_test.prototxt.  solver的第二行已经注明

具体解释 可以参见http://caffe.berkeleyvision.org/gathered/examples/mnist.html




$CAFFE_ROOT/examples/mnist/lenet_train_test.prototx


[html]  view plain copy 在CODE上查看代码片
 
  1. name: "LeNet"  
  2. layers {  
  3.   name: "mnist"  
  4.   type: DATA  
  5.   top: "data"  
  6.   top: "label"  
  7.   data_param {  
  8.     source: "examples/mnist/mnist_train_lmdb"  
  9.     backend: LMDB  
  10.     batch_size: 64  
  11.   }  
  12.   transform_param {  
  13.     scale: 0.00390625  
  14.   }  
  15.   include: { phase: TRAIN }  
  16. }  
  17. layers {  
  18.   name: "mnist"  
  19.   type: DATA  
  20.   top: "data"  
  21.   top: "label"  
  22.   data_param {  
  23.     source: "examples/mnist/mnist_test_lmdb"  
  24.    backend: LMDB  
  25.     batch_size: 100  
  26.   
  27.   }  
  28.   transform_param {  
  29.     scale: 0.00390625  
  30.   }  
  31.   include: { phase: TEST }  
  32. }  
  33.   
  34.   
  35. layers {  
  36.   name: "conv1"  
  37.   type: CONVOLUTION  
  38.   bottom: "data"  
  39.   top: "conv1"  
  40.   blobs_lr: 1  
  41.   blobs_lr: 2  
  42.   convolution_param {  
  43.     num_output: 20  
  44.     kernel_size: 5  
  45.     stride: 1  
  46.     weight_filler {  
  47.       type: "xavier"  
  48.     }  
  49.     bias_filler {  
  50.       type: "constant"  
  51.     }  
  52.   }  
  53. }  
  54. layers {  
  55.   name: "pool1"  
  56.   type: POOLING  
  57.   bottom: "conv1"  
  58.   top: "pool1"  
  59.   pooling_param {  
  60.     pool: MAX  
  61.     kernel_size: 2  
  62.     stride: 2  
  63.   }  
  64. }  
  65. layers {  
  66.   name: "conv2"  
  67.   type: CONVOLUTION  
  68.   bottom: "pool1"  
  69.   top: "conv2"  
  70.   blobs_lr: 1  
  71.   blobs_lr: 2  
  72.   convolution_param {  
  73.     num_output: 50  
  74.     kernel_size: 5  
  75.     stride: 1  
  76.     weight_filler {  
  77.       type: "xavier"  
  78.     }  
  79.     bias_filler {  
  80.       type: "constant"  
  81.     }  
  82.   }  
  83. }  
  84. layers {  
  85.   name: "pool2"  
  86.   type: POOLING  
  87.   bottom: "conv2"  
  88.   top: "pool2"  
  89.   pooling_param {  
  90.     pool: MAX  
  91.     kernel_size: 2  
  92.     stride: 2  
  93.   }  
  94. }  
  95. layers {  
  96.   name: "ip1"  
  97.   type: INNER_PRODUCT  
  98.   bottom: "pool2"  
  99.   top: "ip1"  
  100.   blobs_lr: 1  
  101.   blobs_lr: 2  
  102.   inner_product_param {  
  103.     num_output: 500  
  104.     weight_filler {  
  105.       type: "xavier"  
  106.     }  
  107.     bias_filler {  
  108.       type: "constant"  
  109.     }  
  110.  }  
  111. }  
  112. layers {  
  113.   name: "relu1"  
  114.   type: RELU  
  115.   bottom: "ip1"  
  116.   top: "ip1"  
  117. }  
  118. layers {  
  119.   name: "ip2"  
  120.   type: INNER_PRODUCT  
  121.   bottom: "ip1"  
  122.   top: "ip2"  
  123.   blobs_lr: 1  
  124.   blobs_lr: 2  
  125.   inner_product_param {  
  126.     num_output: 10  
  127.     weight_filler {  
  128.       type: "xavier"  
  129.     }  
  130.     bias_filler {  
  131.       type: "constant"  
  132.     }  
  133.   }  
  134. }  
  135. layers {  
  136.   name: "accuracy"  
  137.   type: ACCURACY  
  138.   bottom: "ip2"  
  139.   bottom: "label"  
  140.   top: "accuracy"  
  141.   include: { phase: TEST }  
  142. }  
  143. layers {  
  144.   name: "loss"  
  145.   type: SOFTMAX_LOSS  
  146.   bottom: "ip2"  
  147.   bottom: "label"  
  148.   top: "loss"  
  149. }  




而examples/mnist/mnist_autoencoder.prototxt 的网络定义则复杂许多：我们也可以看到，里面采用的是sigmoid 而不是 RELU

[html]  view plain copy 在CODE上查看代码片
 
  1. name: "MNISTAutoencoder"  
  2. layers {  
  3.   top: "data"  
  4.   name: "data"  
  5.   type: DATA  
  6.   data_param {  
  7.     source: "examples/mnist/mnist_train_lmdb"  
  8.     backend: LMDB  
  9.     batch_size: 100  
  10.   }  
  11.   transform_param {  
  12.     scale: 0.0039215684  
  13.   }  
  14.   include: { phase: TRAIN }  
  15. }  
  16. layers {  
  17.   top: "data"  
  18.   name: "data"  
  19.   type: DATA  
  20.   data_param {  
  21.     source: "examples/mnist/mnist_train_lmdb"  
  22.     backend: LMDB  
  23.     batch_size: 100  
  24.     scale: 0.0039215684  
  25.   }  
  26.   include: {  
  27.     phase: TEST  
  28.     stage: 'test-on-train'  
  29.   }  
  30. }  
  31. layers {  
  32.   top: "data"  
  33.   name: "data"  
  34.   type: DATA  
  35.   data_param {  
  36.     source: "examples/mnist/mnist_test_lmdb"  
  37.     backend: LMDB  
  38.     batch_size: 100  
  39.   }  
  40.   transform_param {  
  41.     scale: 0.0039215684  
  42.   }  
  43.   include: {  
  44.     phase: TEST  
  45.     stage: 'test-on-test'  
  46.   }  
  47. }  
  48. layers {  
  49.   bottom: "data"  
  50.   top: "flatdata"  
  51.   name: "flatdata"  
  52.   type: FLATTEN  
  53. }  
  54. layers {  
  55.   bottom: "data"  
  56.   top: "encode1"  
  57.   name: "encode1"  
  58.   type: INNER_PRODUCT  
  59.   blobs_lr: 1  
  60.   blobs_lr: 1  
  61.   weight_decay: 1  
  62.   weight_decay: 0  
  63.   inner_product_param {  
  64.     num_output: 1000  
  65.    weight_filler {  
  66.       type: "gaussian"  
  67.       std: 1  
  68.       sparse: 15  
  69.     }  
  70.     bias_filler {  
  71.       type: "constant"  
  72.       value: 0  
  73.     }  
  74.   }  
  75. }  
  76. layers {  
  77.   bottom: "encode1"  
  78.   top: "encode1neuron"  
  79.   name: "encode1neuron"  
  80.   type: SIGMOID  
  81. }  
  82. layers {  
  83.   bottom: "encode1neuron"  
  84.   top: "encode2"  
  85.   name: "encode2"  
  86.   type: INNER_PRODUCT  
  87.   blobs_lr: 1  
  88.   blobs_lr: 1  
  89.   weight_decay: 1  
  90.   weight_decay: 0  
  91.   inner_product_param {  
  92.     num_output: 500  
  93.     weight_filler {  
  94.       type: "gaussian"  
  95.       std: 1  
  96.       sparse: 15  
  97.     }  
  98.     bias_filler {  
  99.       type: "constant"  
  100.       value: 0  
  101.     }  
  102.   }  
  103. }  
  104. layers {  
  105.   bottom: "encode2"  
  106.   top: "encode2neuron"  
  107.   name: "encode2neuron"  
  108.   type: SIGMOID  
  109. }  
  110. layers {  
  111.  bottom: "encode2neuron"  
  112.   top: "encode3"  
  113.   name: "encode3"  
  114.   type: INNER_PRODUCT  
  115.   blobs_lr: 1  
  116.   blobs_lr: 1  
  117.   weight_decay: 1  
  118.   weight_decay: 0  
  119.   inner_product_param {  
  120.     num_output: 250  
  121.     weight_filler {  
  122.       type: "gaussian"  
  123.       std: 1  
  124.       sparse: 15  
  125.     }  
  126.     bias_filler {  
  127.       type: "constant"  
  128.       value: 0  
  129.     }  
  130.   }  
  131. }  
  132. layers {  
  133.   bottom: "encode3"  
  134.   top: "encode3neuron"  
  135.   name: "encode3neuron"  
  136.   type: SIGMOID  
  137. }  
  138. layers {  
  139.   bottom: "encode3neuron"  
  140.   top: "encode4"  
  141.   name: "encode4"  
  142.   type: INNER_PRODUCT  
  143.   blobs_lr: 1  
  144.   blobs_lr: 1  
  145.   weight_decay: 1  
  146.   weight_decay: 0  
  147.   inner_product_param {  
  148.     num_output: 30  
  149.     weight_filler {  
  150.       type: "gaussian"  
  151.       std: 1  
  152.       sparse: 15  
  153.     }  
  154.     bias_filler {  
  155.       type: "constant"  
  156.       value: 0  
  157.     }  
  158.   }  
  159. }  
  160. layers {  
  161.   bottom: "encode4"  
  162.   top: "decode4"  
  163.   name: "decode4"  
  164.   type: INNER_PRODUCT  
  165.   blobs_lr: 1  
  166.   blobs_lr: 1  
  167.   weight_decay: 1  
  168.   weight_decay: 0  
  169.   inner_product_param {  
  170.     num_output: 250  
  171.     weight_filler {  
  172.       type: "gaussian"  
  173.       std: 1  
  174.       sparse: 15  
  175.     }  
  176.     bias_filler {  
  177.       type: "constant"  
  178.       value: 0  
  179.     }  
  180.   }  
  181. }  
  182. layers {  
  183.   bottom: "decode4"  
  184.   top: "decode4neuron"  
  185.   name: "decode4neuron"  
  186.   type: SIGMOID  
  187. }  
  188. layers {  
  189.   bottom: "decode4neuron"  
  190.   top: "decode3"  
  191.   name: "decode3"  
  192.   type: INNER_PRODUCT  
  193.   blobs_lr: 1  
  194.   blobs_lr: 1  
  195.   weight_decay: 1  
  196.   weight_decay: 0  
  197.   inner_product_param {  
  198.     num_output: 500  
  199.     weight_filler {  
  200.       type: "gaussian"  
  201.       std: 1  
  202.       sparse: 15  
  203.     }  
  204.     bias_filler {  
  205.       type: "constant"  
  206.       value: 0  
  207.     }  
  208.   }  
  209. }  
  210. layers {  
  211.   bottom: "decode3"  
  212.   top: "decode3neuron"  
  213.   name: "decode3neuron"  
  214.   type: SIGMOID  
  215. }  
  216. layers {  
  217.   bottom: "decode3neuron"  
  218.   top: "decode2"  
  219.   name: "decode2"  
  220.   type: INNER_PRODUCT  
  221.   blobs_lr: 1  
  222.   blobs_lr: 1  
  223.   weight_decay: 1  
  224.   weight_decay: 0  
  225.   inner_product_param {  
  226.    num_output: 1000  
  227.     weight_filler {  
  228.       type: "gaussian"  
  229.       std: 1  
  230.       sparse: 15  
  231.     }  
  232.     bias_filler {  
  233.       type: "constant"  
  234.       value: 0  
  235.     }  
  236.   }  
  237. }  
  238. layers {  
  239.   bottom: "decode2"  
  240.   top: "decode2neuron"  
  241.   name: "decode2neuron"  
  242.   type: SIGMOID  
  243. }  
  244. layers {  
  245.   bottom: "decode2neuron"  
  246.   top: "decode1"  
  247.   name: "decode1"  
  248.   type: INNER_PRODUCT  
  249.   blobs_lr: 1  
  250.   blobs_lr: 1  
  251.   weight_decay: 1  
  252.   weight_decay: 0  
  253.   inner_product_param {  
  254.     num_output: 784  
  255.     weight_filler {  
  256.       type: "gaussian"  
  257.       std: 1  
  258.       sparse: 15  
  259.     }  
  260.     bias_filler {  
  261.       type: "constant"  
  262.       value: 0  
  263.     }  
  264.   }  
  265. }  
  266. layers {  
  267.   bottom: "decode1"  
  268.   bottom: "flatdata"  
  269.   top: "cross_entropy_loss"  
  270.   name: "loss"  
  271.   type: SIGMOID_CROSS_ENTROPY_LOSS  
  272.   loss_weight: 1  
  273. }  
  274. layers {  
  275.   bottom: "decode1"  
  276.   top: "decode1neuron"  
  277.   name: "decode1neuron"  
  278.   type: SIGMOID  
  279. }  
  280. layers {  
  281.   bottom: "decode1neuron"  
  282.   bottom: "flatdata"  
  283.   top: "l2_error"  
  284.   name: "loss"  
  285.   type: EUCLIDEAN_LOSS  
  286.   loss_weight: 0  
  287. }  





 

当所有数据都训练好之后，接下来就是如何将模型应用到实际数据了：

./build/tools/caffe.bin test -model=examples/mnist/lenet_train_test.prototxt -weights=examples/mnist/lenet_iter_10000.caffemodel -gpu=0 

如果没有GPU则使用

./build/tools/caffe.bin test -model=examples/mnist/lenet_train_test.prototxt -weights=examples/mnist/lenet_iter_10000.caffemodel

 

test：表示对训练好的模型进行Testing，而不是training。其他参数包括train, time, device_query。

-model=XXX：指定模型prototxt文件，这是一个文本文件，详细描述了网络结构和数据集信息。

 

 

输出如下：

 

[html]  view plain copy 在CODE上查看代码片
 
  1. I0303 18:26:31.961637 27313 caffe.cpp:138] Use CPU.  
  2. I0303 18:26:32.035434 27313 net.cpp:275] The NetState phase (1) differed from the phase (0) specified by a rule in layer mnist  
  3. I0303 18:26:32.035794 27313 net.cpp:39] Initializing net from parameters:   
  4. name: "LeNet"  
  5. layers {  
  6.   top: "data"  
  7.   top: "label"  
  8.   name: "mnist"  
  9.   type: DATA  
  10.   data_param {  
  11.     source: "examples/mnist/mnist_test_lmdb"  
  12.     batch_size: 100  
  13.     backend: LMDB  
  14.   }  
  15.   include {  
  16.     phase: TEST  
  17.   }  
  18.   transform_param {  
  19.     scale: 0.00390625  
  20.   }  
  21. }  
  22. layers {  
  23.   bottom: "data"  
  24.   top: "conv1"  
  25.   name: "conv1"  
  26.   type: CONVOLUTION  
  27.   blobs_lr: 1  
  28.   blobs_lr: 2  
  29.   convolution_param {  
  30.     num_output: 20  
  31.     kernel_size: 5  
  32.     stride: 1  
  33.     weight_filler {  
  34.       type: "xavier"  
  35.     }  
  36.     bias_filler {  
  37.       type: "constant"  
  38.     }  
  39.   }  
  40. }  
  41. layers {  
  42.   bottom: "conv1"  
  43.   top: "pool1"  
  44.   name: "pool1"  
  45.   type: POOLING  
  46.   pooling_param {  
  47.     pool: MAX  
  48.     kernel_size: 2  
  49.     stride: 2  
  50.   }  
  51. }  
  52. layers {  
  53.   bottom: "pool1"  
  54.   top: "conv2"  
  55.   name: "conv2"  
  56.   type: CONVOLUTION  
  57.   blobs_lr: 1  
  58.   blobs_lr: 2  
  59.   convolution_param {  
  60.     num_output: 50  
  61.     kernel_size: 5  
  62.     stride: 1  
  63.     weight_filler {  
  64.       type: "xavier"  
  65.     }  
  66.     bias_filler {  
  67.       type: "constant"  
  68.     }  
  69.   }  
  70. }  
  71. layers {  
  72.   bottom: "conv2"  
  73.   top: "pool2"  
  74.   name: "pool2"  
  75.   type: POOLING  
  76.   pooling_param {  
  77.     pool: MAX  
  78.     kernel_size: 2  
  79.     stride: 2  
  80.   }  
  81. }  
  82. layers {  
  83.   bottom: "pool2"  
  84.   top: "ip1"  
  85.   name: "ip1"  
  86.   type: INNER_PRODUCT  
  87.   blobs_lr: 1  
  88.   blobs_lr: 2  
  89.   inner_product_param {  
  90.     num_output: 500  
  91.     weight_filler {  
  92.       type: "xavier"  
  93.     }  
  94.     bias_filler {  
  95.       type: "constant"  
  96.     }  
  97.   }  
  98. }  
  99. layers {  
  100.   bottom: "ip1"  
  101.   top: "ip1"  
  102.   name: "relu1"  
  103.   type: RELU  
  104. }  
  105. layers {  
  106.   bottom: "ip1"  
  107.   top: "ip2"  
  108.   name: "ip2"  
  109.   type: INNER_PRODUCT  
  110.   blobs_lr: 1  
  111.   blobs_lr: 2  
  112.   inner_product_param {  
  113.     num_output: 10  
  114.     weight_filler {  
  115.       type: "xavier"  
  116.     }  
  117.     bias_filler {  
  118.       type: "constant"  
  119.     }  
  120.   }  
  121. }  
  122. layers {  
  123.   bottom: "ip2"  
  124.   bottom: "label"  
  125.   top: "accuracy"  
  126.   name: "accuracy"  
  127.   type: ACCURACY  
  128.   include {  
  129.     phase: TEST  
  130.   }  
  131. }  
  132. layers {  
  133.   bottom: "ip2"  
  134.   bottom: "label"  
  135.   top: "loss"  
  136.   name: "loss"  
  137.   type: SOFTMAX_LOSS  
  138. }  
  139. I0303 18:26:32.035923 27313 net.cpp:67] Creating Layer mnist  
  140. I0303 18:26:32.035931 27313 net.cpp:356] mnist -> data  
  141. I0303 18:26:32.035948 27313 net.cpp:356] mnist -> label  
  142. I0303 18:26:32.035955 27313 net.cpp:96] Setting up mnist  
  143. I0303 18:26:32.076159 27313 data_layer.cpp:68] Opening lmdb examples/mnist/mnist_test_lmdb  
  144. I0303 18:26:32.084071 27313 data_layer.cpp:128] output data size: 100,1,28,28  
  145. I0303 18:26:32.084214 27313 net.cpp:103] Top shape: 100 1 28 28 (78400)  
  146. I0303 18:26:32.084223 27313 net.cpp:103] Top shape: 100 1 1 1 (100)  
  147. I0303 18:26:32.084249 27313 net.cpp:67] Creating Layer label_mnist_1_split  
  148. I0303 18:26:32.084257 27313 net.cpp:394] label_mnist_1_split <- label  
  149. I0303 18:26:32.084269 27313 net.cpp:356] label_mnist_1_split -> label_mnist_1_split_0  
  150. I0303 18:26:32.084280 27313 net.cpp:356] label_mnist_1_split -> label_mnist_1_split_1  
  151. I0303 18:26:32.084286 27313 net.cpp:96] Setting up label_mnist_1_split  
  152. I0303 18:26:32.084292 27313 net.cpp:103] Top shape: 100 1 1 1 (100)  
  153. I0303 18:26:32.084297 27313 net.cpp:103] Top shape: 100 1 1 1 (100)  
  154. I0303 18:26:32.084306 27313 net.cpp:67] Creating Layer conv1  
  155. I0303 18:26:32.084311 27313 net.cpp:394] conv1 <- data  
  156. I0303 18:26:32.084317 27313 net.cpp:356] conv1 -> conv1  
  157. I0303 18:26:32.084326 27313 net.cpp:96] Setting up conv1  
  158. I0303 18:26:32.084775 27313 net.cpp:103] Top shape: 100 20 24 24 (1152000)  
  159. I0303 18:26:32.084791 27313 net.cpp:67] Creating Layer pool1  
  160. I0303 18:26:32.084796 27313 net.cpp:394] pool1 <- conv1  
  161. I0303 18:26:32.084803 27313 net.cpp:356] pool1 -> pool1  
  162. I0303 18:26:32.084810 27313 net.cpp:96] Setting up pool1  
  163. I0303 18:26:32.099537 27313 net.cpp:103] Top shape: 100 20 12 12 (288000)  
  164. I0303 18:26:32.099583 27313 net.cpp:67] Creating Layer conv2  
  165. I0303 18:26:32.099593 27313 net.cpp:394] conv2 <- pool1  
  166. I0303 18:26:32.099606 27313 net.cpp:356] conv2 -> conv2  
  167. I0303 18:26:32.099619 27313 net.cpp:96] Setting up conv2  
  168. I0303 18:26:32.099905 27313 net.cpp:103] Top shape: 100 50 8 8 (320000)  
  169. I0303 18:26:32.099925 27313 net.cpp:67] Creating Layer pool2  
  170. I0303 18:26:32.099947 27313 net.cpp:394] pool2 <- conv2  
  171. I0303 18:26:32.099959 27313 net.cpp:356] pool2 -> pool2  
  172. I0303 18:26:32.099970 27313 net.cpp:96] Setting up pool2  
  173. I0303 18:26:32.099979 27313 net.cpp:103] Top shape: 100 50 4 4 (80000)  
  174. I0303 18:26:32.099990 27313 net.cpp:67] Creating Layer ip1  
  175. I0303 18:26:32.099998 27313 net.cpp:394] ip1 <- pool2  
  176. I0303 18:26:32.100008 27313 net.cpp:356] ip1 -> ip1  
  177. I0303 18:26:32.100019 27313 net.cpp:96] Setting up ip1  
  178. I0303 18:26:32.104487 27313 net.cpp:103] Top shape: 100 500 1 1 (50000)  
  179. I0303 18:26:32.104518 27313 net.cpp:67] Creating Layer relu1  
  180. I0303 18:26:32.104527 27313 net.cpp:394] relu1 <- ip1  
  181. I0303 18:26:32.104538 27313 net.cpp:345] relu1 -> ip1 (in-place)  
  182. I0303 18:26:32.104549 27313 net.cpp:96] Setting up relu1  
  183. I0303 18:26:32.104558 27313 net.cpp:103] Top shape: 100 500 1 1 (50000)  
  184. I0303 18:26:32.104571 27313 net.cpp:67] Creating Layer ip2  
  185. I0303 18:26:32.104579 27313 net.cpp:394] ip2 <- ip1  
  186. I0303 18:26:32.104591 27313 net.cpp:356] ip2 -> ip2  
  187. I0303 18:26:32.104604 27313 net.cpp:96] Setting up ip2  
  188. I0303 18:26:32.104676 27313 net.cpp:103] Top shape: 100 10 1 1 (1000)  
  189. I0303 18:26:32.104691 27313 net.cpp:67] Creating Layer ip2_ip2_0_split  
  190. I0303 18:26:32.104701 27313 net.cpp:394] ip2_ip2_0_split <- ip2  
  191. I0303 18:26:32.104710 27313 net.cpp:356] ip2_ip2_0_split -> ip2_ip2_0_split_0  
  192. I0303 18:26:32.104722 27313 net.cpp:356] ip2_ip2_0_split -> ip2_ip2_0_split_1  
  193. I0303 18:26:32.104733 27313 net.cpp:96] Setting up ip2_ip2_0_split  
  194. I0303 18:26:32.104743 27313 net.cpp:103] Top shape: 100 10 1 1 (1000)  
  195. I0303 18:26:32.104751 27313 net.cpp:103] Top shape: 100 10 1 1 (1000)  
  196. I0303 18:26:32.104763 27313 net.cpp:67] Creating Layer accuracy  
  197. I0303 18:26:32.104770 27313 net.cpp:394] accuracy <- ip2_ip2_0_split_0  
  198. I0303 18:26:32.104779 27313 net.cpp:394] accuracy <- label_mnist_1_split_0  
  199. I0303 18:26:32.104790 27313 net.cpp:356] accuracy -> accuracy  
  200. I0303 18:26:32.104802 27313 net.cpp:96] Setting up accuracy  
  201. I0303 18:26:32.104811 27313 net.cpp:103] Top shape: 1 1 1 1 (1)  
  202. I0303 18:26:32.104822 27313 net.cpp:67] Creating Layer loss  
  203. I0303 18:26:32.104830 27313 net.cpp:394] loss <- ip2_ip2_0_split_1  
  204. I0303 18:26:32.104838 27313 net.cpp:394] loss <- label_mnist_1_split_1  
  205. I0303 18:26:32.104848 27313 net.cpp:356] loss -> loss  
  206. I0303 18:26:32.104857 27313 net.cpp:96] Setting up loss  
  207. I0303 18:26:32.104869 27313 net.cpp:103] Top shape: 1 1 1 1 (1)  
  208. I0303 18:26:32.104877 27313 net.cpp:109]     with loss weight 1  
  209. I0303 18:26:32.104909 27313 net.cpp:170] loss needs backward computation.  
  210. I0303 18:26:32.104918 27313 net.cpp:172] accuracy does not need backward computation.  
  211. I0303 18:26:32.104925 27313 net.cpp:170] ip2_ip2_0_split needs backward computation.  
  212. I0303 18:26:32.104933 27313 net.cpp:170] ip2 needs backward computation.  
  213. I0303 18:26:32.104941 27313 net.cpp:170] relu1 needs backward computation.  
  214. I0303 18:26:32.104948 27313 net.cpp:170] ip1 needs backward computation.  
  215. I0303 18:26:32.104956 27313 net.cpp:170] pool2 needs backward computation.  
  216. I0303 18:26:32.104964 27313 net.cpp:170] conv2 needs backward computation.  
  217. I0303 18:26:32.104975 27313 net.cpp:170] pool1 needs backward computation.  
  218. I0303 18:26:32.104984 27313 net.cpp:170] conv1 needs backward computation.  
  219. I0303 18:26:32.104991 27313 net.cpp:172] label_mnist_1_split does not need backward computation.  
  220. I0303 18:26:32.105000 27313 net.cpp:172] mnist does not need backward computation.  
  221. I0303 18:26:32.105006 27313 net.cpp:208] This network produces output accuracy  
  222. I0303 18:26:32.105017 27313 net.cpp:208] This network produces output loss  
  223. I0303 18:26:32.105034 27313 net.cpp:467] Collecting Learning Rate and Weight Decay.  
  224. I0303 18:26:32.105046 27313 net.cpp:219] Network initialization done.  
  225. I0303 18:26:32.105053 27313 net.cpp:220] Memory required for data: 8086808  
  226. I0303 18:26:32.136730 27313 caffe.cpp:145] Running for 50 iterations.  
  227. I0303 18:26:32.243196 27313 caffe.cpp:169] Batch 0, accuracy = 1  
  228. I0303 18:26:32.243229 27313 caffe.cpp:169] Batch 0, loss = 0.0140614  
  229. I0303 18:26:32.326557 27313 caffe.cpp:169] Batch 1, accuracy = 1  
  230. I0303 18:26:32.326588 27313 caffe.cpp:169] Batch 1, loss = 0.00749996  
  231. I0303 18:26:32.409931 27313 caffe.cpp:169] Batch 2, accuracy = 0.99  
  232. I0303 18:26:32.409963 27313 caffe.cpp:169] Batch 2, loss = 0.0106815  
  233. I0303 18:26:32.493257 27313 caffe.cpp:169] Batch 3, accuracy = 0.99  
  234. I0303 18:26:32.493288 27313 caffe.cpp:169] Batch 3, loss = 0.0528439  
  235. I0303 18:26:32.576733 27313 caffe.cpp:169] Batch 4, accuracy = 0.99  
  236. I0303 18:26:32.576761 27313 caffe.cpp:169] Batch 4, loss = 0.0632355  
  237. I0303 18:26:32.660257 27313 caffe.cpp:169] Batch 5, accuracy = 0.99  
  238. I0303 18:26:32.660289 27313 caffe.cpp:169] Batch 5, loss = 0.041726  
  239. I0303 18:26:32.743624 27313 caffe.cpp:169] Batch 6, accuracy = 0.97  
  240. I0303 18:26:32.743654 27313 caffe.cpp:169] Batch 6, loss = 0.0816639  
  241. I0303 18:26:32.827059 27313 caffe.cpp:169] Batch 7, accuracy = 0.99  
  242. I0303 18:26:32.827090 27313 caffe.cpp:169] Batch 7, loss = 0.0146397  
  243. I0303 18:26:32.910567 27313 caffe.cpp:169] Batch 8, accuracy = 1  
  244. I0303 18:26:32.910598 27313 caffe.cpp:169] Batch 8, loss = 0.00730312  
  245. I0303 18:26:32.993976 27313 caffe.cpp:169] Batch 9, accuracy = 0.99  
  246. I0303 18:26:32.994007 27313 caffe.cpp:169] Batch 9, loss = 0.0225503  
  247. I0303 18:26:33.077335 27313 caffe.cpp:169] Batch 10, accuracy = 0.98  
  248. I0303 18:26:33.077366 27313 caffe.cpp:169] Batch 10, loss = 0.0657359  
  249. I0303 18:26:33.160778 27313 caffe.cpp:169] Batch 11, accuracy = 0.98  
  250. I0303 18:26:33.160809 27313 caffe.cpp:169] Batch 11, loss = 0.0431129  
  251. I0303 18:26:33.244256 27313 caffe.cpp:169] Batch 12, accuracy = 0.96  
  252. I0303 18:26:33.244284 27313 caffe.cpp:169] Batch 12, loss = 0.132687  
  253. I0303 18:26:33.327652 27313 caffe.cpp:169] Batch 13, accuracy = 0.98  
  254. I0303 18:26:33.327684 27313 caffe.cpp:169] Batch 13, loss = 0.0907693  
  255. I0303 18:26:33.411123 27313 caffe.cpp:169] Batch 14, accuracy = 0.99  
  256. I0303 18:26:33.411151 27313 caffe.cpp:169] Batch 14, loss = 0.0150445  
  257. I0303 18:26:33.494606 27313 caffe.cpp:169] Batch 15, accuracy = 0.98  
  258. I0303 18:26:33.494635 27313 caffe.cpp:169] Batch 15, loss = 0.0465094  
  259. I0303 18:26:33.578012 27313 caffe.cpp:169] Batch 16, accuracy = 0.99  
  260. I0303 18:26:33.578042 27313 caffe.cpp:169] Batch 16, loss = 0.0343866  
  261. I0303 18:26:33.661423 27313 caffe.cpp:169] Batch 17, accuracy = 0.99  
  262. I0303 18:26:33.661454 27313 caffe.cpp:169] Batch 17, loss = 0.0277292  
  263. I0303 18:26:33.744851 27313 caffe.cpp:169] Batch 18, accuracy = 1  
  264. I0303 18:26:33.744882 27313 caffe.cpp:169] Batch 18, loss = 0.0146081  
  265. I0303 18:26:33.828307 27313 caffe.cpp:169] Batch 19, accuracy = 0.99  
  266. I0303 18:26:33.828338 27313 caffe.cpp:169] Batch 19, loss = 0.0457058  
  267. I0303 18:26:33.911772 27313 caffe.cpp:169] Batch 20, accuracy = 0.98  
  268. I0303 18:26:33.911800 27313 caffe.cpp:169] Batch 20, loss = 0.086042  
  269. I0303 18:26:33.995313 27313 caffe.cpp:169] Batch 21, accuracy = 0.98  
  270. I0303 18:26:33.995343 27313 caffe.cpp:169] Batch 21, loss = 0.0756276  
  271. I0303 18:26:34.078820 27313 caffe.cpp:169] Batch 22, accuracy = 0.99  
  272. I0303 18:26:34.078850 27313 caffe.cpp:169] Batch 22, loss = 0.0306264  
  273. I0303 18:26:34.162230 27313 caffe.cpp:169] Batch 23, accuracy = 0.98  
  274. I0303 18:26:34.162261 27313 caffe.cpp:169] Batch 23, loss = 0.0438904  
  275. I0303 18:26:34.245688 27313 caffe.cpp:169] Batch 24, accuracy = 0.98  
  276. I0303 18:26:34.245718 27313 caffe.cpp:169] Batch 24, loss = 0.0494635  
  277. I0303 18:26:34.329123 27313 caffe.cpp:169] Batch 25, accuracy = 0.99  
  278. I0303 18:26:34.329152 27313 caffe.cpp:169] Batch 25, loss = 0.0670097  
  279. I0303 18:26:34.412616 27313 caffe.cpp:169] Batch 26, accuracy = 0.99  
  280. I0303 18:26:34.412647 27313 caffe.cpp:169] Batch 26, loss = 0.117325  
  281. I0303 18:26:34.496093 27313 caffe.cpp:169] Batch 27, accuracy = 0.99  
  282. I0303 18:26:34.496122 27313 caffe.cpp:169] Batch 27, loss = 0.0199489  
  283. I0303 18:26:34.579558 27313 caffe.cpp:169] Batch 28, accuracy = 0.98  
  284. I0303 18:26:34.579587 27313 caffe.cpp:169] Batch 28, loss = 0.0489519  
  285. I0303 18:26:34.663027 27313 caffe.cpp:169] Batch 29, accuracy = 0.96  
  286. I0303 18:26:34.663051 27313 caffe.cpp:169] Batch 29, loss = 0.103231  
  287. I0303 18:26:34.746485 27313 caffe.cpp:169] Batch 30, accuracy = 1  
  288. I0303 18:26:34.746516 27313 caffe.cpp:169] Batch 30, loss = 0.0104769  
  289. I0303 18:26:34.829927 27313 caffe.cpp:169] Batch 31, accuracy = 1  
  290. I0303 18:26:34.829990 27313 caffe.cpp:169] Batch 31, loss = 0.00431556  
  291. I0303 18:26:34.913399 27313 caffe.cpp:169] Batch 32, accuracy = 0.98  
  292. I0303 18:26:34.913429 27313 caffe.cpp:169] Batch 32, loss = 0.027013  
  293. I0303 18:26:34.996893 27313 caffe.cpp:169] Batch 33, accuracy = 1  
  294. I0303 18:26:34.996923 27313 caffe.cpp:169] Batch 33, loss = 0.00294145  
  295. I0303 18:26:35.080307 27313 caffe.cpp:169] Batch 34, accuracy = 0.99  
  296. I0303 18:26:35.080338 27313 caffe.cpp:169] Batch 34, loss = 0.0528829  
  297. I0303 18:26:35.163833 27313 caffe.cpp:169] Batch 35, accuracy = 0.93  
  298. I0303 18:26:35.163862 27313 caffe.cpp:169] Batch 35, loss = 0.164353  
  299. I0303 18:26:35.247449 27313 caffe.cpp:169] Batch 36, accuracy = 1  
  300. I0303 18:26:35.247481 27313 caffe.cpp:169] Batch 36, loss = 0.00703398  
  301. I0303 18:26:35.331092 27313 caffe.cpp:169] Batch 37, accuracy = 0.97  
  302. I0303 18:26:35.331121 27313 caffe.cpp:169] Batch 37, loss = 0.0861889  
  303. I0303 18:26:35.414821 27313 caffe.cpp:169] Batch 38, accuracy = 0.99  
  304. I0303 18:26:35.414850 27313 caffe.cpp:169] Batch 38, loss = 0.028661  
  305. I0303 18:26:35.498474 27313 caffe.cpp:169] Batch 39, accuracy = 0.99  
  306. I0303 18:26:35.498502 27313 caffe.cpp:169] Batch 39, loss = 0.0414709  
  307. I0303 18:26:35.582015 27313 caffe.cpp:169] Batch 40, accuracy = 1  
  308. I0303 18:26:35.582042 27313 caffe.cpp:169] Batch 40, loss = 0.0357227  
  309. I0303 18:26:35.665555 27313 caffe.cpp:169] Batch 41, accuracy = 0.99  
  310. I0303 18:26:35.665585 27313 caffe.cpp:169] Batch 41, loss = 0.0525798  
  311. I0303 18:26:35.749254 27313 caffe.cpp:169] Batch 42, accuracy = 1  
  312. I0303 18:26:35.749285 27313 caffe.cpp:169] Batch 42, loss = 0.0257062  
  313. I0303 18:26:35.833019 27313 caffe.cpp:169] Batch 43, accuracy = 0.99  
  314. I0303 18:26:35.833048 27313 caffe.cpp:169] Batch 43, loss = 0.0198026  
  315. I0303 18:26:35.916801 27313 caffe.cpp:169] Batch 44, accuracy = 1  
  316. I0303 18:26:35.916833 27313 caffe.cpp:169] Batch 44, loss = 0.0178475  
  317. I0303 18:26:36.000491 27313 caffe.cpp:169] Batch 45, accuracy = 0.97  
  318. I0303 18:26:36.000522 27313 caffe.cpp:169] Batch 45, loss = 0.0608676  
  319. I0303 18:26:36.085665 27313 caffe.cpp:169] Batch 46, accuracy = 1  
  320. I0303 18:26:36.085697 27313 caffe.cpp:169] Batch 46, loss = 0.0100693  
  321. I0303 18:26:36.169760 27313 caffe.cpp:169] Batch 47, accuracy = 0.98  
  322. I0303 18:26:36.169791 27313 caffe.cpp:169] Batch 47, loss = 0.0211241  
  323. I0303 18:26:36.277791 27313 caffe.cpp:169] Batch 48, accuracy = 0.95  
  324. I0303 18:26:36.277822 27313 caffe.cpp:169] Batch 48, loss = 0.111764  
  325. I0303 18:26:36.361287 27313 caffe.cpp:169] Batch 49, accuracy = 1  
  326. I0303 18:26:36.361318 27313 caffe.cpp:169] Batch 49, loss = 0.0052372  
  327. I0303 18:26:36.361326 27313 caffe.cpp:174] Loss: 0.0452134  
  328. I0303 18:26:36.361332 27313 caffe.cpp:186] accuracy = 0.986  
  329. I0303 18:26:36.361341 27313 caffe.cpp:186] loss = 0.0452134 (* 1 = 0.0452134 loss)  
  330. [root@localhost caffe]#   



 


参考文献：

学习笔记4 学习搭建自己的网络——MNIST在caffe上进行训练与学习-薛开宇
http://wenku.baidu.com/link?url=_sERcBsTCgKElwFi7Hf9FXFe3J-c35ftm27Trf8SJX_iGsR2SlKDDIJmF-5DYruWK-uYJu5pYA3MMfcYt_IRiTL95tYVZ72TYwVTxf0JF27
Deep Learning（深度学习）学习笔记整理系列之LeNet-5卷积参数个人理解 ：http://blog.csdn.net/qiaofangjie/article/details/16826849
Deep Learning论文笔记之（四）CNN卷积神经网络推导和实现：http://blog.csdn.net/zouxy09/article/details/9993371
Deep Learning论文笔记之（六）Multi-Stage多级架构分析：http://blog.csdn.net/zouxy09/article/details/10007237
cuda-convnet 卷积神经网络 一般性结构卷积核个数 和 输入输出的关系以及输入输出的个数的说明: http://blog.csdn.net/zhubenfulovepoem/article/details/29583429
DeepID http://blog.csdn.net/stdcoutzyx/article/details/42091205

你可能感兴趣的:(学习笔记)

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 语文主题教学学习笔记之87 东哥杂谈
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
  • 《转介绍方法论》学习笔记 小可乐的妈妈
    一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • 新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类 WPG大大通 其他笔记汽车BMS经验分享新能源电池
    一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
  • 吴恩达深度学习笔记(30)-正则化的解释 极客Array
    正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
  • 个人学习笔记7-6：动手学深度学习pytorch版-李沐 浪子L 深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
    #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
  • golang学习笔记--MPG模型 xxzed golang#学习笔记学习笔记golang
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
  • 碎片化学习笔记分享 剑客写作
    现在生活节奏很快，学习力成为了我们拥有的最大财富。碎片化学习是最好的。首先，不要太过自信，学会虚心学习，是我们面对现实的好方法，才能够常保新鲜。平时我们要拥有什么工具呢？1.思维导图2.写在印象笔记里3.听书，消燥耳机4.教学输出5.录音笔里面最好的方式就是教学输出法，记忆里最好。当输出时我们集中精力记忆里最好。有人认为缩短睡眠时间来学习，其实最好的方式是保持最好的睡眠，记忆力会更好。剥夺睡眠，会
  • 《随园诗话》学习笔记三百零六 飞鸿雪舞
    卷五凡诗之传者，都在灵性五、五斗米与诗【原文】丁丑，余觅一抄书人，或荐黄生，名之纪，号星岩者，人甚朴野。偶过其案头，得句云；“破庵僧卖临街瓦，独井人争向晚泉。”余大奇之，即饷米五斗。自此欣然大用力于诗。五言句云：“云开日脚直，雨落水纹圆。竹锐穿泥壁，蝇酣落酒尊。钓久知鱼性，樵多识树名。笔残芦并用，墨尽指同磨。＂七言云：＂小窗近水寒偏觉，古木遮天曙不知。旧生萍处泥犹绿，新落花时水亦香。旧甓恐闲都贮水
  • D15 论语学习笔记 许小兔Angelina
    悟：上级对下级的宽容：凡事成定局，就不你说了；已接近完结的事，也没必要匡正和挽回了；既然是过去的事，也没必要追究得失和责任了。对待孩子教育也是，不用“问责制”，这样容易让孩子因为害怕担责而说谎。应当循循善诱，避免再犯错才是最重要的。3.16：【原文】子曰：“射不主皮，为力不同科，古之道也。”【译文】孔子说：“射箭比赛不以射透为主，而主要看是否射得准确，因为人的力量不同，自古如此。”3.17：【原文
  • 网络工程师学习笔记（一） 专业白嫖怪 网络工程师学习笔记学习笔记网络
    为了备战下半年的软考——网络工程师，利用每天的下班的闲暇时间看书听课，然后自己手敲整理的系列资料。希望能够对你们有所帮助第一章__计算机网络概述计算机网络的定义：将分散的具有独立运算功能的计算机系统，通过通信线路和通信设备进行连接起来的实现资源的共享。ARPAnet网络的特征：资源共享、分散控制、分组交换1946年第一台通用计算机—埃尼亚克能够相互连通进行数据交换。1960年提出巨型网络，出现了对
  • K8S学习笔记02——K8S组件 沉淅尘 #Docker#K8Skubernetes
    Kubernetes组件一、控制平面组件（ControlPlaneComponents）(1)kube-apiserver(2)etcd(3)kube-scheduler(4)kube-controller-manager(5)cloud-controller-manager二、Node组件1.kubelet2.kube-proxy3.容器运行时（ContainerRuntime）三、插件（Add
  • 「Python」2020.04.08学习笔记 | 第六章文件（a+）模式+把随机手机号写入文件小练习 Yetta的书影屋
    学习测试开发的Day97，真棒！学习时间为40M第九次全天课(下午视频二20M-50M）>>>fp.seek(0)0>>>fp.read()'你好11你好12你好13你好14你好15\n你好16\n你好17\n你好18\n'>>>fp.seek(0,0)0>>>fp.write("*********************************\n")34>>>fp.seek(0,0)0>>>f
  • 《金文成〈中庸〉学习笔记401。2020-2-24》 金吾生
    《金文成〈中庸〉学习笔记401。2020-2-24》今天是庚子年戊寅月丁酉日，二月初二，2020年2月24日星期一。二月二龙抬头。第二十二章【唯天下至诚，为能尽其性；能尽其性，则能尽人之性；能尽人之性，则能尽物之性；能尽物之性，则能赞天地之化育；能赞天地之化育，则可以与天地参矣。】上一节，船山讲解说，性作为天用之本体，于圣人和匹夫匹妇而言并无二致，区别来自于诚。诚的区别来自于纯粹与掺杂。掺杂什么呢
  • CDGA学习笔记三-《数据安全》 zy_chris 网络安全
    七、数据安全7.1引言数据安全包括安全策略和过程的规划、建立与执行，为数据和信息资产提供正确的身份验证、授权、访问和审计。要求来自以下方面：（1）利益相关方（2）政府法规（3）特定业务关注点（4）合法访问需求（5）合同义务7.1.1业务驱动因素1、降低风险信息安全首先对组织数据进行分级分类，对组织数据进行分类分级的整个流程：1）识别敏感数据资产并分类分级2）在企业中查找敏感数据3）确定保护每项资产
  • vue学习笔记——关于对Vue3 ref(), toRef(), toRefs(), unref(), isRef(), reactive()方法的理解。 chen_sir_sh vue学习笔记javascript前端vue
    VUE3出现了很多新的API，下面是自己的一些理解进行的总结。欢迎大家一起交流补充。ref()使用ref创建一个数据类型，ref有value这个属性constname1={age:"14",name:"bob1"};constname2=ref({name:"bob2"});//使用ref创建一个数据类型相对于reactive，ref有value属性name2.value="bob3"consol
  • 遇到僵尸进程，怎么处理---学习笔记 summer@彤妈 性能优化linux
    僵尸进程解释当iowait升高时，进程很可能因为得不到硬件的响应，而长时间处于不可中断状态。从ps或者top命令的输出中，你可以发现它们都处于D状态，也就是不可中断状态（UninterruptibleSleep）。既然说到了进程的状态，进程有哪些状态你还记得吗？我们先来回顾一下。top和ps是最常用的查看进程状态的工具，我们就从top的输出开始。下面是一个top命令输出的示例，S列（也就是Stat
  • C++学习笔记----6、内存管理（五）---- 智能指针（3） 王俊山IT c++学习笔记开发语言
    2、shared_ptr有时候吧，有些对象或者一部分代码需要同一个指针的拷贝。那么unique_ptr不能被拷贝，因此就不能用于些场景。这样的话，std::shared_ptr就是一个支持能够被拷贝的拥有共享属主的智能指针。但是，如果有指向同一个资源的多个shared_ptr实例，那么怎么知道什么时候去释放资源呢？这可以通过对于引用记数来解决，这个我们以后再聊。首先，让我们看一下怎么构造与使用sh
  • 【学习笔记】武志红心理学—潜意识决定命运 万万千千
    冰山一角什么构成了我们的命运？命运是由我们的显意识和潜意识来决定的。我们可以用一张图做一个比喻。看过“冰山一角”图片的都知道，潜意识就是水面以下的部分，显意识是水面以上的部分，从体积来看，潜意识占了大部分，而显意识只是冰山一角，纵向来看，庞大的潜意识支撑着冰山一角的显意识，才得以让冰山漂浮在水面。延伸到我们的人生，我们对自己显意识层面的想法很容易感知到，所以我们会说这是“我”自己做的选择。而潜意识
  • Prism 教程 yang_B621 PrismIOC
    http://t.csdnimg.cn/VXSSvhttps://blog.csdn.net/u010476739/article/details/119341731Prism-随笔分类-Hello——寻梦者！-博客园(cnblogs.com)C#IoC学习笔记-缥缈的尘埃-博客园(cnblogs.com)WPF_SchuylerEX的博客-CSDN博客
  • 绘本讲师训练营【第30期】2/21阅读原创《绘本之力》学习笔记2 郑贤钰
    30028郑贤钰今天读了绘本之力《留在灵魂里的东西》读了心里有非常大的感触！两个年幼什么都不懂的孩子，为了自己心爱的东西，攒下来自己的零花钱，却买了一个自己不知道怎么用的东西，当他们觉得这个东西根本就不好，准备扔掉的时候，这是故事中的有趣有爱的老爷爷出现了，帮助孩子们再一次发现之前别人拉出优美的音乐，原来自己买的这一个琴，自认为没用的琴也能够经过老爷爷熟练的演奏也能拉出这样优美的声音，这让孩子们十
  • 仿老师悟 耕海者
    毕业十年了，今天去拜访老师，看到老师的学习笔记，看到老师努力学习，积极提高的状态，我觉着自己真是有些懈怠了，孩子们，老师的老师都在孜孜不倦，我们岂能偷懒！
  • C++学习笔记----7、使用类与对象获得高性能（一）---- 书写类（2） 王俊山IT c++学习笔记开发语言
    2.2、定义成员函数前面对SpreadsheetCell类的定义足以让你生成类的对象。然而，如果想调用setValue()或者getValue()成员函数，连接器就会抱怨这些函数没有定义。这是因为到目前为止，这些成员函数只有原型，而还没有实现。通常，类的定义会在模块接口文件。对于成员函数的定义，你有一个选择：可以在模块定义文件或者在模块实现文件。下面是SpreadsheetCell类，在类内对成员
  • Spring6学习笔记4：事务 ·云扬· SSMJava#Spring学习笔记spring
    1JdbcTemplate1.1简介Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作准备工作①搭建子模块搭建子模块：spring-jdbc-tx②加入依赖org.springframeworkspring-jdbc6.0.2mysqlmysql-connector-java8.0.30com.alibabadruid1.2.15③创建jdbc.propertie
  • 连通无向图一般中心的算法及其matlab程序详解 夏天天天天天天天# 图论算法matlab图论
    #################本文为学习《图论算法及其MATLAB实现》的学习笔记#################若服务点只允许取在各顶点上,而服务对象却取在各顶点及各边(或弧)上的点,则在所有顶点中选定一个顶点作为图的一般中心其条件是该点离它本身的最远服务对象(包括顶点及各边(或弧)上的点)的距离达到极小值。寻找无向图的一般中心对解决网络最佳服务点确定的问题是十分有效的，使得服务对象的范围
  • 学习笔记：FW内容安全概述 TKE_yinian
    内容安全概述信息安全概述主要威胁关于防护简介内容安全威胁应用层威胁内容安全技术WEB安全应用安全入侵防御检测邮件安全数据安全网络安全反病毒全局环境感知沙箱检测信息安全概述•信息安全是对信息和信息系统进行保护，防止未授权的访问、使用、泄露、中断、修改、破坏并以此提供保密性、完整性和可用性。•为关键资产提供机密性、完整性和可用性（CIA三元组）保护是信息安全的核心目标。CIA（Confidential
  • java的socket实现一个九宫棋游戏 睡不醒的小泽
    前言一个简单的socket小作品=v=一个机酱在大三实验课中接触到很基础的JAVA语言socket编程。至于你问为什么嵌入式的机酱会弄些Java吗？emmmmm，可能是当初C语言版的不够好玩吧，另外如果碰巧有用，欢迎抱走的yoo在之前的笔记《网络基础知识和网络编程》中有讲解过关于网络编程的一些基本知识，以及一些LinuxC的socket编程，希望粗浅了解socket内部肌理的同学，右转咱的学习笔记
  • 【每日一词】D33 edge 宠辱不惊的中年少女
    1）学习笔记：edge：优势，=advantagebeanabsoluteedge有绝对优势AhasanedgeoverB表示A比B更好maintainone'sedge保持优势loseone'sedge失去优势innovativeedge创新方面的优势2）查字典延伸：A.就工作经验而言，她显然要比我们面试过的其他人都胜出一筹。Intermsofexperience,shedefinitelyha
  • 开发者关心的那些事 圣子足道 ios游戏编程apple支付
    我要在app里添加IAP，必须要注册自己的产品标识符（product identifiers）。产品标识符是什么？ 产品标识符（Product Identifiers）是一串字符串，它用来识别你在应用内贩卖的每件商品。App Store用产品标识符来检索产品信息，标识符只能包含大小写字母（A-Z）、数字（0-9）、下划线（-）、以及圆点(.)。你可以任意排列这些元素，但我们建议你创建标识符时使用
  • 负载均衡器技术Nginx和F5的优缺点对比 bijian1013 nginxF5
            对于数据流量过大的网络中，往往单一设备无法承担，需要多台设备进行数据分流，而负载均衡器就是用来将数据分流到多台设备的一个转发器。         目前有许多不同的负载均衡技术用以满足不同的应用需求，如软/硬件负载均衡、本地/全局负载均衡、更高
  • LeetCode[Math] - #9 Palindrome Number Cwind javaAlgorithm题解LeetCodeMath
    原题链接：#9 Palindrome Number   要求： 判断一个整数是否是回文数，不要使用额外的存储空间   难度：简单   分析： 题目限制不允许使用额外的存储空间应指不允许使用O(n)的内存空间，O(1)的内存用于存储中间结果是可以接受的。于是考虑将该整型数反转，然后与原数字进行比较。 注：没有看到有关负数是否可以是回文数的明确结论，例如
  • 画图板的基本实现 15700786134 画图板
     要实现画图板的基本功能，除了在qq登陆界面中用到的组件和方法外，还需要添加鼠标监听器，和接口实现。 首先，需要显示一个JFrame界面： public class DrameFrame extends JFrame {              //显示
  • linux的ps命令 被触发 linux
    Linux中的ps命令是Process Status的缩写。ps命令用来列出系统中当前运行的那些进程。ps命令列出的是当前那些进程的快照，就是执行ps命令的那个时刻的那些进程，如果想要动态的显示进程信息，就可以使用top命令。 要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps 命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行
  • Android 音乐播放器 下一曲 连续跳几首歌 肆无忌惮_ android
    最近在写安卓音乐播放器的时候遇到个问题。在MediaPlayer播放结束时会回调 player.setOnCompletionListener(new OnCompletionListener() { @Override public void onCompletion(MediaPlayer mp) { mp.reset(); Log.i("H
  • java导出txt文件的例子 知了ing javaservlet
    代码很简单就一个servlet,如下： package com.eastcom.servlet; import java.io.BufferedOutputStream; import java.io.IOException; import java.net.URLEncoder; import java.sql.Connection; import java.sql.Resu
  • Scala stack试玩, 提高第三方依赖下载速度 矮蛋蛋 scalasbt
    原文地址： http://segmentfault.com/a/1190000002894524 sbt下载速度实在是惨不忍睹, 需要做些配置优化 下载typesafe离线包, 保存为ivy本地库 wget http://downloads.typesafe.com/typesafe-activator/1.3.4/typesafe-activator-1.3.4.zip 解压r
  • phantomjs安装(linux，附带环境变量设置) ，以及casperjs安装。 alleni123 linuxspider
    1. 首先从官网 http://phantomjs.org/下载phantomjs压缩包，解压缩到/root/phantomjs文件夹。 2. 安装依赖 sudo yum install fontconfig freetype libfreetype.so.6 libfontconfig.so.1 libstdc++.so.6 3. 配置环境变量 vi /etc/profil
  • JAVA IO FileInputStream和FileOutputStream，字节流的打包输出 百合不是茶 java核心思想JAVA IO操作字节流
    在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流 1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流   类 FileInputStream
  • Spring基础实例（依赖注入和控制反转） bijian1013 spring
    前提条件：在http://www.springsource.org/download网站上下载Spring框架，并将spring.jar、log4j-1.2.15.jar、commons-logging.jar加载至工程1.武器接口 package com.bijian.spring.base3; public interface Weapon { void kil
  • HR看重的十大技能 bijian1013 提升能力HR成长
        一个人掌握何种技能取决于他的兴趣、能力和聪明程度，也取决于他所能支配的资源以及制定的事业目标，拥有过硬技能的人有更多的工作机会。但是，由于经济发展前景不确定，掌握对你的事业有所帮助的技能显得尤为重要。以下是最受雇主欢迎的十种技能。 　　一、解决问题的能力 　　每天，我们都要在生活和工作中解决一些综合性的问题。那些能够发现问题、解决问题并迅速作出有效决
  • 【Thrift一】Thrift编译安装 bit1129 thrift
    什么是Thrift The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and s
  • 【Avro三】Hadoop MapReduce读写Avro文件 bit1129 mapreduce
    Avro是Doug Cutting(此人绝对是神一般的存在）牵头开发的。 开发之初就是围绕着完善Hadoop生态系统的数据处理而开展的（使用Avro作为Hadoop MapReduce需要处理数据序列化和反序列化的场景）,因此Hadoop MapReduce集成Avro也就是自然而然的事情。 这个例子是一个简单的Hadoop MapReduce读取Avro格式的源文件进行计数统计，然后将计算结果
  • nginx定制500，502，503，504页面 ronin47 nginx　错误显示
    server { listen 80; error_page 500/500.html; error_page 502/502.html; error_page 503/503.html; error_page 504/504.html; location /test {return502;}} 配置很简单，和配
  • java-1.二叉查找树转为双向链表 bylijinnan 二叉查找树
    import java.util.ArrayList; import java.util.List; public class BSTreeToLinkedList { /* 把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \
  • Netty源码学习-HTTP-tunnel bylijinnan javanetty
    Netty关于HTTP tunnel的说明： http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/socket/http/package-summary.html#package_description 这个说明有点太简略了 一个完整的例子在这里： https://github.com/bylijinnan
  • JSONUtil.serialize(map)和JSON.toJSONString(map)的区别 coder_xpf jqueryjsonmapval()
     JSONUtil.serialize(map)和JSON.toJSONString(map)的区别   数据库查询出来的map有一个字段为空   通过System.out.println()输出 JSONUtil.serialize(map)： {"one":"1","two":"nul
  • Hibernate缓存总结 cuishikuan 开源sshjavawebhibernate缓存三大框架
    一、为什么要用Hibernate缓存？ Hibernate是一个持久层框架，经常访问物理数据库。 为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。 缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。   二、Hibernate缓存原理是怎样的？ Hibernate缓存包括两大类：Hib
  • CentOs6 dalan_123 centos
    首先su - 切换到root下面1、首先要先安装GCC GCC-C++ Openssl等以来模块：yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel2、再安装ncurses模块yum -y install ncurses-develyum install ncurses-devel3、下载Erang
  • 10款用 jquery 实现滚动条至页面底端自动加载数据效果 dcj3sjt126com JavaScript
      无限滚动自动翻页可以说是web2.0时代的一项堪称伟大的技术，它让我们在浏览页面的时候只需要把滚动条拉到网页底部就能自动显示下一页的结果，改变了一直以来只能通过点击下一页来翻页这种常规做法。 无限滚动自动翻页技术的鼻祖是微博的先驱：推特(twitter)，后来必应图片搜索、谷歌图片搜索、google reader、箱包批发网等纷纷抄袭了这一项技术，于是靠滚动浏览器滚动条
  • ImageButton去边框&Button或者ImageButton的背景透明 dcj3sjt126com imagebutton
    在ImageButton中载入图片后，很多人会觉得有图片周围的白边会影响到美观，其实解决这个问题有两种方法 一种方法是将ImageButton的背景改为所需要的图片。如：android:background="@drawable/XXX" 第二种方法就是将ImageButton背景改为透明，这个方法更常用 在XML里；    <ImageBut
  • JSP之c:foreach eksliang jspforearch
    原文出自：http://www.cnblogs.com/draem0507/archive/2012/09/24/2699745.html <c:forEach>标签用于通用数据循环，它有以下属性 属 性 描 述 是否必须 缺省值 items 进行循环的项目 否 无 begin 开始条件 否 0 end 结束条件 否 集合中的最后一个项目 step 步长 否 1
  • Android实现主动连接蓝牙耳机 gqdy365 android
    在Android程序中可以实现自动扫描蓝牙、配对蓝牙、建立数据通道。蓝牙分不同类型，这篇文字只讨论如何与蓝牙耳机连接。 大致可以分三步： 一、扫描蓝牙设备： 1、注册并监听广播： BluetoothAdapter.ACTION_DISCOVERY_STARTED BluetoothDevice.ACTION_FOUND BluetoothAdapter.ACTION_DIS
  • android学习轨迹之四：org.json.JSONException: No value for hyz301 json
    org.json.JSONException: No value for items  在JSON解析中会遇到一种错误，很常见的错误   06-21 12:19:08.714 2098-2127/com.jikexueyuan.secret I/System.out﹕ Result:{"status":1,"page":1,&
  • 干货分享：从零开始学编程 系列汇总 justjavac 编程
    程序员总爱重新发明轮子，于是做了要给轮子汇总。 从零开始写个编译器吧系列 (知乎专栏) 从零开始写一个简单的操作系统 (伯乐在线) 从零开始写JavaScript框架 (图灵社区) 从零开始写jQuery框架 (蓝色理想 ) 从零开始nodejs系列文章 (粉丝日志) 从零开始编写网络游戏 
  • jquery-autocomplete 使用手册 macroli jqueryAjax脚本
    jquery-autocomplete学习 一、用前必备 官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/ 当前版本：1.1 需要JQuery版本：1.2.6 二、使用 <script src="./jquery-1.3.2.js" type="text/ja
  • PLSQL-Developer或者Navicat等工具连接远程oracle数据库的详细配置以及数据库编码的修改 超声波 oracleplsql
    　　在服务器上将Oracle安装好之后接下来要做的就是通过本地机器来远程连接服务器端的oracle数据库，常用的客户端连接工具就是PLSQL-Developer或者Navicat这些工具了。刚开始也是各种报错，什么TNS:no listener;TNS:lost connection;TNS:target hosts...花了一天的时间终于让PLSQL-Developer和Navicat等这些客户
  • 数据仓库数据模型之：极限存储--历史拉链表 superlxw1234 极限存储数据仓库数据模型拉链历史表
    在数据仓库的数据模型设计过程中，经常会遇到这样的需求： 1. 数据量比较大; 2. 表中的部分字段会被update,如用户的地址，产品的描述信息，订单的状态等等; 3. 需要查看某一个时间点或者时间段的历史快照信息，比如，查看某一个订单在历史某一个时间点的状态，    比如，查看某一个用户在过去某一段时间内，更新过几次等等; 4. 变化的比例和频率不是很大，比如，总共有10
  • 10点睛Spring MVC4.1-全局异常处理 wiselyman spring mvc
    10.1 全局异常处理 使用@ControllerAdvice注解来实现全局异常处理; 使用@ControllerAdvice的属性缩小处理范围 10.2 演示 演示控制器 package com.wisely.web; import org.springframework.stereotype.Controller; import org.spring
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他