Mellorar a clasificación de buques con CNNs e transferencia de aprendizaxe

Introdución

Benvido a unha exploración en profundidade da clasificación de buques mediante redes neuronais convolutivas (CNNs) co conxunto de datos de Analytics Vidhya Hackathon. As CNN son unha pedra angular das tarefas relacionadas coa imaxe, coñecida pola súa capacidade para aprender representacións xerárquicas de imaxes. Neste proxecto, mergullamos para comprender o poder das CNNs para clasificar os buques en función das súas características visuais.

Este proxecto pretende demostrar unha aplicación de aprendizaxe profunda na categorización de imaxes e comparar CNNs construídas desde cero e os reforzados a través da aprendizaxe de transferencias. Explora a clasificación de buques, desde o preprocesamento ata a avaliación e comparación.

Obxectivos de aprendizaxe

• Aplique redes neuronais convolucionais (CNNs) para a clasificación de buques.
• Datos de imaxe preprocesados ​​mediante OpenCV e NUMPY.
• Implementar modelos CNN tanto con e sen aprendizaxe de transferencias.
• Avaliar o rendemento do modelo mediante métricas como a precisión e a puntuación F1.
• Compara os resultados dos modelos CNN con e sen aprendizaxe de transferencias.

Declaración do problema

Neste contexto, a axencia gobernamental marítima e garda costeira busca implementar un sistema automatizado de detección de buques aproveitando a tecnoloxía de visión informática. O obxectivo é identificar e clasificar os buques a partir de imaxes capturadas por barcos de enquisa con precisión. Cunha variedade de tipos de barcos, incluíndo buques de carga, camións cisterna, buques militares, transportistas e barcos de cruceiros, o reto reside en desenvolver un modelo robusto capaz de distinguir entre estas clases de xeito eficaz.

Descrición do conxunto de datos

Os cinco tipos de buques (cargador, cisterna, militares, transportistas e cruceiros) están representados no conxunto de datos por un grupo de fotos tomadas por barcos de enquisa. O conxunto de datos ofrece unha gran variedade de datos visuais para a construción de modelos, con 6252 imaxes para adestramento e 2680 imaxes para probas.

Explicación de OpenCV e CNN

Imos explorar en detalle sobre OpenCV e CNN:

Opencv

Con moitas características para tarefas de procesamento de imaxes, incluíndo detección de obxectos, extracción de funcións e edición de imaxes, OpenCV é unha ferramenta potente. Podemos mellorar a calidade das fotos de entrada, identificar funcións pertinentes e preprocesar os datos de imaxe en bruto mediante OpenCV.

Redes neuronais convolucionais

As CNN están deseñadas específicamente para tarefas relacionadas coa imaxe. As CNN son especialmente boas para extraer automaticamente características a varios graos de abstracción de representacións xerárquicas de imaxes. Podemos crear un modelo que poida recoñecer patróns e trazos únicos conectados a cada tipo de barco adestrando un CNN coas fotos do barco etiquetadas.

Capas en CNNs

As CNN constan de varias capas, cada unha que ten un propósito específico para procesar e extraer funcións de imaxes de entrada. Romperemos os compoñentes dunha CNN:

Capas convolutivas

As CNN están compostas principalmente por capas convolucionais. Estas capas están formadas por filtros aprendibles, comunmente denominados núcleos, que realizan operacións de convolución na imaxe de entrada deslizándose sobre ela. Os filtros usan operacións de multiplicación e suma de elementos para extraer diferentes funcións da imaxe de entrada, incluíndo bordos, texturas e patróns. Normalmente, cada capa convolutiva usa varios filtros para recoller varias funcións.

Función de activación

Para engadir non linealidade á rede, aplícase unha función de activación element por element aos mapas de características de saída despois da operación de convolución. TANH, SIGMOID e RELU (unidade lineal rectificada) son exemplos de funcións de activación comúns. A facilidade de uso e eficiencia de RELU na resolución do problema de gradiente desaparecido convérteno na función de activación máis utilizada en CNNs.

Capas de agrupación

A combinación de capas reduce os mapas de características producidas polas capas convolutivas para preservar a información crucial ao tempo que reduce as súas dimensións espaciais. O procedemento de agrupación máis popular, a agrupación máxima, destaca efectivamente as características salientables mantendo o valor máximo dentro de cada rexión de agrupación. Agrupación da entrada reduce a complexidade computacional da rede e aumenta a súa capacidade para aprender características robustas, tornándoa máis resistente ás lixeiras flutuacións espaciais.

Capas totalmente conectadas

