当前位置：网站首页>Train your own classification [Bao Jiaobao, the data are ready]

Train your own classification [Bao Jiaobao, the data are ready]

2022-07-28 09:05:00 【51CTO】

WeChat official account ：AI Algorithm and image processing

Preface ：

When looking for a job , You are often asked if you have done any projects , I answered that I had run through handwritten numeral recognition , Then he was laughed ...

Indeed, this is relative to the programming hello world

therefore , Today I'll show you how to build your own classifier , It's not that hard

And the industrial application of classifier is very wide , For example, product defect detection （ Detect different defect types ） etc. .

1、 Prepare the data

Picture data of flowers ：http://download.tensorflow.org/example_images/flower_photos.tgz

（ competent , You can go online to crawl other pictures ）

Train one's own classification | 【 Bao Jiao Bao Association , The data are all ready 】_2d

2、 Understand the network structure DenseNet

DenseNet It is a convolutional neural network with dense connections . In this network , There is a direct connection between any two layers , in other words , The input of each layer of the network is the union of the outputs of all previous layers , And the feature map learned by this layer will also be directly transmitted to all the following layers as input . The picture below is DenseNet A schematic diagram of .

Train one's own classification | 【 Bao Jiao Bao Association , The data are all ready 】_ data _02

This is a very cowhide network structure , get CVPR 2017 Best paper .

advantage ：

The relief gradient disappears

Strengthen feature transmission

High feature utilization

Reduce the number of parameters

Thesis link ：https://arxiv.org/pdf/1608.06993.pdf

3、 Code implementation

Environmental Science ：python3.6、tensorflow-gpu 1.5.0、keras2.2.4

The following notes are very detailed , I am not much. bb 了 . For those who don't understand the code, please refer to tensorflow Official course ：https://tensorflow.google.cn/tutorials/

       
       ''
       
       '
       
        Changes needed ：
       
       1
       
       、 Modify the path of training set and verification set （ Here I use the absolute path ）, Models and log The path to save 
       
       2
       
       、 Change according to your own needs batch_size,
       
       epoch,
       
        Learning rate, etc 
       
       ''
       
       '
       
# 
       
       --
       
       coding:
       
       utf
       
       -
       
       8
       
       --
       
       import 
       
       os
       
       import 
       
       sys
       
       import 
       
       glob
       
       import 
       
       matplotlib.
       
       pyplot 
       
       as 
       
       plt
       
       from 
       
       keras 
       
       import 
       
       __version__
       
       from 
       
       keras.
       
       applications.
       
       densenet 
       
       import 
       
       DenseNet201, 
       
       preprocess_input
       
       from 
       
       keras.
       
       models 
       
       import 
       
       Model
       
       from 
       
       keras.
       
       layers 
       
       import 
       
       Dense, 
       
       GlobalAveragePooling2D
       
       from 
       
       keras.
       
       preprocessing.
       
       image 
       
       import 
       
       ImageDataGenerator
       
       from 
       
       keras.
       
       optimizers 
       
       import 
       
       SGD
       
       from 
       
       keras.
       
       callbacks 
       
       import 
       
       ModelCheckpoint, 
       
       TensorBoard
       
# 
       
       os.
       
       environ[
       
       “CUDA_VISIBLE_DEVICES”]
       
       =
       
       “0”
       
       def 
       
       get_nb_files(
       
       directory):
       
       ""
       
       "Get number of files by searching directory recursively"
       
       ""
       
       if 
       
       not 
       
       os.
       
       path.
       
       exists(
       
       directory):
       
       return 
       
       0
       
       cnt 
       
       = 
       
       0
       
       for 
       
       r, 
       
       dirs, 
       
       files 
       
       in 
       
       os.
       
       walk(
       
       directory):
       
       for 
       
       dr 
       
       in 
       
       dirs:
       
       cnt 
       
       += 
       
       len(
       
       glob.
       
       glob(
       
       os.
       
       path.
       
       join(
       
       r, 
       
       dr 
       
       + 
       
       "/*")))
       
       return 
       
       cnt
       
# 
       
        Data preparation 
       
       IM_WIDTH, 
       
       IM_HEIGHT 
       
       = 
       
       224, 
       
       224  # 
       
       densenet Specified picture size 
       
