ประเมินราคาคอนโดสำหรับนักลงทุนมือใหม่ ง่ายแค่คลิกเดียว ด้วย API

Objective: บทความนี้เป็นส่วนหนึ่งของ Data Science Essential ของ Botnoi Classroom หัวข้อ Machine Learning and Prediction Model โดยเป็นการทำโปรเจคสร้าง API เพื่อเรียกใช้ Machine learning model มาทำนายผล

Team Member DSEs G5 : เกริก, เมย์, ฐนวัฒน์, ภาณุ , ไหม

สำหรับใครที่กำลังมองหาคอนโดในกรุงเทพ มองไปทางไหนก็เจอแต่ตัวเลือกน่าสนใจเต็มไปหมด ขนาดห้องก็มีหลายหลาก ราคาก็มีหลากหลาย ความสูงก็มีทั้ง high rise และ low rise ทั้งโครงการขึ้นใหม่ และโครงการเก่า แล้วเราจะตัดสินใจเลือกยังไงกันดีนะ

ก่อนอื่น แนะนำให้กำหนดสิ่งที่อยากได้ให้ชัดเจน อยากได้ห้องเล็กหรือห้องใหญ่ อยู่ติดรถไฟฟ้ารึเปล่า Area ไหน อยู่เองหรือปล่อยเช่า หลังจากที่รู้สิ่งที่ต้องการชัดเจนแล้ว เรื่องราคานั้น ไม่ต้องห่วง เรามีตัวช่วยให้ เพื่อให้คุณได้คอนโดที่ต้องการในราคาที่เหมาะสมที่สุด

วันนี้ทางทีมจะมาแนะนำ API ที่ใช้ machine learning มาช่วยให้คุณสามารถตัดสินใจในเรื่องของการประเมินราคาคอนโด ไม่ว่าจะเป็นราคาซื้อ (ควรต่อรองเท่าไหร่ดี) การตั้งราคาขายที่เหมาะสม(ถ้าขายปีหน้าจะได้ราคาดีกว่านี้รึเปล่า) เพื่อให้คุณไม่ต้องซื้อคอนโดในราคาที่แพงเกินไป หรือติดดอยในอนาคต ถ้าพร้อมกันแล้ว เราไปรู้จัก API ตัวนี้ตั้งแต่วิธีการสร้างกันเลย

เราจะเริ่มต้นจากการพัฒนาโมเดล machine learning สำหรับทำนายราคาคอนโด โดยการใช้ภาษา python พัฒนาผ่าน google colab เมื่อเราได้โมเดลของเราแล้ว ก็มาสร้าง API เพื่อรับข้อมูลจาก user แล้วนำไปป้อนเข้าโมเดลของเรา ก็จะได้ออกมาเป็นราคาคอนโดที่โมเดลทำนายออกมา

โดยกระบวนการพัฒนาโมเดล ก็เป็นไปตาม machine learning pipeline ดังนี้

1. เก็บข้อมูล
2. clean ข้อมูล
3. Split data & extract feature
4. Train โมเดล
5. ประเมินผลโมเดล
6. นำโมเดลที่ดีที่สุดไปใช้งาน

1. เก็บข้อมูล

การที่โมเดลจะทำนายได้แม่นยำแค่ไหน แน่นอนว่าข้อมูลที่จะนำมา train นั้นมีความสำคัญมาก ถ้าข้อมูลที่เลือกมามี feature ที่ดี และมีปริมาณมากพอ ก็น่าจะนำไปพัฒนาโมเดลที่มี performance ที่ดีได้

ข้อมูลที่จะนำมาใช้ในการพัฒนาในครั้งนี้ ได้มาจากการ class ประกอบการเรียน web data extraction เมื่อปี 2019 โดยมีแหล่งข้อมูลมาจาก hipflat.co.th

