使用自己的資料集訓練MobileNet、ResNet實現影象分類（TensorFlow）
使用自己的資料集訓練MobileNet、ResNet實現影象分類（TensorFlow）
之前鄙人寫了一篇部落格《使用自己的資料集訓練GoogLenet InceptionNet V1 V2 V3模型（TensorFlow）》https://panjinquan.blog.csdn.net/article/details/81560537，本部落格就是此部落格的框架基礎上，完成對MobileNet的影象分類模型的訓練，其相關專案的程式碼也會統一更新到一個Github中，強烈建議先看這篇部落格《使用自己的資料集訓練GoogLenet InceptionNet V1 V2 V3模型（TensorFlow）》後，再來看這篇部落格。
TensorFlow官網中使用高階API -slim實現了很多常用的模型，如VGG，GoogLenet V1、V2和V3以及MobileNet、resnet模型：可詳看這裡https://github.com/tensorflow/models/tree/master/research/slim，當然TensorFlow官網也提供了訓練這些模型的指令碼檔案，但靈活性太差了，要想增加log或者其他資訊，真的很麻煩。本人花了很多時間，去搭建一個較為通用的模型訓練框架《tensorflow_models_nets》，目前幾乎可以支援所有模型的訓練，由於訓練過程是自己構建的，所以你可以在此基礎上進行任意的修改，也可以搭建自己的訓練模型。
重要說明：
（1）專案Github原始碼：https://github.com/PanJinquan/tensorflow_models_nets，麻煩給個“Star”
（2）你需要一臺顯示卡不錯的伺服器，不然會卡的一比，慢到花都謝了
（2）對於MobileNet、resnet等大型的網路模型，重頭開始訓練，是很難收斂的。但遷移學習finetune部分我還沒有實現，大神要是現實了，分享一下哈。
（3）注意訓練mobilenet時，在迭代10000次以前，loss和準確率幾乎不會提高。一開始我以為是訓練程式碼寫錯了，後來尋思了很久，才發現是模型太複雜了，所以收斂慢的一比，大概20000次迭代後，準確率才開始蹭蹭的往上長,迭代十萬次後準確率才70%，
目錄
使用自己的資料集訓練MobileNet影象識別（TensorFlow）
1、專案檔案結構說明
tensorflow_models_nets：
|__dataset #資料檔案
|__record #裡面存放record檔案
|__train #train原始圖片
|__val #val原始圖片
|__models #儲存訓練的模型
|__slim #這個是拷貝自slim模組：https://github.com/tensorflow/models/tree/master/research/slim
|__test_image #存放測試的圖片
|__create_labels_files.py #製作trian和val TXT的檔案
|__create_tf_record.py #製作tfrecord檔案
|__inception_v1_train_val.py #inception V1的訓練檔案
|__inception_v3_train_val.py # inception V3訓練檔案
|__mobilenet_train_val.py#mobilenet訓練檔案
|__resnet_v1_train_val.py#resnet訓練檔案
|__predict.py # 模型預測檔案
2、MobileNet的網路：
關於MobileNet模型，請詳看這篇部落格《輕量級網路--MobileNet論文解讀》https://blog.csdn.net/u011974639/article/details/79199306 ，本部落格不會糾結於模型原理和論文，主要分享的是用自己的資料集去訓練MobileNet的方法。
3、圖片資料集
下面是我下載的資料集，共有五類圖片，分別是：flower、guitar、animal、houses和plane，每組資料集大概有800張左右。為了照顧網友，下面的資料集，都已經放在Github專案的資料夾dataset上了，不需要你下載了，記得給個“star”哈
animal：http://www.robots.ox.ac.uk/~vgg/data/pets/
flower：http://www.robots.ox.ac.uk/~vgg/data/flowers/
plane：http://www.robots.ox.ac.uk/~vgg/data/airplanes_side/airplanes_side.tar
house：http://www.robots.ox.ac.uk/~vgg/data/houses/houses.tar
guitar：http://www.robots.ox.ac.uk/~vgg/data/guitars/guitars.tar
下載圖片資料集後，需要劃分為train和val資料集，前者用於訓練模型的資料，後者主要用於驗證模型。這裡提供一個create_labels_files.py指令碼，可以直接生成訓練train和驗證val的資料集txt檔案。
#-*-coding:utf-8-*-
"""
@Project: googlenet_classification
@File : create_labels_files.py
@Author : panjq
@E-mail : pan_jinquan@163.com
@Date : 2018-08-11 10:15:28
"""
import os
import os.path
def write_txt(content, filename, mode='w'):
"""儲存txt資料
:param content:需要儲存的資料,type->list
:param filename:檔名
:param mode:讀寫模式:'w' or 'a'
:return: void
"""
with open(filename, mode) as f:
for line in content:
str_line = ""
for col, data in enumerate(line):
if not col == len(line) - 1:
# 以空格作為分隔符
str_line = str_line + str(data) + " "
else:
# 每行最後一個資料用換行符“\n”
str_line = str_line + str(data) + "\n"
f.write(str_line)
def get_files_list(dir):
'''
實現遍歷dir目錄下,所有檔案(包含子資料夾的檔案)
:param dir:指定資料夾目錄
:return:包含所有檔案的列表->list
'''
# parent:父目錄, filenames:該目錄下所有資料夾,filenames:該目錄下的檔名
files_list = []
for parent, dirnames, filenames in os.walk(dir):
for filename in filenames:
# print("parent is: " + parent)
# print("filename is: " + filename)
# print(os.path.join(parent, filename)) # 輸出rootdir路徑下所有檔案（包含子檔案）資訊
curr_file=parent.split(os.sep)[-1]
if curr_file=='flower':
labels=0
elif curr_file=='guitar':
labels=1
elif curr_file=='animal':
labels=2
elif curr_file=='houses':
labels=3
elif curr_file=='plane':
labels=4
files_list.append([os.path.join(curr_file, filename),labels])
return files_list
if __name__ == '__main__':
train_dir = 'dataset/train'
train_txt='dataset/train.txt'
train_data = get_files_list(train_dir)
write_txt(train_data,train_txt,mode='w')
val_dir = 'dataset/val'
val_txt='dataset/val.txt'
val_data = get_files_list(val_dir)
write_txt(val_data,val_txt,mode='w')
注意，上面Python程式碼，已經定義每組圖片對應的標籤labels：
flower ->labels=0
guitar ->labels=1
animal ->labels=2
houses ->labels=3
plane ->labels=4
4、製作tfrecords資料格式
有了 train.txt和val.txt資料集，我們就可以製作train.tfrecords和val.tfrecords檔案了，專案提供一個用於製作tfrecords資料格式的Python檔案：create_tf_record.py，鄙人已經把程式碼放在另一篇部落格：《Tensorflow生成自己的圖片資料集TFrecords》https://blog.csdn.net/guyuealian/article/details/80857228 ，程式碼有詳細註釋了，所以這裡不貼出來了.
注意：
（1）create_tf_record.py將train和val資料分別儲存為單個record檔案，當圖片資料很多時候，會導致單個record檔案超級巨大的情況，解決方法就是，將資料分成多個record檔案儲存，讀取時，只需要將多個record檔案的路徑列表交給“tf.train.string_input_producer”即可。
（2）如何將資料儲存為多個record檔案呢？請參考鄙人的部落格：《Tensorflow生成自己的圖片資料集TFrecords》https://blog.csdn.net/guyuealian/article/details/80857228
為了方便大家，專案以及適配了“create_tf_record.py”檔案，dataset已經包含了訓練和測試的圖片，請直接執行create_tf_record.py即可生成tfrecords檔案。
對於InceptionNet V1:設定resize_height和resize_width = 224
對於InceptionNet V3:設定resize_height和resize_width = 299
其他模型，請根據輸入需要設定resize_height和resize_width的大小
if __name__ == '__main__':
# 引數設定
resize_height = 224 # 指定儲存圖片高度
resize_width = 224 # 指定儲存圖片寬度
shuffle=True
log=5
# 產生train.record檔案
image_dir='dataset/train'
train_labels = 'dataset/train.txt' # 圖片路徑
train_record_output = 'dataset/record/train{}.tfrecords'.format(resize_height)
create_records(image_dir,train_labels, train_record_output, resize_height, resize_width,shuffle,log)
train_nums=get_example_nums(train_record_output)
print("save train example nums={}".format(train_nums))
# 產生val.record檔案
image_dir='dataset/val'
val_labels = 'dataset/val.txt' # 圖片路徑
val_record_output = 'dataset/record/val{}.tfrecords'.format(resize_height)
create_records(image_dir,val_labels, val_record_output, resize_height, resize_width,shuffle,log)
val_nums=get_example_nums(val_record_output)
print("save val example nums={}".format(val_nums))
# 測試顯示函式
# disp_records(train_record_output,resize_height, resize_width)
batch_test(train_record_output,resize_height, resize_width)
create_tf_record.py提供幾個重要的函式：
- create_records()：用於製作records資料的函式，
- read_records()：用於讀取records資料的函式,
- get_batch_images():用於生成批訓練資料的函式
- get_example_nums：統計tf_records影象的個數(example個數)
- disp_records(): 解析record檔案，並顯示圖片，主要用於驗證生成record檔案是否成功
5、MobileNet模型
官網TensorFlow已經提供了使用TF-slim實現的MobileNet模型。
1、官網模型地址：https://github.com/tensorflow/models/tree/master/research/slim/nets
2、slim/nets下的模型都是用TF-slim實現的網路結構，關係TF-slim的用法，可參考：
《tensorflow中slim模組api介紹》：https://blog.csdn.net/guvcolie/article/details/77686555
6、訓練方法實現過程
訓練檔案原始碼已經給了較為詳細的註釋，不明白請在評論區留言吧
#coding=utf-8
import tensorflow as tf
import numpy as np
import pdb
import os
from datetime import datetime
import slim.nets.mobilenet_v1 as mobilenet_v1
from create_tf_record import *
import tensorflow.contrib.slim as slim
'''
參考資料：https://www.cnblogs.com/adong7639/p/7942384.html
'''
labels_nums = 5 # 類別個數
batch_size = 16 #
resize_height = 224 # mobilenet_v1.default_image_size 指定儲存圖片高度
resize_width = 224 # mobilenet_v1.default_image_size 指定儲存圖片寬度
depths = 3
data_shape = [batch_size, resize_height, resize_width, depths]
# 定義input_images為圖片資料
input_images = tf.placeholder(dtype=tf.float32, shape=[None, resize_height, resize_width, depths], name='input')
# 定義input_labels為labels資料
# input_labels = tf.placeholder(dtype=tf.int32, shape=[None], name='label')
input_labels = tf.placeholder(dtype=tf.int32, shape=[None, labels_nums], name='label')
# 定義dropout的概率
keep_prob = tf.placeholder(tf.float32,name='keep_prob')
is_training = tf.placeholder(tf.bool, name='is_training')
def net_evaluation(sess,loss,accuracy,val_images_batch,val_labels_batch,val_nums):
val_max_steps = int(val_nums / batch_size)
val_losses = []
val_accs = []
for _ in range(val_max_steps):
val_x, val_y = sess.run([val_images_batch, val_labels_batch])
# print('labels:',val_y)
# val_loss = sess.run(loss, feed_dict={x: val_x, y: val_y, keep_prob: 1.0})
# val_acc = sess.run(accuracy,feed_dict={x: val_x, y: val_y, keep_prob: 1.0})
val_loss,val_acc = sess.run([loss,accuracy], feed_dict={input_images: val_x, input_labels: val_y, keep_prob:1.0, is_training: False})
val_losses.append(val_loss)
val_accs.append(val_acc)
mean_loss = np.array(val_losses, dtype=np.float32).mean()
mean_acc = np.array(val_accs, dtype=np.float32).mean()
return mean_loss, mean_acc
def step_train(train_op,loss,accuracy,
train_images_batch,train_labels_batch,train_nums,train_log_step,
val_images_batch,val_labels_batch,val_nums,val_log_step,
snapshot_prefix,snapshot):
'''
迴圈迭代訓練過程
:param train_op: 訓練op
:param loss: loss函式
:param accuracy: 準確率函式
:param train_images_batch: 訓練images資料
:param train_labels_batch: 訓練labels資料
:param train_nums: 總訓練資料
:param train_log_step: 訓練log顯示間隔
:param val_images_batch: 驗證images資料
:param val_labels_batch: 驗證labels資料
:param val_nums: 總驗證資料
:param val_log_step: 驗證log顯示間隔
:param snapshot_prefix: 模型儲存的路徑
:param snapshot: 模型儲存間隔
:return: None
'''
saver = tf.train.Saver(max_to_keep=5)
max_acc = 0.0
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for i in range(max_steps + 1):
batch_input_images, batch_input_labels = sess.run([train_images_batch, train_labels_batch])
_, train_loss = sess.run([train_op, loss], feed_dict={input_images: batch_input_images,
input_labels: batch_input_labels,
keep_prob: 0.8, is_training: True})
# train測試(這裡僅測試訓練集的一個batch)
if i % train_log_step == 0:
train_acc = sess.run(accuracy, feed_dict={input_images: batch_input_images,
input_labels: batch_input_labels,
keep_prob: 1.0, is_training: False})
print("%s: Step [%d] train Loss : %f, training accuracy : %g" % (
datetime.now(), i, train_loss, train_acc))
# val測試(測試全部val資料)
if i % val_log_step == 0:
mean_loss, mean_acc = net_evaluation(sess, loss, accuracy, val_images_batch, val_labels_batch, val_nums)
print("%s: Step [%d] val Loss : %f, val accuracy : %g" % (datetime.now(), i, mean_loss, mean_acc))
# 模型儲存:每迭代snapshot次或者最後一次儲存模型
if (i % snapshot == 0 and i > 0) or i == max_steps:
print('-----save:{}-{}'.format(snapshot_prefix, i))
saver.save(sess, snapshot_prefix, global_step=i)
# 儲存val準確率最高的模型
if mean_acc > max_acc and mean_acc > 0.7:
max_acc = mean_acc
path = os.path.dirname(snapshot_prefix)
best_models = os.path.join(path, 'best_models_{}_{:.4f}.ckpt'.format(i, max_acc))
print('------save:{}'.format(best_models))
saver.save(sess, best_models)
coord.request_stop()
coord.join(threads)
def train(train_record_file,
train_log_step,
train_param,
val_record_file,
val_log_step,
labels_nums,
data_shape,
snapshot,
snapshot_prefix):
'''
:param train_record_file: 訓練的tfrecord檔案
:param train_log_step: 顯示訓練過程log資訊間隔
:param train_param: train引數
:param val_record_file: 驗證的tfrecord檔案
:param val_log_step: 顯示驗證過程log資訊間隔
:param val_param: val引數
:param labels_nums: labels數
:param data_shape: 輸入資料shape
:param snapshot: 儲存模型間隔
:param snapshot_prefix: 儲存模型檔案的字首名
:return:
'''
[base_lr,max_steps]=train_param
[batch_size,resize_height,resize_width,depths]=data_shape
# 獲得訓練和測試的樣本數
train_nums=get_example_nums(train_record_file)
val_nums=get_example_nums(val_record_file)
print('train nums:%d,val nums:%d'%(train_nums,val_nums))
# 從record中讀取圖片和labels資料
# train資料,訓練資料一般要求打亂順序shuffle=True
train_images, train_labels = read_records(train_record_file, resize_height, resize_width, type='normalization')
train_images_batch, train_labels_batch = get_batch_images(train_images, train_labels,
batch_size=batch_size, labels_nums=labels_nums,
one_hot=True, shuffle=True)
# val資料,驗證資料可以不需要打亂資料
val_images, val_labels = read_records(val_record_file, resize_height, resize_width, type='normalization')
val_images_batch, val_labels_batch = get_batch_images(val_images, val_labels,
batch_size=batch_size, labels_nums=labels_nums,
one_hot=True, shuffle=False)
# Define the model:
with slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope()):
out, end_points = mobilenet_v1.mobilenet_v1(inputs=input_images, num_classes=labels_nums,
dropout_keep_prob=keep_prob, is_training=is_training,
global_pool=True)
# Specify the loss function: tf.losses定義的loss函式都會自動新增到loss函式,不需要add_loss()了
tf.losses.softmax_cross_entropy(onehot_labels=input_labels, logits=out) # 新增交叉熵損失loss=1.6
# slim.losses.add_loss(my_loss)
loss = tf.losses.get_total_loss(add_regularization_losses=True) # 新增正則化損失loss=2.2
# Specify the optimization scheme:
# 在定義訓練的時候, 注意到我們使用了`batch_norm`層時,需要更新每一層的`average`和`variance`引數,
# 更新的過程不包含在正常的訓練過程中, 需要我們去手動像下面這樣更新
# 通過`tf.get_collection`獲得所有需要更新的`op`
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
# 使用`tensorflow`的控制流, 先執行更新運算元, 再執行訓練
with tf.control_dependencies(update_ops):
print("update_ops:{}".format(update_ops))
# create_train_op that ensures that when we evaluate it to get the loss,
# the update_ops are done and the gradient updates are computed.
# train_op = tf.train.MomentumOptimizer(learning_rate=base_lr, momentum=0.9).minimize(loss)
train_op = tf.train.AdadeltaOptimizer(learning_rate=base_lr).minimize(loss)
accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(out, 1), tf.argmax(input_labels, 1)), tf.float32))
# 迴圈迭代過程
step_train(train_op=train_op, loss=loss, accuracy=accuracy,
train_images_batch=train_images_batch,
train_labels_batch=train_labels_batch,
train_nums=train_nums,
train_log_step=train_log_step,
val_images_batch=val_images_batch,
val_labels_batch=val_labels_batch,
val_nums=val_nums,
val_log_step=val_log_step,
snapshot_prefix=snapshot_prefix,
snapshot=snapshot)
if __name__ == '__main__':
train_record_file='dataset/record/train224.tfrecords'
val_record_file='dataset/record/val224.tfrecords'
train_log_step=100
base_lr = 0.001 # 學習率
# 重頭開始訓練的話，mobilenet收斂慢的一比，大概20000次迭代後，準確率開始蹭蹭的往上長,迭代十萬次後準確率才70%
max_steps = 100000 # 迭代次數
train_param=[base_lr,max_steps]
val_log_step=500
snapshot=2000#儲存檔案間隔
snapshot_prefix='models/model.ckpt'
train(train_record_file=train_record_file,
train_log_step=train_log_step,
train_param=train_param,
val_record_file=val_record_file,
val_log_step=val_log_step,
labels_nums=labels_nums,
data_shape=data_shape,
snapshot=snapshot,
snapshot_prefix=snapshot_prefix)
7、模型預測
模型預測，專案只提供一個predict.py，實質上，你只需要稍微改改，就可以預測其他模型
#coding=utf-8
import tensorflow as tf
import numpy as np
import pdb
import cv2
import os
import glob
import slim.nets.inception_v3 as inception_v3
from create_tf_record import *
import tensorflow.contrib.slim as slim
def predict(models_path,image_dir,labels_filename,labels_nums, data_format):
[batch_size, resize_height, resize_width, depths] = data_format
labels = np.loadtxt(labels_filename, str, delimiter='\t')
input_images = tf.placeholder(dtype=tf.float32, shape=[None, resize_height, resize_width, depths], name='input')
#其他模型預測請修改這裡
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
out, end_points = inception_v3.inception_v3(inputs=input_images, num_classes=labels_nums, dropout_keep_prob=1.0, is_training=False)
# 將輸出結果進行softmax分佈,再求最大概率所屬類別
score = tf.nn.softmax(out,name='pre')
class_id = tf.argmax(score, 1)
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, models_path)
images_list=glob.glob(os.path.join(image_dir,'*.jpg'))
for image_path in images_list:
im=read_image(image_path,resize_height,resize_width,normalization=True)
im=im[np.newaxis,:]
#pred = sess.run(f_cls, feed_dict={x:im, keep_prob:1.0})
pre_score,pre_label = sess.run([score,class_id], feed_dict={input_images:im})
max_score=pre_score[0,pre_label]
print("{} is: pre labels:{},name:{} score: {}".format(image_path,pre_label,labels[pre_label], max_score))
sess.close()
if __name__ == '__main__':
class_nums=5
image_dir='test_image'
labels_filename='dataset/label.txt'
models_path='models/model.ckpt-10000'
batch_size = 1 #
resize_height = 299 # 指定儲存圖片高度
resize_width = 299 # 指定儲存圖片寬度
depths=3
data_format=[batch_size,resize_height,resize_width,depths]
predict(models_path,image_dir, labels_filename, class_nums, data_format)
8、其他模型訓練方法
上面的程式是訓練MobileNet的完整過程，實質上，稍微改改就可以支援訓練 inception V1，V2和resnet 啦，改動方法也很簡單，以 MobileNe訓練程式碼改為resnet_v1模型為例：
（1）import 改為：
# 將
import slim.nets.mobilenet_v1 as mobilenet_v1
# 改為
import slim.nets.resnet_v1 as resnet_v1
（2）record資料
製作record資料時，需要根據模型輸入設定：
resize_height = 224 # 指定儲存圖片高度
resize_width = 224 # 指定儲存圖片寬度
（3）定義模型和預設引數修改：
# 將
# Define the model:
with slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope()):
out, end_points = mobilenet_v1.mobilenet_v1(inputs=input_images, num_classes=labels_nums,
dropout_keep_prob=keep_prob, is_training=is_training,
global_pool=True)
# 改為
# Define the model:
with slim.arg_scope(resnet_v1.resnet_arg_scope()):
out, end_points = resnet_v1.resnet_v1_101(inputs=input_images, num_classes=labels_nums, is_training=is_training,global_pool=True)
（4）修改優化方案
對於大型的網路模型，重頭開始訓練，是很難收斂的。訓練mobilenet時，在迭代10000次以前，loss和準確率幾乎不會提高。一開始我以為是訓練程式碼寫錯了，後來尋思了很久，才發現是模型太複雜了，所以收斂慢的一比，大概20000次迭代後，準確率才開始蹭蹭的往上長,迭代十萬次後準確率才70%，若訓練過程發現不收斂，請嘗試修改：
1、等！！！！至少你要迭代50000次，才能說你的模型不收斂！
2、增大或減小學習率引數：base_lr（個人經驗：模型越深越複雜時，學習率越小）
3、改變優化方案：如使用MomentumOptimizer或者AdadeltaOptimizer等優化方法
4、是否有設定預設的模型引數：如slim.arg_scope(inception_v1.inception_v1_arg_scope())
……最後，就可以Train了！是的，就是那麼簡單~
相關文章
- 使用TensorFlow slim資料夾當中的inception_resnet_v2網路訓練自己的分類資料集
- 基於pytorch實現Resnet對本地資料集的訓練PyTorch
- 搭建 MobileNet-SSD 開發環境並使用 VOC 資料集訓練 TensorFlow 模型開發環境模型
- 使用PaddleFluid和TensorFlow實現影象分類網路SE_ResNeXtUI
- Windows10 使用 Tensorflow Object_detection API 訓練自己的資料WindowsObjectAPI
- Mxnet R FCN 訓練自己的資料集
- ResNet50的貓狗分類訓練及預測
- keras-retinanet 用自己的資料集訓練KerasNaN
- 用SSD-Pytorch訓練自己的資料集PyTorch
- Mxnet-R-FCN-訓練自己的資料集
- Tensorflow 1.x 影象分類
- 谷歌colab訓練自己的資料集YOLOv3谷歌YOLO
- Caffe-SSD-Ubuntu16-04-訓練自己的資料集Ubuntu
- Caffe SSD Ubuntu16 04 訓練自己的資料集Ubuntu
- 【CANN訓練營第三季】基於Caffe ResNet-50網路實現圖片分類
- 資料集訓練
- tensorflow2.0在訓練資料集的時候，fit和fit_generator的使用
- 訓練自己的Android TensorFlow神經網路Android神經網路
- DeepLab 使用 Cityscapes 資料集訓練模型模型
- TensorFlow 呼叫預訓練好的模型—— Python 實現模型Python
- 輕鬆學Pytorch-使用ResNet50實現影像分類PyTorch
- Yolov3程式碼分析與訓練自己資料集YOLO
- 資料集訓練+1
- fashion資料集訓練
- 看照片挑民宿：Airbnb如何重新訓練ResNet50，實現房間圖片分類最佳化AI
- 全網最細 | 教你如何在 docker 容器下使用 mmdetection 訓練自己的資料集Docker
- Alink漫談(七) : 如何劃分訓練資料集和測試資料集
- yolov3訓練自己資料教程YOLO
- nnUNet使用指南（一）：Ubuntu系統下使用nnUNet對自己的多模態MR資料集訓練Ubuntu
- MXNet的資料格式轉化為tensorflow訓練用的資料格式
- 使用 diffusers 訓練你自己的 ControlNet ?
- 使用Pytorch訓練分類器詳解（附python演練）PyTorchPython
- ImageAI實現完整的流程：資料集構建、模型訓練、識別預測AI模型
- 劃分訓練集與測試集
- 用PyTorch版本R-FCN訓練自己的資料PyTorch
- 使用PaddleFluid和TensorFlow實現影像分類網路SE_ResNeXtUI
- 一文讀懂物體分類AI演算法：LeNet-5 AlexNet VGG Inception ResNet MobileNetAI演算法
- 如何改善你的訓練資料集？（附案例）