ארגז כלים למידה עמוק

data-analytics-feature-trial

ארגז כלי Matlab עבור למידה עמוקה.
למידה עמוקה היא תת שדה חדש של למידה חישובית המתמקדת בלימוד מודלים היררכיים עמוקים של נתונים. הוא בהשראה העמוקה לכאורה של המוח האנושי (שכבתית, היררכית) אדריכלות. סקירה טובה של התאוריה של תורה למידה עמוקה לומדת ארכיטקטורות עמוקות עבור AI

להיכרות פורמלי יותר, לראות את הסרטונים הבאים על ידי ג’פרי הינטון ואנדרו נג.

אם אתה משתמש ארגז הכלים הזה במחקר שלך נא לציין:

חיזוי כמועמד ללימוד מודלים היררכיים עמוקים של נתונים (Palm, 2012)

מדריכים כלולים בארגז הכלים
NN / – ספרייה עבור feedforward backpropagation רשתות עצביות

CNN / – ספרייה עבור רשתות קונבולוציה עצביות

DBN / – ספרייה עבור רשתות אמונה עמוקות

SAE / – ספרייה עבור-מקודדים אוטומטיים Stacked

CAE / – ספרייה עבור קונבולוציה Auto-מקודד

util / – פונקציות שירות המשמשות את הספריות

נתונים שמוצגים בדוגמות – נתונים /

בדיקות / – בדיקות יחידות לאמת ארגז כלים פועלות

לקבלת המלצות על כל שיק ספריית REFS.md

https://github.com/rasmusbergpalm/DeepLearnToolbox

mathworks.com/matlabcentral/fileexchange/38310-deep-learning-toolbox


קבוצות Deep Learning מחקר

מעבדות חלק וקבוצות מחקר, כי הם עובדים באופן פעיל על למידה עמוקה:

אוניברסיטת טורונטו – קבוצה לומדות (ג’פרי הינטון, ריץ ‘זמל, רוסלן Salakhutdinov, ברנדן פריי, רדפורד ניל)

אוניברסיטת מונטריאול – מעבדה מיל”ה (יהושוע בנג’ו, פסקל וינסנט, אהרון Courville, רולנד Memisevic)

אוניברסיטת ניו יורק – יאן Lecun , רוב פרגוס , דוד סונטאג Kyunghyun צ’ו

אוניברסיטת סטנפורד – אנדרו נג , כריסטופר מאנינג של, פיי-פיי לי של הקבוצה

אוניברסיטת אוקספורד – קבוצת למידה עמוק , Nando דה פרייטס ו פיל Blunsom , אנדרו זיסרמן

Google מחקר – ג’ף דין, ג’פרי הינטון, סמי בנג’ו, איליה סוצקבר, איאן גודפלו, אוריול Vinyals, דומיטרו Erhan, Quoc Le ואח

Google DeepMind – אלכס גרייבס, קרול גרגור, Koray Kavukcuoglu, אנדריי Mnih, גיום Desjardins, חאווייר Glorot, Razvan Pascanu, וולודימיר Mnih ואח

פייסבוק AI מחקר (FAIR) – יאן Lecun, רוב פרגוס, ג’ייסון ווסטון, אנטואן Bordes, Soumit Chintala, ליאון Bouttou, רונאן Collobert, יאן Dauphin et al.

קבוצת הלימוד העמוק של טוויטר – הוגו Larochelle, ריאן אדמס, קלמנט Farabet ואח

– Microsoft Research Li דנג ואח

SUPSI – IDSIA ( יורגן Schmidhuber קבוצת ‘ים)

ברקלי – ברונו Olshausen ‘קבוצת ים, טרבור דארל של הקבוצה, פיטר Abbeel

UCLA – אלן Yuille

אוניברסיטת וושינגטון – פדרו דומינגוס קבוצת ‘

IDIAP מכון המחקר – רונאן Collobert של הקבוצה

אוניברסיטת קליפורניה Merced – מיגל א Carreira-Perpinan של הקבוצה

אוניברסיטת הלסינקי – Aapo Hyvärinen של הקבוצה Neuroinformatics

אוניברסיטת שרברוק – הוגו Larochelle קבוצה של

אוניברסיטת Guelph – גרהאם טיילור של הקבוצה

אוניברסיטת מישיגן – Honglak לי קבוצה של

באוניברסיטת ברלין טכני – קלאוס-רוברט מולר של הקבוצה

Baidu – קאי יו ‘s והקבוצה של אנדרו נג

אוניברסיטת אלטו – ג’וחא Karhunen ו Tapani Raiko הקבוצה

U. אמסטרדם – מקס וולינג קבוצה של

CMU – כריס דייר

U. קליפורניה באירווין – פייר באלדי קבוצה של

אוניברסיטת גנט – בנימין Shrauwen קבוצה של

אוניברסיטת טנסי – איתמר אראל של הקבוצה

– המחקר של יבמ בריאן קינגסברי ואח

אוניברסיטת בון – של סוון Behnke הקבוצה

גטסבי היחיד @ University College London – Maneesh Sahani, פיטר דיין

קוגניטיבי Neuroscience חישובית מעבדה @ אוניברסיטת קולורדו בבולדר

תוכנה למידה עמוקה


  1. תיאנו – CPU / GPU מהדר ביטוי סמלי בפייתון (מהמעבדה מיל”ה באוניברסיטת מונטריאול)
  2. לפיד – מספק סביבת כמו-Matlab עבור אלגוריתמים של למידה חישובית המדינה- of-the-art Lua (מ רונאן Collobert, קלמנט Farabet ו Koray Kavukcuoglu)
  3. Pylearn2 – Pylearn2 היא ספריה שנועדה לעשות מחקר למידת מכונה קל.
  4. בלוקים – מסגרת תיאנו עבור רשתות עצביות אימון
  5. Tensorflow – TensorFlow ™ היא ספריית קוד פתוח תוכנה לחישוב המספרי באמצעות גרפים זרימת הנתונים.
  6. MXNet – MXNet היא מסגרת לימוד עמוקה מיועדת הוא יעיל וגמישות.
  7. Caffe -Caffe היא מסגרת למידה עמוקה עשתה עם ביטוי, מהירות, ומודולריות ב mind.Caffe היא מסגרת למידה עמוקה עשתה עם ביטוי, מהירות, מודולריות בראש.
  8. לזניה – לזניה היא ספרייה קלה לבנות ולאמן רשתות נוירונים תיאנו.
  9. Keras – ספרייה למידה עמוקה מבוסס תיאנו.
  10. הדרכות למידה עמוקות – דוגמאות של איך לעשות למידה עמוקה עם תיאנו (ממעבדת LISA באונ’ מונטריאול)
  11. DeepLearnToolbox – ארגז כלי Matlab עבור למידה עמוקה (מ Rasmus ברג כף יד)
  12. קודה-Convnet – A C מהר ++ / CUDA יישום קונבולוציה (או באופן כללי יותר, היזון קדימה) רשתות עצביות. זה יכול לדגמן קישוריות שכבה שרירותית ועומק רשת. כל גרף אציקליות בבימויו של שכבות יעשה.אימון מתבצע באמצעות אלגוריתם גב ההתפשטות.
  13. רשתות אמונה עמוקה . קוד Matlab ללימוד רשתות אמונה עמוקה (מ רוסלן Salakhutdinov).
  14. RNNLM – Toolkit מודלי שפה מבוססת הרשת העצבית החוזרת של תומס Mikolov.
  15. RNNLIB -RNNLIB היא ספריית רשת עצבית חוזרת לבעיות למידת רצף. החלים על רוב סוגי נתונים spatiotemporal, זה הוכח כיעיל במיוחד עבור דיבור וזיהוי כתב יד.
  16. matrbm . פשוט גרסה של הקוד של רוסלן Salakhutdinov, על ידי אנדריי Karpathy (Matlab).
  17. deeplearning4j – Deeplearning4J היא ספריית רשת עצבית 2.0-מורשה Apache, קוד פתוח, מופצים כתוב Java ו סקאלה.
  18. אמידת פונקציית החלוקה של RBM של . קוד Matlab לאמידת פונקציית חלוקה של מכונות בולצמן מוגבלות באמצעות מורפה דגימת חשיבותה (מ רוסלן Salakhutdinov).
  19. למידה מכונה בולצמן העמוק קוד Matlab לאימוני כיוון עדין מכונה בולצמן עמוק (מ רוסלן Salakhutdinov).
  20. LUSH שפת תכנות וסביבת הפיתוח, אשר משמש @ NYU לרשתות עמוק קונבולוציה
  21. Eblearn.lsh היא ספרייה למידת LUSH מבוסס מכונה עושה למידת אנרגיה מבוססת. הוא כולל קוד עבור “חזוי דליל פירוק” ושיטות אוטומטיות מקודדות דלילות אחרות ללמידה ללא השגחה. Koray Kavukcuogluמספק קוד Eblearn לנייר למידה כמה עמוק על זה דף .
  22. deepmat – Deepmat, Matlab מבוסס אלגוריתמים למידה עמוקים.
  23. MShadow – MShadow הוא מטריקס CPU / GPU קל / ספריית התבניות טנסור ב- C ++ / CUDA.מטרת mshadow היא לתמוך ביותר, ספרייה המותחת משתנית ופשוט מכשיר לפרויקט למידה מכונה שמטרתה היא פשטות וביצועים. תומך CPU / GPU / Multi-GPU ו מערכת מבוזרת.
  24. CXXNET – CXXNET הוא מהיר, תמציתי, מסגרת לימודית עמוקה יחולקו לפי MShadow. זהו C להרחבה קל משקל ונוח ++ / CUDA Toolkit רשת עצבית עם ממשק ידידותי Python / Matlab לאימונים וחיזוי.
  25. Nengo -Nengo היא חבילה גרפית scripting מבוסס תוכנה להדמיית מערכות עצביות בקנה מידה גדולה.
  26. Eblearn היא ספריה למידה C ++ מכונה עם רישיון BSD ללמידה מבוססי אנרגיה, רשתות קונבולוציה, חזון / יישומים הכרה, וכו EBLearn נשמר בעיקר על ידי פייר Sermanet ב- NYU.
  27. cudamat היא ספריית מטריצה ​​מבוססת GPU פייתון. קוד דוגמא לאימון עצבי רשתות מכונה בולצמן המוגבל כלול.
  28. Gnumpy הוא מודול פייתון המתממשקת באופן כמעט זהה numpy, אבל עושה חישובים על GPU של המחשב. היא פועלת על גבי cudamat.
  29. הספרייה CUV (GitHub הקישור ) היא מסגרת C ++ עם כריכות פיתון לשימוש קל של פונקציות CUDA Nvidia על מטריצות. הוא מכיל יישום RBM, כמו גם קוד הדגימה חשיבות annealed וקוד לחשב את פונקציית החלוקה בדיוק (מן המעבדה AIS באוניברסיטת בון).
  30. 3 כיווני בחשבון RBM ו mcRBM הוא קוד פיתון קורא CUDAMat להכשיר מודלים של תמונות טבעיות (מMarc’Aurelio Ranzato ).
  31. קוד Matlab להכשרת RBMs / DBNs מותנה ו בחשבון RBMs מותנהגרהאם טיילור ).
  32. mPoT הוא קוד פיתון באמצעות CUDAMat ו gnumpy להכשיר מודלים של תמונות טבעיות (מMarc’Aurelio Ranzato ).
  33. neuralnetworks היא ספריית GPU מבוסס ג’אווה עבור אלגוריתמים למידה עמוקים.
  34. ConvNet הוא ארגז כלים רשת עצבית קונבולוציה מבוסס matlab.
  35. Elektronn הוא ערכת כלים למידה עמוקה שגורם רשתות עצביות עצמה ונגישות מדענים מחוץ לקהילת למידת מכונה.
  36. OpenNN היא ספריית קוד פתוח בכיתה נכתב ב- C ++ שפת תכנות אשר מיישמת רשתות עצביות, אזור הראשי של המחקר למידה עמוקה.
  37. NeuralDesigner הוא כלי למידה עמוק חדשני אנליטיים לניבוי.

