[2023 MathorCup College Mathematical Modeling Challenge-Big Data Competition] Pista A: Detección e identificación de baches en carreteras basadas en análisis de código Python de visión por computadora

[2023 MathorCup College Mathematical Modeling Challenge-Big Data Competition] Pista A: Detección e identificación de baches en carreteras basadas en análisis de código Python de visión por computadora

1 pregunta

La detección e identificación de baches es una tarea de visión por computadora que tiene como objetivo identificar carreteras con baches a partir de imágenes digitales, generalmente imágenes de baches en la superficie. Esto es cierto para la Tierra. Es de gran importancia para la investigación y aplicación en campos como la exploración geofísica, la ciencia aeroespacial y los desastres naturales. Por ejemplo, puede ayudar a identificar baches en la órbita terrestre, así como a analizar y modelar la morfología de la superficie terrestre.

En la tarea de detección de baches en carreteras, los algoritmos de clasificación tradicionales a menudo no pueden lograr buenos resultados porque las características de las imágenes de baches suelen ser muy complejas y cambiantes. Sin embargo, el desarrollo de la tecnología de aprendizaje profundo en los últimos años ha proporcionado nuevas soluciones para la detección de baches en las carreteras.

El aprendizaje profundo tiene sólidas capacidades de extracción y representación de características y puede extraer automáticamente las características más importantes de las imágenes. En la tarea de clasificación de imágenes de baches, se puede utilizar el aprendizaje profundo para extraer características como el contorno, la textura y la morfología de los baches y convertirlas en una representación que sea más fácil de clasificar. Al mismo tiempo, el rendimiento de la clasificación se puede mejorar aún más mediante técnicas como el aprendizaje por transferencia y la destilación de conocimientos. Por ejemplo, algunos investigadores utilizan métodos basados ​​en el aprendizaje profundo para clasificar las imágenes de carreteras en categorías normales y de baches; además, algunos investigadores también utilizan métodos basados ​​en el aprendizaje por transferencia para aprender los baches a partir de modelos generales previos al entrenamiento. Funciones para clasificar imágenes de baches.

Esta pregunta de competencia espera identificar automáticamente baches en una nueva imagen de carretera mediante el análisis, la extracción de características y el modelado de imágenes de carreteras marcadas. Las tareas específicas son las siguientes:
Preguntas preliminares
Pregunta 1: Combine los archivos de imagen proporcionados, extraiga las características de la imagen y establecer un reconocimiento Un modelo con alta eficiencia, velocidad rápida y clasificación precisa, que se utiliza para identificar si la carretera en la imagen es normal o tiene baches.
Pregunta 2: Entrene el modelo creado en la Pregunta 1 y evalúe el modelo desde diferentes dimensiones.
Pregunta 3: Utilice el modelo entrenado para identificar imágenes de baches en el conjunto de prueba y coloque los resultados del reconocimiento en "test_result.csv''. (Nota: el enlace de descarga del conjunto de prueba se anunciará 48 horas antes del final de la competencia; preste atención al sitio web de registro a tiempo)

Descripción del archivo adjunto:
Adjunto 1: data.zip;
Conjunto de datos de entrenamiento, el archivo contiene un total de 301 imágenes.
El nombre del archivo que contiene el carácter "normal" indica una carretera normal; de lo contrario, es una carretera con baches.

Figura 1: Ejemplo de carretera normal

Figura 2: Ejemplo de camino con baches

Adjunto 2: test_result.csv;
Envíe el archivo de resultados de la prueba. El encabezado del archivo permanece sin cambios. Los datos son solo un ejemplo. Elimínelos y rellénelos al enviarlos. Consulte la descripción del campo en la siguiente tabla.
Tabla 1: descripción del campo de la tabla test_result

Campo	ilustrar
nombres	El nombre del archivo de la imagen de prueba.
etiqueta	Identificación de clasificación: complete 1 y 0, 1 significa camino normal; 0 significa camino con baches

Adjunto 3: test_data.zip

El conjunto de datos de prueba contiene miles de imágenes en el archivo. El número específico está sujeto a los datos publicados.

El enlace de descarga del conjunto de datos de prueba se anunciará 48 horas antes del final de la competencia. Preste atención al sitio web de registro a tiempo.

2 Análisis de ideas

En primer lugar, el conjunto de entrenamiento solo tiene 301 imágenes, lo que indica que se trata de un pequeño problema de muestra. Siga el siguiente proceso para establecer una línea de base y luego optimice gradualmente cada parte.

(1) Preprocesamiento de datos:

