day 19 Yolo分析公路車胎壓結合lstm換輪胎時間

2024 iThome 鐵人賽

DAY 19

Software Development

LSTM結合Yolo v8對於多隻斑馬魚行為分析系列第 19 篇

16th鐵人賽

neilsu02

2024-08-21 22:34:14

153 瀏覽

分享至

今天是第十九天我們可以寫一個yolo分析公路車胎壓結合lstm預測換輪胎系統，這不僅保障平時我們的安全更能預防性避免不必要的麻煩出現，以下是程式碼
要結合 YOLO 和 LSTM 來辨識公路車的胎壓並預測換輪胎的時間，可以分為兩個主要部分：

YOLO 部分： 用 YOLO 模型來辨識公路車的輪胎，並從中提取出輪胎的胎壓數據。
LSTM 部分： 利用 LSTM 模型來根據歷史胎壓數據，預測下一次換輪胎的時間。

YOLO 部分


假設你有一個標註了胎壓數據的輪胎影像資料集，你可以使用 YOLO 來辨識輪胎並提取胎壓資訊。這裡假設胎壓可以通過輪胎上的數字或指標來辨識。

```python
import torch

# 加載預訓練的 YOLO 模型
model = torch.hub.load('ultralytics/yolov5', 'custom', path='path_to_your_model.pt')

# 讀取影像
image = 'path_to_your_image.jpg'

# 使用 YOLO 模型辨識輪胎並提取胎壓數據
results = model(image)

# 獲取辨識結果
detected_objects = results.pandas().xyxy[0]  # 取得物件的 DataFrame
tire_pressure = None

# 假設有一個標籤 "tire_pressure" 來標註胎壓數據
for _, row in detected_objects.iterrows():
    if row['name'] == 'tire_pressure':
        tire_pressure = row['confidence'] * 100  # 假設辨識出來的是胎壓百分比

print(f"辨識出的胎壓: {tire_pressure} psi")

LSTM 部分

根據 YOLO 提取的胎壓數據，我們可以構建一個 LSTM 模型來預測換輪胎的時間。

假設我們有一組歷史胎壓數據，使用這些數據來訓練 LSTM 模型。

import numpy as np
import torch
import torch.nn as nn
from sklearn.preprocessing import MinMaxScaler

# 創建一些示例數據
data = np.array([28.5, 28.7, 28.9, 29.0, 28.8, 28.5, 28.3])  # 假設這是歷史胎壓數據
scaler = MinMaxScaler(feature_range=(0, 1))
data_normalized = scaler.fit_transform(data.reshape(-1, 1))

# 構建 LSTM 模型
class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_layer_size=50, output_size=1):
        super(LSTMModel, self).__init__()
        self.hidden_layer_size = hidden_layer_size
        self.lstm = nn.LSTM(input_size, hidden_layer_size, batch_first=True)
        self.linear = nn.Linear(hidden_layer_size, output_size)
        self.hidden_cell = (torch.zeros(1, 1, self.hidden_layer_size),
                            torch.zeros(1, 1, self.hidden_layer_size))

    def forward(self, input_seq):
        lstm_out, self.hidden_cell = self.lstm(input_seq, self.hidden_cell)
        predictions = self.linear(lstm_out[:, -1])
        return predictions

# 創建模型實例
model = LSTMModel()

# 構建序列數據
def create_inout_sequences(input_data, seq_length):
    inout_seq = []
    for i in range(len(input_data) - seq_length):
        seq = input_data[i:i + seq_length]
        label = input_data[i + seq_length]
        inout_seq.append((seq, label))
    return inout_seq

seq_length = 3
train_inout_seq = create_inout_sequences(torch.FloatTensor(data_normalized).view(-1), seq_length)

# 訓練模型
loss_function = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

epochs = 150
for epoch in range(epochs):
    for seq, labels in train_inout_seq:
        optimizer.zero_grad()
        model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
                             torch.zeros(1, 1, model.hidden_layer_size))

        y_pred = model(seq.view(1, -1, 1))
        single_loss = loss_function(y_pred, labels)
        single_loss.backward()
        optimizer.step()

    if epoch % 25 == 0:
        print(f'epoch: {epoch:3} loss: {single_loss.item():10.8f}')

# 預測下一次換輪胎的時間（假設這是時間序列預測的一部分）
model.eval()
with torch.no_grad():
    test_seq = torch.FloatTensor(data_normalized[-seq_length:]).view(1, -1, 1)
    predicted_pressure = model(test_seq)
    predicted_pressure = scaler.inverse_transform(predicted_pressure.numpy())

print(f"預測的下一次胎壓值: {predicted_pressure[0][0]} psi")

1. YOLO 部分

這部分的目的是使用 YOLO 模型來辨識公路車的輪胎，並提取胎壓數據。

import torch

# 加載預訓練的 YOLO 模型
model = torch.hub.load('ultralytics/yolov5', 'custom', path='path_to_your_model.pt')

# 讀取影像
image = 'path_to_your_image.jpg'

# 使用 YOLO 模型辨識輪胎並提取胎壓數據
results = model(image)

# 獲取辨識結果
detected_objects = results.pandas().xyxy[0]  # 取得物件的 DataFrame
tire_pressure = None

# 假設有一個標籤 "tire_pressure" 來標註胎壓數據
for _, row in detected_objects.iterrows():
    if row['name'] == 'tire_pressure':
        tire_pressure = row['confidence'] * 100  # 假設辨識出來的是胎壓百分比

print(f"辨識出的胎壓: {tire_pressure} psi")

說明：

import torch: 載入 PyTorch 庫，這是用來處理深度學習模型的工具。
model = torch.hub.load(...): 這行代碼用來加載 YOLOv5 模型。這個模型已經預先訓練好，可以辨識物件。path_to_your_model.pt 是你訓練的 YOLO 模型的路徑。
results = model(image): 將影像輸入模型，模型會輸出在影像中辨識到的物件。
detected_objects = results.pandas().xyxy[0]: YOLO 的輸出結果會轉換成一個資料框（DataFrame），這裡我們取得第一個 DataFrame。
for _, row in detected_objects.iterrows(): 這個迴圈遍歷每個被辨識到的物件。假設胎壓有一個特定的標籤 "tire_pressure"，當辨識到這個標籤時，取得相對應的信心度，並轉換成胎壓值。
print(f"辨識出的胎壓: {tire_pressure} psi"): 最後將辨識出的胎壓值打印出來。

2. LSTM 部分

這部分用於根據歷史胎壓數據，通過 LSTM 模型來預測下一次胎壓的變化，進而決定何時需要更換輪胎。

import numpy as np
import torch
import torch.nn as nn
from sklearn.preprocessing import MinMaxScaler

# 創建一些示例數據
data = np.array([28.5, 28.7, 28.9, 29.0, 28.8, 28.5, 28.3])  # 假設這是歷史胎壓數據
scaler = MinMaxScaler(feature_range=(0, 1))
data_normalized = scaler.fit_transform(data.reshape(-1, 1))

# 構建 LSTM 模型
class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_layer_size=50, output_size=1):
        super(LSTMModel, self).__init__()
        self.hidden_layer_size = hidden_layer_size
        self.lstm = nn.LSTM(input_size, hidden_layer_size, batch_first=True)
        self.linear = nn.Linear(hidden_layer_size, output_size)
        self.hidden_cell = (torch.zeros(1, 1, self.hidden_layer_size),
                            torch.zeros(1, 1, self.hidden_layer_size))

    def forward(self, input_seq):
        lstm_out, self.hidden_cell = self.lstm(input_seq, self.hidden_cell)
        predictions = self.linear(lstm_out[:, -1])
        return predictions

# 創建模型實例
model = LSTMModel()

# 構建序列數據
def create_inout_sequences(input_data, seq_length):
    inout_seq = []
    for i in range(len(input_data) - seq_length):
        seq = input_data[i:i + seq_length]
        label = input_data[i + seq_length]
        inout_seq.append((seq, label))
    return inout_seq

seq_length = 3
train_inout_seq = create_inout_sequences(torch.FloatTensor(data_normalized).view(-1), seq_length)

# 訓練模型
loss_function = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

epochs = 150
for epoch in range(epochs):
    for seq, labels in train_inout_seq:
        optimizer.zero_grad()
        model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
                             torch.zeros(1, 1, model.hidden_layer_size))

        y_pred = model(seq.view(1, -1, 1))
        single_loss = loss_function(y_pred, labels)
        single_loss.backward()
        optimizer.step()

    if epoch % 25 == 0:
        print(f'epoch: {epoch:3} loss: {single_loss.item():10.8f}')

# 預測下一次換輪胎的時間（假設這是時間序列預測的一部分）
model.eval()
with torch.no_grad():
    test_seq = torch.FloatTensor(data_normalized[-seq_length:]).view(1, -1, 1)
    predicted_pressure = model(test_seq)
    predicted_pressure = scaler.inverse_transform(predicted_pressure.numpy())

print(f"預測的下一次胎壓值: {predicted_pressure[0][0]} psi")

說明：

import numpy as np: 載入 NumPy 庫，用來處理數據。
import torch, torch.nn as nn: 載入 PyTorch 及其神經網絡模組。
from sklearn.preprocessing import MinMaxScaler: 載入 Scikit-learn 的 MinMaxScaler，用來將數據縮放到 [0, 1] 範圍內。
data = np.array([...])：建立一組示例的歷史胎壓數據。
scaler = MinMaxScaler(...): 使用 MinMaxScaler 來標準化數據，這有助於 LSTM 的訓練。
data_normalized = scaler.fit_transform(...): 將數據進行標準化。
class LSTMModel(nn.Module): 這段代碼定義了一個簡單的 LSTM 模型，包括 LSTM 層和線性層。
- init(): 初始化模型的屬性，設置 LSTM 層的大小和線性層的輸出大小。
- forward(): 定義模型的前向傳播過程。LSTM 處理輸入的序列數據，然後通過線性層進行預測。
model = LSTMModel(): 創建 LSTM 模型的實例。
def create_inout_sequences(...): 這個函數用來將數據分成序列，用於 LSTM 的訓練。每個序列包含 seq_length 個連續的胎壓數據點，並預測下一個數據點。
seq_length = 3: 設置序列長度，即每次輸入 LSTM 模型的數據點數量。
train_inout_seq = create_inout_sequences(...): 生成訓練數據。
loss_function = nn.MSELoss(): 定義損失函數，這裡使用均方誤差（MSE）。
optimizer = torch.optim.Adam(...): 使用 Adam 優化器來更新模型權重。
epochs = 150: 設定訓練模型的回合數。
for epoch in range(epochs): ...: 訓練過程的主迴圈。每個 epoch 會遍歷整個數據集，並調整模型的權重以最小化損失。
model.eval(): 將模型設置為評估模式。
with torch.no_grad(): 在不計算梯度的上下文中進行推論，以節省內存。
predicted_pressure = model(test_seq): 使用 LSTM 模型進行預測。
predicted_pressure = scaler.inverse_transform(...): 將預測結果轉換回原始的胎壓值。