lynnandwei

学习笔记：Caffe上配置和运行Cifar10的示例

CIFAR-10数据集含有6万个32*32的彩色图像，共分为10种类型，由 Alex Krizhevsky, Vinod Nair和 Geoffrey Hinton收集而来。包含50000张训练图片，10000张测试图片

http://www.cs.toronto.edu/~kriz/cifar.html

数据集的数据存在一个10000*3072 的 numpy数组中，单位是uint8s，3072是存储了一个32*32的彩色图像。（3072=1024*3）。前1024位是r值，中间1024是g值，后面1024是b值。

首先准备数据集：

cd $CAFFE_ROOT/data/cifar10

./get_cifar10.sh

[root@localhost cifar10]# ./get_cifar10.sh 
Downloading...
--2015-03-09 18:38:23--  http://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz
Resolving www.cs.toronto.edu... 128.100.3.30
Connecting to www.cs.toronto.edu|128.100.3.30|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 170052171 (162M) [application/x-gzip]
Saving to: 鈥渃ifar-10-binary.tar.gz鈥

100%[=============================================================>] 170,052,171 1.66M/s   in 5m 22s

Unzipping...
Done.

然后进入目录执行

cd $CAFFE_ROOT/examples/cifar10

./create_cifar10.sh

create_cifar10.sh 源代码如下，我们可以看到，所做的工作就是将图片库转成leveldb格式，并计算均值二进制文件

#!/usr/bin/env sh
# This script converts the cifar data into leveldb format.

EXAMPLE=examples/cifar10
DATA=data/cifar10

echo "Creating leveldb..."

rm -rf $EXAMPLE/cifar10_train_leveldb $EXAMPLE/cifar10_test_leveldb

./build/examples/cifar10/convert_cifar_data.bin $DATA $EXAMPLE

echo "Computing image mean..."

./build/tools/compute_image_mean $EXAMPLE/cifar10_train_leveldb \
  $EXAMPLE/mean.binaryproto leveldb

echo "Done."

运行之后，将会在 examples 中出现数据库文件 ./cifar10-leveldb 和数据库图像均值二进制文件 ./mean.binaryproto

[root@localhost caffe]# ./examples/cifar10/create_cifar10.sh
Creating leveldb...
Computing image mean...
E0309 18:50:12.026103 18241 compute_image_mean.cpp:114] Processed 10000 files.
E0309 18:50:12.094758 18241 compute_image_mean.cpp:114] Processed 20000 files.
E0309 18:50:12.163048 18241 compute_image_mean.cpp:114] Processed 30000 files.
E0309 18:50:12.231233 18241 compute_image_mean.cpp:114] Processed 40000 files.
E0309 18:50:12.299324 18241 compute_image_mean.cpp:114] Processed 50000 files.
Done.

模型描述在examples/cifar10/cifar10_quick_solver.prototxt，和 examples/cifar10/cifar10_quick_train_test.prototxt 中。

# reduce the learning rate after 8 epochs (4000 iters) by a factor of 10

# The train/test net protocol buffer definition
net: "examples/cifar10/cifar10_quick_train_test.prototxt"
# test_iter specifies how many forward passes the test should carry out.
# In the case of MNIST, we have test batch size 100 and 100 test iterations,
# covering the full 10,000 testing images.
test_iter: 100
# Carry out testing every 500 training iterations.
test_interval: 500
# The base learning rate, momentum and the weight decay of the network.
base_lr: 0.001
momentum: 0.9
weight_decay: 0.004
# The learning rate policy
lr_policy: "fixed"
# Display every 100 iterations
display: 100
# The maximum number of iterations
max_iter: 4000
# snapshot intermediate results
snapshot: 4000
snapshot_prefix: "examples/cifar10/cifar10_quick"
# solver mode: CPU or GPU
solver_mode: CPU
~

name: "CIFAR10_quick"
layers {
  name: "cifar"
  type: DATA
  top: "data"
  top: "label"
  data_param {
    source: "examples/cifar10/cifar10_train_leveldb"
    batch_size: 100
  }
  transform_param {
    mean_file: "examples/cifar10/mean.binaryproto"
  }
  include: { phase: TRAIN }
}
layers {
  name: "cifar"
  type: DATA
  top: "data"
  top: "label"
  data_param {
    source: "examples/cifar10/cifar10_test_leveldb"
    batch_size: 100
  }
  transform_param {
    mean_file: "examples/cifar10/mean.binaryproto"
  }
  include: { phase: TEST }
}
layers {
  name: "conv1"
  type: CONVOLUTION
  bottom: "data"
  top: "conv1"
  blobs_lr: 1
  blobs_lr: 2
  convolution_param {
    num_output: 32
    pad: 2
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "gaussian"
      std: 0.0001
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  name: "pool1"
  type: POOLING
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layers {
  name: "relu1"
  type: RELU
  bottom: "pool1"
  top: "pool1"
}
layers {
  name: "conv2"
  type: CONVOLUTION
  bottom: "pool1"
  top: "conv2"
  blobs_lr: 1
  blobs_lr: 2
  convolution_param {
    num_output: 32
    pad: 2
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  name: "relu2"
  type: RELU
  bottom: "conv2"
  top: "conv2"
}
layers {
  name: "pool2"
  type: POOLING
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: AVE
    kernel_size: 3
    stride: 2
  }
}
layers {
  name: "conv3"
  type: CONVOLUTION
  bottom: "pool2"
  top: "conv3"
  blobs_lr: 1
  blobs_lr: 2
  convolution_param {
    num_output: 64
    pad: 2
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
    }
  }
}
layers {
  name: "relu3"
  type: RELU
  bottom: "conv3"
  top: "conv3"
}
layers {
  name: "pool3"
  type: POOLING
  bottom: "conv3"
  top: "pool3"
  pooling_param {
    pool: AVE
    kernel_size: 3
    stride: 2
  }
}
layers {
  name: "ip1"
  type: INNER_PRODUCT
  bottom: "pool3"
  top: "ip1"
  blobs_lr: 1
  blobs_lr: 2
  inner_product_param {
    num_output: 64
    weight_filler {
      type: "gaussian"
      std: 0.1
    }
    bias_filler {
      type: "constant"
    }
  }
}
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: "gaussian"
      std: 0.1
    }
    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"
}