Dataset หรือชุดข้อมูลประกอบด้วยข้อมูลดังต่อไปนี้
1. Condo_NAME_EN ชื่อโครงการ (ภาษาอังกฤษ)
2. Condo_NAME_TH ชื่อโครงการ (ภาษาไทย)
3. Condo_area เขตที่อยู่อาศัย
4. Condo_link URL ของข้อมูล
5. Address_TH ที่ตั้งของคอนโด
6. Year_built ปีที่สร้างเสร็จ
7. Area_m2 พื้นที่โครงการ (ตารางเมตร)
8. #_Tower จำนวนตึก
9. #_Floor จำนวนชั้น
10. Sale_Price_Sqm ราคาขายต่อตารางเมตร
11. Sale_Price_Increment[Quarter] การเปลี่ยนแปลงราคาเสนอขายจากไตรมาสที่แล้ว
12. Sale_Price_Inc[Year] การเปลี่ยนแปลงราคาเสนอขายจากปีที่แล้ว
13. Rental_Yield ผลตอบแทนค่าเช่า
14. Rental_Yield_Inc[Year] การเปลี่ยนแปลงผลตอบแทนจากค่าเช่าจากปีที่แล้ว
15. Latitude พิกัดละติจูด
16. Longtitude พิกัดลองจิจูด
17. All_Data (TRUE) ตรวจสอบคุณภาพข้อมูลว่าไม่เป็นค่าว่าง ปีที่สร้างเสร็จ ราคาขายต่อตารางเมตร ผลตอบแทนค่าเช่า
18. MinDist_Station ระยะห่างจากสถานีรถไฟฟ้า
19. Condo_Area_corr เขตที่อยู่อาศัย และ จังหวัด

เราได้เก็บ dataset นี้ไว้ในรูป google sheet เพื่อให้สะดวกในการทำงานเป็นทีม เราก็จะเริ่มจากการ import module/library ที่จะเรียกใช้เข้ามาก่อน

จากนั้นเราจะเริ่มจากการสร้าง function สำหรับ load data จาก google sheet มาเก็บไว้ใน dataframe เพื่อให้สะดวกในการเรียกใช้ครั้งต่อๆ ไป

เมื่อลองเรียกใช้ function ก็จะเห็นภาพรวมของ data ดังภาพ

ลองเช็คความสมบูรณ์ของข้อมูล โดยใช้ method info

พบว่ามีข้อมูล 1429 example โดยไม่มีค่า null เลย ก็จะทำการ clean data ต่อไป

2. clean ข้อมูล

ก่อนจะนำข้อมูลเข้าไปเทรนโมเดลต่างๆ เราก็ต้องจัดการ clean ข้อมูลให้เหมาะสม เพื่อให้โมเดลสามารถทำความเข้าใจข้อมูลเหล่านั้นได้อย่างมีประสิทธิภาพ

เราเริ่มจากการพิจารณาดูว่ามีคอลัมน์ไหนที่ไม่มีความหมาย หรือไม่มีความสำคัญบ้าง พบว่า

• ID เป็นการรันตัวเลข ID เฉยๆ
• Condo_NAME_EN , Condo_NAME_TH เป็นชื่อคอนโด มีความแตกต่างกันอย่างมากในแต่ละ example และไม่น่ามีความสำคัญต่อราคา
• Condo_link เป็นเพียง link ไปยังหน้าเพจข้อมูลของคอนโดนั้นๆ
• All_Data เป็นแค่การเช็คว่าเก็บข้อมูลมาครบไหม
• Condo_Area_corr ก็เก็บข้อมูลเขต ซ้ำซ้อนกับ Condo_area

เราจึงจะดรอปคอลัมน์เหล่านี้ออกไป

จากนั้นเราจะลองหาดูว่ามีข้อมูลส่วนไหนที่เป็น empty string บ้าง

พบว่า Area_m2 , #_Floor, Sale_Price_Inc[Year], Rental_Yield_Inc[Year] มีข้อมูลที่หายไปอยู่ ก็จะพยายามเติมข้อมูลให้ได้มากที่สุด เพื่อให้โมเดลทำงานได้ดี

เบื้องต้น ก็จะแทนที่ empty string ด้วย np.nan ก่อน

