เกริ่นสักหน่อย.. ผมได้ติดตามการ์ตูน #petdo มาแบบอ่านบ้าง ไม่อ่านบ้าง แต่ก็พอคิดได้ว่าเป็นการ์ตูนที่สะท้อนถึงประสบการณ์การทำงานในด้าน IT ได้อย่างเห็นภาพและตรงประเด็น ไม่ใช่แค่เอาฮาอย่างเดียว แต่ก็สามารถเป็นแง่คิดสอนอะไรผมหลายๆ อย่าง และคิดว่าจะมีประโยชน์ต่ออาชีพการงานของผมในอนาคต (ผมยังเรียนอยู่และไม่เคยทำงานแบบเต็มเวลามาก่อน ) ใครอยากลองอ่านก็เชิญที่ iampetdo.com ครับ

ก่อนอื่น ขอนอกเรื่องก่อนนะครับ ผมไปถึงที่งานตอนประมาณ 11 โมงกว่าๆ มาถึงก็เจอไอ้พวกนี้ครับ

ทั้งผู้รักษาความปลอดภัย ทั้งพนักงานต้อนรับใส่กระดิ่งเป็นโดเรม่อนกวักอีก ด้วยความหมันไส้หน้ากวนๆ ของพวกมัน ก็เลยขอสักที

ประทับใจครับ คือแว๊บแรกที่ผมเห็นหอประชุมปรีดี พนมยงค์ ผมคิดว่านี่เป็นตึกร้างอะ – -” แต่แค่ไอ้ตัว 3 ตัวนี้มาต้อนรับอยู่ข้างหน้า ก็ทำให้อะไรๆ ดูดีขึ้นครับ ชอบๆ

พอไปถึงหน้างานจะไปลงทะเบียน ก็ได้ยินคุณ @nonggade ถามว่าทำไมมาเร็วจัง ซึ่งผมก็ไม่ได้ตอบอะไรในตอนนั้น ก็มาขอตอบในบล็อกนี้แทนละกันว่าผมมีจุดประสงค์รอง นั่นก็คือ..

เซนไดราเมน มอคโคริ สาขาทองหล่อ นั่นเอง แหะๆ แบบว่าอยากลองอะ ทำไมไม่ไปกินก่อนแล้วค่อยมาลงทะเบียน? นี่คือเหตุผลครับ

อยากเอาไปถ่ายรูปนั่นเอง อิอิ

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

เริ่มแรกก็จะเล่าเรื่องว่าพฤติกรรมของคนรอบตัวเราเป็นอย่างไร ประสบการณ์จริงที่ไปเจอมากับพนักงานขายสินค้า และพฤติกรรมที่ไม่ดีบนเว็บต่างๆ เป็นอย่างไร แซวชาวบ้านว่าให้เอาอย่างเว็บ Drama-Addict.com เพราะสามารถรวมข้อมูลจากหลายๆ เว็บมาไว้ที่เดียวกันได้.. ก็ขอชื่นชมด้วยครับ อีกทั้งยังเล่าประสบการณ์ที่เป็น อ. ว่าได้เจอนักศึกษาแบบไหนอีกด้วย อีกหน่อย ผมก็คงเจอแบบนี้เช่นกัน ฮะๆ และผมชอบมากเลยที่กล่าวพาดพิงถึง Java ว่ามันช้า.. เห็นด้วยครับ! (โดยส่วนตัวแล้วไม่ชอบ)

มีการกล่าวถึงการทำสไลด์ที่ไม่ควรเอาเยี่ยงอย่าง เช่น ใช้ฟอนต์หลายฟอนต์ ใช้สีที่ไม่เหมาะต่อการอ่าน ใช้ Bullet อย่างไม่เหมาะสม การใส่รูปที่ไม่สื่อ และการใส่อนิเมชั่นมาเยอะเกินทำให้ไขว้เขว เสียสมาธิ

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

