用Tensorflow实现植物幼苗图像分类(Kaggle——Plant Seedlings Classification)

最新推荐文章于 2024-04-28 23:02:26 发布
最新推荐文章于 2024-04-28 23:02:26 发布
阅读量4.6k 收藏 19
点赞数
分类专栏： Python TensorFlow Image Classification CNN 文章标签： TensorFlow Image Classification CNN
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liberty1997/article/details/80906363
版权

这道题作为了一门课程期末的考试题， 但因时间及硬件条件的限制，只是简单的搭网络、做预测，对模型精度并没有进行细调。

一、数据增强(Data Augmentation)

#!/bin/python3
import tensorflow as tf
import matplotlib.pyplot as plt
import os, random

def Left_Right(img):
    return tf.image.random_flip_left_right(img)

def Up_Down(img):
    return tf.image.random_flip_up_down(img)

def Transpose(img):
    return tf.image.transpose_image(img)

def Brightness(img, max_delta):
    return tf.image.random_brightness(img, max_delta)

def Contrast(img, lb, ub):
    return tf.image.random_contrast(img, lb, ub)

if __name__ == '__main__':
    path = '/mnt/windows_E/DeepLearningClass/Data'
    class_ = os.listdir(path)
    tf.set_random_seed(217)
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for i in range(len(class_)):
            print(class_[i])
            imgs = os.listdir(path + '/' + class_[i])
            random.shuffle(imgs)
            for j in range(0, 15):
                print(j)
                img = tf.gfile.FastGFile(path + '/' + class_[i] + '/' + imgs[j], 'rb').read()
                img = tf.image.decode_png(img, 3)
                img = Left_Right(img)
                img = tf.image.encode_png(img)
                with tf.gfile.FastGFile('./DataAugmentation/' + class_[i] + '/Aug_LR_' + imgs[j], 'wb') as writer:
                    writer.write(img.eval())
            for j in range(15, 30):
                print(j)
                img = tf.gfile.FastGFile(path + '/' + class_[i] + '/' + imgs[j], 'rb').read()
                img = tf.image.decode_png(img, 3)
                img = Up_Down(img)
                img = tf.image.encode_png(img)
                with tf.gfile.FastGFile('./DataAugmentation/' + class_[i] + '/Aug_UD_' + imgs[j], 'wb') as writer:
                    writer.write(img.eval())
            for j in range(30, 45):
                print(j)
                img = tf.gfile.FastGFile(path + '/' + class_[i] + '/' + imgs[j], 'rb').read()
                img = tf.image.decode_png(img, 3)
                img = Transpose(img)
                img = tf.image.encode_png(img)
                with tf.gfile.FastGFile('./DataAugmentation/' + class_[i] + '/Aug_TR_' + imgs[j], 'wb') as writer:
                    writer.write(img.eval())
            for j in range(45, 60):
                print(j)
                img = tf.gfile.FastGFile(path + '/' + class_[i] + '/' + imgs[j], 'rb').read()
                img = tf.image.decode_png(img, 3)
                img = Brightness(img, 0.2)
                img = tf.image.encode_png(img)
                with tf.gfile.FastGFile('./DataAugmentation/' + class_[i] + '/Aug_BR_' + imgs[j], 'wb') as writer:
                    writer.write(img.eval())
            '''
            for j in range(48, 60):
                print(j)
                img = tf.gfile.FastGFile(path + '/' + class_[i] + '/' + imgs[j], 'rb').read()
                img = tf.image.decode_png(img, 3)
                img = Contrast(img, 0.1, 0.6)
                img = tf.image.encode_png(img)
                with tf.gfile.FastGFile('./DataAugmentation/' + class_[i] + '/Aug_CO_' + imgs[j], 'wb') as writer:
                    writer.write(img.eval())
            '''

二、制作TFRecord

#!/bin/python3
import tensorflow as tf
import os
import random

def _int64_feature(v):
    return tf.train.Feature(int64_list = tf.train.Int64List(value = [v]))