จากนั้นลองดูว่า example ที่ไม่มีข้อมูลจำนวนชั้นเป็นข้อมูลแบบไหน มีจำนวนเท่าไร

พบว่ามีเพียง 2 example ที่ข้อมูลจำนวนชั้นหายไป เราก็ได้หาข้อมูลจำนวนชั้นเพิ่มเติมจาก internet แล้วมาใส่เพิ่มเติมเข้าไปโดยตรง

เราได้มองหา outlier โดยเริ่มจากการ plot กราฟ boxplot

เราอยากทราบข้อมูลว่าโครงการคอนโดที่มี Area_m2 (พื้นที่คอนโดทั้งหมด) เป็น outlier นั้นมักจะสร้างขึ้นในปีใด โดยการ plot กราฟ

ก็พบว่าคอนโดที่สร้างในปี 2010 มีพื้นที่โครงการที่อยู่ในช่วง outlier มากที่สุด ซึ่งก็ยังไม่แน่ใจว่าเป็นเพราะสาเหตุใด อาจต้องหาข้อมูลเพิ่มเติมมากกว่านี้ เบื้องต้น ทีมก็ตัดสินใจว่าจะยังไม่เอา outlier ในส่วนนี้ออกไป เพราะเป็นข้อมูลจริง ไม่ใช่ error จากการใส่ข้อมูลผิด

จากนั้นก็ลองดู histogram ของ Area_m2 กับ Sale_Price_INC[year] เพื่อดูการกระจายตัวของข้อมูล เพื่อตัดสินใจว่าจะแทนที่ข้อมูลที่หายไปอย่างไรดี

เห็นว่าข้อมูลของทั้ง 2 คอลัมน์จะกระจุกตัวอยู่ในช่วงแคบๆ เราจึงจะแทนค่า missing data ของ 2 คอลัมน์นี้ด้วยค่า median น่าจะให้ผลลัพธ์ที่ถูกต้องกว่าการใช้ค่า mean

ส่วนคอลัมน์ Rental_Yield_Inc[Year] มี missing data จำนวนมาก และไม่สามารถแทนค่าข้อมูลได้อย่างถูกต้องเนื่องจากมีข้อมูลไม่เพียงพอ ทีมจึงเลือกดรอปออกไป

เนื่องจากในปัจจุบัน มีการแบ่งคอนโดเป็น 2 ประเภทใหญ่ๆ คือ low rise กับ high rise ซึ่งเรามีสมมติฐานว่าน่าจะมีผลกระทบต่อราคาขาย เราจึงสร้าง feature ใหม่ชื่อว่า Kind โดยแบ่งกลุ่มคอนโดตามจำนวนชั้น ถ้าสูงกว่า 9 ชั้น ให้จัดเป็น high rise ถ้าเตี้ยกว่า 9 ชั้น ก็จัดเป็น low rise

นอกจากนี้ทีมก็คิดกันว่า ที่ตั้งของคอนโด ว่าตั้งอยู่ที่ถนนสายใด ก็น่าจะมีความสำคัญมาก ทีมจึงได้สร้าง feature ใหม่ ชื่อว่า Road โดยการสกัดชื่อถนนออกมาจาก Address_TH และดรอปคอลัมน์เดิมทิ้งไป

จากนั้นเราลองตรวจสอบ correlation ระหว่าง feature ต่างๆ กับ ราคาคอนโดต่อตร.ม. ว่ามี feature ใดบ้างที่น่าจะมีความสำคัญในการทำนายราคา

พบว่า ปีที่สร้าง (Year_bulit) กับ ระยะห่างจากสถานีรถไฟฟ้า (MinDist_Station) มี correlation ที่สูง น่าจะเป็น feature ที่ช่วยให้โมเดลทำนายได้ดี ส่วน Sale_Price_Inc[Year] กับ Sale_Price_Increment[Quarter] ไม่ค่อยมี correlation กับราคา จึงจะดรอป 2 คอลัมน์นี้ออกด้วย

ลอง plot graph ดูการกระจายตัวของ ปีที่สร้างคอนโด กับราคาขาย

