ลดปัญหาการจราจรติดขัดด้วย Reinforcement learning

6 min readJun 15, 2022

Problems

“รถติด” เป็นปัญหาที่ทุกคนไม่ว่าจะขับรถหรือไม่ต่างต้องเจอหากคุณใช้ชีวิตอยู่ใน กรุงเทพมหานครแห่งนี้ ซึ่งปัญหารถติดอยู่คู่กับคนกรุงเทพมาอย่างยาวนานและเป็นสาเหตุของปัญหาต่างๆมากมาย ไม่ว่าจะเป็นเรื่องของการเสียเวลาโดยเปล่าประโยชน์ มลพิษที่เกิดจากการเผาผลาญเชื้อเพลิงของรถยนต์ การสูญเสียพลังงานโดยสูญเปล่า และปัญหาสุขภาพมากมายที่อาจเกิดขึ้นจากการใช้เวลาอยู่บนรถเป็นเวลานาน จากที่กล่าวมาทั้งหมดจะเห็นได้ว่า ปัญหารถติดนั้นเป็นปัญหาใหญ่กว่าที่เราคาดการณ์กันไว้ เพราะฉะนั้นเราจึงควรเริ่มหาทางแก้ไขปัญหานี้ให้เร็วที่สุดเท่าที่จะทำได้

Causes

ปัญหารถติด เกิดขึ้นได้จากหลากหลายสาเหตุมากมาย แต่หนึ่งในสาเหตุเหล่านั้นคือ การควบคุมไฟจราจร ที่ไม่ได้มีประสิทธิภาพสูงสุด ไม่ได้มีการปรับระบบไฟจราจรให้เข้ากับสถานการณ์ของถนน ณ ปัจจุบัน โดยสัญญาณไฟจราจรปัจจุบันแบ่งได้เป็น 2 ประเภทหลักๆนั้นก็ คือ 1.สัญาณไฟจราจรอัจฉริยะ ที่ถูกตั้งเวลาให้เปิดปิดไฟตามช่วงเวลาต่างๆในแต่ละวัน 2.เจ้าหน้าที่ทำหน้าที่ควบคุมไฟจราจรในแต่ละแยกและดูจากสภาพท้องถนน แล้วติดต่อสื่อสารกันผ่านวิทยุสื่อสารเพื่อเปิดปิดไฟจราจรให้เหมาะสมกับสภาพท้องถนน ณ ขณะนั้น อย่างไรก็ตามทั้งสองวิธีนั้นไม่สามารถดูสภาพของรถทั่วทั้ง กทม.ได้ หรือแม้กระทั่งเขตการดูเเลขนาดเล็กก็อาจจะเกิด Human error ได้ และ มนุษย์ไม่สามารถทราบถึงความสัมพันธ์ของเส้นทางจราจรต่างๆได้อย่างครบถ้วน เช่น การที่ปล่อยรถจากเส้นหนึ่งให้ออกจากสี่แยก อาจจะทำให้เกิดรถติดในแยกอื่นๆต่อไปเรื่อยๆ จนเกิดการติดชะงักบนท้องถนนได้ ด้วยเหตุผลทั้งหมดที่กล่าวมาทำให้วิธีการที่ใช้ในปัจจุบันไม่สามารถหาวิธีที่ดีที่สุดในการบริหารจัดการจราจร

Solutions

AI อาจจะเป็นทางออกของการแก้ไขปัญหานี้ เพราะว่า ปัญญาประดิษฐ์สามารถมองดูภาพรวมของถนนได้และถ้าเราสามารถให้ปัญญาประดิษฐ์ควบคุมการเปิดปิดไฟจราจร เพื่อหา Solution ที่ดีที่สุดในแต่ละช่วงเวลา และอัพเดทข้อมูลตลอดเวลาได้ เราจะสามารถลดปัญหารถติดได้อย่างเห็นผล เพราะเราจะไม่มี Human error ในกระบวนการนี้ และ ปัญญาประดิษฐ์สามารถคำนวณถึงความสัมพันธ์ของเส้นทางจราจรต่างๆได้ ่โครงงานนี้ได้เลือกใช้หลักการของ Reinforcement Learningในการสร้าง AI หนึ่งตัวที่ควบคุม ดูแล และ จัดการระบบไฟจราจรให้มีประสิทธิภาพมากที่สุด

Reinforcement Learning (RL)