# 
       
       FC_SIZE 
       
       = 
       
       1024                # 
       
        Number of nodes in the full connection layer 
       
# 
       
       NB_IV3_LAYERS_TO_FREEZE 
       
       = 
       
       172  # 
       
        Number of frozen layers 
       
       train_dir 
       
       = 
       
       '/media/pzw/0E50196C0E50196C/job/triode1/train'  # 
       
        Training set data 
       
       val_dir 
       
       = 
       
       '/media/pzw/0E50196C0E50196C/job/triode1/validate'  # 
       
        Validation set data 
       
       nb_classes 
       
       = 
       
       5
       
       nb_epoch 
       
       = 
       
       5
       
       batch_size 
       
       = 
       
       8
       
       nb_train_samples 
       
       = 
       
       get_nb_files(
       
       train_dir)  # 
       
        Number of training samples 
       
       nb_classes 
       
       = 
       
       len(
       
       glob.
       
       glob(
       
       train_dir 
       
       + 
       
       "/*"))  # 
       
        Number of categories 
       
       nb_val_samples 
       
       = 
       
       get_nb_files(
       
       val_dir)  # 
       
        Number of validation set samples 
       
       nb_epoch 
       
       = 
       
       int(
       
       nb_epoch)  # 
       
       epoch Number 
       
       batch_size 
       
       = 
       
       int(
       
       batch_size)
       
# 　
       
        Image generator 
       
       train_datagen 
       
       = 
       
       ImageDataGenerator(
       
       preprocessing_function
       
       =
       
       preprocess_input,
       
       rotation_range
       
       =
       
       5,
       
       width_shift_range
       
       =
       
       0.02,
       
       height_shift_range
       
       =
       
       0.02,
       
       shear_range
       
       =
       
       0.02,
       
       zoom_range
       
       =
       
       0.02,
       
       horizontal_flip
       
       =
       
       True
       
)
       
       test_datagen 
       
       = 
       
       ImageDataGenerator(
       
       preprocessing_function
       
       =
       
       preprocess_input,
       
       rotation_range
       
       =
       
       5,
       
       width_shift_range
       
       =
       
       0.02,
       
       height_shift_range
       
       =
       
       0.02,
       
       shear_range
       
       =
       
       0.02,
       
       zoom_range
       
       =
       
       0.02,
       
       horizontal_flip
       
       =
       
       True
       
)
       
# 
       
        Training data and test data 
       
       train_generator 
       
       = 
       
       train_datagen.
       
       flow_from_directory(
       
       train_dir,
       
       target_size
       
       =(
       
       IM_WIDTH, 
       
       IM_HEIGHT),
       
       batch_size
       
       =
       
       batch_size, 
       
       class_mode
       
       =
       
       'categorical')
       
       validation_generator 
       
       = 
       
       test_datagen.
       
       flow_from_directory(
       
       val_dir,
       
       target_size
       
       =(
       
       IM_WIDTH, 
       
       IM_HEIGHT),
       
       batch_size
       
       =
       
       batch_size, 
       
       class_mode
       
       =
       
       'categorical')
       
# 
       
        Add new layer 
       
       def 
       
       add_new_last_layer(
       
       base_model, 
       
       nb_classes):
       
       ""
       
       "
       
        Add the last layer 
       
        Input 
       
       base_model And classification quantity 
       
        Output 
       
        new keras Of model
       
       ""
       
       "
       
       x 
       
       = 
       
       base_model.
       
       output
       
       x 
       
       = 
       
       GlobalAveragePooling2D()(
       
       x)
       
    # 
       
       x 
       
       = 
       
       Dense(
       
       FC_SIZE, 
       
       activation
       
       =
       
       'relu')(
       
       x) 
       
       #new 
       
       FC 
       
       layer, 
       
       random 
       
       init
       
       predictions 
       
       = 
       
       Dense(
       
       nb_classes, 
       
       activation
       
       =
       
       'softmax')(
       
       x)  # 
       
       new 
       
       softmax 
       
       layer
       
       model 
       
       = 
       
       Model(
       
       input
       
       =
       
       base_model.
       
       input, 
       
       output
       
       =
       
       predictions)
       
       return 
       
       model
       
