In this emerging technology, we are Leveraging Machine Learning with Text to Speech model which is the preferred tools in many services.

Benefits of Text to Speech

Accessibility is Essential

Text to Speech allows a sensational and lifelike conversation in the nature of how human speaks. Text to Speech can be applied in a wide range across all industries, that are aiming to enhace customer experiences and expand to the global market. With the use of Text To Speech, it is more user friendly and efficient that could save your time and money. Furthermore, text to speech boost up the effective branding across all the touchpoints and with the growth of Eldery users and people with literature issues.

Signal Processing and Wave Knowledges

Once we are synthesizing the speech, let’s look at the signal preprocessing stage, it is crucial to understand our dataset before training it.

We will covered mainly 3 types of the signal waves :

1. The waveforms and frequency
2. Fourier Transform
3. Spectrogram and Mel-Spectrogram

Waveforms

Waveforms are the signal that have amplitute (loudest) on the y-axis and time domain on the x-axis. Raw audio is a type of the waveforms.

Frequency

Fourier Transform

We are decomposing frequency from the original sound wave, to extract more features, learn significant insights from the wave sound and it is much easier to process the wave sound.

In a millisecond of the wave signal, there are monochannel and multiple channels (stereo). In order to extract different properties of the sound, we use “Fourier Transform”.

Spectrograms

A spectrogram is a visual representation of the spectrum of frequencies of a signal as it varies with time. — wikipedia

The mel-spectrogram is manipulating the idea how our ears works, we are taking log or multiplying it to the mel-filterbank, to get the mel — spectogram.

The journey of the Wave :

1. Raw audio
2. Spectrogram ( Raw audio take Furior Transform )
3. Mel-Spectrogram (multiply by a log-alike scale called mel-scale which mimics the frequency range of how human’s ears perceive)

One Full History of TTS

Tacotron2

Tacotron 2 is the very natural sounding of synthesizing the speech by using the advancing AI and ML technology by just using the text, without any redundant specifications of the acoustic features.

The Tacotron2 is the neural network model that researchers around the globe aimed for, we are manipulating the most nature, human-liked sound, that was synthesized and without having sophisticated linguistic and acoustic features as input. The input of Tacotron2 is only the sound waves and the script files.

Why do we choose tacotron : The Ease of Data Preparation

ALL WE NEED to train the model
is the AUDIO WAVE and the SCRIPT!

Tacotron 2 Architecture

Tacotron2 split in 2 main parts :

1. Spectrogram Prediction
   Spectrogram Prediction Network is a seq2seq attention mechanism which combines with Short Time Furior Transform (STFT) and Autoencoder.
2. WaveNet vocoder
   Vocoder (Voice Encoder) is a synthesizer and analyser of the input mel-spectrogram. History of Vocoder

Conclusion

Signal Waves

There are 3 types of the signal waves :

1. The waveforms and frequency
2. Fourier Transform
3. Spectrogram and Mel-Spectrogram

One Full History of Text To Speech

Starting from the Traditional Method and then enhancing with the Machine Learning approach of text synthesizer with Wavenet. During this modern days, we have Tacotron2 with an exceptional performance and ease of data preparation.

Lifelike Speech Synthesis | Thai Text To Speech with Tacotron2

Thai Text To Speech with Tacotron2 | Lifelike Speech Synthesis

Introductory of Speech and Signal Processing | Lifelike Speech Synthesis was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

True Lab Startup Sandbox

For young startups in robotics and AI

ภายใต้ Startup Sandbox โครงการ True Lab Startup Sandbox จัดขึ้นเพื่อสตาร์ทอัปยุคใหม่และผู้มีหัวใจผู้ประกอบการที่สนใจด้าน Robotic และ AI เชิญมาร่วม hack idea และคัดเลือกสมาชิกทีมไปกับกลุ่มทรู ทีมที่ผ่านการคัดเลือกจะได้รับทุนพัฒนาต้นแบบและสิทธิในการใช้พื้นที่ทำงานที่ทรู ดิจิทัล พาร์คฟรี ตลอดระยะเวลาร่วมโครงการ และยังได้เป็นสมาชิก co-working space ต่อหลังจบโครงการอีก 3 เดือน รวมเงินรางวัลทั้งสิ้น 1.5 ล้านบาท

คัดเลือกเข้าร่วม Hackathon (2 วัน 1 คืน ที่ ทรู ดิจิทัล พาร์ค) ทั้งหมด 10 ทีม (ทีมละ 3–5 คน)

และจะรับเพียง 4 ทีมที่มีผลงานดีที่สุดเข้าร่วมโครงการ

Introduction

เนื่องด้วยโอกาสที่เจ้าของบทความ ทีม DeepSec ได้มีโอกาสได้รับคัดเลือกในโครงการ True Lab Startup Sandbox จึงอยากจะแชร์ประสบการณ์การแข่งขัน Hackathon ให้เพื่อนๆที่มีความสนใจใน Start Up เหมือนกัน

โดยการแข่งครั้งนี้จะมาใน Theme ของ Image Recognition และ Speech Recognition

โจทย์ของ True Lab Startup Sandbox Hackathon จะเป็นเช่นใด ? ทางทีม DeepSec จะมีวิธีการใดแก้ไขปัญหา ? เพื่อนๆสามารถติดตามชมได้พร้อมๆกันเลยครับ

Problem

• ถ้าคุณเป็นเจ้าของธุรกิจจำหน่ายสินค้า เคยไหม? ที่ต้องเดินเช็คของทุก 30 นาที หรือทุกๆครึ่งชั่วโมง เพื่อตรวจสอบสินค้าว่ามีเพียงพอสำหรับการจำหน่ายแก่ลูกค้าหรือไม่
• จะเป็นไปได้หรือไม่ ถ้าจะมีระบบช่วยแจ้งเตือนจำนวนสินค้าที่ใกล้จะหมด ให้กับพนักงานในร้านค้า
• แข่งขันเพื่อสร้างและพัฒนาระบบปัญญาประดิษฐ์สำหรับระบุจำนวนสินค้าบนชั้นวางของ

Data

Train Set เป็น Video ~ 15 File ; File ละ 45 ถึง 90 นาที โดยจะเป็นภาพจากกล้อง Video ที่ถ่ายไปยังตู้แช่เช่นเดียวกับภาพตัวอย่าง

ที่น่าสนใจคือ หลายๆ Video ตำแหน่งของกล้องเป็นคนละมุมกัน (น่าจะมาจากคนละร้าน ) และจำนวนแถวอาจจะไม่ตรงกัน เช่น Video A มีน้ำสิงห์ 3 แถว Video B อาจจะมี น้ำสิงห์ 6 แถวได้

Test Set เป็น File Image 50 ภาพ โดยจะให้มาในภายหลัง (กลัวว่ามีคนนั่งนับส่ง)

Naive Solution

ในเมื่อโจทย์ “ต้องการระบุจำนวนสินค้า” ที่วางบนชั้นวางของ เราสามารถมั่นใจได้ ว่า โจทย์นี้เป็น Object Detection อย่างแน่นอน

แต่สังเกตว่า เราไม่สามารถนับว่ามีสินค้าเท่าไหร่ได้ตรงๆ เนื่องจากสินค้าวางซ้อนกัน บางครั้งอาจจะเห็นแค่สินค้าที่วางข้างหน้าสุดเท่านั้น

เมื่อจินตนาการไปถึงเวลาที่เราเข้าไปใน Super Market หรือ 7/11 สังเกตได้ว่า สินค้ามักจะวางอยู่เต็ม(หรือเกือบเต็ม) เสมอ เนื่องจากมีพนักงานเติมอยู่ตลอด

เมื่อคิดอย่างไร้เดียงสา(Naive)ที่สุดแล้ว จาก Data ที่ให้ความลึกของ Shelf และ รัศมีของ Product เราสามารถคำนวณได้ว่า “Product A 1 แถว จะมี Product A nชิ้น ”

เมื่อเราทราบว่า มี Product A m แถว เราจะสามารถทราบได้ว่า มี Product A n*m ชิ้น

เมื่อลองตรวจ Data ดู พบว่า เมื่อสินค้าหายไปเพียง 4–5 ชิ้น ก็มักจะมีพนักงานมาเติมแล้ว ซึ่งถูกต้องตามสมมุติฐานข้างต้น