As capas completamente conectadas normalmente realizan tarefas de clasificación ou regresión en función das características aprendidas despois das capas convolutivas e de agrupación. Estas capas establecen conexións entre cada neurona nunha capa e a neurona de todas as outras capas, permitindo á rede comprender as relacións entre as características extraídas das imaxes de entrada. Nas fases finais da construción da rede, adoitan usarse capas totalmente conectadas para xerar a saída desexada, como as probabilidades de clase nas tarefas de clasificación de imaxes.

Capa de softmax

Normalmente, insírese unha capa de softmax ao final da rede para transformar as probabilidades de clase das puntuacións de saída en bruto nas tarefas de clasificación. Para asegurarse de que as puntuacións de saída se suman a unha e pódense entender como probabilidades, a función SoftMax normaliza os valores de cada clase. Como resultado, a rede pode escoller a clase coa maior probabilidade de facer prediccións.

CNNs aproveitan as capas convolutivas con filtros aprendibles para extraer características xerárquicas de imaxes de entrada, seguidas de funcións de activación para introducir non linealidade, agrupando capas a mapas de características descendentes, capas totalmente conectadas para representación de características de alto nivel e unha capa de softmax para tarefas de clasificación. Esta arquitectura permite que as CNNs poidan realizar un bo en varias tarefas relacionadas coa imaxe, incluída a clasificación de imaxes, a detección de obxectos e a segmentación.

Imos agora aplicar os conceptos ao conxunto de datos do Analytics Vidhya Hackathon.

Implementación de CNN

Executaremos a implementación CNN tanto con e sen aprendizaxe de transferencias. Para comezar, primeiro abordemos a implementación sen aprendizaxe de transferencias.

Aquí está a implementación paso a paso:

Paso 1: Importar bibliotecas e dependencias

Como sabemos, o primeiro paso é instalar todas as bibliotecas e dependencias necesarias:

import pandas as pd
import numpy as np
import cv2
import seaborn as sns
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.math import confusion_matrix
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, InputLayer
from glob import glob
from skimage.transform import resize
from keras.utils import to_categorical
from keras.models import Sequential
import keras
from keras.layers import Dense, Conv2D, MaxPool2D , Flatten
from tensorflow.keras import models, layers

Paso 2: Carga o conxunto de datos

data = pd.read_csv('/kaggle/input/shipdataset/train.csv')

Paso 3: Análise de datos

Agora, imos realizar algunha análise de datos:

data.groupby('category').count()

Isto proporcionará información sobre a distribución de categorías dentro do conxunto de datos.

Paso 4: visualización

Visualizemos agora:

ship_categories = {1: 'Cargo', 2: 'Military', 3: 'Carrier', 4: 'Cruise', 5: 'Tanker'}
data['category_mapped'] = data['category'].map(ship_categories)
sns.countplot(x='category_mapped', data=data)

O CountPlot revela que o conxunto de datos comprende 2120 imaxes clasificadas como carga, 1167 como militares, 916 como transportistas, 832 como cruceiro e 1217 como petroleiro.

Paso5: preprocesando os datos

Agora imos preprocesar os datos coa axuda do código a continuación:

X=[]
import cv2
for img_name in data.image:
    img=cv2.imread('/kaggle/input/shipdataset/images/'+img_name)
    img_resized = cv2.resize(img, (224, 224))
    X.append(img_resized)

X=np.array(X)

Este código carga imaxes dun directorio, redimensionádeas a 224 × 224 píxeles usando OpenCV e almacena as imaxes redimensionadas nunha matriz Numpy.

Paso6: trama

Agora imos tramalos despois do redimensionamento.

nrow = 5
ncol = 4
fig1 = plt.figure(figsize=(15, 15))
fig1.suptitle('After Resizing', size=32)
for i in range(20):
    plt.subplot(nrow, ncol, i + 1)
    plt.imshow(X[i])
    plt.title('class = {x}, Ship = {y}'.format(x=data["category"][i],
     y=ship_categories[data["category"][i]]))
    plt.axis('Off')
    plt.grid(False)
plt.show()

y=data.category.values
y=y-1

Este paso resta 1 de cada valor na matriz de categorías de datos, almacenando o resultado na variable y.

O propósito desta operación podería ser axustar as etiquetas da categoría. É común nas tarefas de aprendizaxe de máquinas comezar a indexarse ​​de 0 en lugar de 1, especialmente cando se trata de tarefas de clasificación. Para aliñar as etiquetas con indexación baseada en cero, a restación 1 das etiquetas da categoría faise a miúdo, como esixe os algoritmos ou bibliotecas de aprendizaxe de máquinas.

X = X.astype('float32') / 255
y = to_categorical(y)

