精华内容
下载资源
问答
  • 14-降噪自编码-增强抗干扰能力

    千次阅读 2018-09-19 21:03:11
    本篇将围绕TinyMind 汉字书法识别自由练习赛中的比赛数据中单个字做数据增强操作,就是依据降噪自编码的原理将相对标准的字形作为训练结果,然后将比赛的单个字所有数据作为输入,简单训练一个有回溯能力的网络结构...

    一、前言
    本篇将围绕TinyMind 汉字书法识别自由练习赛中的比赛数据中单个字做数据增强操作,就是依据降噪自编码的原理将相对标准的字形作为训练结果,然后将比赛的单个字所有数据作为输入,简单训练一个有回溯能力的网络结构。该结构近似的将比赛数据模拟成噪声数据,输出的结果为真实的数据,这样可以在更多分类任务时让模型拥有更好的鲁棒性。也就会获得更好的结果。
    二、相关概念
    去噪自编码器:(Denoising Autoencoder,DA),是在自动编码的基础上,训练数据加入噪声,输出的标签仍是原始的样本(没有加过噪声的),这样自动编码器必须学习去除噪声而获得真正的没有被噪声污染过的输入特征。因此,这就迫使编码器去学习输入信号的更加鲁棒的特征表达,即具有更好的泛化能力。
    三、具体实现
    本篇只显示关键代码字段

    #获取去噪编码结果
    def get_Y(size=(64,64),channels=1):
        #list_words=os.listdir('words')
        #读取图片信息
        word_name='且.png'
        file_content=tf.gfile.FastGFile('words/'+word_name,'rb').read()
        #解码
        image_tensor=tf.image.decode_png(file_content,channels=channels)
        #resize image
        image_tensor=tf.image.resize_images(image_tensor,size=size,method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
    
        image_tensor=tf.reshape(image_tensor,[-1,4096])
        print(image_tensor.get_shape())
        return image_tensor
    
    
    #学习参数
    weight={
        'h1':tf.Variable(tf.random_normal([n_input,n_hidden_1])),
        'h2':tf.Variable(tf.random_normal([n_hidden_1,n_hidden_1])),
        'out':tf.Variable(tf.random_normal([n_hidden_1,n_input]))
    }
    biases={
        'b1':tf.Variable(tf.zeros([n_hidden_1])),
        'b2':tf.Variable(tf.zeros([n_hidden_1])),
        'out':tf.Variable(tf.zeros([n_input]))
    }
    
    
    #网络模型
    def encoder(X_input,weight,biases):
        layer_1=tf.nn.sigmoid(tf.add(tf.matmul(X_input,weight['h1']),biases['b1']))
        #layer_1out=tf.nn.dropout(layer_1,keep_prob=1)
        layer_2=tf.nn.sigmoid(tf.add(tf.matmul(layer_1,weight['h2']),biases['b2']))
        #layer_2out=tf.nn.dropout(layer_2,keep_prob=1)
        return tf.matmul(layer_2,weight['out'])+biases['out']
    
    tf.InteractiveSession()
    #获取数据
    train_X=read_train_data.get_a_category_message('且')   #(400,4096)
    train_Y=get_Y()                        #(1,4096)
    train_Y=train_Y.eval()
    #定义占位符
    X=tf.placeholder(tf.float32,[None,4096])
    Y=tf.placeholder(tf.float32,[None,4096])
    
    reconstruction=encoder(X,weight,biases)
    #损失函数计算
    cost=tf.reduce_mean(tf.pow(reconstruction-Y,2))
    #优化器优化
    #optm=tf.train.AdamOptimizer(learning_rate=0.01).minimize(cost)
    optm=tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)
    
    #训练模型
    def train():
        train_epochs = 3000
        batch_size = 1
        display_step=20
        save_epoch_num=30
    
        with tf.Session() as sess:
            #变量初始化
            sess.run(tf.global_variables_initializer())
            print('开始训练\n')
            # 定义模型保存对象
            saver = tf.train.Saver()
            # 重载保存的中间模型
            result = [0]
            # 查看模型状态
            ckpt = tf.train.get_checkpoint_state('./model')
            # 加载模型
            if ckpt and ckpt.model_checkpoint_path:
                print("model restoring")
                saver.restore(sess, ckpt.model_checkpoint_path)
                print(ckpt.model_checkpoint_path)
                pattern = re.compile('\d+')
                result = pattern.findall(ckpt.model_checkpoint_path)
                print(result[0])
            #显示结果
            for item in range(40):
                tmp_X=np.reshape(train_X[item*10:(item+1)*10],[-1,4096])
                feeds={X:tmp_X}
                encode_decode=sess.run(reconstruction,feed_dict=feeds)
                #创建子图
                f,a=plt.subplots(3,10,figsize=(10,3))
                for i in range(10):
                    a[0][i].imshow(np.reshape(tmp_X[i],(64,64)),cmap=plt.get_cmap('gray'))
                    a[1][i].imshow(np.reshape(encode_decode[i],(64,64)),cmap=plt.get_cmap('gray'))
                    a[2][i].imshow(np.reshape(train_Y,(64,64)),cmap=plt.get_cmap('gray'))
                plt.show()
            # for epoch in range(train_epochs-int(result[0])):
            #
            #     # 400为训练集条数
            #     index = np.random.permutation(400)
            #     total_cost=0
            #     for item in range(400):
            #         #获取训练集索引信息
            #         train_index=index[item]
            #         #训练模型
            #         tmp_X=np.reshape(train_X[train_index],[-1,4096])
            #         feeds={X:tmp_X,Y:train_Y}
            #         sess.run(optm,feed_dict=feeds)
            #         cost_=sess.run(cost,feed_dict=feeds)
            #         total_cost+=cost_
            #
            #         #if item%display_step==0:
            #             #print("epoch:{},step:{},loss:{}".format(epoch+1,item+1,cost_))
            #     print("epoch:{}  average cost: {}".format(epoch + 1+int(result[0]), total_cost/400))
            #     if (epoch+1)%save_epoch_num==0:
            #         #.ckpt模型保存
            #         saver.save(sess,'./model/model',global_step=epoch+1+int(result[0]))
            #         print("{} model had saved in ./model/model".format(epoch+1+int(result[0])))
            print("Finished!")
    
    if __name__ =='__main__':
    
        train()
    
    

    四、效果展示

    在这里插入图片描述
    在这里插入图片描述
    五、分析与总结
    如图所展示的几张图片,第一行是训练之前的数据,第二行是模型所计算的数据,第三行是目标数据,从效果上来看几乎看不出来区别,所以训练的结果还是比较好的。
    拥有这样的训练结果,这跟数据量小的因素有绝大部分关系,总共400张图片所以模型的拟合能力和收敛能力都比较强,但是在后续的工作中还有更多的挑战要做。如有可能,后续的进度会更新至后面的博客中,敬请期待。

    展开全文
  • 为提高自适应小波包调制(WPM)系统窄带干扰能力,提出一...理论分析和仿真结果表明,优选算法在窄带干扰环境下能够简单准确地搜索到最优树,在不需要定时发送训练序列的条件下显著提高自适应WPM系统窄带干扰能力
  • 探讨了现代战场上提高无线电台通信复杂电磁干扰能力的重要性。针对复杂电磁环境的特点,从传输原理、组织运用、传输链路、科学训练等方面着手,提出了无线电台电磁干扰的一些具体措施。
  • 为了得到既有较强差性又有较高效率的估值,采用差最小二乘法在粗差干扰条件下进行参数估计。差最小二乘估计通过等价权把差估计原理与加权最小二乘形式结合在一起,因此在抵抗粗差的同时保持了最小二乘法的...
  • 由于OFDM具有多径衰落和频率选择性衰落的能力,同时又能提高系统的频谱利用率等,因此OFDM系统特别适用于多径无线信道环境下高速率数据的传输。但是与单载波系统相比,OFDM系统对同步的要求更加严格,对同步误差...
  • 由于OFDM具有多径衰落和频率选择性衰落的能力,同时又能提高系统的频谱利用率等,因此OFDM系统特别适用于多径无线信道环境下高速率数据的传输。但是与单载波系统相比,OFDM系统对同步的要求更加严格,对同步误差...
  • 由于线性回归对训练样本的抗干扰能力差,于是就提出了逻辑回归。,笔记如下。

    由于线性回归对训练样本的抗干扰能力差,于是就提出了逻辑回归。,笔记如下。






    展开全文
  • 本文所设计的新型便携式心率计,设计方法比较简单易行,使用的元件...从总体来看,它具有体积小、抗干扰能力强、使用方便、易于观察、易于携带等多种优点。因此,该心率计将非常适合于体育训练和室外作业等场合的使用。
  • 针对采用传统 PID控制一类非线性滞后系统,难以获得满意的控制效果,提出基于RBF神经网络的 PID控制参数自整定的...仿真结果证明了,该控制策略不仅能使非线性滞后系统具有良好的动态跟踪性能,而且具有很好的抗干扰能力
  • 为了改进现有支持向量机所确定的边界抗干扰能力差、对噪声数据敏感等问题,减少野点数据对形成支持向量机边界存在的影响,根据各个样本在整个训练样本集中的重要性不同,将各个训练样本的重要性程度值作为权值赋予...
  • 对mnist集中的原始输入图片加入噪声,在自编码网络中进行训练,得到抗干扰能力更强的特征提取模型。 引入头文件,创建mnist数据集。 import numpy as np import tensorflow as tf import matplotlib.pyplot as ...

    1.引入头文件,创建网络模型及定义学习参数变量

    对mnist集中的原始输入图片加入噪声,在自编码网络中进行训练,得到抗干扰能力更强的特征提取模型。

    引入头文件,创建mnist数据集。

    import  numpy as np
    import  tensorflow as tf
    import  matplotlib.pyplot as plt
    from tensorflow.examples.tutorials.mnist import input_data
    
    mnist = input_data.read_data_sets("/data/", one_hot=True)
    
    train_X = mnist.train.images
    train_Y = mnist.train.labels
    test_X  = mnist.test.images
    test_Y  = mnist.test.labels

    2.定义占位符

    建立4个网络,每一层都用一个网络来训练,需要训练3个网络,最后再把训练好的各几层组合到一起,形成第4个网络。

    n_input = 784
    n_hidden_1 = 256
    n_hidden_2 = 128
    n_classes = 10
    
    #占位符
    #第一层输入
    x = tf.placeholder("float", [None, n_input])
    y = tf.placeholder("float", [None, n_input])
    dropout_keep_prob = tf.placeholder("float")
    #第二层输入
    l2x = tf.placeholder("float", [None, n_hidden_1])
    l2y = tf.placeholder("float", [None, n_hidden_1])
    #第三层输入
    l3x = tf.placeholder("float", [None, n_hidden_2])
    l3y = tf.placeholder("float", [None, n_classes])
    

    3定义学习参数

    除了输入层,后面的其他三层(256、128、10)每一层都需要单独使用一个自编码网络来训练,所以为这3个网络创建3套学习参数。

    #WEIGHTS
    weights = {
        #网络1 784-256-784
        'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
        'l1_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_1])),
        'l1_out': tf.Variable(tf.random_normal([n_hidden_1, n_input])),
        #网络2 256-128-256
        'l2_h1': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
        'l2_h2': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_2])),
        'l2_out': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
        #网络3 128-10
        'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
    }
    biases = {
        'b1':tf.Variable(tf.zeros([n_hidden_1])),
        'l1_b2': tf.Variable(tf.zeros([n_hidden_1])),
        'l1_out': tf.Variable(tf.zeros([n_input])),
    
        'l2_b1': tf.Variable(tf.zeros([n_hidden_2])),
        'l2_b2': tf.Variable(tf.zeros([n_hidden_2])),
        'l2_out': tf.Variable(tf.zeros([n_hidden_1])),
    
        'out': tf.Variable(tf.zeros([n_classes]))
    }
    

    4.第一层网络结构

    为第一层建立一个自编码网络,并定义其网络结构。这里注意,由于要给第一层加入噪声,所以第一层需要有dropout层。

    #第一层的编码输出
    l1_out = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['h1']), biases['b1']))
    
    #11解码器MODEL
    def noise_l1_autodecoder(layer_1, _weights, _biases, _keep_prob):
        layer_1out = tf.nn.dropout(layer_1, _keep_prob)
        layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1out, _weights['l1_h2']), _biases['l1_b2']))
        layer_2out = tf.nn.dropout(layer_2, _keep_prob)
        return tf.nn.sigmoid(tf.matmul(layer_2out, _weights['l1_out'])+_biases['l1_out'])
    
    
    #第一层的解码输出
    l1_reconstruction = noise_l1_autodecoder(l1_out, weights, biases, dropout_keep_prob)
    
    #计算COST
    l1_cost = tf.reduce_mean(tf.pow(l1_reconstruction - y, 2))
    #OPTIMIZER
    l1_optm = tf.train.AdamOptimizer(0.01).minimize(l1_cost)
    

    5.第二层网络结构

    为第二层建立一个自编码网络,并定义其网络结构。

    #解码器MODEL
    def l2_autodecoder(layer1_2, _weights, _biases):
        layer1_2out = tf.nn.sigmoid(tf.add(tf.matmul(layer1_2, _weights['l2_h2']), _biases['l2_b2']))
        return tf.nn.sigmoid(tf.matmul(layer1_2out, _weights['l2_out']) + _biases['l2_out'])
    
    #第二层的编码输出
    l2_out = tf.nn.sigmoid(tf.add(tf.matmul(l2x, weights['l2_h1']), biases['l2_b1']))
    #第二层的解码输出
    l2_reconstruction = l2_autodecoder(l2_out, weights, biases)
    
    #COST计算
    l2_cost = tf.reduce_mean(tf.pow(l2_reconstruction-l2y, 2))
    #优化器
    optm2 = tf.train.AdamOptimizer(0.01).minimize(l2_cost)
    

    6.第三层网络结构

    为第二层建立一个自编码网络,并定义其网络结构。

    l3_out = tf.matmul(l3x, weights['out'])+biases['out']
    l3_cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=l3_out, labels=l3y))
    l3_optm = tf.train.AdamOptimizer(0.01).minimize(l3_cost)

    7.定义级联网络结构

    将3层网络连在一起,建立第四个网络,并定义其网络结构。

    #3层 级联
    #1联2
    l1_l2out = tf.nn.sigmoid(tf.add(tf.matmul(l1_out, weights['l2_h1']), biases['l2_b1']))
    #2联3
    pred = tf.matmul(l1_l2out, weights['out'])+biases['out']
    #定义loss和优化器
    cost3 = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=l3y))
    optm3 = tf.train.AdamOptimizer(0.001).minimize(cost3)
    

    8.第一层网络训练

    网络结构定义好之后,下面开始第一层网络的训练。

    epochs = 50
    batch_size = 100
    disp_step = 10
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
    
        print("开始训练")
        for epoch in range(epochs):
            num_batch = int(mnist.train.num_examples/batch_size)
            total_cost = 0.
            for i in range(num_batch):
                batch_xs, batch_ys = mnist.train.next_batch(batch_size)
                batch_xs_noisy = batch_xs + 0.3*np.random.randn(batch_size,784)
                feeds = {x:batch_xs_noisy,y:batch_xs,dropout_keep_prob:0.5}
                sess.run(l1_optm, feed_dict=feeds)
                total_cost += sess.run(l1_cost, feed_dict=feeds)
                #DISPLAY
            if epoch%disp_step == 0:
                print("Epoch %02d/%02d average cost: %.6f"
                      %(epoch, epochs, total_cost/num_batch))
        print("完成 layer_2 训练")

    执行上面代码,生成如下信息:

    开始训练
    Epoch 00/50 average cost: 0.113839
    Epoch 10/50 average cost: 0.035742
    Epoch 20/50 average cost: 0.033140
    Epoch 30/50 average cost: 0.032191
    Epoch 40/50 average cost: 0.031671
    完成 layer_2 训练
    
    Process finished with exit code 0

    从测试数据里面拿出10个样本放到模型里面,将生成的结果可视化。

        show_num = 10
        test_noisy = mnist.test.images[:show_num]+0.3*np.random.randn(show_num, 784)
        encode_decode = sess.run(l1_reconstruction, feed_dict={x: test_noisy,dropout_keep_prob:1.})
        f,a = plt.subplots(3,10,figsize = (10,3))
        for i in range(show_num):
            a[0][i].imshow(np.reshape(test_noisy[i],(28,28)))
            a[1][i].imshow(np.reshape(mnist.test.images[i],(28,28)))
            a[2][i].matshow(np.reshape(encode_decode[i],(28,28)),cmap=plt.get_cmap('gray'))
        plt.show()
    
    

    执行上面代码,生成如下图所示信息:

    9.第二层网络训练

    下面开始进行第二层网络训练,这个网络模型输入的不是原版MNIST图片,而是上一层输出的图片,所以在准备输入数据时,要让输入的数据在上一层的模型中运算一次才可以作为本次的输入。

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        print("开始训练")
        for epoch in range(epochs):
            num_batch = int(mnist.train.num_examples/batch_size)
            total_cost = 0.
            for i in range(num_batch):
                batch_xs , batch_ys = mnist.train.next_batch(batch_size)
    
                l1_h = sess.run(l1_out, feed_dict = {x: batch_xs, y: batch_xs, dropout_keep_prob:1.})
                _,l2cost = sess.run([optm2, l2_cost], feed_dict = {l2x: l1_h, l2y: l1_h})
                total_cost += l2cost
    
            #log输出
    
    
            if epoch % disp_step == 0:
                print("Epoch %02d/%02d average cost:v%.6f" %(epoch, epochs, total_cost/num_batch))
        print("完成 layer_2 训练")
    

    执行以上代码,生成如下信息:

    开始训练
    Epoch 00/50 average cost:v0.135268
    Epoch 10/50 average cost:v0.054069
    Epoch 20/50 average cost:v0.050967
    Epoch 30/50 average cost:v0.050527
    Epoch 40/50 average cost:v0.049562
    完成 layer_2 训练

    同理,可视化这比分也是这样,所有准备输入的点都要在模型1中生成一次,见一下代码。

        show_num = 10
        testvec = mnist.test.images[:show_num]
        out1vec = sess.run(l1_out, feed_dict={x: testvec, y: testvec, dropout_keep_prob: 1})
        out2vec = sess.run(l2_reconstruction, feed_dict={l2x: out1vec})
    
        f,a = plt.subplots(3, 10 , figsize = (10,3))
        for i in range(show_num):
            a[0][i].imshow(np.reshape(testvec[i], (28, 28)))
            a[1][i].imshow(np.reshape(out1vec[i], (16, 16)))
            a[2][i].matshow(np.reshape(out2vec[1], (16, 16)), cmap = plt.get_cmap('gray'))
        plt.show()
    

    执行上面代码,生成如下所示信息:

    10.第三层网络训练

    现在开始训练第三层网络,同理,这次的输入的数据要经过前面两层网络的运算才可以生成。

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
    
        print("开始训练")
        for epoch in range(epochs):
            num_batch = int(mnist.train.num_examples/batch_size)
            total_cost = 0
            for i in range(num_batch):
                batch_xs , batch_ys = mnist.train.next_batch(batch_size)
                l1_h = sess.run(l1_out, feed_dict = {x: batch_xs , y: batch_xs ,dropout_keep_prob: 1.})
                l2_h = sess.run(l2_out, feed_dict = {l2x: l1_h, l2y: l1_h})
                _, l3cost = sess.run([l3_optm, l3_cost], feed_dict = {l3x: l2_h, l3y: batch_ys})
    
                total_cost += l3cost
            #输出
            if epoch % disp_step == 0:
                print("Epoch %02d/%02d averaage cost: %.6f" %(epoch, epochs, total_cost/num_batch))
        print("完成 layer_3训练")
    

     执行以上代码,生成如下信息:

    开始训练
    Epoch 00/50 averaage cost: 2.266936
    Epoch 10/50 averaage cost: 0.717153
    Epoch 20/50 averaage cost: 0.714110
    Epoch 30/50 averaage cost: 0.708153
    Epoch 40/50 averaage cost: 0.707796
    完成 layer_3训练
    

    11.栈式自编码网络验证

    这次先略过对第三层网络模型的单独验证,直接去验证整个分类模型,将MNIST数据输进去,看看栈式自编码器的分类效果如何。

        #测试moedl
        correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(l3y, 1))
        #计算准确率
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
        print("Accuracy:", accuracy.eval({x: mnist.test.images, l3y: mnist.test.labels }))
    

    执行上面代码,生成如下信息:

    Accuracy: 0.7806

    12.级联微调

    下面进入微调阶段,将网络模型级联起来进行分类训练,这部分的测试代码和前面一样,所以只把训练部分代码贴出来。

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
    
        print("开始训练")
        for epoch in range(epochs):
            num_batch = int(mnist.train.num_examples/batch_size )
            total_cost = 0.
            for i in range(num_batch):
                batch_xs , batch_ys = mnist.train.next_batch(batch_size )
    
                feeds = {x: batch_xs, l3y: batch_ys}
                sess.run(optm3, feed_dict = feeds)
                total_cost  += sess.run(cost3, feed_dict = feeds)
            #输出cost
            if epoch % disp_step == 0:
                print("Eopch %02d/%02d average cost: %.6f" %(epoch, epochs, total_cost/num_batch))
        print("完成 级联 训练")
    

    执行上面代码,生成如下信息:

    开始训练
    Eopch 00/50 average cost: 1.491850
    Eopch 10/50 average cost: 0.074933
    Eopch 20/50 average cost: 0.011442
    Eopch 30/50 average cost: 0.001416
    Eopch 40/50 average cost: 0.000167
    完成 级联 训练
    

    可以看到,由于网络模型中各层的初始训练值已经训练好了,搜易开始就是很低的错误率,错误率接着每次迭代都有很大幅度下降。

    展开全文
  • 随着计算机技术的发展,融合计算机视觉...对比了众多深度学习开源框架后,选择Caffe框架进行训练及测试,实验结果表明,该方法实现了对火灾图像的识别和定位,适应于不同的火灾场景,具有很好的泛化能力和抗干扰能力
  • 在传统的火焰检测算法中,火焰前景提取容易出现火焰轮廓不完整和抗干扰性较差的情况。为此,融合红/绿/蓝(RGB)、色调/饱和度/亮度(HSI)和最大类间...仿真结果表明,该算法具有良好的抗干扰能力,能够提高对火焰识别的精度。
  • 针对煤矿井下传统火灾探测方法的不足,提出了一种基于图像型的火灾...实验结果表明:该方法探测正确率高,误判率低,抗干扰能力强,对于小样本的非线性分类问题效果较好。该研究成果对煤矿外因火灾的预防具有一定实际意义。
  • 利用离子群优化(PSO)算法的全局搜索功能和最小二乘...该方法克服了PID控制中存在的控制精度不高、抗干扰能力差以及实时性不好的缺点。通过对连续槽式搅拌反应器(CSTR)温度控制的实际应用,证明了该方法的有效性。
  • opencv DNN模块之人脸检测

    千次阅读 2020-02-10 20:45:47
    在3.x版本人连检测,常用haar级联器检测,受光照、人脸位置影响比较大,识别率也不理想,DNN模块给出专用人脸模型,跟踪效果很好,抗干扰能力很强。在4版本之后DNN检测以后将会成为主流。 opencv提供的模型 基于...

    DNN人脸检测

    在3.x版本人连检测,常用haar级联器检测,受光照、人脸位置影响比较大,识别率也不理想,DNN模块给出专用人脸模型,跟踪效果很好,抗干扰能力很强。在4版本之后DNN检测以后将会成为主流。


    opencv提供的模型

    • 基于SSD网络模型caffe训练生成的人脸检测模型
    • 基于SSD网络模型tensflow训练生成的人脸检测模型
    • opencv模型量化版本16FP/uint8

    res10_300x300_ssd_iter_140000_fp16.caffemodel
    deploy.prototxt
    opencv_face_detector_uint8.pb
    opencv_face_detector.pbtxt


    相关参数

    # OpenCV's face detection network
    opencv_fd:
      model: "opencv_face_detector.caffemodel"
      config: "opencv_face_detector.prototxt"
      mean: [104, 177, 123]
      scale: 1.0
      width: 300
      height: 300
      rgb: false
      sample: "object_detection"
    

    以caffe模型为例的代码演示

    
    #include <opencv2/face.hpp>
    #include <opencv2/opencv.hpp>
    #include <opencv2/dnn.hpp>
    
    using namespace std;
    using namespace cv;
    using namespace cv::dnn;
    
    int main(void)
    {
        string bin_model = "/work/opencv_dnn/face_detector/res10_300x300_ssd_iter_140000_fp16.caffemodel";
        string protxt = "/work/opencv_dnn/face_detector/deploy.prototxt";
        // load network model
        Net net = readNetFromCaffe(protxt, bin_model);
    
        // 设置计算后台
        net.setPreferableBackend(DNN_BACKEND_OPENCV);
        net.setPreferableTarget(DNN_TARGET_CPU);
        namedWindow("检测画面",WINDOW_AUTOSIZE);
    
        // 获取各层信息
        vector<string> layer_names = net.getLayerNames();
        for (int  i = 0; i < layer_names.size(); i++) {
            int id = net.getLayerId(layer_names[i]);
            auto layer = net.getLayer(id);
            printf("layer id : %d, type : %s, name : %s \n", id, layer->type.c_str(), layer->name.c_str());
        }
        VideoCapture capture(0);
        Mat frame;
        while (true) {
            bool ret = capture.read(frame);
            if (!ret) break;
            flip(frame,frame,1);
            // 构建输入
            Mat blob = blobFromImage(frame, 1, Size(300, 300), Scalar(104, 177, 123), false, false);
            net.setInput(blob, "data");
            // 执行推理
            Mat detection = net.forward("detection_out");
            Mat detectionMat(detection.size[2], detection.size[3], CV_32F, detection.ptr<float>());
            float confidence_threshold = 0.5;
            // 解析输出数据
            for (int i = 0; i < detectionMat.rows; i++) {
                float* curr_row = detectionMat.ptr<float>(i);
                int image_id = (int)(*curr_row++);
                size_t objIndex = (size_t)(*curr_row++);
                float score = *curr_row++;
                if (score > confidence_threshold) {
                    float tl_x = (*curr_row++) * frame.cols;
                    float tl_y = (*curr_row++) * frame.rows;
                    float br_x = (*curr_row++) * frame.cols;
                    float br_y = (*curr_row++) * frame.rows;
                    Rect box((int)tl_x, (int)tl_y, (int)(br_x - tl_x), (int)(br_y - tl_y));
                    rectangle(frame, box, Scalar(0, 0, 255), 2, 8, 0);
                    putText(frame, "man face", box.tl(), FONT_HERSHEY_SIMPLEX, 1.5, Scalar(0, 255, 0), 3, 8);
                }
            }
            // measure time consume
            vector<double> layersTimings;
            double freq = getTickFrequency() / 1000.0;
            double time = net.getPerfProfile(layersTimings) / freq;
            ostringstream ss;
            ss << "FPS: " << 1000 / time << " ; time : " << time << " ms";
    
            // show
            putText(frame, ss.str(), Point(20, 20), FONT_HERSHEY_PLAIN, 1.0, Scalar(255, 0, 0), 2, 8);
            imshow("检测画面", frame);
            char c = waitKey(1);
            if (c == 27) { // ESC
                break;
            }
        }
    
        // 释放资源
        capture.release();
        waitKey(0);
        destroyAllWindows();
        return 0;
    }
    

    效果

    在这里插入图片描述


    展开全文
  • 在数据处理中,包络线法能够快速、准确地提取测得波形的最大幅值,避免了因在线数据的出现干扰造成的误判,提高了检测算法的抗干扰能力;在BP网络训练改进措施中,影响因子数据变化率极大地改善了BP网络的稳定性,提高了...
  • 综合考虑温度、温度变化...仿真结果表明:当输出报警限取O.5时,经一定的时间延时后,该系统可在燃烧发生200s时进行报警,从而有效实现了矿井胶带输送机火灾的早期报警,并增强了系统的抗干扰能力及对环境的适应性能。
  • 定时估计是准确实现 OFDM( orthogonal frequency division multiplexing)系统同步的关键... Matlab仿真表明,与传统算法相比,在高斯噪声和多径信道的影响下,所提出的算法具有较小的均方误差,抗干扰能力强的特点,并为频率
  • 针对任意复杂的具有最小相位,滞后环节和非最小相位特性的离散非线性系统,提出一种通用的直接神经网络模型参考...仿真研究证明,该控制策略不仅能使多种非线性对象跟踪多种参考信号,而且抗干扰能力和鲁棒性也很好。
  • 利用l2范数作为时序一致模型对相邻帧的滤波器建立平滑性约束,使滤波器模板学习到相邻帧目标的上下文信息,增加算法的抗干扰能力;为进一步提升目标模板的表达能力,将包含丰富语义信息的ResNet50深度特征引入到跟踪框架...
  • 针对传统机器视觉的手势识别方法识别准确率低,抗干扰能力差等问题,提出了一种基于支持向量机(Support Vector Machine,SVM)手势分割和迁移学习的静态手势识别方法.本文使用SVM和迁移学习方法相结合构建新的手势...
  • 45/46世界技能大赛江苏省选拔赛总结 ”但见时光流似箭,岂知天道曲如弓“,转眼间我在南京技师学院已经3年多了在老师的悉心关怀和教育下,同学的热情帮助下,自身的不断努力下,也...抗干扰能力也太行,思绪容易被打断。
  • 对PVC胶带机的火灾燃烧试验探测结果表明,当输出报警限取0.5时,经一定的时间延时后,运用该网络可在燃烧发生350 s时进行报警,从而有效实现T矿井胶带输送机火灾的早期报警,并增强了系统的抗干扰能力及对环境的适应...
  • 用其作为神经网络的前置系统进行信息预处理,减少了所需样本数目,从而简化了神经网络结构,减少了网络训练时间,并且充分利用了神经网络容错及抗干扰能力,有效地降低了故障诊断中的误报率和漏报率。该方法可以进行...
  • 针对现阶段容错技术中对于不可直接测量变量往往采用易受扰动影响的观测器这一缺点,提出一种基于鱼群算法优化的最小二乘支持向量回归机(LS-SVR...通过仿真实验表明,所提方法收敛速度快,抗干扰能力强,效果明显提升。
  • 基于语音识别技术和无线传感网络,设计了一套能够通过远程语音遥控进行便捷控制的智能家居...系统实时输出识别结果,识别速度快,抗干扰能力强,识别率可以达到98%,在语音远程控制领域具有广阔的市场前景和应用推广价值。
  • 我时常随身随地思考问题,并尽量让自己在不同的场景中能不受当前...对于这种能力的把控越纯熟,我在思考问题时越不容易走神,对外界环境的抗干扰能力也就越强。  《暗时间》的作者刘未鹏提到“善于利用思维时间...
  • 随着自然语言处理科学的迅猛发展,情感...通过分别使用SVM、降噪自动编码器模型以及改进的模型进行情感分析实验,对比分类效果而得出改进的深度模型对微博文字情感把握更准确而且抗干扰能力及鲁棒性有所提升的结论。

空空如也

空空如也

1 2 3
收藏数 53
精华内容 21
关键字:

抗干扰能力训练