โดยการที่สินค้าหายไป 4–5 ชิ้น เทียบกับสินค้าที่นับถูกประมาณ 100–150 ชิ้น คิดเป็น Accuracy ประมาณ 95% ซึ่งถือว่าเป็น Accuracy ที่ดีมากสำหรับ Naive Solution

Pipeline แรก สำหรับโจทย์ข้อนี้จึงเป็น “Product A1 — A10 มีชนิดละกี่แถว?”

Labeling Policy

ปัญหา Labeling ที่มักจะเกิดขึ้นคือ เราไม่ได้วางนโยบาย(Policy) ที่ดีพอ ส่งผลให้ Data ที่แต่ละคน Label มา มีลักษณะไม่เหมือนกัน ซึ่งถ้า Model ไป Train อาจจะเกิดปัญหาได้ ( Garbage in , Garbage out )

ซึ่ง Policy ที่ทีมวางไว้คือ

• Label เฉพาะขวดที่เห็นเต็มๆ ข้างหน้าสุด
• ถ้าขวดแรกถูกหยิบไป ให้ Label ขวดที่ 2 ( ในกรณีนี้ จะเห็นแบบเต็มขวด เพราะไม่มีขวดที่วางข้างหน้า )

โดยไม่รู้ตัวเลยว่า Policy ที่วางไว้โดยไม่ละเอียดพอ จะทำให้เกิดปัญหาในภายหลัง

รู้จักกับ “เครื่องมือสร้าง Annotations” (Annotation tools)

เพราะ Object Detection เป็นการหาว่า “Object ที่สนใจ อยู่ส่วนไหนของภาพ” Label(คำตอบ) ของ Object Detection ย่อมเป็น “ตำแหน่ง X,Y ของมุมทั้ง 4 ของ Object ที่สนใจ”

ถ้าคำตอบของ Image Classification เรียกว่า “Label” เราจะเรียกคำตอบของ Object Detection ว่า “Annotations”

ปัจจุบัน เครื่องมือในการสร้าง Annotations มีอยู่หลายตัวเช่นกัน ที่ถูกพูดถึงมากที่สุด คงจะเป็น labelme ที่ เล็ก , ติดตั้งได้ง่าย , ทำงานได้หลายระบบปฏิบัติการ

เพื่อป้องกันความยุ่งยาก เมื่อมีการ Labeling มากกว่า 1 คน ทั้งเรื่องการแจกจ่ายงาน การรวมไฟล์ที่ Label แล้ว ทางทีมจึงตัดสินใจที่จะใช้ CVAT ซึ่งเป็น Online Annotations Tools

ปัญหาของการ Labeling Data

เนื่องจาก สมาชิกมี 5 คน แบ่งกันคนละ 300 Images , 1 Images มี 30 Instances+ (นับจากภาพตัวอย่าง) สรุป 1 คนทำ Annotations 9,000 Instances

1 Annotations ใช้เวลาไวที่สุดคือ 2 วินาที สมมุติว่าทำได้ด้วยความเร็วแบบไม่มีตกเลย ต้องใช้ 18,000 วินาที หรือ 5 ชั่วโมง/คน

นี่มัน Hackathon หรือคำสาปแห่งซิซีฟิส (Sisyphus) ทางทีมจึงเสนอ ลดงานเหลือ 1/2 (ราวๆ 750 Images ) ซึ่งแน่นอนว่า ทุกคนในทีมเห็นพ้องต้องกัน

ซึ่งกรณีนี้ แต่ละภาพใน Train Set มีหน้าตาใกล้เคียงกันมาก (มาจาก Video เพียง 15 File หมายความว่ามีอย่างมากที่สุด 15 มุมกล้อง ) การจะ Train ภาพที่ใกล้เคียงกันมากๆ อาจไม่มีความจำเป็นขนาดนั้น การลด Train Images ลงครึ่งนึง จึงดูเป็นเหตุผลที่รับได้

อย่างไรก็ดี การ Label อย่างต่อเนื่อง 2.5 ชั่วโมง ก็ยังเป็นงานที่ค่อนข้างหนัก โชคดี CVAT มีเครื่องมือที่ชื่อ “Propagate” ที่สามารถ “ส่งต่อ” Annotations ของภาพหนึ่งๆ ไปภาพอื่นได้

ด้วยวิธีดังกล่าว สามารถลดเวลา Label เหลือแค่ประมาณ 1 ชม. เท่านั้น (งานลดลง แต่ท้ายที่สุด ต้องใช้เวลาในการตรวจเช็คผลลัพท์ของการ Propagate)

บทส่งท้าย

ผ่านมาครึ่งทางแล้วกับบทความนี้ สังเกตว่ายังไม่มีการพูดถึง Model ที่ใช้เลย (ไม่มีแม้แต่การ Coding) ซึ่งจริงๆแล้ว การตั้งคำถาม , การคิดวิธีในการแก้ไขปัญหา , การจัดการ Data (Pre-process) นั้นสำคัญไม่แพ้การสร้าง Model หรือ Coding เลย

หลังจาก Naive Solution แล้ว ทีม Deep Sec จะใช้วิธีการใด , ใช้ Model ตัวใด สามารถติดตามได้ในบทความต่อไปนะครับ

ส่วนเพื่อนๆที่สนใจโครงการนี้ ในวันนี้(7/30/2021) ทางโครงการ True Lab Startup Sandbox ได้มีการรับสมัครรุ่นที่ 2 แล้ว ซึ่งคราวนี้ มีในธีม Business Analytics สามารถฟอร์มทีมแล้วเริ่มสมัครกันได้เลย สามารถอ่านรายละเอียดเพิ่มเติมได้ที่ https://bit.ly/3wUkPQW

หรือทาง Fanpage https://www.facebook.com/TrueDigitalPark

Ref

YOLO Format https://github.com/AlexeyAB/Yolo_mark/issues/60

LabelMe https://github.com/wkentaro/labelme

YOLOV5 ,Tips for Best Training Results https://github.com/ultralytics/yolov5/wiki/Tips-for-Best-Training-Results

Sisyphus https://en.wikipedia.org/wiki/Sisyphus

https://www.facebook.com/TrueDigitalPark

https://medium.com/analytics-vidhya/image-classification-vs-object-detection-vs-image-segmentation-f36db85fe81

True Lab Startup Sandbox Ep.1 was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

สำหรับงานสาย Data Sci หรือ Hackathon ก็ตามที เพื่อนๆมักคุ้นชินกับ การใช้ Google Colab หรือการทำบน Localhost ใช่ไหม

ซึ่งในหลายๆงาน ไม่ว่าจะเป็นงานวิจัย หรือ Hackathon มักจะมี Cloud ให้ใช้ หลายๆคนอาจจะไม่คุ้นชิน ซึ่งคงเป็นเรื่องที่น่าเสียดายมาก ถ้า Facility ที่ได้มาให้คุ้ม

อนึ่ง จริงๆ Cloud ไม่ว่าจะเป็น GCP , AWS , Huawei ก็ Setting คล้ายๆกัน (เพราะเป็น Ubuntu ) บทความนี้จึงสามารถปรับใช้กับ GCP , AWS ได้อีกด้วย

TL;NR

• ใน Windows OS เราสามารถใช้ Bitvise แทน Putty , FileZilla ได้
• Jupyter Lab มีบน Anaconda Version ใหม่ ซึ่งจริงๆ เราสามารถ Download & Install Anaconda ก็สามารถใช้ Jupyter Lab ได้เลย
• Anaconda Version ใหม่ set Path ให้เราเองเวลา Install ไม่ต้องไปแก้ .bashrc อีกต่อไป
• เพื่อที่จะเรียก Jupyter Lab บน Server จากเครื่องเราได้ ต้องทำการ Bind IP ก่อน

0. รู้จักกับ Bitvise

ปกติเราจะใช้การ SSH (Secure Shell) ผ่าน CMD กันใช่ไหม แต่ SSH ของ window จะ Disconnect เอง เมื่อไม่ได้รับ Response ในระยะเวลาหนึ่ง