模型训练是执行 train_quick.sh ，内容如下

[root@localhost cifar10]# vi train_quick.sh 


#!/usr/bin/env sh


TOOLS=./build/tools


$TOOLS/caffe train \
  --solver=examples/cifar10/cifar10_quick_solver.prototxt


# reduce learning rate by factor of 10 after 8 epochs
$TOOLS/caffe train \
  --solver=examples/cifar10/cifar10_quick_solver_lr1.prototxt \
  --snapshot=examples/cifar10/cifar10_quick_iter_4000.solverstate
~

执行结果如下：


I0313 00:40:24.471531 13825 net.cpp:56] Memory required for data: 0
I0313 00:40:24.471560 13825 net.cpp:67] Creating Layer cifar
I0313 00:40:24.471570 13825 net.cpp:356] cifar -> data
I0313 00:40:24.471585 13825 net.cpp:356] cifar -> label
I0313 00:40:24.471596 13825 net.cpp:96] Setting up cifar
I0313 00:40:24.471602 13825 data_layer.cpp:45] Opening leveldb examples/cifar10/cifar10_test_leveldb
I0313 00:40:24.549324 13825 data_layer.cpp:128] output data size: 100,3,32,32
I0313 00:40:24.549372 13825 base_data_layer.cpp:36] Loading mean file fromexamples/cifar10/mean.binaryproto
I0313 00:40:24.550582 13825 base_data_layer.cpp:64] Initializing prefetch
I0313 00:40:24.550639 13825 base_data_layer.cpp:66] Prefetch initialized.
I0313 00:40:24.550683 13825 net.cpp:103] Top shape: 100 3 32 32 (307200)
I0313 00:40:24.550698 13825 net.cpp:103] Top shape: 100 1 1 1 (100)
I0313 00:40:24.550709 13825 net.cpp:113] Memory required for data: 1229200
I0313 00:40:24.550734 13825 net.cpp:67] Creating Layer label_cifar_1_split
I0313 00:40:24.550750 13825 net.cpp:394] label_cifar_1_split <- label
I0313 00:40:24.550775 13825 net.cpp:356] label_cifar_1_split -> label_cifar_1_split_0
I0313 00:40:24.550802 13825 net.cpp:356] label_cifar_1_split -> label_cifar_1_split_1
I0313 00:40:24.550824 13825 net.cpp:96] Setting up label_cifar_1_split
I0313 00:40:24.550843 13825 net.cpp:103] Top shape: 100 1 1 1 (100)
I0313 00:40:24.550855 13825 net.cpp:103] Top shape: 100 1 1 1 (100)
I0313 00:40:24.550866 13825 net.cpp:113] Memory required for data: 1230000
I0313 00:40:24.550889 13825 net.cpp:67] Creating Layer conv1
I0313 00:40:24.550902 13825 net.cpp:394] conv1 <- data
I0313 00:40:24.550926 13825 net.cpp:356] conv1 -> conv1
I0313 00:40:24.550951 13825 net.cpp:96] Setting up conv1
I0313 00:40:24.551573 13825 net.cpp:103] Top shape: 100 32 32 32 (3276800)
I0313 00:40:24.551583 13825 net.cpp:113] Memory required for data: 14337200
I0313 00:40:24.551599 13825 net.cpp:67] Creating Layer pool1
I0313 00:40:24.551605 13825 net.cpp:394] pool1 <- conv1
I0313 00:40:24.551615 13825 net.cpp:356] pool1 -> pool1
I0313 00:40:24.551625 13825 net.cpp:96] Setting up pool1
I0313 00:40:24.551633 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.551638 13825 net.cpp:113] Memory required for data: 17614000
I0313 00:40:24.551652 13825 net.cpp:67] Creating Layer relu1
I0313 00:40:24.551658 13825 net.cpp:394] relu1 <- pool1
I0313 00:40:24.551667 13825 net.cpp:345] relu1 -> pool1 (in-place)
I0313 00:40:24.551676 13825 net.cpp:96] Setting up relu1
I0313 00:40:24.551682 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.551687 13825 net.cpp:113] Memory required for data: 20890800
I0313 00:40:24.551695 13825 net.cpp:67] Creating Layer conv2
I0313 00:40:24.551700 13825 net.cpp:394] conv2 <- pool1
I0313 00:40:24.551710 13825 net.cpp:356] conv2 -> conv2
I0313 00:40:24.551720 13825 net.cpp:96] Setting up conv2
I0313 00:40:24.554986 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.554996 13825 net.cpp:113] Memory required for data: 24167600
I0313 00:40:24.555009 13825 net.cpp:67] Creating Layer relu2
I0313 00:40:24.555024 13825 net.cpp:394] relu2 <- conv2
I0313 00:40:24.555034 13825 net.cpp:345] relu2 -> conv2 (in-place)
I0313 00:40:24.555043 13825 net.cpp:96] Setting up relu2
I0313 00:40:24.555049 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.555054 13825 net.cpp:113] Memory required for data: 27444400
I0313 00:40:24.555061 13825 net.cpp:67] Creating Layer pool2
I0313 00:40:24.555068 13825 net.cpp:394] pool2 <- conv2
I0313 00:40:24.555076 13825 net.cpp:356] pool2 -> pool2
I0313 00:40:24.555085 13825 net.cpp:96] Setting up pool2
I0313 00:40:24.555094 13825 net.cpp:103] Top shape: 100 32 8 8 (204800)
I0313 00:40:24.555099 13825 net.cpp:113] Memory required for data: 28263600
I0313 00:40:24.555109 13825 net.cpp:67] Creating Layer conv3
I0313 00:40:24.555114 13825 net.cpp:394] conv3 <- pool2
I0313 00:40:24.555124 13825 net.cpp:356] conv3 -> conv3
I0313 00:40:24.555135 13825 net.cpp:96] Setting up conv3
I0313 00:40:24.561589 13825 net.cpp:103] Top shape: 100 64 8 8 (409600)
I0313 00:40:24.561599 13825 net.cpp:113] Memory required for data: 29902000
I0313 00:40:24.561611 13825 net.cpp:67] Creating Layer relu3
I0313 00:40:24.561619 13825 net.cpp:394] relu3 <- conv3
I0313 00:40:24.561627 13825 net.cpp:345] relu3 -> conv3 (in-place)
I0313 00:40:24.561636 13825 net.cpp:96] Setting up relu3
I0313 00:40:24.561642 13825 net.cpp:103] Top shape: 100 64 8 8 (409600)
I0313 00:40:24.561646 13825 net.cpp:113] Memory required for data: 31540400
I0313 00:40:24.561655 13825 net.cpp:67] Creating Layer pool3
I0313 00:40:24.561661 13825 net.cpp:394] pool3 <- conv3
I0313 00:40:24.561669 13825 net.cpp:356] pool3 -> pool3
I0313 00:40:24.561678 13825 net.cpp:96] Setting up pool3
I0313 00:40:24.561686 13825 net.cpp:103] Top shape: 100 64 4 4 (102400)
I0313 00:40:24.561691 13825 net.cpp:113] Memory required for data: 31950000
I0313 00:40:24.561699 13825 net.cpp:67] Creating Layer ip1
I0313 00:40:24.561704 13825 net.cpp:394] ip1 <- pool3
I0313 00:40:24.561714 13825 net.cpp:356] ip1 -> ip1
I0313 00:40:24.561724 13825 net.cpp:96] Setting up ip1
I0313 00:40:24.569967 13825 net.cpp:103] Top shape: 100 64 1 1 (6400)
I0313 00:40:24.569975 13825 net.cpp:113] Memory required for data: 31975600
I0313 00:40:24.569988 13825 net.cpp:67] Creating Layer ip2
I0313 00:40:24.569993 13825 net.cpp:394] ip2 <- ip1
I0313 00:40:24.570004 13825 net.cpp:356] ip2 -> ip2
I0313 00:40:24.570014 13825 net.cpp:96] Setting up ip2
I0313 00:40:24.570108 13825 net.cpp:103] Top shape: 100 10 1 1 (1000)
I0313 00:40:24.570114 13825 net.cpp:113] Memory required for data: 31979600
I0313 00:40:24.570127 13825 net.cpp:67] Creating Layer ip2_ip2_0_split
I0313 00:40:24.570134 13825 net.cpp:394] ip2_ip2_0_split <- ip2
I0313 00:40:24.570143 13825 net.cpp:356] ip2_ip2_0_split -> ip2_ip2_0_split_0
I0313 00:40:24.570154 13825 net.cpp:356] ip2_ip2_0_split -> ip2_ip2_0_split_1
I0313 00:40:24.570163 13825 net.cpp:96] Setting up ip2_ip2_0_split
I0313 00:40:24.570171 13825 net.cpp:103] Top shape: 100 10 1 1 (1000)
I0313 00:40:24.570176 13825 net.cpp:103] Top shape: 100 10 1 1 (1000)
I0313 00:40:24.570181 13825 net.cpp:113] Memory required for data: 31987600
I0313 00:40:24.570189 13825 net.cpp:67] Creating Layer accuracy
I0313 00:40:24.570194 13825 net.cpp:394] accuracy <- ip2_ip2_0_split_0
I0313 00:40:24.570202 13825 net.cpp:394] accuracy <- label_cifar_1_split_0
I0313 00:40:24.570214 13825 net.cpp:356] accuracy -> accuracy
I0313 00:40:24.570222 13825 net.cpp:96] Setting up accuracy
I0313 00:40:24.570230 13825 net.cpp:103] Top shape: 1 1 1 1 (1)
I0313 00:40:24.570235 13825 net.cpp:113] Memory required for data: 31987604
I0313 00:40:24.570245 13825 net.cpp:67] Creating Layer loss
I0313 00:40:24.570250 13825 net.cpp:394] loss <- ip2_ip2_0_split_1
I0313 00:40:24.570257 13825 net.cpp:394] loss <- label_cifar_1_split_1
I0313 00:40:24.570266 13825 net.cpp:356] loss -> loss
I0313 00:40:24.570274 13825 net.cpp:96] Setting up loss
I0313 00:40:24.570286 13825 net.cpp:103] Top shape: 1 1 1 1 (1)
I0313 00:40:24.570291 13825 net.cpp:109]     with loss weight 1
I0313 00:40:24.570305 13825 net.cpp:113] Memory required for data: 31987608
I0313 00:40:24.570312 13825 net.cpp:170] loss needs backward computation.
I0313 00:40:24.570317 13825 net.cpp:172] accuracy does not need backward computation.
I0313 00:40:24.570322 13825 net.cpp:170] ip2_ip2_0_split needs backward computation.
I0313 00:40:24.570338 13825 net.cpp:170] ip2 needs backward computation.
I0313 00:40:24.570349 13825 net.cpp:170] ip1 needs backward computation.
I0313 00:40:24.570359 13825 net.cpp:170] pool3 needs backward computation.
I0313 00:40:24.570372 13825 net.cpp:170] relu3 needs backward computation.
I0313 00:40:24.570384 13825 net.cpp:170] conv3 needs backward computation.
I0313 00:40:24.570396 13825 net.cpp:170] pool2 needs backward computation.
I0313 00:40:24.570406 13825 net.cpp:170] relu2 needs backward computation.
I0313 00:40:24.570420 13825 net.cpp:170] conv2 needs backward computation.
I0313 00:40:24.570432 13825 net.cpp:170] relu1 needs backward computation.
I0313 00:40:24.570442 13825 net.cpp:170] pool1 needs backward computation.
I0313 00:40:24.570456 13825 net.cpp:170] conv1 needs backward computation.
I0313 00:40:24.570471 13825 net.cpp:172] label_cifar_1_split does not need backward computation.
I0313 00:40:24.570482 13825 net.cpp:172] cifar does not need backward computation.
I0313 00:40:24.570494 13825 net.cpp:208] This network produces output accuracy
I0313 00:40:24.570505 13825 net.cpp:208] This network produces output loss
I0313 00:40:24.570536 13825 net.cpp:467] Collecting Learning Rate and Weight Decay.
I0313 00:40:24.570549 13825 net.cpp:219] Network initialization done.
I0313 00:40:24.570554 13825 net.cpp:220] Memory required for data: 31987608
I0313 00:40:24.570590 13825 solver.cpp:41] Solver scaffolding done.
I0313 00:40:24.570595 13825 solver.cpp:160] Solving CIFAR10_quick
I0313 00:40:24.570600 13825 solver.cpp:161] Learning Rate Policy: fixed
I0313 00:40:24.570631 13825 solver.cpp:264] Iteration 0, Testing net (#0)
I0313 00:40:24.570639 13825 net.cpp:652] Copying source layer cifar
I0313 00:40:24.570644 13825 net.cpp:652] Copying source layer conv1
I0313 00:40:24.570652 13825 net.cpp:652] Copying source layer pool1
I0313 00:40:24.570657 13825 net.cpp:652] Copying source layer relu1
I0313 00:40:24.570662 13825 net.cpp:652] Copying source layer conv2
I0313 00:40:24.570667 13825 net.cpp:652] Copying source layer relu2
I0313 00:40:24.570672 13825 net.cpp:652] Copying source layer pool2
I0313 00:40:24.570677 13825 net.cpp:652] Copying source layer conv3
I0313 00:40:24.570696 13825 net.cpp:652] Copying source layer relu3
I0313 00:40:24.570703 13825 net.cpp:652] Copying source layer pool3
I0313 00:40:24.570708 13825 net.cpp:652] Copying source layer ip1
I0313 00:40:24.570724 13825 net.cpp:652] Copying source layer ip2
I0313 00:40:24.570729 13825 net.cpp:652] Copying source layer loss
}
I0313 00:40:24.471531 13825 net.cpp:56] Memory required for data: 0
I0313 00:40:24.471560 13825 net.cpp:67] Creating Layer cifar
I0313 00:40:24.471570 13825 net.cpp:356] cifar -> data
I0313 00:40:24.471585 13825 net.cpp:356] cifar -> label
I0313 00:40:24.471596 13825 net.cpp:96] Setting up cifar
I0313 00:40:24.471602 13825 data_layer.cpp:45] Opening leveldb examples/cifar10/cifar10_test_leveldb
I0313 00:40:24.549324 13825 data_layer.cpp:128] output data size: 100,3,32,32
I0313 00:40:24.549372 13825 base_data_layer.cpp:36] Loading mean file fromexamples/cifar10/mean.binaryproto
I0313 00:40:24.550582 13825 base_data_layer.cpp:64] Initializing prefetch
I0313 00:40:24.550639 13825 base_data_layer.cpp:66] Prefetch initialized.
I0313 00:40:24.550683 13825 net.cpp:103] Top shape: 100 3 32 32 (307200)
I0313 00:40:24.550698 13825 net.cpp:103] Top shape: 100 1 1 1 (100)
I0313 00:40:24.550709 13825 net.cpp:113] Memory required for data: 1229200
I0313 00:40:24.550734 13825 net.cpp:67] Creating Layer label_cifar_1_split
I0313 00:40:24.550750 13825 net.cpp:394] label_cifar_1_split <- label
I0313 00:40:24.550775 13825 net.cpp:356] label_cifar_1_split -> label_cifar_1_split_0
I0313 00:40:24.550802 13825 net.cpp:356] label_cifar_1_split -> label_cifar_1_split_1
I0313 00:40:24.550824 13825 net.cpp:96] Setting up label_cifar_1_split
I0313 00:40:24.550843 13825 net.cpp:103] Top shape: 100 1 1 1 (100)
I0313 00:40:24.550855 13825 net.cpp:103] Top shape: 100 1 1 1 (100)
I0313 00:40:24.550866 13825 net.cpp:113] Memory required for data: 1230000
I0313 00:40:24.550889 13825 net.cpp:67] Creating Layer conv1
I0313 00:40:24.550902 13825 net.cpp:394] conv1 <- data
I0313 00:40:24.550926 13825 net.cpp:356] conv1 -> conv1
I0313 00:40:24.550951 13825 net.cpp:96] Setting up conv1
I0313 00:40:24.551573 13825 net.cpp:103] Top shape: 100 32 32 32 (3276800)
I0313 00:40:24.551583 13825 net.cpp:113] Memory required for data: 14337200
I0313 00:40:24.551599 13825 net.cpp:67] Creating Layer pool1
I0313 00:40:24.551605 13825 net.cpp:394] pool1 <- conv1
I0313 00:40:24.551615 13825 net.cpp:356] pool1 -> pool1
I0313 00:40:24.551625 13825 net.cpp:96] Setting up pool1
I0313 00:40:24.551633 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.551638 13825 net.cpp:113] Memory required for data: 17614000
I0313 00:40:24.551652 13825 net.cpp:67] Creating Layer relu1
I0313 00:40:24.551658 13825 net.cpp:394] relu1 <- pool1
I0313 00:40:24.551667 13825 net.cpp:345] relu1 -> pool1 (in-place)
I0313 00:40:24.551676 13825 net.cpp:96] Setting up relu1
I0313 00:40:24.551682 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.551687 13825 net.cpp:113] Memory required for data: 20890800
I0313 00:40:24.551695 13825 net.cpp:67] Creating Layer conv2
I0313 00:40:24.551700 13825 net.cpp:394] conv2 <- pool1
I0313 00:40:24.551710 13825 net.cpp:356] conv2 -> conv2
I0313 00:40:24.551720 13825 net.cpp:96] Setting up conv2
I0313 00:40:24.554986 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.554996 13825 net.cpp:113] Memory required for data: 24167600
I0313 00:40:24.555009 13825 net.cpp:67] Creating Layer relu2
I0313 00:40:24.555024 13825 net.cpp:394] relu2 <- conv2
I0313 00:40:24.555034 13825 net.cpp:345] relu2 -> conv2 (in-place)
I0313 00:40:24.555043 13825 net.cpp:96] Setting up relu2
I0313 00:40:24.555049 13825 net.cpp:103] Top shape: 100 32 16 16 (819200)
I0313 00:40:24.555054 13825 net.cpp:113] Memory required for data: 27444400
I0313 00:40:24.555061 13825 net.cpp:67] Creating Layer pool2
I0313 00:40:24.555068 13825 net.cpp:394] pool2 <- conv2
I0313 00:40:24.555076 13825 net.cpp:356] pool2 -> pool2
I0313 00:40:24.555085 13825 net.cpp:96] Setting up pool2
I0313 00:40:24.555094 13825 net.cpp:103] Top shape: 100 32 8 8 (204800)
I0313 00:40:24.555099 13825 net.cpp:113] Memory required for data: 28263600
I0313 00:40:24.555109 13825 net.cpp:67] Creating Layer conv3
I0313 00:40:24.555114 13825 net.cpp:394] conv3 <- pool2
I0313 00:40:24.555124 13825 net.cpp:356] conv3 -> conv3
I0313 00:40:24.555135 13825 net.cpp:96] Setting up conv3
I0313 00:40:24.5I0313 00:41:19.945504 13934 data_layer.cpp:187] Restarting data prefetching from start.
I0313 00:41:21.066936 13825 solver.cpp:315]     Test net output #0: accuracy = 0.0932
I0313 00:41:21.066978 13825 solver.cpp:315]     Test net output #1: loss = 2.30265 (* 1 = 2.30265 loss)
I0313 00:41:22.483836 13825 solver.cpp:209] Iteration 0, loss = 2.3028
I0313 00:41:22.483877 13825 solver.cpp:224]     Train net output #0: loss = 2.3028 (* 1 = 2.3028 loss)
I0313 00:41:22.483894 13825 solver.cpp:445] Iteration 0, lr = 0.001
I0313 00:43:45.116195 13825 solver.cpp:209] Iteration 100, loss = 1.785
I0313 00:43:45.116281 13825 solver.cpp:224]     Train net output #0: loss = 1.785 (* 1 = 1.785 loss)
I0313 00:43:45.116291 13825 solver.cpp:445] Iteration 100, lr = 0.001
I0313 00:46:07.567387 13825 solver.cpp:209] Iteration 200, loss = 1.62294
I0313 00:46:07.567468 13825 solver.cpp:224]     Train net output #0: loss = 1.62294 (* 1 = 1.62294 loss)
I0313 00:46:07.567479 13825 solver.cpp:445] Iteration 200, lr = 0.001
I0313 00:48:30.618835 13825 solver.cpp:209] Iteration 300, loss = 1.34621
I0313 00:48:30.618942 13825 solver.cpp:224]     Train net output #0: loss = 1.34621 (* 1 = 1.34621 loss)
I0313 00:48:30.618953 13825 solver.cpp:445] Iteration 300, lr = 0.001