def _bytes_feature(v):
    return tf.train.Feature(bytes_list = tf.train.BytesList(value = [v]))

def Write_TFRecords(path, output):
    class0 = os.listdir(path[0])
    class1 = os.listdir(path[1])
    class0.sort()
    class1.sort()
    photos = []
    label_ = {}
    for i in range(len(class0)):
        label_[class0[i]] = i
        pics = os.listdir(path[0] + class0[i] + '/')
        for j in range(len(pics)):
            photos.append(path[0] + '#' + class0[i] + '#' + pics[j])
    for i in range(len(class1)):
        pics = os.listdir(path[1] + class1[i] + '/')
        for j in range(len(pics)):
            photos.append(path[1] + '#' + class1[i] + '#' + pics[j])
    random.shuffle(photos)
    with open('Valid_Augmentation_120.txt') as f:
        con = f.read()
    valid = con.splitlines()
    photos = list(set(photos) - set(valid))
    with open('HALF.txt') as f:
        con = f.read()
    h = con.splitlines()
    photos = list(set(photos) - set(h))
    #half = len(photos) // 2
    fw = open('HALF2.txt', 'w')
    writer = tf.python_io.TFRecordWriter(output)
    #for i in range(half):
    for i in range(len(photos)):
        fw.write(photos[i] + '\n')
        p, label, pic = photos[i].split('#')
        print(i, p, label, pic)
        pic_ = p + label + '/' + pic
        image = tf.gfile.FastGFile(pic_, 'rb')
        img_str = image.read()
        height, width, channels = tf.image.decode_png(img_str).eval().shape
        example = tf.train.Example(features = tf.train.Features(feature = \
            {'image': _bytes_feature(img_str), 'label': _int64_feature(label_[label]), \
            'name': _bytes_feature(bytes(pic, encoding = 'utf8'))}))
        writer.write(example.SerializeToString())
    writer.close()
    fw.close()

if __name__ == '__main__':
    path = ['/mnt/windows_E/DeepLearningClass/Data/', './DataAugmentation/']
    output = './Weed_InputData_Training_Augmentation.tfrecords02'
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        Write_TFRecords(path, output)

三、读取TFRecord、数据预处理

#!/bin/python3
import tensorflow as tf
import matplotlib.pyplot as plt

def Read_Test_TFRecords(files, resize):
    files = tf.train.match_filenames_once(files)
    filename_queue = tf.train.string_input_producer(files, shuffle = False)
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(serialized_example, features = \
        {'image': tf.FixedLenFeature([], tf.string), 'img_name': tf.FixedLenFeature([], tf.string)})
    image = tf.image.decode_png(features['image'], 3)
    image = tf.image.convert_image_dtype(image, dtype = tf.float32)
    image = tf.image.resize_images(image, [resize, resize])
    name = features['img_name']

    return image, name

def Read_TFRecords(files):
    files = tf.train.match_filenames_once(files)
    filename_queue = tf.train.string_input_producer(files, shuffle = True)
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(serialized_example, features = \
        {'image': tf.FixedLenFeature([], tf.string), 'label': tf.FixedLenFeature([], tf.int64)})
    '''
    features = tf.parse_single_example(serialized_example, features = \
        {'image': tf.FixedLenFeature([], tf.string), 'label': tf.FixedLenFeature([1], tf.int64), \
        'height': tf.FixedLenFeature([1], tf.int64), 'width': tf.FixedLenFeature([1], tf.int64), \
        'channels': tf.FixedLenFeature([1], tf.int64)})
    decode_png时用RGB模式(数字3)
    之前是想从tfrecord中读取height/width/channels然后用reshape，
    但是总是有错
    '''
    image = tf.image.decode_png(features['image'], 3)
    label = tf.cast(features['label'], tf.int32)

    return image, label

def Preprocess(image, label, resize):
    image = tf.image.convert_image_dtype(image, dtype = tf.float32)
    image = tf.image.resize_images(image, [resize, resize])
    label = tf.one_hot(label, 12, 1., 0., dtype = tf.float32)

    return image, label