מערכי נתונים

מערכי נתונים אלה יכולים לשמש עבור בהשוואות אלגוריתמים למידה עמוקות:

מערכי נתוני מוסיקה סמליים


תמונות טבע


מערכי נתונים מלאכותיים

  • יקום ארקייד – גנרטור נתונים מלאכותי עם תמונות המכילות שדוני משחקי ארקייד כגון טטריס pentomino / חפצי tetromino. גנרטור זה מבוסס על של O. Breleux bugland גנרטור הנתונים.
  • אוסף של מערכי נתונים בהשראת רעיונות BabyAISchool :
  • מערכי נתונים שנוצרו לצורך ההערכה אמפירית של ארכיטקטורות עמוקות (DeepVsShallowComparisonICML2007 ):

Faces


טֶקסט


נְאוּם


מערכות המלצה

  • MovieLens: שני מערכי נתונים זמינים http://www.grouplens.org . בסיס הנתונים הראשון יש 100,000 רייטינג של 1682 סרטים על ידי 943 משתמשים, מחולקים לחמישה תת פרוק. בסיס הנתונים השני יש כ -1 מיליון רייטינג של 3900 סרטים על ידי 6040 משתמשים.
  • Jester: זה בסיס נתונים מכילים 4.1 מיליון דירוגים רציפים (-10.00 עד 10.00) של 100 בדיחות מ 73,421 משתמשים.
  • נטפליקס פרס: נטפליקס פרסמה גרסה אנונימי של דירוג הסרט שלהם במערך ; זה מורכב של 100 מיליון דירוגים, נעשה על ידי 480,000 משתמשים אשר דירגו בין 1 וכל 17,770 סרטים.
  • נתוני ספר-מעבר: זה בסיס נתונים הוא מקהילת הספר-מעבר, ומכיל 278,858 משתמשים מתן 1,149,780 דירוגים על 271,379 ספרים.

שונה


קוד המקור של התמונה פילוח MATLAB

מושלם עבור המתחיל, הדגמה זו ממחישה זיהוי אובייקטים פשוטים (פילוח, הדמיה), מדידה של סינון. דורש את התמונה עיבוד בארגז כלים של פקדים (טכנולוגייה) כי הוא מדגים כמה פונקציות שסיפק את ארגז הכלים, בנוסף היא משתמשת בתמונה הדגמה “מטבעות” המצורף את ארגז הכלים. אם יש לך את טכנולוגייה (ניתן לראות על-ידי הקלדת גרסה בשורת הפקודה), תוכל להפעיל קוד זה הדגמה פשוט על ידי העתקה של הדבקת הקוד הזה לתוך חלון עורך חדש ולאחר מכן לחיצה על הירוק “הפעל” המשולש בסרגל הכלים.
תחילה מוצא את כל האובייקטים ולאחר מכן מסננים את התוצאות כדי לבחור אובייקטים בגדלים מסוימים. מושגי יסוד קביעת סף, תיוג ו regionprops הם הפגינו עם דוגמא פשוטה.

זה מדריך טוב עבור אותם משתמשים חדשים לתמונה של MATLAB עיבוד יכולות ללמוד, לפני שהם הולכים אלגוריתמים מתוחכמים יותר.

http://nl.mathworks.com/matlabcentral/fileexchange/25157-image-segmentation-tutorial

תא כלי תוכנה פילוח

 

כלי תוכנה

מפתח

COM

אתר אינטרנט

CellProfiler

במכון

לא

http:// www. cellprofiler. התארגנות

ארגז כליםOMAL

פרדריק הלאומי מעבדה

לא

http:// ncifrederick. סרטן. גוב

פסיפס תוכנה

קבוצה פסיפס

לא

http:// www. פסיפס. ethz. ch / הורדות / phasecontrast

LSDCAS

אוניברסיטת איווה

לא

http:// www. uihealthcare. התארגנות / otherservices.aspx? id = 21022

CellTrack

המזרח התיכון

לא

db.cse.ohio-state.edu/CellTrack

האוניברסיטה הטכנית

אייסי

מכון פסטר

לא

icy.bioimageanalysis.org

CyteSeer

ואלה מדעי

כן

http:// www. valasciences. com / תוכנה / זיהוי / cyteseer

Cellomics

תרמו מדעי

כן

http:// www. cellomics. com

החוש

LabTech טרומבוציטופניה טרומבוזית

כן

http:// www. ttplabtech. com

אפיגנטיקה היעד

Evotec

כן

http:// www. evotec. com

יצירת פרופיל

ב בלש תא

GE Healthcare

כן

http:// www. biacore. com

הרמוניה

PerkinElmer

כן

http:// www. perkinelmer. com

CellScan LS

Imstar

כן

http:// www. imstarsa. com

iCyte

CompuCyte

כן

http:// www. compucyte. com

Com = מסחרי.

 

 


MATLAB מנורמל חתכים מקטעי קוד

מנורמל גזור סגמנטציה ואישכול קוד להוריד כאן
סיבוכיות זמן # Multiscale מנורמל לחתוך סגמנטציה קוד MATLAB הוא זמין להורדה כאן.

 

 


קיבוץ באשכולות והסיווג באמצעות דחיסה מאבדת נתונים

MATLAB החבילות הזמינות להלן:

כל הקוד הוא זכויות יוצרים 2007 באוניברסיטה של אילינוי.

קיבוץ באשכולות של נתונים מעורבים רב משתנית

Matlab החבילה: segmentation_code.zip

השימוש הוא פשוט: אם X היא מטריצת נתונים (בצורה עמודה), מתקשר
Y = coding_seg (X, אפסילון, false);
לחלק את הנתונים כדי למזער את מספר הסיביות הדרוש כדי
קוד של אפסילון עיוות נתונים upto וקטורים ^ 2. הפרמטר האחרון
צריך להיות נכון אם הנתונים ידועים להיות שונה מאפס-ממוצע. ראה “test.m”
זו רק דוגמה.

איש קשר: ג’ון רייט (jnwright@uiuc.edu).

סיווג של נתונים רב משתנית

Matlab החבילה: MICL_code.zip

איש קשר: ג’ון רייט (jnwright@uiuc.edu)

פילוח של תמונות טבעי

Matlab החבילה: tbes_1.0.zip

התקנה: אלגוריתם פילוח זה מרקם משתמשת הקוד superpixel של. מורי et al., הכולל כמה קבצים ג שאין צורך לבצע הידור. כדי לעשות את זה MATLAB פתוח ולאחר מכן להפעיל את הפקודות הבאות:
> cd superpixels/yu_imncut > mex csparse.c > mex ic.c > mex imnb.c > mex parmatV.c > spmd_imncut.c mex שימוש: כדי לבדוק שלנו אלגוריתם פילוח מרקם, הפעל את הפקודה הבאה ב- MATLAB:
> test_texture_seg

 

 

מספר סידורי: http://perception.csl.illinois.edu/coding/sample_code.htm



 

זיהוי מתאר ומשאבים פילוח תמונה

 

מטרת עבודה זו היא לספק בסיס אמפירי לחקר סגמנטציה וזיהוי גבול. על מנת לקדם את התקדמות מדעית במחקר של קיבוץ חזותי, אנו מספקים המשאבים הבאים:

    • מערכת גדולה dataset של תמונות טבעי יש כבר מחולקים באופן ידני. הביאורים האדם לשמש הקרקע האמת ללימוד קיבוץ רמזים, כמו גם תקן ביצוע לצורך השוואת פילוח שונים ואלגוריתמים זיהוי גבולות.

 

    • האחרונה של אלגוריתמים הקבוצה שלנו פיתחה עבור פילוח זיהוי מתאר.

 

 

משאבים מלאים הזמינים בדף זה ניתן להוריד קובץיחיד. (מעודכן ינואר 2013)

פרטים בודדים הורדות זמינות מתחת. אם אתה משתמש במשאבים בדף זה, אנא מצטטים את הנייר:

Contour הירארכי סגמנטציה וזיהוי
עמ’ Arbelaez, מסיה Maire, Fowlkes ג, ג’ מאליק.
IEEE TPAMI, כרך 33, מס ‘ 5, עמ’ 898-916, מאי 2011.
[PDF] [BibTex]

ערכת נתוני פילוח ברקלי, ובחינות 500 (BSDS500)

ערכת נתונים חדש זה הוא הרחבה של BSDS300, איפה התמונות המקוריות 300 משמשים עבור הכשרה / אימות של 200 תמונות טריים, יחד עם ביאורים אנושי, מתווספים לבדיקה. כל תמונה היה מקוטע לפי נושאים שונים 5 בממוצע. ביצועים מוערך על-ידי מדידת דיוק / אחזור על שלושה מדדים נוספים מבוססי אזור ובגבולות שזוהו.

התמונה המקורית נושא 1 נושא 2 נושא 3