I0313 00:50:52.191938 13825 solver.cpp:209] Iteration 400, loss = 1.28778
I0313 00:50:52.192026 13825 solver.cpp:224]     Train net output #0: loss = 1.28778 (* 1 = 1.28778 loss)
I0313 00:50:52.192037 13825 solver.cpp:445] Iteration 400, lr = 0.001
I0313 00:53:09.941452 14527 data_layer.cpp:187] Restarting data prefetching from start.
I0313 00:53:12.735488 13825 solver.cpp:264] Iteration 500, Testing net (#0)
I0313 00:53:12.735517 13825 net.cpp:652] Copying source layer cifar
I0313 00:53:12.735524 13825 net.cpp:652] Copying source layer conv1
I0313 00:53:12.735530 13825 net.cpp:652] Copying source layer pool1
I0313 00:53:12.735535 13825 net.cpp:652] Copying source layer relu1
I0313 00:53:12.735540 13825 net.cpp:652] Copying source layer conv2
I0313 00:53:12.735545 13825 net.cpp:652] Copying source layer relu2
I0313 00:53:12.735550 13825 net.cpp:652] Copying source layer pool2
I0313 00:53:12.735554 13825 net.cpp:652] Copying source layer conv3
I0313 00:53:12.735560 13825 net.cpp:652] Copying source layer relu3
I0313 00:53:12.735565 13825 net.cpp:652] Copying source layer pool3
I0313 00:53:12.735569 13825 net.cpp:652] Copying source layer ip1
I0313 00:53:12.735575 13825 net.cpp:652] Copying source layer ip2
I0313 00:53:12.735580 13825 net.cpp:652] Copying source layer loss
I0313 00:54:08.180796 14634 data_layer.cpp:187] Restarting data prefetching from start.
I0313 00:54:09.297691 13825 solver.cpp:315]     Test net output #0: accuracy = 0.5571
I0313 00:54:09.297731 13825 solver.cpp:315]     Test net output #1: loss = 1.271 (* 1 = 1.271 loss)
I0313 00:54:10.695636 13825 solver.cpp:209] Iteration 500, loss = 1.20884
I0313 00:54:10.695677 13825 solver.cpp:224]     Train net output #0: loss = 1.20884 (* 1 = 1.20884 loss)
I0313 00:54:10.695686 13825 solver.cpp:445] Iteration 500, lr = 0.001
I0313 00:56:32.906312 13825 solver.cpp:209] Iteration 600, loss = 1.18048
I0313 00:56:32.906397 13825 solver.cpp:224]     Train net output #0: loss = 1.18048 (* 1 = 1.18048 loss)
I0313 00:56:32.906407 13825 solver.cpp:445] Iteration 600, lr = 0.001