if __name__ == '__main__':
    batch_size = 10
    min_after_dequeue = 1000
    capacity = min_after_dequeue + 3 * batch_size
    num_threads = 2
    image, label = Read_TFRecords('Weed_InputData_Valid*')
    image_p, label_p = Preprocess(image, label, 256)
    image_batch, label_batch = tf.train.batch([image_p, label_p], batch_size = batch_size)
    #image_batch, label_batch = tf.train.shuffle_batch([image_p, label_p], batch_size = batch_size, capacity = capacity, min_after_dequeue = min_after_dequeue, num_threads = num_threads)
    with tf.Session() as sess:
        sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess = sess, coord = coord)
        for i in range(12):
            '''
            a, b = sess.run([image_batch, label_batch])
            plt.imshow(a[0])
            plt.show()
            '''
            a, b = sess.run([image_batch, label_batch])
            print(b)
        coord.request_stop()
        coord.join(threads)

四、模型训练

#!/bin/python3
import time
import tensorflow as tf
from Read_Data import *

def Conv_layer(in_, name, kh, kw, n_out, dh, dw, padding):
    n_in = in_.get_shape()[-1].value
    w = tf.get_variable('w_' + name + str(n_out), shape = [kh, kw, n_in, n_out], dtype = tf.float32, initializer = tf.contrib.layers.xavier_initializer_conv2d())
    b = tf.get_variable('b_' + name + str(n_out), shape = [n_out], dtype = tf.float32, initializer = tf.constant_initializer(0.0))
    conv = tf.nn.conv2d(input = in_, filter = w, strides = [1, dh, dw, 1], padding = padding)
    out_ = tf.nn.relu(tf.nn.bias_add(conv, b))
    return out_

def Maxpooling_layer(in_, kh, kw, dh, dw, padding):
    return tf.nn.max_pool(in_, ksize = [1, kh, kw, 1], strides = [1, dh, dw, 1], padding = padding)

def Fullc_layer(in_, name, n_out):
    n_in = in_.get_shape()[-1].value
    w = tf.get_variable('w_' + name + str(n_out), shape=[n_in, n_out], dtype = tf.float32, initializer = tf.contrib.layers.xavier_initializer())
    b = tf.get_variable('b_' + name + str(n_out), shape = [n_out], dtype = tf.float32, initializer = tf.constant_initializer(0.1))
    return tf.nn.relu_layer(in_, w, b)

def Model(x_, keep_prob):

    conv1_1 = Conv_layer(x_, 'conv1_1', 5, 5, 32, 3, 3, 'SAME')
    pool1 = Maxpooling_layer(conv1_1, 3, 3, 2, 2, 'SAME')

    conv2_1 = Conv_layer(pool1, 'conv2_1', 5, 5, 64, 3, 3, 'SAME')
    pool2 = Maxpooling_layer(conv2_1, 3, 3, 2, 2, 'SAME')

    pool_shape = pool2.get_shape().as_list()
    nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]
    reshaped = tf.reshape(pool2, [-1, nodes])

    fc1 = Fullc_layer(reshaped, 'fc1', 256)
    fc2 = Fullc_layer(fc1, 'fc2', 256)
    fc2_drop = tf.nn.dropout(fc2, keep_prob)
    fc3 = Fullc_layer(fc2_drop, 'fc3', 12)

    logits = fc3
    return logits