הכי טוב להתאמן הנחיות: ערכת הנתונים מורכב 500 תמונות טבעי, ביאורים האנושי הקרקע-האמת וקוד בהשוואות. הנתונים מופרד באופן מפורש לערכות הרכבת, אימות ובדיקה מפוזרות. על מנת לשמור על השלמות של הערכת ולקבל השוואה ישירה והוגנת של התוצאות שלכם עם שיטות קיימות, חייב להיות במעקב ההנחיות הבאות:

    • הרכבת רק על trainval: כל הלמידה, פרמטר הכוונון, מודל הבחירה, וכו ‘ צריך להיעשות אך ורקעל הרכבת ובדיקת קבוצות משנה של הנתונים.

 

    • לרוץ פעם במבחן: לאחר הכשרה, אלגוריתם שלך אמורה לפעול פעם אחת בלבד עם פרמטרים קבועים על המשנה בדיקה של הנתונים. תמונות של הקרקע-האמת segmentations של הבדיקה קבע לא יכול לשמש עבור כוונון אלגוריתם שלך.

 

    • לדווח על כל התוצאות הערכה: להעריך את תוצאות המשנה מבחן עם הקוד בהשוואות. על מנת להעריך היבטים שונים באופן כמותי של ביצועים של זיהוי מתאר ואלגוריתמים פילוח, BSDS500 מספק חבילה של אמצעי הערכה. נא לדווח כל הציונים ועיקולים שהחזיר את הערכה scriptboundaryBench (שיטות איתור מתאר) או allBench (פילוח שיטות).

 

    • הערך גם על BSDS300: על מנת להפוך את התוצאות שלך דומה עם שיטות שבהן הוערכו ב- BSDS300 המקורי, אתה צריך לחזור על שלושת הצעדים לעיל, אבל מוודא להתאמן רק על המשנה הרכבת של הנתונים ולבדוק על המשנה אימות.

 

הורד BSDS500: תמונות, נתוני הקרקע-האמת, ובחינות.


אלגוריתמים

השיטות האחרונה שפיתחה הקבוצה שלנו.

    • זיהוי מתאר. GlobalPb גלאי מתאר משלבת מספר רמזים המקומי למסגרת הגלובליזציה בהתבסס על התקבצות ספקטרלי.

 

    • סגמנטציה הירארכי. פילוח כלליים אלגוריתם חמושים-ucm הופכת את הפלט של כל גלאי מתאר עץ היררכי באזור.

 

    • כלי אינטראקטיבי פילוח. ממשק Matlab כדי לייצר באיכות גבוהה מוגדרים על-ידי המשתמש segmentations מן התוצאות האוטומטית שלנו.

 

התמונה המקורית globalPb מפת מתאר ultrametric פילוח אוטומטי

הורדות:

 

 

 

 

 

הערה: כל הורדות בעמוד זה ניתן בבטחה דחוסה באותה תיקיה.

 

מספר סידורי: http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/resources.html

 


סגמנטציה kmeans

תוכנית זו מקבל תמונה ומספר המחיצות desidered מוצא את האמצעים של המעמדות השונים ואת מספק תמונת clasified
(מסכת).

 

מספר סידורי: http://nl.mathworks.com/matlabcentral/fileexchange/8379-kmeans-image-segmentation

 


פאזי C-אמצעי קיבוץ באשכולות

פונקציה זו מתארת את פאזי c-אמצעי קיבוץ באשכולות של תמונה. זה קטע אוטומטית את התמונה לתוך אשכולות n עם אתחול אקראי. ניתן לציין את מספר אשכולות על-ידי המשתמש. מספר האיטראציות יכולים גם להיות נשלט.הפונקציה התוצרים הם מחולקים התמונה ומעודכן אשכול מרכזי.

http://nl.mathworks.com/matlabcentral/fileexchange/56147-fuzzy-c-means-clustering


באמצעות מורפולוגיה

פונקציה זו מתארת את פאזי c-אמצעי קיבוץ באשכולות של תמונה

פונקציה זו מתארת את פאזי c-אמצעי קיבוץ באשכולות של תמונה. זה קטע אוטומטית את התמונה לתוך אשכולות n עם אתחול אקראי. ניתן לציין את מספר אשכולות על-ידי המשתמש. מספר האיטראציות יכולים גם להיות נשלט.הפונקציה התוצרים הם מחולקים התמונה ומעודכן אשכול מרכזי.

 


צמח גילוי מחלות עלים והסיווג באמצעות Multiclass מכונת וקטורים תומכים מסווג

 

קוד Matlab לזהות ולסווג מחלות בצמח משאיר באמצעות מסווג מכונת וקטורים תומכים multiclass

קוד Matlab נכתב כדי לסווג את העלים לתוך אחד מהסוגים הבאים: ‘Alternaria Alternata’, ‘Anthracnose’, ‘הנגיף חיידקי’, ‘ Cercospora עלה ספוט ‘, ‘עלים בריאים’. הסיווג נעשה על ידי מכונת וקטורים תומכים Multiclass (אחד נגד כולם)
כיצד להפעיל??
1. מניחים את התיקיה ‘Leaf_Disease_Detection_code’ בנתיב Matlab, ולהוסיף את כל תיקיות המשנה לנתיב הזה
2. הפעל DetectDisease_GUI.m
3. לחץ על GUI על טעינת התמונה, טען התמונה המחלה Dataset של מאנו, לחץ על לשפר את הניגודיות.
4. לאחר מכן לחץ על קטע התמונה, לאחר מכן הזן האשכול לא המכיל את רועי, כלומר רק את המחלה השפיע חלק או את החלק הבריא
5. לחץ על סיווג תוצאות. ואז למדוד דיוק (במקרה זה בריא לעומת כל המחלות).
הקוד מבוסס באופן רופף על הנייר הבאים, אנא צטט מתחת לתת קרדיט ליוצרים:
[1] הקטר, אופירה, ואח “אוטומטי מחלות מי קולחין (APDA): השוואת ביצועים של טכניקות למידה מכונה.”הגבולות של טכנולוגיית המידע (התאמה), 2013 11 כנס בינלאומי. IEEE, 2013.
[2] multiclass מכונת וקטורים תומכים מאת Anand מישרה הקישור:http://www.mathworks.com/matlabcentral/fileexchange/33170-multi-class-support-vector-machine

 

http://nl.mathworks.com/matlabcentral/fileexchange/55098-plant-leaf-disease-detection-and-classification-using-multiclass-svm-classifier

 



 

קוד חופשי MATLAB:

sparse_classification.zip (פרסום ראשון: ספטמבר 2013; מהדורה אחרונה: ספטמבר 2013)

קוד MATLAB לביצוע זיהוי תבניות באמצעות מגוון של אלגוריתמים קידוד דליל שונים, כולל אלגוריתם ה-PC/לפנה ס-דים. קוד זה מבצע את הניסויים המתוארים: מ וו Spratling (2014) סיווג באמצעות ייצוגים דלילים: גישה סבירה מבחינה ביולוגית- קיברנטיקה ביולוגי, 108 (1): 61-73.

drivers_modulators.zip (פרסום ראשון: יולי 2013; מהדורה אחרונה: יולי 2013)

קוד MATLAB להדמיית השפעות הן modulatory והן נהיגה של חיבורים לרוחב, ו מלמעלה למטה feedforward, עם דגם PC/לפנה ס-דים. קוד זה מבצע את הניסויים המתוארים: מ וו Spratling (2014) מודל פונקציונלי יחיד של מנהלי התקנים ושל מאפננים בקליפת. Journal of Neuroscience חישובית, 36(1): 97-118.

edge_detection.zip (פרסום ראשון: אוקטובר 2012; מהדורה אחרונה: אוקטובר 2012)

קוד MATLAB לביצוע סגמנטציה באמצעות המודל PC/לפנה ס-דים של V1 עם חיבורים לרוחב. קוד זה מבצע את הניסויים המתוארים: מ וו Spratling (2013) סגמנטציה באמצעות מודל קידוד דלילה של אזור בקליפת המוח V1. עסקאות IEEE על עיבוד תמונה, 22 (4): 1631-43.

partial_transforms.zip (פרסום ראשון: מאי 2012; מהדורה אחרונה: במאי 2012)

קוד MATLAB עבור דגמי המרות מסגרת התייחסות חלקית באמצעות מודל PC/לפנה ס-דים. קוד זה מבצע את הניסויים המתוארים: מאיר דה ק ו מ ו Spratling (2013) דגם של מסגרת התייחסות חלקית המרות באמצעות צירוף של תגובות מאופנן רווח. קליפת המוח, 23 (5): 1230-9-

v1_reverse_correl.zip (פרסום ראשון: ינואר 2012; מהדורה אחרונה: ינואר 2012)

קוד MATLAB עבור דגמי קורלציה הפוכה ניסויים באמצעות מודל PC/לפנה ס-דים של V1. קוד זה מבצע את הניסויים המתוארים: מ וו Spratling (2012) חזוי קידוד חשבונות עבור מאפייני תגובה V1 נרשם באמצעות קורלציה הפוכה. קיברנטיקה ביולוגי, 106 (1): 37-49-

v1_saliency.zip (פרסום ראשון: יולי 2011; מהדורה אחרונה: יולי 2011)

קוד MATLAB עבור דגמי saliency חזותי באמצעות מודל PC/לפנה ס-דים. קוד זה מבצע את הניסויים המתוארים:מ וו Spratling (2012) קידוד חזוי כמודל של ההיפותזה מפה saliency V1. רשתות עצביות, 26:7-28-

dim_learn_recip_weights.zip (פרסום ראשון: יוני 2011; מהדורה אחרונה: יוני 2011)

קוד MATLAB ללמידה במודל ההיררכי של PC/לפנה ס-דים. המודל מוחל למידה הבעיה ברים, וכדי למידה באמצעות תמונות טבעיות. במקרה האחרון RFs דומים לאלה שנמצאו באזורים קורטיקליים V1 ו- V2 הם למדו.קוד זה מבצע את הניסויים המתוארים: מ וו Spratling (2012) ללא השגחה למידה של משקולות גנרטיבית, שמסווגת קידוד רכיבי תמונה אלמנטרית במודל של קידוד חזוי של הפונקציה קליפתי. חישוביות עצבית, 24(1): 60-103.

gain_modulation.zip (פרסום ראשון: מרץ 2011; מהדורה אחרונה: מרץ 2011)