……

附上readme里面的解释

When you run the code, you will see a lot of messages flying by like this:

I0317 21:52:48.945710 2008298256 net.cpp:74] Creating Layer conv1
I0317 21:52:48.945716 2008298256 net.cpp:84] conv1 <- data
I0317 21:52:48.945725 2008298256 net.cpp:110] conv1 -> conv1
I0317 21:52:49.298691 2008298256 net.cpp:125] Top shape: 100 32 32 32 (3276800)
I0317 21:52:49.298719 2008298256 net.cpp:151] conv1 needs backward computation.
These messages tell you the details about each layer, its connections and its output shape, which may be 

helpful in debugging. After the initialization, the training will start:

I0317 21:52:49.309370 2008298256 net.cpp:166] Network initialization done.
I0317 21:52:49.309376 2008298256 net.cpp:167] Memory required for Data 23790808
I0317 21:52:49.309422 2008298256 solver.cpp:36] Solver scaffolding done.
I0317 21:52:49.309447 2008298256 solver.cpp:47] Solving CIFAR10_quick_train
Based on the solver setting, we will print the training loss function every 100 iterations, and test the 

network every 500 iterations. You will see messages like this:

I0317 21:53:12.179772 2008298256 solver.cpp:208] Iteration 100, lr = 0.001
I0317 21:53:12.185698 2008298256 solver.cpp:65] Iteration 100, loss = 1.73643
...
I0317 21:54:41.150030 2008298256 solver.cpp:87] Iteration 500, Testing net
I0317 21:54:47.129461 2008298256 solver.cpp:114] Test score #0: 0.5504
I0317 21:54:47.129500 2008298256 solver.cpp:114] Test score #1: 1.27805
For each training iteration, lr is the learning rate of that iteration, and loss is the training function. For 