เป็นหลักการ Machine Learning Algorithm แบบหนึ่ง ที่มีหลักการทำงานเสมือนกับการที่มนุษย์เรียนรู้บางสิ่งบางอย่างด้วยการลองผิดลองถูก และมีการเรียนรู้เกิดขึ้นระหว่างทางว่าการกระทำไหนดีหรือไม่ดี โดยมีส่วนประกอบเป็น

Agent — ผู้กระทำ Action
Action (a) — การกระทำของ Agent ที่ส่งผลบางอย่างต่อ Environment
Environment (e) — ระบบที่ Agent ต้องมีปฏิสัมพันธ์ด้วย
State (s) — สถานการณ์ของ Environment ที่ทาง Agent สามารถรับรู้ได้
Policy (π) — หลักการที่ Agent ใช้ในการตัดสินใจเลือก Action หลังจากประเมินสถานการณ์แล้ว
Reward (R) — ตัวประเมินผลลัพธ์ที่เกิดจากการกระทำของ Agent

โดย Reinforcement Learning นั้นจะทำงานโดยการที่ Agent จะรับรู้สถานการณ์ หรือ State ของ Environment จากนั้นจึงใช้ Policy ในการเลือกทำการกระทำบางอย่าง (Action) ที่ส่งผลต่อ Environment ซึ่งผลจากการกระทำ หรือ Action นั้นจะทำให้สถานการณ์ของ Environment เปลี่ยนจากสถานการณ์เดิมไปสู่อีกสถานการณ์หนึ่ง (State ใหม่) โดยที่หลังจากที่ Agent กระทำการ Action แล้วจะนำ Reward ที่ได้ส่งกลับไปหา Agent เพื่อให้ Agent เรียนรู้ว่า Action ที่ทำลงไปส่งผลดีหรือเสียอย่างไรต่อ Environmnt โดยรวมแล้วเราจะวน Process นี้เพื่อที่จะให้ Agent คำนวณหา Solution ในการเลือกกระทำ Action ต่างๆต่อไปในอนาคต โดยหลักการที่ว่า Agent จะพยายามทำให้ Reward เป็นค่ามากที่สุด

โดยการที่จะนำ Reinforcement Learning มาสร้าง model ของโครงงานของเรานั้น เราจะเริ่มต้นจากการใช้ Simulation มาเป็น Environment ใน model ของโครงงาน และ Simulation ที่เราเลือกใช้คิอ “SUMO”

Simulation of Urban MObility (SUMO)

SUMO เป็น open-source simulation ที่สามารถจำลองถนนทั่วโลก โดยดึงข้อมูลจากแผนที่จริงๆในโลกของเรามาทำเป็น simulation หรือสร้างเส้นทางการจราจรขึ้นมาเอง และจำลองการเคลื่อนของรถยนต์บนถนนนั้นๆ พร้อมการเปิดปิดของไฟจราจร

โดยการที่เราเลือกใช้ simulation นี้เพราะเราสามารถอ้างอิงข้อมูลจากแผนที่จริงได้เลยโดยที่ไม่ต้องมา สร้าง map ขึ้นมาด้วยตัวเอง และ simulation นี้ยังสามารถปรับแต่งข้อมูลต่างๆได้อย่างละเอียด มากไปกว่านั้นเรายังมี Library ของ SUMO-RL และ stable-baselines 3 ที่สามารถนำมาสร้างสร้าง model RL ได้โดยใช้ simulation ตัวนี้อีกด้วย

Creating models

Import Map

เราจะใช้ OSMWebWizard ซึ่งเป็นหนึ่งใน tool ที่ SUMO ให้มาสำหรับการ import map จาก open street map โดยการเรียกใช้จะใช้โดยการเปิด Command Prompt โดยให้ link กับ folder tools ของ SUMO จากนั้นเรียกใช้คำสั่ง

python osmWebWizard.py

เพื่อเปิด OSMWebWizard ซึ่งเราจะสามารถ search ชื่อสถานที่ต่างๆเพื่อดึงข้อมูลมาโดยการตีกรอบในส่วนที่เราต้องการจากนั้น เราจะสามารถดึง map ใช้งานได้

Method

ตามหลักการของ Reinforcement Learning เราต้องกำหนดค่าที่จะนำมาใช้อ้างอิงในการทำ model แต่ละตัวก่อน เริ่มจาก

Action : คือการที่เรากำหนดให้ agent ของเราควบคุมไฟจราจร สีแดงและเขียว ในทุกๆแยกที่มีไฟจราจร

