Meramalkan kecekapan bahan api menggunakan Tensorflow dalam Python

Meramalkan kecekapan bahan api adalah penting untuk mengoptimumkan prestasi kenderaan dan mengurangkan pelepasan karbon, dan ini boleh diramalkan dengan mudah menggunakan perpustakaan Python Tensorflow. Dalam artikel ini, kami akan meneroka cara memanfaatkan kuasa perpustakaan pembelajaran mesin popular Tensorflow untuk meramalkan kecekapan bahan api menggunakan Python. Dengan membina model ramalan berdasarkan set data Auto MPG, kami boleh menganggarkan kecekapan bahan api kenderaan dengan tepat. Mari kita mendalami proses membuat ramalan kecekapan bahan api yang tepat menggunakan Tensorflow dalam Python.

Set Data MPG automatik

Untuk meramalkan kecekapan bahan api dengan tepat, kami memerlukan set data yang boleh dipercayai. Dataset Auto MPG berasal daripada Repositori Pembelajaran Mesin UCI dan menyediakan maklumat yang diperlukan untuk model kami. Ia mengandungi pelbagai sifat seperti bilangan silinder, anjakan, berat, kuasa kuda, pecutan, negara asal dan tahun model. Atribut ini berfungsi sebagai ciri, manakala kecekapan bahan api (diukur dalam batu per gelen, atau MPG) berfungsi sebagai label. Dengan menganalisis set data ini, kami boleh melatih model untuk mengenali corak dan membuat ramalan berdasarkan ciri kenderaan yang serupa.

Sediakan set data

Sebelum membina model ramalan, kita perlu menyediakan set data. Ini melibatkan pengendalian nilai yang hilang dan menormalkan ciri. Nilai yang tiada boleh mengganggu proses latihan, jadi kami mengalih keluarnya daripada set data. Ciri standard seperti kuasa kuda dan berat memastikan setiap ciri berada dalam julat yang sama. Langkah ini penting kerana ciri dengan julat berangka yang besar boleh mendominasi proses pembelajaran model. Menormalkan set data memastikan semua ciri dilayan secara adil semasa latihan.

Bagaimana untuk meramalkan kecekapan bahan api menggunakan TensorFlow?

Berikut adalah langkah yang akan kami ikuti untuk meramal kecekapan bahan api menggunakan Tensorflow -

• Import perpustakaan yang diperlukan - kami mengimport aliran tensor, Keras, lapisan dan panda.

• Muat set data MPG Auto. Kami juga menentukan nama lajur dan mengendalikan sebarang nilai yang hilang.

• Pisah set data kepada ciri dan label - Kami bahagikan set data kepada dua bahagian - ciri (pembolehubah input) dan label (pembolehubah output).

• Ciri dinormalkan - Kami menggunakan penskalaan min-maks untuk menormalkan ciri.

• Set data dibahagikan kepada set latihan dan set ujian.

• Tentukan seni bina model - Kami mentakrifkan model berjujukan ringkas dengan tiga lapisan padat, dengan 64 neuron setiap lapisan dan menggunakan fungsi pengaktifan ReLU.

• Kompilasi model - Kami menyusun model menggunakan fungsi kehilangan ralat kuasa dua (MSE) dan pengoptimum RMSprop.

• Latih model - Latih model selama 1000 zaman pada set latihan dan nyatakan pembahagian pengesahan 0.2.

• Nilai model - Lakukan penilaian model pada set ujian dan kira purata MSE serta kecekapan bahan api dan ralat mutlak (MAE).

• Kira kecekapan bahan api kereta baharu - Kami menggunakan DataFrame panda untuk mencipta fungsi bagi kereta baharu. Kami menormalkan ciri kereta baharu menggunakan faktor penskalaan yang sama seperti set data asal.

• Ramalkan kecekapan bahan api kereta baharu menggunakan model terlatih.

• Cetak Kecekapan Bahan Api Diramalkan - Kami mencetak ramalan kecekapan bahan api kereta baharu ke konsol

• Cetak metrik ujian - Kami mencetak ujian MAE dan MSE ke konsol.

Atur cara di bawah menggunakan Tensorflow untuk membina model rangkaian saraf untuk meramalkan kecekapan bahan api berdasarkan set data Auto MPG.

Contoh

# Import necessary libraries
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import pandas as pd

# Load the Auto MPG dataset
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data"
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
   'Acceleration', 'Model Year', 'Origin']
raw_dataset = pd.read_csv(url, names=column_names,
   na_values='?', comment='\t', sep=' ', skipinitialspace=True)

# Drop missing values
dataset = raw_dataset.dropna()

# Separate the dataset into features and labels
cfeatures = dataset.drop('MPG', axis=1)
labels = dataset['MPG']

# Normalize the features using min-max scaling
normalized_features = (cfeatures - cfeatures.min()) / (cfeatures.max() - cfeatures.min())

# Split the dataset into training and testing sets
train_features = normalized_features[:300]
test_features = normalized_features[300:]
train_labels = labels[:300]
test_labels = labels[300:]

# Define the model architecture for this we will use sequential API of the keras
model1 = keras.Sequential([
   layers.Dense(64, activation='relu', input_shape=[len(train_features.keys())]),
   layers.Dense(64, activation='relu'),
   layers.Dense(1)
])
#if you want summary of the model’s architecture you can use the code: model1.summary()

# Model compilation
optimizer = tf.keras.optimizers.RMSprop(0.001)
model1.compile(loss='mse', optimizer=optimizer, metrics=['mae', 'mse'])

# Train the model
Mhistory = model1.fit(
   train_features, train_labels,
   epochs=1000, validation_split = 0.2, verbose=0)

# Evaluate the model on the test set
test_loss, test_mae, test_mse = model1.evaluate(test_features, test_labels)
# Train the model
model1.fit(train_features, train_labels, epochs=1000, verbose=0)

# Calculation of the fuel efficiency for a new car
new_car_features = pd.DataFrame([[4, 121, 110, 2800, 15.4, 81, 3]], columns=column_names[1:])

normalized_new_car_features = (new_car_features - cfeatures.min()) / (cfeatures.max() - cfeatures.min())
fuel_efficiencyc = model1.predict(normalized_new_car_features)

# Print the test metrics
print("Test MAE:", test_mae)
print("Test MSE:", test_mse)
print("Predicted Fuel Efficiency:", fuel_efficiencyc[0][0])

Output

C:\Users\Tutorialspoint>python image.py
3/3 [==============================] - 0s 2ms/step - loss: 18.8091 - mae: 3.3231 - mse: 18.8091
1/1 [==============================] - 0s 90ms/step
Test MAE: 3.3230929374694824
Test MSE: 18.80905532836914
Predicted Fuel Efficiency: 24.55885

Kesimpulan

Ringkasnya, meramalkan kecekapan bahan api menggunakan Tensorflow dalam Python ialah alat berkuasa yang boleh membantu pengeluar dan pengguna membuat keputusan termaklum. Dengan menganalisis pelbagai ciri kenderaan dan melatih model rangkaian saraf, kami boleh meramalkan kecekapan bahan api dengan tepat.

Maklumat ini boleh menggalakkan pembangunan kenderaan yang lebih cekap tenaga, mengurangkan kesan alam sekitar dan menjimatkan kos untuk pengguna. Fleksibiliti dan kemudahan penggunaan Tensorflow menjadikannya aset berharga kepada industri automotif dalam usahanya untuk meningkatkan kecekapan bahan api.

Atas ialah kandungan terperinci Meramalkan kecekapan bahan api menggunakan Tensorflow dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!