the output of the testing phase, score 0 is the accuracy, and score 1 is the testing loss function.

And after making yourself a cup of coffee, you are done!

I0317 22:12:19.666914 2008298256 solver.cpp:87] Iteration 5000, Testing net
I0317 22:12:25.580330 2008298256 solver.cpp:114] Test score #0: 0.7533
I0317 22:12:25.580379 2008298256 solver.cpp:114] Test score #1: 0.739837
I0317 22:12:25.587262 2008298256 solver.cpp:130] Snapshotting to cifar10_quick_iter_5000
I0317 22:12:25.590215 2008298256 solver.cpp:137] Snapshotting solver state to 

cifar10_quick_iter_5000.solverstate
I0317 22:12:25.592813 2008298256 solver.cpp:81] Optimization Done.
Our model achieved ~75% test accuracy. The model parameters are stored in binary protobuf format in

cifar10_quick_iter_5000

你可能感兴趣的:(Machine,Learning)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
深度 Qlearning：在直播推荐系统中的应用 AGI通用人工智能之禅程序员提升自我硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM Java Python 架构设计 Agent 程序员实现财富自由
深度Q-learning：在直播推荐系统中的应用关键词：深度Q-learning,强化学习,直播推荐系统,个性化推荐1.背景介绍1.1问题的由来随着互联网技术的飞速发展,直播平台如雨后春笋般涌现。面对海量的直播内容,用户很难快速找到自己感兴趣的内容。因此,个性化推荐系统在直播平台中扮演着越来越重要的角色。1.2研究现状目前,主流的个性化推荐算法包括协同过滤、基于内容的推荐等。这些方法在一定程度上缓
管理员权限的软件不能开机自启动的解决方法 ss_ctrl
这是几种解决方法：1.将启动参数写入到32位注册表里面去在64位系统下我们64位的程序访问此HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run注册表路径，是可以正确访问的，32位程序访问此注册表路径时，默认会被系统自动映射到HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft
golang学习笔记--MPG模型 xxzed golang #学习笔记学习笔记 golang
MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
【开发环境搭建】Macbook M1搭建Java开发环境 weixin_44329069 java 开发语言
JDK安装与配置下载并安装JDK：ARM64DMG安装包下载链接：JDK21forMac(ARM64)。双击下载的DMG文件，按照提示安装JDK。配置环境变量：打开终端，使用vim编辑.bash_profile文件：vim~/.bash_profile在文件中添加以下内容来设置JAVA_HOME：exportJAVA_HOME=/Library/Java/JavaVirtualMachines/j
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
机器学习VS深度学习 nfgo 机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
ResNet的半监督和半弱监督模型 Valar_Morghulis
Billion-scalesemi-supervisedlearningforimageclassificationhttps://arxiv.org/pdf/1905.00546.pdfhttps://github.com/facebookresearch/semi-supervised-ImageNet1K-models/权重在timm中也有：https://hub.fastgit.org/r
联邦学习 Federated learning Google I/O‘19 笔记努力搬砖的星期五笔记联邦学习机器学习机器学习 tensorflow
FederatedLearning:MachineLearningonDecentralizeddatahttps://www.youtube.com/watch?v=89BGjQYA0uE文章目录FederatedLearning:MachineLearningonDecentralizeddata1.DecentralizeddataEdgedevicesGboard:mobilekeyboa
PCL 怎样可视化深度图像 LeonDL168 PCL 计算机视觉人工智能视觉检测图像处理算法
本小节讲解如何可视化深度图像的两种方法，在3D视窗中以点云形式进行可视化（深度图像来源于点云），另一种是，将深度值映射为颜色，从而以彩色图像方式可视化深度图像。代码首先，在PCL（PointCloudLearning）中国协助发行的书提供光盘的第7章例2文件夹中，打开名为range_image_visualization.cpp的代码文件，同文件夹下可以找到相关的测试点云文件room_scan1.
FISCO BCOS（十七）——— go SDK的使用林中有神君 #FISCO BCOS 2.8.0 golang 服务器 linux fisco bcos 区块链
1、创建一个工作目录root@wyg-virtual-machine:~/fisco#mkdirgoWorkSpace2、下载go-sdkroot@wyg-virtual-machine:~/fisco/
Git报错（一）fatal: Could not read from remote repository. librarycode
解决方案来自CSDN：https://blog.csdn.net/cxwtsh123/article/details/79194263?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.control&dist_request_id=&depth_1-utm_source=distr
VOC数据集转换为CoCo数据集（亲测有效）情书学长人工智能学习笔记图像处理
#VOC数据集格式VOC格式的数据集分为3部分，Annotations、ImageSets、JPEGImages。（一）Annotations：存放数据标注的xml文件，格式如下：CUMID_train0001.pngC:\Users\86182\Desktop\CUMID_train\0001.pngUnknown2040136830MachineUnspecified0011933491451
【Vesta发号器源码】PropertyMachineIdsProvider DeanChangDM
Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
Awesome TensorFlow weixin_30594001 人工智能移动开发大数据
AwesomeTensorFlowAcuratedlistofawesomeTensorFlowexperiments,libraries,andprojects.Inspiredbyawesome-machine-learning.WhatisTensorFlow?TensorFlowisanopensourcesoftwarelibraryfornumericalcomputationusin
【ShuQiHere】探索人工智能核心：机器学习的奥秘 ShuQiHere 人工智能机器学习
【ShuQiHere】什么是机器学习？机器学习（MachineLearning,ML）是人工智能（ArtificialIntelligence,AI）中最关键的组成部分之一。它使得计算机不仅能够处理数据，还能从数据中学习，从而做出预测和决策。无论是语音识别、自动驾驶还是推荐系统，背后都依赖于机器学习模型。机器学习与传统的编程不同，它不再依赖于人类编写的固定规则，而是通过数据自我改进模型，从而更灵活
综述论文“A Survey of Zero-Shot Learning: Settings, Methods, and Applications” 硅谷秋水机器学习机器学习神经网络深度学习
该零样本学习综述，发表于ACMTrans.Intell.Syst.Technol.10,2,Article13(January2019)摘要：大多数机器学习方法着重于对已经在训练中看到其类别的实例进行分类。实际上，许多应用程序需要对实例进行分类，而这些实例的类以前没有见过。零样本学习（Zero-ShotLearning）是一种强大而有前途的学习范例，其中训练实例涵盖的类别与想分类的类别是不相交的。
go-etcd实战小书go golang 实战演练 golang etcd 服务发现服务注册微服务
etcd简介etcdisastronglyconsistent,distributedkey-valuestorethatprovidesareliablewaytostoredatathatneedstobeaccessedbyadistributedsystemorclusterofmachines.Itgracefullyhandlesleaderelectionsduringnetwork
梯度提升机 (Gradient Boosting Machines, GBM) ALGORITHM LOL boosting 集成学习机器学习
梯度提升机(GradientBoostingMachines,GBM)通俗易懂算法梯度提升机（GradientBoostingMachines，GBM）是一种集成学习算法，主要用于回归和分类问题。GBM本质上是通过训练一系列简单的模型（通常是决策树），然后将这些模型组合起来，从而提高整体预测性能。基本步骤初始模型：首先，我们用一个简单的模型（如一个常数值）作为预测模型，记为F0(x)F_0(x)F
机器学习 VS 表示学习 VS 深度学习 Efred.D 人工智能机器学习深度学习人工智能
文章目录前言一、机器学习是什么?二、表示学习三、深度学习总结前言本文主要阐述机器学习,表示学习和深度学习的原理和区别.一、机器学习是什么?机器学习(machinelearning),是从有限的数据集中学习到一定的规律,再把学到的规律应用到一些相似的样本集中做预测.机器学习的历史可以追溯到20世纪40年代McCulloch提出的人工神经元网络,目前学界大致把机器学习分为传统机器学习和机器学习两个类别
端到端的自动驾驶论文与代码整理大别山伧父自动驾驶
LearningbyCheatinggithubcodearxivpaperconferenceonrobotlearning最新进展(May2021)Checkoutourlatestfollow-upwork:WorldonRails(2020)Checkoutoursubmissiontothe2020CARLAChallenge!pass
JVM 架构 : 运行时数据区 & 内存结构光剑书架上的书
JVM:JavaVirtualMachine架构JVMArchitectureRuntimeDataArea/MemoryStructureClassloaderClassloaderisasubsysteminJVM,whichisprimarilyresponasibleforloadingthejavaclasses,thereare3differentclassloaders:Bootst
Lt-8 Multithreading yanlingyun0210 java
IntendedLearningOutcomesTounderstandtheconceptofconcurrency.Tounderstandthedifferenceofaprocessandathread.TodefineathreadusingtheThreadclassandRunnableinterface.TocontrolthreadswithvariousThreadmethod
如何使用Pytorch-Metric-Learning？鱼儿也有烦恼 PyTorch pytorch
文章目录如何使用Pytorch-Metric-Learning？1.Pytorch-Metric-Learning库9个模块的功能1.1Sampler模块1.2Miner模块1.3Loss模块1.4Reducer模块1.5Distance模块1.6Regularizer模块1.7Trainer模块1.8Tester模块1.9Utils模块2.如何使用PyTorchMetricLearning库中的
risc-v特权模式狮子座硅农（Leo ICer） risc-v
risc-v架构定义了3种工作模式，又称为特权模式（privilegedmode）。机器模式（machinemode），简称M模式；监督模式（supervisormode），简称S模式；用户模式（usermode），简称U模式。risc-v架构定义机器模式为必选模式，另外两种模式为可选模式，通过不同的模式组合可以实现不同的系统。risc-v架构支持几种不同的存储器地址管理机制，包括对物理地址和虚拟
推荐开源项目：PyTorch-Metric-Learning 潘惟妍
推荐开源项目：PyTorch-Metric-Learningpytorch-metric-learningTheeasiestwaytousedeepmetriclearninginyourapplication.Modular,flexible,andextensible.WritteninPyTorch.项目地址:https://gitcode.com/gh_mirrors/py/pytorc
推荐：FastAPI驱动的稳定扩散LLMs演示项目褚知茉Jade
推荐：FastAPI驱动的稳定扩散LLMs演示项目FastAPI-for-Machine-Learning-Live-DemoThisrepositorycontainsthefilestobuildyourveryownAIimagegenerationwebapplication!OutlinedarethecorecomponentsoftheFastAPIwebframework,anda
【python】【Ray的概述】资源存储库 python 开发语言
Overview概述Rayisanopen-sourceunifiedframeworkforscalingAIandPythonapplicationslikemachinelearning.Itprovidesthecomputelayerforparallelprocessingsothatyoudon’tneedtobeadistributedsystemsexpert.Rayminimi
强大的销售团队背后竟然是大数据分析的身影蓝儿唯美数据分析
Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析
Haproxy+Keepalived高可用双机单活 bylijinnan 负载均衡 keepalived haproxy 高可用
我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 1.正常情况下，只有master启动MyApp并提供服务 2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过服务器资源 10.7
eclipse编辑器中文乱码问题解决 0624chenhong eclipse乱码
使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 本文以Eclipse 3.3（英文）为例加以说明： 1. 设置Workspace的编码格式： Windows-&g
基础篇--resources资源不懂事的小屁孩 android
最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 String.xml 字符串资源涉及国际化问题 http://www.2cto.com/kf/201302/190394.html string-array
接上篇补上window平台自动上传证书文件的批处理问卷酷的飞上天空 window
@echo off : host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称 set host=localhost set ou=localhost set o=localhost set password=123456 set validity=3650 set salias=s
企业物联网大潮涌动：如何做好准备？蓝儿唯美企业
物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
spring学习——数据库（mybatis持久化框架配置） a-john mybatis
Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
Java静态代理、动态代理实例 aijuans Java静态代理
采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。按照代理类的创建时期，可以分为：静态代理和动态代理。所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。一、静态代理类实例： 1、Serivce.ja
Struts1与Struts2的12点区别 asia007 Struts1与Struts2
1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
初学者要多看看帮助文档不要用js来写Jquery的代码百合不是茶 jquery js
解析json数据的时候需要将解析的数据写到文本框中, 出现了用js来写Jquery代码的问题; 1, JQuery的赋值有问题代码如下: data.username 表示的是: 网易 $("#use
经理怎么和员工搞好关系和信任 bijian1013 团队项目管理管理
产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
如何为rich:tree不同类型节点设置右键菜单 sunjing contextMenu tree Richfaces
组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}" selectionChangeListener=&qu
【Redis二】Redis2.8.17搭建主从复制环境 bit1129 redis
开始使用Redis2.8.17 Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。 Ubuntu上安装Red
JSONObject转换JSON--将Date转换为指定格式白糖_ JSONObject
项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式： {"nanos":0,"time":-27076233600000,
JavaScript语言精粹读书笔记 braveCS JavaScript
【经典用法】： //①定义新方法 Function .prototype.method=function(name, func){ this.prototype[name]=func; return this; } //②给Object增加一个create方法，这个方法创建一个使用原对
编程之美-找符合条件的整数用字符串来表示大整数避免溢出 bylijinnan 编程之美
import java.util.LinkedList; public class FindInteger { /** * 编程之美找符合条件的整数用字符串来表示大整数避免溢出 * 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0 * * 假设当前正在搜索由0，1组成的K位十进制数
读书笔记 chengxuyuancsdn 读书笔记
1、Struts访问资源 2、把静态参数传递给一个动作 3、<result>type属性 4、s:iterator、s:if c:forEach 5、StringBuilder和StringBuffer 6、spring配置拦截器 1、访问资源 (1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
[通讯与电力]光网城市建设的一些问题 comsci 问题
信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........
oracle 空间RESUMABLE daizj oracle 空间不足 RESUMABLE 错误挂起
空间RESUMABLE操作转 Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。这一篇简单介绍空间RESUMABLE的例子。第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
重构第一次写的线程池 dieslrae 线程池 python
最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 #!/usr/bin/env python # -*- coding:utf8 -*-
C语言学习六指针 dcj3sjt126com c
初识指针，简单示例程序： /* 指针就是地址，地址就是指针地址就是内存单元的编号指针变量是存放地址的变量指针和指针变量是两个不同的概念但是要注意：通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样 */ # include <stdio.h> int main(void) { int * p; // p是变量的名字， int *
yii2 beforeSave afterSave beforeDelete dcj3sjt126com delete
public function afterSave($insert, $changedAttributes) { parent::afterSave($insert, $changedAttributes); if($insert) { //这里是新增数据 } else { //这里是更新数据 } }
timertask shuizhaosi888 timertask
java.util.Timer timer = new java.util.Timer(true); // true 说明这个timer以daemon方式运行（优先级低， // 程序结束timer也自动结束），注意，javax.swing // 包中也有一个Timer类，如果import中用到swing包， // 要注意名字的冲突。 TimerTask task = new
Spring Security（13）——session管理 234390216 session Spring Security 攻击保护超时
session管理目录 1.1 检测session超时 1.2 concurrency-control 1.3 session 固定攻击保护
公司项目NODEJS实践0.3[ mongo / session ...] 逐行分析JS源代码 mongodb session nodejs
http://www.upopen.cn 一、前言书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
pojo.vo.po.domain区别 LiaoJuncai java VO POJO javabean domain
　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。　　　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
Windows Error Code OhMyCC windows
0 操作成功完成. 1 功能错误. 2 系统找不到指定的文件. 3 系统找不到指定的路径. 4 系统无法打开文件. 5 拒绝访问. 6 句柄无效. 7 存储控制块被损坏. 8 存储空间不足, 无法处理此命令. 9 存储控制块地址无效. 10 环境错误. 11 试图加载格式错误的程序. 12 访问码无效. 13 数据无效. 14 存储器不足, 无法完成此操作. 15 系
在storm集群环境下发布Topology roadrunners 集群 storm topology spout bolt
storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。 1、打包打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 <plugin> <groupId>org.apache.maven.
为什么不允许代码里出现“魔数” tomcat_oracle java
　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。　　很多开发者在这个检查方面都有问题，这可以从结果
zoj 3511 Cake Robbery(线段树) 阿尔萨斯线段树
题目链接：zoj 3511 Cake Robbery 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 #include <cstdio> #include <cstring> #include <vector&