ก่อนที่จะพักครึ่ง ก็ได้เชิญแขกพิเศษมา นั่นก็คือ อ. @jittat นั่นเองครับ มาเป็นตัวอย่างของ อ. เพ็ดโด้ แค่ออกมาแสดงตัวก็ฮาแล้ว แต่ดูท่า อ. ท่านจะตื่นเต้นมากไปหน่อย หุหุ อย่างไรก็ตามแต่ อ. ท่านนี้ เป็น อ. ที่ผมนับถือด้วย เป็นคนที่เก่งมาก และแจกเกรด F ให้ผมด้วย! ฮะๆ แต่ถ้าตอนนั้นไม่ได้ F มา ผมคงจะเหลวไหลไปไหนต่อไปแล้ว ขอบคุณอีกทีครับที่ให้ F ผม ตาสว่างเห็นสัจธรรม (ไม่ใช่ สัตว์จะทำ นะครับ) กันเลยทีเดียว -/\-

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

พักครึ่ง.. วง #iHear ก็มาเล่นให้ฟังต่อ ดนตรีเพราะ เพลงเพราะ นักร้องเสียงดีกันทุกคนเลย แหะๆ แต่บางทีพูดอะไรมา ผมฟังไม่ค่อยรู้เรื่องอะ เสียงไมค์มันออกมาอู้ๆ ไปหน่อย

กลับมาครึ่งหลัง ก็ได้พูดถึง User/Client โดยจะอ้างอิงถึงการ์ตูนแต่ละตอนครับ แล้วก็เล่าถึงว่าคนเราส่วนใหญ่จะมองที่ผลแต่ไม่ค่อยมองที่เหตุ แล้วก็มีสไลด์หนึ่ง ที่ผมก็ชอบอีกเช่นกันที่เป็นกราฟที่เอามาจากหนังสือเล่มหนึ่ง (จำชื่อไม่ได้) แสดงให้เห็นว่า People สำคัญที่สุด และ Technology อยู่อันดับสุดท้าย แต่ในความเป็นจริงในหลายๆ ที่รวมไปถึงในประเทศของเรา อันดับ 1 ดันเป็น Technology และอันดับสุดท้ายเป็น People อันนี้โดนมากเลยครับ ตัวผมเองบางทีก็ชอบไปเล่นเทคโนโลยีก่อนเช่นกัน

จากนั้นก็ต่อด้วยเรื่อง Failๆ ของ Usability ซึ่งได้ยกตัวอย่างจากรูปที่ถ่ายมาในชีวิตประจำวัน แล้วก็กลับมาเล่าถึงเรื่องผู้ใช้ทั่วๆ ไป ที่ไม่กล้าเปลี่ยนแปลง และยึดติดกับสิ่งที่ตัวเองคิด และสิ่งที่ใช้อยู่ในชีวิตประจำวัน ยกตัวอย่างเรื่อง การแสดงผลที่ผิดพลาดของ IE ซึ่งผู้ใช้ประมาณว่าไม่ยอมเปลี่ยนมาใช้ Firefox ด้วยเหตุผลต่างๆ นานา แต่พอเอาไอคอนของ IE มาแทนไอคอนของ Firefox และเอามาไว้ตำแหน่งเดียวกับไอคอนเดิมของ IE พบว่า ผู้ใช้สามารถใช้ Firefox ได้อย่างปกติ.. ต่อมาก็เล่าถึงเรื่อง Requirement ที่ไม่ชัดเจนและเป็นไปไม่ได้ และอะไรอีกหลายๆ อย่าง ตลกดีครับ ฮากันเข้าไป แต่ฮาอย่างเดียวก็คงไม่เหมาะ เราต้องเข้าใจความจริงด้วย และต้องยอมรับมัน — อันนี้เขียนไว้เตือนสติตัวเองนะครับ

ไม่รู้ว่าทำไม ผมรู้สึกว่าครึ่งแรกดูสนุกกว่าครึ่งหลัง แต่ครึ่งหลังดูฮากว่า ฮะๆ แล้วก็แอบงอนด้วย ทำไมไม่มีใครมาแจกน้ำผมมั่งเลย ชิๆ (แซวเล่นนะครับ )

และตอนสุดท้ายก็ได้ฝากข้อคิดไว้ว่าให้กำจัด Problem Generator (หรือ ไอ้เพ็ดโด้) ทิ้งซะก่อน นั่นก็คือให้ “แก้ปัญหาที่ต้นเหตุ” นั่นเอง