หลายๆคนอาจจะแก้ปัญหา ด้วยการใช้ Putty แทน ซึ่งสามารถใช้แทน SSH บน CMD ได้

แต่ตัว Putty ไม่สามารถ FTP ได้ จึงต้อง FTP ผ่าน FileZilla แทน แต่หมายความว่า เราต้อง Login 2 Program ซึ่งถือว่ายุ่งยากระดับหนึ่ง ( แล้วตัว Putty กับ FileZilla นี่ไม่ได้ใช้ง่ายนะ ใช้ครั้งแรกต้องมางมแน่ๆ )

ผู้เขียนบทความจึงเสนอให้ใช้ Bitvise แทน โดยสามารถเป็นได้ทั้ง FTP และ SSH ซึ่ง UX&UI ถือว่าใช้ง่ายอย่างสุดๆ ประเภทที่ ใส่ HOST , Username , Password (Port ก็ไม่ต้องใส่ ถ้าเป็น default) ก็สามารถใช้ได้ทันที

อนึ่ง OSX , Linux ไม่มี Bitvise ใครใช้ระบบดังกล่าว ต้องใช้วิธี SSH , FTP แบบเดิม

1. Install Anaconda

1.1 Download Anaconda

Anaconda เป็น Starter Package ของ Python ส่วนตัวผู้เขียนบทความ Download ด้วย wget ผ่าน tsinghua.edu

โดยให้เลือก Download Link ที่เป็น Linux-x86_64.sh เพราะเราทำงานบน Ubuntu-64bit

อย่างไรก็ตาม ถ้า tsinghua.edu เกิดเข้าไม่ได้หรือไม่อัพเดท เพื่อนๆยังสามารถ Download ผ่าน Official Website ได้

1.2 Install Anaconda

สำคัญ ถ้าเป็น Version เก่าๆ เราจะต้อง set enviroment path เอง แต่ถ้า version ใหม่ Anaconda จะถามว่า จะให้ set Enviroment path ไหม ให้ตอบ yes ไป

สำคัญ เวลา set Enviroment Path ทุกครั้ง ต้อง Restart Terminal ่ด้วย(ในที่นี้คือปิดแล้วเปิดใหม่)

2. Install Jupyter lab

Anaconda version ใหม่ๆ ปกติจะติดตั้ง Jupyter Lab ให้แล้ว สามารถทดสอบเปิดได้ผ่านคำสั่งด้านล่าง

3. Binding IP

ก่อนจะไปขั้นตอนต่อไป ต้องเข้าใจเรื่อง Inbound & Outbound ก่อน

เมื่อเราเรียก Jupyter Lab ผ่าน localhost:8000 ซึ่ง Port 8000 ถือเป็น Inbound เพราะเรียกจาก Host เอง

ทางกลับกัน สมมุติเราเรียก SSH ผ่าน ssh user@IP -p 26 , Port 26 นี้ ถือเป็น Outbound เพราะถูกเรียกจาก Client -> Host

Inbound Port, Outbound Port ถือว่าเป็นคนละ Port กัน การที่เรา Mapping Outbound Port : Inbound Port เรียกว่า “การ Bind IP”

ในที่นี้ เมื่อเราต้องการเรียกใช้งาน Jupyter Lab จาก Server สังเกตว่าเป็นการเรียก Outbound Port ของ Client ไป Inbound Port ของ Server ในกรณีนี้ ถึงต้อง Bind IP

ซึ่งวิธีที่ง่ายที่สุด คือ แก้ config บนใน file jupyter_notebook_config.py

4. Start Jupyter Lab Server

จากนั้น เราจะสามารถเรียก IP.huawei.cloud@8080 ผ่าน Web Browser ได้แล้ว

หลังจากนี้ก็สามารถใช้ Conda Install เพื่อติดตั้ง Package ที่จำเป็นเหมือนที่เพื่อนๆเคยทำได้เลย

ในส่วนท้ายของบทความนี้ ต้องขอขอบคุณทาง Huawei Cloud และ True Lab Startup Sandbox ที่จัดการแข่งขันที่น่าสนใจ และเพื่อนๆที่อ่านบทความนี้จนจบด้วยนะครับ

PS.เพื่อนๆที่เซิร์ซเจอบทความนี้ ต้องกำลังแข่ง Hackathon อยู่อย่างแน่นอน (เหมือนเจ้าของบทความในวันนั้น) ขอให้เพื่อนโชคดีกับการแข่งนะครับ

Ref

https://www.programmersought.com/article/47726882708/

https://stackoverflow.com/questions/18675907/how-to-run-conda

https://stackoverflow.com/questions/1621457/about-ip-0-0-0-0-in-django

How to set up Jupyter Lab on Huawei cloud was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

Communication is extremely important! The easiest and quickest ways to communicate and understand each other is the “speech”. :)

1. Generate

2. Recognize

3. Analysis

1. How to apply machine learning and deep learning methods to audio analysis

Audio Analysis — >

Machine Learning for Audio: Digital Signal Processing, Filter Banks, Mel-Frequency Cepstral Coefficients

DCT for Speech Signal Compression

DCT for Speech Signal Compression

https://www.researchgate.net/publication/301552643_Audio_and_Speech_Compression_Using_DCT_and_DWT_Techniques

Mel- frequency Cepstrum MFCC

Mel Frequency Cepstral Coefficients (MFCCs)

MFCC is used for the process of feature extraction where a more compact and less redundant of the representative voice can be obtained from the input voice

Filter bank — Compressed Spectrogram manipulate our ear

Speech recognition is still a growing field. … Fast Fourier Transform (FFT) is the traditional technique to analyze frequency spectrum of the signal in speech recognition.

Wavenet

Conditional WaveGAN Explained

• Conditional WaveGAN Explained
• chaeyoung-lee/cwavegan

NGC

NVIDIA NGC

Real Time Cloning

GitHub - CorentinJ/Real-Time-Voice-Cloning: Clone a voice in 5 seconds to generate arbitrary speech in real-time

Dog voice Identification

Dog voice identification (ID) for detection system

https://www.researchgate.net/publication/261394450_Dog_voice_identification_ID_for_detection_system/link/548e989a0cf214269f244515/download

Automatic Cry Recognition

Baby voice Detection

Voice Synthesis

Mean Opinion Score (MOS) for each voice. Test subjects ranked each voice on a scale of 1–5 according to how much it sounded like natural speech.

Conditional Voice Synthesis

Pixel Recurrent Neural Networks

Pixel Recurrent Neural Networks

Keywords from the Meeting

Low pass feature

Fourier Transform and then transform back

THAI SER

IEMOCAP

Speech Emotion Recognition IEMOCAP

— -

CSTR voice cloning toolkit (VCTK)

44 hours from 109 speakers

https://www.researchgate.net/publication/346248936_Non-parallel_Voice_Conversion_based_on_Hierarchical_Latent_Embedding_Vector_Quantized_Variational_Autoencoder

• Unsupervised speech representation learning using WaveNet autoencoders
• Generating Diverse High-Fidelity Images with VQ-VAE-2
• Uncovering Latent Style Factors for Expressive Speech Synthesis
• Audio samples from "Uncovering Latent Style Factors for Expressive Speech Synthesis"
• WaveNet: A Generative Model for Raw Audio

TenserFlow TTS(Text to Speech)

• chaeyoung-lee/cwavegan
• ljspeech | TensorFlow Datasets
• Tacotron: Towards End-to-End Speech Synthesis
• TensorSpeech/TensorFlowTTS
• Google Colaboratory

Speech Projects — Acoustical Work was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

1. Initially, we have to know about Graph
2. Graph traversal — look through the nodes in the Graph
3. In the first word, we will talk about MST (Minimum Spanning Tree)
4. The next algorithm will be the shortest path algorithms.

Graph Knowledges

As we know in our secondary schools, we all have learnt about graphs. There are many types of graph, but today we will talk about path. The famous problems about Königsberg brides, with 7 paths. Such as the Euler rule of the Königsberg bride. Have you remembered?

How could you travel to these islands without crossing the same bride twice?

When will look at graph types :
There are Nodes and Edges,

• Nodes (vertices in the graph)
• Edges

There are several ways in representing data in graph

1. Matrix Representation

