Dalam industri restoran yang kompetitif, memahami dan mengoptimalkan profitabilitas menu adalah kunci kesuksesan. Pengelola restoran perlu mengetahui item mana yang memberikan keuntungan tertinggi dan mana yang mungkin perlu diperbaiki atau dihapus dari menu. Untuk membantu dalam analisis ini, dataset Predict Restaurant Menu Items Profitability menyediakan informasi berharga mengenai berbagai aspek menu restoran.
Dataset ini bertujuan untuk membantu restoran memaksimalkan profitabilitas dengan menganalisis berbagai kategori item menu, bahan makanan yang digunakan, harga yang ditetapkan, serta indikator profitabilitas lainnya. Dengan data ini, pemilik dan manager restoran dapat membuat keputusan yang lebih baik dan terinformasi mengenai penyusunan menu mereka.
Berikut merupakan fitur-fitur yang terdapat dalam dataset ini:
- RestaurantID : Pengenal restoran.
- MenuCategory : Kategori item menu (Appetizers , Main Course, Desserts, Beverage)
- MenuItem : Nama item menu.
- Ingredients : Daftar bahan yang digunakan dalam item menu (data rahasia disertakan untuk minuman).
- Price : Harga item menu dalam dolar (dibulatkan ke dua angka di belakang koma).
- Profitability : Variabel target yang menunjukkan profitabilitas item menu (Low, Medium, High).
Dataset ini relevan untuk mengatasi masalah yang dihadapi restoran, yaitu bagaimana mengoptimalkan menu dan harga untuk memaksimalkan keuntungan. Dataset ini berisi berbagai fitur yang dapat digunakan untuk membangun model machine learning yang memprediksi profitabilitas berdasarkan faktor-faktor seperti kategori menu, bahan makanan, dan harga. Dengan informasi ini, kita dapat mengeksplorasi wawasan menarik tentang bagaimana pilihan menu yang berbeda memengaruhi keuntungan restoran. Analisis faktor-faktor yang memengaruhi profitabilitas item menu, optimasi strategi penetapan harga berdasarkan biaya bahan dan kategori menu, serta pemahaman terhadap preferensi pelanggan dan perilaku pembelian dapat dilakukan. Aplikasi dari dataset ini ideal untuk manajemen restoran, strategi pemasaran, rekayasa menu, dan pengambilan keputusan berbasis data di industri perhotelan.
Sebelum memulai analisis data lebih lanjut, penting untuk melakukan Exploratory Data Analysis (EDA) terlebih dahulu. Hal ini mampu memberikan pemahaman mendalam tentang dataset Predict Restaurant Menu Items dan membantu mengarahkan analisis lebih lanjut.
Berdasarkan dataset Predict Restaurant Menu Items, terlihat bahwa restoran memiliki variasi menu yang cukup seimbang antara Beverages, Appetizers dan Desserts, dengan fokus yang sedikit lebih kecil pada Main Course. Hal ini dapat mengindikasikan beberapa hal, seperti adanya strategi restoran untuk menawarkan pilihan menu yang lebih banyak pada kategori Beverages dan Appetizers untuk menarik pelanggan, atau mungkin menunjukkan tingkat permintaan yang lebih tinggi untuk jenis menu tersebut.
Dapat diketahui bahwa restoran berhasil menawarkan variasi menu yang luas dengan fokus yang kuat pada Beverages dan Appetizers. Meskipun Main Course memiliki frekuensi keseluruhan yang lebih rendah, beberapa hidangan utama tetap sangat diminati. Hal ini menunjukkan bahwa strategi restoran dalam menawarkan berbagai pilihan menu telah berhasil memenuhi preferensi pelanggan dan menciptakan keseimbangan yang baik antara berbagai kategori menu.
Distribusi harga menunjukkan bahwa sebagian besar harga berkisar antara 2 hingga 30 dolar. Sebagian besar pembeli cenderung memilih harga yang lebih murah. Hal ini ditunjukkan oleh frekuensi tinggi pada rentang harga yang lebih rendah. Seiring dengan meningkatnya harga, frekuensi pembelian menurun. Artinya, semakin tinggi harga, semakin sedikit jumlah pembelian yang terjadi. Secara keseluruhan, dataset Predict Restaurant Menu Items menunjukkan bahwa item menu dengan harga murah lebih banyak dibeli oleh konsumen, sementara item menu dengan harga lebih tinggi cenderung dibeli lebih sedikit. Hal ini bisa mengindikasikan preferensi konsumen terhadap item menu yang lebih murah atau adanya batasan anggaran yang membuat pembeli cenderung memilih barang dengan harga lebih rendah.
Perbedaan harga berdasarkan kategori profitabilitas akan mengindikasikan bahwa item menu dengan profitabilitas yang lebih tinggi cenderung memiliki harga yang lebih tinggi. Item menu dengan profitabilitas rendah cenderung memiliki harga yang lebih rendah dan lebih konsisten, sedangkan item menu dengan profitabilitas tinggi menunjukkan variasi harga yang lebih besar dan median harga yang lebih tinggi. Maka dari itu restoran mungkin menetapkan harga yang lebih tinggi untuk item menu yang dianggap lebih menguntungkan. Dengan menetapkan harga yang lebih tinggi pada item menu yang lebih menguntungkan, restoran dapat meningkatkan margin keuntungan mereka dan memaksimalkan pendapatan dari penjualan item menu tersebut.
Pada dataset Predict Restaurant Menu Items, secara keseluruhan restoran berhasil menawarkan variasi menu yang luas dengan fokus kuat pada kategori Beverages dan Appetizers, yang sangat diminati pelanggan. Meskipun Main Course memiliki frekuensi lebih rendah, beberapa item tetap populer. Distribusi harga menunjukkan bahwa item menu dengan harga lebih murah lebih banyak dibeli, sementara item dengan harga lebih tinggi cenderung dibeli lebih sedikit. Analisis profitabilitas menunjukkan bahwa item dengan harga dan profitabilitas lebih tinggi memiliki variasi harga yang lebih besar.
Berdasarkan penjelasan diatas, analisis lebih lanjut dapat difokuskan pada profitabilitas item menu. Analisis yang dapat dilakukan yaitu segmentasi item menu berdasarkan profitabilitas, yang akan mengklasifikasikan item menu ke dalam kategori profitabilitas rendah, sedang, dan tinggi. Dengan melakukan analisis lanjutan ini, restoran dapat membuat keputusan yang lebih cerdas tentang penetapan harga dan pengelolaan menu, yang pada akhirnya akan membantu dalam meningkatkan margin keuntungan dan kepuasan pelanggan.
Sebelum melakukan analisis perlu dilakukan pra-pemrosesan dataset. Pra-pemrosesan data adalah tahap penting dalam analisis data dan pengembangan model machine learning. Langkah-langkah ini membantu memastikan bahwa data yang digunakan dalam model bersih, lengkap, dan dalam format yang tepat. Berikut pra-pemrosesan dataset yang dapat dilakukan.
Pertama, memeriksa dan menangani nilai yang hilang (Missing Values). Dapat dilakukan dengan mengidentifikasi kolom atau baris yang memiliki nilai yang hilang, kemudian jika ada nilai yang hilang dapat diatasi dengan menghapus baris atau kolom dan mengisi nilai yang hilang dengan rata-rata, median, modus, atau menggunakan teknik imputasi lainnya.
print(df.isnull().sum())
RestaurantID 0
MenuCategory 0
MenuItem 0
Ingredients 0
Price 0
Profitability 0
dtype: int64
Dari hasil pemeriksaan nilai yang hilang, terlihat bahwa tidak ada nilai yang hilang dalam dataset ini. Setiap kolom memiliki nol nilai yang hilang, sehingga kita tidak perlu melakukan langkah-langkah khusus untuk mengatasi nilai yang hilang.
Kedua, menghapus data yang tidak digunakan. Langkah ini sering kali disebut sebagai seleksi fitur. Menghapus fitur yang tidak relevan atau tidak berkontribusi signifikan terhadap model dapat mengurangi kompleksitas model, membuat lebih mudah untuk diinterpretasikan dan dipelihara. Fitur yang tidak relevan atau noise dalam data dapat mengganggu proses pelatihan model dan mengurangi akurasinya. Dengan menghapus fitur tersebut, model dapat lebih fokus pada fitur yang benar-benar penting. Pada dataset ini menghapus fitur RestaurantID dan Ingredients.
df.drop(['RestaurantID'] , axis = 1 , inplace = True)
df.drop(['Ingredients'] , axis = 1 , inplace = True)
Menghapus dua fitur terebut, karena pada fitur Restaurants ID sebagai pengenal unik untuk restoran dan tidak memberikan informasi yang bermanfaat untuk analisis atau model machine learning. Dalam banyak kasus, ID unik ini tidak memiliki nilai prediktif. Fitur Ingredients
kemungkinan berisi teks deskriptif yang mencantumkan bahan-bahan dari setiap item menu. Teks ini dapat sangat bervariasi dan memiliki dimensi tinggi, yang membuatnya sulit untuk diproses tanpa langkah tambahan seperti teknik pemrosesan teks (NLP). Hal ini membantu mengurangi noise, meningkatkan efisiensi, dan fokus pada fitur-fitur yang langsung berkaitan dengan tujuan analisis.
Ketiga, pengkodean variable kategori. Pengkodean variabel kategori adalah proses mengubah data kategorikal menjadi format numerik yang dapat digunakan oleh algoritma machine learning untuk membuat data lebih cocok untuk analisis. Terlebuh dahulu melakukan pengelompokan dengan mengubah nilai di fitur MenuItem menjadi label yang lebih sederhana berdasarkan nilai di fitur MenuCategory.
for i in range(df.shape[0]):
if df.loc[i , 'MenuCategory'] == 'Beverages':
df.loc[i , 'MenuItem'] = 'A'
elif df.loc[i , 'MenuCategory'] == 'Appetizers':
df.loc[i , 'MenuItem'] = 'B'
elif df.loc[i , 'MenuCategory'] == 'Desserts':
df.loc[i , 'MenuItem'] = 'C'
else:
df.loc[i , 'MenuItem'] = 'D'
Selanjutnya melakukan encoding pada kolom-kolom kategori untuk mengubahnya menjadi format numerik yang dapat digunakan oleh model machine learning dengan menggunakan LabelEncoder. Dalam hal ini fitur MenuCategory, MenuItem, dan Profitability diubah menjadi format numerik.
from sklearn.preprocessing import LabelEncoderencoder = LabelEncoder()
df['MenuCategory'] = encoder.fit_transform(df['MenuCategory'])
df['MenuItem'] = encoder.fit_transform(df['MenuItem'])
df['Profitability'] = encoder.fit_transform(df['Profitability'])
Melakukan pengelompokan bertujuan untuk membantu menyederhanakan nilai kategori menjadi label yang lebih sederhana, yang dapat membuat proses encoding lebih efektif dan data lebih mudah dianalisis. Encoding sendiri bertujuan untuk mengubah nilai kategori menjadi numerik, memungkinkan model machine learning untuk memahami dan menggunakan data tersebut. Dengan melakukan kedua langkah ini, dataset menjadi lebih terstruktur dan siap untuk analisis atau digunakan dalam pengembangan model machine learning. Berikut bentuk dataset yang sudah siap dilakukan analisis menggunakan model machine learning.
Setelah melakukan pra-pemrosesan dataset, selanjutnya melakukan analisis menggunakan model machine learning. Pertama memisahkan variabel target (y) dari fitur-fitur independen (x). Dalam analisis ini akan melakukan prediksi pada profitabilitas, maka yang menjadi variabel target adalah fitur Profitability.
y = df['Profitability']
X = df.drop('Profitability' , axis = 1)
Langkah selanjutnya adalah membagi dataset menjadi pelatihan dan pengujian. Pelatihan digunakan untuk melatih model, sementara pengujian digunakan untuk mengevaluasi performa model dan memastikan bahwa model dapat menggeneralisasi dengan baik pada data baru.
from sklearn.model_selection import train_test_split# Pembagian data
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2,
random_state=42)
Model machine learning yang dapat digunakan untuk klasifikasi pada fitur Profitability dalam dataset Predict Restaurant Menu Items meliputi Decision Tree, SVM, dan KNN. Model Decision Tree mudah diinterpretasikan dan divisualisasikan karena strukturnya yang berbentuk pohon memungkinkan kita memahami bagaimana keputusan diambil berdasarkan fitur-fitur input. Algoritma ini tidak memerlukan normalisasi atau standarisasi fitur, sehingga mengurangi kebutuhan pra-pemrosesan tambahan. Selain itu, Decision Tree dapat menangani fitur kategorikal dan numerik dengan baik, membuatnya cocok untuk dataset yang memiliki campuran tipe data seperti Predict Restaurant Menu Items.
Model Support Vector Machine (SVM) efektif pada ruang dimensi tinggi dan sangat berguna ketika jumlah fitur lebih besar daripada jumlah sampel. SVM bekerja dengan mencari hyperplane yang memaksimalkan margin antara kelas-kelas, yang dapat menghasilkan kinerja klasifikasi yang baik. Model ini juga mendukung kernel trick, yang memungkinkan pemrosesan data non-linier dengan mengubahnya ke dalam ruang fitur yang lebih tinggi. SVM biasanya robust terhadap overfitting, terutama dalam skenario di mana jumlah fitur jauh lebih besar daripada jumlah sampel.
Model K-Nearest Neighbors (KNN) adalah algoritma yang sederhana namun efektif. KNN bekerja berdasarkan premis bahwa data yang serupa cenderung berada dekat satu sama lain dalam ruang fitur. Tidak ada fase pelatihan eksplisit, sehingga cepat diimplementasikan. Proses pengambilan keputusan terjadi selama fase prediksi. KNN cenderung bekerja dengan baik pada dataset yang relatif kecil, di mana komputasi jarak tidak menjadi masalah besar. Dengan penanganan yang tepat, KNN dapat digunakan untuk fitur kategorikal dengan mengukur kesamaan atau jarak kategori.
Menggunakan Decision Tree, SVM, dan KNN pada dataset Predict Restaurant Menu Items adalah pilihan yang tepat karena model-model ini mampu menangani fitur kategorikal dan numerik dengan baik, memberikan interpretasi yang jelas, serta menawarkan fleksibilitas dalam menangani data dengan berbagai tingkat kompleksitas. Dengan implementasi yang tepat, kita dapat mengevaluasi dan memilih model terbaik untuk memprediksi profitabilitas item menu secara efektif. Berikut adalah model klasifikasi yang diterapkan untuk analisis.
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifiermodels = {
'Decision Tree': DecisionTreeClassifier(random_state=42),
'SVM': SVC(random_state=42),
'KNN': KNeighborsClassifier()
}
def evaluate_model(model, X_train, y_train, X_test, y_test):
"""Trains, evaluates, and returns performance metrics for a given model."""
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')
return accuracy, precision, recall, f1
Tuning hyperparameter adalah langkah penting dalam membangun model machine learning karena hyperparameter yang tepat dapat sangat mempengaruhi kinerja model. Hyperparameter adalah parameter yang tidak dipelajari dari data, melainkan diatur secara manual sebelum proses pelatihan model dimulai.
results = {}
for model_name, model in models.items():
print(f"Tuning: {model_name}")
if model_name == 'Decision Tree':
param_grid = {
'criterion': ['gini', 'entropy'],
'max_depth': [None, 5, 10, 15],
'min_samples_split': [2, 5, 10]
}
elif model_name == 'SVM':
param_grid = {
'C': [0.1, 1, 10],
'kernel': ['linear', 'rbf'],
'gamma': ['scale', 'auto']
}
elif model_name == 'KNN':
param_grid = {
'n_neighbors': [3, 5, 7, 9],
'weights': ['uniform', 'distance'],
'metric': ['euclidean', 'manhattan']
}grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)
print(f"Best parameters: {grid_search.best_params_}")
Menyesuaikan hyperparameter membantu dalam mengoptimalkan kinerja model. Pada Decision Tree memilih criterion
yang tepat (misalnya gini
atau entropy
) dan mengatur max_depth
serta min_samples_split
membantu dalam menghindari overfitting atau underfitting, yang berdampak langsung pada akurasi model. Pada SVM menggunakan parameter C
, kernel
, dan gamma
mempengaruhi kemampuan model untuk menangani data yang tidak terpisahkan secara linier dan menyeimbangkan trade-off antara margin pemisahan dan kesalahan klasifikasi. Pada menggunakan parameter n_neighbors
, weights
, dan metric
mempengaruhi bagaimana model membuat prediksi berdasarkan tetangga terdekat dan dapat meningkatkan akurasi prediksi.
Kemudian hyperparameter yang di-tune dengan baik dapat meningkatkan kemampuan model untuk generalisasi pada data yang belum terlihat, yang penting untuk memastikan model tidak hanya menghafal data pelatihan. Serta tuning hyperparameter membantu menyesuaikan model dengan karakteristik unik dari dataset, sehingga model dapat memanfaatkan pola data yang relevan secara efektif.
Tuning: Decision Tree
Best parameters: {'criterion': 'entropy', 'max_depth': 5, 'min_samples_split': 10}
Tuning: SVM
Best parameters: {'C': 1, 'gamma': 'auto', 'kernel': 'rbf'}
Tuning: KNN
Best parameters: {'metric': 'euclidean', 'n_neighbors': 5, 'weights': 'uniform'}
Hasil diatas merupakan penggunaan GridSearchCV dari library sklearn. Menghasilkan kombinasi hyperparameter yang memberikan kinerja terbaik untuk model. Kemudian dapat melakukan evaluasi model terbaik yang ditemukan melalui proses GridSearchCV dan menyimpan metrik kinerja dari model tersebut.
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_scorebest_model = grid_search.best_estimator_
best_accuracy, precision, recall, f1 = evaluate_model(best_model, X_train, y_train, X_test, y_test)
results[model_name + ' (Tuned)'] = {'Accuracy': best_accuracy, 'Precision': precision, 'Recall': recall, 'F1-Score': f1}
Selanjutnya dapat melakukan evaluasi model terbaik yang telah di-tune menggunakan cross-validation. Hal ini dilakukan untuk mengevaluasi kinerjanya secara lebih menyeluruh dan mendapatkan estimasi akurasi yang lebih stabil.
from sklearn.model_selection import cross_val_scorecv_scores = cross_val_score(best_model, X, y, cv=5, scoring='accuracy')
results[model_name + ' (Tuned)']['Mean Accuracy'] = cv_scores.mean()
Dengan melakukan evaluasi model terbaik yang telah di-tune dapat memperoleh gambaran menyeluruh tentang kinerja model dengan evaluasi menyeluruh baik pada data pelatihan, data pengujian, dan estimasi kinerja secara umum melalui cross-validation. Selanjutnya dapat mengonversi hasil evaluasi model yang disimpan dalam dictionary results
ke dalam format DataFrame menggunakan pandas
. Ini memudahkan analisis dan visualisasi hasil model.
results_df = pd.DataFrame(results).T.reset_index()
results_df.columns = ['Model', 'Accuracy', 'Precision', 'Recall', 'F1-Score', 'Mean Accuracy']
print(results_df)
Dengan DataFrame ini, dapat dengan mudah membandingkan metrik kinerja antara berbagai model yang telah di-tune dan memilih model yang paling sesuai berdasarkan hasil evaluasi yang komprehensif.
Model Accuracy Precision Recall F1-Score Mean Accuracy
0 Decision Tree (Tuned) 0.870 0.868065 0.870 0.863700 0.910
1 SVM (Tuned) 0.895 0.893712 0.895 0.888263 0.915
2 KNN (Tuned) 0.905 0.902905 0.905 0.897901 0.912
Berdasarkan metrik kinerja pada model, maka model KNN merupakan model terbaik yang dapat digunakan untuk analisis klasifikasi pada fitur Profitability dalam dataset Predict Restaurant Menu Items. KNN dipilih sebagai model terbaik, karena memiliki nilai metrik yang paling tinggi dengan akurasi 0.905, precision 0.902905, recall 0.905, F1-Score 0.897901, dan mean accuracy sebesar 0.912.
Hal ini menunjukkan bahwa secara keseluruhan KNN membuat prediksi yang benar dan lebih mungkin membuat prediksi positif yang benar dibandingkan model lain. KNN juga mencapai keseimbangan terbaik antara precision dan recall, menjadikannya pilihan yang baik ketika penting untuk mempertimbangkan keduanya secara bersamaan. Dengan mempertimbangkan akurasi, precision, recall, dan F1-Score yang lebih tinggi, KNN tetap menjadi model terbaik secara keseluruhan. Grafik berikut menunjukkan bahwa KNN memiliki nilai yang lebih tinggi pada semua metrik dibandingkan dengan model lainnya.
Model K-Nearest Neighbors (KNN) dipilih untuk analisis klasifikasi pada fitur Profitability dalam dataset Predict Restaurant Menu Items. Model KNN ini akan digunakan untuk memprediksi profit item menu ke dalam kategori profitabilitas rendah, sedang, dan tinggi. Setelah model KNN berhasil dibuat dan diuji, langkah selanjutnya adalah men-deploy model tersebut agar dapat diakses dan digunakan oleh aplikasi atau sistem lain. PythonAnywhere adalah salah satu platform yang memungkinkan deploy model machine learning secara mudah dan efisien.
Pertama, membuat persamaan model klasifikasi dengan KNN dan disimpan dengan nama “model.py”. Membangun model KNN untuk klasifikasi profitabilitas item menu sama seperti penjelasan sebelumnya. Persamaan dari model klasifikasi ini tersimpan dalam “knnmodel.sav”.
# load data
import pandas as pd
import numpy as npdf = pd.read_csv('restaurant_menu_optimization_data.csv')
df.head()
# cek NA
print(df.isnull().sum())
# drop kolom yang tidak dibutuhkan
df.drop(['RestaurantID', 'Ingredients'], axis=1, inplace=True)
# Grouping
for i in range(df.shape[0]):
if df.loc[i, 'MenuCategory'] == 'Beverages':
df.loc[i, 'MenuItem'] = 'A'
elif df.loc[i, 'MenuCategory'] == 'Appetizers':
df.loc[i, 'MenuItem'] = 'B'
elif df.loc[i, 'MenuCategory'] == 'Desserts':
df.loc[i, 'MenuItem'] = 'C'
else:
df.loc[i, 'MenuItem'] = 'D'
# Encoding
from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
df['MenuCategory'] = encoder.fit_transform(df['MenuCategory'])
df['MenuItem'] = encoder.fit_transform(df['MenuItem'])
df['Profitability'] = encoder.fit_transform(df['Profitability'])
df.head()
# Pembagian data
y = df['Profitability']
X = df.drop('Profitability', axis=1)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
import matplotlib.pyplot as plt
# Model KNN
param_grid = {
'n_neighbors': [3, 5, 7, 9],
'weights': ['uniform', 'distance'],
'metric': ['euclidean', 'manhattan']
}
grid_search = GridSearchCV(estimator=KNeighborsClassifier(), param_grid=param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)
print(f"Best parameters: {grid_search.best_params_}")
# Evaluasi model KNN terbaik dari pencarian grid
best_model = grid_search.best_estimator_
best_model.fit(X_train, y_train)
y_pred = best_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')
cv_scores = cross_val_score(best_model, X, y, cv=5, scoring='accuracy')
# Simpan model
import pickle
filename = 'knnmodel.sav'
pickle.dump(best_model, open(filename, 'wb'))
Kedua, membuat file Flask untuk menyajikan model dan disimpan dengan nama “app.py”. Dalam hal ini menggunakan model KNN yang telah dilatih sebelumnya dan berisi prediksi kategori profitabilitas, dengan menggunakan data input dari pengguna untuk memprediksi apakah suatu item menu memiliki profitabilitas rendah, sedang, atau tinggi. Kemudian berisi mengenai pemetaan item menu dengan mengubah nama item menu menjadi nilai numerik yang dapat digunakan oleh model KNN.
from flask import Flask, request, render_template
import joblib
import numpy as npapp = Flask(__name__)
# Load the trained model using joblib
model = joblib.load('knnmodel.sav')
# Menu item mappings
menu_item_mapping = {
'Appetizers': {'Bruschetta': 0, 'Caprese Salad': 1, 'Spinach Artichoke Dip': 2, 'Stuffed Mushrooms': 3},
'Beverages': {'Coffee': 0, 'Iced Tea': 1, 'Lemonade': 2, 'Soda': 3},
'Desserts': {'Chocolate Lava Cake': 0, 'Fruit Tart': 1, 'New York Cheesecake': 2, 'Tiramisu': 3},
'Main Course': {'Chicken Alfredo': 0, 'Grilled Steak': 1, 'Shrimp Scampi': 2, 'Vegetable Stir-Fry': 3}
}
@app.route('/')
def home():
return render_template('index.html')
@app.route('/predict', methods=['POST'])
def predict():
if request.method == 'POST':
# Get data from form
MenuCategory = int(request.form['MenuCategory'])
MenuItem = request.form['MenuItem']
Price = float(request.form['Price'])
# Map MenuItem to integer
category_name = ['Appetizers', 'Beverages', 'Desserts', 'Main Course'][MenuCategory]
MenuItem_encoded = menu_item_mapping[category_name][MenuItem]
# Create feature array
features = np.array([[MenuCategory, MenuItem_encoded, Price]])
# Make prediction
prediction = model.predict(features)
output = ['Low', 'Medium', 'High'][prediction[0]]
return render_template('result.html', prediction_text=f'{output}')
@app.route('/menu_items', methods=['GET'])
def menu_items():
category = request.args.get('category')
items = {
'0': ['Bruschetta', 'Caprese Salad', 'Spinach Artichoke Dip', 'Stuffed Mushrooms'],
'1': ['Coffee', 'Iced Tea', 'Lemonade', 'Soda'],
'2': ['Chocolate Lava Cake', 'Fruit Tart', 'New York Cheesecake', 'Tiramisu'],
'3': ['Chicken Alfredo', 'Grilled Steak', 'Shrimp Scampi', 'Vegetable Stir-Fry']
}
return {'items': items.get(category, [])}
if __name__ == '__main__':
app.run(debug=True)
Ketiga, membuat file HTML. File HTML digunakan untuk menyediakan antarmuka pengguna (User Interface atau UI) yang interaktif dan dapat diakses melalui browser web. Untuk memprediksi profit item menu ke dalam kategori profitabilitas, dapat dibuat file HTML yang dirancang untuk memungkinkan pengguna memasukkan data mengenai item menu restoran. Halaman HTML ini akan menyediakan antarmuka bagi pengguna untuk memilih kategori menu, item menu, dan memasukkan harga. File HTML ini disimpan dengan nama “index.html”.
<!DOCTYPE html>
<html>
<head>
<title>Profit Dish Insight</title>
<style>
body {
font-family: 'Arial', sans-serif;
margin: 0;
padding: 0;
height: 100vh;
display: flex;
justify-content: center;
align-items: center;
background-image: url('
background-size: cover;
background-position: center;
background-repeat: no-repeat;
}.form-container {
background: rgba(0, 0, 0, 0.8);
padding: 40px 50px;
border-radius: 10px;
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
width: 300px;
position: relative;
z-index: 2;
}
.form-container h2 {
margin: 0 0 20px;
color: #fff;
text-align: center;
}
.form-container label {
margin: 10px 0 5px;
color: #fff;
display: block;
}
.form-container select,
.form-container input[type="text"] {
width: 100%;
padding: 10px;
margin: 8px 0;
border: none;
border-radius: 5px;
box-sizing: border-box;
}
.form-container input[type="submit"] {
width: 100%;
padding: 10px;
background-color: #fff;
color: #000;
border: none;
border-radius: 5px;
cursor: pointer;
font-size: 16px;
margin-top: 10px;
}
.form-container input[type="submit"]:hover {
background-color: #ddd;
}
</style>
<script>
function updateMenuItems() {
const category = document.getElementById('MenuCategory').value;
fetch(`/menu_items?category=${category}`)
.then(response => response.json())
.then(data => {
const menuItemSelect = document.getElementById('MenuItem');
menuItemSelect.innerHTML = '';
data.items.forEach(item => {
const option = document.createElement('option');
option.value = item;
option.textContent = item;
menuItemSelect.appendChild(option);
});
});
}
</script>
</head>
<body>
<div class="form-container">
<h2>Predict Menu Item Profitability</h2>
<form action="/predict" method="post">
<label for="MenuCategory">Menu Category:</label>
<select name="MenuCategory" id="MenuCategory" onchange="updateMenuItems()" required>
<option value="0">Appetizers</option>
<option value="1">Beverages</option>
<option value="2">Desserts</option>
<option value="3">Main Course</option>
</select>
<label for="MenuItem">Menu Item:</label>
<select name="MenuItem" id="MenuItem" required></select>
<label for="Price">Price:</label>
<input type="text" name="Price" id="Price" required>
<input type="submit" value="Predict">
</form>
</div>
</body>
</html>
Selanjutnya membuat file HTML yang menampilkan hasil prediksi profitabilitas dari item menu. Setelah pengguna mengisi formulir dan mengirimkan data untuk diprediksi, halaman ini akan menampilkan hasil prediksi. File HTML ini disimpan dengan nama “result.html”.
<!DOCTYPE html>
<html>
<head>
<title>Prediction Result</title>
<style>
body {
font-family: 'Arial', sans-serif;
margin: 0;
padding: 0;
height: 100vh;
display: flex;
justify-content: center;
align-items: center;
background: url(' no-repeat center center fixed; /* Ganti URL ini dengan gambar latar belakang tema restoran yang sesuai */
background-size: cover;
color: #fff;
}.result-container {
background: rgba(0, 0, 0, 0.8);
padding: 40px 50px;
border-radius: 10px;
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
text-align: center;
}
.result-container h2 {
margin: 0 0 20px;
}
.result-container a {
color: #000;
text-decoration: none;
background-color: #ddd;
padding: 10px 20px;
border-radius: 5px;
display: inline-block;
transition: background-color 0.3s ease;
}
.result-container a:hover {
background-color: #ddd;
}
</style>
</head>
<body>
<div class="result-container">
<h2>The Menu Item is Predicted Profitability</h2>
<h1>{{ prediction_text }}</h1>
<a href="/">Back to Home</a>
</div>
</body>
</html>
Keempat, deploy ke PythonAnywhere. Sebelumnya buat akun terlebih dahulu, kemudian add a new web app dan masuk ke mysite/. Selanjutnya upload a file, file yang dimasukan yaitu file model klasifikasi KNN model.py, hasil persamaan dari model klasifikasi knnmodel.sav, file Flask yang disimpan app.py dan dataset Predict Restaurant Menu Items restaurant_menu_optimization_data.csv.
Kemudian membuat directory baru dengan nama templates. Upload file HTML yang sudah dibuat yaitu index.html dan result.html.
Selanjutnya masuk ke web dan masuk WSGI configuration file untuk mengganti ‘from flask_app import app as application’ menjadi ‘from app import app as application’. Lalu save dan kembali ke web.
Lalu dapat melakukan reload. Hal ini untuk menerapkan perubahan kode dan memperbarui konfigurasi. Setelah itu dapat masuk pada configuration for, maka akan menghasilkan link website yang dapat diakses sebagai berikut .
Berikut merupakan hasil dari men-deploy model dengan PythonAnywhere. Website ini diberi nama Profit Dish Insight yang melakukan klasifikasi profitabilitas menu restoran dengan K-Nearest Neighbors (KNN).