พบว่า ปีที่สร้าง Year_bulit กับ ราคาเสนอขายต่อตารางเมตร Sale_Price_Sqm มีความสัมพันธ์กันในรูปแบบเชิงเส้น จึงน่าจะเป็น feature ที่ช่วยให้โมเดลทำนายได้ดี

จากนั้นเราจะสร้าง feature เพิ่ม โดยใช้ method get_dummies เปลี่ยน categorical data ให้เป็น ตัวเลข (one hot encoding) และดรอปคอลัมน์เดิมออก

เราก็จะรวบรวมทุกขั้นตอนมาใส่ไว้ใน function clean_data เพื่อเตรียมนำไปเรียกใช้ใน pipeline ต่อไป

3. Split Data & Extract Feature

โมเดลที่ดีที่สุดที่เป็นเป้าหมายของเรา คือ โมเดลที่สามารถ generalize ได้ดี หมายถึงว่า เมื่อนำข้อมูลใหม่ที่โมเดลไม่เคยเห็นมาก่อน โมเดลก็ยังสามารถทำนายค่าออกมาได้ดี มี error ไม่สูงมากนัก เราก็จะกันข้อมูลออกบางส่วนไว้ไม่นำไป train ด้วย เพื่อใช้ข้อมูลเหล่านั้นในการวัด performance ของแต่ละโมเดล

โดยเราได้สร้าง function create_dataset สำหรับ แบ่งข้อมูลออกเป็น training data : cross validation data : testing data ใน อัตราส่วน 80:10:10 พร้อมกับ extract feature และ ทำ normalization โดยการใช้ MinMaxScaler

จากนั้นเราจะสร้าง function create_dataset_standard ขึ้นมาอีกอันหนึ่ง โดยแบ่งข้อมูลเหมือนเดิมแต่เลือกทำ standardization โดยการใช้ StandardScaler เพื่อเปรียบเทียบในขั้นต่อไปว่า การทำ feature scaling แบบไหน จะทำให้โมเดลได้ผลลัพธ์ที่ดีกว่ากัน

4. Train โมเดล

ในขั้นตอนการ train โมเดลนั้น ทางทีมได้แบ่งงานกันไป explore โมเดลต่างๆ ดังนี้

1. Neural Networks
2. Linear Regression
3. RandomForestRegressor
4. GradientBoostingRegressor
5. DecisionTreeRegressor

เราก็จะสร้าง function สำหรับ train model ต่างๆ เพื่อเตรียมนำไปเรียกใช้ใน pipeline ต่อไป

4.1 Neural Networks

เราจะสร้าง Neural Networks โดยใช้ Keras Framework เริ่มต้นโดยการ import module/library ต่างๆ ที่ต้องการใช้

ทีมได้ประชุมกันแล้วตกลงว่าจะเลือกใช้ RMSE เป็น evaluation metric ในการเลือกโมเดล และเนื่องจากตัว Neural Networks ได้ใช้ Keras framework จึงสร้าง function สำหรับคำนวณ RMSE สำหรับ Keras แยกไว้ด้วย

4.1.1 Initialize

เราเริ่มจากลองสร้างโมเดลขึ้นมา 1 ตัวเป็น baseline โดยเลือกให้มี 5 layer และในแต่ละ layer มี activation unit ต่างๆ กัน เลือกใช้ relu เป็น activation function ในทุก layer ยกเว้น layer สุดท้ายใช้เป็น linear เนื่องจากต้องการทำนายค่าออกมาเป็นตัวเลข

ลอง plot กราฟ loss ออกมาเพื่อดูว่า model learn ได้ถูกต้องหรือไม่ ก็พบว่าน่าจะถูกต้องดีแล้ว โดย loss ได้ลดลงอย่างต่อเนื่อง

4.1.2 Tuning Neural Networks

จากนั้นก็จะลอง tune โดยการเลือก range ของ hyperparamer ค่าต่างๆ ที่ต้องการทดลอง แล้วเทรนโมเดลมาจาก combination ต่างๆ แล้วเลือกโมเดลที่ผลลัพธ์ดีที่สุดออกมา

