hiudawn

Tensorflow对比AlexNet的CPU和GPU运算效率

代码及注释

from datetime import datetime
import math
import time 
import tensorflow as tf
c:\program files\python\python36\lib\site-packages\h5py\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.
  from ._conv import register_converters as _register_converters
batch_size = 32
num_batches = 100

# 该函数用来显示网络每一层的结构，展示tensor的尺寸
def print_activations(t):
    print(t.op.name, ' ',t.get_shape().as_list())


# with tf.name_scope('conv1') as scope  # 可以将scope之内的variable自动命名为conv1/xxx，便于区分不同组件
def inference(images):
    parameters = []
    # 第一个卷积层
    with tf.name_scope('conv1') as scope:
        # 卷积核、截断正态分布
        kernel = tf.Variable(tf.truncated_normal([11,11,3,64],
                                                dtype=tf.float32,stddev=1e-1),name='weights')
        conv = tf.nn.conv2d(images,kernel,[1,4,4,1],padding='SAME')
        # 可训练
        biases = tf.Variable(tf.constant(0.0,shape=[64],dtype=tf.float32),trainable=True,name='biases')
        bias = tf.nn.bias_add(conv,biases)
        conv1 = tf.nn.relu(bias,name=scope)
        print_activations(conv1)
        parameters += [kernel,biases]
        # 再加LRN和最大池化层，除了AlexNet，基本放弃了LRN，说是效果不明显，还会减速？
        lrn1 = tf.nn.lrn(conv1,4,bias=1.0,alpha=0.001/9,beta=0.75,name='lrn1')
        pool1 = tf.nn.max_pool(lrn1,ksize=[1,3,3,1],strides = [1,2,2,1],padding='VALID',name='pool1')
        print_activations(pool1)
    # 第二个卷积层，只有部分参数不同
    with tf.name_scope('conv2') as scope:
        kernel = tf.Variable(tf.truncated_normal([5,5,64,192],dtype=tf.float32,stddev=1e-1),name='weights')
        conv = tf.nn.conv2d(pool1,kernel,[1,1,1,1],padding='SAME')
        biases = tf.Variable(tf.constant(0.0,shape=[192],dtype=tf.float32),trainable=True,name='biases')
        bias = tf.nn.bias_add(conv,biases)
        conv2 = tf.nn.relu(bias,name=scope)
        parameters += [kernel,biases]
        print_activations(conv2)
        # 稍微处理一下
        lrn2 = tf.nn.lrn(conv2,4,bias=1.0,alpha = 0.001/9,beta=0.75,name='lrn2')
        pool2 = tf.nn.max_pool(lrn2,ksize=[1,3,3,1],strides=[1,2,2,1],padding='VALID',name='pool2')
        print_activations(pool2)
    # 第三个
    with tf.name_scope('conv3') as scope:
        kernel = tf.Variable(tf.truncated_normal([3,3,192,384],dtype=tf.float32,stddev=1e-1),name='weights')
        conv = tf.nn.conv2d(pool2,kernel,[1,1,1,1],padding='SAME')
        biases = tf.Variable(tf.constant(0.0,shape=[384],dtype=tf.float32),trainable=True,name='biases')
        bias = tf.nn.bias_add(conv,biases)
        conv3 = tf.nn.relu(bias,name=scope)
        parameters += [kernel,biases]
        print_activations(conv3)
    # 第四层
    with tf.name_scope('conv4') as scope:
        kernel = tf.Variable(tf.truncated_normal([3,3,384,256],dtype=tf.float32,stddev=1e-1),name='weights')
        conv = tf.nn.conv2d(conv3,kernel,[1,1,1,1],padding='SAME')
        biases = tf.Variable(tf.constant(0.0,shape=[256],dtype=tf.float32),trainable=True,name = 'biases')
        bias = tf.nn.bias_add(conv,biases)
        conv4 = tf.nn.relu(bias,name=scope)
        parameters += [kernel,biases]
        print_activations(conv4)
    # 第五个
    with tf.name_scope('conv5') as scope:
        kernel = tf.Variable(tf.truncated_normal([3,3,256,256],dtype=tf.float32,stddev=1e-1),name='weights')
        conv = tf.nn.conv2d(conv4,kernel,[1,1,1,1],padding= 'SAME')
        biases = tf.Variable(tf.constant(0.0,shape=[256],dtype=tf.float32),trainable=True,name='biases')
        bias = tf.nn.bias_add(conv,biases)
        conv5 = tf.nn.relu(bias,name=scope)
        parameters += [kernel,biases]
        print_activations(conv5)

        # 之后还有最大化池层
        pool5 = tf.nn.max_pool(conv5,ksize=[1,3,3,1],strides = [1,2,2,1],padding='VALID',name = 'pool5')
        print_activations(pool5)
        return pool5,parameters

# 全连接层


# 评估每轮计算时间，第一个输入是tf得Session，第二个是运算算子，第三个是测试名称
# 头几轮有显存加载，cache命中等问题，可以考虑只计算第10次以后的
def time_tensorflow_run(session,target,info_string):
    num_steps_burn_in = 10
    total_duration = 0.0
    total_duration_squared = 0.0
    # 进行num_batches+num_steps_burn_in次迭代
    # 用time.time()记录时间，热身过后，开始显示时间
    for i in range(num_batches + num_steps_burn_in):
        start_time = time.time()
        _ = session.run(target)
        duration = time.time() - start_time
        if i >= num_steps_burn_in:
            if not i %10:
                print('%s:step %d, duration = %.3f' % (datetime.now(),i-num_steps_burn_in,duration))
            total_duration += duration
            total_duration_squared += duration*duration
        # 计算每轮迭代品均耗时和标准差sd
        mn = total_duration/num_batches
        vr = total_duration_squared/num_batches - mn*mn
        sd = math.sqrt(vr)
        print('%s: %s across %d steps, %.3f +/- %.3f sec / batch' % (datetime.now(),info_string,num_batches,mn,sd))