2. Adjacency list

Furthermore, there are various types of the graph such as the weighted and unweighted graph. Imagine about travelling between two towns, in each road there must be the different distance. Therefore, it shown that every route is not the same (have different weight) and we should “considered” when choosing the path.

Directed and undirected graph
When we are travelling, there might be some more factors, not every road is expressway. The expressway are called the undirected graph, which means that we could travel back and front in that path. On the contraty,

Graph Traversal

Let’s Traverse in the Graph!

Depth First Search

We will traverse in the graph, by going in depth first. Therefore, this types of traverse is Depth First Search or DFS. There are 2 ways to code the Depth First Search; by using stack and recursive function.

DFS Implementation using recursive function (code in c++) :

DFS Implementation using stack (code in c++) :

Depth First Search or DFS for a Graph - GeeksforGeeks

Breadth First Search

We will search the graph by the Breadth, this will traverse through the nearer nodes first.

BFS Implementation using queue (code in c++) :

Mahattan Distance

Lecture 0 - CS50's Introduction to Artificial Intelligence with Python

Minimum Spanning Tree

Minimum Spanning Tree’s aim is to :
connect all the nodes in the graph with the shortest distance.

In the minimum spanning tree, there must be only n-1 edges when there is only n nodes.

The Prim algorithm

• 2 subsets ( in MST or not)
• find the least weight to join the MST

1. Find the starting node
2. look through all the edges that connected to the nodes in MST
3. Select the least weight in all the edges.
4. Join the node in MST
5. Loop to all nodes until every nodes are in the MST

These are the vectors that we have to create :
1. Parent [NULL]
2. Visited [false]
3. Key [infinity] (Distance from the first nodes)
We will updates new weight (key) when it’s less than the previous key’s value.

Prim MST Implementation using priority queue (code in c++) :

Prim's Algorithm for Minimum Spanning Tree (MST) - GeeksforGeeks

The Kruskal Algorithm

• sort all the paths
• select the least weight
• join the graph if the nodes aren’t in the same subset

UNION and FIND methods :

Boruvka’s algorithm

Borůvka's algorithm - Wikipedia

1) Input is a connected, weighted and un-directed graph.
2) Initialize all vertices as individual components (or sets).
3) Initialize MST as empty.
4) While there are more than one components, do following
for each component.
a) Find the closest weight edge that connects this
component to any other component.
b) Add this closest edge to MST if not already added.
5) Return MST.

Boruvka's algorithm | Greedy Algo-9 - GeeksforGeeks

Shortest Path

Finding the shortest path between two distances.

Dijkstra Algorithm

Like Prim algorithm, will the note of keeping in mind the distance that have traverse through the whole graph.

Bellman Ford Algorithm

Using Dynamic Programming Approach

Graph Neural Network

“In this tutorial, we will discuss the application of neural networks on graphs. Graph Neural Networks (GNNs) have recently gained increasing popularity in both applications and research, including domains such as social networks, knowledge graphs, recommender systems, and bioinformatics.

While the theory and math behind GNNs might first seem complicated, the implementation of those models is quite simple and helps in understanding the methodology. Therefore, we will discuss the implementation of basic network layers of a GNN, namely graph convolutions, and attention layers. Finally, we will apply a GNN on a node-level, edge-level, and graph-level tasks.”

• Graph Neural Networks: A Review of Methods and Applications
• Google Colaboratory

Couclusion and use cases

Graph can be extremely useful in many real-world problems, of minimizing loss in every paths, that we have walk or even a journey or route that is planned for your trip. Gets everyday easier, more convinient with graph traversal in your trip to get a happier trip.

The algorithm are as follows:
Prim Algorithm
Kruskal Algorithm
Dijkstra Algorithm

Have fun exploring Graph! See you!

Book suggestion

Competitive Programmer’s Handbook

https://cses.fi/book/book.pdf

References

Graph Algorithms was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

ในบทความนี้ก็ต่อจากบทความที่แล้ว

วิธีติดตั้ง YOLOv5 บน Windows 10

และก็จะขอต่อจากบทความที่แล้วหน่อยนะครับ สำหรับคนที่มีปัญหาระหว่างลง pycocotools เช่นติดตั้ง Build Tools ไปแล้ว แต่ยัง Build Wheel ไม่ผ่าน!

ณ ตอนนี้มี Package ที่ชื่อว่า pycocotools-windows ซึ่ง Build สำหรับ Windows 10 มาพร้อมแล้ว สามารถ Copy คำสั่งได้จากด้านล่างเลยครับ 😁

pip install pycocotools-windows

เอาละครับ ถ้าติดตั้งได้แล้ว เรามาได้วิธีการใช้มันกันดีกว่า 🤔

เมื่อเราโหลด Repository ของ YOLOv5 มาแล้ว เรามาดู File กับ Folder ก่อนดีกว่า ว่าแต่ละ File ทำอะไรและแต่ละโฟลเดอร์เก็บอะไร 🤔

.
├── Dockerfile
├── LICENSE
├── READMEt.md
├── data
│   ├── argoverse_hd.yaml
│   ├── coco.yaml
│   ├── coco128.yaml
│   ├── hyp.finetune.yaml
│   ├── hyp.scratch.yaml
│   ├── images
│   ├── scripts
│   └── voc.yaml
├── detect.py
├── hubconf.py
├── models
│   ├── __init__.py
│   ├── __pycache__
│   ├── common.py
│   ├── experimental.py
│   ├── export.py
│   ├── hub
│   ├── yolo.py
│   ├── yolov5l.yaml
│   ├── yolov5m.yaml
│   ├── yolov5s.yaml
│   └── yolov5x.yaml
├── requirements.txt
├── runs
│   └── detect
├── test.py
├── train.py
├── tutorial.ipynb
├── utils
│   ├── __init__.py
│   ├── __pycache__
│   ├── activations.py
│   ├── autoanchor.py
│   ├── aws
│   ├── datasets.py
│   ├── general.py
│   ├── google_app_engine
│   ├── google_utils.py
│   ├── loss.py
│   ├── metrics.py
│   ├── plots.py
│   ├── torch_utils.py
│   └── wandb_logging
└── weights
    └── download_weights.sh

14 directories, 35 files

1. Dockerfile, LICENSE และ README.md — ก็ตามชื่อครับ 😐
2. data — โฟลเดอร์ที่จะเก็บ Dataset ในรูปแบบของ YOLO Format 🤨
3. detect.py — ไฟล์ที่เอาไว้ Run Detection 😀
4. hubconf.py — สำหรับ Access ใช้โมเดล YOLOv5 ผ่าน TorchHub 😮
5. models — โฟลเดอร์ที่เก็บ Config ของแต่ละโมเดล ซึ่งแต่ละโมเดลจะแยกออกเป็นหลายอัน ซึ่งผมจะระบุภายหลังครับ
6. requirements.txt — “เพียงแค่ pip install -r requirements.txt ก็ใช้ได้แล้ว แค่มันใช้กับ Windows 10 ไม่ได้อะ” 5555
7. runs — โฟลเดอร์นี้จะเก็บผลลัพท์การ Run จากไฟล์ detect.py และ train.py ทั้งหมดซึ่งเป็นโฟลเดอร์ Default ที่ตั้งเอาไว้
8. test.py — ไว้สำหรับ Test โมเดลที่เรา Custom เอง
9. train.py — ใช่ครับทุกคนคิดถูก มันก็คือที่เทรนโมเดลนั่นแหละ 😏
10. tutorials.py — Tutorials แหละครับตามชื่อเลย ซึ่งเขาได้เพิ่มเติม Tools ต่างๆ เช่น Monitor, TensorRT Deployment เป็นต้น
11. utils — อย่าไปยุ่งครับ เดี๋ยวมันพัง 555
12. weights — จะมี Scripts ที่เอาไว้สำหรับโหลด Weights ที่เขาเทรนมาให้เรียบร้อยแล้ว

โอเค … มาเริ่ม Detect กันแบบง่ายๆ ดีกว่า

python detect.py --help

เมื่อเราเรียก help มาเขาก็แสดง Parameters ที่ต้องการแล้ว ตัวอย่างง่ายๆ นะครับ