โมเดลที่ tune แล้วได้ผลลัพธ์ดีที่สุด มี 6 layer โดย 5 layer แรกมีจำนวน activation unit : 64,48,32,48,32 ตามลำดับ และ layer สุดท้าย มี 1 unit

ลองดูผลลัพธ์ของโมเดลเมื่อทดสอบด้วย cross validation data

พบว่าโมเดลที่ tune แล้วทำผลงานได้ดี โดยได้ค่า rmse ที่ 26549.41840621449 กระบวนการ tune น่าจะไม่มีข้อผิดพลาด ก็นำผลลัพธ์ที่ได้มาทำเป็น tuned_NN model

เราจะสร้าง function สำหรับ train Neural Network 2 โมเดล โดย function แรก train_NN เป็นการสร้างตัวโมเดล Neural Network ที่เราลองสร้างขึ้นโดยยังไม่ได้ tune hyperparameter ส่วน function ที่สอง train_tuned_NN เป็นการสร้างโมเดลตาม hyperparameter ที่เรา tune แล้ว

4.2 LinearRegression, RandomForestRegressor, GradientBoostingRegressor, DecisionTreeRegressor

เราจะสร้าง function train_model สำหรับ train โมเดล LinearRegression, RandomForestRegressor, GradientBoostingRegressor, DecisionTreeRegressor ไว้สำหรับเรียกใช้ใน pipeline ดังนี้

เวลาจะเปลี่ยนโมเดลที่ต้องการ train ก็มา uncommnet code ตัว model ที่ต้องการ train ใน function แล้วรันใหม่ แล้วกด pipeline อีกครั้ง ก็จะได้ผลลัพธ์เลย

Pipeline

ตอนนี้เราก็มี function สำหรับทุกๆ ขั้นตอนการทำงานแล้ว ก็จะนำทุกอย่างมารวมกัน สร้างเป็น function pipeline ขึ้นมาเรียกใช้ เพื่อดูผลลัพธ์ความแม่นยำของโมเดลได้จากการรัน pipeline เพียงครั้งเดียว

ถ้ารัน code ตามนี้ครั้งแรก ก็จะเป็นการเทรนโมเดล Linear regression โดยทำ MinMaxScaling ได้ผลลัพธ์เป็นค่า rmse ของโมเดล

5. ประเมินผลโมเดล

เราก็จะวัด performance ของ แต่ละ model ด้วย ค่า rmse และเราอยากจะเปรียบเทียบวิธีการ scale feature ด้วยว่าใช้ MinMaxScaler หรือ StandardScaler จะได้ผลลัพธ์ที่ดีกว่ากัน

เราจะเริ่มจากการทดสอบทุกโมเดลโดยใช้ MinMaxScaler ก่อน ก็ทำได้โดยการเลือกใช้ function create_dataset ใน pipeline แล้วกดรันทีละโมเดล และเก็บผลลัพธ์ไว้ใน rmse_list

จะเห็นว่า เมื่อเราใช้ MinMaxScaler โมเดลที่ดีที่สุดก็คือ RandomForest โดยได้ค่า rmse ที่ 22368.88

ต่อไปเราก็จะมาใช้ StandardScaler ดูบ้าง ก็ทำตามขั้นตอนเดิม และเก็บผลลัพธ์ไว้ใน rmse_list2

เมื่อใช้ StandardScaler โมเดลที่ดีที่สุดคือ GradinetBoosting ได้ค่า rmse = 22532.92

สังเกตได้ว่า Linear Regression ทำผลงานได้ดีขึ้นมากเมื่อเปลี่ยนมาใช้ Standard Scaler ก็เป็นเพราะ Linear Regression มีสมมติฐานว่า data มีการกระจายตัวแบบปกตินั่นเอง พอเราทำ StandardScaler จึงได้ผลดีขึ้นมาก