if __name__ == '__main__':
    IMAGE_SIZE = 256
    IMAGE_CHANNELS = 3
    BATCH_SIZE = 32
    MIN_AFTER_DEQUEUE = 500
    CAPACITY = MIN_AFTER_DEQUEUE + 3 * BATCH_SIZE
    NUM_THREADS = 4

    keep_prob = tf.placeholder(tf.float32, name = "keep_prob")

    #image, label = Read_TFRecords('Weed_InputData_Training.tfrecords*')
    image, label = Read_TFRecords('Weed_InputData_Training_Augmentation*')
    #image, label = Read_TFRecords('Weed_InputData_Augmentation*')
    image_p, label_p = Preprocess(image, label, IMAGE_SIZE)
    image_batch, label_batch = tf.train.shuffle_batch([image_p, label_p], batch_size = BATCH_SIZE, capacity = CAPACITY, min_after_dequeue = MIN_AFTER_DEQUEUE, num_threads = NUM_THREADS)

    logits = Model(image_batch, keep_prob)
    cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels = label_batch, logits = logits)
    loss = tf.reduce_mean(cross_entropy)
    train_step = tf.train.AdamOptimizer(1e-3).minimize(loss)

    correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(label_batch, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    saver = tf.train.Saver()
    with tf.Session() as sess:
        step = 0
        c_acc = 0
        start = time.time()
        sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess = sess, coord = coord)
        while True:
            sess.run(train_step, feed_dict = {keep_prob: 0.5})
            if step % 10 == 0:
                valid_loss, valid_accuracy = sess.run([loss, accuracy], feed_dict = {keep_prob: 1.0})
                print('Step {}, loss = {:.6f}, training accuracy = {:.6f}, total time = {:.3f}'.format(step, valid_loss, valid_accuracy, time.time() - start))
                if valid_accuracy == 1.0:
                    c_acc += 1
                    if c_acc == 10:
                        saver.save(sess, './Model_Saver04_TrainingDataAugmentation/model_save.ckpt', global_step = c_acc)
                    elif c_acc == 12:
                        saver.save(sess, './Model_Saver04_TrainingDataAugmentation/model_save.ckpt', global_step = c_acc)
                    elif c_acc == 13:
                        saver.save(sess, './Model_Saver04_TrainingDataAugmentation/model_save.ckpt', global_step = c_acc)
                    elif c_acc == 15:
                        saver.save(sess, './Model_Saver04_TrainingDataAugmentation/model_save.ckpt', global_step = c_acc)
                    elif c_acc == 18:
                        saver.save(sess, './Model_Saver04_TrainingDataAugmentation/model_save.ckpt', global_step = c_acc)
                    elif c_acc > 18:
                        break
            step += 1
        coord.request_stop()
        coord.join(threads)

五、模型验证(自行划分的120张图片作为验证集)

#!/bin/python3
import tensorflow as tf
import train_nn_TrainingAugmentation
import train_nn_Training
import train_nn
import Read_Data

IMAGE_SIZE = 256
BATCH_SIZE = 20
#img_valid, img_label = Read_Data.Read_TFRecords('Weed_InputData_Valid_120.tfre*')
img_valid, img_label = Read_Data.Read_TFRecords('Weed_InputData_Valid_Augmentation*')
img_p, label_p = Read_Data.Preprocess(img_valid, img_label, IMAGE_SIZE)
img_valid_batch, img_label_batch = tf.train.batch([img_p, label_p], batch_size = BATCH_SIZE)
keep_prob = tf.placeholder(tf.float32)
#logits = train_nn.Model(img_valid_batch, keep_prob)
#logits = train_nn_Training.Model(img_valid_batch, keep_prob)
logits = train_nn_TrainingAugmentation.Model(img_valid_batch, keep_prob)
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(img_label_batch, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver()
with tf.Session() as sess:
    sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess = sess, coord = coord)
    # BEST Model_Saver06_Final_Augmentation
    saver = tf.train.import_meta_graph('./Model_Saver06_Final_Augmentation/model_save.ckpt-13.meta')
    saver.restore(sess, './Model_Saver06_Final_Augmentation/model_save.ckpt-13')
    #saver = tf.train.import_meta_graph('./Model_Saver05_Final_Augmentation/model_save.ckpt-15.meta')
    #saver.restore(sess, './Model_Saver05_Final_Augmentation/model_save.ckpt-15')
    #saver = tf.train.import_meta_graph('./Model_Saver04_TrainingDataAugmentation/model_save.ckpt-18.meta')
    #saver.restore(sess, './Model_Saver04_TrainingDataAugmentation/model_save.ckpt-18')
    #saver = tf.train.import_meta_graph('./Model_Saver01/model_save.ckpt.meta')
    #saver.restore(sess, './Model_Saver01/model_save.ckpt')
    #saver = tf.train.import_meta_graph('./Model_Saver03_DataAugmentation/model_save.ckpt.meta')
    #saver.restore(sess, './Model_Saver03_DataAugmentation/model_save.ckpt')
    #saver = tf.train.import_meta_graph('./Model_Saver02_Training/model_save.ckpt-15.meta')
    #saver.restore(sess, './Model_Saver02_Training/model_save.ckpt-15')
    A = 0.0
    for i in range(6):
        ans = sess.run(accuracy, feed_dict = {keep_prob: 1.0})
        print(ans)
        A += ans
    print('Mean: ', A / 6)
    coord.request_stop()
    coord.join(threads)