def run_benchmark():
    # 首先定义默认的Graph
    with tf.Graph().as_default():
    # 并不实用ImageNet训练，知识随机计算耗时
        image_size = 224
        images = tf.Variable(tf.random_normal([batch_size,image_size,image_size,3],dtype=tf.float32,stddev=1e-1))
        pool5,parameters = inference(images)
        init = tf.global_variables_initializer()
        sess = tf.Session()
        sess.run(init)
        # 下面直接用pool5传入训练（没有全连接层）
        # 只是做做样子，并不是真的计算
        time_tensorflow_run(sess,pool5,"Forward")
        # 瞎弄的，伪装
        objective = tf.nn.l2_loss(pool5)
        grad = tf.gradients(objective,parameters)
        time_tensorflow_run(sess,grad,"Forward-backward")

run_benchmark()

cpu运行结果：

conv1  [32, 56, 56, 64]
conv1/pool1  [32, 27, 27, 64]
conv2  [32, 27, 27, 192]
conv2/pool2  [32, 13, 13, 192]
conv3  [32, 13, 13, 384]
conv4  [32, 13, 13, 256]
conv5  [32, 13, 13, 256]
conv5/pool5  [32, 6, 6, 256]
2018-04-07 22:04:02.078231: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:03.381361: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:04.645201: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:05.934559: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:07.261441: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:08.600831: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:09.864171: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:11.132014: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:12.440383: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:13.715730: Forward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:04:15.047116:step 0, duration = 1.330
2018-04-07 22:04:15.047616: Forward across 100 steps, 0.013 +/- 0.132 sec / batch
2018-04-07 22:04:16.427534: Forward across 100 steps, 0.027 +/- 0.190 sec / batch
2018-04-07 22:04:17.825463: Forward across 100 steps, 0.041 +/- 0.234 sec / batch
2018-04-07 22:04:19.149843: Forward across 100 steps, 0.054 +/- 0.266 sec / batch
2018-04-07 22:04:20.465219: Forward across 100 steps, 0.067 +/- 0.294 sec / batch
2018-04-07 22:04:21.931704: Forward across 100 steps, 0.082 +/- 0.325 sec / batch
2018-04-07 22:04:23.300113: Forward across 100 steps, 0.096 +/- 0.349 sec / batch
2018-04-07 22:04:24.705568: Forward across 100 steps, 0.110 +/- 0.373 sec / batch
2018-04-07 22:04:26.021455: Forward across 100 steps, 0.123 +/- 0.391 sec / batch
2018-04-07 22:04:27.387037: Forward across 100 steps, 0.137 +/- 0.410 sec / batch
2018-04-07 22:04:28.670890:step 10, duration = 1.283
2018-04-07 22:04:28.671891: Forward across 100 steps, 0.149 +/- 0.425 sec / batch
2018-04-07 22:04:29.951741: Forward across 100 steps, 0.162 +/- 0.440 sec / batch
2018-04-07 22:04:31.253607: Forward across 100 steps, 0.175 +/- 0.454 sec / batch
2018-04-07 22:04:32.656039: Forward across 100 steps, 0.189 +/- 0.470 sec / batch
2018-04-07 22:04:33.946397: Forward across 100 steps, 0.202 +/- 0.482 sec / batch
2018-04-07 22:04:35.237774: Forward across 100 steps, 0.215 +/- 0.493 sec / batch
2018-04-07 22:04:36.508665: Forward across 100 steps, 0.228 +/- 0.504 sec / batch
2018-04-07 22:04:37.887082: Forward across 100 steps, 0.242 +/- 0.516 sec / batch
2018-04-07 22:04:39.174097: Forward across 100 steps, 0.254 +/- 0.526 sec / batch
2018-04-07 22:04:40.512485: Forward across 100 steps, 0.268 +/- 0.536 sec / batch
2018-04-07 22:04:41.811973:step 20, duration = 1.299
2018-04-07 22:04:41.812475: Forward across 100 steps, 0.281 +/- 0.545 sec / batch
2018-04-07 22:04:43.105834: Forward across 100 steps, 0.294 +/- 0.554 sec / batch
2018-04-07 22:04:44.386699: Forward across 100 steps, 0.307 +/- 0.561 sec / batch
2018-04-07 22:04:45.649539: Forward across 100 steps, 0.319 +/- 0.569 sec / batch
2018-04-07 22:04:46.935394: Forward across 100 steps, 0.332 +/- 0.576 sec / batch
2018-04-07 22:04:48.270282: Forward across 100 steps, 0.345 +/- 0.583 sec / batch
2018-04-07 22:04:49.543627: Forward across 100 steps, 0.358 +/- 0.589 sec / batch
2018-04-07 22:04:50.811971: Forward across 100 steps, 0.371 +/- 0.595 sec / batch
2018-04-07 22:04:52.119853: Forward across 100 steps, 0.384 +/- 0.601 sec / batch
2018-04-07 22:04:53.490264: Forward across 100 steps, 0.398 +/- 0.608 sec / batch
2018-04-07 22:04:54.818654:step 30, duration = 1.328
2018-04-07 22:04:54.819154: Forward across 100 steps, 0.411 +/- 0.613 sec / batch
2018-04-07 22:04:56.146036: Forward across 100 steps, 0.424 +/- 0.619 sec / batch
2018-04-07 22:04:57.543481: Forward across 100 steps, 0.438 +/- 0.625 sec / batch
2018-04-07 22:04:58.914893: Forward across 100 steps, 0.452 +/- 0.630 sec / batch
2018-04-07 22:05:00.318326: Forward across 100 steps, 0.466 +/- 0.635 sec / batch
2018-04-07 22:05:01.642206: Forward across 100 steps, 0.479 +/- 0.639 sec / batch
2018-04-07 22:05:02.951076: Forward across 100 steps, 0.492 +/- 0.643 sec / batch
2018-04-07 22:05:04.296471: Forward across 100 steps, 0.506 +/- 0.646 sec / batch
2018-04-07 22:05:05.792464: Forward across 100 steps, 0.520 +/- 0.652 sec / batch
2018-04-07 22:05:07.362509: Forward across 100 steps, 0.536 +/- 0.658 sec / batch
2018-04-07 22:05:08.714419:step 40, duration = 1.351
2018-04-07 22:05:08.714920: Forward across 100 steps, 0.550 +/- 0.661 sec / batch
2018-04-07 22:05:10.368039: Forward across 100 steps, 0.566 +/- 0.667 sec / batch
2018-04-07 22:05:11.925074: Forward across 100 steps, 0.582 +/- 0.672 sec / batch
2018-04-07 22:05:13.389365: Forward across 100 steps, 0.596 +/- 0.675 sec / batch
2018-04-07 22:05:14.829647: Forward across 100 steps, 0.611 +/- 0.678 sec / batch
2018-04-07 22:05:16.287116: Forward across 100 steps, 0.625 +/- 0.680 sec / batch
2018-04-07 22:05:17.707072: Forward across 100 steps, 0.640 +/- 0.682 sec / batch
2018-04-07 22:05:19.012940: Forward across 100 steps, 0.653 +/- 0.682 sec / batch
2018-04-07 22:05:20.430382: Forward across 100 steps, 0.667 +/- 0.683 sec / batch
2018-04-07 22:05:21.800792: Forward across 100 steps, 0.680 +/- 0.683 sec / batch
2018-04-07 22:05:23.106659:step 50, duration = 1.305
2018-04-07 22:05:23.107161: Forward across 100 steps, 0.694 +/- 0.682 sec / batch
2018-04-07 22:05:24.418033: Forward across 100 steps, 0.707 +/- 0.681 sec / batch
2018-04-07 22:05:25.709418: Forward across 100 steps, 0.720 +/- 0.680 sec / batch
2018-04-07 22:05:27.040803: Forward across 100 steps, 0.733 +/- 0.679 sec / batch
2018-04-07 22:05:28.389215: Forward across 100 steps, 0.746 +/- 0.678 sec / batch
2018-04-07 22:05:29.674569: Forward across 100 steps, 0.759 +/- 0.676 sec / batch
2018-04-07 22:05:30.958422: Forward across 100 steps, 0.772 +/- 0.673 sec / batch
2018-04-07 22:05:32.305644: Forward across 100 steps, 0.785 +/- 0.671 sec / batch
2018-04-07 22:05:33.569985: Forward across 100 steps, 0.798 +/- 0.668 sec / batch
2018-04-07 22:05:34.848835: Forward across 100 steps, 0.811 +/- 0.665 sec / batch
2018-04-07 22:05:36.199232:step 60, duration = 1.350
2018-04-07 22:05:36.199733: Forward across 100 steps, 0.824 +/- 0.662 sec / batch
2018-04-07 22:05:37.558151: Forward across 100 steps, 0.838 +/- 0.659 sec / batch
2018-04-07 22:05:38.840033: Forward across 100 steps, 0.851 +/- 0.655 sec / batch
2018-04-07 22:05:40.112378: Forward across 100 steps, 0.863 +/- 0.651 sec / batch
2018-04-07 22:05:41.405738: Forward across 100 steps, 0.876 +/- 0.646 sec / batch
2018-04-07 22:05:42.745129: Forward across 100 steps, 0.890 +/- 0.642 sec / batch
2018-04-07 22:05:44.070010: Forward across 100 steps, 0.903 +/- 0.637 sec / batch
2018-04-07 22:05:45.362869: Forward across 100 steps, 0.916 +/- 0.632 sec / batch
2018-04-07 22:05:46.695755: Forward across 100 steps, 0.929 +/- 0.626 sec / batch
2018-04-07 22:05:48.006666: Forward across 100 steps, 0.942 +/- 0.620 sec / batch
2018-04-07 22:05:49.291521:step 70, duration = 1.284
2018-04-07 22:05:49.292021: Forward across 100 steps, 0.955 +/- 0.614 sec / batch
2018-04-07 22:05:50.568369: Forward across 100 steps, 0.968 +/- 0.607 sec / batch
2018-04-07 22:05:51.916775: Forward across 100 steps, 0.981 +/- 0.600 sec / batch
2018-04-07 22:05:53.247160: Forward across 100 steps, 0.995 +/- 0.593 sec / batch
2018-04-07 22:05:54.513500: Forward across 100 steps, 1.007 +/- 0.585 sec / batch
2018-04-07 22:05:55.794351: Forward across 100 steps, 1.020 +/- 0.577 sec / batch
2018-04-07 22:05:57.115230: Forward across 100 steps, 1.033 +/- 0.568 sec / batch
2018-04-07 22:05:58.434607: Forward across 100 steps, 1.047 +/- 0.560 sec / batch
2018-04-07 22:05:59.707954: Forward across 100 steps, 1.059 +/- 0.550 sec / batch
2018-04-07 22:06:01.056851: Forward across 100 steps, 1.073 +/- 0.540 sec / batch
2018-04-07 22:06:02.388235:step 80, duration = 1.331
2018-04-07 22:06:02.389236: Forward across 100 steps, 1.086 +/- 0.530 sec / batch
2018-04-07 22:06:03.818185: Forward across 100 steps, 1.100 +/- 0.520 sec / batch
2018-04-07 22:06:05.277789: Forward across 100 steps, 1.115 +/- 0.509 sec / batch
2018-04-07 22:06:06.727272: Forward across 100 steps, 1.129 +/- 0.498 sec / batch
2018-04-07 22:06:08.093180: Forward across 100 steps, 1.143 +/- 0.485 sec / batch
2018-04-07 22:06:09.585633: Forward across 100 steps, 1.158 +/- 0.472 sec / batch
2018-04-07 22:06:11.111158: Forward across 100 steps, 1.173 +/- 0.459 sec / batch
2018-04-07 22:06:12.512989: Forward across 100 steps, 1.187 +/- 0.444 sec / batch
2018-04-07 22:06:13.805348: Forward across 100 steps, 1.200 +/- 0.428 sec / batch
2018-04-07 22:06:15.113332: Forward across 100 steps, 1.213 +/- 0.411 sec / batch
2018-04-07 22:06:16.451307:step 90, duration = 1.337
2018-04-07 22:06:16.452307: Forward across 100 steps, 1.227 +/- 0.392 sec / batch
2018-04-07 22:06:17.779690: Forward across 100 steps, 1.240 +/- 0.373 sec / batch
2018-04-07 22:06:19.064052: Forward across 100 steps, 1.253 +/- 0.351 sec / batch
2018-04-07 22:06:20.342401: Forward across 100 steps, 1.266 +/- 0.328 sec / batch
2018-04-07 22:06:21.650772: Forward across 100 steps, 1.279 +/- 0.302 sec / batch
2018-04-07 22:06:22.920115: Forward across 100 steps, 1.291 +/- 0.274 sec / batch
2018-04-07 22:06:24.254011: Forward across 100 steps, 1.305 +/- 0.241 sec / batch
2018-04-07 22:06:25.709478: Forward across 100 steps, 1.319 +/- 0.202 sec / batch
2018-04-07 22:06:27.372083: Forward across 100 steps, 1.336 +/- 0.156 sec / batch
2018-04-07 22:06:28.808038: Forward across 100 steps, 1.350 +/- 0.081 sec / batch
2018-04-07 22:06:35.461935: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:06:41.997287: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:06:48.182993: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:06:54.358695: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:07:00.541870: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:07:06.823545: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:07:12.998150: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:07:19.139292: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:07:25.350639: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:07:31.543266: Forward-backward across 100 steps, 0.000 +/- 0.000 sec / batch
2018-04-07 22:07:37.788917:step 0, duration = 6.245
2018-04-07 22:07:37.789417: Forward-backward across 100 steps, 0.062 +/- 0.621 sec / batch
2018-04-07 22:07:43.974582: Forward-backward across 100 steps, 0.124 +/- 0.870 sec / batch
2018-04-07 22:07:50.103804: Forward-backward across 100 steps, 0.186 +/- 1.055 sec / batch
2018-04-07 22:07:56.308428: Forward-backward across 100 steps, 0.248 +/- 1.213 sec / batch
2018-04-07 22:08:02.566087: Forward-backward across 100 steps, 0.310 +/- 1.352 sec / batch
2018-04-07 22:08:08.795247: Forward-backward across 100 steps, 0.372 +/- 1.474 sec / batch
2018-04-07 22:08:14.924900: Forward-backward across 100 steps, 0.434 +/- 1.581 sec / batch
2018-04-07 22:08:21.144569: Forward-backward across 100 steps, 0.496 +/- 1.682 sec / batch
2018-04-07 22:08:27.448335: Forward-backward across 100 steps, 0.559 +/- 1.778 sec / batch
2018-04-07 22:08:33.655970: Forward-backward across 100 steps, 0.621 +/- 1.863 sec / batch
2018-04-07 22:08:40.002033:step 10, duration = 6.346
2018-04-07 22:08:40.003033: Forward-backward across 100 steps, 0.684 +/- 1.947 sec / batch
2018-04-07 22:08:46.189682: Forward-backward across 100 steps, 0.746 +/- 2.021 sec / batch
2018-04-07 22:08:52.435864: Forward-backward across 100 steps, 0.809 +/- 2.092 sec / batch
2018-04-07 22:08:58.665004: Forward-backward across 100 steps, 0.871 +/- 2.159 sec / batch
2018-04-07 22:09:04.900665: Forward-backward across 100 steps, 0.933 +/- 2.222 sec / batch
2018-04-07 22:09:11.080890: Forward-backward across 100 steps, 0.995 +/- 2.280 sec / batch
2018-04-07 22:09:17.550010: Forward-backward across 100 steps, 1.060 +/- 2.342 sec / batch
2018-04-07 22:09:23.804166: Forward-backward across 100 steps, 1.122 +/- 2.396 sec / batch
2018-04-07 22:09:30.818193: Forward-backward across 100 steps, 1.193 +/- 2.464 sec / batch
2018-04-07 22:09:37.286491: Forward-backward across 100 steps, 1.257 +/- 2.516 sec / batch
2018-04-07 22:09:44.119077:step 20, duration = 6.832
2018-04-07 22:09:44.120579: Forward-backward across 100 steps, 1.326 +/- 2.573 sec / batch
2018-04-07 22:09:51.168940: Forward-backward across 100 steps, 1.396 +/- 2.632 sec / batch
2018-04-07 22:09:58.243589: Forward-backward across 100 steps, 1.467 +/- 2.688 sec / batch
2018-04-07 22:10:04.727410: Forward-backward across 100 steps, 1.532 +/- 2.729 sec / batch
2018-04-07 22:10:11.002081: Forward-backward across 100 steps, 1.594 +/- 2.765 sec / batch
2018-04-07 22:10:17.775683: Forward-backward across 100 steps, 1.662 +/- 2.808 sec / batch
2018-04-07 22:10:24.408629: Forward-backward across 100 steps, 1.728 +/- 2.846 sec / batch
2018-04-07 22:10:30.710613: Forward-backward across 100 steps, 1.791 +/- 2.877 sec / batch
2018-04-07 22:10:37.306567: Forward-backward across 100 steps, 1.857 +/- 2.910 sec / batch
2018-04-07 22:10:43.785874: Forward-backward across 100 steps, 1.922 +/- 2.940 sec / batch
2018-04-07 22:10:50.352258:step 30, duration = 6.566
2018-04-07 22:10:50.352759: Forward-backward across 100 steps, 1.988 +/- 2.970 sec / batch
2018-04-07 22:10:56.846428: Forward-backward across 100 steps, 2.053 +/- 2.996 sec / batch
2018-04-07 22:11:03.307729: Forward-backward across 100 steps, 2.117 +/- 3.021 sec / batch
2018-04-07 22:11:09.610920: Forward-backward across 100 steps, 2.180 +/- 3.042 sec / batch
2018-04-07 22:11:15.950465: Forward-backward across 100 steps, 2.244 +/- 3.062 sec / batch
2018-04-07 22:11:22.532876: Forward-backward across 100 steps, 2.310 +/- 3.083 sec / batch
2018-04-07 22:11:28.878169: Forward-backward across 100 steps, 2.373 +/- 3.100 sec / batch
2018-04-07 22:11:35.081804: Forward-backward across 100 steps, 2.435 +/- 3.114 sec / batch
2018-04-07 22:11:42.013672: Forward-backward across 100 steps, 2.504 +/- 3.136 sec / batch
2018-04-07 22:11:48.819330: Forward-backward across 100 steps, 2.572 +/- 3.155 sec / batch
2018-04-07 22:11:55.479284:step 40, duration = 6.659
2018-04-07 22:11:55.480285: Forward-backward across 100 steps, 2.639 +/- 3.170 sec / batch
2018-04-07 22:12:01.803794: Forward-backward across 100 steps, 2.702 +/- 3.180 sec / batch
2018-04-07 22:12:08.027946: Forward-backward across 100 steps, 2.764 +/- 3.187 sec / batch
2018-04-07 22:12:14.246596: Forward-backward across 100 steps, 2.827 +/- 3.194 sec / batch
2018-04-07 22:12:20.853037: Forward-backward across 100 steps, 2.893 +/- 3.203 sec / batch
2018-04-07 22:12:27.755235: Forward-backward across 100 steps, 2.962 +/- 3.214 sec / batch
2018-04-07 22:12:34.547499: Forward-backward across 100 steps, 3.030 +/- 3.222 sec / batch
2018-04-07 22:12:41.893929: Forward-backward across 100 steps, 3.103 +/- 3.236 sec / batch
2018-04-07 22:12:48.495318: Forward-backward across 100 steps, 3.169 +/- 3.240 sec / batch
2018-04-07 22:12:54.999182: Forward-backward across 100 steps, 3.234 +/- 3.241 sec / batch
2018-04-07 22:13:01.428955:step 50, duration = 6.429
2018-04-07 22:13:01.429456: Forward-backward across 100 steps, 3.298 +/- 3.240 sec / batch
2018-04-07 22:13:07.911265: Forward-backward across 100 steps, 3.363 +/- 3.238 sec / batch
2018-04-07 22:13:15.010983: Forward-backward across 100 steps, 3.434 +/- 3.241 sec / batch
2018-04-07 22:13:21.574445: Forward-backward across 100 steps, 3.500 +/- 3.237 sec / batch
2018-04-07 22:13:28.327446: Forward-backward across 100 steps, 3.567 +/- 3.234 sec / batch
2018-04-07 22:13:35.170995: Forward-backward across 100 steps, 3.636 +/- 3.230 sec / batch
2018-04-07 22:13:43.325071: Forward-backward across 100 steps, 3.717 +/- 3.240 sec / batch
2018-04-07 22:13:50.248083: Forward-backward across 100 steps, 3.787 +/- 3.234 sec / batch
2018-04-07 22:13:57.226529: Forward-backward across 100 steps, 3.856 +/- 3.227 sec / batch
2018-04-07 22:14:05.166786: Forward-backward across 100 steps, 3.936 +/- 3.229 sec / batch
2018-04-07 22:14:13.147299:step 60, duration = 7.980
2018-04-07 22:14:13.148299: Forward-backward across 100 steps, 4.016 +/- 3.229 sec / batch
2018-04-07 22:14:19.532873: Forward-backward across 100 steps, 4.079 +/- 3.212 sec / batch
2018-04-07 22:14:25.992300: Forward-backward across 100 steps, 4.144 +/- 3.194 sec / batch
2018-04-07 22:14:32.404073: Forward-backward across 100 steps, 4.208 +/- 3.175 sec / batch
2018-04-07 22:14:38.651726: Forward-backward across 100 steps, 4.271 +/- 3.153 sec / batch
2018-04-07 22:14:45.506017: Forward-backward across 100 steps, 4.339 +/- 3.134 sec / batch
2018-04-07 22:14:52.723815: Forward-backward across 100 steps, 4.411 +/- 3.116 sec / batch
2018-04-07 22:14:59.618563: Forward-backward across 100 steps, 4.480 +/- 3.094 sec / batch
2018-04-07 22:15:06.859808: Forward-backward across 100 steps, 4.553 +/- 3.073 sec / batch
2018-04-07 22:15:13.477717: Forward-backward across 100 steps, 4.619 +/- 3.045 sec / batch
2018-04-07 22:15:20.112636:step 70, duration = 6.634
2018-04-07 22:15:20.113135: Forward-backward across 100 steps, 4.685 +/- 3.016 sec / batch
2018-04-07 22:15:27.965407: Forward-backward across 100 steps, 4.764 +/- 2.995 sec / batch
2018-04-07 22:15:34.965559: Forward-backward across 100 steps, 4.834 +/- 2.964 sec / batch
2018-04-07 22:15:42.242897: Forward-backward across 100 steps, 4.906 +/- 2.934 sec / batch
2018-04-07 22:15:49.095452: Forward-backward across 100 steps, 4.975 +/- 2.898 sec / batch
2018-04-07 22:15:55.880514: Forward-backward across 100 steps, 5.043 +/- 2.860 sec / batch
2018-04-07 22:16:03.602515: Forward-backward across 100 steps, 5.120 +/- 2.827 sec / batch
2018-04-07 22:16:11.750931: Forward-backward across 100 steps, 5.201 +/- 2.796 sec / batch
2018-04-07 22:16:18.997248: Forward-backward across 100 steps, 5.274 +/- 2.754 sec / batch
2018-04-07 22:16:25.345089: Forward-backward across 100 steps, 5.337 +/- 2.704 sec / batch
2018-04-07 22:16:31.857926:step 80, duration = 6.512
2018-04-07 22:16:31.858927: Forward-backward across 100 steps, 5.402 +/- 2.653 sec / batch
2018-04-07 22:16:38.345797: Forward-backward across 100 steps, 5.467 +/- 2.598 sec / batch
2018-04-07 22:16:44.743050: Forward-backward across 100 steps, 5.531 +/- 2.541 sec / batch
2018-04-07 22:16:51.504735: Forward-backward across 100 steps, 5.599 +/- 2.482 sec / batch
2018-04-07 22:16:58.363358: Forward-backward across 100 steps, 5.668 +/- 2.421 sec / batch
2018-04-07 22:17:04.801136: Forward-backward across 100 steps, 5.732 +/- 2.354 sec / batch
2018-04-07 22:17:11.422538: Forward-backward across 100 steps, 5.798 +/- 2.284 sec / batch
2018-04-07 22:17:18.029753: Forward-backward across 100 steps, 5.864 +/- 2.209 sec / batch
2018-04-07 22:17:24.838779: Forward-backward across 100 steps, 5.932 +/- 2.131 sec / batch
2018-04-07 22:17:31.531255: Forward-backward across 100 steps, 5.999 +/- 2.047 sec / batch
2018-04-07 22:17:38.791928:step 90, duration = 7.260
2018-04-07 22:17:38.792429: Forward-backward across 100 steps, 6.072 +/- 1.960 sec / batch
2018-04-07 22:17:47.367134: Forward-backward across 100 steps, 6.157 +/- 1.878 sec / batch
2018-04-07 22:17:55.087142: Forward-backward across 100 steps, 6.235 +/- 1.780 sec / batch
2018-04-07 22:18:02.064306: Forward-backward across 100 steps, 6.304 +/- 1.667 sec / batch
2018-04-07 22:18:08.902851: Forward-backward across 100 steps, 6.373 +/- 1.543 sec / batch
2018-04-07 22:18:15.971768: Forward-backward across 100 steps, 6.443 +/- 1.405 sec / batch
2018-04-07 22:18:23.112095: Forward-backward across 100 steps, 6.515 +/- 1.248 sec / batch
2018-04-07 22:18:30.340400: Forward-backward across 100 steps, 6.587 +/- 1.065 sec / batch
2018-04-07 22:18:36.829714: Forward-backward across 100 steps, 6.652 +/- 0.834 sec / batch
2018-04-07 22:18:43.282010: Forward-backward across 100 steps, 6.717 +/- 0.500 sec / batch