คุ้มค่าทุกบาทครับ สนับสนุนเสื้อไปทั้ง 3 แบบ แหะๆ ใครมาอ่านบล็อกผมก็ขอแนะนำให้ไปฟังกันนะครับถ้ามีครั้งต่อไป จริงๆ ผมก็ไม่ชอบเข้ามาในเมืองสักเท่าไหร่ ที่ยอมเข้ามาก็เพราะงานนี้เลยนะเนี่ย เย้! จะคอยติดตามผลงานต่อไปครับ

1. install dependencies as follows (please also see the screen shots below).
   • libcv4
   • libcv-dev
   • libcvaux4
   • libcvaux-dev
   • libhighgui4
   • libhighgui-dev
   • opencv-doc (optional)
   • ffmpeg (optional; if you want to use ffmpeg to do video processing)

   

   

2. install cmake using the command sudo apt-get install cmake.
3. run cmake -D WITH_FFMPEG=ON -D CMAKE_INSTALL_PREFIX=${HOME}/opencv/ ..
   • Note that there is a dot at the end of the command above which means to run at the current directory.
   • The options mean to use ffmpeg and to set the OpenCV path in your home directory.
4. check if ffmpeg is available and the folder to install is correct. See the screen shot below.

   

5. run the command make
6. run the command sudo make install.
7. The last thing is to is to tell the dynamic linker where the DLLs are; so, add the line: export LD_LIBRARY_PATH=${HOME}/opencv/lib to ~/.bashrc and then relogin.

finish..

ก่อนอื่นเลย Histogram ของรูป คืออะไร.. มันก็คือกราฟที่เกิดจากการพลอตจำนวนของ pixel ที่ค่าสีนั้นๆ นั่นเอง แกน X คือค่าของสี ส่วนแกน Y คือจำนวนของ pixel (อ่านเพิ่มเติมได้ที่ Image histogram ครับ)

เมื่อเราทราบหลักการของการสร้าง Histogram จากรูปแล้ว เราก็มาดูที่โค้ดกันครับ เริ่มต้นเราก็ประกาศขนาดของ Histogram ครับ ให้มีขนาด 256 ช่อง (ค่าสีปกติจะมีค่าระหว่าง 0-255 ในที่นี้ผมจะให้ช่องหนึ่งคือค่าสีหนึ่งนะครับ ซึ่งค่านี้สามารถเปลี่ยนแปลงได้แล้วแต่งานครับ)

int bins = 256;
int hsize[] = { bins };

ในโค้ดของผมนี้ผมจะสร้าง Histogram ที่เป็น uniform นะครับ เราก็ต้องกำหนดขอบเขตของค่า x ซึ่งต้องกำหนดตาม format ดังนี้ครับ โดย ranges[] จะต้องมีจำนวน dimension เท่ากับจำนวนค่าที่เป็นคู่ที่เราประกาศไว้ (คู่ 0 กับ 255)

float xranges[] = { 0, 255 };
float* ranges[] = { xranges };

เนื่องจากรูปตัวอย่างเป็น RGB เราก็ต้องแปลงให้เป็น Grayscale ก่อนนะครับ โดย image ในที่นี้คือรูปที่เราโหลดมาตั้งแต่ต้นนะครับ

IplImage* gray = cvCreateImage( cvGetSize( image ), 8, 1 );
cvCvtColor( image, gray, CV_BGR2GRAY );

จากนั้นเราต้องสร้างเพลน (plane) เพื่อมาคำนวณกราฟกันครับ ในที่นี้มีแค่ 1

IplImage* planes[] = { gray };

แล้วเราก็คำนวณค่าของ Histogram ดังนี้ โดยค่า 1 ตัวแรกหมายถึง จำนวน dimension ครับ ส่วน CV_HIST_ARRAY หมายถึงให้ type เป็นชนิด array และค่า 1 ตัวสุดท้ายหมายถึงว่าเป็น uniform ครับ

CvHistogram* hist = cvCreateHist( 1, hsize, CV_HIST_ARRAY, ranges, 1 );
cvCalHist( planes, hist, 0, NULL );