六、模型预测

  • 将测试集图片做成TFRecord
#!/bin/python3
import tensorflow as tf
import os

def _int64_feature(v):
    return tf.train.Feature(int64_list = tf.train.Int64List(value = [v]))

def _bytes_feature(v):
    return tf.train.Feature(bytes_list = tf.train.BytesList(value = [v]))

def Write_TFRecords(path, output):
    img = os.listdir(path)
    img.sort()
    writer = tf.python_io.TFRecordWriter(output)
    for i in range(len(img)):
        print(i, img[i])
        image = tf.gfile.FastGFile(path + img[i], 'rb')
        img_str = image.read()
        height, width, channels = tf.image.decode_png(img_str).eval().shape
        example = tf.train.Example(features = tf.train.Features(feature = \
        {'image': _bytes_feature(img_str), 'img_name': _bytes_feature(bytes(img[i], encoding = 'utf8'))}))
        writer.write(example.SerializeToString())
    writer.close()

if __name__ == '__main__':
    path = '/mnt/windows_E/DeepLearningClass/TestData/'
    output = './Weed_InputData_Final_Test.tfrecords'
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        Write_TFRecords(path, output)
  • 预测，并将结果写入文件
#!/bin/python3
import tensorflow as tf
import train_nn
import train_nn_TrainingAugmentation
import Read_Data

IMAGE_SIZE = 256
BATCH_SIZE = 6
with open('classes.txt') as f:
    con = f.read()
class_ = con.splitlines()
label = {}
for i in range(len(class_)):
    a, b = class_[i].split('#')
    label[int(a)] = b
print(label)
img_test, img_name = Read_Data.Read_Test_TFRecords('Weed_InputData_Final_Test*', IMAGE_SIZE)
img_test_batch, img_name_batch = tf.train.batch([img_test, img_name], batch_size = BATCH_SIZE)
keep_prob = tf.placeholder(tf.float32)
#logits = train_nn_TrainingAugmentation.Model(img_test_batch, keep_prob)
logits = train_nn.Model(img_test_batch, keep_prob)
pred = tf.argmax(tf.nn.softmax(logits), 1)
saver = tf.train.Saver()
with tf.Session() as sess:
    sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess = sess, coord = coord)
    # results04
    saver = tf.train.import_meta_graph('./Model_Saver03_DataAugmentation/model_save.ckpt.meta')
    saver.restore(sess, './Model_Saver03_DataAugmentation/model_save.ckpt')
    # results03
    #saver = tf.train.import_meta_graph('./Model_Saver01/model_save.ckpt.meta')
    #saver.restore(sess, './Model_Saver01/model_save.ckpt')
    # results02
    #saver = tf.train.import_meta_graph('./Model_Saver05_Final_Augmentation/model_save.ckpt-15.meta')
    #saver.restore(sess, './Model_Saver05_Final_Augmentation/model_save.ckpt-15')
    # results01
    #saver = tf.train.import_meta_graph('./Model_Saver06_Final_Augmentation/model_save.ckpt-13.meta')
    #saver.restore(sess, './Model_Saver06_Final_Augmentation/model_save.ckpt-13')
    with open('TestData_results04.csv', 'w') as fw:
        fw.write(',species\n')
        for i in range(79):
            print('----------------------------------------')
            #a = sess.run(img_name_batch)
            ans = sess.run(pred, feed_dict = {keep_prob: 1.0})
            #print(img_name_batch.eval())
            for _ in range(len(ans)):
                fw.write(',' + label[ans[_]] + '\n')
            #print(a)
            # 以下两个eval()每运行一下 就会取出来一个batch
            #print(img_name_batch.eval())
            #print(img_name_batch.eval())
    coord.request_stop()
    coord.join(threads)
