Reifenrillenanalyse mit künstlicher Intelligenz in Python!

Die Analyse des Reifenprofils ist eine entscheidende Aufgabe, um Verschleiß zu erkennen und die Sicherheit zu gewährleisten, insbesondere bei Fahrzeugen, die lange Strecken zurücklegen. Mithilfe künstlicher Intelligenz (KI) und Python können wir diesen Prozess schnell und präzise automatisieren. Hier zeigen wir, wie ein Convolutional Neural Network (CNN)-Modell, das auf der VGG16-Architektur basiert, Reifen in „neu“ oder „gebraucht“ klassifiziert, während OpenCV bei der Analyse von Bildern hilft, um die Profiltiefe zu messen.

Verwendete Technologien

• Python:
  Beliebte Programmiersprache für KI und maschinelles Lernen, insbesondere wegen ihrer erweiterten Bibliotheken.

• OpenCV:
  Wird verwendet, um Bilder zu verarbeiten, Konturen zu erkennen und die Reifenprofilfläche zu messen.

• TensorFlow und Keras:
  Deep-Learning-Bibliotheken. Wir verwenden Keras, um mit dem VGG16-Modell zu arbeiten, einem vortrainierten CNN für die Bilderkennung.

• Matplotlib:
  Bibliothek zur Datenvisualisierung und Diagrammerstellung, die Klassifizierungsergebnisse besser interpretierbar macht.

Code:

1. Bilder laden und vorverarbeiten:
Reifenbilder werden hochgeladen und in der Größe auf ein Standardformat (150 x 150 Pixel) geändert, das für die Modelleingabe erforderlich ist. Diese Größenänderung behält das Seitenverhältnis bei und normalisiert Pixelwerte zwischen 0 und 1, um die Verarbeitung durch das Modell zu erleichtern.

import cv2
import numpy as np
from tensorflow.keras.applications.vgg16 import preprocess_input

def process_image(image_path, target_size=(150, 150)):
    image = cv2.imread(image_path)
    if image is None:
        print(f"Erro ao carregar a imagem: {image_path}. Verifique o caminho e a integridade do arquivo.")
        return None, None

    image_resized = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)
    image_array = np.array(image_resized) / 255.0  
    image_array = np.expand_dims(image_array, axis=0)
    image_preprocessed = preprocess_input(image_array)

    return image_resized, image_preprocessed

2. Klassifizierung mit dem trainierten Modell:
Wir haben ein vorab trainiertes neuronales Faltungsnetzwerkmodell geladen, das darauf abgestimmt wurde, Reifen als „neu“ oder „gebraucht“ zu klassifizieren. Dieses Modell liefert einen Konfidenzwert, der die Wahrscheinlichkeit angibt, dass ein Reifen neu ist.

from tensorflow.keras.models import load_model

model = load_model('pneu_classificador.keras')
prediction = model.predict(image_preprocessed)

3. Konturanalyse für Rillentiefe:
Die Erkennung der Rillentiefe erfolgt mithilfe von Computer-Vision-Techniken. Das Graustufenbild durchläuft einen Unschärfefilter und eine Canny-Kantenerkennung, die bei der Identifizierung von Rillenkonturen hilft. Anschließend berechnen wir die Gesamtfläche der Konturen, wodurch wir den Verschleiß abschätzen können.

def detect_tread_depth(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edges = cv2.Canny(blurred, 30, 100)
    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    total_area = sum(cv2.contourArea(c) for c in contours if cv2.contourArea(c) > 100)
    return total_area

4. Visualisierung und Analyse der Ergebnisse:
Nach der Klassifizierung und Analyse jedes Reifens werden die Ergebnisse mit Matplotlib angezeigt. Wir haben den Klassifizierungskonfidenzwert und den in jedem Bild erkannten Rillenbereich verglichen.

import matplotlib.pyplot as plt

confidence_scores = []
total_area_green_values = []
predicted_classes = []

for image_file in os.listdir(ver_dir):
    image_path = os.path.join(ver_dir, image_file)
    image_resized, image_preprocessed = process_image(image_path)
    if image_preprocessed is not None:
        prediction = model.predict(image_preprocessed)
        confidence_score = prediction[0][0]
        total_area_green = detect_tread_depth(image_resized)

        predicted_class = "novo" if total_area_green > 500 else "usado"
        confidence_scores.append(confidence_score)
        total_area_green_values.append(total_area_green)
        predicted_classes.append(predicted_class)

        plt.imshow(cv2.cvtColor(image_resized, cv2.COLOR_BGR2RGB))
        plt.title(f"Pneu {predicted_class} (Área: {total_area_green:.2f}, Confiança: {confidence_score:.2f})")
        plt.axis('off')
        plt.show()

fig, axs = plt.subplots(2, 1, figsize=(10, 10))

axs[0].bar(os.listdir(ver_dir), confidence_scores, color='skyblue')
axs[0].set_title('Confiança na Classificação')
axs[0].set_ylim(0, 1)
axs[0].tick_params(axis='x', rotation=45)

axs[1].bar(os.listdir(ver_dir), total_area_green_values, color='lightgreen')
axs[1].set_title('Área Verde Detectada')
axs[1].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.show()

Dieses Projekt von mir zeigt, wie es möglich ist, die Reifenverschleißanalyse mithilfe von KI und Computer Vision zu automatisieren, was zu einer genauen und schnellen Klassifizierung führt. Die VGG16-Architektur und die Verwendung von OpenCV sind der Schlüssel zur Kombination der Genauigkeit neuronaler Netzwerkmodelle mit visueller Sulci-Analyse. Dieses System kann für eine kontinuierliche Überwachung aller Fahrzeugflotten erweitert werden, was dazu beiträgt, Unfälle zu reduzieren und das Reifenmanagement zu optimieren.

Das obige ist der detaillierte Inhalt vonReifenrillenanalyse mit künstlicher Intelligenz in Python!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!