• Cambiar el tamaño de la imagen: dado que el modelo de aprendizaje profundo tiene requisitos estrictos sobre el tamaño de la imagen de entrada, puede utilizar un algoritmo de procesamiento de imágenes (como la función de cambio de tamaño en la biblioteca OpenCV) para escalar uniformemente la imagen a un tamaño fijo. En el siguiente ejemplo, el tamaño unificado es 224*224.
• Mejora de datos: se pueden utilizar algoritmos de mejora de imágenes (como funciones de traducción, rotación, volteo, etc. en la biblioteca OpenCV) para mejorar la imagen para ampliar la cantidad de muestras y aumentar la diversidad de datos.

(2) Extracción de características:

• Extracción de características basada en algoritmos tradicionales de visión por computadora: los algoritmos de extracción de características de imágenes tradicionales (como SIFT, HOG, LBP, etc.) se pueden utilizar para extraer características locales o globales de la imagen para entrenar modelos de aprendizaje profundo.
• Extracción de características basada en modelos de aprendizaje profundo: puede utilizar redes neuronales convolucionales previamente entrenadas (como VGG, ResNet, Inception, etc.) para extraer características de alto nivel de las imágenes y utilizar estas características como entrada para entrenar modelos de aprendizaje profundo. El siguiente es un ejemplo de extracción de características por parte de VGG, consulte la Sección 3.3.

(3) Conjunto de datos de análisis visual:

• Utilice un algoritmo de procesamiento de imágenes (como la función imshow en la biblioteca OpenCV) para mostrar la imagen: puede seleccionar aleatoriamente algunas imágenes de muestra de carreteras normales y carreteras con baches, y utilizar un algoritmo de procesamiento de imágenes para mostrarlas visualmente y comprender las características y dificultades del conjunto de datos.
• Dibuje gráficos estadísticos, como histogramas y diagramas de dispersión: puede utilizar métodos estadísticos, como dibujar histogramas de píxeles de imágenes de carreteras normales y con baches, diagramas de dispersión de características de color, etc., para observar la distribución del conjunto de datos y determinar la imagen. Características ¿Hay alguna distinción?

(4) Establecer un modelo de aprendizaje profundo:

• La línea de base utiliza redes neuronales convolucionales (como VGG, ResNet, Inception, etc.), codificadores automáticos, redes neuronales recurrentes, etc., y realiza ajustes finos o aprendizaje de transferencia de acuerdo con las características del conjunto de datos.
• Otras técnicas de clasificación de imágenes de vanguardia incluyen
  • Transferir aprendizaje: transfiera modelos entrenados en conjuntos de datos a gran escala (como ImageNet) a pequeños problemas de muestra y resuelva problemas de clasificación mediante ajuste fino o extracción de características.
  • Mejora de datos: utilice algoritmos de mejora de imágenes (como rotación, traducción, volteo, recorte, etc.) para expandir muestras y aumentar el número y la diversidad de muestras.
  • Red generativa adversaria (GAN): aumente la cantidad de muestras sintetizando datos de muestra y utilice el generador GAN para generar muestras realistas para expandir los datos.
  • Metaaprendizaje: aprenda a aprender y generalizar rápidamente a partir de muestras limitadas y optimice la eficiencia de utilización de las muestras a través del conocimiento previo aprendido.
  • Aprendizaje semisupervisado: utilice una pequeña cantidad de muestras etiquetadas y una gran cantidad de muestras sin etiquetar para el entrenamiento para mejorar la precisión de la clasificación.
  • Aprendizaje activo: utilice la selección activa y el etiquetado de muestras clave para reducir los costos de etiquetado y mejorar el rendimiento del modelo.
  • Métodos de aprendizaje de muestras pequeñas: se proponen algoritmos y métodos especiales para problemas de muestras pequeñas, como aprendizaje de pocas oportunidades, aprendizaje de una sola vez, aprendizaje de cero oportunidades, etc.
  • Aprendizaje incremental: aprenda y actualice gradualmente el modelo para adaptarse a la introducción de nuevas muestras y al olvido de muestras antiguas.
  • Compresión y cuantificación del modelo: mediante técnicas como la poda, cuantificación y destilación del modelo, los parámetros y cálculos del modelo se reducen para adaptarse a problemas de muestras pequeñas.
  • Aprendizaje conjunto: combine los resultados de múltiples clasificadores para mejorar la precisión y solidez de la clasificación, como embolsado, impulso, etc.

(5) Evaluación y optimización del modelo:

• Utilice métodos de validación cruzada para evaluar el modelo: puede utilizar métodos como la validación cruzada k-fold para evaluar el modelo y obtener indicadores como precisión y recuperación para juzgar el rendimiento del modelo.
• Ajuste los parámetros y optimice el modelo: puede probar diferentes funciones de pérdida, optimizadores, tasas de aprendizaje y otros hiperparámetros, así como aumentar el tamaño del conjunto de datos y reducir la complejidad del modelo para optimizar el modelo de aprendizaje profundo.