เมื่อเทียบทั้ง 2 วิธีแล้วก็ สรุปได้ว่า โมเดล RandomForestRegressor โดยการทำ normaliziation กับ data ด้วย MinMaxScaler ให้ผลลัพธ์ที่ดีที่สุด ได้ค่า rmse = 22368.88 จึงเลือกนำโมเดลนี้มา fine tune ต่อไป

Tuning Random Forest

เราจะ tune hyperparameter ใน model RandomForestRegressor ให้ model สามารถ generalize ได้ดีขึ้น

เมื่อ tune เสร็จแล้ว ก็จะได้ค่า hyperparameter ที่ดีที่สุดออกมา

ลองดูผลลัพธ์จาก โมเดลที่ tune แล้ว พบว่า rmse ของ validation data สูงขึ้นเล็กน้อย

ลองทดสอบเปรียบเทียบ ตัวโมเดลใหม่ที่ tune แล้ว กับตัวเดิม โดยใช้ test data เริ่มจากโมเดล RandomForest ตัวเดิม พบว่าได้ค่า RMSE = 31856.16 จากนั้นลองใช้โมเดลที่ tune ค่าแล้ว ได้ค่า RMSE = 28806.57

พบว่าโมเดลที่ tune ค่าแล้ว มีค่า RMSE ที่ต่ำกว่า แสดงว่า สามารถ generalize ได้ดีกว่า จึงเลือกใช้โมเดลนี้เป็นโมเดลที่ดีที่สุด

6. นำโมเดลที่ดีที่สุดไปใช้งาน

เราจะนำโมเดลที่ tune ค่าแล้วไปใช้ในการสร้าง api ต่อไป

ดู colab ตัวเต็มได้ที่ https://colab.research.google.com/drive/1tMxZa6mTcrh8t9jeG164EktC5lN-PMtg?usp=sharing

ขั้นตอนการ deploy api

ตัว api เราเลือกที่จะ deploy ไปที่ heroku server หลังจากที่เราเลือก model เรียบร้อยเเล้ว เราก็มาเตรียมไฟล์สำหรับจะ deploy
สำหรับไฟล์ที่จำเป็นจะต้องมีในการ Deploy API มีดังนี้

1.Procfile เพื่อกำหนดคำสั่งที่ Heroku ใช้ในการรัน API ของเรา

2. requirements.txt กำหนด Package Library หรือ Module ที่ต้องติดตั้งเพื่อให้ API ของเราสามารถทำงานได้

3. data_scaler.joblib เป็นไฟล์สำหรับทำ Scale ข้อมูลเนื่องจากในขั้นตอนการเทรน Model มีการ scale ข้อมูลก่อนการเทรน Model ในขั้นตอนการทำนายราคาคอนโดของ API จึงต้องนำไฟล์นี้ Deploy บน Heroku ด้วย

4.rf.joblib เป็น ไฟล์ Model สำหรับทำนายราคาคอนโดซึ่งเป็นหัวใจสำคัญสำหรับ API นี้

5.app.py เป็นไฟล์ API ที่ต้องการใช้งาน

6.predict_condo_price.py เป็นไฟล์ที่รวมขั้นตอนการ Clean data และทำนายราคาคอนโด

Structure file จะเป็นดังนี้

เมื่อเราสร้าง folder ที่จะใช้สำหรับ deploy เรียบร้อยเเล้ว ขั้นต่อไปเราต้องไปสร้าง login ไปที่ heroku เพื่อสร้าง โปรเจคของเราที่จะใช้สำหรับ deploy ในที่นี้ ทีมเราใช้ชื่อ dse-g5 สร้างเสร็จเเล้วเราก็จะได้ server ดังรูป

หลังจากนั้น เราต้อง install heroku CLI ในเครื่องเราก่อน เพื่อที่จะสามารถใช้คำสั่งใน command line สั่ง deploy ขึ้น heroku server ได้
รายละเอียดเพิ่มเติม สามารถดูได้จาก https://stackabuse.com/deploying-a-flask-application-to-heroku/

เมื่อเรา deploy สำเร็จ เราสามารถเทส ตัว api เราผ่าน ทาง browser หรือ tool postman ก็ได้ เราเลือกใช้ POST method เพราะว่า request parameter เรายาวมาก มีถึง 10 ตัวด้วยกัน
parameter ที่จำเป็นต้องสำหรับการเรียกใช้ API นี้ได้แก่

