精华内容
下载资源
问答
  • 提供十种花卉的图像识别与分类,测试集准确率较好
  • 花卉分类,花卉分类方法,Python源码
  • 本例中包含两层BP神经网络模板程序(可以直接调用,可定制中间层神经元个数,设置学习率,绘制衰减曲线,可用于简单的模式识别和预测)、一个调用的例程(包括简单的数据预处理如归一化的使用,测试结果准确率为98.3...
  • 提前说明一下,本文的CNN神经网络模型是参考网上诸多相关CNN图像分类大牛的博客修改的,在模型的基础上,用python的Flask框架搭载了一个web页面用来可视化展示。 第一步,爬取图片数据集 用python实现了一个非常简单...
  • 用来做分类的图像数据集,包含17个花卉种类,17个文件夹。可以根据自己的需求调整数量。
  • 数据集为牛津大学库里的17类花卉图像提取码c4s4,该程序的思路是参考手势识别的项目所修改。 1. 提取所有花卉图像的SIFT特征 opencv里有直接调用sift特征提取的函数,下列操作是将所有类别图像文件夹遍历,批量提取...

    数据集为牛津大学库里的17类花卉图像提取码c4s4,该程序的思路是参考手势识别的项目所修改。

    1. 提取所有花卉图像的SIFT特征

    opencv里有直接调用sift特征提取的函数,下列操作是将所有类别图像文件夹遍历,批量提取sift特征,并将特征量化到一个文本文件中方便后续操作。

    path = './' + 'feature' + '/' #保存特征的路径
    path_img = './' + 'image' + '/' #数据集路径
    
    def calcSURFFeature(img):
    	gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    	sift = cv2.xfeatures2d.SURF_create(200) #特征点数量限制自行设置 
    	kps, des = sift.detectAndCompute(gray, None)
    	return des
    	
    if __name__ == "__main__":
        for i in range(1, 18): #读取17类图像的文件夹
            for j in range(1, 21): #读取每类文件夹的图像数量
                #文件夹路径+命名形式
                #数据集内图像名称未按顺序命名,建议先改名后提取特征
                roi = cv2.imread(path_img + str(i) + '_' + str(j) + '.jpg') 
                descirptor_in_use = fd.calcSURFFeature(roi)
                fd_name = path + str(i) + '_' + str(j) + '.txt' #形成特征
                with open(fd_name, 'w', encoding='utf-8') as f:
                    for k in range(1, len(descirptor_in_use)):
                        x_record = descirptor_in_use[k]
                        f.write(str(x_record))
                        f.write(' ')
                    f.write('\n')
                print(i, '_', j, '完成')
    

    2. 将文本文件中特征形式统一

    由于上一步得出的文本中的surf特征都是矩阵形式,为了后续方便分类,将文本中不必要的字符都删除掉。

    path = './' + 'feature' + '/'
    xmls = glob.glob(path+'*.txt')
    
    for one_xml in xmls:
        print(one_xml)
        f = open(one_xml, 'r+', encoding='utf-8')
        all_the_lines = f.readlines()
        f.seek(0)
        f.truncate()
        for line in all_the_lines:
            line = line.replace('[', '')
            line = line.replace(']', '')
            line = line.replace(' ', '')
            line = line.replace('  ', '')
            line = line.replace('   ', '')
            line = line.replace('\n', '')
            line = line.replace('.', ' ')
            f.write(line)
        f.close()
    

    3. 用SVM分类

    先将文本文件中数据归一化

    #路径设置
    path = './' + 'feature' + '/'
    model_path = "./model/"
    test_path = "./test_feature/"
    
    test_accuracy = []
    
    def txtToVector(filename, N):
    	returnVec = np.zeros((1, N))
    	fr = open(filename)
    	lineStr = fr.readline()
    	lineStr = lineStr.split(' ')
    	for i in range(N):
    		returnVec[0, i] = int(lineStr[i])
    	return returnVec
    

    再到SVM分类器的训练过程,SVM参数设定很重要,参数设置要求越高时间越长,网上有很多SVM参数设定的文章。训练过程中有很多数据用不了,可以直接删除。数据能否使用,与后面设定的N值有关,可以进行debug形式查看哪些数据不能用,但过程比较繁琐。

    def tran_SVM(N):
    	svc = SVC()
    	parameters = {'kernel': ('linear', 'rbf'),
    				  'C': [1, 3, 5, 7, 9],
    				  'gamma': [0.0001, 0.001, 0.1, 1, 10, 100]}  
    	hwLabels = []  # 存放类别标签
    	trainingFileList = listdir(path)
    	m = len(trainingFileList)
    	trainingMat = np.zeros((m, N))
    	for i in range(m):
    		fileNameStr = trainingFileList[i]
    		classNumber = int(fileNameStr.split('_')[0])
    		hwLabels.append(classNumber)
    		trainingMat[i, :] = txtToVector(path + fileNameStr, N)  
    	print("完成")
    	clf = GridSearchCV(svc, parameters, cv=5, n_jobs=4) #此处参数设定也很重要
    	clf.fit(trainingMat, hwLabels)
    	best_model = clf.best_estimator_
    	print("SVM模型保存中...")
    	save_path = model_path + "svm_efd_" + "train_model.m"
    	joblib.dump(best_model, save_path)  # 保存最好的模型
    
    def test_SVM(clf, N):
    	testFileList = listdir(test_path)
    	errorCount = 0  # 记录错误个数
    	mTest = len(testFileList)
    	for i in range(mTest):
    		fileNameStr = testFileList[i]
    		classNum = int(fileNameStr.split('_')[0])
    		vectorTest = txtToVector(test_path + fileNameStr, N)
    		valTest = clf.predict(vectorTest)
    		if valTest != classNum:
    			errorCount += 1
    	print("总共错了%d个数据\n错误率为%f%%" % (errorCount, errorCount / mTest * 100))
    
    if __name__ == "__main__": #此处N值设定影响训练结果
    	tran_SVM(50000)
    	clf = joblib.load(model_path + "svm_efd_" + "train_model.m")
    	test_SVM(clf,50000)
    

    4. 总结

    关于N值的设定我调了很久,N值越大结果的精确度越高,但也对数据有很多限制,因此也删除了许多数据,我用AMD训练时间花了一个多小时。大家可以尝试其他特征提取后再做SVM分类,我用SURF特征提取精确度并不高,不知道有哪些位置可以改正以提高识别率,欢迎交流。

    展开全文
  • 主要介绍了python KNN算法实现鸢尾花数据集分类,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 使用Python最终项目进行AI编程(创建自己的花朵图像分类器) 该项目包括两个部分,一个是使用PyTorch开发图像分类器的代码,然后将该代码转换为命令行Python应用程序。 vgg16和densitynet121神经网络模型已用于该...
  • 官网虽然可以下载,但是是1360张图片堆在一个文件夹里,没有分类。要是自己手动分成17个文件夹,然后再复制图片进去,一来效率低,二是容易出错。以下代码是把1360张图片按照80个一类分别放入17个文件夹中: # ...

    牛津花卉数据集下载链接:http://www.robots.ox.ac.uk/~vgg/data/flowers/17/
    官网虽然可以下载,但是是1360张图片堆在一个文件夹里,没有分类。要是自己手动分成17个文件夹,然后再复制图片进去,一来效率低,二是容易出错。以下代码是把1360张图片按照80个一类分别放入17个文件夹中:

    # coding:utf-8
    
    from imutils import paths   # 把dir路径下的所有图片名称变成一个列表
    import os
    import shutil
    
    dataset_dir = os.path.abspath(r"C:/迅雷下载/17flowers")
    
    picture_list = list(paths.list_images(dataset_dir))  # 存放1360张图片的文件夹
    
    pic_num = 0  # 用来计数1360,便于接下来遍历存储图片
    
    for i in range(1, 18):
        value = 0
        file_path = os.path.abspath(str(i))    # 创建17个类别文件夹
        while value < 80:
            shutil.copy(picture_list[pic_num], file_path)  # 这个是复制语句,将picture_list的图片复制到file文件夹里
    
            pic_num += 1
            value += 1
    

    转自https://blog.csdn.net/einstellung/article/details/90181177

    展开全文
  • 分类 使用mobilenet v2对102种花朵进行分类并进行转移学习。 使用Costom数据集对花朵图像进行分类 下载资料 在该项目中,使用了 。 您可以下载和。 数据集为tar文件形式,一旦提取,所有图像均位于jpg文件夹内。 ...
  • Python BP神经网络实现

    千次阅读 2018-06-11 20:19:01
    Python_BP神经网络实现(向量化运算、鸢尾花分类测试) 简介 人工神经网络模型种类很多,其中根据网络内数据流向进行分类可以分为前馈网络、反馈网络和自组织网络。 通过对Andrew Ng的深度学习课程的学习,本文...

    Python_BP神经网络实现(向量化运算、鸢尾花分类测试)


    简介

    人工神经网络模型种类很多,其中根据网络内数据流向进行分类可以分为前馈网络、反馈网络和自组织网络。

    通过对Andrew Ng的深度学习课程的学习,本文总结其中浅层神经网络一章的知识点(本文重点不在于公式讲解,而是算法的简单实现,具体理论可看——深度学习工程师)。在此介绍和利用Python实现BP神经网络,BP神经网络是一种典型的前馈神经网络。

    结构

    BP神经网络分为三层分别是输入层、隐层和输出层,其中隐层的层数可以扩展,且每一层的神经元个数也可以增减。每一层中神经元与前后层神经元相连接,但是同一层神经元之间无连接。可看下方示意图。

    原理

    当我们使用BP神经网络来对数据进行分类或者预测的时候,每对有连接的神经元之间都有一个权重,记为w;同时还有偏移量,记为b。每个神经元中还有一个激活函数,记为σ(x),要注意的是这不是一个函数,有多个函数可以作为激活函数SigmoidtanhRelu等。

    在每一次迭代计算中,正向运算(输入层开始),我们会计算出一个值,然后计算出该值与标准值的误差;反向运算(输出层开始),按照减小误差方向,修正各连接权。通过一次次的迭代计算,直到误差减小到给定的极小值,就可以结束迭代,完成训练。

    Python实现思路

    通过python实现BP神经网络,主要有以下几个步骤:

    1. 神经网络结构确定
    2. 权重和偏移量参数初始化
    3. 正向传播计算
    4. 成本函数计算
    5. 反向传播计算
    6. 权重和偏移量参数更新

    神经网络结构确定

    该函数主要是为了获取输入量x的矩阵大小,以及标签y的矩阵大小。

    def layer_size(X, Y):
    """
    :param X: input dataset of shape (input size, number of examples)  (输入数据集大小(几个属性,样本量))
    :param Y: labels of shape (output size, number of exmaples) (标签数据大小(标签数,样本量))
    :return: 
    n_x: the size of the input layer
    n_y: the size of the output layer
    """
    n_x = X.shape[0]
    n_y = Y.shape[0]
    
    return (n_x, n_y)
    

    权重和偏移量参数初始化

    该函数主要是为了初始化我们的连接权重w和偏移量b。要注意的是确保参数矩阵大小正确。

    def initialize_parameters(n_x, n_h, n_y):
    """
    initialize_parameters
    (参数初始化)
    :param n_x: size of the input layer 
    :param n_h: size of the hidden layer
    :param n_y: size of the output layer
    :return: 
    W1: weight matrix of shape (n_h, n_x) (第1层的权重矩阵(n_h, n_x))
    b1: bias vector of shape (n_h, 1) (第1层的偏移量向量(n_h, 1))
    W2: weight matrix of shape (n_y, n_h) (第2层的权重矩阵(n_y, n_h))
    b2: bias vector of shape (n_y, 1) (第2层的偏移量向量(n_y, 1))
    """
    # np.random.seed(2)  #Random initialization (随机种子初始化参数)
    
    W1 = np.random.randn(n_h, n_x) * 0.01
    b1 = np.zeros((n_h, 1))
    W2 = np.random.randn(n_y, n_h) * 0.01
    b2 = np.zeros((n_y, 1))
    
    parameters = {
        'W1': W1,
        'b1': b1,
        'W2': W2,
        'b2': b2,
    }
    
    return parameters
    

    正向传播计算

    该函数为正向传播计算,需要注意的是,中间层的激活函数为tanh,输出层的激活函数为sigmoid。

    def forward_propagation(X, parameters):
    """
    forward_propagation
    (正向传播)
    :param X: input data of size (n_x, m)  (输入数据集X)
    :param parameters: python dictionary containing your parameters (output of initialization function) (字典类型, 权重以及偏移量参数)
    :return: 
    A2: The sigmoid output of the second activation (第2层激活函数sigmoid函数输出向量)
    cache: a dictionary containing "Z1", "A1", "Z2" and "A2" (字典类型,包含"Z1", "A1", "Z2", "A2")
    """
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']
    
    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)            #第1层激活函数选择tanh
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)            #第2层激活函数选择sigmod
    
    
    assert (A2.shape == (1, X.shape[1])) #若A2的大小和((1, X.shape[1]))不同,则直接报异常
    
    cache = {
        'Z1': Z1,
        'A1': A1,
        'Z2': Z2,
        'A2': A2,
    }
    
    return A2, cache
    

    成本函数计算

    该函数主要是为了计算成本函数,注意一个样本的期望输出和实际输出的误差的平方用来定义损失函数,在向量化的计算过程中,这里使用了成本函数。详细定义可见深度学习工程师

    def compute_cost(A2, Y, parameters):
    """
    compute cost
    (计算成本函数)
    :param A2: The sigmoid output of the second activation, of shape (1, number of examples) (第2层激活函数sigmoid函数输出向量)
    :param Y: "true" labels vector of shape (1, number of examples) (正确标签向量)
    :param parameters: python dictionary containing your parameters W1, b1, W2 and b2 (字典类型,权重以及偏移量参数)
    :return: 
    cost: cross-entropy cost 
    """
    m = Y.shape[1]  # number of example
    
    W1 = parameters['W1']
    W2 = parameters['W2']
    
    logprobs = np.multiply(np.log(A2), Y)
    cost = - np.sum(np.multiply(np.log(A2), Y) + np.multiply(np.log(1. - A2), 1. - Y)) / m
    # cost = np.sum(Y * np.log(A2) + (1 - Y) * np.log(1 - A2))/(-m)
    
    cost = np.squeeze(cost) #squeeze()函数的功能是:从矩阵shape中,去掉维度为1的。例如一个矩阵是的shape是(5, 1),使用过这个函数后,结果为(5,)。
    
    assert (isinstance(cost, float)) #若cost不是float型 则直接报异常
    
    return cost
    

    反向传播计算

    该函数为方向传播计算。

    def backward_propagation(parameters, cache, X, Y):
    """
    backward propagation
    (反向传播)
    :param parameters: python dictionary containing our parameters
    :param cache: a dictionary containing "Z1", "A1", "Z2" and "A2"
    :param X: input data of shape (2,number of examples)
    :param Y: "ture" labels vector of shape (1, number of examples)
    :return: 
    grads: python dictionary containing your gradients with respect to different parameters (字典类型,梯度微分参数)
    """
    m = X.shape[1]
    
    W1 = parameters['W1']
    W2 = parameters['W2']
    
    A1 = cache['A1']
    A2 = cache['A2']
    
    dZ2 = A2 - Y
    dW2 = np.dot(dZ2, A1.T) / m
    db2 = np.sum(dZ2, axis=1, keepdims=True) / m
    dZ1 = np.dot(W2.T, dZ2) * (1 - A1 ** 2)
    dW1 = np.dot(dZ1, X.T) / m
    db1 = np.sum(dZ1, axis=1, keepdims=True) / m
    
    grads = {
        'dW1': dW1,
        'db1': db1,
        'dW2': dW2,
        'db2': db2,
    }
    
    return grads
    

    权重和偏移量参数更新

    该函数为更新权重和偏移量参数。

    def update_parameters(parameters, grads, learning_rate):
    """
    update parameters
    (更新权重和偏移量参数)
    :param parameters: python dictionary containing your parameters
    :param grads: python dictionary containing your gradients 
    :param learning_rate (学习速率)
    :return: 
    :parameters:  python dictionary containing your updated parameters 
    """
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']
    
    dW1 = grads['dW1']
    db1 = grads['db1']
    dW2 = grads['dW2']
    db2 = grads['db2']
    
    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2
    
    parameters = {
        "W1": W1,
        "b1": b1,
        "W2": W2,
        "b2": b2,
    }
    
    return parameters
    

    BP神经网络

    选择我们将上面的几个函数组合起来,就可以得到一个两层的BP神经网络模型。

    def nn_model(X, Y, n_h, num_iterations, learning_rate, print_cost=False):
    """
    Forward Neural Network model
    (前向神经网络模型)
    :param X: input dataset of shape (input size, number of examples)  (输入数据集大小(几个属性,样本量))
    :param Y: labels of shape (output size, number of exmaples) (标签数据大小(标签数,样本量))
    :param n_h: size of the hidden layer (隐层神经元数量)
    :param num_iterations:  Number of iterations in gradient descent loop (迭代次数)
    :param learning_rate (学习速率)
    :param print_cost: if True, print the cost every 1000 iterations (是否打印显示)
    :return: 
    parameters: parameters learnt by the model. They can then be used to predict (训练完成后的参数)
    """
    
    # np.random.seed(4)
    n_x = layer_size(X, Y)[0]
    n_y = layer_size(X, Y)[1]
    
    parameters = initialize_parameters(n_x, n_h, n_y)
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']
    
    cost_list = []
    for i in range(0, num_iterations):
    
        A2, cache = forward_propagation(X, parameters)
    
        cost = compute_cost(A2, Y, parameters)
    
        cost_list.append(cost)
    
        grads = backward_propagation(parameters, cache, X, Y)
    
        parameters = update_parameters(parameters, grads, learning_rate)
    
        if print_cost and i % 1000 == 0:
            print("Cost after iteration %i: %f" % (i, cost))
    
    return parameters, cost_list
    

    鸢尾花分类测试

    既然已经完成了这个BP神经网络模型,现在就可以来试试效果。在这里我们用鸢尾花的分类来检测这个模型的可用性。

    简介

    Iris数据集是常用的分类实验数据集,由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。数据集包含150个数据集,分为3类,每类50个数据,每个数据包含4个属性。可通过花萼长度,花萼宽度,花瓣长度,花瓣宽度4个属性预测鸢尾花卉属于(Setosa,Versicolour,Virginica)三个种类中的哪一类。

    属性:

    • Sepal.Length(花萼长度),单位是cm;

    • Sepal.Width(花萼宽度),单位是cm;

    • Petal.Length(花瓣长度),单位是cm;

    • Petal.Width(花瓣宽度),单位是cm;

    种类:

    • Iris Setosa(山鸢尾)(本例中使用数字‘0’表示)
    • Iris Versicolour(杂色鸢尾)(本例中使用数字‘1’表示)
    • Iris Virginica(维吉尼亚鸢尾)(本例中使用数字‘2’表示)

    鸢尾花数据下载

    测试程序

    #!/usr/bin/env python  
    # _*_ coding:utf-8 _*_  
    #  
    # @Version : 1.0  
    # @Time    : 2018/6/6  
    # @Author  : 圈圈烃
    # @File    : User_BPNN
    import numpy as np
    import matplotlib.pyplot as plt
    from Forward_NeuralNetwork import *
    
    
    def data_process():
        """Iris.txt数据预处理"""
        with open("iris.txt", 'r') as f:
            data = f.read()
            data = data.replace('Iris-setosa', '0,')
            data = data.replace('Iris-versicolor', '1,')
            data = data.replace('Iris-virginica', '2,')
        with open("iris1.txt", 'w') as fw:
            fw.write(data)
            fw.close()
    
    
    def load_csv():
        """加载处理好存入csv格式的数据"""
        tmp = np.loadtxt("iris.csv",dtype=np.str, delimiter=",")
        data = tmp[0:, 0:4].astype(np.float)
        label = tmp[0:, 4].astype(np.float)
        label = label.reshape(150, 1)
        return data.T, label.T
    
    
    def normalized(X):
        """
        :param X: 待归一化的数据 
        :return: 
        X:归一化后的数据
        """
        Xmin, Xmax = X.min(), X.max()
        XN = (X - Xmin) / (Xmax - Xmin)
        return XN
    
    
    def main():
    
        X, Y = load_csv()
        X = normalized(X)
        Y = normalized(Y)
        """训练集90个数据"""
        train_x = np.hstack((X[:, 0:30], X[:, 50:80], X[:, 100:130]))
        train_y = np.hstack((Y[:, 0:30], Y[:, 50:80], Y[:, 100:130]))
        """测试集60个数据"""
        test_x = np.hstack((X[:, 30:50], X[:, 80:100], X[:, 130:150]))
        test_y = np.hstack((Y[:, 30:50], Y[:, 80:100], Y[:, 130:150]))
        """训练,中间层10个神经元,迭代10000次,学习率0.25"""
        n_h = 10
        parameter, cost_list = nn_model(train_x, train_y, n_h, num_iterations=10000, learning_rate=0.25, print_cost=True)
        """测试,代入测试集数据"""
        A2, cache = forward_propagation(test_x, parameters=parameter)
        TY = A2
        TY[TY > 0.8] = 1
        TY[TY < 0.2] = 0
        TY[(TY >= 0.2) & (TY <= 0.8)] = 0.5
        # print(A2,TY)
        count = 0
        for i in range(0, 60):
            if TY[0, i] == test_y[0, i]:
                count += 1
        print("准确率为:%f %%" %(100*count/60))
        """绘制梯度下降曲线"""
        plt.plot(cost_list)
        plt.show()
    
    
    if __name__ == '__main__':
        main()
    

    测试结果

    测试中,将150个数划分成了90个训练数据,60个测试数据。神经网络的中间层为10个神经元,迭代次数为10000次,学习率为0.25。在训练和测试中,需要对数据进行归一化,其中包括对标签数据Y的归一化,原来,我设置的三类鸢尾花的标签分别是0,1,2。通过归一化之后,获得的标签数据为0,0.5,1。对测试集获得的结果,进行归档,小于0.2的为0,大于0.8的为1,其余的均为0.5。最终获得的分类结果的准确率为98.3%。

    Cost after iteration 0: 0.693152
    Cost after iteration 1000: 0.280715
    Cost after iteration 2000: 0.275627
    Cost after iteration 3000: 0.274676
    Cost after iteration 4000: 0.274162
    Cost after iteration 5000: 0.273742
    Cost after iteration 6000: 0.273368
    Cost after iteration 7000: 0.273018
    Cost after iteration 8000: 0.272678
    Cost after iteration 9000: 0.272336
    准确率为:98.333333 %
    

    写在最后

    完整程序,欢迎下载

    还有不足,欢迎交流。

    展开全文
  • python+Tensorflow+CNN花朵分类

    千次阅读 2019-12-22 18:36:06
    1、首先下载数据集,存放于电脑E盘,图片路径path,e:\flowers; 2、读取数据。将图片存放在data中,标签存放在label中 #读取图片 def read_img(path): #os.listdir(path)表示在path路径下的所有文件和和文件夹...

    代码

    实验步骤

    1、首先下载数据集,存放于电脑E盘,图片路径path,e:\flowers;
    2、读取数据。将图片存放在data中,标签存放在label中

    #读取图片
    def read_img(path):
        #os.listdir(path)表示在path路径下的所有文件和和文件夹列表
        #用cate记录五种花的文件路径
        cate=[path+x for x in os.listdir(path) if os.path.isdir(path+x)]
        imgs=[]  #存放所有的图片
        labels=[]  #图片的类别标签
        for idx,folder in enumerate(cate):
            for im in glob.glob(folder+'/*.jpg'):
                #print('reading the images:%s'%(im))#im表示某张图片的路径
                img=io.imread(im)
                img=transform.resize(img,(w,h))#图片resize为100*100
                imgs.append(img)
                labels.append(idx)
        #不用array的原因是copy时不会占用新的内存
        return np.asarray(imgs,np.float32),np.asarray(labels,np.int32)   
    

    3、从每类花中选取部分图片可视化。设置要显示的每类花的数量show_num,获取每类花的总数量max_n。对每类花,随机生成show_num个在0,max_n-1之间的数据,表示在该类花中随机选择的图片。由于data中花是按顺序存放Dev,所以i类花的第j个花在data中的位置为i*max_n+j。调用matplotlib.pyplot显示图片。

    #部分图片可视化,每种花分别选取show_num 张
    ###1.每类花选择show_num张图片显示
    ###2.获取每类花的数量max_n
    ###3.对每类花,随机生成show_num个在0,max_n-1之间的数据,表示该类花随机选择的图片
    ###由于data中花是按顺序存放,i类花的第j个在data中的位置为i*max_n+j
    def show(data,label):
        show_num = 5
        plt.figure()
        max_n = np.int(data.shape[0]/5)
        for i in range(show_num):
            a=[random.randint(0,max_n) for _ in range(show_num)]
            for j in range(show_num):
                plt.subplot(show_num,show_num,show_num*i+j+1)
                plt.imshow(data[a[j]+np.int(max_n*i)-1])
                plt.axis('off')
        plt.show()
    

    结果:
    在这里插入图片描述
    4、将所有图片归一化为100×100×3,打乱顺序后,选取60%作为训练集,20%为验证集,20%作为测试集。
    训练集:用来训练网络参数,使得模型能够拟合数据。
    验证集:调整超参数,防止模型发生过拟合,从而决定训练的结束。
    测试集:用来测试模型的泛华能力,检查模型是否能很好的拟合训练过程中没有出现过的新数据,以此反应模型的真实能力。

    #打乱顺序
    ###调用np.random.shuffle函数将有序数组变无序
    ###返回打乱顺序后的图片和对应的标签
    def disturb(data,lable):
        num_example=data.shape[0]
        arr=np.arange(num_example)
        np.random.shuffle(arr)
        img=data[arr]
        labels=label[arr]
        return img,labels
    #将所有数据分为训练集和验证集\测试集
    def allocate(data,label):
        inter1 = 0.6
        inter2 = 0.8
        num_example = data.shape[0]
        s1 = np.int(num_example*inter1)
        s2 = np.int(num_example*inter2)
        x_train = data[:s1]
        y_train = label[:s1]
        x_val = data[s1:s2]
        y_val = label[s1:s2]
        x_test = data[s2:]
        y_test = label[s2:]
        return x_train,y_train,x_val,y_val,x_test,y_test    
    

    5、构建CNN卷积网络,下图为CNN网络图。CNN模型输入为100×100,3个通道的图像;

    第一层:Convolution5×5的卷积核32个,步幅为2,max_pooling卷积核2×2,Relu激活函数后,后输出第一层tensor为50×50×32。

    第二层:Convolution 5×5的卷积核64个,步幅为2,max_pooling卷积核2×2,Relu激活函数后输出tensor为25×25×64

    第三层:Convolution3×3的卷积核128个,步幅为2,max_pooling卷积核2×2,Relu激活函数后输出tensor为12×12×128

    第四层:Convolution3×3的卷积核128个,步幅为2,max_pooling卷积核2×2,Relu激活函数后输出tensor为6×6×128

    进入全连接层
    第一层全连接层:1024维,将第四层输出的6×6×128tensor连接成为一个一维向量,作为该层的输入。

    第二层全连接层:512维

    第三层全连接层:5维

    Softmax层:输出为5,即属于五类花中每类花的概率。
    在训练时,从数据集中按批次取数据,设置的大小为64,训练次数分别设置为10次和20次,得到测试结果。

    #-----------------构建网络----------------------
    def Network():
    #占位符
        #第一个卷积层(100——>50)
        conv1=tf.layers.conv2d(
              inputs=x,
              filters=32,
              kernel_size=[5, 5],
              padding="same",
              activation=tf.nn.relu,
              kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
        pool1=tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
    #第二个卷积层(50->25)
        conv2=tf.layers.conv2d(
              inputs=pool1,
              filters=64,
              kernel_size=[5, 5],
              padding="same",
              activation=tf.nn.relu,
              kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
        pool2=tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
     #第三个卷积层(25->12)
        conv3=tf.layers.conv2d(
              inputs=pool2,
              filters=128,
              kernel_size=[3, 3],
              padding="same",
              activation=tf.nn.relu,
              kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
        pool3=tf.layers.max_pooling2d(inputs=conv3, pool_size=[2, 2], strides=2)
     #第四个卷积层(12->6)
        conv4=tf.layers.conv2d(
              inputs=pool3,
              filters=128,
              kernel_size=[3, 3],
              padding="same",
              activation=tf.nn.relu,
              kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
        pool4=tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2)
        re1 = tf.reshape(pool4, [-1, 6 * 6 * 128])
    #全连接层
        dense1 = tf.layers.dense(inputs=re1, 
                          units=1024, 
                          activation=tf.nn.relu,
                          kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                          kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
        dense2= tf.layers.dense(inputs=dense1, 
                          units=512, 
                          activation=tf.nn.relu,
                          kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                          kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
        logits= tf.layers.dense(inputs=dense2, 
                            units=5, 
                            activation=None,
                            kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                            kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
         return logits                                                  
    

    6、训练模型,将训练好的模型保存在modle.ckpt中。

    #训练和测试数据,可将n_epoch设置更大一些
    def train(x_train,y_train,x_val,y_val,train_op,loss,acc):
        n_epoch=10
        batch_size=64
        # 用于保存和载入模型
        saver = tf.train.Saver(max_to_keep=1)
        sess=tf.InteractiveSession()  
        sess.run(tf.global_variables_initializer())
        #保存训练过程中训练损失和训练集的正确率
        Train_loss= np.zeros(n_epoch)
        Train_acc = np.zeros(n_epoch)
        #保存训练过程中验证损失和验证集的正确率
        Val_loss= np.zeros(n_epoch)
        Val_acc = np.zeros(n_epoch)
        for epoch in range(n_epoch):
            start_time = time.time()
            #training
            train_loss, train_acc, n_batch = 0, 0, 0
            for x_train_a, y_train_a in minibatches(x_train, y_train, batch_size, shuffle=True):
                _,err,ac=sess.run([train_op,loss,acc], feed_dict={x: x_train_a, y_: y_train_a})
                train_loss += err; 
                train_acc += ac; 
                n_batch += 1
            print('epoch',epoch+1)
            Train_loss[epoch] = train_loss/ n_batch
            Train_acc[epoch] = train_acc/ n_batch
            print("   train loss: %f" % Train_loss[epoch])
            print("   train acc: %f" %  Train_acc[epoch])
            #validation
            val_loss, val_acc, n_batch = 0, 0, 0
            for x_val_a, y_val_a in minibatches(x_val, y_val, batch_size, shuffle=False):
                err, ac = sess.run([loss,acc], feed_dict={x: x_val_a, y_: y_val_a})
                val_loss += err; 
                val_acc += ac; 
                n_batch += 1
            Val_loss[epoch] = val_loss/ n_batch
            Val_acc[epoch] = val_acc/ n_batch
            print("   validation loss: %f" %  Val_loss[epoch])
            print("   validation acc: %f" %  Val_acc[epoch])
        N = [i+1 for i in range(n_epoch)]
        saver.save(sess,modle_path)
        sess.close()
        return Train_loss,Train_acc,Val_loss,Val_acc,N
    

    最终训练10次时训练集正确率达到58.82%,下图为训练损失、训练正确率、验证损失和验证集正确率随训练次数的变化。
    在这里插入图片描述

    7、测试模型。载入训练好的模型,读取模型参数,将测试集数据传人网络得到输出,输出与正确标签对比获得测试集正确率。

    def test(x_test,y_test):
        with tf.Session() as sess:
            saver = tf.train.import_meta_graph('E:/flowers/modle.ckpt.meta')
            saver.restore(sess,tf.train.latest_checkpoint('E:/flowers/'))
            #获取默认系统图
            graph = tf.get_default_graph()
            x = graph.get_tensor_by_name("x:0")
            feed_dict = {x:x_test}
            logits = graph.get_tensor_by_name("logits_eval:0")
            #得到预测结果
            classification_result = sess.run(logits,feed_dict)
            #根据索引通过字典对应花的分类
            output = []
            output = tf.argmax(classification_result,1).eval()
            print(output)
            Real = tf.equal(output,y_test).tolist.count(True)
            test_acc = Real / x_test.shape[0]
            return test_acc
    

    8、预测花朵类别。读取训练好的模型,输入待测试图片,最终输出花朵种类。本文从网上一共找了10张图片进行测试。

    # -*- coding: utf-8 -*-
    import matplotlib.pyplot as plt
    import numpy as np
    import tensorflow as tf
    from skimage import io,transform                                          
    def predict(img):
        with tf.Session() as sess:
            saver = tf.train.import_meta_graph('E:/flowers/modle.ckpt.meta')
            saver.restore(sess,tf.train.latest_checkpoint('E:/flowers/'))
            graph = tf.get_default_graph()
            x = graph.get_tensor_by_name("x:0")
            feed_dict = {x:img}
            logits = graph.get_tensor_by_name("logits_eval:0")
            #得到预测结果
            classification_result = sess.run(logits,feed_dict)
            output = tf.argmax(classification_result,1).eval()
            return output
    imgs = []
    for i in range(1,10):
        img = io.imread('e:/test/'+str(i)+'.jpg')
        img = transform.resize(img,(100,100))
        imgs.append(img)
    imgs = np.asarray(imgs,np.float32)
    output = predict(imgs)
    #acc = test(x_test,y_test)
    class_flower = ["daisy","dandelion","rose","sunflowers","tulips"]
    plt.rcParams['font.sans-serif']=['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    print('预测结果:',output)
    for i in range(9):
        plt.figure(i+1)
        img = io.imread('e:/test/'+str(i+1)+'.jpg')
        plt.imshow(img)
        plt.xlabel('预测结果为:'+class_flower[output[i]])    
    

    结果:
    在这里插入图片描述

    如果这篇文章对您有帮助的话,感谢支持哦!

    在这里插入图片描述

    展开全文
  • 本文是利用卷积神经网络VGG16模型对花卉和手势进行分类识别,利用卷积神经网络的卷积层进行特征提取,连接层起到分类器的作用,对图像进行分类。所用软件是pycharm,解释器是python3.6。
  • 目录 一、模型框架 二、数据预处理 ...在之前的中期报告中,对于两个题目我分别用的是肤色检测和CNN模型,但是,在之后的程序设计当中,我发现对于两者所训练的结果准确率不高,并且分类效果不明...
  • Python决策树鸢尾花类别分类

    千次阅读 2020-05-18 11:16:47
    Python决策树鸢尾花类别分类 引入使用到的模块 #决策树 鸢尾花类别 import sklearn.datasets as dSets import pandas as pd; import matplotlib.pyplot as plt from sklearn.model_selection import train_test_...
  • 需要的第三方库: pytorch、matplotlib、json、os、tqdm 一、model.py的编写 (1)准备工作 1.参照vgg网络结构图(如下图1),定义一个字典,用于存放各种vgg网络,字典如下图2(M表示最大池化层) ...
  • 用于花卉多类分类的 Scikit-learn 神经网络 用于心电图 (ECG) 异常检测的 Keras LSTM 递归神经网络 第 6 章:Scikit-image 的医学图像处理应用 Scikit-image io 模块,用于读取、写入和可视化各种格式的图像 Scikit-...
  • 现在,我们使用Python语言来实现感知器算法,进行鸢尾花的分类。 class Perceptron : """通过Python语言实现感知器类。用来进行二分类任务。""" def __init__ ( self , eta , epoch ) : """初始...
  • 深度学习代码,主要用于垃圾分类花卉识别、图像识别,python语言编写
  • 使用TensorFlow进行卷积神经网络实现花卉分类的项目,加载十种花分类,建立模型后进行预测分类图片 环境:win10 +TensorFlow gpu 1.12.0+pycharm 训练集 训练数据存放路径为:‘D:/LearnMSA/flower/train/花文件名/*....
  • python_io . tf_record_iterator ( tfrecord_name ) : sample_nums += 1 return sample_nums train_total = total_sample ( 'train.tfrecords' ) test_total = total_sample ( 'test.tfrecords' ) ...
  • (▲由Python大本营下载自视觉中国)翻译 | 李润嘉校对 | 和中华来源 |数据派THU(ID:DatapiTHU)本教程介绍了用于分类的决策树,即分类树,包括分类...
  • KNN(python)实现-鸢尾花

    2019-05-19 20:18:49
    根据段小手的《深入浅出Python机器学习》第三章KNN实现,采用pycharm 2017.3运行,由于本机sklearn中datasets没有load_wine(),使用鸢尾花(load_iris)代替。效果相同。
  • 102类花卉分类数据集(已划分,有训练集、测试集、验证集标签)+完整运行代码 数据集已经经过处理划分好了,并且附带了训练集,测试集,验证集的txt文本标签。配合完整运行代码即可训练。 数据集链接在文章中间部分 ...
  • 【大作业怎么搞01】基于tensorflow2.3的花卉识别程序_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili 垃圾分类是目前社会的一个热点,分类的任务是计算机视觉任务中的基础任务,相对来说比较简单,只要找到合适的数据集,...
  • 我们使用了102种花卉类别的数据集( )。 •解决方案:使用火炬视觉加载数据。 数据集分为三个部分:训练,验证和测试。 对于训练,应用了变换,例如随机缩放,裁剪和翻转。 这将有助于网络泛化,从而带来更好的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 947
精华内容 378
关键字:

花卉分类python

python 订阅