קוד MATLAB RFs למידה (באמצעות האלגוריתם עמום) שבו קלט אחד נוהג ולהתעלות אחרים modulatory, נותן סוגים של “רווח שדה” נצפתה באזורים קורטיקליים שונים (כמו למשל כאשר RF הרשתית מאופנן לפי מיקום העין).קוד זה מבצע את הניסויים המתוארים: מאיר דה ק ו מ ו Spratling (2011) רווח אוילר אפנון מתעוררת באמצעות למידה ללא השגחה במודל של קידוד חזוי של הפונקציה קליפתי. חישוביות עצבית, 23 (6): 1536-67.

v1_suppression_mechanisms.zip (פרסום ראשון: מרץ 2011; מהדורה אחרונה: מרץ 2011)

קוד MATLAB עבור דגמי מנגנוני דיכוי V1 באמצעות מודל PC/לפנה ס-דים. קוד זה מבצע את הניסויים המתוארים:מ וו Spratling (2011) מודל פונקציונלי יחיד חשבונות עבור מאפיינים ברורים של דיכוי באזור קורטיקליים V1.חזון מחקר, 51:563-76-

v1_response_properties.zip (פרסום ראשון: 02/10; מהדורה אחרונה: מרץ 2010)

קוד MATLAB עבור דגמי V1 מאפייני תא פשוט RF באמצעות מודל PC/לפנה ס-דים. קוד זה מבצע את הניסויים המתוארים: מ וו Spratling (2010) קידוד חזוי כמודל של התגובה נכסים באזור קורטיקליים V1. Journal of Neuroscience, 30 (9): 3531-43.

pc_attention.zip (פרסום ראשון: 02/10; מהדורה אחרונה: 02/10)

קוד MATLAB עבור דגמי תשומת לב ואיגוד באמצעות מודל PC/לפנה ס-דים. קוד זה מבצע את הניסויים המתוארים: מ וו Spratling (2008) קידוד חזוי כמודל של מוטה בתחרות תשומת לב- חזון מחקר, 48 (12): 1391-408.

dim_squares.m (פרסום ראשון: 02/10; מהדורה אחרונה: 02/10)

קוד MATLAB ללימוד הבעיה ריבועים באמצעות האלגוריתם מחלוקת קלט אפנון (לדים). קוד זה מבצע אחת המשימות המתוארות: מ’ Spratling וו, מאיר דה ק ו ר Kompass (2009)ללא השגחה למידה חופפים רכיבי תמונה באמצעות מחלוקת אפנון קלט. מודיעין חישובית ומדעי המוח, 2009 (381457): 1-19-

 

 

מספר סידורי: http://www.inf.kcl.ac.uk/staff/mike/code.html

 

 

 



צורה מוקדמת של סגמנטציה

הצורה סטטיסטי מראש באמצעות למידה סעפת

עבודה משותפת עם Arturo מנדוזה Quispe

בעבודה זאת, נוכל לבנות לכהן סטטיסטי באמצעות יריעה לימוד טכניקה (דיפוזיה מפות) ולכלול אותו בגרף לחתוך מסגרת. תארנו את שיטת צורה מוקדמת מבוסס סגמנטציה באמצעות למידה סעפת, Quispe מנדוזה א ו ג Petitjean, התקבלה ב- IEEE IPTA, 2015. גרסת pdf

כמה תוצאות על החדר הימני פילוח בתמונות תהודה מגנטית לב:

imgsegm

קוד Matlab: קוד פילוח שלנו זמין כאן. הקוד הוא תואם עם Matlab גירסה 8 עם הכלים לעיבוד תמונה.

זה דורש את השימוש בקוד הבא:

הארכיון שלנו הוא מוגנים באמצעות סיסמה; אנא בקשו הסיסמה של caroline.petitjean [ב] אוניברסיטת-rouen.fr.

אנא שימו לב: הקוד מסופק ללא נתונים. הקוד הוא הצעה של מימוש האלגוריתם המתואר בעיתון המצוטט לעיל [מנדוזה Quispe ו Petitjean, 2015]. זה מסופק «כפי» ללא כל תמיכה ולא אחריות ולא ניתן להבטיחן לחלוטין ללא חרקים. אנו מודים לך דו ח של נייר שלנו למקרה הקוד משמש.

הפניות הראשי:

  • Etyngier, עמ’, Ségonne, פ, Keriven, ר: לעצב הרשעות קודמות תוך שימוש בטכניקות למידה סעפת.ב: ראייה ממוחשבת, 2007. ICCV 2007. IEEE 11 כנס בינלאומי. 1 עמ’ 8. IEEE (2007)
  • Moolan-פירוז, שיטת Mirmehdi, מ’, המילטון, מ., Bucciarelli-זה, ג: פילוח של העליה הימנית באמצעות מפות ffusion di elds פי אקראי מרקוב. ב: רפואי התמונה מחשוב והתערבות המחשב בסיוע MICCAI 2014, עמ’ 682 689. ספרינגר (2014)

גרף לחתוך סגמנטציה בצורת סטטיסטי multilabel מוקדמת

עבודה משותפת עם דמיאן Grosgeorge, סו Ruan

קוד Matlab:

  • שיסופק בקרוב

הפניות הראשי:

  • ד Grosgeorge, Petitjean ג, ס’ Ruan משותפת חלוקת החדרים הלב מימין ומשמאל תוך שימוש מרובה-תוויות גרף גזירה, IEEE סימפוזיון בינלאומי בנושא ביו הדמיה (ISBI’14), 2014, בייג’ינג, סין
  • ד Grosgeorge, ג Petitjean, J. n Dacher, ס Ruan. גרף לחתוך פילוח מודל סטטיסטי צורה ב- MRI לב, ראייה ממוחשבת והבנת התמונה, כרך 117, עמ’ 1027-1035, 2013.
  • ד Grosgeorge, Petitjean ג, ס’ Ruan, Caudron ג’יי, ג’יי-ש… Dacher. ממש פילוח החדר על ידי גרף לחתוך עם צורה מוקדמת. MICCAI סדנה בינלאומית, אתגר פילוח של החדר הימני, 2012.

קוד MATLAB עבור electroencephalography עיבוד (EEG) ו מגנטו (MEG) נתונים

Mne היא חבילת תוכנה מונחת קהילה מיועדת עבור electroencephalography עיבוד (EEG) ו מגנט (MEG) נתוני מתן כלי זרימות עבודה מקיפים:

  1. עיבוד מקדים
  2. להערכת מקור
  3. ניתוח זמן-תדר
  4. בדיקות סטטיסטיות
  5. הערכת קישוריות תפקודית
  6. החלת אלגוריתמים של למידה חישובית
  7. ויזואליזציה של נתונים sensor- ומקור-שטח

Mne כוללת חבילת פייתון מקיפה (בתנאי תחת רישיון BSD פשוטה), בתוספת כלי הידור מקוד C עבור מערכות הפעלה לינוקס ו- Mac OSX, וכן ארגז כלי MATLAB.

קישור להורדה :

https://github.com/mne-tools/mne-matlab

מקור קישור:

http://martinos.org/mne/stable/index.html

ארגז כלי Matlab לעבודה עם מערכי נתוני מודל נתונים משותפים

סיכום קצר:

nctoolbox הוא Matlab ארגז כלים המספקים גישה לקריאה בלבד כדי מודל נתונים משותפים מערכי נתונים. מתחת למכסה המנוע, nctoolbox משתמשת NetCDF-Java כמו שכבת גישה לנתונים. זה מאפשר nctoolbox לגשתNetCDF , OPeNDAP , HDF5 , גריב, GRIB2, HDF4 ורבים (15+) פורמטים של קבצים אחרים ושירותים באמצעות אותו API.

תיעוד

שאר הסיפור

ישנן מספר כיתות בסיס הנתונים, שניתן להשתמש בהם כדי לקרוא את הנתונים. כל מספק סוגים שונים של פונקציונליות. כל שיעורי הנתונים לספק גישה לנתונים משתנים, רשימה של שמות משתנים, ואת netcdf מייחס גם כאובייקט במערך netcdf-java הבסיסי. רוב המשתמשים יעדיפו להשתמש NCGEODATASET, המעמד האחרון, מאז זה המעמד היחיד שנותן גישה למחלקת geovariable. זה מאפשר subsetting ידי ערכים של קווי אורך / רוחב, על ידי חלונות זמן ואת היכולת לחזור קואורדינטות המשתמשות בשמות זמן תקניים, לאט, לון, z עבור כל משתנה נתונים (ואף מבצע לתאם מרות). יש מחלקה זו גם שיטה למשוך תכונות מקובץ netcdf למבנה matlab נוח ועוד למשוך את ובמידות של קואורדינטות. שיעורי NCDATASET ו CFDATASET המבוגרים נשמרים בעיקר עבור תאימות לאחור.

עוקבים EyeTribe באמצעות Matlab

על אודות

ארגז הכלים של EyeTribe עבור Matlab הוא קבוצה של פונקציות שיכולים לשמש כדי לתקשר עם עקב עין מתוצרתEyeTribe . תהליך התקשורת אינו ישיר, אלא עובר דרך א-שרת תת שמקבל קלט Matlab (כאשר הפונקציות מארגז הכלים הזה נקראות), ולאחר מכן שולח פקודה לשרת EyeTribe בפועל.

התקנה זו היא די מוזרה, אבל זה הפתרון האלגנטי ביותר שאני יכול לבוא עם לעקוף את הבעיה של Matlab שלא פונקציונלי multithreading הגון. פונקציונליות זו נדרש להפעלת אשכול דופק (אשר שומר על קשר עם EyeTribe בחיים), ובהמשך נושא אחר לפקח דגימות (ולכתוב אלה לקובץ יומן). תוצאות דומות עשויים להיות מושגת על ידי שימוש בפונקציות התקשרות במסגרת ה- TCP / IP של Matlab, אולם הגישה הזאת גורמת עיתוי שגיאות במידה לתחומים אחרים: עיתוי בבעיות בעת השימוש של Psychtoolbox WaitSecs פונקציה, ותהליכי רקע ב- Matlab לפשל כל מיני תהליכים רגישים עיתוי אחרים .

לכן, מתוך lazine … לשגות … מתוך מאמץ וניהול תזמון מתוכנן היטב כדי למנוע אובדן זמן על ידי ממציא מחדש את הגלגל, אני פשוט משתמש PyTribe ב סקריפט פייתון קצר (ראה python_source התיקייה עבור המקור) על מנת ליצור Windows הפעלה, אשר אמור להתנהל לפני שאתה מפעיל סקריפט Matlab שלך.

