Penerapan Model Pembelajaran Mesin sebagai Apl Web menggunakan Streamlit

pengenalan

Model pembelajaran mesin pada asasnya ialah satu set peraturan atau mekanisme yang digunakan untuk membuat ramalan atau mencari corak dalam data. Untuk meletakkannya dengan sangat mudah (dan tanpa rasa takut akan terlalu dipermudahkan), garis arah aliran yang dikira menggunakan kaedah kuasa dua terkecil dalam Excel juga merupakan model. Walau bagaimanapun, model yang digunakan dalam aplikasi sebenar tidak begitu mudah—ia selalunya melibatkan persamaan dan algoritma yang lebih kompleks, bukan hanya persamaan mudah.

Dalam siaran ini, saya akan bermula dengan membina model pembelajaran mesin yang sangat mudah dan mengeluarkannya sebagai apl web yang sangat mudah untuk merasakan proses tersebut.

Di sini, saya hanya akan menumpukan pada proses, bukan model ML itu sendiri. Juga saya akan menggunakan Streamlit dan Streamlit Community Cloud untuk mengeluarkan aplikasi web Python dengan mudah.

TL;DR:

Menggunakan scikit-learn, perpustakaan Python yang popular untuk pembelajaran mesin, anda boleh melatih data dengan cepat dan mencipta model dengan hanya beberapa baris kod untuk tugasan mudah. Model itu kemudiannya boleh disimpan sebagai fail boleh guna semula dengan joblib. Model yang disimpan ini boleh diimport/dimuatkan seperti perpustakaan Python biasa dalam aplikasi web, membenarkan apl membuat ramalan menggunakan model terlatih!

URL Apl: https://yh-machine-learning.streamlit.app/
GitHub: https://github.com/yoshan0921/yh-machine-learning.git

Timbunan Teknologi

• Python
• Strim: Untuk mencipta antara muka aplikasi web.
• pembelajaran scikit: Untuk memuatkan dan menggunakan model Random Forest terlatih.
• NumPy & Pandas: Untuk manipulasi dan pemprosesan data.
• Matplotlib & Seaborn: Untuk menjana visualisasi.

Apa yang Saya Buat

Apl ini membolehkan anda memeriksa ramalan yang dibuat oleh model hutan rawak yang dilatih pada dataset Palmer Penguin. (Lihat penghujung artikel ini untuk mendapatkan butiran lanjut tentang data latihan.)

Secara khusus, model meramalkan spesies penguin berdasarkan pelbagai ciri, termasuk spesies, pulau, panjang paruh, panjang sirip, saiz badan dan jantina. Pengguna boleh menavigasi apl untuk melihat cara ciri berbeza mempengaruhi ramalan model.

• Skrin Ramalan
  

• Skrin Data/Visualisasi Pembelajaran
  

Langkah Pembangunan1 - Mencipta Model

Langkah1.1 Import Perpustakaan

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import joblib

pandas ialah perpustakaan Python khusus dalam manipulasi dan analisis data. Ia menyokong pemuatan data, prapemprosesan dan penstrukturan menggunakan DataFrames, menyediakan data untuk model pembelajaran mesin.
sklearn ialah perpustakaan Python yang komprehensif untuk pembelajaran mesin yang menyediakan alatan untuk latihan dan penilaian. Dalam siaran ini, saya akan membina model menggunakan kaedah pembelajaran yang dipanggil Random Forest.
joblib ialah pustaka Python yang membantu menyimpan dan memuatkan objek Python, seperti model pembelajaran mesin, dengan cara yang sangat cekap.

Langkah1.2 Baca Data

df = pd.read_csv("./dataset/penguins_cleaned.csv")
X_raw = df.drop("species", axis=1)
y_raw = df.species

Muatkan set data (data latihan) dan pisahkan kepada ciri (X) dan pembolehubah sasaran (y).

Langkah1.3 Mengekodkan Pembolehubah Kategori

encode = ["island", "sex"]
X_encoded = pd.get_dummies(X_raw, columns=encode)

target_mapper = {"Adelie": 0, "Chinstrap": 1, "Gentoo": 2}
y_encoded = y_raw.apply(lambda x: target_mapper[x])