御坂10358
关注
  • 0
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
Plant-seedling-classification:使用CNN将植物幼苗分为杂草幼苗和农作物幼苗
05-14
植物苗种分类 域背景 图像分类已成为机器学习和深度学习可以解决的最重要问题之一。 在这个项目中，我将使用kaggle竞赛的数据集之一，该数据集包含大约960种独特植物的图像，这些植物在多个生长阶段属于12个物种。它包含带注释的RGB图像，其物理分辨率约为每毫米10像素。 奥尔胡斯大学信号处理小组工程系已上传此数据集，以使其具有更大的曝光范围，从而为社区提供了尝试不同图像识别技术的机会，并提供了一个可以相互授粉的思想场所。 在南丹麦大学和奥尔胡斯大学的合作下，该数据库已在奥尔胡斯大学Flakkebjerg研究站进行了记录。 您可以在此处找到数据集，该数据集具有1.7 G的训练集（无节段的单株植物），这里的问题是杂草幼苗很像农作物幼苗，我们的目标是能够使用机器学习和深度学习技术来区分它们。 你可以找到项目报告 安装 他的项目需要Python 3.5或更高版本，并安装了以下Python库：
KaggleLeafClassfication:Kaggle竞赛“植物幼苗分类”
04-30
KaggleLeaf分类 Kaggle竞赛“植物幼苗分类”
MPViT实战：植物幼苗分类
最新发布
2401_84584522的博客
04-28 319
test2.py：本文定义数据集==============================================================数据集选用植物幼苗分类，总共12类。数据集连接如下：链接：https://pan.baidu.com/s/1TOLSNj9JE4-MFhU0Yv8TNQ提取码：syng在工程的根目录新建data文件夹，获取数据集后，将trian和test解压放到data文件夹下面，如下图：导入模型文件===================================
经典CNN网络之ResNet 图像分类网络实战项目：34植物叶片图像分类数据集（迁移学习）
04-08
基于resnet101网络对34植物叶片图像分类数据集的迁移学习项目，包含代码、数据集和训练好的权重文件，经过测试，可以直接运行 【网络】resnet101 【数据集】34分类的植物叶片数据集(苹果、葡萄、猕猴桃） 【训练train.py】 1、训练过程中，会对数据集进行随机裁剪、翻转等数据增广等等。 2、网络初始化会自动载入官方在imagenet上的预训练权重进行迁移学习。 3、训练脚本会自动生成数据集类别的 json 文件，并且通过json文件自动设定网络的输出维度，不需要自己定义输出的channel。train.py 训练完成会生成训练集的loss曲线、学习率衰减曲线、测试集的accuracy曲线以及训练日志，保存在run_results文件内。 【预测predict.py】只需要将待预测的图像放在inference文件夹下，代码会自动将该文件下所有的图像进行预测，并在原图像左上角写入最大的前三个类别和概率，无需更改任何代码 【本项目仅仅训练了10个epoch，验证集上准确率为0.998，增大epoch可以提升精度】
【图像分类】实战——使用VGG16实现对植物幼苗的分类（pytroch）
AI浩
06-09 9392
摘要 【图像分类】一文学会VGGNet（pytorch）_AI浩-CSDN博客
ConvNeXt实战：使用ConvNeXt实现植物幼苗分类（自创，非官方）
AI浩
01-15 5989
ConvNeXts 完全由标准 ConvNet 模块构建，在准确性和可扩展性方面与 Transformer 竞争，实现 87.8% ImageNet top-1 准确率，在 COCO 检测和 ADE20K 分割方面优于 Swin Transformers，同时保持标准 ConvNet 的简单性和效率。 论文链接：https://arxiv.org/pdf/2201.03545.pdf 代码链接：https://github.com/facebookresearch/ConvNeXt 如果github不能下载
tensorflow 五种花朵分类识别
05-21
基于Tensorflow 框架编写的花朵识别程序 ，使用了tfrecord 数据读取格式，并且添加了图形可视化操作，可以在训练过程中观测测试集以及验证集的loss值的变化，以及accuracy的变化，并附上单幅图的识别
[Kaggle]Plant Seedlings Classification
yeahDeDiQiZhang的博客
03-13 2545
Kaggle 上的比赛， 识别12种类型的植物，部分图片如下：预处理这里参考Gábor Vecsei的kernel，将叶片从背景中提取出来训练使用keras中的Xception模型，数据增加部分使用了[-180°，180°]的随机旋转，0.3的随机平移，0.3的随机放缩与随机翻转，代码如下：batch_size = 16 train_img = np.zeros([4750, img_size, ...
植物种类分类器：使用CNN进行植物幼苗图像分类
02-08
植物种类分类器 CNN对植物幼苗图像进行分类 内容： 奥尔胡斯大学信号处理小组与南丹麦大学合作，发布了一个数据集，其中包含处于几个生长阶段的属于12种物种的独特植物的图像。 区分杂草和农作物幼苗的能力意味着更好的农作物产量和更好的环境管理。
深度学习图像分类：Kaggle植物幼苗分类（Plant Seedlings Classification）完整代码
RickieLim的博客
03-05 3171
学习并参考了这个链接。 提前准备：anaconda3（Jupyter）；tensorflow；cv2；数据集（官网可以下，点开我给的超链接） 注意：tensorflow要求python是3.5/3.6版本的，已经配置了python3.7/3.8的朋友可以重新下载一个python 3.6，具体操作网上有很多教程可以参考~ 基本思路： 读入图片 & 数据预处理 使用cv2。每个文件夹的名字就...
Tensorflow 使用slim框架下的分类模型进行分类
cugxyy6的博客
10-27 2852
Tensorflow的slim框架可以写出像keras一样简单的代码来实现网络结构（虽然现在keras也已经集成在tf.contrib中了），而且models/slim提供了类似之前说过的object detection接口类似的image classification接口，可以很方便的进行fine-tuning利用自己的数据集训练自己所需的模型。官方文档提供了比较详细的从数据准备，预训练模型的mo
Plant-Detection-Using-TensorFlow:基于叶片结构的植物识别
05-09
植物检测使用张量流 基于叶片结构的植物识别 介绍 在我们生活的任何地方以及没有我们的地方都存在植物。 他们中的许多人为人类社会的发展提供了重要的信息。 人与植物之间的关系也非常密切。 另外，植物是环境和人类生产的重要手段。 令人遗憾的是，人类文明的惊人发展极大地扰乱了这种平衡，而不是人们意识到的。 保护植物免受各种危险是人类最大的职责之一。 因此，应该恢复植物群落的多样性，并使一切恢复平衡。 紧急情况是许多植物面临灭绝的危险。 因此，建立用于植物保护的数据库是非常必要的。我们相信第一步是教计算机如何对植物进行分类。 该教程是针对Windows 10编写的，也将适用于Windows 7和8。该常规过程也可用于Linux操作系统，但是文件路径和软件包安装命令将需要相应地更改。 特别鸣谢：EdjeElectronics，Sentdex 如果在执行此项目时遇到任何问题，请参考下面给出的解决方
Kaggle Plant Seedlings Classification.docx
12-30
【Kaggle Plant Seedlings Classification】比赛是关于图像分类的挑战，目标是区分12种不同的植物种子幼苗。在这个任务中，不依赖深度学习，而是利用特征提取和传统机器学习算法来达到78%的分类准确率。数据集包含...
人工智能-项目实践-植物分类-基于SVM的Plant Seedlings Classification植物分类
05-26
人工智能-项目实践-植物分类-基于SVM的Plant Seedlings Classification植物分类 基于SIFT特征、颜色特征、HOG特征的SVM分类模型，使用的是传统的特征提取和机器学习的方法。未涉及神经网络等深度学习方法 本模型在...
kaggle——销量预测 Top1%
01-21
# 一般一起用才会管用，否则可能会显示混乱 get_ipython().run_line_magic('config', ZMQInteractiveShell.ast_node_interactivity='all') get_ipython().run_line_magic('pprint', '') # In[60]: # cod
Kaggle实战：Plant Seedlings Classification（植物幼苗分类）
playezio的博客
05-25 5806
    2018年初从天池大数据竞赛转战Kaggle，发现在这里有更多有趣的项目，也有更多的大神来分享经验和代码，体会良多。    经过数字识别和泰坦尼克号预测的入门，我实战的第一个比赛是Plant Seedlings Classification（植物幼苗分类），我将从以下几个方面来记录这个比赛。1. 比赛描述2. 评价指标3. 迁移学习4. Keras训练5. 比赛结果------------...
TensorFlow实现kaggle数据集图像分类Ⅰ——tfrecord数据格式掌握
DeepHao'Blog
04-05 770
一、TensorFlow数据集模式 TensorFlow 的数据读取一共有如下三种方式： 名称 解释 供给数据（Feeding） TensorFlow直接将图像喂入网络，最简单的数据喂入格式，占用磁盘内存较高，数据集喂入容易出现瓶颈 官方接口（tf.data API） 是 TensorFlow 推荐的喂入方式，也是 TensorFlow2.x 主打方式 队列输入（tfrec...
深度学习图像分类：植物幼苗图像分类入门(Plant Seedlings Classification)
qq_37355731的博客
07-09 8104
前言：深度考试期末的题目，植物幼苗分类，可以帮助农业领域的进步。 题目介绍：kaggle原题:可以下载数据集，查看一些参与者的思路等。 易用的深度学习框架Keras简介及使用 部分图片如下： 思路： 由于是图像分类问题，tensorflow官网提供了深度学习做图片分类的入门教材都是MNIST或者CIFAR-10的例子。但这里数据都是图片，还是需要自己读入和预处理，采用k...
基于 TensorFlow 的植物识别教程
qq_35827483的博客
02-23 1059
基于 TensorFlow 的植物识别教程
mpvit实战:植物幼苗分类
07-29
MPVIT是一种用于植物幼苗分类的实战技术。植物幼苗分类是指通过对不同植物幼苗的形态特征进行识别和分类。这项技术的应用可以帮助农业科研人员和农民更好地了解植物生长的特点，从而更好地管理植物种植和培育。 MPVIT技术的实施需要先采集一定数量的植物幼苗样本，并通过高清摄像设备拍摄植物幼苗的影像。然后，使用计算机视觉算法对图像进行分析和处理，提取出关键的形态特征，如叶片的大小、形状、颜色等。通过对这些特征进行量化和比较，可以区分不同植物幼苗的种类。 MPVIT技术具有许多优势。首先，它可以提高植物幼苗分类的准确性和效率。相比传统的人工鉴定方法，这项技术可以节省大量的时间和人力成本。其次，它可以对大量的样本进行自动化处理，并生成准确的分类结果。此外，MPVIT技术还能够识别难以区分的植物幼苗，有助于鉴别和管理种植中的杂草，提高农作物的产量和质量。 总而言之，MPVIT是一种用于植物幼苗分类的实战技术，它通过对植物幼苗形态特征的分析和比较，可以准确地识别和分类不同的幼苗。这项技术的应用有助于农业科研人员和农民更好地了解和管理植物种植，从而提高农作物的产量和质量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值