1. condo-area คือ เขตที่ condo ที่ต้องการทำนายตั้งอยู่(ภาษาอังกฤษ) เช่น Bang Kapi
2. address เป็นที่อยู่ของ condo เช่น ถนนเสรีไทย คลองจั่น บางกะปิ
3. year คือปีที่ condo นั้นถูกสร้าง
4. sqm คือขนาดพื้นที่ทั้งหมดของโครงการ หน่วยเป็นตารางเมตร
5. tower จำนวนตึกของ condo
6. floor จำนวนชั้นทั้งหมดของ condo
7. rent-yield คอืค่าเช่าสำหรับการเช่าเพื่ออยู่อาศัยของห้องของ condo นั้นๆ
8. lat คือ latitude ของที่ตั้งของ condo
9. long คือ longitude ของที่ตั้งของ condo
10. min-dist-station คือราคาค่าเช่าขั้นต่ำของ condo

ตัวอย่าง การ call api ผ่าน tool ที่ชื่อ postman เมื่อลองใส่ข้อมูลเข้าไป ก็จะได้ผลลัพธ์ออกมาเป็นราคาต่อตร.ม. ที่โมเดลทำนายออกมาในที่สุด

นอกจากนี้ เรายังมีการ host api ของเราไปที่ botnoi server ทำให้ใช้งานได้สะดวกมากยิ่งขึ้น สามาถ copy url ไปใช้ต่อยอดโปรเจคอื่นๆได้อีกด้วย สามารถเข้าไปดูได้ที่
https://openapi.botnoi.ai/dashboard/myapi/sa-CondoPricePrediction

สรุปผลและแนวทางการพัฒนาในอนาคต

จะเห็นได้ว่า เราสามารถใช้ machine learning model ในการทำนายราคาคอนโดในกรุงเทพได้ แม้ผลลัพธ์จะยังไม่แม่นยำมากนัก แต่ก็สามารถพัฒนาต่อไปได้อีกมาก โดยมีหลายแนวทาง เช่น

• เก็บข้อมูลคอนโดในรูปแบบเดียวกันนี้เพิ่มขึ้น ก็จะช่วยให้โมเดลมี performance ที่ดีขึ้น
• อาจเก็บข้อมูลอื่นๆ มาเพิ่ม เป็น feature ให้โมเดล เช่น หาว่าคอนโดแต่ละที่ ใกล้สิ่งอำนวยความสะดวกอื่นๆ เช่น โรงเรียน โรงพยาบาล มากน้อยเพียงใด มาเพิ่ม
• ทำ feature engineer เพิ่มเติม เช่น ทำ cluster ของคอนโดตาม location
• อาจเลือกดรอปข้อมูลที่เป็น outlier ออกไปเพิ่มขึ้น
• ลองหาโมเดลอื่นๆ มาทดสอบเปรียบเทียบอีก
• เราสามารถพัฒนาโมเดลในส่วนการทำ feature engineering สำหรับตัวแปรชนิด string หรือ category โดยเปลี่ยนจาก one hot encoding เป็น word to vector ซึ่งจะทำให้ข้อจำกัดของโมเดลที่ไม่สามารถเรียนรู้ค่าตัวแปรใหม่ๆ ในการทำนายนั้นหมดไป

หากได้โมเดลที่มีความแม่นยำดีขึ้น ก็น่าจะนำไปสู่การใช้งานจริงได้ และน่าจะเป็นประโยชน์ต่อผู้ที่กำลังมองหาคอนโด หรือผู้ที่ต้องการขายคอนโดของตัวเอง ให้ตัดสินใจได้ดีขึ้นได้ทั้งสองฝ่าย อีกทั้งเราสามารถขยายผลจากโมเดลไปสู่การพัฒนาแอปพลิเคชันเพื่อเป็นประโยชน์ต่อผู้ใช้งานในวงกว้างต่อไป