State : สิ่งที่ Agent จะรับรู้ได้และรับเป็น input คือ จำนวนรถที่หยุดนิ่งอยู่ในเลน ณ ขณะนั้น โดยจะสามารถนำไปคิดเป็นความหนาแน่นได้ โดยคิดจาก ปริมาณรถที่หยุดนิ่งอยู่ในเลน หารด้วย ปริมาณรถสูงสุดที่เลนนั้นรับได้

Rewards : คือการที่เรากำหนดให้ reward ขึ้นอยู่กับ ความหนาแน่นของรถยนต์ (lane density) เราจะใช้ค่านี้เป็นตัวกำหนดว่า สภาพท้องถนน ณ ขณะนั้นรถติดมากน้อยเพียงใด

อ้างอิงจาก https://github.com/LucasAlegre/sumo-rl

ซึ่งความหนาแน่นสูง ก็หมายถึงรถติดมาก ทำให้ Reward ยิ่งน้อยลง กล่าวคือ Agent จะพยายามสังเกตุดู ความหนาแน่นของรถยนต์ แล้วเปิดปิดไฟเขียวและแกงเพื่อให้ ความหนาแน่นของรถยนต์ในท้องถนน ลดลงให้เหลือน้อยที่สุดเท่าที่จะเป็นไปได้

Files needed

File ที่จำเป็นในการ Run และ Train คือ ไฟล์ประเภท .net.xml ที่เป็นตัว map และเส้นทางการเดินรถต่างๆ รวมถึงไฟจราจรและอื่นๆ File อีกตัวที่สำคัญคือไฟล์สกุล .rou.xml ซึ่งเป็นไฟล์ที่ระบุรถที่เข้ามาในแต่ละเลน ทั้ง จำนวน ปริมาณ และ ความถี่ และจะนำข้อมูลที่ได้จากไฟล์ทั้งสองมาใช้ในการ train model

File map จาก https://github.com/LucasAlegre/sumo-rl

การสร้างไฟล์การเคลื่อนที่ของรถ (.rou)

หนึ่งในปัญหาที่พบระหว่างการทำโครงงานคือ การ import file map จาก OSMWebWizard นั้น เราพบว่า file การเคลื่อนที่ของรถยนต์ที่วิ่งอยู่บน map ไม่ได้ถูกสร้างมาด้วยทำให้เราต้องหาวิธีการในการสร้างไฟล์การเคลื่อนที่ของรถยนต์ขึ้นมาด้วยตัวเอง

วิธีการแก้ไขปัญหาดังกล่าว เราพบว่าเราสามารถใช้ tool ที่มีมาให้จาก SUMO ซึ่งก็คือ randomTrips ซึ่งเป็น tool ที่ใช้ในการสร้างรถยนต์แบบสุ่มขึ้นมา ใช้ใน map ต่างๆที่ต้องการการสร้างรถยนต์ขึ้นมาแบบสุ่ม โดยสุ่มทั้งจุดที่รถวิ่งเข้ามา โดยที่ต้องเป็นจุดสิ้นสุดของเส้นทางไม่ใช่ระหว่างเส้นทาง และจะสุ่มสถานที่ที่รถยนต์แต่ละคันจะวิ่งไปถึงอีกด้วย ซึ่งทำให้เรายิ่งได้ข้อมูลที่หลากหลายมากยิ่งขึ้นไปอีกด้วย

โดยการใช้งานเราต้องนำไฟล์ randomTrips ไปใส่ใน Folder ที่มี file Map (.net)ที่เราสร้างขึ้นมา แล้วเรียกใช้ code

!python randomTrips.py -n osm.net.xml -r osm.rou.xml -o trips.xml -e 100000 -p 0.5

โดยเราสามารถกำหนดระยะเวลาที่จะเพิ่มรถเข้ามาเรื่อยๆใน simulation ได้และยังสามารถกำหนด ความถี่ของการเพิ่มรถเข้ามาใน simulation ได้ดังเช่น code ที่แสดง เราจะมีระยะเวลาที่เพิ่มรถเท่ากับ 100,000 ms และ เพิ่มรถเข้ามาทุก 5 ms

หลังจาก run ตามขั้นตอนแล้วจะได้ file .rou มา

Coding

ทำการลงตัวของ SUMO-RL และ stable-baselines3

pip install sumo-rl
pip install stable-baselines3

จากนั้นทำการ import Library ที่ต้องการใช้งาน