# 
       
        Build a model 
       
       model 
       
       = 
       
       DenseNet201(
       
       include_top
       
       =
       
       False)
       
       model 
       
       = 
       
       add_new_last_layer(
       
       model, 
       
       nb_classes)
       
# 
       
        When the next training wants to start from the starting point of the previous model , You can uncomment the following one 
       
# 
       
       model.
       
       load_weights(
       
       'model/checkpoint-02e-val_acc_0.82.hdf5')
       
       model.
       
       compile(
       
       optimizer
       
       =
       
       SGD(
       
       lr
       
       =
       
       0.001, 
       
       momentum
       
       =
       
       0.9, 
       
       decay
       
       =
       
       0.0001, 
       
       nesterov
       
       =
       
       True), 
       
       loss
       
       =
       
       'categorical_crossentropy',
       
       metrics
       
       =[
       
       'accuracy'])
       
# 
       
        Better save the model  
       
       Save 
       
       the 
       
       model 
       
       after 
       
       every 
       
       epoch.
       
       output_model_file 
       
       = 
       
       '/media/pzw/0E50196C0E50196C/job/triode1/denseNet/model/checkpoint-{epoch:02d}e-val_acc_{val_acc:.2f}.hdf5'
       
# 
       
       keras.
       
       callbacks.
       
       ModelCheckpoint(
       
       filepath, 
       
       monitor
       
       =
       
       'val_loss', 
       
       verbose
       
       =
       
       0, 
       
       save_best_only
       
       =
       
       False, 
       
       save_weights_only
       
       =
       
       False, 
       
       mode
       
       =
       
       'auto', 
       
       period
       
       =
       
       1)
       
       checkpoint 
       
       = 
       
       ModelCheckpoint(
       
       output_model_file, 
       
       monitor
       
       =
       
       'val_acc', 
       
       verbose
       
       =
       
       1, 
       
       save_best_only
       
       =
       
       True)
       
# 
       
       tensorboard visualization 
       
       RUN 
       
       = 
       
       RUN 
       
       + 
       
       1 
       
       if 
       
       'RUN' 
       
       in 
       
       locals() 
       
       else 
       
       1  # 
       
       locals() 
       
        The function returns all local variables in the current position as dictionary type .
       
       LOG_DIR 
       
       = 
       
       '/media/pzw/0E50196C0E50196C/job/triode1/denseNet/training_logs/run{}'.
       
       format(
       
       RUN)
       
       tensorboard 
       
       = 
       
       TensorBoard(
       
       log_dir
       
       =
       
       LOG_DIR, 
       
       write_images
       
       =
       
       True)
       
# 
       
        Start training 
       
       history_ft 
       
       = 
       
       model.
       
       fit_generator(
       
       train_generator,
       
       samples_per_epoch
       
       =
       
       nb_train_samples,
       
       nb_epoch
       
       =
       
       nb_epoch,
       
       callbacks
       
       =[
       
       tensorboard, 
       
       checkpoint],
       
       validation_data
       
       =
       
       validation_generator,
       
       nb_val_samples
       
       =
       
       nb_val_samples)
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.

The convergence speed of this model training is really fast , Very awesome.

After training, you can use tensorboard see loss Change and accuracy of

Of course, we need to see how the test effect of the model is , So take a look at the test results of a single picture

       
       # 
       
       --
       
       coding:
       
       utf
       
       -
       
       8
       
       --
       
       ''
       
       '
       
       1
       
       、 Modify the path of the model and the path of the image 
       
       2
       
       、 If the number of categories is different, it should be modified labels Parameters in and plt Inside list
       
       ''
       
       '
       
# 
       
        Definition layer 
       
       import 
       
       sys
       
       import 
       
       argparse
       
       import 
       
       numpy 
       
       as 
       
       np
       
       from 
       
       PIL 
       
       import 
       
       Image
       
       from 
       
       io 
       
       import 
       
       BytesIO
       
       import 
       
       matplotlib.
       
       pyplot 
       
       as 
       
       plt
       
       from 
       
       keras.
       
       preprocessing 
       
       import 
       
       image
       
       from 
       
       keras.
       
       models 
       
       import 
       
       load_model
       
       from 
       
       keras.
       
       applications.
       
       densenet 
       
       import 
       
       preprocess_input
       