שגרת הכיול מבוססת על Psychtoolbox עבור Matlab, ומחייב חלון פעיל יועבר אליו. זה מבטיח כי אתה חופשי לכייל את הגשש בכל רגע נתון בניסוי, בלי שום מאבק חיצוני כיול שיגרתי עם הניסוי על שליטת התצוגה הפעילה.

אם אינך רוצה לבצע כיול באמצעות Psychtoolbox, אתה עדיין יכול להשתמש בארגז הכלים EyeTribe עבור Matlab, על ידי פשוט לא קורא את eyetribe_calibrate פונקציה. אנא שים לב לעשות אז אתה צריך לכייל את המערכת עם אמצעי משלך, למשל באמצעות ה- GUI עצמו EyeTribe ( C:\Program Files (x86)\EyeTribe\Client\EyeTribeWinUI.exe ) לפני תחילת כל תוכנה קוראת Toolbox EyeTribe עבור Matlab.

חָשׁוּב

הנחה מקובלת מאוד בקרב אנשים באמצעות EyeTribe עבור ארגז כלי Matlab היא הקריאה לפונקציה המדגמת היא דרישה. זה לא נכון! לאחר קורא eyetribe_start_recording ההפעלה (EyeTribe_Matlab_server.exe)יוודא כי נתונים ייכתב לקובץ יומן. קורא eyetribe_stop_recording ייבלם נתוני רישום.eyetribe_sample ו eyetribe_pupil_size הפונקציות אין לי מה לעשות עם הקלטת נתונים!

אז למה הם שם? ובכן, לפעמים אתה רוצה להשתמש בנקודה של המשתתף לגבי לשנות משהו על המסך או לתת משוב. לשם כך, אפשר לקרוא eyetribe_sample כדי לקבל את המבט האחרון קואורדינטות. אלה יכולים לשמש כדי לקבוע את המיקום של גירוי (למשל כדי לנעול אותו להתבונן עמדה), או כדי לפקח אם המשתתפים הוא מסתכל גירוי מסוים.

סיכומו של דבר, eyetribe_sample ו eyetribe_pupil_size הפונקציות נמצאות שם כדי לתמוך מציג תלוי מבט. הם אינם קשורים ההקלטה של נתונים: ריצת ההפעלה ברקע תהיה להתמודד עם זה ברקע, אחסון נתוני מבט תלמיד בקובץ טקסט.

DOWNLOAD

1) עבור אל: https://github.com/esdalmaijer/EyeTribe-Toolbox-for-Matlab

2) לחץ על לחצן ZIP להורדה, או לחץ זה קשר ישיר .

3) חלץ את הארכיון ZIP שהורדת.

4) העתק את התיקייה EyeTribe_for_Matlab למקום שבו אתה רוצה שזה יהיה (למשל בתיקייה ‘מסמכים’,תחת MATLAB).

5) ב Matlab, ללכת קובץ -> הגדרת נתיב -> הוספת תיקייה ובחר את התיקייה שהעתקת בשלב 4.