ในการคำนวณโดยใช้ cvCalHist นั้น เราเซตค่าที่ 3 ว่าให้เป็น 1 แปลว่า ถ้าสมมุติว่าเราวนลูปอ่านค่าสีจากรูปมาเรื่อยๆ เราสามารถบวกค่า pixel เพิ่มได้ในกราฟ Histogram อันเดิมครับ แต่ถ้าเป็น 0 ก็แปลว่าไม่ต้องบวกเพิ่ม ส่วนค่าสุดท้าย ถ้าไม่ใช่ NULL เราจะนำแค่จุด pixel ที่ไม่ใช่ 0 และมีการ mask ไว้ในรูปมาคำนวณครับ

ขั้นตอนต่อไป เราก็ต้องสร้างรูปขึ้นมาเพื่อแสดงผลครับ ในที่นี้เรากำหนดให้มีความสูงแค่ 50 พอครับ

IplImage* imgHistogram = cvCreateImage( cvGetSize( bins, 50 ), 8, 1 );
cvRectangle( imgHistogram, cvPoint( 0, 0 ), cvPoint( 256, 50 ), CV_RGB( 255, 255, 255 ), -1 ); // ค่าสุดท้ายคือค่า thickness ครับ ถ้าเป็น -1 แสดงว่าให้เป็นค่าสูงสุดเลย (เพื่อที่ว่าเราจะระบายสีขาวให้เต็มสีเหลี่ยมเลยครับ)

ขั้นตอนสุดท้ายเราก็วาดกราฟครับ และแสดงผล วิธีการก็คือดึงค่าออกมาทีละค่านั่นเอง แต่เนื่องจากเราเซตความสูงไว้ที่ 50 เราจะต้อง normalize ด้วยนะครับ แต่การที่เราจะ normalize ได้เราต้องมีค่าสูงสุดของ Histogram ก่อนครับ หาได้ดังนี้

float max_value = 0, min_value = 0;
cvGetMinMaxHistValue( hist, &min_value, $max_value );

และสุดท้ายจริงๆ ก็ดังนี้ครับ

cvNamedWindow( "histogram", 1 );
for( int i = 0; i < bins; i++ ) {
  float value = cvQueryHistValue_1D( hist, i );
  int normalized = cvRound( value * 50 / max_value );
  cvLine( imgHistogram, cvPoint( i, 50 ), cvPoint( i, 50 - normalized ), CV_RGB( 0, 0, 0 ) );
}
cvShowImage( "histogram", imgHistogram );

หวังว่าจะเป็นจุดอ้างอิงสำหรับผู้ที่เริ่มต้นสนใจในด้าน Image Processing นะครับ

Source code: hist.cc

credit: Isaias Gonzalez (siderevs at gmail dot com)

วันนี้ผมได้วิธีง่ายๆ มาและอยากแบ่งปันก็คือใช้ Tomboy Notes และ Dropbox นั่นเอง ถึงแม้ว่า Tomboy จะดีไม่เท่า OneNote ก็ตาม แต่ผมก็ยังคงไม่มีปัญหา เพราะเดิมที ไม่ได้ใช้ความสามารถของ OneNote มากสักเท่าไหร่

วิธีทำให้โน้ตของเรา sync กับ Dropbox ก็ให้ไปที่ Tomboy แล้ว Edit -> Preferences -> Synchronization และ ใช้ Service เป็น Local Folder จากนั้นก็เซต Folder Path ให้อยู่ภายใต้โฟลเดอร์ของ Dropbox และตามด้วยชื่อโฟลเดอร์ที่เราต้องการ เช่น ~/Dropbox/Tomboy หลังจากนั้น เราก็เขียนโน้ตตามปรกติ ถ้าเราต้องการให้ sync กัน ให้เลือกที่ Tools -> Synchronize Notes

เป็นอันเสร็จสิ้น

credit: http://www.starryhope.com/linux/2009/synchronize-tomboy-notes-with-dropbox/

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