gpu：

后话

差了50倍，可以洗洗睡了（20180407，我，还没有GPU）(20180506我也还没有)

AlexNet 使用GPU、ReLU、Dropout和LRN和Trick。转折点

你可能感兴趣的:(deeplearning)

云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
机器学习VS深度学习 nfgo 机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
linux查看jupyter运行,在Linux服务器上运行Jupyter notebook server教程天启大烁哥
在Linux服务器上运行Jupyternotebookserver教程很多deeplearning教程都推荐在jupyternotebook运行python代码，方便及时交互。但只在本地运行没有GPU环境，虽然googlecolab是个好办法，但发现保存模型后在云端找不到模型文件，且需要合理上网才能访问。于是想给实验室的服务器配置jupyternotebook，供本机远程访问。踩了不少坑，码一下教
使用matlab的热门问题七十二五值得关注 matlab 开发语言青少年编程算法经验分享
MATLAB广泛应用于科学计算、数据分析、信号处理、图像处理、机器学习等多个领域，因此热门问题也涵盖了这些方面。以下是一些可能被认为当前最热门的MATLAB问题：深度学习与神经网络：如何使用MATLAB的深度学习工具箱（DeepLearningToolbox）来构建和训练神经网络？如何利用MATLAB进行图像识别、语音识别或自然语言处理等深度学习应用？数据分析与可视化：如何使用MATLAB进行大数
COI实验室技能：图像到图像的深度学习开发框架（pytorch版）山颠海涯深度学习 pytorch 人工智能
Basicdeeplearningframeworkforimage-to-image这个开发框架旨在帮助科研人员快速地实现图像到图像之间的模型开发。github连接：https://github.com/SituLab/Basic-deep-learning-framework-for-image-to-image目录1模型开发1-1克隆项目到本地1-2深度学习开发2环境配置2-1安装conda
Python深度学习-环境 cunzai1985 tensorflow python 深度学习人工智能 anaconda
Python深度学习-环境(PythonDeepLearning-Environment)Inthischapter,wewilllearnabouttheenvironmentsetupforPythonDeepLearning.Wehavetoinstallthefollowingsoftwareformakingdeeplearningalgorithms.在本章中，我们将学习为Python
深度学习-OpenCV运用（3）红米煮粥深度学习 opencv 人工智能
文章目录一、简介二、OpenCV运用1.图片扩充2.图像阈值处理3.添加椒盐噪声三、总结一、简介深度学习（DeepLearning）与OpenCV（OpenSourceComputerVisionLibrary）的结合为计算机视觉领域带来了强大的解决方案。OpenCV是一个开源的计算机视觉和机器学习软件库，它提供了大量的视觉处理算法，包括但不限于图像和视频处理、特征检测、对象识别等。二、OpenC
【论文阅读】Purloining Deep Learning Models Developed for an Ultrasound Scanner to a Competitor Machine Bosenya12 科研学习模型窃取论文阅读深度学习人工智能模型安全
TheArtoftheSteal:PurloiningDeepLearningModelsDevelopedforanUltrasoundScannertoaCompetitorMachine（2024）摘要Atransferfunctionapproach（传递函数方法）hasrecentlyproveneffectiveforcalibratingdeeplearning(DL)algorit
【论文阅读】QUEEN: Query Unlearning against Model Extraction（2024） Bosenya12 科研学习模型窃取论文阅读提取攻击模型安全
摘要Modelextractionattacks（模型提取攻击）currentlyposeanon-negligiblethreat（不可忽视的威胁）tothesecurity（安全性）andprivacy（隐私性）ofdeeplearningmodels.Byqueryingthemodelwithasmalldataset（通过小数据集查询模型）andusingthequeryresultsa
【论文阅读33】Deep learning optoacoustic tomography with sparse data 弹伦琴的雷登【论文阅读系列】人工智能深度学习论文阅读图像处理
Deeplearningoptoacoustictomographywithsparsedata论文题目：基于稀疏数据的深度学习光声断层扫描论文链接：Deeplearningoptoacoustictomographywithsparsedata|NatureMachineIntelligence代码链接：GitHub-ndavoudi/sparse_artefact_unet数据链接：Data发
python里的i_Python 中[::] 与 [:,:,i] 总结桌游顽主的航仔 python里的i
最近在学吴恩达的DeepLearning中的第五门课SequenceModel,第一个lab是用Numpy搭建RNN，在搭建RNN的时候用到了Numpy的Slicing([:,:,i]),在这里想总结下[:,:,i]与[::i]的用法，有写的不对的地方请随时指教。总的来说，[::i]是Python中的基础索引，而[:,:,i]是Numpy中对于多维度Array的提取，在StackOverflow中
智能合约漏洞检测论文 weixin_45332030 智能合约
综述TestingEthereumSmartContracts:AComparisonofSymbolicAnalysisandFuzzTestingTools符号执行与模糊测试工具的比较综述DeepLearningBasedVulnerabilityDetection:AreWeThereYet?基于深度学习的漏洞检测研究https://github.com/VulDetProject/ReVe
机器学习概述与应用：深度学习、人工智能与经典学习方法刷刷刷粉刷匠人工智能机器学习深度学习
引言机器学习（MachineLearning）是人工智能（AI）领域中最为核心的分支之一，其主要目的是通过数据学习和构建模型，帮助计算机系统自动完成特定任务。随着深度学习（DeepLearning）的崛起，机器学习技术在各行各业中的应用变得越来越广泛。在本文中，我们将详细介绍机器学习的基础概念，包括无监督学习、有监督学习、增量学习，以及常见的回归和分类问题，并结合实际代码示例来加深理解。1.机器学
【现学现卖】CHEER中的概念解释——k-mer 番茄随笔
“概念理解”CHEER:HierarCHicaltaxonomicclassificationforviralmEtagEnomicdataviadeepleaRning对这篇文章中概念的理解：【现学现卖】CHEER与病毒宏基因组数据分析（1）【现学现卖】CHEER与病毒宏基因组数据分析（2）k-mer单独的k-mer很好理解，就是从一段序列中迭代分割提取长度为k的几个子序列（一般k为奇数，使用例
Learning Deep Learning（学习深度学习） weixin_34056162 开发工具人工智能 python
作者：chen_h微信号&QQ：862251340微信公众号：coderpai简书地址：https://www.jianshu.com/p/e98...LearningDeepLearning（学习深度学习）TherearelotsofawesomereadinglistsorpoststhatsummarizedmaterialsrelatedtoDeepLearning.SowhywouldI
【论文阅读】APMSA: Adversarial Perturbation Against Model Stealing Attacks（2023） Bosenya12 科研学习模型窃取论文阅读模型窃取防御对抗性扰动
摘要TrainingaDeepLearning(DL)model（训练深度学习模型）requiresproprietarydata（专有数据）andcomputing-intensiveresources（计算密集型资源）.Torecouptheirtrainingcosts（收回训练成本）,amodelprovidercanmonetizeDLmodelsthroughMachineLearni
DeePhage：预测噬菌体的生活方式 CAAS_IFR_zp 生活
GitHub-shufangwu/DeePhage:Atoolfordistinguishtemperatephage-derivedandvirulentphage-derivedsequenceinmetaviromedatausingdeeplearning安装condacreate-ndeephagecondaactivatedeephagepipinstallnumpypipinstal
机器学习、深度学习、神经网络之间的关系你好，工程师 AI 机器学习
机器学习（MachineLearning）、深度学习（DeepLearning）和神经网络（NeuralNetworks）之间存在密切的关系，它们可以被看作是一种逐层递进的关系。下面简要介绍它们之间的关系：机器学习（MachineLearning）：机器学习是一种人工智能的分支，关注如何通过数据让计算机系统从经验中学习，提高性能。机器学习算法可以分为监督学习、无监督学习、半监督学习和强化学习等不同
认识小波-DWT CWT Scattering 闪闪发亮的小星星数字信号处理与分析计算机视觉人工智能信号处理
这里写自定义目录标题小波变换的种类连续小波变换（CWT）DWTANexampleapplicationofDWTANexampleofCWT5.MachineLearningandDeepLearningwithWaveletScattering小波散射网络大家好。在本次介绍性课程中，我将介绍一些基本的小波概念。我将主要使用一维示例，但相同的概念也可以应用于图像。首先，我们回顾一下什么是小波。现实
Mastering Convolutional Neural Networks: A Comprehensive Practical Exploration Bio大恐龙人工智能深度学习数据可视化机器学习
ConvolutionalNeuralNetworks(CNNs)haverevolutionizedthefieldofcomputervisionandimagerecognition,enablinggroundbreakingadvancementsinvariousdomains.Thesepowerfuldeeplearningmodelshaveproventheirprowessi
精读《深度学习 - 函数式之美》可口可乐Vip 前端深度学习人工智能
1引言函数式语言在深度学习领域应用很广泛，因为函数式与深度学习模型的契合度很高，TheBeautyofFunctionalLanguagesinDeepLearning — ClojureandHaskell就很好的诠释了这个道理。通过这篇文章可以加深我们对深度学习与函数式编程的理解。2概述与精读深度学习是机器学习中基于人工神经网络模型的一个分支，通过模拟多层神经元的自编码神经网络，将特征逐步抽象
苹果手机怎么学python_我是如何在 Python 内使用深度学习实现 iPhone X 的 FaceID 的... weixin_39693437 苹果手机怎么学python
雷锋网按：本文为AI研习社编译的技术博客，原标题HowIimplementediPhoneX'sFaceIDusingDeepLearninginPython，作者为SHIVAMBANSAL。翻译|陶玉龙余杭校对|Lamaric整理|MY在最近推出的iPhoneX中，它被讨论最多的特点之一是它采用了新的解锁方法，即TouchID：FaceID。在研发出无边框手机后，苹果公司想开发一种新的方法来快捷
解决conda环境下import TensorFlow失败的问题绿竹巷人功能安装 conda tensorflow 人工智能
问题描述安装了anaconda的电脑，新建了一个名叫deeplearning的环境，在该环境下已经成功安装了tensorflow。于是在终端打开python并执行代码importtensorflowastfprint(1)除了提示2024-02-2721:50:00.801427:Iexternal/local_tsl/tsl/cuda/cudart_stub.cc:31]Couldnotfind
Deep Learning with OpenCV DNN Module介绍 lida2003 Linux 深度学习 opencv dnn 计算机视觉人工智能
DeepLearningwithOpenCVDNNModule介绍1.源由2.为什么/什么是OpenCVDNNModule?2.1支持的不同深度学习功能2.2支持的不同模型2.3支持的不同框架3.如何使用OpenCVDNN模块3.1使用从Keras和PyTorch等不同框架转换为ONNX格式的模型3.2使用OpenCVDNN模块的基本步骤4.参考资料1.源由看了一些资料和数据，感觉他讲的非常好，也
文献阅读（42）——使用深度学习在眼底照中检测糖网并分类（综述）柚子味的羊文献阅读深度学习分类人工智能
使用深度学习在眼底照中检测糖网并分类（综述）Deeplearningfordiabeticretinopathydetectionandclassificationbasedonfundusimages:AreviewIF=6.698/Q1文章目录使用深度学习在眼底照中检测糖网并分类（综述）先验知识/知识拓展文章结构文章结果1.introduction方法1.眼底图像一般的分析pipeline2.
深度学习——概念引入韶光流年都束之高阁深度学习日记深度学习人工智能职场和发展
深度学习深度学习简介深度学习分类根据网络结构划分：循环神经网络卷积神经网络根据学习方式划分：监督学习无监督学习半监督学习根据应用领域划分：计算机视觉自然语言处理语音识别生物信息学深度学习简介深度学习（DeepLearning，DL）是机器学习领域中的一个新的研究方向，主要是通过学习样本数据的内在规律和表示层次，让机器能够具有类似于人类的分析学习能力。深度学习的最终目标是让机器能够识别和解释各种数据
ChatGPT魔法1：背后的原理王丰博 GPT chatgpt
1.AI的三个阶段1）上世纪50~60年代，计算机刚刚产生2）Machinelearning3）Deeplearning，有神经网络，最有代表性的是ChatGPT,GPT(GenerativePre-TrainedTransformer)2.深度神经网络llyaSutskever:做图像识别，使用了GPT去并行计算及训练。Alexnet数据库已经label好的（李飞飞）GPU算力3.GPT3.1T
中科院一区论文复现，改进蜣螂算法，Fuch映射+反向学习+自适应步长+随机差分变异，MATLAB代码... 今天吃饺子算法学习 matlab 开发语言
本期文章复现一篇发表于2024年来自中科院一区TOP顶刊《Energy》的改进蜣螂算法。论文引用如下：LiY,SunK,YaoQ,etal.Adual-optimizationwindspeedforecastingmodelbasedondeeplearningandimproveddungbeetleoptimizationalgorithm[J].Energy,2024,286:129604
速读-张量流处理器（TSP） Reacubeth 徐奕的专栏机器学习人工智能体系结构深度学习
Paper:Abts,Dennis,etal.“Thinkfast:atensorstreamingprocessor(TSP)foracceleratingdeeplearningworkloads.”2020ACM/IEEE47thAnnualInternationalSymposiumonComputerArchitecture(ISCA).IEEE,2020.简介本文介绍了一种名为张量流处
如何在6个月内学习深度学习(翻译) 三猫后端
原文链接：如何在6个月内学习深度学习(翻译)微信公众号：机器学习养成记搜索添加微信公众号：chenchenwings机器学习工程师Bargava的文章《HowtolearnDeepLearningin6months》介绍了6个月内学习并掌握深度学习的实现步骤，每个步骤列出了相应的学习材料和学习目标。本周公众号内容为原文的部分内容翻译。准备6个月内，每周将花费10-20小时。需要一些编程基础。这样便
二分查找排序算法周凡杨 java 二分查找排序算法折半
一：概念二分查找又称折半查找（折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
java中的BigDecimal bijian1013 java BigDecimal
在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。原文地址：http://blog.csdn.net/ugg/article/de
Shell echo命令详解 daizj echo shell
Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
Oracle DBA 简单操作周凡杨 oracle dba sql
--执行次数多的SQL select sql_text,executions from ( select sql_text,executions from v$sqlarea order by executions desc ) where rownum<81; &nb
画图重绘朱辉辉33 游戏
我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
线程之初体验西蜀石兰线程
一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
linux集群互相免登陆配置林鹤霄 linux
配置ssh免登陆 1、生成秘钥和公钥 ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub 其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密 c
mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html 原因是你使用的InnoDB 表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错. 你可以把这个时间加长,或者优化存储
Socket编程基本的聊天实现。 alleni123 socket
public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
多线程监听器事件模式(一个简单的例子) 百合不是茶线程监听模式
多线程的事件监听器模式监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到创建多线程的事件监听器模式思路: 1, 创建线程并启动,在创建线程的位置设置一个标记 2,创建队
spring InitializingBean接口 bijian1013 java spring
spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle 数据库权限
Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
【Struts2五】Struts2 参数传值 bit1129 struts2
Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
I got serveral questions about auto.offset.reset. This configuration parameter governs how consumer read the message from Kafka when there is no initial offset in ZooKeeper or
nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
nginx gzip压缩配置更多 0 nginx gzip 配置随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
Spring源码学习-JdbcTemplate queryForObject bylijinnan java spring
JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
[冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
看美国那边的气候情况....我有个感觉...是不是要进入小冰期了? 那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段... &nb
js 获取浏览器型号 cuityang js 浏览器
根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head> <meta charset="utf-8" content="text/html"/> <meta name=
C# socks5详解转 dalan_123 socket C#
http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html 这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
运维 Centos问题汇总 dcj3sjt126com 云主机
一、sh 脚本不执行的原因 sh脚本不执行的原因只有2个 1.权限不够 2.sh脚本里路径没写完整。二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom 三、查询连接数
Yii防注入攻击笔记 dcj3sjt126com sql WEB安全 yii
网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
MongoDB简介[一] eksliang mongodb MongoDB简介
MongoDB简介转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用 MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。另外，不
zookeeper windows 入门安装和测试 greemranqq zookeeper 安装分布式
一、序言以下是我对zookeeper 的一些理解： zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。栗子1号：假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
Spring之使用事务缘由(2-注解实现) ihuning spring
Spring事务注解实现 1. 依赖包： 1.1 spring包： spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.
iOS App Launch Option 啸笑天 option
iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。 launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节。 1、若用户直接
jdk与jre的区别（_） macroli java jvm jdk
简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。 JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。如果安装了JDK，会发同你
Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象 git
$ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
[一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hive hive元数据结构
关键字：Hive元数据、Hive元数据表结构之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。文章最后面，会以一个示例来全面了解一下，
Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。其中Spring 4.1.7主要包含这些更新内容。