3 implementación de código Python

3.1 Preprocesamiento de datos

import os
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Convolution2D, MaxPooling2D, ZeroPadding2D
from tensorflow.keras import optimizers
from tensorflow.keras import applications
from tensorflow.keras.models import Model
from IPython.display import Image
from tensorflow.keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
import os
from sklearn.model_selection import train_test_split
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import pandas as pd
from PIL import Image
import os

# 将图片统一像素格式，并分别存储到文件夹中

# 创建文件夹
processed_normal_dir = "data/processed_normal"
processed_wavy_dir = "data/processed_wavy"
os.makedirs(processed_normal_dir, exist_ok=True)
os.makedirs(processed_wavy_dir, exist_ok=True)

# 处理图像
data_dir = "data"
for filename in os.listdir(data_dir):
    img_path = os.path.join(data_dir, filename)
    img = Image.open(img_path)
    
    # 对图像进行缩放
    img = img.resize((224, 224))
    
    # 决定图像应该存储在哪个文件夹中
    if "normal" in filename:
        save_dir = processed_normal_dir
    else:
        save_dir = processed_wavy_dir
    # 保存图像
    save_path = os.path.join(save_dir, filename)
    img.save(save_path)

(2) Carga de datos

Hay un total de 301 imágenes, se seleccionan 30 imágenes como conjunto de prueba y se toma 1 imagen por separado para probar; de lo contrario, es difícil dividirla en números enteros.

img_width, img_height = 224, 224
num_classes = 2
batch_size = 10

datagen = ImageDataGenerator(rescale=1./255)

X = []
y = []
normal_dir = "data/processed_normal"
wavy_dir = "data/processed_wavy"

for img_name in os.listdir(normal_dir):
    img_path = os.path.join(normal_dir, img_name)
    X.append(img_path)
    y.append('0')
for img_name in os.listdir(wavy_dir):
    img_path = os.path.join(wavy_dir, img_name)
    X.append(img_path)
    y.append('1')

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.1, random_state=42)
train_df = pd.DataFrame(data={
    
    'filename': X_train, 'class': y_train})
val_df = pd.DataFrame(data={
    
    'filename': X_val, 'class': y_val})