บล็อกนี้ผมขอแนะนำการใช้ Perl ครับ ในกรณีของผม ผมใช้ Perl script ไฟล์เดียว ใส่ค่าพารามิเตอร์ครั้งแรก เราก็แค่รอให้ผลออกมา ถ้าไม่ดี เราก็รันคำสั่งเดียว เปลี่ยนค่าพารามิเตอร์ และก็รอผล ก็ดูง่ายๆ ใช่เปล่าครับ แต่สำหรับคนที่ไม่เคยทำ และจะลองมาทำดูก็จะค่อนข้างเสียเวลาในการศึกษา เสียเวลาไป google หาโค้ด หาตัวอย่าง ผมเลยเอาโค้ดที่ผมคิดว่าใช้บ่อยๆ มารวมไว้ครับ

ก่อนที่จะใช้ Perl script ผมแนะนำให้

1. เขียนโปรแกรมให้รับค่าพารามิเตอร์จาก command line ให้ได้ก่อน ถ้าเป็นภาษา C/C++ ก็ใช้พวก argc, argv และ getopt (ลองดูโค้ดตัวอย่างได้ที่  ตัวอย่าง getopt ครับ
2. ตอนที่แสดงผลจากโปรแกรมนั้น ให้เราแสดงออกมาทาง stdout หรือจะเขียนลงไฟล์ก็ได้ครับ
3. output ที่ออกมา เราควรจะออกแบบสักหน่อย เพื่อให้โปรแกรมต่อไปสามารถรับจาก command line ได้

ต่อไปนี้ก็จะเป็นโค้ดตัวอย่างที่ผมใช้บ่อยๆ ครับ

การรับพารามิเตอร์จาก command line ใช้ดังนี้

my $myVariable = $ARGV[0];

เริ่มจากเลข 0 ครับ ถ้ามี 3 ค่า จะเป็นดังนี้

my $myVariable1 = $ARGV[0];
my $myVariable2 = $ARGV[1];
my $myVariable3 = $ARGV[2];

ส่วนคำสั่ง Perl สำหรับรันโปรแกรมที่เราเขียนขึ้นเองต่างหากก็ตามนี้

system( "myProgram $param01 $param02" );

เปิดโฟลเดอร์เพื่อแสดงชื่อไฟล์ทั้งหมด (รวมทั้งชื่อโฟลเดอร์ด้วย ฉะนั้นแนะนำว่าให้ชื่อไฟล์มี extension ไว้ แล้วแก้คำสั่ง grep เพื่อกรองเอาแต่ไฟล์ครับ)

opendir( DIR, $folder_name ) or die "couldn't open $folder_name\n";
# ไม่เอา . ไม่เอา .. และไม่เอา .svn (เผื่อว่าเราใช้ svn)
my @files = grep { $_ ne '.' && $_ ne '..' && $_ ne '.svn' } readdir DIR;
for $file ( sort @files ) {
  print $file . "\n";
}

ถ้าต้องการที่จะเรียงไฟล์ตามตัวอักษรไม่ใช่ตามแบบ string ก็ใช้ตามนี้ครับ

for $file ( sort { $a <=> $b } @files ) { ... }

ส่วนฟังก์ชั่นตัด extension ของไฟล์

sub without_ext {
  my ( $file ) = @_;
  return substr( $file, 0, rindex( $file, '.' ) );
}

วิธีใช้ก็แค่โยนชื่อไฟล์เข้าไปแบบนี้ without_ext ( $file )

และฟังก์ชั่นตัดเอามาแต่ extension ของไฟล์

sub ext_only {
  my ( $file ) = @_;
  return substr( $file, rindex( $file, '.' ) + 1 );
}

วิธีใช้ก็แค่โยนชื่อไฟล์เข้าไปแบบนี้ ext_only( $file ) เช่นกัน

การเปิดไฟล์สำหรับอ่านและการอ่านไฟล์

open( FILE, $filename ) or die( "Cannot open file" );
@data = <FILE>;
foreach $text_line ( @data ) {
  print $text_line . "\n";
}

การเปิดไฟล์สำหรับเขียนลงไฟล์ก็แค่เพิ่ม “>” ลงไปก่อนหน้าชื่อไฟล์ครับ ดังนี้

open( FILE, ">$filename" ) or die( "Cannot open file" );
print FILE "test\n";

การอ่านข้อมูลจาก stdout

# ต้องใส่ | ข้างหลังด้วย แปลว่าให้อ่านจาก pipe
open( OUTPUT, "myProgram $param01 $param02 |" );
while( <OUTPUT> ) {
  # แบบนี้จะตัด input โดยใช้การขึ้นบรรทัดใหม่เป็นตัวกำหนด ถ้าต้องการตัดโดยใช้ tab ก็เปลี่ยนจาก "\n" เป็น "\t"
  @output = split( "\n", $_ );
  foreach $val ( @output ) {
    print $val . "\t";
  }
}

สามารถหาข้อมูลเพิ่มเติมเกี่ยวกับ open() ได้ ที่นี่ ครับ

หวังว่าจะมีประโยชน์สำหรับหลายๆ ท่านนะครับ

ลองดูกำหนดการของงานครับ น่าสนใจมาก ใครที่สนใจงานทางด้าน Software Engineering โดยเฉพาะ Testing ก็น่าจะมางานนี้นะครับ

ถ้าโค้ดของเรามีดังนี้

1
2
3
4

IplImage* img = cvCreateImage( ... );  // ประกาศตัวแปร img และได้จองหน่วยความจำไว้
img = xfunction( ... );  // ส่งค่า IplImage* กลับ
…
cvReleaseImage( &img );  // ลบหน่วยความจำตัวใหม่ที่เกิดจาก xfunction

แบบนี้แสดงว่าเกิด Memory leak ที่ xfunction ครับ คือตอนแรกเราจองหน่วยความจำให้กับตัวแปร img และต่อมาได้เรียกฟังก์ชั่น xfunction ซึ่งฟังก์ชั่นนี้ จะจองหน่วยความจำไว้อีกที่หนึ่งสำหรับค่าที่จะส่งกลับ ทำให้ตัวแปร img ไปชี้ที่หน่วยความจำใหม่ และหน่วยความจำเก่าที่ได้จองไว้ตอนแรกยังคงอยู่ (ถ้าใช้ภาษา Java คิดว่าไม่น่าจะมีปัญหาตรงนี้ครับ)

วิธีแก้ก็ง่ายมากครับ แค่แทนที่จะใช้ cvCreateImage() เราก็เปลี่ยนให้ชี้ไปที่ NULL แทน ดังนี้ครับ

1
2
3
4

IplImage* img = NULL;
img = xfunction( ... );
…
cvReleaseImage( &img );

สรุปคือ ถ้าใช้ภาษา C/C++ ต้องระวังเป็นอย่างมากครับ ไม่งั้นโปรแกรมอาจจะใช้แรมไปจนหมดเครื่องแน่ๆ ต้องหมั่นตรวจสอบว่าเราจองหน่วยความจำไว้ที่ไหน และพยายามลบทิ้งถ้าไม่ได้ใช้แล้วนะครับ ถ้ายิ่งทำงานเกี่ยวกับการวิเคราห์ไฟล์วีดีโอด้วยแล้วยิ่งต้องระวัง

อ่านรายละเอียดทั้งหมดได้ที่: OpenCV memory leaking management in C/C++

ในปัญหานี้เราจะบอกว่าผลลัพธ์ที่ได้ว่าเป็นคลาส Positive หรือ Negative ซึ่งผลลัพธ์ที่ได้สามารถมีได้ 4 แบบ คือ

1. True Positive (TP) หมายความว่า เราได้ผลลัพธ์จากการทำนายคือ p และค่าจริงๆ ก็คือ p ด้วย
2. False Positive (FP) หมายความว่า เราได้ผลลัพธ์จากการทำนายคือ p แต่ว่าค่าจริงๆ แล้วคือ n
3. True Negative (TN) หมายความว่า เราได้ผลลัพธ์จากการทำนายคือ n และค่าจริงๆ ก็คือ n ด้วย
4. False Negative (FN) หมายความว่า เราได้ผลลัพธ์จากการทำนายคือ n แต่ว่าค่าจริงๆ แล้วคือ p

จะเห็นได้ว่า TN จะกลับกันกับ TP และ FN จะกลับกันกับ FP ตามลำดับ

หลายๆ คนจะค่อนข้างสับสนเวลาที่คำนวณค่าจริงๆ ก็จะอธิบายจากความเข้าใจของผมนะครับ และคิดว่าน่าจะเข้าใจง่ายที่สุดแล้ว (เครดิต: @b39ppr) ยกตัวอย่าง เช่น เวลาที่เราต้องการจะทำนายว่า พฤติกรรมของคนๆ นี้ผิดปกติหรือไม่? หรืออีกนัยหนึ่งคือ เราต้องการที่จะตรวจจับพฤติกรรมที่ผิดปกติของคนๆ หนึ่ง

ในที่นี้จะได้ว่า พฤติกรรมที่ผิดปกติคือคลาส Positive ส่วนพฤติกรรมปกติคือคลาส Negative จะได้ว่า

• TP คือ ระบบเราตรวจจับได้ว่าคนๆ นี้ผิดปกติ และ คนๆ นี้ได้มีพฤติกรรมผิดปกติจริงๆ
• FP คือ ระบบเราตรวจจับได้ว่าคนๆ นี้ผิดปกติ แต่ว่า จริงๆ แล้ว เค้าไม่ได้ทำอะไรผิดเลย
• TN คือ ระบบเราไม่ได้ตรวจจับอะไรเลย และ คนๆ นี้ก็ไม่ได้ทำผิด
• FN คือ ระบบเราไม่ได้ตรวจจับอะไรเลย แต่ว่า คนๆ นี้ จริงๆ แล้วเค้ามีพฤติกรรมที่ผิดปกติ!

พอนึกออกรึเปล่าครับ? ผมจะขอยกตัวอย่างอีกสักตัวอย่าง เช่น เราเขียนโมเดลระบบตรวจจับสแปมเมล ถ้าเจอสแปมเมลให้ลบทิ้งเลย (ระบบออกแนวโหดหน่อย)

ในที่นี้จะได้ว่า เมลที่เป็นสแปมคือคลาส Positive ส่วนเมลปกติคือคลาส Negative

• TP คือ ระบบทำนายว่าเมลนี้เป็นสแปม และ มันก็เป็นสแปมจริงๆ
• FP คือ ระบบทำนายว่าเมลนี้เป็นสแปม แต่ว่า จริงๆ แล้วเมลนี้เป็นเมลปกติ เช่น ข่าวสารทั่วไป เมลเกี่ยวกับงานต่างๆ
• TN คือ ระบบทำนายว่าเมลนี้เป็นเมลปกติ และ เมลนี้ก็ปกติจริงๆ
• FN คือ ระบบทำนายว่าเมลนี้เป็นเมลปกติ แต่ว่า จริงๆ แล้วมันเป็นสแปม!

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

มีสรุปเพิ่มเติมจากคุณ pat หรือคุณ @b39ppr นั่นเอง ดังนี้ครับ (มีคำถามให้คิดเล่นตอนท้าย)

การอ่าน (T,F)(P,N) แบบไม่งง

• ดูตัวหลังก่อน ว่า P หรือ N
  ถ้า P คือ model ของเรา predict ว่ามันเป็น positive (เป็นคนร้าย, เป็น spam)
• ต่อไปดูตัวหน้า ว่า T หรือ F
  ถ้า T คือ ที่ model ของเรา predict ไปนั้น ถูกต้องแล้ว ถ้า F คือ predict ผิด

ตัวอย่าง: ระบบตรวจหา spam mail

1. ตรวจหาอะไรก็ให้สิ่งนั้นเป็น positive
   จะตรวจหา spam เมื่อคิดว่าเจอ spam ก็คือเจอกรณี positive
2. จะคำนวณ FP ทำอย่างไร?
   ตอบ สำหรับ FP นั้น
   2.1 ตัวหลังเป็น P ให้นับจำนวน mail ที่เรา predict ว่าเป็น “positive” (เป็น spam)
   2.2 ตัวหน้าเป็น F ให้ดูว่าที่ predict ว่าเป็น spam ไปนั้น มีอันไหน “ผิด” บ้าง

เอ้า ลองคิดกันหน่อย:
มี email ใหม่ ส่งมาหาเราทั้งหมด 10 ฉบับ เข้ามาใน inbox 8 ส่วนอีก 2 เข้าไปอยู่ในกล่อง junk mail 8 mail ใน inbox นั้นมาจากคนรู้จักซะ 5 ที่เหลือเป็นเมล์ขายของ ไม่อยากได้ ส่วนในกล่อง junk mail ดันมีเมล์สำคัญจากเพื่อนอยู่ 1 ฉบับ ลองบอกค่า TP, FP, TN, FN ของระบบกรอง spam ตัวนี้มาหน่อย

หวังว่าจะมีประโยชน์นะครับ

ข้อมูลเพิ่มเติม: Receiver Operating Characteristic (ROC)

รายรับ – รายจ่าย = เงินออม

สูตรนี้ก็ตรงไปตรงมาใช่ไหมครับ? แต่ว่าสูตรนี้น่าจะเหมาะสำหรับคนที่มีความพอเพียงอย่างมาก มีรายจ่ายน้อยจริงๆ แต่จะไม่ค่อยเหมาะสำหรับคนส่วนใหญ่ (รวมไปถึงผมด้วย) สักเท่าไหร่ ซึ่งเราจะคิดกันว่าเราสามารถจ่ายเท่าไหร่ก็ได้ แค่ไม่ให้รายจ่ายมากกว่ารายรับแค่นั้น ทำให้ทุกๆ ช่วงสิ้นเดือนเราจะไม่ค่อยมีเงินเหลือกันสักเท่าไหร่ เป็นกันไหมครับ? ดังที่ @lecuppiecake เคยกล่าวไว้ว่า “สิ้นเดือนเมื่อไหร่ แม้แต่แกลบยังแพง” ตัวผมเองไม่เหมาะกับสูตรนี้อย่างแรง

แล้วสูตรไหนเหมาะ? ก็แค่ย้ายข้างสมการ จะได้อีกสูตรดังนี้

รายรับ – เงินออม = รายจ่าย

ดูแล้วผลลัพธ์เท่ากันใช่ไหมครับ? ถ้าตอบในเชิงคณิตศาสตร์ก็ใช่ครับ แต่ว่าในชีวิตจริงคำตอบคงต่างออกไป สมการข้างต้นนี้จะมีความหมายว่า พอเราได้รายรับ (เงินเดือน หรืออะไรก็ตาม) มาเมื่อไหร่ ให้หักเก็บไว้เป็นเงินออมทันที ประมาณ 10-20% ของรายรับ (แล้วแต่คนนะครับ เลขนี้ไม่ตายตัว) การทำเช่นนี้ให้ผลดีตามมาก็คือ

1. เราสามารถคิดได้ว่า มีเท่าไหร่ก็ใช้เท่านั้น (คิดเหมือนตอนที่เราใช้สูตรแรก) โดยไม่ต้องกังวลว่าเรามีเงินออมหรือเปล่า (นั่นก็เพราะ เราได้หักส่วนของเงินออมออกไปแล้ว)
2. เงินออมของเราจะเพิ่มขึ้นอย่างสม่ำเสมอ เราสามารถนำเงินจำนวนนี้ไปทำงานแทนเราได้ เช่น ฝากธนาคารเอาดอกเบี้ย หรือ ลงทุน
3. ลดค่าใช้จ่ายที่ไม่จำเป็นออก โดยที่เราไม่รู้ตัว

จริงๆ แล้วยังมีข้อดีอีกมากมายครับ สำหรับการใช้สูตรที่ 2 นี้

เราสามารถเริ่มต้นการออมเมื่อไหร่ก็ได้ครับ แค่ “ออมก่อน มีสิทธิรวยกว่า” เท่านั้นเอง

Firstly, install gnome-mount.

sudo apt-get install gnome-mount

Secondly, go to System > Preferences > Startup Applications. And add this command.

gnome-mount -p xxx (change xxx to the volume label)

Finally, log out the system and it should work then. However, the problem still occurs after unmount and unplug the USB drive. To fix it, log out the system and then plug in the USB drive again. It is not a very good solution by the way.

Also, find the bug report here.