Este código converte os valores de píxeles en X a flotadores entre 0 e 1 e un-hot codifica etiquetas categóricas en y.

Paso 7: Data de división no conxunto de datos de tren/proba

Dividir o conxunto de datos en conxuntos de formación e probas mediante a función Train_test_split.

X_train, X_test, y_train, y_test = train_test_split(X, y,
 test_size=0.2, random_state=42)

Definición do modelo CNN: Defina un modelo CNN usando a API secuencial de Tensorflow, especificando as capas convolutivas e de agrupación.

CNN_model = models.Sequential([
    layers.Conv2D(64, (3, 3), activation='relu', padding='same', 
    input_shape=(224, 224, 3)),
    layers.Conv2D(64, (3, 3), padding='same', activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(128, (3, 3), padding='same', activation='relu'),
    layers.Conv2D(128, (3, 3), padding='same', activation='relu'), 
    layers.MaxPooling2D((2, 2)),
    layers.GlobalAveragePooling2D(),  
    layers.Dense(128, activation='relu'),
    layers.Dense(128, activation='relu'),
    layers.Dense(128, activation='relu'),
    layers.Dense(5, activation='softmax')  
])
CNN_model.summary()

Paso 8: Formación de modelos

Chove o modelo CNN nos datos de formación, configurando a parada precoz e o punto de control do modelo para evitar o exceso de encaixe e gardar o mellor modelo.

Compile o modelo con Adam Optimizer e a perda como entropía cruzada categórica como clasificación multiclase

from tensorflow.keras.optimizers import Adam
model.compile(optimizer="adam",
                  loss="categorical_crossentropy",
                  metrics=['accuracy',tf.keras.metrics.F1Score()])

Aforrando o mellor modelo na perda de validación

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
early_stop = EarlyStopping(monitor="val_loss", 
patience=3, restore_best_weights=True)
checkpoint = ModelCheckpoint('best_model.keras', 
monitor="val_loss", save_best_only=True, mode="min")

Paso 9: adaptar o modelo

history = model.fit(X_train, y_train, 
                        epochs=20, 
                        batch_size=32, 
                        validation_data=(X_test, y_test), 
                        callbacks=[early_stop, checkpoint])

Paso 10: Avaliación do modelo

Agora imos facer a avaliación do modelo mediante un modelo adestrado.

from sklearn.metrics import f1_score
y_pred = model.predict(X_test)

Converter as predicións desde un formato codificado dunha calidade ás etiquetas de clase.

y_pred_labels = np.argmax(y_pred, axis=1)
y_true_labels = np.argmax(y_test, axis=1)

from sklearn.metrics import classification_report
report = classification_report(y_true_labels, y_pred_labels)
print("Classification Report:")
print(report)

Trama os valores de perda de formación e validación

plt.figure(figsize=(10, 6))
plt.plot(history.history['loss'], label="Training Loss")
plt.plot(history.history['val_loss'], label="Validation Loss")
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.grid(True)
plt.show()

import matplotlib.pyplot as plt
plt.plot(history.history['accuracy'], label="Training accuracy")
plt.plot(history.history['val_accuracy'], label="Validation accuracy")
plt.title('Training and Validation accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.grid(True)
plt.show()

Probas de datos

Preparando e preprocesando os datos de proba de xeito similar aos datos de formación, fai predicións usando o modelo adestrado e visualiza algunhas predicións de mostra xunto coas súas clases previstas.

test=pd.read_csv('/kaggle/input/test-data/test_ApKoW4T.csv')

X_test=[]
import cv2
for img_name in test.image:
    img=cv2.imread('/kaggle/input/shipdataset/images/'+img_name)
    img_resized = cv2.resize(img, (224, 224))
    X_test.append(img_resized)
X_test=np.array(X_test)
X_test = X_test.astype('float32') / 255

Facendo predición

predictions=model.predict(X_test)
predicted_class= np.argmax(predictions,axis=1)
predicted_class=predicted_class+1
csv_=test.copy()
csv_
csv_['category']=predicted_class
csv_.head()

csv_['category'].value_counts()

Gardar predicións en CSV

csv_.to_csv('prediction1.csv',index=False)

Trama os datos de proba previstos

plt.figure(figsize=(8, 8))
for i in range(20):
    plt.subplot(4, 5, i + 1)  
    plt.imshow(X_test[i])  
    plt.title(f'Predicted Class: {ship_categories[predicted_class[i]]}', fontsize=8)  
plt.tight_layout() 
plt.savefig('prediction_plot1.png')
plt.show()

Agora imos empregar a aprendizaxe de transferencias para resolver este problema para isto, estaremos usando Resnet.

Comprender Mobilenet

Mobilenet é un tipo de rede neuronal convolutiva (CNN) deseñada específicamente para dispositivos móbiles e incrustados. É coñecido por ser eficiente e lixeiro, tornándoo ideal para situacións nas que o procesamento de potencia e a duración da batería son limitados.

Aquí tes un desglose das características clave de Mobilenet:

• Eficiencia: Mobilenet emprega convolucións separables profundamente, que dividen o procesamento de datos en dous pasos: Convolución profunda usando un único filtro para cada canle de entrada e convolución puntual usando filtros 1 × 1.
• Lightweight: Mobilenet reduce a cantidade de parámetros necesarios polo modelo minimizando os cálculos. Isto significa que o modelo será máis pequeno, o que é importante para os dispositivos móbiles con almacenamento restrinxido.
• Aplicacións: É útil para varias tarefas en dispositivos móbiles, incluíndo a clasificación de imaxes, a detección de obxectos e o recoñecemento facial.

Podes ler máis sobre Mobilenet facendo clic aquí.

Utilizaremos Mobilenet para esta tarefa. Todo segue sendo coherente desde a importación de bibliotecas ata a división de datos (o mesmo paso que sen a aprendizaxe de transferencias). Ademais, necesitamos importar a biblioteca Mobilenet.

from keras.applications import MobileNet
from keras.models import Model
from keras.layers import Dense, GlobalAveragePooling2D
from keras.layers import Dropout, BatchNormalization

Cargando un modelo pre-adestrado

Agora cargue o modelo pre-adestrado como modelo base

base_model = MobileNet(weights="imagenet", include_top=False)

Conxelar todas as capas do modelo base:

for layer in base_model.layers:
    layer.trainable = False

Construír modelo mediante a función funcional

x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
x = BatchNormalization()(x)
x = Dropout(0.5)(x)  # Add dropout with a rate of 0.5
predictions = Dense(5, activation='softmax')(x)
 
#Creating the model
model = Model(inputs=base_model.input, outputs=predictions)

Compilando o modelo

Compile o modelo con Adam Optimizer e a perda como entropía cruzada categórica como clasificación multiclase

from tensorflow.keras.optimizers import Adam
model.compile(optimizer="adam",
                  loss="categorical_crossentropy",
                  metrics=['accuracy',tf.keras.metrics.F1Score()])

Aforrando o mellor modelo na perda de validación

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
early_stop = EarlyStopping(monitor="val_loss", patience=2, restore_best_weights=True)
checkpoint = ModelCheckpoint('best_model.keras', monitor="val_loss", 
  save_best_only=True, mode="min")

Encaixando o modelo

history = model.fit(X_train, y_train, 
                    epochs=20, 
                    batch_size=32, 
                    validation_data=(X_test, y_test),
                    callbacks=[early_stop,checkpoint])

Avaliación do modelo

Agora imos facer a avaliación do modelo.

from sklearn.metrics import f1_score

#Making predictions using the trained model
y_pred = model.predict(X_test)

#Converting predictions from one-hot encoded format to class labels
y_pred_labels = np.argmax(y_pred, axis=1)
y_true_labels = np.argmax(y_test, axis=1)

from sklearn.metrics import classification_report
report = classification_report(y_true_labels, y_pred_labels)
print("Classification Report:")
print(report)

Trama os valores de perda de formación e validación

plt.figure(figsize=(10, 6))
plt.plot(history.history['loss'], label="Training Loss")
plt.plot(history.history['val_loss'], label="Validation Loss")
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.grid(True)
plt.show()

Curva de precisión

import matplotlib.pyplot as plt
plt.plot(history.history['accuracy'], label="Training accuracy")
plt.plot(history.history['val_accuracy'], label="Validation accuracy")
plt.title('Training and Validation accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.grid(True)
plt.show()

Agora fai a predición sobre os datos da proba igual que se fai sen aprendizaxe de transferencias

Conclusión

Este estudo explora dous enfoques para a clasificación de buques mediante redes neuronais convolutivas (CNNs). O primeiro consiste en construír un CNN desde cero sen técnicas de aprendizaxe de transferencias, mentres que o segundo usa a aprendizaxe de transferencias mediante a arquitectura Mobilenet. Ambos os métodos mostran solucións potenciais para a clasificación de buques, coa aprendizaxe de transferencias ofrecendo un mellor rendemento con menos datos de formación. A elección depende dos recursos computacionais, do tamaño do conxunto de datos e das métricas de rendemento desexadas.

Preguntas frecuentes