import sumo_rl
import supersuit as ss
from stable_baselines3.common.vec_env import VecMonitor
import supersuit
from pettingzoo.utils.env import ParallelEnv
import gymfrom stable_baselines3 import A2C

เนื่องจาก stable-baselines3 เป็น Library ที่มี RL Algorithms จำนวนหนึ่งให้เลือกใช้งานเพราะฉะนั้นเราจึงต้องเลือก Algorithms ที่สามารถนำมาใช้งานได้และเหมาะสมกับตัวโครงงานของเรา

อ้างอิง : https://stable-baselines3.readthedocs.io/en/master/guide/algos.html

โดยตัวของ Algorithms ที่เลือกใช้ได้ต้องสามารถ ส่ง (Action) เป็น Discrete ได้ และรับข้อมูล (Observation) เป็น Box ได้เนื่องจากสกุลไฟล์ทั้งสองประเภทตรงกับการ run คำสั่งบน SUMO-RL ทำให้ Algorithm ที่เลือกใช้ได้หลักๆจะมี A2C, DQN และ PPO

หลังจากนั้นเราจะนำ Algorithms ทั้ง 3 แบบมาลอง Train ใน map อย่างง่ายเพื่อทดสอบความเหมาะสมกับตัวโครงงาน โดยใช้จำนวนครั้งในการเทรนเท่ากัน เวลาใน simulation เท่ากัน delta time เท่ากัน เพื่อดูความสามารถของ Algorithm โดยวัดจาก reward และ เวลาที่ใช้ในการ train ที่แต่ละตัวทำได้

Map อย่างง่าย (single-intersection) จาก https://github.com/LucasAlegre/sumo-rl

โดยกำหนดให้ delta_time = 10 mSec simulation run ครั้งละ 20,000 mSec และ train 20,000 ครั้ง เป็นตัวแปรต้น เพื่อที่ดูความแตกต่างของ Reward และ ผลลัพท์ต่างที่ได้ของ Algorithm แต่ละแบบ

Example code for A2C model

#A2C model 
import gymfrom stable_baselines3 import A2Cenv = sumo_rl.parallel_env(net_file='sumo-rl-master/nets/single-intersection/single-intersection.net.xml',
                  route_file='sumo-rl-master/nets/single-intersection/single-intersection.rou.xml',
                  use_gui=False,
                  delta_time = 10 ,
                  num_seconds= 20000)env = ss.pettingzoo_env_to_vec_env_v1(env)
env = ss.concat_vec_envs_v1(env, 2, num_cpus=1, base_class='stable_baselines3')
env = VecMonitor(env)env.reset()model = A2C('MlpPolicy', env, verbose=1)
model.learn(total_timesteps=20000)

Result

หลังจากลองใน input ที่เหมือนกันทั้ง 3 ตัวแล้วจึงได้ข้อสรุปว่า model ที่สร้างจาก A2C ได้ reward สูงที่สุด(ค่าที่ขีดเส้นใต้)และ ยังใช้เวลาในการ train น้อยที่สุดอีกด้วย ซึ่งแสดงให้เห็นว่า model ที่สร้างจาก A2C สามารถทำให้ถนนมีความหนาแน่นได้น้อยที่สุด เนื่องจาก Reward ของโครงงานเราขึ้นอยู่กับ ความหนาแน่นของรถบนท้องถนน ทำให้เราตัดสินใจเลิก A2C สำหรับการนำไปใช้ในการ train model จาก map ที่จะ import เข้ามาใน simulation ต่อไป

Comparison

ตัวอย่าง Sitmulation ที่ไม่ผ่านการ train แล้วตั้งเวลาให้ไฟจราจรเปลี่ยนสลับไฟแดงไฟเขียวทุก 5 วินาทีใน simulation

ตัวอย่าง Sitmulation ที่ใช้ model ที่ผ่านการ trian โดยใช้ Algorithm A2C train ตามข้อมูล และ code ที่กล่าวไปข้างต้น