python detect.py --source 0             # Webcam
                          file.jpg      # Image
                          file.mp4      # Video
                          path\         # Directory
                          path\*.jpg    # glob
                          rtsp://[URI]  # RTSP Stream
                          rtmp://[URI]  # RTMP Stream
                          http://[URL]  # HTTP Stream

detect.py — นั้นรองรับการ Input ได้หลายรูปแบบ

1. Webcam — ใช้เลขในการระบุว่าเป็นกล้องตัวไหน
2. Image — Path ที่มีนามสกุลไฟล์เป็น .png, .jpg
3. Video — พอๆ กับ Image ครับแค่เปลี่ยนนามสกุลไฟล์เป็น .mp4, .avi, etc…
4. Directory — ใช้ Path ที่ลงท้ายด้วย \ (Backslash)
5. glob — สามารถใช้เครื่องหมาย * ในการระบุไฟล์ที่ต้องการจาก Directory นั้นๆ ได้เหมือนกับ Linux CLI ที่เคยใช้ๆ กัน
6. RTSP, RTMP, HTTP Streaming— แม้แต่ Protocol ต่างๆ ก็รองรับ สามารถยัด URI เข้าไปได้เลย

และยังมี Parameters อื่นๆ ที่ detect.py ทีด้วย 😮เช่น

1. source — Input ที่อธิบายไปในด้านบนอะครับ 😁
2. weights — Model ที่ใช้ในการ Detect เป็น .pt 🤨
3. device — Device ที่จะใช้ในการประมวลผลเช่น CUDA หรือ CPU 🙃
4. view-img — แสดงผลรูปภาพออกมาด้วย 😎
5. save-txt — บันทึกรายละเอียดลงเป็น .txt 😃
6. save-conf — ใช้คู่กับ save-txt ซึ่งจะบันทึก Confidence ลงไปด้วย
7. classes — คัดกรอง Class ที่จะ detect ออกมา
8. conf หรือ conf-thres — วัตถุนั้นจะถูก detect เมื่อมี confidence มากกว่าที่กำหนด

ประมาณนี้นะครับสำหรับ detect.py เรามาพูดถึงเรื่องโมเดลของ YOLOv5 ที่ถูก Pre-trained มาแล้ว 😁

https://github.com/ultralytics/yolov5#pretrained-checkpoints

แต่ละโมเดลมีความแม่นยำต่างกันไป 😶… ยกตัวอย่างโมเดล YOLOv5x มีความแม่นยำมากที่สุด แต่ก็ต้องแลกมาด้วยเวลาในการประมวณผล และไฟล์ใหญ่กว่าชาวบ้านเขา 😮

และสามารถเอา Pre-trained Model ของเขามาเทรนกับ Dataset ของเราได้ ส่วนเรื่องของเวลาในการเทรนก็ขึ้นอยู่กับ ขนาดของโมเดล, ขนาดของ Data และ เครื่องของเรา 😎

เชื่อว่าหลายๆ คนกำลังรอสิ่งนี้นั่นก็คือ … Customize Dataset คร้าบบบ!!! 😍

พูดง่ายๆ ก็คือ Detect Object ด้วย Data ของเรานั่นแหละ 🤔

YOLOv5 ใช้ data เป็น YOLO Format นะครับ ซึ่งเราต้องทำ Annotations หลังจากนั้นก็ Export ออกมาเป็น YOLO Format 🙂

ซึ่งมันเองก็มี Tools ในการทำ Annotations อยู่หลายอันนะครับ

1. CVAT — เป็น Tools ของ OpenVINO สำหรับการทำ Annotations ซึ่งเขาเปิดเป็นเว็บให้สามารถใช้ได้ฟรีแต่ก็จะมีการ Limit บางอย่างเพื่อไม่ให้เซิร์ฟเวอร์ล่ม วิธีการปลด Limit ผมแนะนำให้ Run บนเครื่องตัวเอง ซึ่งมันมี Repository ของตัวเองอยู่ สามารถโหลดมาแล้วอ่าน Installation ได้เลยครับ
2. labelImg — ต่างกับ CVAT เรื่อง UI แต่ว่ามันถูกเขียนขึ้นโดย Python และไม่มีเว็บให้ลองใช้ แต่ว่ามันฟรีครับ ใช้ง่ายมากก ลงบนเครื่องของเราได้เลย ไม่ยากครับแค่ Copy Paste เหมือนที่ทุกคนทำกันทุกวันเดี๋ยวก็ได้แล้ว

ในบทความนี้ขอใช้ Dataset ของ Dogs vs. Cats จาก Kaggle นะครับ 😎

แต่ในบทความนี้ผมจะขอยก CVAT เป็นหลักนะครับ

CVAT สามารถโหลดลงเครื่องแล้ว Run ผ่าน Docker หรือใช้บนเว็บก็ได้นะครับ แต่ผมแนะนำให้โหลดลงเครื่องเพราะว่าเราสามารถกำหนด Limit ของมันได้ 👍

กดปุ่ม Create New Task 😁

ใส่ชื่อของ Task

เพิ่ม Label ที่ต้องการ 🤔

กดปุ่ม Continue เพื่อสร้าง Class ไปเรื่อยๆ

หลังจากใส่ Class ครบแล้ว ก็กดปุ่ม Done ได้เลย~~

เลือกไฟล์ที่ต้องการที่จะ Annotate (สามารถเลือกได้หลายภาพ) 👇

ใน Advanced configuration สามารถเลือก Segment size เพื่อที่จะแยก Jobs ออกมาหลายๆ อัน (ไม่จำเป็น) ✋

หลังจากที่อัพโหลดรูปภาพแล้วก็กด Submit ได้เลย 😊

หลังจากที่สร้างเสร็จจะมี Notifications ขึ้นมาอยู่ทางด้านขวาบน 🤔

เมื่อกดเข้าไปแล้ว ก็จะมีหน้าแต่เป็นแบบนี้ 😮

ถ้าหากว่าไม่ได้กำหนด Segment size จะไม่มีการแยก Jobs ให้

แต่ว่ามันไม่จำเป็น

เพราะฉะนั้น … ต่อดีกว่า 😑

เมื่อเรากดเข้าไปใน Jobs นะครับ มันจะมีหน้าตาแบบนี้

วิธีการ Annotate นะครับ ในแถบด้านซ้าย จะมีไอคอนนี้ให้เรา *คลิก* 😁

เมื่อคลิกแล้วมันจะขึ้น Pop-up เล็กๆ และเราก็สามารถเลือก Class ในการ Annotate ได้นะครับ หลังจากนั้นเราก็ลากกรอบของเราให้อยู่ใน ROI ได้เลยย 👇

แล้วก็ทำให้ครบเลย ทุกรูปนะครับ 😎

เมื่อ Annotate เสร็จแล้วอย่าลืมปิด Jobs ด้วยนะครับ MENU > Finish the job

ใครที่ทำ Segment Size ก็ต้องปิด Jobs ทุกอันด้วยนะครับ 😅

หลังจากที่ปิด Jobs เสร็จแล้ว เราจะ Export Annotations ที่เราเพิ่งทำไป

Actions > Export as a dataset > YOLO 1.1

หลังจากที่เรา Export ออกมาแล้วจะได้ไฟล์ .zip มานะครับ พอดาวน์โหลด 100% แล้วก็ปิด CVAT ไปได้เลยครับ 😁

หลังจากนั้นก็แตกไฟล์นะครับ โดย YOLOv5 จะรับแค่ train และ validation

สร้าง Directory ชื่อว่า dataset มาในโฟลเดอร์ yolov5 แล้วเราก็จะจัด data หน้าตาแบบนี้ครับ

.dataset
├── images
│   ├── train
│   │   └── [set of training images]
│   └── val
│       └── [set of validation images]
└── labels
    ├── train
    │   └── [set of training annotations]
    └── val
        └── [set of validation annotations]

A:  จัดเสร็จแล้วว เทรนโมเดลได้ยังอะ
B: ใจเย็นๆ ยังไม่หมด

สร้างไฟล์ dataset.yaml ในโฟลดเดอร์ data มา … แล้ว Copy Paste เปลี่ยนชื่อ Class และจำนวนClassด้วยนะครับบ!!

