kkk584520

Caffe代码导读（5）：对数据集进行Testing

上一篇介绍了如何准备数据集，做好准备之后我们先看怎样对训练好的模型进行Testing。

先用手写体识别例子，MNIST是数据集（包括训练数据和测试数据），深度学习模型采用LeNet（具体介绍见http://yann.lecun.com/exdb/lenet/），由Yann LeCun教授提出。

如果你编译好了Caffe，那么在CAFFE_ROOT下运行如下命令：

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

就可以实现Testing。参数说明如下：

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

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

name: "LeNet"
layers {
  name: "mnist"
  type: DATA
  top: "data"
  top: "label"
  data_param {
    source: "examples/mnist/mnist_train_lmdb"
    backend: LMDB
    batch_size: 64
  }
  transform_param {
    scale: 0.00390625
  }
  include: { phase: TRAIN }
}
layers {
  name: "mnist"
  type: DATA
  top: "data"
  top: "label"
  data_param {
    source: "examples/mnist/mnist_test_lmdb"
    backend: LMDB
    batch_size: 100
  }
  transform_param {
    scale: 0.00390625
  }
  include: { phase: TEST }
}

layers {
  name: "conv1"
  type: CONVOLUTION
  bottom: "data"
  top: "conv1"
  blobs_lr: 1
  blobs_lr: 2
  convolution_param {
    num_output: 20
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  name: "pool1"
  type: POOLING
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  name: "conv2"
  type: CONVOLUTION
  bottom: "pool1"
  top: "conv2"
  blobs_lr: 1
  blobs_lr: 2
  convolution_param {
    num_output: 50
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  name: "pool2"
  type: POOLING
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  name: "ip1"
  type: INNER_PRODUCT
  bottom: "pool2"
  top: "ip1"
  blobs_lr: 1
  blobs_lr: 2
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  name: "relu1"
  type: RELU
  bottom: "ip1"
  top: "ip1"
}
layers {
  name: "ip2"
  type: INNER_PRODUCT
  bottom: "ip1"
  top: "ip2"
  blobs_lr: 1
  blobs_lr: 2
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  name: "accuracy"
  type: ACCURACY
  bottom: "ip2"
  bottom: "label"
  top: "accuracy"
  include: { phase: TEST }
}
layers {
  name: "loss"
  type: SOFTMAX_LOSS
  bottom: "ip2"
  bottom: "label"
  top: "loss"
}

里面定义的网络结构如下图所示：

-weights=XXX：指定训练好的caffemodel二进制文件。如果你手头没有训练好的可以下载这个（http://download.csdn.net/detail/kkk584520/8219443）。

-gpu=0：指定在GPU上运行，GPUID=0。如果你没有GPU就去掉这个参数，默认在CPU上运行。

运行输出如下：

I1203 18:47:00.073052  4610 caffe.cpp:134] Use GPU with device ID 0
I1203 18:47:00.367065  4610 net.cpp:275] The NetState phase (1) differed from the phase (0) specified by a rule in layer mnist
I1203 18:47:00.367269  4610 net.cpp:39] Initializing net from parameters: 
name: "LeNet"
layers {
  top: "data"
  top: "label"
  name: "mnist"
  type: DATA
  data_param {
    source: "examples/mnist/mnist_test_lmdb"
    batch_size: 100
    backend: LMDB
  }
  include {
    phase: TEST
  }
  transform_param {
    scale: 0.00390625
  }
}
layers {
  bottom: "data"
  top: "conv1"
  name: "conv1"
  type: CONVOLUTION
  blobs_lr: 1
  blobs_lr: 2
  convolution_param {
    num_output: 20
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  bottom: "conv1"
  top: "pool1"
  name: "pool1"
  type: POOLING
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  bottom: "pool1"
  top: "conv2"
  name: "conv2"
  type: CONVOLUTION
  blobs_lr: 1
  blobs_lr: 2
  convolution_param {
    num_output: 50
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  bottom: "conv2"
  top: "pool2"
  name: "pool2"
  type: POOLING
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  bottom: "pool2"
  top: "ip1"
  name: "ip1"
  type: INNER_PRODUCT
  blobs_lr: 1
  blobs_lr: 2
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  bottom: "ip1"
  top: "ip1"
  name: "relu1"
  type: RELU
}
layers {
  bottom: "ip1"
  top: "ip2"
  name: "ip2"
  type: INNER_PRODUCT
  blobs_lr: 1
  blobs_lr: 2
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  bottom: "ip2"
  bottom: "label"
  top: "accuracy"
  name: "accuracy"
  type: ACCURACY
  include {
    phase: TEST
  }
}
layers {
  bottom: "ip2"
  bottom: "label"
  top: "loss"
  name: "loss"
  type: SOFTMAX_LOSS
}
I1203 18:47:00.367391  4610 net.cpp:67] Creating Layer mnist
I1203 18:47:00.367409  4610 net.cpp:356] mnist -> data
I1203 18:47:00.367435  4610 net.cpp:356] mnist -> label
I1203 18:47:00.367451  4610 net.cpp:96] Setting up mnist
I1203 18:47:00.367571  4610 data_layer.cpp:68] Opening lmdb examples/mnist/mnist_test_lmdb
I1203 18:47:00.367609  4610 data_layer.cpp:128] output data size: 100,1,28,28
I1203 18:47:00.367832  4610 net.cpp:103] Top shape: 100 1 28 28 (78400)
I1203 18:47:00.367849  4610 net.cpp:103] Top shape: 100 1 1 1 (100)
I1203 18:47:00.367863  4610 net.cpp:67] Creating Layer label_mnist_1_split
I1203 18:47:00.367873  4610 net.cpp:394] label_mnist_1_split <- label
I1203 18:47:00.367892  4610 net.cpp:356] label_mnist_1_split -> label_mnist_1_split_0
I1203 18:47:00.367908  4610 net.cpp:356] label_mnist_1_split -> label_mnist_1_split_1
I1203 18:47:00.367919  4610 net.cpp:96] Setting up label_mnist_1_split
I1203 18:47:00.367929  4610 net.cpp:103] Top shape: 100 1 1 1 (100)
I1203 18:47:00.367938  4610 net.cpp:103] Top shape: 100 1 1 1 (100)
I1203 18:47:00.367950  4610 net.cpp:67] Creating Layer conv1
I1203 18:47:00.367959  4610 net.cpp:394] conv1 <- data
I1203 18:47:00.367969  4610 net.cpp:356] conv1 -> conv1
I1203 18:47:00.367982  4610 net.cpp:96] Setting up conv1
I1203 18:47:00.392133  4610 net.cpp:103] Top shape: 100 20 24 24 (1152000)
I1203 18:47:00.392204  4610 net.cpp:67] Creating Layer pool1
I1203 18:47:00.392217  4610 net.cpp:394] pool1 <- conv1
I1203 18:47:00.392231  4610 net.cpp:356] pool1 -> pool1
I1203 18:47:00.392247  4610 net.cpp:96] Setting up pool1
I1203 18:47:00.392273  4610 net.cpp:103] Top shape: 100 20 12 12 (288000)
I1203 18:47:00.392297  4610 net.cpp:67] Creating Layer conv2
I1203 18:47:00.392307  4610 net.cpp:394] conv2 <- pool1
I1203 18:47:00.392318  4610 net.cpp:356] conv2 -> conv2
I1203 18:47:00.392330  4610 net.cpp:96] Setting up conv2
I1203 18:47:00.392669  4610 net.cpp:103] Top shape: 100 50 8 8 (320000)
I1203 18:47:00.392729  4610 net.cpp:67] Creating Layer pool2
I1203 18:47:00.392756  4610 net.cpp:394] pool2 <- conv2
I1203 18:47:00.392768  4610 net.cpp:356] pool2 -> pool2
I1203 18:47:00.392781  4610 net.cpp:96] Setting up pool2
I1203 18:47:00.392793  4610 net.cpp:103] Top shape: 100 50 4 4 (80000)
I1203 18:47:00.392810  4610 net.cpp:67] Creating Layer ip1
I1203 18:47:00.392819  4610 net.cpp:394] ip1 <- pool2
I1203 18:47:00.392832  4610 net.cpp:356] ip1 -> ip1
I1203 18:47:00.392844  4610 net.cpp:96] Setting up ip1
I1203 18:47:00.397348  4610 net.cpp:103] Top shape: 100 500 1 1 (50000)
I1203 18:47:00.397372  4610 net.cpp:67] Creating Layer relu1
I1203 18:47:00.397382  4610 net.cpp:394] relu1 <- ip1
I1203 18:47:00.397394  4610 net.cpp:345] relu1 -> ip1 (in-place)
I1203 18:47:00.397407  4610 net.cpp:96] Setting up relu1
I1203 18:47:00.397420  4610 net.cpp:103] Top shape: 100 500 1 1 (50000)
I1203 18:47:00.397434  4610 net.cpp:67] Creating Layer ip2
I1203 18:47:00.397442  4610 net.cpp:394] ip2 <- ip1
I1203 18:47:00.397456  4610 net.cpp:356] ip2 -> ip2
I1203 18:47:00.397469  4610 net.cpp:96] Setting up ip2
I1203 18:47:00.397532  4610 net.cpp:103] Top shape: 100 10 1 1 (1000)
I1203 18:47:00.397547  4610 net.cpp:67] Creating Layer ip2_ip2_0_split
I1203 18:47:00.397557  4610 net.cpp:394] ip2_ip2_0_split <- ip2
I1203 18:47:00.397565  4610 net.cpp:356] ip2_ip2_0_split -> ip2_ip2_0_split_0
I1203 18:47:00.397583  4610 net.cpp:356] ip2_ip2_0_split -> ip2_ip2_0_split_1
I1203 18:47:00.397593  4610 net.cpp:96] Setting up ip2_ip2_0_split
I1203 18:47:00.397603  4610 net.cpp:103] Top shape: 100 10 1 1 (1000)
I1203 18:47:00.397611  4610 net.cpp:103] Top shape: 100 10 1 1 (1000)
I1203 18:47:00.397622  4610 net.cpp:67] Creating Layer accuracy
I1203 18:47:00.397631  4610 net.cpp:394] accuracy <- ip2_ip2_0_split_0
I1203 18:47:00.397640  4610 net.cpp:394] accuracy <- label_mnist_1_split_0
I1203 18:47:00.397650  4610 net.cpp:356] accuracy -> accuracy
I1203 18:47:00.397661  4610 net.cpp:96] Setting up accuracy
I1203 18:47:00.397673  4610 net.cpp:103] Top shape: 1 1 1 1 (1)
I1203 18:47:00.397687  4610 net.cpp:67] Creating Layer loss
I1203 18:47:00.397696  4610 net.cpp:394] loss <- ip2_ip2_0_split_1
I1203 18:47:00.397706  4610 net.cpp:394] loss <- label_mnist_1_split_1
I1203 18:47:00.397714  4610 net.cpp:356] loss -> loss
I1203 18:47:00.397725  4610 net.cpp:96] Setting up loss
I1203 18:47:00.397737  4610 net.cpp:103] Top shape: 1 1 1 1 (1)
I1203 18:47:00.397745  4610 net.cpp:109]     with loss weight 1
I1203 18:47:00.397776  4610 net.cpp:170] loss needs backward computation.
I1203 18:47:00.397785  4610 net.cpp:172] accuracy does not need backward computation.
I1203 18:47:00.397794  4610 net.cpp:170] ip2_ip2_0_split needs backward computation.
I1203 18:47:00.397801  4610 net.cpp:170] ip2 needs backward computation.
I1203 18:47:00.397809  4610 net.cpp:170] relu1 needs backward computation.
I1203 18:47:00.397816  4610 net.cpp:170] ip1 needs backward computation.
I1203 18:47:00.397825  4610 net.cpp:170] pool2 needs backward computation.
I1203 18:47:00.397832  4610 net.cpp:170] conv2 needs backward computation.
I1203 18:47:00.397843  4610 net.cpp:170] pool1 needs backward computation.
I1203 18:47:00.397851  4610 net.cpp:170] conv1 needs backward computation.
I1203 18:47:00.397860  4610 net.cpp:172] label_mnist_1_split does not need backward computation.
I1203 18:47:00.397867  4610 net.cpp:172] mnist does not need backward computation.
I1203 18:47:00.397874  4610 net.cpp:208] This network produces output accuracy
I1203 18:47:00.397884  4610 net.cpp:208] This network produces output loss
I1203 18:47:00.397905  4610 net.cpp:467] Collecting Learning Rate and Weight Decay.
I1203 18:47:00.397915  4610 net.cpp:219] Network initialization done.
I1203 18:47:00.397923  4610 net.cpp:220] Memory required for data: 8086808
I1203 18:47:00.432165  4610 caffe.cpp:145] Running for 50 iterations.
I1203 18:47:00.435849  4610 caffe.cpp:169] Batch 0, accuracy = 0.99
I1203 18:47:00.435879  4610 caffe.cpp:169] Batch 0, loss = 0.018971
I1203 18:47:00.437434  4610 caffe.cpp:169] Batch 1, accuracy = 0.99
I1203 18:47:00.437471  4610 caffe.cpp:169] Batch 1, loss = 0.0117609
I1203 18:47:00.439000  4610 caffe.cpp:169] Batch 2, accuracy = 1
I1203 18:47:00.439020  4610 caffe.cpp:169] Batch 2, loss = 0.00555977
I1203 18:47:00.440551  4610 caffe.cpp:169] Batch 3, accuracy = 0.99
I1203 18:47:00.440575  4610 caffe.cpp:169] Batch 3, loss = 0.0412139
I1203 18:47:00.442105  4610 caffe.cpp:169] Batch 4, accuracy = 0.99
I1203 18:47:00.442126  4610 caffe.cpp:169] Batch 4, loss = 0.0579313
I1203 18:47:00.443619  4610 caffe.cpp:169] Batch 5, accuracy = 0.99
I1203 18:47:00.443639  4610 caffe.cpp:169] Batch 5, loss = 0.0479742
I1203 18:47:00.445159  4610 caffe.cpp:169] Batch 6, accuracy = 0.98
I1203 18:47:00.445179  4610 caffe.cpp:169] Batch 6, loss = 0.0570176
I1203 18:47:00.446712  4610 caffe.cpp:169] Batch 7, accuracy = 0.99
I1203 18:47:00.446732  4610 caffe.cpp:169] Batch 7, loss = 0.0272363
I1203 18:47:00.448249  4610 caffe.cpp:169] Batch 8, accuracy = 1
I1203 18:47:00.448269  4610 caffe.cpp:169] Batch 8, loss = 0.00680142
I1203 18:47:00.449801  4610 caffe.cpp:169] Batch 9, accuracy = 0.98
I1203 18:47:00.449821  4610 caffe.cpp:169] Batch 9, loss = 0.0288398
I1203 18:47:00.451352  4610 caffe.cpp:169] Batch 10, accuracy = 0.98
I1203 18:47:00.451372  4610 caffe.cpp:169] Batch 10, loss = 0.0603264
I1203 18:47:00.452883  4610 caffe.cpp:169] Batch 11, accuracy = 0.98
I1203 18:47:00.452903  4610 caffe.cpp:169] Batch 11, loss = 0.0524943
I1203 18:47:00.454407  4610 caffe.cpp:169] Batch 12, accuracy = 0.95
I1203 18:47:00.454427  4610 caffe.cpp:169] Batch 12, loss = 0.106648
I1203 18:47:00.455955  4610 caffe.cpp:169] Batch 13, accuracy = 0.98
I1203 18:47:00.455976  4610 caffe.cpp:169] Batch 13, loss = 0.0450225
I1203 18:47:00.457484  4610 caffe.cpp:169] Batch 14, accuracy = 1
I1203 18:47:00.457504  4610 caffe.cpp:169] Batch 14, loss = 0.00531614
I1203 18:47:00.459038  4610 caffe.cpp:169] Batch 15, accuracy = 0.98
I1203 18:47:00.459056  4610 caffe.cpp:169] Batch 15, loss = 0.065209
I1203 18:47:00.460577  4610 caffe.cpp:169] Batch 16, accuracy = 0.98
I1203 18:47:00.460597  4610 caffe.cpp:169] Batch 16, loss = 0.0520317
I1203 18:47:00.462123  4610 caffe.cpp:169] Batch 17, accuracy = 0.99
I1203 18:47:00.462143  4610 caffe.cpp:169] Batch 17, loss = 0.0328681
I1203 18:47:00.463656  4610 caffe.cpp:169] Batch 18, accuracy = 0.99
I1203 18:47:00.463676  4610 caffe.cpp:169] Batch 18, loss = 0.0175973
I1203 18:47:00.465188  4610 caffe.cpp:169] Batch 19, accuracy = 0.97
I1203 18:47:00.465208  4610 caffe.cpp:169] Batch 19, loss = 0.0576884
I1203 18:47:00.466749  4610 caffe.cpp:169] Batch 20, accuracy = 0.97
I1203 18:47:00.466769  4610 caffe.cpp:169] Batch 20, loss = 0.0850501
I1203 18:47:00.468278  4610 caffe.cpp:169] Batch 21, accuracy = 0.98
I1203 18:47:00.468298  4610 caffe.cpp:169] Batch 21, loss = 0.0676049
I1203 18:47:00.469805  4610 caffe.cpp:169] Batch 22, accuracy = 0.99
I1203 18:47:00.469825  4610 caffe.cpp:169] Batch 22, loss = 0.0448538
I1203 18:47:00.471328  4610 caffe.cpp:169] Batch 23, accuracy = 0.97
I1203 18:47:00.471349  4610 caffe.cpp:169] Batch 23, loss = 0.0333992
I1203 18:47:00.487124  4610 caffe.cpp:169] Batch 24, accuracy = 1
I1203 18:47:00.487180  4610 caffe.cpp:169] Batch 24, loss = 0.0281527
I1203 18:47:00.489002  4610 caffe.cpp:169] Batch 25, accuracy = 0.99
I1203 18:47:00.489048  4610 caffe.cpp:169] Batch 25, loss = 0.0545881
I1203 18:47:00.490890  4610 caffe.cpp:169] Batch 26, accuracy = 0.98
I1203 18:47:00.490932  4610 caffe.cpp:169] Batch 26, loss = 0.115576
I1203 18:47:00.492620  4610 caffe.cpp:169] Batch 27, accuracy = 1
I1203 18:47:00.492640  4610 caffe.cpp:169] Batch 27, loss = 0.0149555
I1203 18:47:00.494161  4610 caffe.cpp:169] Batch 28, accuracy = 0.98
I1203 18:47:00.494181  4610 caffe.cpp:169] Batch 28, loss = 0.0398991
I1203 18:47:00.495693  4610 caffe.cpp:169] Batch 29, accuracy = 0.96
I1203 18:47:00.495713  4610 caffe.cpp:169] Batch 29, loss = 0.115862
I1203 18:47:00.497226  4610 caffe.cpp:169] Batch 30, accuracy = 1
I1203 18:47:00.497246  4610 caffe.cpp:169] Batch 30, loss = 0.0116793
I1203 18:47:00.498785  4610 caffe.cpp:169] Batch 31, accuracy = 1
I1203 18:47:00.498817  4610 caffe.cpp:169] Batch 31, loss = 0.00451814
I1203 18:47:00.500329  4610 caffe.cpp:169] Batch 32, accuracy = 0.98
I1203 18:47:00.500349  4610 caffe.cpp:169] Batch 32, loss = 0.0244668
I1203 18:47:00.501878  4610 caffe.cpp:169] Batch 33, accuracy = 1
I1203 18:47:00.501899  4610 caffe.cpp:169] Batch 33, loss = 0.00285445
I1203 18:47:00.503411  4610 caffe.cpp:169] Batch 34, accuracy = 0.98
I1203 18:47:00.503429  4610 caffe.cpp:169] Batch 34, loss = 0.0566256
I1203 18:47:00.504940  4610 caffe.cpp:169] Batch 35, accuracy = 0.95
I1203 18:47:00.504961  4610 caffe.cpp:169] Batch 35, loss = 0.154924
I1203 18:47:00.506500  4610 caffe.cpp:169] Batch 36, accuracy = 1
I1203 18:47:00.506520  4610 caffe.cpp:169] Batch 36, loss = 0.00451233
I1203 18:47:00.508111  4610 caffe.cpp:169] Batch 37, accuracy = 0.97
I1203 18:47:00.508131  4610 caffe.cpp:169] Batch 37, loss = 0.0572309
I1203 18:47:00.509635  4610 caffe.cpp:169] Batch 38, accuracy = 0.99
I1203 18:47:00.509655  4610 caffe.cpp:169] Batch 38, loss = 0.0192229
I1203 18:47:00.511181  4610 caffe.cpp:169] Batch 39, accuracy = 0.99
I1203 18:47:00.511200  4610 caffe.cpp:169] Batch 39, loss = 0.029272
I1203 18:47:00.512725  4610 caffe.cpp:169] Batch 40, accuracy = 0.99
I1203 18:47:00.512745  4610 caffe.cpp:169] Batch 40, loss = 0.0258552
I1203 18:47:00.514317  4610 caffe.cpp:169] Batch 41, accuracy = 0.99
I1203 18:47:00.514338  4610 caffe.cpp:169] Batch 41, loss = 0.0752082
I1203 18:47:00.515854  4610 caffe.cpp:169] Batch 42, accuracy = 1
I1203 18:47:00.515873  4610 caffe.cpp:169] Batch 42, loss = 0.0283319
I1203 18:47:00.517379  4610 caffe.cpp:169] Batch 43, accuracy = 0.99
I1203 18:47:00.517398  4610 caffe.cpp:169] Batch 43, loss = 0.0112394
I1203 18:47:00.518925  4610 caffe.cpp:169] Batch 44, accuracy = 0.98
I1203 18:47:00.518946  4610 caffe.cpp:169] Batch 44, loss = 0.0413653
I1203 18:47:00.520457  4610 caffe.cpp:169] Batch 45, accuracy = 0.98
I1203 18:47:00.520478  4610 caffe.cpp:169] Batch 45, loss = 0.0501227
I1203 18:47:00.521989  4610 caffe.cpp:169] Batch 46, accuracy = 1
I1203 18:47:00.522009  4610 caffe.cpp:169] Batch 46, loss = 0.0114459
I1203 18:47:00.523540  4610 caffe.cpp:169] Batch 47, accuracy = 1
I1203 18:47:00.523561  4610 caffe.cpp:169] Batch 47, loss = 0.0163504
I1203 18:47:00.525075  4610 caffe.cpp:169] Batch 48, accuracy = 0.97
I1203 18:47:00.525095  4610 caffe.cpp:169] Batch 48, loss = 0.0450363
I1203 18:47:00.526633  4610 caffe.cpp:169] Batch 49, accuracy = 1
I1203 18:47:00.526651  4610 caffe.cpp:169] Batch 49, loss = 0.0046898
I1203 18:47:00.526662  4610 caffe.cpp:174] Loss: 0.041468
I1203 18:47:00.526674  4610 caffe.cpp:186] accuracy = 0.9856
I1203 18:47:00.526687  4610 caffe.cpp:186] loss = 0.041468 (* 1 = 0.041468 loss)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
100天持续行动—Day01 Richard_DL
今天开始站着学习，发现效率大幅提升。把fast.ai的Lesson1的后半部分和Lesson2看完了。由于Keras版本和视频中的不一致，运行notebook时经常出现莫名其妙的错误，导致自己只动手实践了视频中的一小部分内容。为了赶时间，我打算先把与CNN相关的视频过一遍。然后尽快开始做自己的项目。明天继续加油，争取把Lesson3和Lesson4看完。
yolov5＞onnx＞ncnn＞apk 图像处理大大大大大牛啊 opencv实战代码讲解 yolo onnx ncnn 安卓
一.yolov5pt模型转onnx条件：colabnotebookyolov51.安装环境!pipinstallonnx>=1.7.0#forONNXexport!pipinstallcoremltools==4.0#forCoreMLexport!pipinstallonnx-simplifier2.修改common.py在classFocus下面
推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！小猪包333 写论文人工智能 AI写作深度学习计算机视觉
在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
[实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估 pytorch python 机器学习
文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
[实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用 pytorch 深度学习人工智能机器学习 python 优化器
文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
吴恩达深度学习笔记(30)-正则化的解释极客Array
正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
计算机视觉中，Pooling的作用 Wils0nEdwards 计算机视觉人工智能
在计算机视觉中，Pooling（池化）是一种常见的操作，主要用于卷积神经网络（CNN）中。它通过对特征图进行下采样，减少数据的空间维度，同时保留重要的特征信息。Pooling的作用可以归纳为以下几个方面：1.降低计算复杂度与内存需求Pooling操作通过对特征图进行下采样，减少了特征图的空间分辨率（例如，高度和宽度）。这意味着网络需要处理的数据量会减少，从而降低了计算量和内存需求。这对大型神经网络
神经网络-损失函数红米煮粥神经网络人工智能深度学习
文章目录一、回归问题的损失函数1.均方误差（MeanSquaredError,MSE）2.平均绝对误差（MeanAbsoluteError,MAE）二、分类问题的损失函数1.0-1损失函数（Zero-OneLossFunction）2.交叉熵损失（Cross-EntropyLoss）3.合页损失（HingeLoss）三、总结在神经网络中，损失函数（LossFunction）扮演着至关重要的角色，它
损失函数与反向传播 Star_. PyTorch pytorch 深度学习 python
损失函数定义与作用损失函数(lossfunction)在深度学习领域是用来计算搭建模型预测的输出值和真实值之间的误差。1.损失函数越小越好2.计算实际输出与目标之间的差距3.为更新输出提供依据（反向传播)常见的损失函数回归常见的损失函数有：均方差（MeanSquaredError，MSE）、平均绝对误差（MeanAbsoluteErrorLoss，MAE）、HuberLoss是一种将MSE与MAE
BP神经网络的传递函数大胜归来19 MATLAB
BP网络一般都是用三层的，四层及以上的都比较少用；传输函数的选择，这个怎么说，假设你想预测的结果是几个固定值，如1,0等，满足某个条件输出1，不满足则0的话，首先想到的是hardlim函数，阈值型的，当然也可以考虑其他的；然后，假如网络是用来表达某种线性关系时，用purelin---线性传输函数；若是非线性关系的话，用别的非线性传递函数，多层网络时，每层不一定要用相同的传递函数，可以是三种配合，可
探索创新科技： Lite-Mono - 简约高效的小型化Mono框架杭律沛Meris
探索创新科技：Lite-Mono-简约高效的小型化Mono框架Lite-Mono[CVPR2023]Lite-Mono:ALightweightCNNandTransformerArchitectureforSelf-SupervisedMonocularDepthEstimation项目地址:https://gitcode.com/gh_mirrors/li/Lite-Mono如果你在寻找一个轻
神经网络传递函数sigmoid,神经网络传递函数作用快乐的小荣荣神经网络机器学习深度学习人工智能
神经网络传递函数选取不同会有特别大差别嘛？只是最后一层，但前面层是非线性，那么可能存在区别不大的情况。线性函数f(a*input)=af(input),一般来说，input为向量，最简化情况下，可以假设input的各个维度，a1=a2=a3。。。意味着你线性层只是简单的对输入做了scale~而神经网络能起作用的原因，在于通过足够复杂的非线性函数，来模拟任何的分布。所以，神经网络必须要用非线性函数。
Python和R均方根误差平均绝对误差算法模型亚图跨际 Python 交叉知识 R 回归模型误差指标归一化均方根误差生态状态指标神经网络成本误差气体排放气候模型多项式拟合
要点回归模型误差评估指标归一化均方根误差生态状态指标神经网络成本误差计算气体排放气候算法模型Python误差指标均方根误差和平均绝对误差均方根偏差或均方根误差是两个密切相关且经常使用的度量值之一，用于衡量真实值或预测值与观测值或估计值之间的差异。估计器θ^\hat{\theta}θ^相对于估计参数θ\thetaθ的RMSD定义为均方误差的平方根：RMSD⁡(θ^)=MSE⁡(θ^)=E((θ^−θ
【深度学习】训练过程中一个OOM的问题，太难查了 weixin_40293999 深度学习深度学习人工智能
现象：各位大佬又遇到过ubuntu的这个问题么？现象是在训练过程中，ssh上不去了，能ping通，没死机，但是ubunutu的pc侧的显示器，鼠标啥都不好用了。只能重启。问题原因：OOM了95G，尼玛！！！！pytorch爆内存了，然后journald假死了，在journald被watchdog干掉之后，系统就崩溃了。这种规模的爆内存一般，即使被oomkill了，也要卡半天的，确实会这样，能不能配
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
机器学习VS深度学习 nfgo 机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
数据分析-24-时间序列预测之基于keras的VMD-LSTM和VMD-CNN-LSTM预测风速皮皮冰燃数据分析数据分析
文章目录1普通的LSTM模型1.1数据重采样1.2数据标准化1.3切分窗口1.4划分数据集1.5建立模型1.6预测效果2VMD-LSTM模型2.1VMD分解时间序列2.2对每一个IMF建立LSTM模型2.2.1IMF1—LSTM2.2.2IMF2-LSTM2.2.3统一代码2.3评估效果3CNN-LSTM模型3.1数据预处理3.2建立模型3.3效果预测4VMD-CNN-LSTM模型4.1VMD分解
大数据毕业设计hadoop+spark+hive知识图谱租房数据分析可视化大屏租房推荐系统 58同城租房爬虫房源推荐系统房价预测系统计算机毕业设计机器学习深度学习人工智能 2401_84572577 程序员大数据 hadoop 人工智能
做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。我先来介绍一下这些东西怎么用，文末抱走。（1）Python所有方向的学习路线（
深度学习-13-小语言模型之SmolLM的使用皮皮冰燃深度学习深度学习
文章附录1SmolLM概述1.1SmolLM简介1.2下载模型2运行2.1在CPU/GPU/多GPU上运行模型2.2使用torch.bfloat162.3通过位和字节的量化版本3应用示例4问题及解决4.1attention_mask和pad_token_id报错4.2max_new_tokens=205参考附录1SmolLM概述1.1SmolLM简介SmolLM是一系列尖端小型语言模型，提供三种规
【NLP5-RNN模型、LSTM模型和GRU模型】一蓑烟雨紫洛 nlp rnn lstm gru nlp
RNN模型、LSTM模型和GRU模型1、什么是RNN模型RNN（RecurrentNeuralNetwork)中文称为循环神经网络，它一般以序列数据为输入，通过网络内部的结构设计有效捕捉序列之间的关系特征，一般也是以序列形式进行输出RNN的循环机制使模型隐层上一时间步产生的结果，能够作为当下时间步输入的一部分（当下时间步的输入除了正常的输入外还包括上一步的隐层输出）对当下时间步的输出产生影响2、R
基于深度学习的农作物病害检测 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的农作物病害检测利用卷积神经网络（CNN）、生成对抗网络（GAN）、Transformer等深度学习技术，自动识别和分类农作物的病害，帮助农业工作者提高作物管理效率、减少损失。1.农作物病害检测的挑战病害种类繁多：农作物病害的类型多样，不同病害在同一作物上的表现差异很大，同时同一种病害在不同生长阶段的症状也可能不同。环境影响：天气、光照、湿度等外部环境因素会影响农作物的表现，使得病害检
基于深度学习的文本引导的图像编辑 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的文本引导的图像编辑（Text-GuidedImageEditing）是一种通过自然语言文本指令对图像进行编辑或修改的技术。它结合了图像生成和自然语言处理（NLP）的最新进展，使用户能够通过描述性文本对图像内容进行精确的调整和操控。1.文本引导的图像编辑的挑战文本和图像之间的对齐：如何将文本中的语义信息准确地映射到图像中的特定区域或元素是一个关键挑战。这涉及到多模态数据的对齐和理解。编
深度学习--对抗生成网络（GAN, Generative Adversarial Network） Ambition_LAO 深度学习生成对抗网络
对抗生成网络（GAN,GenerativeAdversarialNetwork）是一种深度学习模型，由IanGoodfellow等人在2014年提出。GAN主要用于生成数据，通过两个神经网络相互对抗，来生成以假乱真的新数据。以下是对GAN的详细阐述，包括其概念、作用、核心要点、实现过程、代码实现和适用场景。1.概念GAN由两个神经网络组成：生成器（Generator）和判别器（Discrimina
继之前的线程循环加到窗口中运行 3213213333332132 java thread JFrame JPanel
之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 package thread; import java.awt.Graphics; import java.text.SimpleDateFormat; import java.util
linux 常用命令 BlueSkator linux 命令
1.grep 相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。但之前总是习惯于使用（grep -n 关键字文件名）查出关键字以及该关键字所在的行数，然后再用（sed -n '100,200p' 文件名），去查出该关键字之后的日志内容。但其实还有更简便的办法，就是用（grep -B n、-A n、-C n 关键
php heredoc原文档和nowdoc语法 dcj3sjt126com PHP heredoc nowdoc
<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body> <?
overflow的属性周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
《我所了解的Java》——总体目录 g21121 java
准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。 &n
[简单]docx4j常用方法小结 53873039oycg docx
本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下: import java.io.File; import java.io.FileInputStream; import ja
Spring配置学习云端月影 spring配置
首先来看一个标准的Spring配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=&q
Java新手入门的30个基本概念三 aijuans java 新手 java 入门
17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
《2008 IBM Rational 软件开发高峰论坛会议》小记 antonyup_2006 软件测试敏捷开发项目管理 IBM 活动
我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
PL/SQL的过程编程,异常,声明变量,PL/SQL块百合不是茶 PL/SQL的过程编程异常 PL/SQL块声明变量
PL/SQL; 过程; 符号; 变量; PL/SQL块; 输出; 异常; PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
Mockito(三)--完整功能介绍 bijian1013 持续集成 mockito 单元测试
mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。一.使用mockito验证行为 //首先要import Mockito import static org.mockito.Mockito.*; //mo
精通Oracle10编程SQL(8)使用复合数据类型 bijian1013 oracle 数据库 plsql
/* *使用复合数据类型 */ --PL/SQL记录 --定义PL/SQL记录 --自定义PL/SQL记录 DECLARE TYPE emp_record_type IS RECORD( name emp.ename%TYPE, salary emp.sal%TYPE, dno emp.deptno%TYPE ); emp_
【Linux常用命令一】grep命令 bit1129 Linux常用命令
grep命令格式 grep [option] pattern [file-list] grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。 pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
mybatis3入门学习笔记白糖_ sql ibatis qq jdbc 配置管理
MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。 MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
Linux 命令神器：lsof 入门 ronin47 lsof
lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。有趣的是，lsof也是有着最多
java实现两个大数相加，可能存在溢出。 bylijinnan java实现
import java.math.BigInteger; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BigIntegerAddition { /** * 题目：java实现两个大数相加，可能存在溢出。 * 如123456789 + 987654321
Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法 Kai_Ge Kettle
Kettle学习资料分享 Kettle 3.2 使用说明书目录概述..........................................................................................................................................7 1.Kettle 资源库管
[货币与金融]钢之炼金术士 comsci 金融
自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的那么随着人类在理论物理和工程物理上面取得的一些突破性进展...... 炼金术这个古老
Toast原来也可以多样化 dai_lm android toast
Style 1：默认 Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT); def.show(); Style 2：顶部显示 Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT); t
java数据计算的几种解决方法3 datamachine java hadoop ibatis r-langue r
4、iBatis 简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
向网页中插入透明Flash的方法和技巧 dcj3sjt126com html Web Flash
将 Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制：　　注意wmode="transparent"是控制Flash是否透明
ios UICollectionView的使用 dcj3sjt126com
UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 1.UIViewController实现委托，代码如
Eos平台java公共逻辑蕃薯耀 Eos平台java公共逻辑 Eos平台 java公共逻辑
Eos平台java公共逻辑 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:20:4
SpringMVC4零配置--Web上下文配置【MvcConfig】 hanqunfeng springmvc4
与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。 applicationContext-MvcConfig.xml  <
解决ie和其他浏览器poi下载excel文件名乱码 jackyrong Excel
使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码，因此必须综合判断，编写一个工具类： /** * * @Title: pro
挥洒泪水的青春 lampcy 编程生活程序员
2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制 nannan408
对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
动态设置iframe高度(iframe高度自适应) Rainbow702 JavaScript iframe contentDocument 高度自适应局部刷新
如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： <div id="content"> <div id=&quo
用Rapael做图表 tntxia rap
function drawReport(paper,attr,data){ var width = attr.width; var height = attr.height; var max = 0; &nbs
HTML5 bootstrap2网页兼容（支持IE10以下） xiaoluode html5 bootstrap
<!DOCTYPE html> <html> <head lang="zh-CN"> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge">

Caffe代码导读（5）：对数据集进行Testing

你可能感兴趣的:(神经网络,cnn,深度学习,caffe)