จากการเปรียบเทียบ simulation ทั้งสองจะเห็นได้ชัดว่าแม้กระทั่งสี่แยกอย่างง่ายที่สุด การเปิดปิดไฟโดยตั้งเวลาไว้ไม่ได้มีประสิทธิภาพที่ดีเท่าไหร่นัก แต่กลับกันหลังจากการ train แค่ 20,000 ครั้ง จะเห็นถึงความแตกต่างที่ชัดเจนของสภาพท้องถนนว่ามีความคล่องตัวเพิ่มขึ้นอย่างมาก นี่จึงเป็นข้อพิสูจน์อย่างหนึ่งว่า การใช้ AI เข้ามาช่วยในการจัดการควบคุมสัญญาณไฟจราจรมีประสิทธิภาพมากกว่า การตั้งเวลาเปิดปิดไฟจราจรซึ่งใช้อยู่ในปัจจุบัน และมีแนวโน้มที่จะมีประสิทธิภาพในการทำ simulation ของ map ที่ซับซ้อนกว่านี้ และมีประสิทธิภาพในการนำไปใช้ใน map จากโลกจริง

ปัญหาการใช้ Map จาก OSM ไม่ได้

ปัญหาสำคัญของโครงงานนี้ที่ยังต้องหาทางแก้ไข และปรับปรุงต่อไปก็คือ map จากเส้นทางจริงที่ถูก import มาจาก OSM มีความผิดพลาดของเส้นถนนอยู่มากมาย เช่น สัญญาณไฟจราจรที่มีมากกว่าหนึ่งอันในหนึ่งแยก เส้นทางถนนที่เกิดการทับซ้อนกันของ map ทำให้รถวิ่งขวางเส้นทางกันเอง(ซึ่งไม่ควรเกิดขึ้นกับสถานที่จริง) ปัญหาถนนที่เป็นทางตันทำให้รถบางส่วนวิ่งวนและเกิดการติดขัดไปสู่ทั้งระบบ และทำให้เป็นปัญหาในการ import มาให้ RL เรียนรู้ จากปัญหาดังกล่าวทำให้เราตัดสินใจว่า โครงงานนี้จะใช้ map ที่มีอยู่จาก Library SUMO-RL ที่มีความซับซ้อนมากขึ้นและใกล้เคียงกับ map ในสถานที่จริงมากที่สุด แทนการใช้ map ที่มีในสถานที่จริง

Train Final Model

หลังจากที่เราเตรียมชุดข้อมูลทุกอย่างที่จำเป็น และ เรียนรู้การ Train model เบื้องต้นแล้ว เราจะเริ่มเข้าสู้การ Train model จาก map ที่มีความซับซ้อนมากยิ่งขึ้น โดยเราเลือกใช้ map ingolstadt7 ซึ่งเป็น map ่ที่มีมาให้ใน file ของ Librart SUMO-RL โดยขั้นตอนจะเหมือนกับที่เคยกล่าวไปข้างต้น

#A2C model 
import gymfrom stable_baselines3 import A2Cenv = sumo_rl.parallel_env(net_file='sumo-rl-master/nets/Test3/kaset.net.xml',
                  route_file='sumo-rl-master/nets/Test3/kaset.rou.xml',
                 use_gui=False,
                 begin_time = 500,
                 delta_time = 10 ,
                 num_seconds= 8000 )
 
env = supersuit.pad_observations_v0(env)
env = supersuit.pad_action_space_v0(env)
env = ss.pettingzoo_env_to_vec_env_v1(env)
env = ss.concat_vec_envs_v1(env, 2, num_cpus=3, base_class='stable_baselines3')env.reset()model = A2C('MlpPolicy', env, verbose=1 , tensorboard_log= "./a2c_cartpole_tensorboard/")
model.learn(total_timesteps= 20000 , log_interval = 100 )

โดยใช้ code นี้ในการเทรนใน map และ กำหนดทุกๆไฟจราจรให้เปิดปิดสลับไฟแดงและไฟเขียวทุกๆ 15 วินาที โดยใช้โปรแกรม netedit ซึ่งเป็นโปรแกรมที่มีมาพร้อมกับตอนที่โหลด SUMO simulation เพื่อตัววัดผลและความสามารถของ model

โปรแกรม netedit ตั้งค่าให้ไฟจราจรสลับทุก 15 วินาที

ผลลัพท์ที่ได้จากการ Train เราจะตั้งค่า Simulatiion โดยใช้สีในการแสดงถึง เวลาที่รถแต่ละคันต้องหยุดนิ่งรอไฟจราจร โดยไล่จากสีโทนเย็น(น้ำเงิน) ไปถึงสีโทนร้อน(สีแดง) แสดงเวลาที่รถต้องรอจากน้อยไปมากตามลำดับ ดังรูปด้านล่าง โดยที่สีโทนเย็นแสดงว่ารถหยุดนิ่งน้อย (รถไม่ติด) และสีโทนร้อนแสดงว่ารถหยุดนิ่งนาน (รถติดมาก) และ ใช้ file รถยนต์(.rou) ตัวเดียวกันเพื่อควบคุมจำนวนรถว่าทั้งสองแบบมีจำนวนรถที่เท่ากัน