train: ./dataset/images/train/
val: ./dataset/images/val/

ถ้าหากว่าไม่มี Validation Set ก็ใช้เป็น directory เดียวกันได้เลยครับ

nc: 2

จำนวน Class

names: ['cat', 'dog']

ชื่อ Class เรียงตามการสร้าง Class ใน CVAT

# ./data/dataset.yaml
train: ./dataset/images/train/
val: ./dataset/images/val/

nc: 2

names: ['cat', 'dog']

เทรนโมเดล

B: ไปดาวน์โหลด Model มา
A: ดาวน์โหลดที่ไหนอะ
B: ข้างบนๆ 👆 ตรง Pre-trained Model 😁👍

ผมเลือกเป็นโมเดล YOLOv5s … เนื่องจากขนาดของไฟล์ค่อนข้างเล็ก สามารถนำไป Run บนเครื่องที่สเป็กต่ำๆ ได้

*จริงๆ Wi-Fi ของผมมันไม่อำนวย*

แถเก่งไปละ.. เข้าเรื่องดีกว่า

ไม่อธิบายครับ ยาวเกิน 😂

python train.py --img 640 --batch 2 --epochs 5 --data ".\data\dataset.yaml" --weights ".\weights\yolov5s.pt"

img — ขนาดรูปที่จะเป็น Output ของ Model 😮

batch — ขนาด Input ที่จะฟีดเข้าไปใน Model … ปรับให้มันสมดุลนะครับ สำหรับเครื่องผม VRAM น้อยมากๆ ถ้าปรับมากไปหรือน้อยบางทีโปรแกรมอาจจะงอแงนะครับเช่น BrokenPipe หรือ CUDA OOM 😎

epochs — ตามชื่อนั่นแหละ เทรนกี่รอบ

data — Path หาเข้า dataset.yaml

weights — Path ไปหา Weights ที่เมื่อกี้ไล่ให้ไปโหลดครับ

รอ ยาวๆ~~ 😪

ผมขอข้ามเวลาด้วยการลด Epoch จาก 100 เหลือลง 10 ละกัน ข้้างบนนี่ภาพแต่ง

เมื่อเทรนเสร็จแล้ว Model จะถูกบันทึกไปที่ runs/train/exp

runs
├── detect
└── train
    └── exp
        ├── F1_curve.png
        ├── PR_curve.png
        ├── P_curve.png
        ├── R_curve.png
        ├── confusion_matrix.png
        ├── events.out.tfevents.1616481672.DESKTOP-E3G9LEN.6228.0
        ├── hyp.yaml
        ├── labels.jpg
        ├── labels_correlogram.jpg
        ├── opt.yaml
        ├── results.png
        ├── results.txt
        ├── test_batch0_labels.jpg
        ├── test_batch0_pred.jpg
        ├── test_batch1_labels.jpg
        ├── test_batch1_pred.jpg
        ├── test_batch2_labels.jpg
        ├── test_batch2_pred.jpg
        ├── train_batch0.jpg
        ├── train_batch1.jpg
        ├── train_batch2.jpg
        └── weights
            ├── best.pt
            └── last.pt

แต่ว่าเจ้า exp มันมาเป็นโฟลเดอร์เลย Model ของเราอยู่หนายยยย!! 😣

มันอยู่ใน exp/weights มีอยู่ 2 อันคือ best.pt กับ last.pt

best.pt — คือโมเดลที่ดีที่สุด

last.pt — คือ Epochs ล่าสุดที่เทรนล่าสุด

A: แล้วเอาโมเดลที่เราเทรนมาใช้ยังไงอะ
B: อ่านต่อสิครับ ถ้าอยากรู้ (มาเขียนตอนใกล้จบอีกด้วย 555)

เหมือนเดิมเลยครับ กันการใช้ detect.py เพียงแค่เติม — weights

python detect.py --source 0
                 --weights ".\runs\train\exp\weights\best.pt"

เพียงเท่านี้ก็เสร็จสมบูรณ์แล้วคร้าบบบ!! 😁

ขอบคุณมากๆ ครับ 😀

ภวัต แสงเดือน ( นน \ Non )

วิธีการ Detect Object ด้วย YOLOv5 และ Customize Object บน Windows 10 was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

Image Processing

Convolutional Neural Network
The algorithm that manipulated our human brain, the brain of the machine!!!

With the different cross-correlation network,

“ In the past 10 years, the best-performing artificial-intelligence systems — such as the speech recognizers on smartphones or Google’s latest automatic translator — have resulted from a technique called “deep learning.”

Deep learning is in fact a new name for an approach to artificial intelligence called neural networks, which have been going in and out of fashion for more than 70 years. Neural networks were first proposed in 1944 by Warren McCullough and Walter Pitts, two University of Chicago researchers who moved to MIT in 1952 as founding members of what’s sometimes called the first cognitive science department.” — MIT

Model

We created the deep learning model for Thai Cuisine Image Classification.

Model Versions:
1. VGG16 — acc 72.75% (val set)
2. EfficientNet — acc 86% (val set)
3. EfficientNet_FineTuning — acc 90.94% (val_set)
4. Ensemble Method

Colab Links

• Google Colaboratory
• Google Colaboratory
• Google Colaboratory

Keras Model

Keras is the powerful open source library with various applications.

VGG16

VGG16 is an ancient long neural network with high memory.

Prepare Data
We create 2 datasets of Train and Validate set.

These are the layers in multilayer perceptron;

x = pt.layers[-1].output

x = tf.keras.layers.GlobalAveragePooling2D()(x)

x = tf.keras.layers.Dropout(0.25)(x)

x = tf.keras.layers.Dense(1024,activation='relu')(x)

x = tf.keras.layers.Dropout(0.25)(x)

x =  tf.keras.layers.Dense(50,activation='softmax')(x)

Model.compile

model.compile(optimizer='adam',loss=tf.keras.losses.BinaryCrossentropy(),metrics=['accuracy'])

EfficientNet: Break the Mold !!! Rethinking Model Scaling for CNN (Deep Learning)

Food Image Classification was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

สวัสดีครับ… วันนี้ผมจะมาพูดถึงอุปกรณ์ Intel Neural Compute Stick 2 เรียกสั้นๆว่า NCS2 เป็นอุปกรณ์ที่ใช้เป็นตัวเร่งการประมวลผลด้าน AI ที่อยู่ในรูปแท่ง USB ยอดนิยม โดยเวอร์ชั่นใหม่นี้ ซึ่งก็คือเวอร์ชัน 2 ให้ทั้งประสิทธิภาพที่มากขึ้น รวมทั้งครอบคลุมการนำไปประยุกต์ใช้ได้หลากหลายขึ้น

สำหรับ NCS2 นี้ใช้ชิป Vision Processing Unit (VPU)ตัวล่าสุดในชื่อ Movidius Myriad X VPU ทำให้มีประสิทธิภาพเหนือกว่า NCS รุ่นแรกถึง 8 เท่า รวมทั้งมีชุดเครื่องมือ IntelOpenVINO ที่เปิดให้นักพัฒนาสามารถสร้างและฝึกโมเดล AI บนคลาวด์ได้

ซึ่งในบทความนี้จะเป็นการนำ NCS2 มาใช้กับ Raspberry Pi 4 เรียกย่อๆว่า RPI4 ซึ่งเป็นบอร์ดตัวหนึ่งที่รันแบบมี OS เป็นของตัวเอง เปรียบเสมือนคอมพิวเตอร์จิ๋วตัวหนึ่ง ประสิทธิภาพก็จะมีข้อจำกัดตามขนาด ซึ่งหากเราต้องการใช้ RPI4 รันระบบ AI ก็อาจจะทำให้การประมวลผลนั้นค่อนข้างช้ามาก จึงเป็นที่มาที่เรานำตัว NCS2 มาช่วยในส่วนนี้ครับ

Install NCS2 บน OS ของ RPI4

เริ่มจาก Install Software ที่ใช้ในการติดตั้งครับ

# install software

sudo apt-get update

sudo apt-get install git

sudo apt-get install cmake

sudo apt-get install libatlas-base-dev

sudo apt-get install python3-pip

sudo apt install libgtk-3-dev

pip3 install — upgrade pip