Pembolehubah kategori ditukar kepada format berangka menggunakan pengekodan satu panas (X_encoded). Sebagai contoh, jika "pulau" mengandungi kategori "Biscoe", "Dream" dan "Torgersen", lajur baharu dibuat untuk setiap satu (island_Biscoe, island_Dream, island_Torgersen). Perkara yang sama dilakukan untuk seks. Jika data asal ialah "Biscoe", lajur island_Biscoe akan ditetapkan kepada 1 dan yang lain kepada 0.
Spesies pembolehubah sasaran dipetakan kepada nilai berangka (y_encoded).

Langkah1.4 Pisahkan Set Data

x_train, x_test, y_train, y_test = train_test_split(
    X_encoded, y_encoded, test_size=0.3, random_state=1
)

Untuk menilai model, adalah perlu untuk mengukur prestasi model pada data yang tidak digunakan untuk latihan. 7:3 digunakan secara meluas sebagai amalan umum dalam pembelajaran mesin.

Langkah1.5 Latih Model Hutan Rawak

clf = RandomForestClassifier()
clf.fit(x_train, y_train)

Kaedah fit digunakan untuk melatih model.
X_train mewakili data latihan untuk pembolehubah penjelasan, dan y_train mewakili pembolehubah sasaran.
Dengan memanggil kaedah ini, model yang dilatih berdasarkan data latihan disimpan dalam clf.

Langkah1.6 Simpan Model

joblib.dump(clf, "penguin_classifier_model.pkl")

joblib.dump() ialah fungsi untuk menyimpan objek Python dalam format binari. Dengan menyimpan model dalam format ini, model boleh dimuatkan daripada fail dan digunakan sebagaimana adanya tanpa perlu dilatih lagi.

Kod Contoh

Development Step2 - Building the Web App and Integrating the Model

Step2.1 Import Libraries

import streamlit as st
import numpy as np
import pandas as pd
import joblib

stremlit is a Python library that makes it easy to create and share custom web applications for machine learning and data science projects.
numpy is a fundamental Python library for numerical computing. It provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays efficiently.

Step2.2 Retrieve and encode input data

data = {
    "island": island,
    "bill_length_mm": bill_length_mm,
    "bill_depth_mm": bill_depth_mm,
    "flipper_length_mm": flipper_length_mm,
    "body_mass_g": body_mass_g,
    "sex": sex,
}
input_df = pd.DataFrame(data, index=[0])

encode = ["island", "sex"]
input_encoded_df = pd.get_dummies(input_df, prefix=encode)

Input values are retrieved from the input form created by Stremlit, and categorical variables are encoded using the same rules as when the model was created. Note that the order of each data must also be the same as when the model was created. If the order is different, an error will occur when executing a forecast using the model.

Step2.3 Load the Model

clf = joblib.load("penguin_classifier_model.pkl")

"penguin_classifier_model.pkl" is the file where the previously saved model is stored. This file contains a trained RandomForestClassifier in binary format. Running this code loads the model into clf, allowing you to use it for predictions and evaluations on new data.

Step2.4 Perform prediction

prediction = clf.predict(input_encoded_df)
prediction_proba = clf.predict_proba(input_encoded_df)

clf.predict(input_encoded_df): Uses the trained model to predict the class for the new encoded input data, storing the result in prediction.
clf.predict_proba(input_encoded_df): Calculates the probability for each class, storing the results in prediction_proba.

Sample Code

Step3. Deploy

You can publish your developed application on the Internet by accessing the Stremlit Community Cloud (https://streamlit.io/cloud) and specifying the URL of the GitHub repository.

About Data Set

Artwork by @allison_horst (https://github.com/allisonhorst)

The model is trained using the Palmer Penguins dataset, a widely recognized dataset for practicing machine learning techniques. This dataset provides information on three penguin species (Adelie, Chinstrap, and Gentoo) from the Palmer Archipelago in Antarctica. Key features include:

• Species: The species of the penguin (Adelie, Chinstrap, Gentoo).
• Island: The specific island where the penguin was observed (Biscoe, Dream, Torgersen).
• Bill Length: The length of the penguin's bill (mm).
• Bill Depth: The depth of the penguin's bill (mm).
• Flipper Length: The length of the penguin's flipper (mm).
• Body Mass: The mass of the penguin (g).
• Sex: The sex of the penguin (male or female).

This dataset is sourced from Kaggle, and it can be accessed here. The diversity in features makes it an excellent choice for building a classification model and understanding the importance of each feature in species prediction.

Atas ialah kandungan terperinci Penerapan Model Pembelajaran Mesin sebagai Apl Web menggunakan Streamlit. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!