จะเห็นได้อย่างชัดเจนจากสีของรถยนต์ และ จำนวนรถยนต์ที่อยู่ในภาพ ว่าการเปิดปิดไฟทุกๆ 15 วินาทีนั้น มีประสิทธิภาพน้อยกว่า model ที่ผ่านการ Train โดยดูความหนาแน่นของรถยนต์เป็น reward และสามารถ update ตัวเองตลอดเวลา อย่างเห็นได้ชัด

การเซฟโมเดล

เราจะใช้คำสั่ง ข้างล่าง เพื่อ save model ที่ train แล้วออกมาเป็น file

model.save("Test_RL")

ถ้าเราต้องการใช้งาน model หรือ ต้องการนำ model ไป train ต่อจะใช้คำสั่ง

model = A2C.load("Test_RL")

เพื่อเรียก model มาใช้งาน

โดยเรานำตัว model ที่ผ่านการ train นี้ export โดยใช้ Library streamlit ในการสร้างเว็บสำหรับการทดลองใช้ simulation นี้

สามารถลอง model ที่ train แล้วกับ map ตัวอย่างที่กล่าวไปข้างต้นได้จาก Link https://share.streamlit.io/nadoltitan/rl_in_traffic_management/main/app.py / ติดตั้งและใช้งานตามข้อมูลที่ระบุภายในเว็บ

Summary

โครงงานนี้ริเริ่มจากการหาทางแก้ไขปัญหา รถติด ในกรุงเทพมหานคร โดยที่เราจะนำหลักการ Reinforcement Learning มาควบคุมไฟจราจรต่างๆเพื่อหา solution ที่ดีที่สุดในการเปิดปิดไฟจราจรเพื่อลดความหนาแน่นบนท้องถนน โดยจำลองท้องถนนใน SUMO simulation

โดยเราจะ กำหนด Reward ของ model โดยขึ้นอยู่กับความหนาแน่นของรถบนท้องถนน กล่าวคือ ยิ่งความหนาแน่นมาก Reward จะยิ่งติดลบทำให้ model จะพยายามทำให้ท้องถนนมีความหนาแน่นน้อยที่สุดนั่นเอง

ปัญหาที่เจอระหว่างการทำโครงงาน คือ ปัญหาในการสร้าง file รถยนต์บน simulation ต่างๆ จึงแก้ไขปัญหานี้โดยการใช้ tool randomTrips ในการสร้าง file รถยนต์ขึ้นมา

Future Plan

ในขณะนี้ ตัว model ที่ทำออกมาเป็น simulation ที่ยังไม่ได้อ้างอิงข้อมูลรถยนต์จากชีวิตจริงมาใช้ และ map ที่ import จากเส้นทางจริงยังติดปัญหาต่างๆที่รอการแก้ไข ทำให้ยังไม่สามารถ Train model บนสถานการณ์จริงได้

อย่างไรก็ตาม โครงงานนี้แสดงให้เห็นถึงแนวโน้มและความเป็นไปได้อย่างสูงที่จะสามารถนำไปใช้จริงได้ โดยที่ตัวของ map ถ้ามีเวลาในการปรับปรุง และ แก้ไขแบบ manual และลงรายละเอียดต่างๆต่อไปก็สามารถนำไปใช้ Train ได้ทันที และหลังจากการ train โดยใช้ข้อมูลแบบสุ่มไปแล้ว ในส่วนของข้อมูลรถยนต์ มีแนวทางและความเป็นไปได้ที่จะหาข้อมูลดังกล่าว เช่นจาก google map หรือ จากภาพจากกล้องวงจรปิดบนถนนของตำรวจจราจร และ กทม. ถ้าเราสามารถได้ข้อมูลดังกล่าวและเก็บข้อมูลเหล่านั้นมาเป็น Input ให้กับโครงงานของเราได้ ขั้นตอนต่อไปก็คือการเปลี่ยน Output ให้เชื่อมตรงกับสัญญาณไฟจราจรจริงๆในแต่ละสถานที่ ใช้ AI ช่วยในการบริหารจัดการสัญญาณไฟจราจรอย่างมีประสิทธิภาพ ภาพที่รถติดน้อยลงคงเป็นไปได้ไม่เกินฝันอย่างแน่นอน