לחלופין, למקם את הקוד הבא בתחילת הניסוי שלך:

  % בהנחה שאתה הנחת את EyeTribe_for_Matlab ישירות תחת C:
 addpath ( "C: \ EyeTribe_for_Matlab ')

שימוש באתר WINDOWS

  1. התחל שרת EyeTribe C:\Program Files(x86)\EyeTribe\Server\EyeTribe.exe
  2. התחל EyeTribe_Matlab_server.exe .
  3. הפעל סקריפט Matlab שלך, למשל בדוגמה הבאה:

שימוש באתר X ו- Linux OS

הודות @ shandelman116 על נכונותך לנסות את (ראה בעיה מספר 4 ).

  1. פתח מסוף.
  2. השתמש cd הפונקציה ללכת לתיקיית python_source. דוגמה:
 cd /home/python_source
  1. השתמש פייתון לרוץ המקור. פייתון יש להתקין על כל מערכת לינוקס, ואני חושב OS X בדרך כלל מגיע עם זה גם. הקלד את הפקודה הבאה בטרמינל:
 python EyeTribe_Matlab_server.py
  1. עכשיו להפעיל script Matlab שלך (אבל לעשות את זה בתוך שתי דקות של הפעלת סקריפט פייתון, כי זה יהיה פסק זמן אחרי זה).

דוגמא SCRIPT

  % לא טורחים עם בדיקות vsync עבור הדגמה זו
 מסך (ה'העדפה ',' SkipSyncTests ', 1);

 % לאתחל חיבור
 [הצלחה, חיבור] = eyetribe_init ( "מבחן");

 % לפתוח חלון חדש
 מסך חלון = ( 'OpenWindow', 2);

 % לכייל את הגשש
 הצלחה = eyetribe_calibrate (חיבור, חלון);

 צג% חלון ריק
 מסך ( 'Flip', חלון);

 הקלטת start%
 הצלחה = eyetribe_start_recording (חיבור);

 % להיכנס משהו
 הצלחה = eyetribe_log (חיבור, 'TEST_START');

 % לקבל כמה דוגמאות
 הערת%: זה אינה הכרחי עבור הקלטת נתונים
 אוסף%, אבל רק הפגנה של המדגם
 פונקציות% ו pupil_size!
 עבור i = 1: 60
     הפסקה (0.0334)
     [הצלחה, x, y] = eyetribe_sample (חיבור);
     [הצלחה, size] = eyetribe_pupil_size (חיבור);
     חד פעמי ([ 'x =' num2str (x) ", = y 'num2str (y)', s = 'num2str (גודל)])
 סוֹף

 % להיכנס משהו
 הצלחה = eyetribe_log (חיבור, 'TEST_STOP');

 % עצור הקלטה
 הצלחה = eyetribe_stop_recording (חיבור);

 חיבור% קרוב
 הצלחה = eyetribe_close (חיבור);

 % חלון סגור
 מסך ( 'סגור', חלון);

ארגז כלי MATLAB עבור עיבוד גיאומטריה

word_cloud_geometry_i_9

gptoolbox – ארגז כלי עיבוד גיאומטריה

https://github.com/alecjacobson/gptoolbox/

זהו ארגז הכלים של פונקציות MATLAB שימושי לעיבוד הגיאומטריה. יש גם כלים קשורים לעיבוד אופטימיזציה ותמונה constrainted. בדרך כלל אלה הם פונקציות שירות שאינם עומדים לבד יישומים.

הנה רשימה חלקית של תכונות מגניבות ארגז כלי MATLAB זה מכיל:

  • עטיפות עבור TetGen, משולש, QSlim, meshfix
  • רשת חלקה
  • רשת לנקות (להסיר כפילויות, להסיר ומנותק מכל)
  • מרחקים הגיאודזית על משולש meshes טטראהדרלי
  • רשת כמויות ושאילתות (נורמליות, עקמומיות גאוס דיסקרטיות, גבול קצות רשימה, טופולוגיה, זוויות, זוויות dihedral וכו ‘)
  • רשת דפורמציה (כמו-נוקשה עד כמה שאפשר (אראפ), נע הפחות ריבועים, וכו ‘)
  • רשת parameterization (הרמוני, קונפורמי ריבועים פחות, אראפ, וכו ‘)
  • חישוב משקל הפשטה אוטומטית (מתוחם משקולות biharmonic, עצם חום)
  • רשת משולשת 2D מתמונה בינארי
  • קלט / פלט עבור פורמטים רשת רבים (.obj, .off, .stl, .wrl, .ply, .mesh, .node, .ele, .poly, .smf, .bdl, .face)
  • מפעילי גיאומטריה משתנה בדיד עבור משולש meshes טטראהדרלי (cotangent Laplacian, שיפוע, סטייה)
  • תכנות ריבועית, פותר ערכה פעיל
  • צביעה מבוססת תמונת שרבוט, עקומות דיפוזיה
  • מדויק (האו”ם) חתם חישוב שדה מרחק עבור משתלב
  • פעולות גיאומטריה מוצקה בונות על משתלב, בוליאנים
  • מיקום נקודת מואצת משתלבת משולש tetrahedral
  • היסוסים תמונה
  • תלות פונקצית matlab העמוק

התפקיד היה מאורגן בתיקיות לפי היישום העיקרי שלהם:

  • חיצוני/
  • עיבוד תמונה/
  • תמונות /
  • מַטרִיצָה/
  • רֶשֶׁת/
  • MEX /
  • תוֹעֶלֶת/
  • עטיפות /

הַתקָנָה

הרוב המכריע של הקוד הזה הוא MATLAB ישר ( *.m קבצים). לפיכך, רק התקנת MATLAB והוספת בספריית qptoolbox ולמדריכי המשנה שלו לדרך MATLAB שלך הדרושים להתקנה:

 addpath(genpath('/absolute/path/to/gptoolbox'))

כדי לבצע שינוי זה קבע, אז בעיה:

 savepath

ישנם כמה קבצי MEX, תיעוד אשר להתקנה כלולות בקבוצה מתאימה mex/README.md קובץ.

כדי להפעיל כרטיסייה השלימה בנושא פונקציות IO של gptoolbox:

 add_gptoolbox_tab_completion

זה לוקח שני או שניים (או 30) ולאחר מכן תצטרך להפעיל מחדש MATLAB עבור זה ייכנס לתוקף.

התקנה מלאה

זה שואף להיות הוראות התקנה מלאות, אבל ללא ספק להישאר שלם במשך זמן מה. בגין על ידי הוספת נתיבים כנ”ל.

כאמור לעיל, רוב הקבצים ישר matlab ופשוט יפעל אם gptoolbox בדרך שלך.

לקמפל /mex

רוב הקבצים MEX שלנו יהיה תלוי libigl . להלן יתפוס שלך usign “ץ” יוניקס “סטנדרטי” של להתקין libigl כספריה סטטי.

בגיליון MATLAB:

 cd mex compile_qptoolbox_mex

לקמפל toolbox_fast_marching

בגיליון MATLAB:

 cd external/toolbox_fast_marching/ compile_mex

תלות

זה תלוי MATLAB ורחבות ארגז הכלים שונים. פונקציות רבות צריכות גם לעבוד עם אוקטבה, אם כי זה לא נבדק.

פונקציות המסתמכות על quadprog נבדקו אופטימיזציה בהנחת ארגז הכלים המוסק הותקנו, אבל צריך גם לעבוד עם quadprog בארגז הכלים אופטימיזציה של MATLAB.

קבצי Mex עשויים להיות תלות חיצונית אחרת (למשל CGAL, אייגן, libigl). ראה READMEs שלהם לקבלת מידע נוסף. בעת התקנת ספריות MEX, ייתכן שיהיה עליך לשנות את הקבצים wrappers/ (כגוןpath_to_libigl.m ) כך gptoolbox יודע איפה לחפש.

שִׁיוּך

אם אתה משתמש gptoolbox בפרויקטים האקדמיים שלך, צטט את הניירות אנו ליישם על פי צורך. כדי לציין את הספרייה בכלל, אתה יכול להשתמש בערך BibTeX זה:

 @misc{gptoolbox, title = {{gptoolbox}: Geometry Processing Toolbox}, author = {Alec Jacobson and others}, note = {http://github.com/alecjacobson/gptoolbox}, year = {2015}, }

רישיון

אלא אם כן מסומן אחר, כל הקוד הוא בעלת זכויות היוצרים אלק יעקובסון 2015.

אנחנו כנראה נעבור רישיון MPL2 בעתיד הקרוב.

איש קשר

ארגז הכלים של עיבוד הגיאומטריה צמח מתוך codebase הפרטית של אלק יעקובסון במהלך עבודת הדוקטורט שלו, אבל הרוויח הרבה מן משתפי פעולה שונים ב- NYU ו- ETH ציריך. עכשיו, בארגז כלי עיבוד הגיאומטריה הוא מאמץ קבוצתי. אם אתה intersted לתרום, אנא צרו קשר עם אלק יעקובסון ( alecjacobson@gmail.com ) או להגיש בקשה למשוך על GitHub.

תיעוד

לעת עתה, תיעוד מוגבל בסיס לכל פונקציה. לדוגמה, כדי למצוא בתיעוד cotmatrix הבעיה:

 help cotmatrix

סקריפטים Matlab לקרוא ולכתוב קבצי MIDI

התקן MIDI

MIDI הוא ראשי תיבות כי מייצג ממשק דיגיטלי נגינה. זוהי דרך לחיבור התקנים שהופכים וסאונד שליטה – כגון סינתיסייזרים, סמפלרים, ומחשבים – כך שהם יכולים לתקשר אחד עם השני, באמצעות הודעות MIDI. זה מאפשר הדק מקלדת אחת נשמע על סינתיסייזר אחר, וזה מאפשר להקליט את המוזיקה בצורה האפשר עריכת פתק קלה, תזמור גמיש, וסידור שיר. מכשירים וירטואליים – תוכנות מחשב מדמים סינתיסייזרים דוגם חומרה – גם לתקשר עם תוכנת רצף מחשב עם מערכת הפעלה על אותו המחשב באמצעות הודעות MIDI.

דף אינטרנט זה מספק היכרות עם הכללים הבסיסיים של MIDI. היישום האינטרקטיווי אתה יכול להוריד מן הסילבוסעוזר לך להבין כמה פרטים של הודעות MIDI.

למה לענייני MIDI

הנה רק כמה מהדברים MIDI מאפשר:

  • אתה יכול להשתמש במכשיר MIDI שבה אתה מרגיש בנוח לשחק את הצלילים השייכים לכל מכשיר MIDI אחר, כולל סינתיסייזרים רך.
  • יצירת טקסטורות מוזיקלית עשירה על ידי שכבות צלילים מהתקני MIDI מרובים, או להקצות צלילים שונים לשחק בטווחי צליל שונים.
  • כשאתה לנגן על כלי MIDI, היא מייצרת נתונים שאפשר לתפוס אותם על ידי MIDI “ברצף.” כאשר ברצף המשחק חזר את הנתונים, הביצוע המקורי שלך נוצר מחדש. Sequencers אינם רק חליליות MIDI, אף-הם מאפשרים לך לתקן טעויות, לשנות את מגרשי ההערות שלך, לתקן העיתוי שלהם, הדרך בה הם משחקים, הצלילים הם משתמשים, ועוד. בנוסף, רוב sequencers יכול ללכוד הופעות מרובות נפרדים “מסלולים”, המאפשר לך לבנות את עיבודים מלאים, רצועה אחת בכל פעם.
  • סט קול MIDI הכללי מאפשר לך לנגן מוסיקה מוקלטת מראש באופן מיידי על מכשירי MIDI רבים, או במחשב.
  • תקן MIDI אפשר לשלוט על עם אחר, ומאפשר לך להשתמש בכלי הנוח ביותר עבור כל עבודה. מכשיר ערוך MIDI נשמע במחשב, להפעיל מקליט אודיו מתוך MIDI ביט בוקס, וכן הלאה וכן הלאה.

חוברת הטוב ביותר עבור MIDI:

https://www.midi.org/images/easyblog_articles/43/intromid_20160320-111631_1.pdf

  כלי קובץ MIDI עבור MATLAB


 נוֹהָג

   מוסיפים את ספריית 'matlab-midi / src' לדרך Matlab שלך.
   לקריאת יסוד:

   בסיסי לכתוב:

   לקבלת תיעוד מלא, לראות http://kenschutte.com/midi

 רישיון

   קוד זה משוחרר תחת GPL.

 מְחַבֵּר

   קן Schutte
   kenschutte@gmail.com

קישור להורדת קוד מקור:

https://github.com/kts/matlab-midi

הספרייה עבור מכונת וקטורים תומכים (SVM)

Libsvm היא תוכנה פשוטה, קלה לשימוש, ויעילה לסיווג SVM ורגרסיה. זה פותר סיווג C-SVM, נו-SVM
סיווג, ברמה אחת-SVM, רגרסיה אפסילון-SVM, ונסיגה nu-SVM. הוא גם מספק כלי בחירת מודל אוטומטיים עבור
סיווג C-SVM. מסמך זה מסביר את השימוש libsvm.

Libsvm is available at
http://www.csie.ntu.edu.tw/~cjlin/libsvm
Please read the COPYRIGHT file before using libsvm.

Table of Contents
=================

- Quick Start
- Installation and Data Format
- `svm-train' Usage
- `svm-predict' Usage
- `svm-scale' Usage
- Tips on Practical Use
- Examples
- Precomputed Kernels
- Library Usage
- Java Version
- Building Windows Binaries
- Additional Tools: Sub-sampling, Parameter Selection, Format checking, etc.
- MATLAB/OCTAVE Interface
- Python Interface
- Additional Information

Quick Start
===========

If you are new to SVM and if the data is not large, please go to
`tools' directory and use easy.py after installation. It does
everything automatic -- from data scaling to parameter selection.

Usage: easy.py training_file [testing_file]

More information about parameter selection can be found in
`tools/README.'

Installation and Data Format
============================

On Unix systems, type `make' to build the `svm-train' and `svm-predict'
programs. Run them without arguments to show the usages of them.

On other systems, consult `Makefile' to build them (e.g., see
'Building Windows binaries' in this file) or use the pre-built
binaries (Windows binaries are in the directory `windows').

The format of training and testing data file is:

<label> <index1>:<value1> <index2>:<value2> ...
.
.
.

Each line contains an instance and is ended by a '\n' character.  For
classification, <label> is an integer indicating the class label
(multi-class is supported). For regression, <label> is the target
value which can be any real number. For one-class SVM, it's not used
so can be any number.  The pair <index>:<value> gives a feature
(attribute) value: <index> is an integer starting from 1 and <value>
is a real number. The only exception is the precomputed kernel, where
<index> starts from 0; see the section of precomputed kernels. Indices
must be in ASCENDING order. Labels in the testing file are only used
to calculate accuracy or errors. If they are unknown, just fill the
first column with any numbers.

A sample classification data included in this package is
`heart_scale'. To check if your data is in a correct form, use
`tools/checkdata.py' (details in `tools/README').

Type `svm-train heart_scale', and the program will read the training
data and output the model file `heart_scale.model'. If you have a test
set called heart_scale.t, then type `svm-predict heart_scale.t
heart_scale.model output' to see the prediction accuracy. The `output'
file contains the predicted class labels.

For classification, if training data are in only one class (i.e., all
labels are the same), then `svm-train' issues a warning message:
`Warning: training data in only one class. See README for details,'
which means the training data is very unbalanced. The label in the
training data is directly returned when testing.

There are some other useful programs in this package.

svm-scale:

	This is a tool for scaling input data file.

svm-toy:

	This is a simple graphical interface which shows how SVM
	separate data in a plane. You can click in the window to
	draw data points. Use "change" button to choose class
	1, 2 or 3 (i.e., up to three classes are supported), "load"
	button to load data from a file, "save" button to save data to
	a file, "run" button to obtain an SVM model, and "clear"
	button to clear the window.

	You can enter options in the bottom of the window, the syntax of
	options is the same as `svm-train'.

	Note that "load" and "save" consider dense data format both in
	classification and the regression cases. For classification,
	each data point has one label (the color) that must be 1, 2,
	or 3 and two attributes (x-axis and y-axis values) in
	[0,1). For regression, each data point has one target value
	(y-axis) and one attribute (x-axis values) in [0, 1).

	Type `make' in respective directories to build them.

	You need Qt library to build the Qt version.
	(available from http://www.trolltech.com)

	You need GTK+ library to build the GTK version.
	(available from http://www.gtk.org)

	The pre-built Windows binaries are in the `windows'
	directory. We use Visual C++ on a 32-bit machine, so the
	maximal cache size is 2GB.

`svm-train' Usage
=================

Usage: svm-train [options] training_set_file [model_file]
options:
-s svm_type : set type of SVM (default 0)
	0 -- C-SVC		(multi-class classification)
	1 -- nu-SVC		(multi-class classification)
	2 -- one-class SVM
	3 -- epsilon-SVR	(regression)
	4 -- nu-SVR		(regression)
-t kernel_type : set type of kernel function (default 2)
	0 -- linear: u'*v
	1 -- polynomial: (gamma*u'*v + coef0)^degree
	2 -- radial basis function: exp(-gamma*|u-v|^2)
	3 -- sigmoid: tanh(gamma*u'*v + coef0)
	4 -- precomputed kernel (kernel values in training_set_file)
-d degree : set degree in kernel function (default 3)
-g gamma : set gamma in kernel function (default 1/num_features)
-r coef0 : set coef0 in kernel function (default 0)
-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)
-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)
-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)
-m cachesize : set cache memory size in MB (default 100)
-e epsilon : set tolerance of termination criterion (default 0.001)
-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)
-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)
-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)
-v n: n-fold cross validation mode
-q : quiet mode (no outputs)


The k in the -g option means the number of attributes in the input data.

option -v randomly splits the data into n parts and calculates cross
validation accuracy/mean squared error on them.

See libsvm FAQ for the meaning of outputs.

`svm-predict' Usage
===================

Usage: svm-predict [options] test_file model_file output_file
options:
-b probability_estimates: whether to predict probability estimates, 0 or 1 (default 0); for one-class SVM only 0 is supported

model_file is the model file generated by svm-train.
test_file is the test data you want to predict.
svm-predict will produce output in the output_file.

`svm-scale' Usage
=================

Usage: svm-scale [options] data_filename
options:
-l lower : x scaling lower limit (default -1)
-u upper : x scaling upper limit (default +1)
-y y_lower y_upper : y scaling limits (default: no y scaling)
-s save_filename : save scaling parameters to save_filename
-r restore_filename : restore scaling parameters from restore_filename

See 'Examples' in this file for examples.

Tips on Practical Use
=====================

* Scale your data. For example, scale each attribute to [0,1] or [-1,+1].
* For C-SVC, consider using the model selection tool in the tools directory.
* nu in nu-SVC/one-class-SVM/nu-SVR approximates the fraction of training
  errors and support vectors.
* If data for classification are unbalanced (e.g. many positive and
  few negative), try different penalty parameters C by -wi (see
  examples below).
* Specify larger cache size (i.e., larger -m) for huge problems.

Examples
========

> svm-scale -l -1 -u 1 -s range train > train.scale
> svm-scale -r range test > test.scale

Scale each feature of the training data to be in [-1,1]. Scaling
factors are stored in the file range and then used for scaling the
test data.

> svm-train -s 0 -c 5 -t 2 -g 0.5 -e 0.1 data_file

Train a classifier with RBF kernel exp(-0.5|u-v|^2), C=10, and
stopping tolerance 0.1.

> svm-train -s 3 -p 0.1 -t 0 data_file

Solve SVM regression with linear kernel u'v and epsilon=0.1
in the loss function.

> svm-train -c 10 -w1 1 -w-2 5 -w4 2 data_file

Train a classifier with penalty 10 = 1 * 10 for class 1, penalty 50 =
5 * 10 for class -2, and penalty 20 = 2 * 10 for class 4.

> svm-train -s 0 -c 100 -g 0.1 -v 5 data_file

Do five-fold cross validation for the classifier using
the parameters C = 100 and gamma = 0.1

> svm-train -s 0 -b 1 data_file
> svm-predict -b 1 test_file data_file.model output_file

Obtain a model with probability information and predict test data with
probability estimates

Precomputed Kernels
===================

Users may precompute kernel values and input them as training and
testing files.  Then libsvm does not need the original
training/testing sets.

Assume there are L training instances x1, ..., xL and.
Let K(x, y) be the kernel
value of two instances x and y. The input formats
are:

New training instance for xi:

<label> 0:i 1:K(xi,x1) ... L:K(xi,xL)

New testing instance for any x:

<label> 0:? 1:K(x,x1) ... L:K(x,xL)

That is, in the training file the first column must be the "ID" of
xi. In testing, ? can be any value.

All kernel values including ZEROs must be explicitly provided.  Any
permutation or random subsets of the training/testing files are also
valid (see examples below).

Note: the format is slightly different from the precomputed kernel
package released in libsvmtools earlier.

Examples:

	Assume the original training data has three four-feature
	instances and testing data has one instance:

	15  1:1 2:1 3:1 4:1
	45      2:3     4:3
	25          3:1

	15  1:1     3:1

	If the linear kernel is used, we have the following new
	training/testing sets:

	15  0:1 1:4 2:6  3:1
	45  0:2 1:6 2:18 3:0
	25  0:3 1:1 2:0  3:1

	15  0:? 1:2 2:0  3:1

	? can be any value.

	Any subset of the above training file is also valid. For example,

	25  0:3 1:1 2:0  3:1
	45  0:2 1:6 2:18 3:0

	implies that the kernel matrix is

		[K(2,2) K(2,3)] = [18 0]
		[K(3,2) K(3,3)] = [0  1]

Library Usage
=============

These functions and structures are declared in the header file
`svm.h'.  You need to #include "svm.h" in your C/C++ source files and
link your program with `svm.cpp'. You can see `svm-train.c' and
`svm-predict.c' for examples showing how to use them. We define
LIBSVM_VERSION and declare `extern int libsvm_version; ' in svm.h, so
you can check the version number.

Before you classify test data, you need to construct an SVM model
(`svm_model') using training data. A model can also be saved in
a file for later use. Once an SVM model is available, you can use it
to classify new data.

- Function: struct svm_model *svm_train(const struct svm_problem *prob,
					const struct svm_parameter *param);

    This function constructs and returns an SVM model according to
    the given training data and parameters.

    struct svm_problem describes the problem:

	struct svm_problem
	{
		int l;
		double *y;
		struct svm_node **x;
	};

    where `l' is the number of training data, and `y' is an array containing
    their target values. (integers in classification, real numbers in
    regression) `x' is an array of pointers, each of which points to a sparse
    representation (array of svm_node) of one training vector.

    For example, if we have the following training data:

    LABEL    ATTR1    ATTR2    ATTR3    ATTR4    ATTR5
    -----    -----    -----    -----    -----    -----
      1        0        0.1      0.2      0        0
      2        0        0.1      0.3     -1.2      0
      1        0.4      0        0        0        0
      2        0        0.1      0        1.4      0.5
      3       -0.1     -0.2      0.1      1.1      0.1

    then the components of svm_problem are:

    l = 5

    y -> 1 2 1 2 3

    x -> [ ] -> (2,0.1) (3,0.2) (-1,?)
         [ ] -> (2,0.1) (3,0.3) (4,-1.2) (-1,?)
         [ ] -> (1,0.4) (-1,?)
         [ ] -> (2,0.1) (4,1.4) (5,0.5) (-1,?)
         [ ] -> (1,-0.1) (2,-0.2) (3,0.1) (4,1.1) (5,0.1) (-1,?)

    where (index,value) is stored in the structure `svm_node':

	struct svm_node
	{
		int index;
		double value;
	};

    index = -1 indicates the end of one vector. Note that indices must
    be in ASCENDING order.

    struct svm_parameter describes the parameters of an SVM model:

	struct svm_parameter
	{
		int svm_type;
		int kernel_type;
		int degree;	/* for poly */
		double gamma;	/* for poly/rbf/sigmoid */
		double coef0;	/* for poly/sigmoid */

		/* these are for training only */
		double cache_size; /* in MB */
		double eps;	/* stopping criteria */
		double C;	/* for C_SVC, EPSILON_SVR, and NU_SVR */
		int nr_weight;		/* for C_SVC */
		int *weight_label;	/* for C_SVC */
		double* weight;		/* for C_SVC */
		double nu;	/* for NU_SVC, ONE_CLASS, and NU_SVR */
		double p;	/* for EPSILON_SVR */
		int shrinking;	/* use the shrinking heuristics */
		int probability; /* do probability estimates */
	};

    svm_type can be one of C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR.

    C_SVC:		C-SVM classification
    NU_SVC:		nu-SVM classification
    ONE_CLASS:		one-class-SVM
    EPSILON_SVR:	epsilon-SVM regression
    NU_SVR:		nu-SVM regression

    kernel_type can be one of LINEAR, POLY, RBF, SIGMOID.

    LINEAR:	u'*v
    POLY:	(gamma*u'*v + coef0)^degree
    RBF:	exp(-gamma*|u-v|^2)
    SIGMOID:	tanh(gamma*u'*v + coef0)
    PRECOMPUTED: kernel values in training_set_file

    cache_size is the size of the kernel cache, specified in megabytes.
    C is the cost of constraints violation.
    eps is the stopping criterion. (we usually use 0.00001 in nu-SVC,
    0.001 in others). nu is the parameter in nu-SVM, nu-SVR, and
    one-class-SVM. p is the epsilon in epsilon-insensitive loss function
    of epsilon-SVM regression. shrinking = 1 means shrinking is conducted;
    = 0 otherwise. probability = 1 means model with probability
    information is obtained; = 0 otherwise.

    nr_weight, weight_label, and weight are used to change the penalty
    for some classes (If the weight for a class is not changed, it is
    set to 1). This is useful for training classifier using unbalanced
    input data or with asymmetric misclassification cost.

    nr_weight is the number of elements in the array weight_label and
    weight. Each weight[i] corresponds to weight_label[i], meaning that
    the penalty of class weight_label[i] is scaled by a factor of weight[i].

    If you do not want to change penalty for any of the classes,
    just set nr_weight to 0.

    *NOTE* Because svm_model contains pointers to svm_problem, you can
    not free the memory used by svm_problem if you are still using the
    svm_model produced by svm_train().

    *NOTE* To avoid wrong parameters, svm_check_parameter() should be
    called before svm_train().

    struct svm_model stores the model obtained from the training procedure.
    It is not recommended to directly access entries in this structure.
    Programmers should use the interface functions to get the values.

	struct svm_model
	{
		struct svm_parameter param;	/* parameter */
		int nr_class;		/* number of classes, = 2 in regression/one class svm */
		int l;			/* total #SV */
		struct svm_node **SV;		/* SVs (SV[l]) */
		double **sv_coef;	/* coefficients for SVs in decision functions (sv_coef[k-1][l]) */
		double *rho;		/* constants in decision functions (rho[k*(k-1)/2]) */
		double *probA;		/* pairwise probability information */
		double *probB;
		int *sv_indices;        /* sv_indices[0,...,nSV-1] are values in [1,...,num_traning_data] to indicate SVs in the training set */

		/* for classification only */

		int *label;		/* label of each class (label[k]) */
		int *nSV;		/* number of SVs for each class (nSV[k]) */
					/* nSV[0] + nSV[1] + ... + nSV[k-1] = l */
		/* XXX */
		int free_sv;		/* 1 if svm_model is created by svm_load_model*/
					/* 0 if svm_model is created by svm_train */
	};

    param describes the parameters used to obtain the model.

    nr_class is the number of classes. It is 2 for regression and one-class SVM.

    l is the number of support vectors. SV and sv_coef are support
    vectors and the corresponding coefficients, respectively. Assume there are
    k classes. For data in class j, the corresponding sv_coef includes (k-1) y*alpha vectors,
    where alpha's are solutions of the following two class problems:
    1 vs j, 2 vs j, ..., j-1 vs j, j vs j+1, j vs j+2, ..., j vs k
    and y=1 for the first j-1 vectors, while y=-1 for the remaining k-j
    vectors. For example, if there are 4 classes, sv_coef and SV are like:

        +-+-+-+--------------------+
        |1|1|1|                    |
        |v|v|v|  SVs from class 1  |
        |2|3|4|                    |
        +-+-+-+--------------------+
        |1|2|2|                    |
        |v|v|v|  SVs from class 2  |
        |2|3|4|                    |
        +-+-+-+--------------------+
        |1|2|3|                    |
        |v|v|v|  SVs from class 3  |
        |3|3|4|                    |
        +-+-+-+--------------------+
        |1|2|3|                    |
        |v|v|v|  SVs from class 4  |
        |4|4|4|                    |
        +-+-+-+--------------------+

    See svm_train() for an example of assigning values to sv_coef.

    rho is the bias term (-b). probA and probB are parameters used in
    probability outputs. If there are k classes, there are k*(k-1)/2
    binary problems as well as rho, probA, and probB values. They are
    aligned in the order of binary problems:
    1 vs 2, 1 vs 3, ..., 1 vs k, 2 vs 3, ..., 2 vs k, ..., k-1 vs k.

    sv_indices[0,...,nSV-1] are values in [1,...,num_traning_data] to
    indicate support vectors in the training set.

    label contains labels in the training data.

    nSV is the number of support vectors in each class.

    free_sv is a flag used to determine whether the space of SV should
    be released in free_model_content(struct svm_model*) and
    free_and_destroy_model(struct svm_model**). If the model is
    generated by svm_train(), then SV points to data in svm_problem
    and should not be removed. For example, free_sv is 0 if svm_model
    is created by svm_train, but is 1 if created by svm_load_model.

- Function: double svm_predict(const struct svm_model *model,
                               const struct svm_node *x);

    This function does classification or regression on a test vector x
    given a model.

    For a classification model, the predicted class for x is returned.
    For a regression model, the function value of x calculated using
    the model is returned. For an one-class model, +1 or -1 is
    returned.

- Function: void svm_cross_validation(const struct svm_problem *prob,
	const struct svm_parameter *param, int nr_fold, double *target);

    This function conducts cross validation. Data are separated to
    nr_fold folds. Under given parameters, sequentially each fold is
    validated using the model from training the remaining. Predicted
    labels (of all prob's instances) in the validation process are
    stored in the array called target.

    The format of svm_prob is same as that for svm_train().

- Function: int svm_get_svm_type(const struct svm_model *model);

    This function gives svm_type of the model. Possible values of
    svm_type are defined in svm.h.

- Function: int svm_get_nr_class(const svm_model *model);

    For a classification model, this function gives the number of
    classes. For a regression or an one-class model, 2 is returned.

- Function: void svm_get_labels(const svm_model *model, int* label)

    For a classification model, this function outputs the name of
    labels into an array called label. For regression and one-class
    models, label is unchanged.

- Function: void svm_get_sv_indices(const struct svm_model *model, int *sv_indices)

    This function outputs indices of support vectors into an array called sv_indices.
    The size of sv_indices is the number of support vectors and can be obtained by calling svm_get_nr_sv.
    Each sv_indices[i] is in the range of [1, ..., num_traning_data].

- Function: int svm_get_nr_sv(const struct svm_model *model)

    This function gives the number of total support vector.

- Function: double svm_get_svr_probability(const struct svm_model *model);

    For a regression model with probability information, this function
    outputs a value sigma > 0. For test data, we consider the
    probability model: target value = predicted value + z, z: Laplace
    distribution e^(-|z|/sigma)/(2sigma)

    If the model is not for svr or does not contain required
    information, 0 is returned.

- Function: double svm_predict_values(const svm_model *model,
				    const svm_node *x, double* dec_values)

    This function gives decision values on a test vector x given a
    model, and return the predicted label (classification) or
    the function value (regression).

    For a classification model with nr_class classes, this function
    gives nr_class*(nr_class-1)/2 decision values in the array
    dec_values, where nr_class can be obtained from the function
    svm_get_nr_class. The order is label[0] vs. label[1], ...,
    label[0] vs. label[nr_class-1], label[1] vs. label[2], ...,
    label[nr_class-2] vs. label[nr_class-1], where label can be
    obtained from the function svm_get_labels. The returned value is
    the predicted class for x. Note that when nr_class = 1, this
    function does not give any decision value.

    For a regression model, dec_values[0] and the returned value are
    both the function value of x calculated using the model. For a
    one-class model, dec_values[0] is the decision value of x, while
    the returned value is +1/-1.

- Function: double svm_predict_probability(const struct svm_model *model,
	    const struct svm_node *x, double* prob_estimates);

    This function does classification or regression on a test vector x
    given a model with probability information.

    For a classification model with probability information, this
    function gives nr_class probability estimates in the array
    prob_estimates. nr_class can be obtained from the function
    svm_get_nr_class. The class with the highest probability is
    returned. For regression/one-class SVM, the array prob_estimates
    is unchanged and the returned value is the same as that of
    svm_predict.

- Function: const char *svm_check_parameter(const struct svm_problem *prob,
                                            const struct svm_parameter *param);

    This function checks whether the parameters are within the feasible
    range of the problem. This function should be called before calling
    svm_train() and svm_cross_validation(). It returns NULL if the
    parameters are feasible, otherwise an error message is returned.

- Function: int svm_check_probability_model(const struct svm_model *model);

    This function checks whether the model contains required
    information to do probability estimates. If so, it returns
    +1. Otherwise, 0 is returned. This function should be called
    before calling svm_get_svr_probability and
    svm_predict_probability.

- Function: int svm_save_model(const char *model_file_name,
			       const struct svm_model *model);

    This function saves a model to a file; returns 0 on success, or -1
    if an error occurs.

- Function: struct svm_model *svm_load_model(const char *model_file_name);

    This function returns a pointer to the model read from the file,
    or a null pointer if the model could not be loaded.

- Function: void svm_free_model_content(struct svm_model *model_ptr);

    This function frees the memory used by the entries in a model structure.

- Function: void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr);

    This function frees the memory used by a model and destroys the model
    structure. It is equivalent to svm_destroy_model, which
    is deprecated after version 3.0.

- Function: void svm_destroy_param(struct svm_parameter *param);

    This function frees the memory used by a parameter set.

- Function: void svm_set_print_string_function(void (*print_func)(const char *));

    Users can specify their output format by a function. Use
        svm_set_print_string_function(NULL);
    for default printing to stdout.

Java Version
============

The pre-compiled java class archive `libsvm.jar' and its source files are
in the java directory. To run the programs, use

java -classpath libsvm.jar svm_train <arguments>
java -classpath libsvm.jar svm_predict <arguments>
java -classpath libsvm.jar svm_toy
java -classpath libsvm.jar svm_scale <arguments>

Note that you need Java 1.5 (5.0) or above to run it.

You may need to add Java runtime library (like classes.zip) to the classpath.
You may need to increase maximum Java heap size.

Library usages are similar to the C version. These functions are available:

public class svm {
	public static final int LIBSVM_VERSION=321;
	public static svm_model svm_train(svm_problem prob, svm_parameter param);
	public static void svm_cross_validation(svm_problem prob, svm_parameter param, int nr_fold, double[] target);
	public static int svm_get_svm_type(svm_model model);
	public static int svm_get_nr_class(svm_model model);
	public static void svm_get_labels(svm_model model, int[] label);
	public static void svm_get_sv_indices(svm_model model, int[] indices);
	public static int svm_get_nr_sv(svm_model model);
	public static double svm_get_svr_probability(svm_model model);
	public static double svm_predict_values(svm_model model, svm_node[] x, double[] dec_values);
	public static double svm_predict(svm_model model, svm_node[] x);
	public static double svm_predict_probability(svm_model model, svm_node[] x, double[] prob_estimates);
	public static void svm_save_model(String model_file_name, svm_model model) throws IOException
	public static svm_model svm_load_model(String model_file_name) throws IOException
	public static String svm_check_parameter(svm_problem prob, svm_parameter param);
	public static int svm_check_probability_model(svm_model model);
	public static void svm_set_print_string_function(svm_print_interface print_func);
}

The library is in the "libsvm" package.
Note that in Java version, svm_node[] is not ended with a node whose index = -1.

Users can specify their output format by

	your_print_func = new svm_print_interface()
	{
		public void print(String s)
		{
			// your own format
		}
	};
	svm.svm_set_print_string_function(your_print_func);

Building Windows Binaries
=========================

Windows binaries are available in the directory `windows'. To re-build
them via Visual C++, use the following steps:

1. Open a DOS command box (or Visual Studio Command Prompt) and change
to libsvm directory. If environment variables of VC++ have not been
set, type

""C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\amd64\vcvars64.bat""

You may have to modify the above command according which version of
VC++ or where it is installed.

2. Type

nmake -f Makefile.win clean all

3. (optional) To build shared library libsvm.dll, type

nmake -f Makefile.win lib

4. (optional) To build 32-bit windows binaries, you must
	(1) Setup "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat" instead of vcvars64.bat
	(2) Change CFLAGS in Makefile.win: /D _WIN64 to /D _WIN32

Another way is to build them from Visual C++ environment. See details
in libsvm FAQ.

- Additional Tools: Sub-sampling, Parameter Selection, Format checking, etc.
============================================================================

See the README file in the tools directory.

MATLAB/OCTAVE Interface
=======================

Please check the file README in the directory `matlab'.

Python Interface
================

See the README file in python directory.

Additional Information
======================

If you find LIBSVM helpful, please cite it as

Chih-Chung Chang and Chih-Jen Lin, LIBSVM : a library for support
vector machines. ACM Transactions on Intelligent Systems and
Technology, 2:27:1--27:27, 2011. Software available at
http://www.csie.ntu.edu.tw/~cjlin/libsvm

LIBSVM implementation document is available at
http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf

For any questions and comments, please email cjlin@csie.ntu.edu.tw

Acknowledgments:
This work was supported in part by the National Science
Council of Taiwan via the grant NSC 89-2213-E-002-013.
The authors thank their group members and users
for many helpful discussions and comments. They are listed in
http://www.csie.ntu.edu.tw/~cjlin/libsvm/acknowledgements

 

source :

https://github.com/cjlin1/libsvm