# 
       
        Crazy level picture specifies the size 
       
       target_size 
       
       = (
       
       224, 
       
       224)
       
# 
       
        Prediction function 
       
# 
       
        Input ：model, picture , Target size 
       
# 
       
        Output ： forecast predict
       
       def 
       
       predict(
       
       model, 
       
       img, 
       
       target_size):
       
       ""
       
       "Run model prediction on image
       
       Args:
       
       model: 
       
       keras 
       
       model
       
       img: 
       
       PIL 
       
       format 
       
       image
       
       target_size: (
       
       w,
       
       h) 
       
       tuple
       
       Returns:
       
       list 
       
       of 
       
       predicted 
       
       labels 
       
       and 
       
       their 
       
       probabilities
       
       ""
       
       "
       
       if 
       
       img.
       
       size 
       
       != 
       
       target_size:
       
       img 
       
       = 
       
       img.
       
       resize(
       
       target_size)
       
       x 
       
       = 
       
       image.
       
       img_to_array(
       
       img)
       
       x 
       
       = 
       
       np.
       
       expand_dims(
       
       x, 
       
       axis
       
       =
       
       0)
       
       x 
       
       = 
       
       preprocess_input(
       
       x)
       
       preds 
       
       = 
       
       model.
       
       predict(
       
       x)
       
       return 
       
       preds[
       
       0]
       
# 
       
        Drawing function 
       
# 
       
        Draw a picture after prediction , The default here is cat and dog , Of course, you can modify label
       
       labels 
       
       = (
       
       "daisy", 
       
       "dandelion",
       
       "roses",
       
       "sunflowers",
       
       "tulips")
       
       def 
       
       plot_preds(
       
       image, 
       
       preds, 
       
       labels):
       
       ""
       
       "Displays image and the top-n predicted probabilities in a bar graph
       
       Args:
       
       image: 
       
       PIL 
       
       image
       
       preds: 
       
       list 
       
       of 
       
       predicted 
       
       labels 
       
       and 
       
       their 
       
       probabilities
       
       ""
       
       "
       
       plt.
       
       imshow(
       
       image)
       
       plt.
       
       axis(
       
       'off')
       
       plt.
       
       figure()
       
       plt.
       
       barh([
       
       0, 
       
       1, 
       
       2, 
       
       3, 
       
       4], 
       
       preds, 
       
       alpha
       
       =
       
       0.5)
       
       plt.
       
       yticks([
       
       0, 
       
       1, 
       
       2, 
       
       3, 
       
       4], 
       
       labels)
       
       plt.
       
       xlabel(
       
       'Probability')
       
       plt.
       
       xlim(
       
       0, 
       
       1.01)
       
       plt.
       
       tight_layout()
       
       plt.
       
       show()
       
# 
       
        Load model 
       
       model 
       
       = 
       
       load_model(
       
       '/media/pzw/0E50196C0E50196C/job/triode1/DenseNet/model/checkpoint-08e-val_acc_0.92.hdf5')
       
# 
       
        Local pictures 
       
       img 
       
       = 
       
       Image.
       
       open(
       
       '20180820111351_1_1_Q90.jpg')
       
       preds 
       
       = 
       
       predict(
       
       model, 
       
       img, 
       
       target_size)
       
       plot_preds(
       
       img, 
       
       preds, 
       
       labels)
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.

effect ：

Train one's own classification | 【 Bao Jiao Bao Association , The data are all ready 】_2d_03

summary

1、 Here is the application of the model , Of course, you need to understand the basic structure during the interview , There are also some clever ideas of the author , Not just to find a bite to eat , For future work and ideas for solving problems , Can be of great help , It can brighten the eyes of leaders

2、 Say more here , When we learn from others' achievements , I'm not looking at or saying goodbye to others , More should be to learn how they solve problems when they encounter them , Everyone will encounter the problem of no , But how to think when encountering problems , That's where others are , From scratch , cattle .

Train one's own classification | 【 Bao Jiao Bao Association , The data are all ready 】_2d_04