train_generator = datagen.flow_from_dataframe(
        ...略

validation_generator = datagen.flow_from_dataframe(
        ...略

Se encontraron 270 nombres de archivos de imágenes validados que pertenecen a 2 clases.
Se encontraron 30 nombres de archivos de imágenes validados que pertenecen a 2 clases.

3.2 Entrenamiento del modelo de convolución

(1) Definir red convolucional

model = Sequential()
model.add(Convolution2D(32, (3, 3), input_shape=(img_width, img_height,3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Convolution2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Convolution2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

(2) Entrenamiento modelo

epochs = 20
train_samples = 270
validation_samples = 30
batch_size =10
model.fit_generator(
        train_generator,
        steps_per_epoch=train_samples // batch_size,
        epochs=epochs,
        validation_data=validation_generator,
        validation_steps=validation_samples// batch_size,)

model.save_weights('models/basic_cnn_20_epochs.h5')
model.load_weights('models_trained/basic_cnn_30_epochs.h5')

(3) Verificación del modelo

# 将多余出来的一张图片拿出来预测
img = load_img('data/normal1.jpg')
x = img_to_array(img)
prediction = model.predict(x.reshape((1,img_width, img_height,3)),batch_size=10, verbose=0)
print(prediction)

0

model.evaluate_generator(validation_generator, validation_samples)

[0,7280968427658081, 0,8999999761581421]

3.3 Entrenamiento en aumento de datos

(1) Mejora de datos

Un conjunto de datos mejorado artificialmente con imágenes nuevas e invisibles mediante la aplicación de transformaciones aleatorias al conjunto de entrenamiento. Reducir el sobreajuste y proporcionar a nuestra red mejores capacidades de generalización.

train_datagen_augmented = ImageDataGenerator(
        rescale=1./255,        # normalize pixel values to [0,1]
        shear_range=0.2,       # randomly applies shearing transformation
        zoom_range=0.2,        # randomly applies shearing transformation
        horizontal_flip=True)  # randomly flip the images

train_generator_augmented = train_datagen_augmented.flow_from_dataframe(
       ...略

(2) Entrenamiento modelo

model.fit_generator(
        train_generator_augmented,
        steps_per_epoch=train_samples // batch_size,
        epochs=epochs,
        validation_data=validation_generator,
        validation_steps=validation_samples // batch_size,)

(3) Evaluación del modelo

model.save_weights('models/augmented_20_epochs.h5')
#model.load_weights('models_trained/augmented_30_epochs.h5')

model.evaluate_generator(validation_generator, validation_samples)

[0,2453145980834961, 0,8666666746139526]

3.4 Modelo previamente entrenado

Al utilizar un clasificador de imágenes previamente entrenado y de uso general, es posible superar los modelos anteriores en términos de rendimiento y eficiencia. Este ejemplo utiliza VGG16, un modelo entrenado en el conjunto de datos ImageNet, que contiene millones de imágenes clasificadas en 1000 categorías.

(1) Cargue los pesos del modelo VGG.

model_vgg =

train_generator_bottleneck = datagen.flow_from_dataframe(
        dataframe=train_df,
        directory=None,
        x_col='filename',
        y_col='class',
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='binary')

validation_generator_bottleneck = datagen.flow_from_dataframe(
        dataframe=val_df,
        directory=None,
        x_col='filename',
        y_col='class',
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='binary')

(2) Utilice el modelo para extraer características.

bottleneck_features_train = model_vgg.predict_generator(train_generator_bottleneck, train_samples // batch_size)
np.save(open('models/bottleneck_features_train.npy', 'wb'), bottleneck_features_train)

bottleneck_features_validation = model_vgg.predict_generator(validation_generator_bottleneck, validation_samples // batch_size)
np.save(open('models/bottleneck_features_validation.npy', 'wb'), bottleneck_features_validation)

(3) Leer datos preprocesados

train_data = np.load(open('models/bottleneck_features_train.npy', 'rb'))
train_labels = np.array([0] * (train_samples // 2) + [1] * (train_samples // 2))

validation_data = np.load(open('models/bottleneck_features_validation.npy', 'rb'))
validation_labels = np.array([0] * (validation_samples // 2) + [1] * (validation_samples // 2))

(4) Capacitación en modelo de red completamente conectada

model_top = Sequential()
model_top.add(Flatten(input_shape=train_data.shape[1:]))
model_top.add(Dense(256, activation='relu'))
model_top.add(Dropout(0.5))
model_top.add(Dense(1, activation='sigmoid'))

model_top.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])

model_top.fit(train_data, train_labels,
        epochs=epochs, 
        batch_size=batch_size,
        validation_data=(validation_data, validation_labels))

model_top.save_weights('models/bottleneck_20_epochs.h5')

(5) Evaluación del modelo

model_top.evaluate(validation_data, validation_labels)

[2.3494818210601807, 0.4333333373069763]

3.5 Ajuste del modelo previamente entrenado

Construya un modelo clasificador sobre el modelo convolucional. Para realizar ajustes, comience con un clasificador completamente capacitado. Se utilizarán los pesos del modelo anterior. Luego agregue este modelo a la base de convolución.

weights_path = 'weight/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5'
model_vgg = applications.VGG16(include_top=False, weights=weights_path, input_shape=(224, 224, 3))

top_model = Sequential()
top_model.add(Flatten(input_shape=model_vgg.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(1, activation='sigmoid'))

top_model.load_weights('models/bottleneck_20_epochs.h5')

#model_vgg.add(top_model)
model = Model(inputs = model_vgg.input, outputs = top_model(model_vgg.output))
# 微调，只需要训练几层。这一行将设置前25层(直到conv块)为不可训练的。

for layer in model_vgg.layers[:15]:
    layer.trainable = False
    
model.compile(loss='binary_crossentropy',
              optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
              metrics=['accuracy'])

aumento de datos

# 数据增强
train_datagen = ImageDataGenerator(
        rescale=1./255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True)

test_datagen = ImageDataGenerator(rescale=1./255)


train_generator = datagen.flow_from_dataframe(
      ...略

validation_generator = datagen.flow_from_dataframe(
        ...略

Ajuste del modelo

# 微调模型
model.fit_generator(
    train_generator,
    steps_per_epoch=train_samples // batch_size,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=validation_samples // batch_size)

model.save_weights('models/finetuning_20epochs_vgg.h5')
model.load_weights('models/finetuning_20epochs_vgg.h5')

Evaluación del modelo

model.evaluate_generator(validation_generator, validation_samples)

[en, 0,8666666746139526]

Al final, el modelo no converge de esta manera, lo que indica que existen aspectos irrazonables en el proceso de configuración de la red, como el número de capas de parámetros congelados, el modelo de red utilizado y si se requiere mejora de los datos. Este método se proporciona para que los estudiantes mejoren.

4 Descarga el programa completo

El código anterior está incompleto; descargue el archivo fuente si lo desea completo
Incluye el modelo entrenado y los archivos de peso