pip3 install numpy

ดาวน์โหลด Openvino Toolkit เลือกที่เป็นเวอร์ชันสำหรับ Raspberry Pi

https://storage.openvinotoolkit.org/repositories/openvino/packages/2021.2/l_openvino_toolkit_runtime_raspbian_p_2021.2.185.tgz

แตกไฟล์ที่ดาวน์โหลด แก้ไขชื่อ folder ตามต้องการ ในบทความนี้ผมจะตั้งเป็น openvino_toolkit

รัน Environment ของ Openvino ถ้ารันแล้วสามารถเช็คจากเวอร์ชันของ Opencv ถ้าเป็น Openvino จะเป็น 4.x.x-openvino

# set environment

source /openvino_toolkit/bin/setupvars.sh

ติดตั้ง USB Rules เพื่อให้ RPI 4 เห็นอุปกรณ์ NCS2 ผ่าน USB

# add usb rules

sudo usermod -a -G users “$(whoami)”

sh /openvino_toolkit/install_dependencies/install_NCS_udev_rules.sh

cd /etc/udev/rules.d/

cat 97-myriad-usbboot.rules

ในไฟล์ 97-myriad-usbboot.rules จะต้องมีข้อความตามนี้

SUBSYSTEM==”usb”, ATTRS{idProduct}==”2150", ATTRS{idVendor}==”03e7", GROUP=”users”, MODE=”0660", ENV{ID_MM_DEVICE_IGNORE}=”1"

SUBSYSTEM==”usb”, ATTRS{idProduct}==”2485", ATTRS{idVendor}==”03e7", GROUP=”users”, MODE=”0660", ENV{ID_MM_DEVICE_IGNORE}=”1"

SUBSYSTEM==”usb”, ATTRS{idProduct}==”f63b”, ATTRS{idVendor}==”03e7", GROUP=”users”, MODE=”0660", ENV{ID_MM_DEVICE_IGNORE}=”1"

จากนั้นเรามาทำการทดสอบกันครับ สร้างไฟล์ openvino_fd_myriad.py

import cv2 as cv

# Load the model.

net = cv.dnn_DetectionModel(‘face-detection-adas-0001.xml’,

‘face-detection-adas-0001.bin’)

# Specify target device.

net.setPreferableTarget(cv.dnn.DNN_TARGET_MYRIAD)

# Read an image.

frame = cv.imread(‘/path/to/image’)

if frame is None:

raise Exception(‘Image not found!’)

# Perform an inference.

_, confidences, boxes = net.detect(frame, confThreshold=0.5)

# Draw detected faces on the frame.

for confidence, box in zip(list(confidences), boxes):

cv.rectangle(frame, box, color=(0, 255, 0))

# Save the frame to an image file.

cv.imwrite(‘out.png’, frame)

ดาวน์โหลดไฟล์ weight ที่เป็น .bin

wget — no-check-certificate https://download.01.org/opencv/2020/openvinotoolkit/2020.1/open_model_zoo/models_bin/1/face-detection-adas-0001/FP16/face-detection-adas-0001.bin

ดาวน์โหลดไฟล์ .xml

wget — no-check-certificate https://download.01.org/opencv/2020/openvinotoolkit/2020.1/open_model_zoo/models_bin/1/face-detection-adas-0001/FP16/face-detection-adas-0001.xml

จากนั้นลองรันด้วยคำสั่ง

python3 openvino_fd_myriad.py

จะได้ไฟล์ out.png ที่เป็นการประมวลผลรูปภาพที่สำเร็จแล้ว ลองเปิดไฟล์เพื่อดูผล

จากนั้นทำการรันทดสอบกับไฟล์วิดิโอกันบ้างครับ รันแบบปกติบน RPI4 แบบไม่ใช้ NCS2 จะได้ FPS ตามด้านล่างครับ

FPS: 1.15 (excluding drawing time of 32.57ms)
FPS: 1.24 (excluding drawing time of 30.59ms)
FPS: 1.32 (excluding drawing time of 30.58ms)
FPS: 1.24 (excluding drawing time of 31.96ms)
FPS: 1.37 (excluding drawing time of 31.31ms)
FPS: 1.28 (excluding drawing time of 30.64ms)
FPS: 1.28 (excluding drawing time of 30.44ms)
FPS: 1.24 (excluding drawing time of 34.44ms)

ต่อไปลองเสียบ NCS2 แล้วลองรัน Openvino Environment และลองรันโปรแกรมใหม่อีกทีครับ

FPS: 14.02 (excluding drawing time of 55.95ms)
FPS: 18.72 (excluding drawing time of 40.07ms)
FPS: 16.93 (excluding drawing time of 40.36ms)
FPS: 16.29 (excluding drawing time of 42.52ms)
FPS: 16.75 (excluding drawing time of 39.74ms)
FPS: 16.54 (excluding drawing time of 41.56ms)
FPS: 16.84 (excluding drawing time of 41.47ms)
FPS: 19.02 (excluding drawing time of 39.78ms)

จะเห็นได้ว่า FPS เร็วขึ้นมากถึง 13 เท่าเลยทีเดียวครับ ขอจบเพียงเท่านี้ครับ…

Ref: https://docs.openvinotoolkit.org/2020.1/_docs_install_guides_installing_openvino_raspbian.html

การใช้ Intel Neural Compute Stick 2 กับ Raspberry Pi 4 was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

รหัสโครงการ 22p21n0185 | บ้านปังปุริเย่

สวัสดีครับ~~ ผมชื่อ “นน” นะครับ… ในบทความนี้ผมจะไกด์วิธีการลง YOLOv5 บน Windows 10… เรามาเกริ่นกันก่อนว่า YOLO คืออะไรและ YOLOv5 คืออะไร

YOLO คือ State-of-the-art Object Detection ที่ถูกเขียนโดย “Joseph Redmon”

YOLO นั้นถูกสร้างโดยภาษา C และภาษา CUDA เพื่อสร้าง Real-time Object Detection

ส่วน YOLOv5 ถูกพัฒนาโดย Ultralytics ซึ่งมีฐานมาจาก YOLO… YOLOv5 เขียนบนเฟรมเวิร์คที่ชื่อว่า PyTorch นั่นเองครับ

เรามาเริ่มติดตั้ง YOLOv5 ดีกว่า~~

ดาวน์โหลด YOLOv5

เราก็เริ่มโหลด YOLOv5 มาจาก GitHub ด้วยคำสั่ง

git clone https://github.com/ultralytics/yolov5.git

ติดตั้ง Packages

หลังจากลง YOLOv5 เราใช้เลยได้มั้ย.. ได้ฮะ ได้ก็บ้าแล้วว!! อย่าลืมลง Packages ก่อนนะฮะ เดี๋ยวรันแล้วแดงเถือก!!

.. Package Requirements ที่ต้องมีก็ประมาณนี้ครับ

ถึงแม้ว่าเขาจะมีมาให้หมดก็ไม่ใช่ว่า Runได้นะครับ…

ซึ่งมันก็มีบางอันที่ต้องลงเอง เช่นในรูปก็เป็น PyTorch นะครับ เราไปต่อกันดีกว่า!!

หลังจากที่เราลง PyTorch เสร็จแล้ว ก็รันอีกรอบนึงแล้วจะพบว่า แดงอีกละ… ขยันแดงจริงๆ

ที่มันพังเพราะว่า Windows 10 เวอร์ชั่น 2004 ขึ้นไป นั้นมันมีปัญหากับ NumPy (ถ้าไม่พังก็ไปต่อได้เลยนะครับ)

วิธีการแก้ก็คือ Downgrade NumPy ลงมาเวอร์ชั่น 1.19.0 ก็ง่ายๆ เลยครับ

pip install numpy ===1.19.0

หลังจากนั้นก็รันใหม่ ก็ไม่แดงละคร้าบบ.. (แต่ถ้าหากว่าไม่ได้ลง Visual C++ 2015 build tools ก็อาจจะลง pycocotools ไม่ได้นะครับ)

ก็เสร็จไปเรียบร้อยแล้วนะครับบ สำหรับไกด์การติดตั้ง prerequisites ของ YOLOv5

เตรียมพบกันในบทความต่อไปนะครับ สวัสดีคร้าบบบบ~~~

