精华内容
下载资源
问答
  • Python+OpenCV颜色识别 物体追踪

    千次阅读 2021-02-13 22:57:20
    Python+OpenCV颜色识别 物体追踪 对于颜色识别和imutils包的用法请浏览我得另一篇博客:OpenCV学习笔记 文章目录Python+OpenCV颜色识别 物体追踪代码原理代码最终效果图 代码原理 这是个比较简单的代码。代码实现的...

    Python+OpenCV颜色识别 物体追踪

    对于颜色识别和imutils包的用法请浏览我得另一篇博客:OpenCV学习笔记

    个人博客原址:OpenCV颜色识别 物体追踪

    代码原理

    这是个比较简单的代码。代码实现的就是简单的物体追踪,将物体用方框框出。

    简单来讲就是先进行颜色识别,正确识别到物体后获取物体的外接矩形再画出外接矩形即可。

    详细的解释可以看代码注释,应该是容易理解的。

    代码

    import cv2
    import numpy as np
    import imutils
    from imutils import contours
    
    # 颜色阈值
    lower = np.array([130, 62, 72])
    upper = np.array([170, 255, 148])
    # 内核
    kernel = np.ones((5, 5), np.uint8)
    # 打开摄像头
    vc = cv2.VideoCapture(0)
    if vc.isOpened():
        flag, frame = vc.read()
        # 翻转图像
        # 这一步可以忽略,博主的摄像头是反着的
        # 所以加上这句话可以让摄像头的图像正过来
        frame = imutils.rotate(frame, 180)
        cv2.imshow("frame", frame)
    else:
        flag = False
    while flag:
        flag, frame = vc.read()
        # 翻转图像
        frame = imutils.rotate(frame, 180)
        draw_frame = frame.copy()
        if frame is None:
            break
        if flag is True:
            '''下面对摄像头读取到的图像进行处理,这个步骤是比较重要的'''
            # 转换颜色空间HSV
            frame_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
            # 颜色识别
            img = cv2.inRange(frame_hsv, lower, upper)
            # 膨胀操作
            dilation = cv2.dilate(img, kernel, iterations=1)
            # 闭操作
            closing = cv2.morphologyEx(dilation, cv2.MORPH_CLOSE, kernel)
            # 高斯滤波
            closing = cv2.GaussianBlur(closing, (5, 5), 0)
            # 边缘检测
            edges = cv2.Canny(closing, 10, 20)
            '''上面进行那么多操作就是为了得到更好的目标图形,具体效果因环境而异'''
            # 寻找轮廓
            cnts, _ = cv2.findContours(
                edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
            # 判断轮廓数量也就是判断是否寻找到轮廓,如果没有找到轮廓就不继续进行操作
            if len(cnts) > 0:
                # 存放轮廓面积的列表
                s = []
                # 存放最大轮廓的索引
                max_index = 0
                # 获得排序后的轮廓列表以及每个轮廓对应的外接矩形
                (cnts, boundingRects) = contours.sort_contours(cnts)
                # 寻找面积最大的轮廓的索引
                for cnt in cnts:
                    s.append(cv2.contourArea(cnt))
                max_index = s.index(max(s))
                # 根据面积最大轮廓的索引找到它的外接矩形的信息
                (x, y, w, h) = boundingRects[max_index]
                # 画矩形
                frame_out = cv2.rectangle(
                             draw_frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
            cv2.imshow("frame", draw_frame)
            if cv2.waitKey(10) == 27:
                break
    vc.release()
    cv2.destroyAllWindows()
    

    具体解释都在代码注释里面了,下面我要提一些注意的地方。

    1. 获得过图像之后可能需要进行一系列的形态学操作,这样可以让获得的图像更加接近目的图像。这些操作虽然不是必需的但如果正常取得的图像效果不好的时候可以加上。
    2. 函数contours.sort_contoursimutils.rotateimutils包里面的,使用起来比较方便,具体用法可以看博主的另一篇博客:OpenCV学习笔记。外接矩形也可以通过cv2.boundingRect函数获得。
    3. 代码中博主是以轮廓的最大面积为条件画的图,但这个条件应该根据自己想要的效果而定。这里除了寻找最大面积以外还可以寻找最大周长、最长的边之类的。

    最终效果图

    最终效果图

    展开全文
  • ImageTarget识别物体脱离识别案例

    千次阅读 2016-01-19 16:50:11
    最近见很多群内的小伙伴都在问这个技术。 我说说我的做法,尽大可能不修改源码的情况下。 首先我们需要理解所谓的识别物体,也...所以这里我是直接在预加载一个prefab来复制当前识别物体来替代识别物体。 然后通过

    最近见很多群内的小伙伴都在问这个技术。

    我说说我的做法,尽大可能不修改源码的情况下。

    首先我们需要理解所谓的识别物体,也就是我们所提供的模型是如何存在与识别图上的。

    模型的显示是通过ImageTargetBehaviour这个脚本所控制的,所以我们让这个component隐藏的时候,模型是必然不显示的。

    所以这里我是直接在预加载一个prefab来复制当前识别物体来替代识别物体。

    然后通过关闭ImageTargetBehaviour这个脚本来隐藏识别物体。


    原理不多说,直接上代码

    public void  Lock()
        {
    <span style="white-space:pre">	</span>//num是点击次数
            if (num % 2 == 0)
            {
    <span style="white-space:pre">	</span>//一个加载函数,模型名称就是识别图的名称
                ReasouceLoda(DefaultTrackableEventHandler.name);
    <span style="white-space:pre">	</span>//这个if是找到识别图下的模型,可写可不写
                if (GameObject.Find(DefaultTrackableEventHandler.name).transform.tag == "Model")
                {
                    NewTemp = GameObject.Find(DefaultTrackableEventHandler.name);
                    
                }
                else
                {
                    for (int i = 0; i < GameObject.Find(DefaultTrackableEventHandler.name).transform.childCount;i++ )
                    {
                        GameObject spritobj = GameObject.Find(DefaultTrackableEventHandler.name).transform.GetChild(i).gameObject;
                        if( GameObject.Find(DefaultTrackableEventHandler.name).transform.GetChild(i).gameObject.tag=="Model")
                        {
                            NewTemp = spritobj.gameObject;
                        }
                    }
                       
                }
                Vector3Clear();
            }
            else
            {
                Destroy(SceneMgr.temp);
                NewTemp.transform.parent.GetComponent<ImageTargetBehaviour>().enabled = true;
            }
            num++;
        }
    ///temp是resouce加载的物体,NewTemp是识别物体
    public void Vector3Clear()
        {
            SceneMgr.temp.transform.position = NewTemp.transform.position;
            SceneMgr.temp.transform.rotation = NewTemp.transform.rotation;
            SceneMgr.temp.transform.localScale = NewTemp.transform.lossyScale;
            NewTemp.transform.parent.GetComponent<ImageTargetBehaviour>().enabled = false;
        }


    展开全文
  • TensorFlow - 识别物体

    千次阅读 2017-09-18 17:36:12
    TensorFlow - 识别物体flyfish环境 Win7 x64 Python3 TensorFlowinception-2015-12-05.tgz 下载地址 models源码文件 只用其中一个,目录是 \tutorials\image\imagenet\classify_image.py 执行命令python ...

    TensorFlow - 识别物体

    flyfish

    环境
    Win7 x64
    Python3
    TensorFlow

    inception-2015-12-05.tgz 下载地址

    models源码文件
    这里写图片描述
    只用其中一个,目录是
    \tutorials\image\imagenet\classify_image.py

    执行命令

    python classify_image.py --model_dir /tmp --image_file /tmp/1.jpg 

    第一个参数是模型文件所在的目录
    第二个参数是需要识别的图片
    假设1.jpg是玉米的照片

    假设该命令式在E:\下执行,会在E盘创建tmp,并自动下载inception-2015-12-05.tgz
    如果已经下载直接将文件放置该路径解压即可 类似 E:\tmp\inception-2015-12-05.tgz

    执行结果
    corn (score = 0.88042)
    ear, spike, capitulum (score = 0.11927)
    wok (score = 0.00003)
    frying pan, frypan, skillet (score = 0.00001)
    knot (score = 0.00001)

    展开全文
  • python卷积神经网络识别物体

    千次阅读 2019-03-23 15:50:03
    python卷积神经网络识别物体介绍函数卷积:tf.nn.conv2d(...)池化函数:数据集实现导入数据预处理建立模型训练可视化评估,预测代码 介绍 模型: 函数 卷积:tf.nn.conv2d(…) 参数: input:输入,4维([batch,in_...

    介绍

    模型:
    1

    函数

    卷积:tf.nn.conv2d(…)

    参数:
    input:输入,4维([batch,in_height,in_width,in_channels]),类型float32或float64。
    filter:卷积核,([filter_height,filter_width,in_channels,out_channels])。
    strides:图像每一维的步长,一维向量,长度为4。
    padding:SAME边缘填充,VALID边缘不填充。
    use_cudnn_on_gpu:是否加速。
    name:名称

    池化函数:

    最大池化:tf.nn.max_pool(…)
    平均池化:tf.nn.avg_pool(…)
    参数:
    value:通常为conv2d所输出的,4维([batch,in_height,in_width,in_channels])。
    ksize:池化窗口大小,一般[1,height,width,1]。
    strides:图像每一维的步长,一维向量,长度为4。
    padding:SAME边缘填充,VALID边缘不填充。。
    name:名称

    数据集

    CIFAR-10数据集,其中的数据图像为rgb图像,图片尺寸为32x32,共十个类别。
    训练图片50000张,测试图片10000张。
    下载地址:CIFAR-10数据集
    https://www.cs.toronto.edu/~kriz/cifar.html

    实现

    导入数据

    data_dir='data1/cifar-10-batches-py/'
    Xtrain,Ytrain,Xtest,Ytest=load_CIFAR_data(data_dir)
    print('training data shape:',Xtrain.shape)  #显示数据信息
    print('training labels shape:',Ytrain.shape)
    print('test data shape:',Xtest.shape)
    print('test labels shape:',Ytest.shape)
    

    读取批次函数:

    def load_CIFAR_batch(filename):     #读取1个批次
        with open(filename,'rb') as f:
            data_dict=p.load(f,encoding='bytes')
            images=data_dict[b'data']
            labels=data_dict[b'labels']
            images=images.reshape(10000,3,32,32)
            images=images.transpose(0,2,3,1)
            labels=np.array(labels)
            return images,labels
    

    读取数据函数:

    def load_CIFAR_data(data_dir):      #读取数据
        images_train=[]
        labels_train=[]
        for i in range(5):
            f=os.path.join(data_dir,'data_batch_%d'%(i+1))
            print('loading',f)
            image_batch,label_batch=load_CIFAR_batch(f)
            images_train.append(image_batch)
            labels_train.append(label_batch)
            Xtrain=np.concatenate(images_train)#数组拼接,传入参数为一个或多个数组的元组或列表
            Ytrain=np.concatenate(labels_train)
            del image_batch,label_batch     #删除变量,但不删除数据
        Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))
        print('finished loadding CIFAR-10 data')
        return Xtrain,Ytrain,Xtest,Ytest
    

    预处理

    label_dict={0:"airplane",1:"automobile",2:"bird",3:"cat",4:"deer(鹿)",5:"dog",6:"frog(青蛙)",7:"horse",8:"ship",9:"truck(货车)"}
     #进行数字标准化(以[0,1]小数表示)
    Xtrain_normalize=Xtrain.astype('float32')/255.0
    Xtest_normalize=Xtest.astype('float32')/255.0
    
    from sklearn.preprocessing import OneHotEncoder#独热编码
    encoder=OneHotEncoder(sparse=False)#不采用稀疏格式(索引加值)
    yy=[[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]]
    encoder.fit(yy)
    Ytrain_reshape=Ytrain.reshape(-1,1)
    Ytrain_onehot=encoder.transform(Ytrain_reshape)
    Ytest_reshape=Ytest.reshape(-1,1)
    Ytest_onehot=encoder.transform(Ytest_reshape)
    

    建立模型

    2
    定义数与操作:

    def weight(shape):#定义权值
        return tf.Variable(tf.truncated_normal(shape,stddev=0.1),name='W')
    def bias(shape):#定义偏置
        return tf.Variable(tf.constant(0.1,shape=shape),name='b')
    def conv2d(x,W):#定义卷积操作,步长为1
        return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
    def max_pool_2x2(x):#定义池化,步长为2
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    

    定义层:

    with tf.name_scope('input_layer'):#输入层
        x=tf.placeholder('float',shape=[None,32,32,3],name='x')
    with tf.name_scope('conv_1'):#卷积层1
        W1=weight([3,3,3,32])
        b1=bias([32])
        conv_1=conv2d(x,W1)+b1
        conv_1=tf.nn.relu(conv_1)
    with tf.name_scope('pool_1'):#池化层1
        pool_1=max_pool_2x2(conv_1)
    with tf.name_scope('conv_2'):#卷积层2
        W2=weight([3,3,32,64])
        b2=bias([64])
        conv_2=conv2d(pool_1,W2)+b2
        conv_2=tf.nn.relu(conv_2)
    with tf.name_scope('pool_2'):#池化层2
        pool_2=max_pool_2x2(conv_2)
    with tf.name_scope('fc'):#全连接层
        W3=weight([4096,128])
        b3=bias([128])
        flat=tf.reshape(pool_2,[-1,4096])
        h=tf.nn.relu(tf.matmul(flat,W3)+b3)
        h_dropout=tf.nn.dropout(h,keep_prob=0.8)
    with tf.name_scope('output_layer'):#输出层
        W4=weight([128,10])
        b4=bias([10])
        pred=tf.nn.softmax(tf.matmul(h_dropout,W4)+b4)
    

    模型:

    with tf.name_scope('optimizer'):#建模
        y=tf.placeholder('float',shape=[None,10],name='label')
        loss_function=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y))
        optimizer=tf.train.AdamOptimizer(learning_rate=0.0001).minimize(loss_function)
    with tf.name_scope("evaluation"):#准确率
        correct_prediction=tf.equal(tf.argmax(pred,1),tf.argmax(y,1))
        accuracy=tf.reduce_mean(tf.cast(correct_prediction,"float"))
    

    训练

    准备

    train_epochs=25#轮数
    batch_size=50#一批大小
    total_batch=int(len(Xtrain)/batch_size)#批次
    epoch=tf.Variable(0,name='epoch',trainable=False)#把epoch作为运算节点,但不能被训练自动更改
    epoch_list=[];accuracy_list=[];loss_list=[]
    startTime=time()
    sess=tf.Session()
    init=tf.global_variables_initializer()
    sess.run(init)
    

    断点续训

    ckpt_dir="CIFAR10-log/"
    if not os.path.exists(ckpt_dir):
        os.makedirs(ckpt_dir)
    saver=tf.train.Saver(max_to_keep=1)
    ckpt=tf.train.latest_checkpoint(ckpt_dir)#检查点文件
    if ckpt!=None:
        saver.restore(sess,ckpt)#加载所有参数
    else:
        print("Training from scratch.")
    start=sess.run(epoch)
    print("Training start from {} epoch.".format(start+1))#从第xx轮开始
    

    迭代训练

    def get_train_batch(number,batch_size):#获得训练数据
        return Xtrain_normalize[number*batch_size:(number+1)*batch_size],Ytrain_onehot[number*batch_size:(number+1)*batch_size]
    for ep in range(start,train_epochs):
        for i in range(total_batch):
            batch_x,batch_y=get_train_batch(i,batch_size)
            sess.run(optimizer,feed_dict={x:batch_x,y:batch_y})
            if i%100==0:
                print("step {}".format(i)," finished")
        loss,acc=sess.run([loss_function,accuracy],feed_dict={x:batch_x,y:batch_y})
        epoch_list.append(ep+1)
        loss_list.append(loss)
        accuracy_list.append(acc)
        print("Train epoch: ",'%02d'%(sess.run(epoch)+1),"Loss=","{:.6f}".format(loss),"Accuracy=",acc)
        saver.save(sess,ckpt_dir+"CIFAR10_cnn_model.cpkt",global_step=ep+1)#保存
        sess.run(epoch.assign(ep+1))
    duration=time()-startTime
    print("Train finished takes: ",duration)#训练时长
    

    可视化

    import matplotlib.pyplot as plt
    fig=plt.gcf()
    fig.set_size_inches(4,2)
    plt.plot(epoch_list,loss_list,label='loss')
    plt.ylabel('loss')
    plt.xlabel('epoch')
    plt.legend(['loss'],loc='upper right')
    plt.plot(epoch_list,accuracy_list,label="accuracy")
    fig=plt.gcf()
    fig.set_size_inches(4,2)
    plt.ylim(0.1,1)
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.legend()
    plt.show()
    

    评估,预测

    #计算测试集上准确率
    test_total_batch=int(len(Xtest_normalize)/batch_size)
    test_acc_sum=0.0
    for i in range(test_total_batch):
        test_image_batch=Xtest_normalize[i*batch_size:(i+1)*batch_size]
        test_label_batch=Ytest_onehot[i*batch_size:(i+1)*batch_size]
        test_batch_acc=sess.run(accuracy,feed_dict={x:test_image_batch,y:test_label_batch})
        test_acc_sum+=test_batch_acc
    test_acc=float(test_acc_sum/test_total_batch)
    print("Test accuracy: {:.6f}",format(test_acc))
    #预测    
    test_pred=sess.run(pred,feed_dict={x:Xtest_normalize[:10]})
    prediction_result=sess.run(tf.argmax(test_pred,1))
    plot_image_labels_prediction(Xtest,Ytest,prediction_result,0,10)
    

    3

    代码

    # -*- coding: utf-8 -*-
    import os   #处理文件或目录的库
    import numpy as np
    import pickle as p
    def load_CIFAR_batch(filename):     #读取1个批次
        with open(filename,'rb') as f:
            data_dict=p.load(f,encoding='bytes')
            images=data_dict[b'data']
            labels=data_dict[b'labels']
            images=images.reshape(10000,3,32,32)
            images=images.transpose(0,2,3,1)
            labels=np.array(labels)
            return images,labels
    def load_CIFAR_data(data_dir):      #读取数据
        images_train=[]
        labels_train=[]
        for i in range(5):
            f=os.path.join(data_dir,'data_batch_%d'%(i+1))
            print('loading',f)
            image_batch,label_batch=load_CIFAR_batch(f)
            images_train.append(image_batch)
            labels_train.append(label_batch)
            Xtrain=np.concatenate(images_train)#数组拼接,传入参数为一个或多个数组的元组或列表
            Ytrain=np.concatenate(labels_train)
            del image_batch,label_batch     #删除变量,但不删除数据
        Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))
        print('finished loadding CIFAR-10 data')
        return Xtrain,Ytrain,Xtest,Ytest
    data_dir='data1/cifar-10-batches-py/'
    Xtrain,Ytrain,Xtest,Ytest=load_CIFAR_data(data_dir)
    print('training data shape:',Xtrain.shape)  #显示数据信息
    print('training labels shape:',Ytrain.shape)
    print('test data shape:',Xtest.shape)
    print('test labels shape:',Ytest.shape)
    
    import matplotlib.pyplot as plt
    plt.imshow(Xtrain[6])
    print(Ytrain[6])
    label_dict={0:"airplane",1:"automobile",2:"bird",3:"cat",4:"deer(鹿)",5:"dog",6:"frog(青蛙)",7:"horse",8:"ship",9:"truck(货车)"}
    def plot_image_labels_prediction(images,labels,prediction,idx,num=10):#显示图像、标签函数
        fig=plt.gcf()
        fig.set_size_inches(12,6)
        if num>10:
            num=10
        for i in range(0,num):
            ax=plt.subplot(2,5,1+i)
            ax.imshow(images[idx],cmap='binary')
            title=str(i)+','+label_dict[labels[idx]]
            if len(prediction)>0:
                title+='=>'+label_dict[prediction[idx]]
            ax.set_title(title,fontsize=10)
            idx+=1
        plt.show()
    plot_image_labels_prediction(Xtest,Ytest,[],0,10)
    
    #进行数字标准化(以[01]小数表示)
    Xtrain_normalize=Xtrain.astype('float32')/255.0
    Xtest_normalize=Xtest.astype('float32')/255.0
    
    from sklearn.preprocessing import OneHotEncoder#独热编码
    encoder=OneHotEncoder(sparse=False)#不采用稀疏格式(索引加值)
    yy=[[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]]
    encoder.fit(yy)
    Ytrain_reshape=Ytrain.reshape(-1,1)
    Ytrain_onehot=encoder.transform(Ytrain_reshape)
    Ytest_reshape=Ytest.reshape(-1,1)
    Ytest_onehot=encoder.transform(Ytest_reshape)
    
    import tensorflow as tf
    tf.reset_default_graph()
    def weight(shape):#定义权值
        return tf.Variable(tf.truncated_normal(shape,stddev=0.1),name='W')
    def bias(shape):#定义偏置
        return tf.Variable(tf.constant(0.1,shape=shape),name='b')
    def conv2d(x,W):#定义卷积操作,步长为1
        return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
    def max_pool_2x2(x):#定义池化,步长为2
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    
    with tf.name_scope('input_layer'):#输入层
        x=tf.placeholder('float',shape=[None,32,32,3],name='x')
    with tf.name_scope('conv_1'):#卷积层1
        W1=weight([3,3,3,32])
        b1=bias([32])
        conv_1=conv2d(x,W1)+b1
        conv_1=tf.nn.relu(conv_1)
    with tf.name_scope('pool_1'):#池化层1
        pool_1=max_pool_2x2(conv_1)
    with tf.name_scope('conv_2'):#卷积层2
        W2=weight([3,3,32,64])
        b2=bias([64])
        conv_2=conv2d(pool_1,W2)+b2
        conv_2=tf.nn.relu(conv_2)
    with tf.name_scope('pool_2'):#池化层2
        pool_2=max_pool_2x2(conv_2)
    with tf.name_scope('fc'):#全连接层
        W3=weight([4096,128])
        b3=bias([128])
        flat=tf.reshape(pool_2,[-1,4096])
        h=tf.nn.relu(tf.matmul(flat,W3)+b3)
        h_dropout=tf.nn.dropout(h,keep_prob=0.8)
    with tf.name_scope('output_layer'):#输出层
        W4=weight([128,10])
        b4=bias([10])
        pred=tf.nn.softmax(tf.matmul(h_dropout,W4)+b4)
    with tf.name_scope('optimizer'):#建模
        y=tf.placeholder('float',shape=[None,10],name='label')
        loss_function=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y))
        optimizer=tf.train.AdamOptimizer(learning_rate=0.0001).minimize(loss_function)
    with tf.name_scope("evaluation"):#准确率
        correct_prediction=tf.equal(tf.argmax(pred,1),tf.argmax(y,1))
        accuracy=tf.reduce_mean(tf.cast(correct_prediction,"float"))
        
    from time import time
    train_epochs=25#轮数
    batch_size=50#一批大小
    total_batch=int(len(Xtrain)/batch_size)#批次
    epoch=tf.Variable(0,name='epoch',trainable=False)#把epoch作为运算节点,但不能被训练更改
    epoch_list=[];accuracy_list=[];loss_list=[]
    startTime=time()
    sess=tf.Session()
    init=tf.global_variables_initializer()
    sess.run(init)
    
    ckpt_dir="CIFAR10-log/"
    if not os.path.exists(ckpt_dir):
        os.makedirs(ckpt_dir)
    saver=tf.train.Saver(max_to_keep=1)
    ckpt=tf.train.latest_checkpoint(ckpt_dir)#检查点文件
    if ckpt!=None:
        saver.restore(sess,ckpt)#加载所有参数
    else:
        print("Training from scratch.")
    start=sess.run(epoch)
    print("Training start from {} epoch.".format(start+1))#从第xx轮开始
    
    def get_train_batch(number,batch_size):#获得训练数据
        return Xtrain_normalize[number*batch_size:(number+1)*batch_size],Ytrain_onehot[number*batch_size:(number+1)*batch_size]
    for ep in range(start,train_epochs):
        for i in range(total_batch):
            batch_x,batch_y=get_train_batch(i,batch_size)
            sess.run(optimizer,feed_dict={x:batch_x,y:batch_y})
            if i%100==0:
                print("step {}".format(i)," finished")
        loss,acc=sess.run([loss_function,accuracy],feed_dict={x:batch_x,y:batch_y})
        epoch_list.append(ep+1)
        loss_list.append(loss)
        accuracy_list.append(acc)
        print("Train epoch: ",'%02d'%(sess.run(epoch)+1),"Loss=","{:.6f}".format(loss),"Accuracy=",acc)
        saver.save(sess,ckpt_dir+"CIFAR10_cnn_model.cpkt",global_step=ep+1)#保存
        sess.run(epoch.assign(ep+1))
    duration=time()-startTime
    print("Train finished takes: ",duration)#训练时长
    
    import matplotlib.pyplot as plt
    fig=plt.gcf()
    fig.set_size_inches(4,2)
    plt.plot(epoch_list,loss_list,label='loss')
    plt.ylabel('loss')
    plt.xlabel('epoch')
    plt.legend(['loss'],loc='upper right')
    plt.plot(epoch_list,accuracy_list,label="accuracy")
    fig=plt.gcf()
    fig.set_size_inches(4,2)
    plt.ylim(0.1,1)
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.legend()
    plt.show()
    
    #计算测试集上准确率
    test_total_batch=int(len(Xtest_normalize)/batch_size)
    test_acc_sum=0.0
    for i in range(test_total_batch):
        test_image_batch=Xtest_normalize[i*batch_size:(i+1)*batch_size]
        test_label_batch=Ytest_onehot[i*batch_size:(i+1)*batch_size]
        test_batch_acc=sess.run(accuracy,feed_dict={x:test_image_batch,y:test_label_batch})
        test_acc_sum+=test_batch_acc
    test_acc=float(test_acc_sum/test_total_batch)
    print("Test accuracy: {:.6f}",format(test_acc))
    #预测    
    test_pred=sess.run(pred,feed_dict={x:Xtest_normalize[:10]})
    prediction_result=sess.run(tf.argmax(test_pred,1))
    plot_image_labels_prediction(Xtest,Ytest,prediction_result,0,10
    
    
    展开全文
  • 百度API识别物体 百度在人工只能这个方向已经走了很多年了 再加上强大的搜索引擎和百度图库 在这么多条件的加持下将会创造一个强大的生态 不过目前只是能玩玩而已 但是可以进行持续性的关注 开始 浏览器打开:...
  • 百度AI人脸识别接口测试 最近在做项目,刚好做到了人脸识别,害怕以后忘记怎么调用,在这里进行一波记录 首先我们默认已经做好了百度接口的配置(申请应用,生成了AK,SK等) 不多说了直接上代码 package ...
  • 学习笔记:Python for yolo 之 调用摄像头识别物体

    千次阅读 多人点赞 2018-05-03 12:33:29
    前记:作用说明:学习笔记,主要用于自我记录。(PS:本人新手,文章仅供参考;如有错误,欢迎各位大神批评指正!...此篇介绍(3)yolo用python实现调用摄像头识别物体。【本系列博文代码基于原作者...
  • 实现自动识别监控图像的任何物体 实现在监控中对图像画面的判断。(商业价值:人脸打卡;对实施监控外来人口的出入;识别异样物体;实施监控除该物体以外的其他物体等) 通过模型对需要载入的人进行人脸模型训练。...
  • matlab 自动识别物体

    热门讨论 2009-05-09 10:46:43
    应用matlab 检测物体边缘、经形态学处理,最后标记出物体
  • 使用opencv识别物体的位置,找到中心点位: 步骤:先拿到图像-->进行高斯滤波-->进行灰度处理-->进行二值化-->进行开运算-->轮廓提取-->计算中心点位 效果图如下: 代码如下: import cv2 ...
  • 机器视觉识别物体应用案例

    千次阅读 2016-12-22 19:12:15
    机器视觉,是怎么识别周围物体与环境的,这里给出一个形象的案例加以说明全部的算法。 视觉识别,可以整体识别,也可以局部细节识别,可以从物体或环境的形状做视觉识别,也可以加入色彩的元素以更加细腻地刻画...
  • ARKit&&Vision的识别物体

    千次阅读 2018-06-16 09:19:01
    我们下面就来做下物体识别的例子,首先从官网下载模型 下载完成之后将其导入到我们新建的工程当中 然后我们将模型给导入 然后目前我们要做的就是点击屏幕的中间部分需要有小球产生以及显示出识别物体...
  • opencv识别物体

    2012-08-01 11:05:20
    如何根据给出的一张图片,得到图片轮廓后,//该步骤基本达成 根据轮廓进行判断图片中是否包含汽车屁股? 图片上可能包含一切情况…… 谁有好的想法和思路,以前想连续点判断直线,是直线点保留不是舍去,发现效果...
  • SIFT+RANSAC识别物体,并标注边界

    热门讨论 2015-07-17 08:35:20
    采用SIFT和RANSAC算法完成特征点的匹配和筛选,并求出物体的变换矩阵,通过变换矩阵计算出物体的边界。
  • 一、简介 二、仿真图 三、运行结果 四、备注 完整代码或者代写添加QQ912100926 ...【模式识别】银行卡号之识别【Matlab 077期】 【模式识别】指纹识别【Matlab 078期】 【图像处理】基于GUI界面之DWT+DCT+P
  • 1. 概述 本文针对OpenCV中的”SIFT”、”SURF”、”FAST” 对... 安装好opencv-2.4.10,VS2010,Web摄像头,要识别物体或场景 3. 打开文件,将OperatorType设置1,运行代码,提取感兴趣区域ROI while(1){...
  • 具体的配置,参数设置请参看相关博文。这里只讲下Qt下使用。 直接上图 运行效果。这个我是挂到了其它的一个项目中的,只加了一个按钮,代码如上图...相比之下只检6类物体二者相差不多,不过yolo3可以在9秒内检80...
  • 一、简介 二、仿真图 三、运行结果 四、备注 完整代码或者代写添加QQ 1564658423 往期回顾>>...【信号处理】基于matlab HMM的睡眠状态检测【含Matlab源码 050期】 【信号处理】基于matlab CDR噪声和混响抑制...
  • (点击传送门) OpenCV开发专栏(点击传送门) 上一篇:《OpenCV开发笔记(七十二):红胖子8分钟带你使用opencv+dnn+tensorFlow识别物体》 下一篇:持续补充中… 前言   级联分类器的效果并不是很好,准确度相对...
  • 本教程旨在利用Adaboost算法结合OpenCV生成自己的级联分类器(一个.xml文件),并在本教程中利用该分类器识别所需的物体。教程分为以下四部: 准备正负样本图片 生成样本描述文件 训练样本 目标识别
  • yolov4的Pytorch(cpu版)识别物体

    千次阅读 2020-07-07 11:53:50
    目录一、准备文件1、pytorch-YOLOv4代码下载2、权重(weights)模型下载2、下载pytorch二、测试 一、准备文件 1、pytorch-YOLOv4代码下载 ...2、权重(weights)模型下载 通过如下百度网盘链接进行权重文件下载,下载...
  • 本教程旨在利用Adaboost算法结合OpenCV生成自己的级联分类器(一个.xml文件),并在本教程中利用该分类器识别所需的物体
  • 点击上方“AI公园”,关注公众号,选择加“星标“或“置顶”作者:Robert Geirhos编译:ronghuaiyang导读和人类不同,AI物体识别靠的是小的细节,而不...
  • 这会让构成物体的几何离子更明显,从而是人更快更轻松第识别物体 ·多用二维元素,少用三维元素。大脑以二维形式接受人眼观察到的信息,因此屏幕上饿三维图形可能会减慢识别和理解的速度
  • 本系列文章旨在学习如何在opencv中基于haar-like特征训练自己的分类器,并且用该分类器用于模式识别。该过程大致可以分为一下几个大步骤: 1.准备训练样本图片,包括正例及反例样本 2.生成样本描述文件 3.训练...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,142
精华内容 34,056
关键字:

怎么识别物体