ภวัต แสงเดือน ( นน | Non )

วิธีติดตั้ง YOLOv5 บน Windows 10 was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.

ใบบทความนี้ผมจะพาท่านผู้อ่านมาทำความรู้จักกับเบื้องหลังของระบบอัจฉริยะนี้ แท้จริงแล้วมันเรียบง่ายเพียงใด และเราจะสามารถประยุกต์ใช้แนวคิดของระบบนี้ในชีวิตประจำวัน หรือแม้กระทั่งต่อยอดสร้างระบบแนะนำอัจฉริยะของตัวเองได้อย่างไร ระบบนี้มีชื่อว่า “ระบบผู้ช่วยแนะนำ” หรือ “Recommender Systems”

Recommender Systems ที่ใช้กันแบ่งได้เป็น 3 ประเภท หลักๆ ได้แก่

1. Demographic Filtering: เป็นการคัดกรองที่เริ่มจากแนวคิดที่พื้นฐานที่ว่า หากสิ่งใดได้รับความนิยมโดยคนหมู่มาก โอกาสเป็นไปได้สูงที่จะผ่านเกณฑ์ความชอบเฉลี่ย ของคนทั่วๆ ไป ตัวอย่างเช่น มีคนแนะนำว่า “ซีรีย์เรื่อง Game of Thrones สนุกมากก! นายลองดูสิ” จริงๆ แล้วคนแนะนำอาจจะยังไม่เคยดู แต่คนส่วนมากบอกว่าสนุกจึงแนะนำเพื่อนต่อ (เพราะคิดว่าเพื่อนต้องชอบแน่)
2. Content Based Filtering: เป็นการคัดกรองที่เริ่มจากเนื้อหาภายในข้อมูลนั้นๆ ที่มีความคล้ายคลึงกับพฤติกรรมของผู้บริโภค หรือผู้ใช้งานในอดีต ผมขอยกตัวอย่าง สถานการ์ณสมมุติ ที่ผมได้มีโอกาสแนะนำให้เพื่อนซื้อแผ่นเกมส์ PS4 โดยมี 4 เกมส์ เป็นตัวเลือก ได้แก่ 1.God of War 2.Diablo 3.Overcooked และ 4.Detroit: Become Human และสมมุติว่าในสถานการ์ณนี้ ทรัพยากรในกระเป๋าตังมีอยู่อย่างจำกัด ผมต้องเลือก 1 ตัวเลือก จาก 4 เกมส์ข้างต้น มาแนะนำ เพื่อให้เพื่อนประทับใจ และเล่นมันอย่างคุ้มค่า! ผมจึงสร้างระบบผู้ช่วยแนะนำของผมขึ้นมา ซึ่งเป็นตารางลักษณะดังนี้

ข้อสังเกตุ: จะเห็นว่าฟีเจอร์อธิบายเกมส์ส่วนใหญ่ ไม่ว่าจะเป็น คำบรรยายเกมส์ ความรุนแรง ระยะเวลาเคลียเกมส์ และอิสระในการเล่น ล้วนเป็นสิ่งที่ผมใส่ความเห็นของตนเองลงไป เพื่อใช้เป็นตัวคัดกรองในการทำระบบผู้ช่วยแนะนำ ดังนั้นในระบบ Content Based Filtering จะอาศัยความรู้ ความเชี่ยวชาญในเนื้อหาของข้อมูล

ซึ่งก่อนหน้านี้ผมมีประวัติของเพื่อนว่า เพื่อนผมติดเกมส์มือถือ “Ragnarok Online (RO)” มาก่อน ซึ่งหากเรานำ RO เพิ่มเข้ามาในตารางเพื่อทำการเปรียบเทียบกับเกมส์อื่นๆ จะพบว่า…

เราจะสามารถสร้างระบบรวมคะแนนขึ้นจากฟีเจอร์ที่วัดผลได้ (ไม่รวมคอลัมม์ บรรยายเกมส์) โดยให้คะแนนความตรงกันเท่ากับ 1 เราจะวัดคะแนนความตรงกันของเกมส์ต่างๆ กับเกมส์ที่เพื่อนเคยเล่นได้ดังนี้

• God of War มีความเหมือนกัน 1 ช่อง = 1 คะแนน
• Diablo มีความเหมือนกัน 4 ช่อง = 4 คะแนน
• Overcooked มีความเหมือนกัน 1 ช่อง = 1 คะแนน
• Detroit: Become Human มีความเหมือนกัน 2 ช่อง = 2 คะแนน

สุดท้ายเราได้ข้อสรุปว่า เกมส์ที่เหมาะกับเพื่อนผมมากที่สุดคือเกมส์ “Diablo” และรองลงมาคือ “Detroit: Become Human”

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

3. Collaborative Filtering: อาจกล่าวได้ว่า ระบบนี้เป็นการคัดกรองที่ทำงานตรงข้ามกับระบบที่ 2 โดยจะดูจากบริบท แล้วค้นหาความสัมพันธ์ที่ซ่อนอยู่ ว่าผู้บริโภค หรือผู้ใช้งานมีแนวโน้มจะชอบอะไร ผมจะยกตัวอย่างการซื้อเกมส์อีกรอบ เพื่อให้เห็นภาพเปรียบเทียบที่ชัดเจนยิ่งขึ้น

ในกรณีนี้เราจะนำประวัติความชอบ ของคนที่เคยเล่นเกมส์ต่างๆ ได้แก่ โรเจอร์ ซาโบ้ ไคโด มัลโก้ และเพื่อนของผม มาเปรียบเทียบกัน จากตาราง จะเห็นได้ว่า ซาโบ้ และ มัลโก้ ชอบเล่นเกมส์ Ragnarok Online (ซึ่งคล้ายกันกับเพื่อนผม) ซึ่งทั้งสองยังชอบเล่นเกมส์ Diablo เหมือนกันอีกด้วย ดังนั้นจึงสรุปได้ว่า เพื่อนผมมีแนวโน้มที่จะชอบเกมส์ Diablo เหมือนกันกับสองคนนี้ หรือ

“เกมส์ Diablo กับ Ragnarok จะต้องมีอะไรภายในบางอย่างที่ทำให้ พวกเขาชอบมันเหมือนกัน”

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

หากสังเกตุดีๆ แท้จริงแล้วแนวคิดการสร้าง Recommender Systems นั้นมาจากตรรกะที่เรียบง่ายบวกกับประสบการณ์ในชีวิตประจำวันของเรา เพียงแต่ด้วยข้อมูลมากมายมหาศาลในปัจจุบัน ทำให้ความซับซ้อนของระบบผู้ช่วยแนะนำนั้นมากขึ้นตามไปด้วย และนั่นคือเหตุผลที่ทำให้ระบบผู้ช่วยแนะนำของเรามีความอัจฉริยะมากยิ่งขึ้น ซึ่งนอกเหนือจาก 3 ระบบข้างต้นแล้ว ยังมีการใช้ระบบผู้ช่วยแนะนำแบบลูกผสม หรือ Hybrid Recommender Systems เพื่อช่วยให้ผลแม่นยำและเป็นที่น่าพอใจมากขึ้นไปอีก ตอนนี้เชื่อว่าท่านผู้อ่านคงจะเข้าใจพื้นฐานของระบบผู้ช่วยแนะนำทั้ง 3 แบบแล้ว ซึ่งในบทความหน้าเราจะมาลองสร้างระบบผู้ช่วยแนะนำโดยการใช้ข้อมูลจริงกันดู . . .

ขอบคุณที่อ่านมาจนจบครับ

Jest.

Reference:

• How Recommender Systems Work (Netflix/Amazon):[https://www.youtube.com/watch?v=n3RKsY2H-NE]
• Recommender Systems: [https://www.youtube.com/watch?v=Eeg1DEeWUjA]
• The Age of Recommender Systems: [https://www.kaggle.com/ibtesama/getting-started-with-a-movie-recommendation-system]

ระบบผู้ช่วยแนะนำ(Recommender Systems) เรียบง่าย ใกล้ตัว กว่าที่คิด was originally published in Super AI Engineer on Medium, where people are continuing the conversation by highlighting and responding to this story.