ניתוח אותות ומערכות א' 2017/2018

Transcript

1 ניתוח אותות ומערכות א' חורף סמסטר 2017/2018

2

3 4 69 הרצאות תרגולים מס' עמוד הרצאות

4 דנה לינדר שחם ניתוח אותות ומערכות מרצים: ד"ר עמרי ברק. ד"ר דורי דריקמן. מבוא לתכנות: נתחיל בלהבין את סוג הבעיות שאיתם נתמודד. דוגמא: יוסי מגיע למיון, דופק 180, חום 39 מעלות. נשאלת השאלה האם הוא יתאשפז? ההחלטה אמורה להיות סטטיסטית. אותה עושים באמצעות תכנות. שלב ראשון בתכנות הוא להגדיר בעייה )למשל, האם האדם יתאשפז(. הגדרת הבעייה צריכה להיות מאוד מדויקת )למשל, בהינתן דופן וחום כאלו..(. בתהליך התכנות יש את הקלט- מה יכנס )הנתונים של יוסי(, ופלט- מה יצא )תשובה לגבי האשפוז(. האלגוריתם הוא הרעיון של הפתרון. הוא כולל את התכנון של שלבי העבודה. השלב האחרון הוא תיקון טעויות. ברוב המקרים כאשר כותבים תכנה, היא לא עובדת כפי שציפינו, וזה בגלל שכמעט תמיד יש טעויות. נניח כי הדבר היחיד שמשפיע על אשפוז הוא האם הדופק גבוה מ אנו מקבלים רשימה של אנשים, עם הדופק שלהם, ורוצים להוציא תשובה של כן/לא. פתרון: נציג אותו באמצעות תרשים זרימה: עבור מטופל מסיום מתחילים, שואלים האם הדופק גדול מ אם לא רושמים "לא", אם כן רושמים "כן". זה הסוף. start Yes Pulse>120? No Write "Yes" -4- Write "No"

5 כמובן שזה תרשים זרימה לכל מטופל. צריך לעשות את זה עבור על המטופלים אשר ברשימה. לשם כך צריך להגדיר משתנים לקלט ולפלט. נניח משתנה הפלט יהיה.hospital אז בתרשים שלנו, נזין לתוך hospital את ה"כן" וה"לא" בהתאם למטופל ולפרטים שלו. על פי תרשים הזרימה שלנו, אם הדופק יהיה 120 בדיוק, אנחנו אמורים לקבל "לא". כי 120 אינו גדול מ- 120, שזו שאלת הסינון. מה עושים עם משתנים? ניתן לעשות השמה. כמו שעושים למשתנה "מטופל". ניתן לעשות השוואה. כמו שעשינו עם המשתנה "דופק"..1.2 כתיבת אלגוריתם )באופן חופשי(: If Pulse>120 Hospital "Yes" Else Hospital "No" כתיבת האלגוריתם )במטלב(: If pulse>120 Hospital='yes' Else Hospital='no' End השמה של משתנים במטלב: דוגמא: 7=a. צריך לשים את ה- a משמאל ואת המספר/ביטוי מימין. -5-

6 פונקציות של מטלב: יש פונקציות מוכנות במטלב, שניתן להשתמש בהם. כך למשל הפונקציה abs תתן את הערך המוחלט של המשתנה. הכתיב היה abs(a) כאשר a הוא משתנה. למטלב יש יתרון בו ניתן לעבוד עם רשימות של משתנים. זאת באמצעות וקטורים או מטריצות. למשל, אם נרצה ליצור את המשתנה,pulses אשר מקבל את הערכים של הדופק של כל החולים, ניתן לעשות כך: 1].pulses=[ *פה שמתי רווחים בין המספרים, יכולתי גם לשים פסיקים. *כלומר יש סוגים שונים של משתנים- integer )פשוט מספר סקלארי(, מערך )וקטור(, סטרינג )שזה כיתוב(. ניתן לעשות על אותו המערך הוקטורי גם פעולות מתמטיות. למשל אם ניקח את,pulses+2 כל הערכים בתוך pulses יגדלו ב- 2 ( 3] [ ) ניתן גם לחבר או לחסר שני וקטורים שהם בעלי אותו הגודל. למשל, אם 2] b=[ ,a=[ ], ונעשה,c=a+b נקבל כי:.c=[ ] ניתן גם לשלוף איבר אחד מתוך המערך. כדי לעשות זאת ניתן לרשום,pulses(3) וזה ישלוף את האיבר השלישי מתוך המערך.pulses ניתן גם להשים לתוך משתנה חדש את אחד מאיברי מערך אחר: אם נכתוב:,c=b(3) אז לתוך c יכנס מספר אחד, שהוא האיבר השלישי בתוך b. אם נכתוב,c=b(3)+a(1) אז לתוך c יכנס מספר אחד, שהוא חיבור של האיבר השלישי ב- עם האיבר הראשון ב- a. b ניתן לבצע פעולת השמה לתוך איבר ספציפי במערך: 7=(2)b, אומר שלתוך מערך b באיבר השני יכנס המספר 7. שמות משתנים: -כדאי לבחור שם הגיוני hospital( )pulse, ולא.a,b,1,2 זה על מנת שנזכור בהמשך מה עשינו, וזה יהיה פחות מבלבל. כמו כן אחרים יוכלו יותר בקלות לקרוא את הקוד שלנו. -יש מספר חוקים לשמות משתנים. למשל- אסור להתחיל במספר, לשים מינוס, לעשות רווח. -יש מילים שמורים שלא ניתן להשתמש בהם, כמו.if, else -6-

7 למשל, אם ניצור משתנה b כך: [1 3] 2 =b, ואז ניתן פקודה 7=(2)b, אז משתנה b יהפוך להיות: [1 3]=b. 7 אם נמשיך עם הדוגמא הזו, ונגדיר 1=c, ואז 4]=b. 7 [1 יהפוך להיות: b אז הערך של,b(c)=4 דוגמא נוספת יותר מסובכת: c=[1 2] b=[3 7].d=b(c) ערך d בסוף הפעולה הוא: [7 3]=d. *הפקודה אומרת כי לתוך d צריך להכניס את האיברים ה- cים של מערך b, שזה האיברים הראשון והשני נמשיך קצת עם השמה. כאמור, ניתן להעשות השמה לתוך משתנה, כאשר משתמשים באיברים של מערך אחר עם האינדקסים הרלוונטים. נניח כי יש מערך של חמישה איברים: [3.forest=[ אם נרשום ([5,tree=forest([3, נקבל מערך של שני איברים [3.tree=[99 אסור היה לרשום,tree=forest(3,5) כי בסוגריים עגולים צריך לבוא אינדקס אחד. בסוגרים מרובעים צריך לבוא מערך. דוגמא נוספת: התשובה הנכונה היא התשובה הרביעית. למעשה עשינו השמה לאיבר השני בתוך a )באמצעות האינדקס מ- b (. -7-

8 דוגמא נוספת: התוצאות של המשתנים יהיו: [11 -Apple=[ מערך שמתחיל ב- 3, עולה בקפיצות של 2, עד לא יכלל כבר..apple מערך שצריך לקחת את האיבר השני, שלישי ורביעי של -orange=[5 7 [9 [5 strawberry=[9 -מערך 7 שצריך לקחת את האיבר השלישי מ- orange, את האיבר השני והראשון )בסדר הזה(. ניתן ליצור מערך ריק ללא איברים. ניתן ליצור מערך על ידי פעולת השמה, וזה אומר לעשות השמה לכאורה לאיבר שאינו קיים. נניח אין מערך בשם a, ואנחנו מבקשים 5=(8)a, אז נקבל מערך של 8 איברים, כאשר השבעה הראשונים הם אפס, והאחרון הוא 5. פעולות חשבון על מערכים: אם אנחנו רוצים לעשות פעולות חשבון על מערכים, הם חייבים להיות באותו גודל. למשל פעולת חיבור: [5 3]+[3 4 2] תתן הודעת שגיאה, כי במערך הראשון יש שני איברים ובשני שלושה. סקריפט: זו רשימת פקודות שמבוצעות זו אחר זו. ניתן לשמור את הסקריפט להריץ אותו שוב ושב. במטלב כדי לרשום סקריפט צריך לרשום edit ב- window.command אז לכתוב בחלון שנפתח את הסקריפט. אם נשמור את הסקריפט, ואז נרשום ב- window command אז שם הסקריפט המטלב יריץ אותו. פעולות בוליאניות: פעולות של אמת ושקר. הם יחזירו 1 אם הביטוי נכון, ו- 0 אם הוא לא. אם נרשום )ב- command ( את השורה 5>3, והוא יחזיר לנו 0. אם נרשום 5<3 יתקבל

9 למעשה הסימן גדול או קטן הוא כמו פעולה חשבונית )כמו +,-,^(, רק שהיא מוציאה 0 או 1. לשים לב כי הסימן '=' אינו פעולה כמו <,>, כי הוא שייך להשמה. למשל 7=7 יתן שגיאה. אם רוצים לבחון שיוויון צריך לרשום '=='. למשל 7==7 יתן 1. כדי לבחון אי שיוויון הסימון הוא '=~'. כמובן שיש גם =>, =< )זה גדול או שווה וקטן או שווה בהתאמה(. הסימון '&' הוא וגם, ו- זה או. את הפעולות הבוליאניות אפשר לבדוק גם על מערכים. הבדיקה תעשה איבר איבר. דוגמא: 9] 5]>[1 [3 נקבל 0[.]1 ניתן לחבר פעולות בוליאניות לקבלת תשובה אחת: אם 5=a, ואנו נרשום: (a>3) & (a<1) נקבל 0. כי הוא כן גדול מ- 3 אבל לא קטן מ- 1. לוקיגה בוליאנית: דוגמא: ( (4>2)&(2==3) ) (4<9) תשובה: נשארנו בסוף אם 0 או 1, לכן זה

10 דוגמא: (3>3) 0.1 ((3>7) (7>3)) & ((3>3) (3<3)) 1 & (3<7) == (3~=7) 1==1 1.3 ~(-4>1) & ~(7>3) 1 & פקודת :if במהלך הסקריפט יש תנאי, שהוא הוא שווה לאחד, אז הפקודה אחרי ה- if תתבצע. אם הוא שווה לאפס, הפקודה לא תתבצע. בסוף רושמים. דוגמא: על המסך יופיע: *בגלל שאחרי ה- if היה 1, הפקודה בפנים התבצעה. *אם הסקריפט היה שאחרי ה- if היה 0, אז היינו רואים:

11 a=2 b=10 c=33 if a<b (###1) b=5 a=7 if a<b (###0) c=55 disp(c) c=33. דוגמא: הפקודות שראינו עכשיו יכולות לבדוק לנו תנאי ולעשות פקודות על הפלט כאשר יש קלט 1. אם חוזרים לדוגמא של המטופלים והאשפוז, אז זה רלוונטי לדוגמא בה יש מטופל אחד. אבל מה עם יש כמה מטופלים? לשם כך יש לולאות. נניח כי יש לנו פה את המערך עם הנתונים של כמה מטופלים, בתוך המשתנה.pulse pulse= [ ] הלולאה הבאה: for p=pulse disp(p) תגרור הצגה של הנתונים של כל המטופלים. והערך של p בסוף הלולאה יהיה 60. אבל תוך כדי ההרצה הוא היה כל פעם ערך אחר )האיברים במערך pulse בסדר עולה(. שילוב לולאה ותנאי: זו הדרך לבדוק האם צריך לאשפז את המטופלים שלנו: הפלט יהיה: No No No No Yes No -11-

12 הסקריפט שאנו רואים למעלה גורר שתהיה הצגה של התשובות. אבל במקור של הבעייה רצינו להזין את התשובות לתוך מערך אחר הנקרא.hospital כדי לעשות זאת, צריך להגדיר קודם את המשתנה hospital בתור מערך ריק. וגם להגדיר אינדקס רץ, שבלולאה הוא יריץ את האינדקסים של המשתנה.hospital צריך לשים לב שיש להעלות כל פעם את האינדקס באחד, וזה מחוץ לתנאי של ה- if. בעקרון לא היינו חייבים להגדיר את המשתנה hospital מחוץ ללולאה. אבל זו דרך לוודא שהוא יהיה ריק )נניח אם היינו משתמשים בסקריפט הזה יום אחר יום, ואז המערך כבר היה מלא מתוך הערכים של אתמול(. שימוש אחר ב- for, יותר נפוץ: פה לא הוגדר משתנה p, והלולאה רצה על Pulse באופן עקיף, באמצעות האינדקס. לולאות מקוננות: דוגמא: פה בפלט יופיעו על המסך 6 מספרים. [11, 12, 21, 22, 31, 32] -12-

13 שאלה: סיבוב ראשון: :i=6.c=1 סיבוב שני: i=5.c=2 סיבוב שלישי: i=4 c=8 סיבוב רביעי: i=3 c=24 סיבוב חמישי: i=2.c=48 התשובה היא

14 לולאות :while בשונה מלולאה,for ללולאה זו אין משתנה לולאה, אבל יש תנאי סיום. דוגמא: המספרים שיכנסו ל- a יהיו:,1, 2, 4, 8, 16, 32 ואז יעצר. אם היינו שמים אפס בהתחלה ב- a, הלולאה הייתה ממשיכה לנצח. מערכים ולולאות: במערכים יש יותר מאיבר אחד. לולאה מאפשרת לנו לבצע פעולות על כל האיברים של המערך, אם רצים על האינדקס. ולכן אם היינו רוצים לעשות פעולה על כל אחד מאיברי המערך, יכולנו לשים לולאה הרצה על האינדקסים של המערך, אבל היתרון של מטלב הוא שאין צורך בזה, כי ניתן לעשות פעולות אלגבריות על המערך שחוסכות בקוד. למשל, בדוגמא הבאה, שתי הפעולות האלו שקולות )הוספת 3 לכל אחד מאיברי המערך(: דוגמא נוספת: פה יש פעולות שקולות, כאשר הפעולה היא פעולה לוגית. התוצאה היא שבכל פעם שהאיבר בתוך b גדול מ- 2, האיבר התואם ב- c ישונה ל

15 נחזור לדוגמא של אשפוז חולים על פי דופק, אבל על פי התנאים הבאים: אם המטופל הוא בין 18 ל- 25, יאושפז מי שהדופק שלו גדול מ אם המטופל מעל גיל 25, יאושפז מי שהדופק שלו בין 80 ל אם המטופל מתחת לגיל 18, יאושפז מי שהדופק שלו מעל 200 פחות הגיל. - איך כותבים את זה? pulse = [ ]; age = [ ]; N = length(pulse); hospital = zeros(1,n); for idx=1:n hospital(idx) = ishospital (pulse(idx), age(idx) ); זו פונקציה. נכנס לה קלט והיא תוציא לנו פלט. זה עוזר לנו לא להתבלבל אם כל %%% התנאים השונים, ולשמור בראש על התמונה הגדולה )שהיא- לרוץ על המטופלים, ועל כל אחד לקבל החלטה האם לאשפז או לא(. פונקציה המטרה של פונקציות היא פירוק בעייה גדולה לבעיות קטנות יותר. בדוגמא שלנו, יש לנו רשימה גדולה של אנשים, ועל כך אחד צריך להחליט אם לאשפז או לא. הבעייה הגדולה היא לעבור על כל האנשים ולקבל החלטה. אבל ההחלטה האם לאשפז היא בעייה נפרדת, תת בעייה של הבעייה הקטנה. נניח והרשימה של המטופלים הייתה באיזה אתר אינטרנט. אז הייתה עוד תת בעייה שהיא למצוא את המטופלים- להיכנס לרשת, לאיזה אתר, שם למצוא אותם.. עוד יתרון של הפונקציה היא שניתן לשמור אותה ולהשתמש בה על פעם. -15-

16 בפונקציה צריך להגדיר בדיוק מהו הקלט ומהו הפלט. איך מגדירים פונקציה? לפונקציה יש שם,)isHospital( ולאחר השם צריך להופיע בסוגריים עגולים את הקלטים )הם באדום(. הפקודה פונקציה תהיה ראשונה, ואחריה יופיע משתנה שאליו יכנס הפלט )בכחול((:.function yesno = ishospital (inpulse, inage) נשים לב כי לא קראנו למשתני הקלט באותו השם של המערכים של הקלט. זה משום שהם משתנים שיכולים לקבל כל מיני מערכים )למשל את הנתונים של היום ושל מחר, ונתונים מאיזו רשימה בתוך האינטרנט. זה לא בהכרח המערכים הספציפיים.)pulse, age איך תראה הפונקציה הרלוונטית לבעייה שלנו? function yesno = ishospital (inpulse, inage) yesno = 0; if inage < 18 if inpulse> (200-inAge) %% another option: if (inage + inpulse) > 200 yesno = 1; elseif inage<=25 if inpulse>130 yesno = 1; else if inpulse>80 & inpulse<100 yesno = 1; את הפונקציה צריך לשמור, ושם הקובץ צריך להיות כמו שם הפונקציה. -16-

17 פונקציה היא קטע קוד השמור בקובץ M )כמו סקריפט(, המיועד לבצע מטלה מסוג מסוים. כשיש צורך ניתן לקרוא לפונקציה. בקריאה ניתן להעביר קלט ולקבל פלט. זה לא תמיד, יש פונקציות שאין להן קלט או פלט. דוגמא מתוך מבחן: נתונה הפונקציה func.m מה יהיה הפלט של קטע הקוד הבא? function x=func(y) x=y^2 x=9 y=func(x) disp(y) תשובה:. 81 הפונקציה עצמה, שמה לתוך x שהוא הפלט, את התוצאה של הקלט y בריבוע. לתוך הפונקציה הכנסנו פלט השווה ל- 9 )כי הוא בסוגריים שאחרי שם הפונקציה(, ואת התוצאה של הפונקציה אנחנו אמורים לשים בתוך משתנה חדש y ולהציג אותו. הוא יהיה שווה ל- 9 בריבוע. פונקציות יכולות לקרוא לפונקציות סיווג אנחנו נעסוק בסיווג על פי הסתברות. נניח אם אנחנו צריכים להחליט אם לאשפז אנשים על סמך כמה מדדים בסיסיים. הרעיון הוא לאסוף נתונים מאוכלוסייה גדולה, ולעשות היסטוגרמת שכיחות של המקרים בהם התקבלה כל תוצאה. מתוך אותה התפלגות למצוא סף שמעליו תתקבל החלטה לכאן או לכאן. אחר כך את כל מקרי הבחן שלנו נבחן אל מול הסף הזה. נסתכל על המקרה עם כל מיני מודיפקציות: אם יש 100,000 מקרים שעל פיהם נבנה הגרף. במקרה זה הגרף הויזואלי יהיה כל כך צפוף שלא נצליח ויזואלית לעשות את ההפרדה. אבל בטוח שזה מעלה את הבטחון -17-

18 בהחלטה. המחשב יפתור את הבעייה )הוא יתרכז כל פעם באזור אחר בגרף, וישווה את כמות הנקודות האדומות )לא אשפוז( לכמות הנקודות הכחולות )כן אשפוז( בכל אזור של הגרף. אם מחליטים על פי 6 גורמים שונים, ההחלטה תהיה יותר מורכבת. היא גם יותר מושכלת. מבחינת קבלת החלטה זה קשה יותר. צריך כלים מתמטים שונים לקבל החלטה. אחד הדברים שנעשה הוא לשרטט כל פעם היטל של שני מדדים שונים )פעם דופק מול חום, פעם דופק מול רמת חמצן בדם..(. אם נשנה את מחיר האשפוז- נבחן זאת כשהוא עולה 2 לעומת כאשר הוא עולה חצי מיליון. במקרה זה הסף החלטה ישתנה- כשהאשפוז הוא זול, נעדיף לעשות יותר טעויות מסוג "אשפזתי שכשלא היה צריך". כאשר ההחלטה צריכה להתקבל באופן מהיר ביותר, אנחנו צריכים שהצורה של גבול ההחלטה תהיה ברורה. לא נוכל לקחת גבול החלטה בצורה אלכסונית )קו שמפריד בין המקרים של אשפוז ולא אשפוז שיהיה אלכסוני. ככה קשה להחליט(, אבל כן נוכל לקחת גבול בצורת מלבן. איך עושים זאת במחשב? חשוב לתת שמות נוחים למשתנים. בדר"כ עדיף שמות קצרים. למשל נסמן דופק ב- x1 וחום ב- x2 עדיף לכתוב אות בודדת ולא מילה בתור משתנה )כדי לא להתבלבל עם כפל(. אבל יש מקרים שבהם חשוב לנו לשמור את על שמות משתנים ברורים כדי שבהמשך נבין מה עשינו סימונים מוסכמים: קלטים או כניסות:.,x2,x1 פלטים או יציאות:,0=y(. )1=y y היציאה החזויה: y. המטרה שלנו היא למצוא פונקציה (x2 y = f(x1, כך ש- y y. ה- y יהיה מוגדר עבור כל המישור. הוא לא יהיה מוגדר רק עבור נקודות שבהם היה y. כלומר, נוכל לקבל ניבוי של החלטה )אשפוז/לא אשפוז( עבור נקודות )x2,x1( שלא היו לנו בנתונים המקוריים עליהם בנינו את גרף ההחלטה. -18-

19 אם יש לנו קו החלטה המיוצג על ידי קו ישר, הוא ישפיע רק על y ולא על y. כדי לייצג אותו במחשב נשתמש במשוואת הישר:.x2=ax1+b אבל יש בעייה במשוואת קו ישר- יתכן ש- x2 יהיה תלוי ב- x1 ולא להפך. יתכן שנצטרך קו החלטה שהוא קו אנכי. לכן נעשה את הרישום בצורה של פולינום: a 0 + a 1 x 1 + a 2 x 2 = 0 a ממשוואת קו ישר b ממשוואת קו ישר בכיתוב הזה, אם נרצה שכל מה שמימין לקו יסווג כ- 1 )אשפוז( וכל מה שמשמאל לקו יסווג כ- 0 )לא אשפוז(, אפשר להגדיר את הפונקציה הבאה: 0 a 0 + a 1 x 1 + a 2 x 2 < 0 ŷ= 1 a 0 + a 1 x 1 + a 2 x 2 0 בעצם לפנינו 2 בעיות בשאלות הסיווג: למצוא את הקו בהינתן הקו, לסווג נקודה חדשה..1.2 מציאת הקו: כדי למצוא את הקו צריך למצוא את.a 0, a 1, a 2 אבל אם נעבור על כל הקומבינציות של a 0, a 1, a 2 אנחנו נעבור על כמה ישרים יותר מפעם אחת )ישרים שהם אותו דבר אבל מוכפלים, למשל 8=4+2x ;4=2+x(. אם נעבוד בשיטה של קו ישר רגיל x, 2 =ax 1 b+ נצטרך למצוא רק שני משתנים: את a ו- b. אבל גם פה יהיה חסר לנו אינפורמציה והיא הסיווג- פרמטר שיגדיר שמי שמתחת לקו הוא 0 ומי שמעליו הוא 1, או להיפך. הפתרון הוא באמצע. לעשות נרמול על ידי קביעה כי הערך המוחלט של a 0 הוא

20 הבהרה- למה אם נעבור על כל הקומביציות של המקדמים נבדוק איפורמציה כפולה: ההחלטות: 3+7*x 1-2*x 2 >0 6+14*x 1-4*x 2 >0 הן אותו הדבר. הנרמול של הערך המוחלט של a 0 ל- 1 מונע מאיתנו לעבור על אותה החלטה יותר מפעם אחת. אבל יש לה מחיר ובו אנחנו מפספסים בדיקות של ישרים בהם 0= 0 a. כדי להתמודד עם זה אפשר להזיז את הקו במספר קטן מאוד מהמקום בו הוא היה צריך לעבור אם =0 0.a למשל, אם הקו עובר דרך ראשית הצירים =0( 0,)a אז המשוואה הייתה =0 2.x 1 - x אם היינו עושים קו: 0= 2 + x 1 - x 1/100, הוא היה מוסט מעט מאוד למעלה, אז ההחלטה עדיין הייתה מספיק טובה. זה אפילו היה יותר טוב אם היינו בוחרים מספר יותר קטן מ- 1/100. אבל מאחר ו a 0 חייב להיות 1, נכפיל את כל המשוואה ב- 100 ואז קו הההחלטה יהיה: x 1 100x 2 =0 עכשיו נדון בבעייה איך בוחרים את הקו הטוב ביותר מבין כל האופציות שעברנו עליהם. זו בעייה בתכנות. בבעייה שלנו יהיו שלושה מערכים:,x1.,x2 y כמו כן, נניח כי אנחנו כבר יודעים את a0 ו- a2. כעת אנחנו מעוניינים לעבור על כל הערכים של a1. for a1= -20:0.1:20 calcerror ( x1, x2, y, a0, a1, a2) *הפקודה calcerror קוראת לפונקציה התשווה בין ה- ŷ שיחושב לבין ה- y שהכנסנו )את ה- ŷ היא תחשב מתוך ה- x1 ו- x2 שהכנסנו, ומתוך הנתונים על,a0(.,a1 a2 if calcerror<besterror besterror = calcerror; besta1=a1; -20-

21 *החלק הזה שואל האם השגיאה שזה עתה חושבה, היא קטנה יותר מאשר השגיאה הקטנה ביותר שהייתה עד כה. אם כן, אז היא תשמור אותה כעת בתור השגיאה הטובה ביותר, ותשים את ה- a1 הנוכחי בתור ה- a1 הטוב ביותר. צריך גם להגדיר לפני הלולאה את besterror להיות איזשהיא שגיאה מסוימת )אנחנו נגדיר אותה(. מה קורה אם? כל הנקודות נמצאות בין הערכים ל בציר x1, ובין ל בציר x2? במקרה הזה כל הנקודות הן מאוד מאוד צפופות. השינויים שיקרו ב- a1 בעת ההרצה של הלולאה יזיזו כל פעם את הקו, אבל השינויים שיקרו בקו יהיו גסים מדי כדי לתפוס בדיוק את הנקודה שאנחנו צריכים כדי לעשות הפרדה טובה. לכן, בבדיקה של a1 יש חשיבות גם לטווח שנחליט עליו, וגם על הקפיצות שבהם נבדוק אותו )רזולצית הבדיקה(. אנחנו נחליט על אלו בהתאם לבעייה שעומדת מולנו..1 כל התשובות מהפונקציה calcerror הן מספרים הגדולים מ- 100,000. זה יכול לקרות אם למשל calcerror סופר את כמות הטעויות. במקרה הזה חשוב לשים לב כי ההגדרה ההתחלתית של השגיאה המינימלית היא מספיק גדולה..2 יש שני ערכי a1 שונים בעלי ערך calcerror זהה. התוכנה שאנחנו כתבנו תשמור את הערך הראשון. אבל מבחינת ההחלטה, אולי כדאי לנו בשלב הזה להגדיל את הרזולציה, ואז לבחור את הטוב מביניהם..3 צריך לבדוק גם ערכי,a0. a1 צריך במקרה הזה להוסיף לולאה מקוננת שעוברת על a2 מחוץ ללולאה של a1. נצטרך גם להוסיף למקרה התנאי )שבודק את טיב השגיאה( את הפקודה לשמור גם את a2, במידה והתנאי התקיים )כלומר יצא שהשגיאה הנוכחית קטנה מהשגיאה המינימלית הקיימת עד כה(..4 ההחלטה הייתה מתקבלת על סמך 6 גורמים שונים. היינו מוסיפים לולאות בדומה למה שיש בסעיף הקודם, לפי כמות הגורמים סיווג- המשך נמשיך לעסוק בסיווג, אבל נרחיב היום את הסיווג למסווגים אשר נותנים מספרים ממשיים ולא רק מספרים לוגיים. -21-

22 ראינו פעם קודמת כי a 0 מנורמל בסיווג להיות 1 או מינוס 1, על מנת שלא נבדוק את אותם המסווגים יותר מפעם אחת. אבל אם היינו מנרמלים את a 2 דווקא, אז היינו מקבלים מסווגים שיש לנו יותר אינטואיציה לגביהם. הם יהיו מהסוג: x 2 > -a 0 a 1 x 1 x 2 < a 0 +a 1 x 1 יש בעיות של סיווג בהם המסווג אינו מסוג של קו ישר. למשל בדוגמאות הבאות: נסתכל על הדוגמא האמצעית, העקום המסווג מזכיר פרבולה. המשוואה הרגילה היא x 2 =a 1 x a 2 x 1 +a 0 אם היינו רוצים לנסח את כלל ההחלטה לפי הצורה המוכרת לנו מהמסווג של קו ישר, זה היה נראה כך: a 0 +a 1 x 1 + a 2 x 2 +a 3 x 1 2 </> 0 עבור מסווג כזה צריך יותר משלושה פרמטרים. אם זה פרבולה זה ארבעה מסווגים. מסווג עם כניסה אחת: במקרה בו יש רק כניסה אחת )הכוונה היא שיש משתנה אחד שמסווג )x1( ולא נקודות )x2,x1(. פה צריך 2 פרמטרים:,a0. a1 המסווג הוא: a 0 +a 1 x 1 >0 את אחד המקדמים אנחנו צריכים לקבע על 1 או מינוס אחד )עדיף את a1 כי זה יותר אינטואבטיבי:.)x 1 > a 0-22-

23 יתכן גם מצב בו יש כניסה אחת עם שני מסווגים, למשל: פה נצטרך שני קווים על מנת לסווג. נעבור למודלים. אלו הם מודלים לניבוי, שהם לא רק מסווגים )כן/לא( אלא נותנים איזה חיזוי למשתנה שמעניין אותנו. נניח אם עוסקים בבעייה של חולים שמאושפזים, אז הניבוי האם לאשפז הוא לא הוא בינארי וזה סיווג לוגי, אבל אם נוסיף ניסיון לנבא כמה זמן החולה יאושפז, על סמך ההיסטוריה הרפואית שלו, אז הניבוי הוא כבר מספר וזה מודל. הדוגמא הפשוטה ביותר היא חיזוי משקל בהינתן הגובה. נשים לב כי פה יש כניסה )גובה( ויציאה )משקל( ולא שתי כניסות כפי שראינו קודם. החיזוי הוא מהסוג: y = a 1 x 1 אין משמעות לאיזו נקודה היא מעל הקו או מתחת לקו, החיזוי הוא הנקודות על הקו עצמו. הנקודות הן ה"נתונים ההיסטורים". -23-

24 כדי לסמן כל נקודה, צריך אינדקסים. נניח כי הכניסה היא x1 )זה המשקל( והיציאה היא y )הגובה(. כדי שנוכל להבדיל בין נקודה לנקודה )אדם אחד לאחר( נוסיף אינדקסים לכל משתנה: (x 11, y 1 ), (x 12, y 2 ), (x 13, y 3 ) האינדקס הראשון של ה- x מדבר על הכניסה- אז זו הכניסה הראשונה או השנייה. בדוגמא הנ"ל יש רק כניסה אחת אז זה מיותר, אבל יכולה להיות יותר מכניסה אחת. האינדקס השני מתייחס אל האדם- האדם הראשון, השני, עד ה- n. ב- y, האינדקס הוא גם לאדם. וכך גם נשים אינדקס על ה- y. חישוב השגיאה: אנחנו רוצים ש- y יהיה כמה שיותר דומה ל- y. מאחר ומדובר במספרים )גם ב- y וגם ב- y כובע(, הגיוני לשאול על מרחק בין הנקודות כדי להעריך שגיאה. לכן ניתן להגדיר:.err = y y העניין הוא שאם נסכום אם כל השגיאות, הן יאפסו אחת את השנייה, כי לעיתים הניבוי יהיה נמוך מהערך האמיתי, ולעיתים הוא יהיה גבוה מהערך האמיתי. לכן מחשבים את השגיאה הריבועית: ) 2 i.err = (y i y את כל השגיאות האלו נסכום ונמצע )כלומר נחלק ב- n (, ואז נקבל את הסטייה הריבועית הממוצעת. אם היינו רוצים לעשות את זה במטלב, היינו צריכים לבחור את אופציה E: -24-

25 על הגרף ניתן לראות את הנקודות האמיתיות )כחול(, הניבוי )אדום( ואת השגיאה )הקו ביניהם(: דוגמא: נתונות שלוש נקודות: 4) (4, 2), (3, 3),.(2, הכי הגיוני ליצור להם קו ניבוי,y=x כלומר 1=a1. במקרה זה, השגיאה עבור הנקודה הראשונה תהיה 1 )הערך האמיתי הוא 3, הניבוי הוא 2. ההפרש בריבוע הוא 1(. השגיאה עבור הנקודה השנייה היא גם 1, ועבור הנקודה השלישית היא אפס. אם היינו עושים קו ניבוי אחר בו 2=a1, השגיאה הייתה 1 עבור הנקודה הראשונה )ערך אמיתי 3, ניבוי 4(, 16 עבור הנקודה השנייה )ניבוי הוא 6, ערך אמיתי הוא 2, הפרש ריבועי הוא 16( וגם 16 עבור הנקודה השלישית. ניתן אם כך להסיק כי קו הניבוי הראשון הוא טוב הרבה יותר מהשני. אנחנו יכולים לשרטט את השגיאה המחושבת, עבור ערכים שונים של a1: אנחנו נקבל עקומה כזו: ניתן לראות כי הפרמטר שיתן את השגיאה הנמוכה ביותר הוא ערך הקטן בקצת מ

26 עבור הגרף הזה, ניתן להגיד כי השגיאה היא פונקציה של a1. עוד ניתן להגיד כי השגיאה הקטנה ביותר היא בנקודת המינימום של הגרף. לכן, אם ניקח את הפונקציה, נגזור אותה ונשווה לאפס, נוכל למצוא את הפרמטר הטוב ביותר. מתמטית זה יראה כך: dtoterr da1 y = a 1 x 1 err = (y y) 2 = (a 1 x 1 y) 2 derr da1 = 2(a 1x 1 y)x 1 = 2(a 1 x 11 y)x (a 1 x 1n y)x n ובמטלב: אופן חישוב זה של a1 יתן את a1 האופטימלי, ויחסוך לנו את הצורך בלולאה שרצה על כך מיני ערכי a1. היא ישר תבוא ותחשב, על סמך הנגזרת של השגיאה, את ה- a1 הכי טוב. ניקח דוגמא עם אותן נקודות שראינו קודם: (4,4),(2,3),(3,2). Err = (a1*2-3)^2 +(a1*3-2)^2 +(a1*4-4)^2 derr/da1= 2(a1*2-3)*2 +2 (a1*3-2)*3 + 2(a1*4-4)*4 a1[2*2+3*3 + 4*4]= [3*2 + 2*3 + 4*4] a1= (3*2 + 2*3 + 4*4)/(2*2 + 3*3 + 4*4) =11/13 אפשר לראות שקיבלנו ערך הקרוב מאוד ל

27 דיברנו שיעור שעבר על מציאה של קו ניבוי אופטימלי, על ידי שימוש בנקודת המינימום של פונקצית השגיאה. היום נראה איך מרחיבים את זה למקרה יותר כללי, ונתחיל בדוגמא פשוטה בה הקו אינו עובר דרך הראשית. השגיאה במקרה הזה תלויה ב- a0 וב- a1. ישנו הפתרון של הסיווג באמצעות לולאות כפולות. זה פתרון שיעבוד אבל יהיה ארוך ולא יעיל. השאיפה היא למצוא פתרון מהסגנון של הנוסחא ל- a1 האופטימלי )עם השוואת הנגזרת לאפס(. נזכר בנוסחא של השגיאה הבודדת: err = (y y) 2 err = (a 0 + a 1 x 1 y) 2 ניתן לעשות כרגע נגזרת חלקית, פעם אחת לפי a0 ופעם אחת לפי a1. ואת שתי הנגזרות האלו להשוות לאפס. כך נקבל את שני הפרמטרים- a0 ו- a1 שיובילו את השגיאה למינימום: מטריצות נדון בשתי משוואת עם שני נעלמים. יש לנו מטרה למצוא דרך לפתור אותן במטלב, כאשר צריך משהו שהוא שיטתי )כלומר לא ניתן רק לחבר משוואת/לחסר משוואת וכן הלאה, כי צריך קוד שמתאים לכל מקרה ובו לא צריך ל"חשוב"(. שלב מקדים יהיה למצוא דרך לכתוב את הדברים. אנחנו צריכים דרך כיתוב שתאפשר לנו לדבר על יותר ממשוואה אחת, ועל יותר מפרמטר אחד בכל משוואה. הפתרון הוא לשים אינדקסים על כל הפרמטרים. האינדקס הראשון )שמאלי( מציין את השורה, והאינדקס השני מציין איזה פרמטר הוא בשורה. -27-

28 דרך מקוצרת לכתוב את כל זה הוא בתוך מטריצות: האיבר השמאלי הוא מטריצה. בתוכו, השורות הן המשוואות עצמן. הטורים הם הפרמטר בתוך כל משוואה. האיבר האמצעי והאחרון הם וקטורים )שזה בעצם מטריצה חד מימדית(. למעשה מטריצה היא מערך דו מימדי של מספרים. מציינים את גודל המטריצה על ידי מספר השורות והעמודות בה. כדי לכתוב מטריצות במטלב צריך להשתמש בהשמה, כמו בוקטור, רק שאם נשים ; זה ירד שורה: [5 ; 4 3 2]=A. זה יתן לנו מטריצה של 2x2 שנראת כך: במטריצה, מספר האיברים בכל טור ובכל שורה חייב להיות תואם. כלומר עליה להיות סימטרית. אם נבקש לדעת את המימדים של המטריצה, נוכל לרשום,size(A) והוא יתן לנו תשובה עם שני מימדים- האיבר הראשון יציין את השורות, השני את הטורים. מטריצות מוכרות במטלב הם ones ו- zeros : כאשר אנחנו כותבים את הסוגריים, אנחנו מציינים כמה שורה וטורים נרצה. -28-

29 כדי לבקש איבר ספציפי בתוך מטריצה, זה נעשה באופן דומה למה שהיה במערכים: ככה שולפים את האיבר השלישי בשורה השנייה: ניתן גם לעשות השמה לתוך איבר ספציפי בתוך המערך. למשל להגיד: 8=(1,1)B, ואז האיבר הראשון בשורה הראשונה יתחלף ב- 8. פעולות מתמטיות עם מטריצות ווקטורים: ניתן לכפול מטריצה בוקטור, כמו שרצינו בבעייה המקורית לעשות. כדי לעשות את זה, חייב שמספר השורות של הוקטור יהיה שווה למספר העמודות של המטריצה. הכפל נעשה על ידי סיבוב של הוקטור, הכפלה וסכימה: מכאן גם ברור למה מספר השורות של הוקטור חייב להיות תואם למספר הטורים של המטריצה. יש דרך מתמטית לכתוב את זה: אם נגדיר כי,Ax=Z אז: שזה אומר כי האיבר ה- i בתוך המכפלות aij ב- xj. Z, הוא סכימה של כל -29-

30 כפל מטריצה במטריצה: כדי להכפיל מטריצה במטריצה, צריך לעשות פשוט פעמיים הכפלה של מטריצה בוקטור. התוצאה היא מטריצה. "מחלקים" את מטריצה הימנית ל- 2 וקטורים של טור, ואז מכפילים כל וקטור במטריצה. דוגמא: כדי לעשות כפל מטריצות, צריכה להיות התאמה בין מספר הטורים במטריצה השמאלית למספר השורות במטריצה הימנית. למשל, בדוגמא הבאה, רק,B C הן אופציות "חוקיות: נשים לב למימדים בכל סעיף: a. 2x1 2x2 b. 1x2 2x1 c. 2x3 3x2 d. 3x2 2x2 e. 1x2 1x2 אנחנו תמיד נחפש שתהיה התאמה בין שני האיברים הפנימיים. -30-

31 באופן כללי, בכפל מטריצות.AB BA )לפחות לא בהכרח(. הנוסח הכללי של הכפלת מטריצות )שמראה מה יהיו המימדים( הוא: מתי כן יתקיים?AB=BA כאשר מכפילים את מטריצה כלשהי במטריצת היחידה. מטריצת היחידה היא מטריצה ריבועית, שבאלכסון שלה יש 1, וכל שאר האיברים הם אפס. דוגמאות: מטריצות היחידה מקיימות את התכונה עבור כל מטריצה :A mxn I m A=AI n =A ניתן גם לעשות חיבור וחיסור של מטריצות. זה יעשה איבר איבר. נחזור לפתירה של שתי משוואת עם שני נעלמים, ונחפש את הפתרון הכללי: עבור מערכת המשוואות: -31-

32 ניתן למצוא פתרון כללי לפיו: בסימון של כפל מטריצות נוכל לכתוב: x = y = 1 (dz bw) ad bc 1 ( cz + aw) ad bc אם נסכם, כדי לפתור שתי משוואות עם שתי נעלמים, נוכל לעשות כל מטריצה בוקטור, והפתרון הוא כזה: מושג נוסף שצריך להכיר הוא מטריצה הופכית: אם נכפיל את המטריצה A במטריצה ההופכית שלה נקבל את מטריצת היחידה: A*A -1 =A -1 *A=I n -32-

33 מטריצה הופכית מוגדרת רק למטריצה ריבועית: A. nxn היא קיימת רק אם הדטרמיננטה )ad-bc( שונה מ- 0. באופן כללי, ניתן להוכיח כי משוואה מסוג Ax=y )כאשר A הוא כל מטריצה שהיא, ו- x ו- y הם וקטורים כלשהם, כמובן שהמימדים כן תואמים(, אז ניתן למצוא פתרון ל- x :,x=a 1- y ובתנאי שהדטרמיננטה של A שונה מאפס. כאשר הדטרמיננטה היא אפס, אין פתרון למערכת המשוואות. ניתן לראות זאת בדוגמא הזו: 4x-2y=2 4x-2y=13 אם נחשב דטרמיננטה היא תהיה אפס, וזה ברור כי למערכת משוואות כזו לא יהיה פתרון. במטלב, כדי למצוא פתרון למערכת משוואות של שתי משוואות עם שני נעלמים, נגיד כי [x,y]=inv(a)*[2;13] )2,13( הם ה- Z במערכת המשוואות. נחזור חזרה לבעייה המקורית- למצוא פתרון אופטימלי ל- a0 ו- a1 עבור נתונים היסטורים,x. y אמרנו כי: a 1 = x 11y 1 + x 12 y 2 + x 13 y 3 + x 11 x 11 + x 12 x 12 + x 13 x 13 + אפשר לכתוב את זה בצורה של מטריצות, אבל בשביל זה צריך לעשות טרנספוז לוקטור x )כדי שנוכל להתאים מימדים )טרנספוז יהפוך וקטור שורה לוקטור עמודה(: a 1 = y xt x x T = (xxt ) 1 (yx T ) נשים לב כי המימדים של y הם n*1 )זה שורה( הנ"ל נקבל סקלאר )1*1(. כנ"ל במכנה. והמימדים של x T הם 1*n, ולכן בכפל המטריצות -33-

34 )הושלם מנועה( צריך לדעת: כפל מטריצות שימוש המטריצות הופכיות חישוב דטרמיננטות ע"פ נוסח שתינתן לנו. Err = (Y AX) 2 אם החיתוך הוא לא עם הראשית? אנחנו יודעים לפתור את זה y = a1x1 + a2x2 אבל מעוניינים בזה : a1x1 y = a0 + נתייחס לזה כך: = 1 a0 a2x2 = -34-

35 אני יכול גם לקחת פולינום במעלה 3, וכו' וכו'... אם אגיע לפולינום ממעלה 21 תהיה לי אפס שגיאה כלומר אקבל שגיאה מינימלית. בפולינום מדרגה 10, למשל, ייתן שגיאה גבוהה מאוד. פתאום התוצאה תהיה מוזרה ולא תואמת את ציפיתנו. כדי ליצור מודל טוב: צריך לאזן שגיאה נמוכה עם יכולת הכללה. המודל צריך לתת פרדיקציה לנתונים שלא ראינו. במצב שהוא אינו טוב, הוא מותאם מידי לנתונים ההיסטוריים, הוא "טוב מידי". אנחנו לא רוצים מודל שיתאים בדיוק אחד לאחד )אחרת היינו לוקחים טבלה(. במצב כזה מודל לא יודע להתמודד עם נקודות שאינו מופיעות כנתונים היסטוריים. אנחנו רוצים מודל שיודע לחשוב ולצפות, שיודע לתת מענה גם לנתונים שלא נתקל בהם בעבר. איך מאזנים שגיאה נמוכה עם יכולת הכללה? אנחנו רוצים לדעת כמה טוב הוא מסווג את הנתונים העתידיים. validation" "cross \ תוקף צולב: ניקח רק חלק מהנתונים ההיסטוריים set( )train שלנו ונמצא עבורם שגיאות. נמצא את השגיאה המינימלית עבור אותם נתונים היסטוריים חלקיים, ונבחר את הפרמטר הכי טוב- ועל בסיסו ניצור מודל. -35-

36 לקחנו את אותו מודל ובדקנו את השגיאה שלו עבור הנתונים האחרים. ואז השגיאה הראשונה הייתה שגיאת האימון והשנייה הייתה שגיאת הבוחן. לוקחים את יתר הנתונים set( )test ומריצים אותם על המודל הנסיוני שלנו, רואים מהי השגיאה המינימלית ומשווים אותה לשגיאה המינימלית שהתקבלה בסט האימון. כך נוכל לקחת מודלים שונים ולבדוק מה ההפרש ביו שגיאת האימון לשגיאת הבוחן- בכל אחד מהם, ולהכריע איזה מהם הוא המודל הטוב ביותר ( באיזה מודל שגיאת האימון ושגיאת הבוחן תואמות, ומינימליות(. שגיאת הבוחן מאפשרת לנו לראות כמה למודל יש פרדיקציה טובה )כמה הוא יצליח לצפות את הסיווג כמו שצריך(, שכן היא בודקת את יכולת "ההסקה" של המודל, על בסיס נתונים היסטוריים- על נתונים היסטוריים. תמיד תמיד תמיד, שגיאת האימון תהיה יותר טובה במודל האימון של פרבולה מאשר במודל אימון של קו לינארי )לעומת שגיאות הבוחן- שם זה סיפור אחר(. שגיאת האימון של הפרבולה מכילה בתוכה את שגיאות האימון של הישר ( כי מודל האימון של פרבולות מכילה את מודלי האימון של הקווים הישרים(. 1. מפצלים את הנתונים: לאימון ולבוחן 2. עבור כל מודל: - בעזרת נתוני האימון נבחר את הפרמטרים המיטביים )שגיאת אימון מינימלית( - נבדוק את השגיאה על נתוני הבוחן )שגיאת הבוחן( 3.נשווה את שגיאת הבוחן בין המודלים- ונבחר את המודל האופטימלי. נסתכל על שגיאת הבוחן כי מעניינת אותנו הכללה. *זה יכול לא יעבוד אם יש לי מעט נתונים או הרבה פרמטרים. סוגים של מודלים: מה נעשה בבעיה של התאמת עקום, כשלאו דווקא יש לנו מודל מוכר לפתרון )פולינום וכו'(? יש מודלים אחרים עם יציאה של מספר ממשי, למשל: a0 + a1x x > a2 y = { a3 + a4x x a2-36-

37 ECG במצב זה, כדי להשוות סוגים של מודלים, נפעל בשיטת "תוקף צולב" עבור כל מודל. סיכום הפעולה: בעזרת נתוני האימון- מתאימים את המודל הכי טוב לאימון מציבים בו את נתוני הבוחן מוצאים את שגיאת הבוחן משווים בין שגיאות הבוחן של כל המודלים שנבדקו ומוצאים את השגיאה המינימלית את המודל הטוב ביותר. עיבוד אותות בזמן אותות ביולוגים מורכבים מסיגנל ומרעש. נתבונן בדוגמא של ECG פה, האות הוא כ- 0.04v )מבחינת אמפליטודה(, ואילו הרעש הוא מורכב. בתדירות גבוהה, הוא 0.01v אבל בתדירות נמוכה הוא 0.04v )צריך להסתכל משנייה 12 ועד שנייה 14, הגל הזה הוא גם סוג של רעש( time in seconds כאשר עושים עיבוד אותות בזמן, חשוב לבחור את קצב הדגימה המתאים לסיגנל. קצב הדגימה פה בדוגמא הוא 1000 הרץ )1000 דגימות לשנייה(. אבל כאשר אנחנו עושים קצב דגימה גדול מאוד, אז יש לנו המון דאטה. זה מבזבז מקום בזכרון וזמן עיבוד. כמו כן אנחנו מסתכנים ב- fitting.over אבל מה אם היינו בוחרים קצב דגימה נמוך מדי? למשל 1 הרץ? במקרה זה נאבד את הסיגנל כי יש יותר מפעימה בשנייה. -37-

38 downsampled signal downsampled signal אז השאלה היא מהו קצב הדגימה האיטי ביותר כדי לזהות את קצב הלב? Hz Hz time in seconds time in seconds אפשר לראות פה דוגמא של דגימה ב- 2 הרץ וב- 3 הרץ. ניתן לראות כי ב- 2 הרץ אנחנו מפספסים את הסיגנל, ואילו ב- 3 הרץ לא- זאת כי רואים גם את העליות וגם את הירידות. מתברר כי קצב הדגימה האיטי ביותר כדי לזהות את קצב הלב הוא פי 2 מקצב הלב )כך נוכל לראות את העליות וגם את הירידות(. לאותה תדירות דגימה האיטית ביותר קוראים "תדירות."Nyquist איך נמדוד את קצב הלב מתוך ה- ECG? 1. שיטה ראשונה- מדידה באמצעות סף. שמים את הסף בגובה מסוים מעל הרעש, וסופרים את מספר הפעמים שהסיגנל חצה את הסף. זה מעיד על קצב הלב. נשים לב שיש חשיבות לגובה בו ממקמים את הסף. אילו הוא היה גבוה יותר, כמו הקו באדום, או נמוך מדי, כמו הקו הירוק, נראה כי קצב הלב הנמדד )כמעברים על הסף( היה לא נכון. -38-

39 חישוב הסף במתלב: שלב ראשון הוא שרטוט של הסיגנל: plot (time, ECG, 'b') בהנחה כי יש בו דגימות מ- 10 שניות של מדידה, בקצב של 1000 הרץ, אז יהיה לנו וקטורים )זמן וסיגנל( בגודל של בדוגמא שלנו, ניצור קודם את הסף ב )לפי החלטה שלנו( ואז נצייר אותו. threshold=0.03; line ([min(time) max(time)], threshold] הפקודה Line אומרת לשרטט את המשתנה,threshold ולקבוע כי הוא יתחיל בערך המינימלי של זה יבטיח כי הקו היה נע לאורך כל ציר ה- X (. )ככה time ויסתיים בערך המקסימלי של time כעת נקבע מתי אנחנו עוברים את הסף ומתי לא: ecg_thresh = ECG > threshold זה יתן לנו וקטור לוגי, אשר בכל מקום בו הערכים של ECG עברו את הסף יש לנו 1 ובכל מקום שהערכים של ECG מתחת לסף יש לנו אפס. אבל בתוך הוקטור הזה יש לנו רצפים של 1 ו- 0. כי קצב המדידה הוא גבוה, ולכן כאשר יהיה פעימת לב, אז יהיו לנו כמה 1 רצופים. אז המטרה שלנו היא לברור את אותם המקומות בוקטור ecg_thresh בהם יש שינוי מ- 0 ל- 1 : הפקודה היא: נתבונן בפקודה הזו. אורכו של הוקטור ecg_tresh(2:) הוא אורכו של הוקטור ecg_tresh(1:-1) הוא גם איך נראים הוקטורים האלו? התחתון הוא הסטה של הוקטור המקורי בערך אחד שמאלה. ups = (ecg_tresh(2:) > ecg_thresh(1:-1)); ecg_tresh: ecg_tresh(1:-1): ecg_thresh(2:):

40 לכן, באמצעות הוקטור ups אנחנו בודקים מתי הוקטור ecg_tresh(2:) גדול מהוקטור.ecg_thresh(1:-1) זה קורה בדיוק במקומות שיש בהם שינוי בסיגנל. איך מחשבים מתוך זה את קצב הלב? sum (ups) / max (time)-min (time) המטרה הבאה היא לנקות את הרעש. צריך להיפטר מהשינויים המהירים. הדרך היא לעשות ממוצע רץ. לוקחים כל מקבץ של נקודות, למשל של 10 או 100 או 1000, וממצעים אותם. ואז מכל נקודה בדאטה המקורי מחסירים את הממוצע הרץ. מבחינה גרפית זה יראה כך: איך זה במתלב? קודם כל מחליטים את הרזולוציה של ה"החלקה". פה זה 101 נקודות. L הוא ה"כנפיים" של הדאטה שצריך ללכת לכל כיוון. אפשר לראות כי הוא יוצא 50. זה כי עבור כל נקודה בדאטה נרצה "ללכת" 50 נקודות דאטה ימינה ושמאלה על מנת לערוך את הממוצע. -40-

41 בתוך הלולאה, אנחנו עוברים על כל נקודה בדאטה של,ECG ומייצרים ממוצע רץ עבורה מ- 101 נקודות. הפקודות min ו- max שיש באמצע מבטיחות כי לא נחרוג מתחת לערך המינימלי של הדאטה או המקסימלי של הדאטה. כלומר שלא נלך מעבר לדגימה 1 או בעצם בוחרים את הערך המקסימלי בין i-l ו- 1. אם ה- i-l יצא שלילי, אז הספירה של הערכים לממוצע תתחיל מ-...1 באופן דומה בוחרים את הערך הימני ביותר לממוצע. בסוף מחסירים מכל נקודה בדאטה את הממוצע הרץ אנחנו ממשיכים לעסוק בסיווג היום. ראינו כמה סוגים של מודלים סטטיסטים, ביניהם בעיות סיווג והתאמת עקום. גם ראינו שיטות למציאת מסווג )על ידי סריקת פרמטרים( ושיטות להתאמת עקום )על ידי נוסחא אנליטית(. דיברנו גם על בחירת מודל אופטימלי על ידי שגיאת אימון ובוחן. היום נחזור לסיווג ונעסוק בקירוב לסיווג על ידי רגרסיה ליניארית. כך נוכל לוותר על סריקת פרמטרים. -41-

42 ניקח דוגמא- רוצים שיטה שתוכל לסייע האם להחליט אם לנתק אדם ממכונת הנשמה )לעשות אקסטובציה(, על סמך נתונים מטיפול נמרץ. לפי הדוגמא של הנתונים מהטבלה אפשר לראות כי אין מדד )דופק, נפח הנשמה וסטורציה( שהוא אופטימלי על מנת להחליט באופן בינארי אם כדאי לעשות הנשמה: המדדים השונים נמדדו באופן רציף. לצורך הדוגמא נתייחס למספר מאפיינים של כל מדד: דופק מקסימלי, דופק ממוצע, חציון של הסטורציה... בסך הכל יש 50 מאפיינים כאלו, ונתונים על 70 מטופלים. למעשה זה אומר כי יש לנו בעיית סיווג ב- 50 מימדים. בעבר היינו פותרים את זה ב- force brute )סריקת פרמטרים(. אבל קשה מאוד לעשות סריקה של פרמטרים ב- 50 מימדים )בשני מימדים עוד יכולנו לבחון את הדאטה בצורה ויזואלית ולנחש מהו הטווח ההגיוני להריץ בו את הסריקה של הפרמטר, אבל ב- 50 פרמטרים זה בלתי אפשרי, וסריקה לא מושכלת מבחינת טווחים תקח נצח(. מה שעושים הוא סיווג בעזרת משוואה, אבל באופן הבא: )זה שונה מהתאמת עקום, שם.)yhat=AX לפי הפתרון הזה צריך להתאים איזשהוא עקום.)AX( כיצד נדע להתאים את אותו עקום? נחשוב על זה בבעייה חד מימדית )כלומר מסווג אחד בלבד(, שאותה ניתן לשרטט בשני אופנים: y X1-42- X1

43 המטרה היא למצוא מסווג כמו המדרגה הזו. אבל אנחנו לא יודעים לעשות זאת, אנחנו כן יודעים באמצעות נוסחא לעשות את הקו האדום )העקום הישר(. עושים זאת על ידי הפרמטר שמביא את השגיאה הריבועית למינימום. ואז על אותו הקו, אפשר להגיד כי כל נקודה שהיא מעל החיתוך עם ציר ה- x )דהיינו אפס( תסווג כ- 1, וכל נקודה שמתחתיה תסווג כ למעשה הסיווג של ±1 היא כדי שיהיה לנו קל להעביר את העקום בנקודת האפס )שהיא האמצע(. אילו היינו משאירים את הסיווג כ- 1/0, היינו צריכים להעביר את הנקודת סיווג ב- 1/2. עכשיו נתבונן בזה בשני מימדים: כיצד יש להכין את הנתונים? אנחנו רוצים את הכניסות שיהיו עבור קו ישר )ולכן יש גם a0(. אפשר לראות פה גם איך הופכים את ה- y להיות ±1. תהליך הרגרסיה עצמו: מציאת המקדמים a0-an היא כמו שהיה בהתאמת עקום: inv(x*x') A. = Y*X' * -43-

44 כאשר X,Y הם כפי שהוגדרו למעלה )±1=y ו- x הוא מטריצה של שורת אחדות, ואז שורת x1 ואז שורת x2(. כך: כך הגדרנו מודל,yhat=AX ואנחנו מעוניינים שעבור הנקודות הכחולות, 1- yhat= ועבור הנקודות האדמות,.yhat=1 לכן AX=0 אמור להגדיר את קו הגבול. בצורה מתמטית זה נראה וזו נוסחא של קו ישר. a 0 + a 1 x 1 + a 2 x 2 = 0 סיכום כל המודלים והבעיות שהיו לנו עד כה: בעית התאמת עקום בצורה אנליטית בחירת מודל על ידי שגיאת אימון ובוחן בעית סיווג על ידי הפתרון האנליטי. יש פה את השינוי של y ל- ±1. בעית סיווג על ידי סריקת פרמטרים פונקצית שגיאה היא שגיאה ריבועית. מתאים לבעייה למעלה פונקצית שגיאה של סיווג -44-

45 מחיר הקירוב: אילצנו את כל המקרים להיות פלוס/מינוס 1. זה אומר כי כל הנקודות יהיו רחוקות באותה מידה מהגבול, וזה עלול לגרום לעיוותים: למשל פה, הקו היה מותאם באופן הבא, כי הוא עובר במרכז של הנקודות. ואז היה נוצר עיוות של הסיווג. יש שתי דרכים לעשות פה את הפתרון, שאנחנו לא נעסוק בהם, ואחת היא לעשות למידה הדרגתית, והשנייה היא להתעלם מהמקרים הקלים )פה זה הנקודות הימניות הקיצוניות(. נחזור לבעייה של האקסטובציה, בה יש 50 כניסות למודל ו- 70 נתונים היסטורים. אנחנו יכולים להשתמש בכל 50 הכניסות כדי ליצור מודל רגרסיה, אבל רוב הסיכויים שנעשה התאמת יתר כי הפרופורציה בין מספר הכניסות למספר הנבדקים הוא נמוך. לכן ננסה לפשט את המודל ולקחת פחות כניסות. נניח כי יש 5 מתוך כל ה- 50 כניסות שנותנות ניבוי טוב, ומטרתנו למצוא מי הם אותם חמישה מסווגים. כדי לעשות זאת נבחר המון אפשרויות. יש כ- 50^5 אפשרויות לבחור 5 מתוך 50. זה יותר מדי אופציות לבחינה, ולכן נבחר 1000 כניסות רנדומליות. עבור חמישיה מסוימת, נפצל את הנתונים לאימון ולבוחן. עבור אותם 35 מטופלים )יש רק 35 כי אלו הם נקודות האימון( ו- 5 כניסות נעשה התאמת עקום באמצעות רגרסיה )נמצא את A(. אבל פה נבדוק את השגיאת אימון על פי שגיאת סיווג ולא שגיאת עקום. איך זה נראה במתלב? תחילה מכינים את הנקודות: -45-

46 בונים את מטריצת הכניסות על ידי 35 המטופלים ו- 5 הכניסות שבחרנו אקראית.)useMe( מוסיפים גם שורת אחדות כי יש גם a0. כך נוצרת מטריצה של 5*35 )5 כניסות על 35 מטופלים(. את ה- Y מגדירים כ- ±1. ואז מוצאים את מטריצה A: וכעת נוצר למצוא את השגיאה. לשם כך צריך להגדיר את yhat )זה הסיווג(. הוא יהיה הסימן של התוצאה של ה- AX : והשגיאה היא כל פעם כאשר yhat שונה מ- y )למעשה כל פעם שתהיה שגיאה יהיה 1 וכל פעם שלא תהיה שגיאה יהיה אפס(. פה הוא הפך את זה למערך של מספרים במקום מערך לוגי )על ידי הפקודה :)double ואז כדי שנוכל לדעת את השגיאה הממוצעת, צריך לסכום את השגיאות ולחלק באורך הוקטור. בכתיב וקטורי זה נעשה כך: )למעשה כאשר מכפילים וקטור בעצמו, כך שאחד שורה והשני עמודה זה יעשה סכימה של כל איבר בריבוע. מאחר והאיברים הם 0 או 1, הריבועים יהיו גם 0 או 1 ולכן הסכימה שנוצרת מהכפלת הוקטורים היא סכימה של השגיאות( כל הדבר הזה נעשה עבור כל חמישייה מתוך ה שנבחרות רנדומלית. ובנוסף מחשבים את שגיאת הבוחן עבור 35 הנבדקים הנותרים. בוחרים את המסווג האופטימלי שמביא את שגיאת הבוחן למינימום. פה רואים את הסיכום של המסווגים )חמישיות שנבדקו(: -46-

47 כל נקודה מייצגת חמישייה, ובציר ה- Y רואים את שגיאת הבוחן שלה. אם שגיאת הבוחן היא חצי, אז המסווג הוא ממש גרוע )זה אומר כי חצי מהמטופלים סווגו לא נכון, שזה שקול לרמת ניחוש(. מתי שהשגיאה היא נמוכה מחצי, אז המסווג הוא טוב ממצב ניחוש. למשל אפשר לראות כי הנקודה שסומנה בעיגול היא קו מסווג שבנוי על הפרמטרים: חציון קצב לב, מינימום קצב לב, מקסימום קצב לב, ממוצע קצב לב, חציון של,vin מינימום של.peep פה רואים דוגמא של סיווג רק על פי שני פרמטרים: הקו המסווג אומר שמתחתיו נעשה אקסטובציה ומעליו לא. העיגולים האדומים החלולים הם אנשים שעדיף לא לעשות להם אקסטובציה והכוכביות הכחולות הם אנשים שאפשר היה לעשות להם אקסטובציה. כך לפי הסיווג הזה, יש 3 אנשים שהיה עדיף לעשות להם אקסטובציה ולא עשינו, ואילו מלא אדומים שהיה עדיף לחכות איתם ולא חיכינו. במקרים רבים, לשתי סוגי השגיאות האלו יש מחיר שונה. ככל הנראה עדיף לנו לטעות יותר על הכחולים- שיותר אנשים שהיו צריכים לעבור אקסטובציה יחכו עוד קצת, כדי שנמנע מהסיבוכים. כלומר להעביר את הקו יותר שמאלה. כדי לעשות זאת משנים את המשקל בסריקת הפרמטרים: פה עשינו חישוב של שתי השגיאות בנפרד- טעות מסוג אחד ומסוג שני. ואז כדי לחשב את הטעות הכוללת אנחנו עושים ממוצע משוקלל משניהם, כאשר לכל טעות יש משקולת אחרת בהתאם למה -47-

48 שאנחנו רוצים )האחת תקבל משקולת אלפא והשנייה 1 פחות אלפא(. הקביעה של האלפא היא לפי שיקולים תיאורטים של הבעייה עיבוד אותות בזמן- המשך: חזרה על מושגים חשובים: יחס אות-רעש- היחס בין מה שנרצה למדוד למה שלא נרצה למדוד. המטרה היא להגדיל כמה שיותר את היחס הזה. דיברנו על כמה סוגים של פילטרים, שעוזרים לנו לנקות חלק מהרעש. למשל ניקוי באמצעות ממוצע רץ ש"מחליק" את הדאטה, הוא מוציא את התדרים הגבוהים. זאת משום שהממוצע הרץ הוא בתדר נמוך, הוא משתנה לאט בזמן, ולכן זה.low pass filter ואז אם מחסירים אותו מהדאטה אפשר להיפטר מתדרים נמוכים, ולכן זה.high pass filter בדוגמא הבאה רואים את השפעתו. ניתן לראות כי קל יותר לשים סף לבחינת האות, לאחר הניקוי עם ממוצע רץ. -48-

49 באופן כללי, פילטרים הם פעולות שאפשר לעשות על הסיגנל, אשר משנות אותו באופן מסוים. אנחנו הכרנו שתי דוגמאות כרגע: :Low-Pass Filter "גילוח" כל חלקי הסיגנל שמשתנים "מהר" בזמן. :High-Pass Filter "גילוח" כל חלקי הסיגנל שמשתנים "לאט" בזמן..1.2 קל לנו יותר לדבר על אותות כאשר הם מחזוריים/גליים. למעשה ניתן להגיד כי כל אות ניתן לפירוק של גלים מחזורים, כי הוא סכימה של המון גלי סינוס בתדרים שונים. חזרה על גל סינוס: הפונקציה הזו מתאפסת באפס, ושוב בחצי וב- 1. כל מחזור שלה הוא אחרי 1=t. אפשר ל"שחק" עם שלוש תכונות של גלי הסינוס: אמפליטודה. זה על ידי הוספת מקדם לפני הפונקציה: משחקים עם ה- A..F(t)=A*sin(2* π (t* פאזה. זה על ידי הוספה של קבוע אל הסינוס. זה מזיז את הפונקציה ימינה ושמאלה..F(t)=sin(2* π *t+ Bpi) תדירות. זה על ידי שינוי המקדם של ה- t. הגדלתו מעלה את התדירות: F(t)=sin(2* π *Ct) דוגמא- מהם הפרמטרים בדוגמא הזו? התשובה היא א'. התדירות פה היא 1 הרץ. האפליטודה היא 1. הפאזה היא

50 דוגמא נוספת: פה התשובה היא B. התדירות היא 1/2. אפשר לראות כי זמן המחזור הוא 2, ולכן התדר הוא 1/2. האמפליטודה היא כמובן 2. הפאזה היא פאי. אילו הפאזה הייתה אפס, אז ב- t=0 היינו רואים את הגל עולה. מאחר יורד בערך הזה הוא פאי. ניתן גם לעבוד עם גלי קוסינוס. מה הקשר בין גל סינוס וקוסינוס? תשובה C. צריך להסתכל על 0=t. הקוסינוס יוצא 1. כדי ליצר חפיפה בין הגרפים, אנו רוצים שגם הסינוס יצא 1 כאשר 0=t. מאחר וסינוס נותן 1 ב- pi/2, אז באופציה C, כאשר 0=t, הסינוס יהיה,pi/2 ואז הוא גם יתן 1. ישנה זהות טריגונומטרית שמראה כי: sin(α+β) = sin(α)cos(β) + cos(α)sin(β) נשתמש בה על הביטוי: Asin(2πft + φ) = A[sin(2πft) cos(φ) + cos(2πft) sin(φ)] = A cos(φ) sin(2πft) + A sin(φ) cos(2πft) ניתן להגדיר כי sin(φ) B=A cos(φ), C= A מפה יוצא במקום להשתמש בביטוי של סינוס שיש בו פאזה, אפשר להעביר אותו לביטוי של סינוס ועוד קוסינוס, שניהם ללא פאזה: -50-

51 ובתוך זה מתקיים הקשר הפיתגורי: 2^C.A^2=B^2 + Asin(2πft + φ) = B sin(2πft) + Ccos(2πft) יש מספר דוגמאות במצגת לכך. לשים לב כי בכל הדוגמאות, האמפליטודה של הסינוס בריבוע והאמפליטודה של הקוסינוס בריבוע יתנו 1. אפשר לראות איך שני הגלים התווספו יחד, ויצרו אמפליטודה גבוהה יותר והובילו לשינוי פאזה. משפט פורייה אומר כי כל פונקציה ניתן להרכיב כפונקציה של גלים שונים. לכן למעשה נוכל לתאר כל גל באמצעות חיבור של מספיק גלים. אפשר לראות בדוגמא הבאה חיבור של שני גלי סינוס, בתדירויות שונות: כדי לחבר מספר פונקציות במתלב: בקטע הקוד הזה מחברים 9 פונקציות סינוס, שכל אחת מהן היא בתדר אחר )f(, אשר עולה כל פעם ב- 1 בכל פונקציה. -51-

52 ניתן לשרטט את המקדמים כפונקציה של התדר. בעיבוד אותות נעבור מהצגה לפי הזמן להצגה לפי התדר, וזה ילמד אותנו על הגלים שיש בתוך האות. נחזור לדוגמא של אותות ביולוגים- אות.ECG האם ניתן להרכיב אותה כסכום של גלי סינוס ו/או קוסינוס? התשובה היא כן. זה למעשה פירוק פורייה. אבל לשם כך צריך לעבור מפונקצית מקדמים בדידה לפונקצית מקדמים רציפה. זאת משום שכאשר המקדמים הם בדידים, אנחנו יכולים לקבל רק פונקציות מחזוריות על ידי סכימה שלהם. וה- ECG אינו מחזורי. הפתרון הוא לעבור למקדמים רצפים. על פי משפט פורייה, ניתן להרכיב כל פונקציה, גם אם אינה מחזורית, באמצעות פונקציות סינוס, כל עוד לוקחים בחשבון את כל המקדמים )כלומר הם רציפים(. מעבר זה הוא גם מעבר בין סכום לאינטגרל. בצורה של סכום זה היה: 9 F(t) = A f sin (2πft) f=1 כעת יש לנו מטרה להקטין את הקפיצות ב- A כדי להפוך אותו לרציף: 5 F(t) = [0.01 A(f)] sin (2πft) f=0,0.01,0.02 רואים פה הכפלה בין רוחב המלבן, לבין הפונקציה של הסינוס )לא קריטי למה עושים את זה, זה קשור לעובדה שלא רוצים ששינוי ברזולוציה של A ישנה את הפונקציה F(. ניתן לכתוב את זה גם כך, כאשר delta f הוא 0.01: f max F(t) = [ f A(f)] sin (2πft) f=0, f,2 f -52-

53 כאשר delta f הוא מספיק קטן, זה שקול לאינטגרל: f max F(t) = df A(f)sin (2πft) 0 ברגע שיש לנו אינטגרל, אנחנו סוכמים המון המון פונקציות, שלהם תדרים f ואמפליטודות,A(f) אשר משתנים מאוד לאט )כלומר שינוי מאוד מזערי בתדרים, על מנת לייצג את התדרים באופן רציף(. זה מה שמאפשר לנו למעשה לקבל כל פונקציה, גם אם אינה מחזורית. כדי לחשב את האינטגרל במתלב: הקשר בין A ל- f נקבע להיות: A(f)=e^(-f^2/2) זוהי פונקציה של חצי גאוסיין. בתוך הלולאה רצים על התדרים )f(. בתוכה מייצרים כל פעם פונקציה,)func( שלה תדר אחר, ולכן גם אמפליטודה אחרת )שכן האמפליטודה היא פונקציה של התדר גם, בקשר של חצי גאוסיין(. את אותם הפונקציות סוכמים ב- sum_func, שזה למעשה האינטגרל. הפקודה המתאימה ליצירת האינטגרל היא זו שב- C. הפונקציה sum_func שמתקבלת היא: והיא פונקציה לפי הזמן. אפשר לראות שהיא אכן לא מחזורית )שזהו הייתה המטרה שלנו- לקבל פונקציה שאינה מחזורית מתוך סכימה של פונקציות מחזוריות(. -53-

54 עיבוד אותות בזמן ובמרחב- המשך: דיברנו בשיעור הקודם על סכימה של פונקציות סינוס וקוסינוס לייצוג פונקציות מורכבות. דוגמא: נתון הפונקציה הבאה: sin(2πft) A f =, F(t) והגרף הבא המתאר את הקשר בין f ל- f_max f=1 :A נשאלת השאלה מהי הפונקציה המתארת אותה גרפית? התשובה היא A. על פניו, פונקציה C היא היחידה שמתארת מצב בו יש סכימה של כמה פונקציות סינוס עם תדרים שונים, אבל אם מתבוננים בקשר בין A ל- f ניתן לראות כי עבור כל התדרים 1-8, האמפליטודה היא אפס, ואילו עבור תדר בלבד 9 האמפליטודה היא שונה מאפס. כלומר הוא התדר היחיד שיכול להיות מיוצג- בכל תדר אחר לא אמורה להיות עלייה וירידה. דוגמא נוספת: הקשר בין f ל- A נתון כך: -54-

55 התשובות האפשריות הן: בפונקציה הפעם הקשר בין f-לa הוא כזה שיש שני תדרים אפשרים להיות מיוצגים. תשובות A ו- D מתארות מצב בו יש רק תדר אחד שמיוצג ולכן לא טובות. שנית, התדרים שיהיו להם יצוג הם 2-3 הרץ, ותשובה B מתארת ייצוג של תדרים גבוהים יותר. לכן תשובה C היא היחידה שאפשרית. דוגמא נוספת. הפעם נתונה הפונקציה וצריך להבין את הקשר בין A ל- f : הפונקציה מתארת גל שיש בו ייצוג לשני תדרים- אחד גבוה ואחד נמוך. לכן התשובה הנכונה היא C. -55-

56 דיברנו על מעבר מסכימה של פונקציות לאינטגרל סופי- מאפס ועד fmax על כל הפונקציות. אבל לא חייבים להגביל את הערך של fmax וניתן לעשות את האינטגרל מ- 0 ועד אינסוף: F(t) = df A(f) sin(2πft) 0 ולדרוש כי A(f)=0 עבור fים גדולים מאוד. כעת נרחיב את הרעיון הזה שוב ונוסיף פאזה לגלי הסינוס. גם הפאזה תלויה ב- f )בדומה ל- A (: Fmax F(t) = A f sin (2πft + φf) f=1 אך ראינו בשיעור הקודם כי ניתן להיפטר מהפאזה על ידי חיבור פונקציות סינוס וקוסינוס: ואם נרצה להציג את זה כאינטגרל אינסופי: F(t) = Fmax F(t) = [B f sin(2πft) + C f cos(2πft)] 0 f=0 df B(f) sin(2πft)+ 0 df C(f) cos(2πft) פה ניתן לראות דוגמא למצב בו מחברים פונקציות סינוס וקוסינוס: הפוקנציות סינוס משתנה בתדרים שונים סביב 5 הרץ. אבל מאחר וזה עקום רציף, אז יש לה המון תדירויות בהן היא משתנה. זו הסיבה שאנחנו רואים בגרף של החיבור )ה- A ( עליות וירידות בתנודות גבוהות )השינוי בתדר הוא מאוד קטן וזה יוצר גרף קופץ(. למעשה יש פה מעבר ממרחב התדר למרחב הזמן, וזה טרנספורם פורייה. -56-

57 משפט פורייה: ניתן להציג כל פונקציה סבירה באופן הבא: F(t) = 0 df B(f) sin(2πft)+ 0 df C(f) cos(2πft) כלומר, ניתן למצוא פונקציות C(f) ו-( B(f שיאפשרו לנו "להרכיב" את F(t) כסכום אינסופי של גלי סינוס וקוסינוס. כדי למצוא את B(f) ואת C(f) מתוך :F(t) נשים לב כי F(t) הוא אינטגרל על התדר, ואילו האינטגרל ב-( B(f ו-( C(f הם אינטגרלים על הזמן. נדבר על הפירוק פורייה במקרה פשוט בו התדר הוא 1 הרץ :)F(t)=F(t+1)( שם האינטגרל יהיה מ- 0 ועד 1 במקום ממינוס אינסוף ועד אינסוף: F(t) = B f sin(2πft) + C f cos(2πft) f=0 f=0 1 B g = 2 F(t) sin(2πgt) dt 0 1 C g = 2 F(t) cos(2πgt) dt 0 ההוכחה מראה מהם Bg ו- Cg )שתי השורות התחתונות( כאשר F(t) נתון כפי שהוא נתון בשורה העליונה )אין צורך לראות או להתעמק בהוכחה(. מכאן ניתן לקחת את זה למקרה הכללי, בו התדר g אינו בדיד אלא רציף. נקבל את מה שראינו למעלה לפיו כאשר הפונקציה היא: -57-

58 אז ניתן למצוא את B(g) ואת C(g) והם יהיו שווים: המסקנה של כל הדבר הזה היא שניתן לעבור ממרחב הזמן למרחב התדר בקלות, וגם כיצד ניתן לעשות זאת. המטרה הבאה תהיה לאפס תדרים מסוים על מנת לעשות כל מיני פילטרים עיבוד אותות בזמן-המשך: דיברנו על פירוק פורייה שבאמצעותו לוקחים כל פונקציה )סבירה( וניתן להציג אותם כסכומים )אינטגרל( של סינוסים וקוסינוסים, ואף ניתן באמצעות הפירוק למצוא את המקדמים של הפונקציות המרכיבות אותן )שזה מציאת הפונקציות B(f) ו-( C(f המייצגות את האמפליטודות של הפונקציות(. דוגמא- טרנספורם פורייה של גאוסיין נראה כך )היא הפונקציה היחידה שמקיימת את התנאי הזה בו צורתם במרחב הזמן והתדר זהה(: משמאל רואים את הפונקציה ומימין את פירוק פורייה. -58-

59 מה ניתן ללמוד מתוך הגרפים של B(f) C(f), על הפונקציה?F(t) בדוגמא של הגאוסיין, מאחר וה-( B(f הוא אפס עבור כל התדרים ניתן ללמוד מכך על הפונקציה F(t) שהיא זוגית סביב ראשית הצירים. ניתן ללמוד כי הפונקציה משתנה לאט. הסבר לחלק על הזוגיות: B(f)* קשור לפונקציות הסינוס וזו פונקציה א-סימטרית. שנית, מאחר וב-( C(f יש ביטוי רק לתדרים נמוכים, אז *פונקצית ה- cos הא סימטרית ולכן החלק מימין לראשית הצירים הוא מראה של החלק משמאל לראשית הצירים )זה פונקצית U או U הפוך(. בסינוס זה לא כך )צריך לעשות היפוך מראה וגם לסובב ב- 180 מעלות, זו פונקציה שנראת כמו נחש(. *אם הפונקציה הייתה א-סימטרית היינו מסיקים כי ה-( C(f הוא אפס. אם אין קשר בין מה שקורה משמאל ומימין לראשית הצירים אז היה ביטוי גם ל-( B(f וגם ל-( C(f. אם נתונה לנו פונקציה F(t) ואנחנו רוצים ללמוד על הפונקציה הזוגית והאי זוגית שלה, ניתן להמיר אותה למרחב התדר )חישוב B(f),)C(f), ואז לאפס פעם אחת את B(f) ולשחזר את F )זה יתן את החלק הזוגי( ופעם שנייה לאפס את C(f) ולשחזר את F )זה יתן את החלק האי זוגי(. המצב המשלים הוא שנתונות לנו הפונקציות B(f) ו-( C(f ואנחנו מעוניינים לבנות מהן חזרה את הפונקציה המקורית.F(t) ברוב המקרים השחזור יהיה קרוב מאוד לפונקציה המקורית. דוגמא: הפונקציה הבאה היא זוגית, ולכן ה-( B(f יהיה אפס. דוגמא נוספת: מה המקדמים של פונקצית הא.ק.ג? -59-

60 מאחר והיא לא סימטרית ולא א-סימטרית, נצפה כי אף פונקציה לא תתאפס. שנית, התדר הבולט פה הוא כ- 1.5 הרץ )יש 7 ספייקים ב- 5 שניות(, ולכן B(f) ו-( C(f יהיו חזקים סביב הפונקציות הנמוכות. אכן רואים את זה, אבל לשים לב כי העלייה סביב הרץ היא יחסית נמוכה בפונקציות התדר. מרבית העליות בפונקציות התדר הן בתדרים המאוד נמוכים, פחות מ- 1 הרץ. זה מייצג את השינויים האיטיים בECG )למעשה האמפליטודה של השינויים האיטיים היא דווקא מאוד גדולה- מיוצגת באדום, בעוד שהאמפליטודה של השינויים המהירים "רוכבת" על הגלים האיטיים והיא די קטנה-מיוצגת בסגול(. אם היינו מסתכלים על השחזור של הפונקציה הזו, הוא היה פחות טוב בהשוואה לדוגמא הקודמת. זאת משום שהפונקציה הזו הרבה יותר מורכבת. התנודה המאוד גדולה שיש סביב 2- היא ככל הנראה הנשימה. זה תדר מאוד נמוך, וסיכוי סביר כי בפוקנציות B(f),C(f), "ההתרחשות" הגדולה בתדרים הנמוכים היא הקפיצה הזו של הנשימה. כי כאמור האמפליטודה של שינוי זה היא הכי גדולה בגרף. -60-

61 ניתן גם להשלים חלק מהפונקציה. זהו הפילטר למעשה. ניתן לשחזר רק את התדרים הנמוכים, זהו low-pass פילטר, או לשחזר רק את התדרים הגבוהים, זהו high-pass פילטר. כדי לעשות פילטר, צריך להגדיר את הגבולות של האינטרגל באופן שונה מ- 0 ועד אינסוף )זה שחזור מלא(. עושים שחזור בהתאם לגבולות של מה שרוצים לשחזר. אם רוצים למשל low pass filter אפשר לעשות את הגבולות של האינטגרל מ- 0 ועד 1, אם רוצים high pass filter אפשר להגדיר את האינטגרל מ- 1 ועד אינסוף. יש גם Band-pass filter הוא שחזור של תדרים "אמצעים", למשל מ- 1 ועד.10 דוגמאות: תזכורת- עשינו גם פילטר באמצעות ממוצע רץ )נקרא גם.)smoothed signal הוא דומה ל-- low.pass filter וכאשר הפחתנו את הממוצע הרץ מהסיגנל זה דומה ל- filter.high pass תזכורת לכתיבה במתלב: -61-

62 הממוצע הרץ הוא חלון מרובע, בו לכל נקודה בדאטה ניתן משקל שווה. ניתן לייצר חלונות שונים הנותנים משקל שונה לכל נקודת דאטה בחלון. איך מייצרים את החלון? תחילה יש לדבר על האופרטורים.and, or, xor האופרטור and מקביל ל"ו". מסומן &. האופרטור or מקביל ל"ו/או". מסומן בקו אנכי. הוא יחזיר )=true( 1 כאשר אחד מהתנאים הוא או ששניהם.)=true( 1 )=true( 1 האופרטור xor הוא "או" אבסולוטי. הוא יחזיר )=true( 1 רק כאשר אחד מהתנאים הוא 1,)=true( אבל לא כששניהם.)=true( 1 ניתן לראות את הטבלאות הבוליאניות של האופרטורים: איך בונים את פונקצית "הגבשושית" G במתלב? * T הוא גודל החלון. הוא שווה ל- 1. התשובה הנכונה היא A. הקוד מגדיר כי G הוא אפסים, אבל באזור שבין 1/2- ל- 1/2 הוא שווה ל

63 כאשר אומרים שגודל החלון הוא 1, אז גם השטח שלו צריך להיות 1. פה זה יוצא כך כי הוא 1 באורך ובגובה. ניתן היה להגדיר את 2=T, ואם היינו משאירים את הקוד כפי שהוא, הרוחב של החלון היה 2 אבל האורך נשאר 1/2 ולכן הגודל של החלון היה נשאר 1. חישוב ממוצע רץ: ה- F גג הוא ממוצע. סוכמים את האיברים מ- t ועד טאו, כאשר הטאו רץ מ- Ldt - ועד,Ldt בצעדים של 1, ואז מחלקים ב-) 2L+1 (, לצורך נרמול. לכן למעשה הסכימה מתחילה מ- ומסתיימת ב-) t+ldt (. )t-ldt( זה שקול לסכימה לשורה השנייה )מפחיתים טאו מ- t (. נניח כי ה- dt=0.01, וכי ה- L=100. אז.Ldt=100*0.01=1 לפיכך, ה- T, שהוא רוחב החלון, הוא 2 )הוא מתחיל מ- 1 - ועד 1(. מפה המטרה היא לעשות אינטגרל ולא סכום. צריך להכפיל ב- dt/dt )או ב- dtau/dtau, זה אותו הדבר(, ואז עוד כמה מניפולציות מתמטיות ויוצא: קונבולוציה פירוק פורייה כאמור מפרק את הפונקציה לרכיב הזוגי והאי זוגי שלה. מה הקשר שלו לממוצע רץ? -63-

64 כדי לחשב ממוצע רץ השתמשנו בנוסחא הבאה: T 2 F (t) = 1 F(t τ)dτ T T 2 בתוך הנוסחא הזו- הזמן הוא τ t; הוא המשתנה שאנחנו רצים עליו בתוך הממוצע הרץ. כלומר בנקודה t מסוימת, אנחנו סוכמים τ נקודות אחורה וקדימה; T הוא גודל החלון..T/2=LΔ τ נעבור לדבר על את פונקצית הגבשושית, היא מוגדרת כך: לפיכך ניתן להגיד כי, הפונקציה,F (t) שהיא הממוצע הרץ בזמן t הינה: זה שווה ל- G. ניתן להחליף את גבולות האינטגרל משום שזה לא ישנה אותו- כי ה- G בכל מקרה שווה לאפס מחוץ לתחום של 2/T ועד 2/T. במילים אחרות, ממוצע רץ הוא מקרה פרטי של קונבולוציה של שתי פונקציות, שאחת מהן היא פונקצית גבשושית. באופן כללי קונבולוציה של פונקציות,F1 F2 מוגדרת: אפשר גם להגיד כי זו נוסחת הקונבולוציה במרחב הזמן. -64-

65 ואפשר לראות גרפית את התוצאה של קונבולוציה של הפונקציה F עם פונקצית הגבשושית: F(t) G(τ) F * (t) כמובן שזה.low pass filter כדי לחשב את הממוצע הרץ באמצעות קונבולוציה במתלב: נגדיר קודם את פונקצית הגבשושית )משמאל יש פונקציה שיוצרת את הגבשושית לפי T ו- tau ספציפיים(, ואז בתוך הקוד של הקונבולוציה מייצרים אותה עבור הפרמטרים T ו- tau שאנחנו מעוניינים: ואז אפשר ליישם את הפונקציה conv )פונקציה שמורה במתלב(: את ה- same צריך לשים כי הוא "מטפל" בקצוות- שם הרי יש בעייה עם הממוצע. וה- dt גם צריך להוסיף. לא הוסבר מדוע. אבל ניתן היה גם לכתוב.dτ ניתן לעשות קונבולוציות גם באמצעות חלונות לא מרובעים- בהם הפונקציה אלא למשל משולש. G אינה גבשושית, -65-

66 כל פונקציה G שונה מייצרת פילטר low pass שונה. ניתן להרחיב או להצר את גודלה של לשנות את הפילטר. G וכך מדוע ממוצע רץ דומה ל- filter?low pass אמרנו כבר כי ממוצע רץ הוא סוג של קונבולוציה. כעת ניתן לעשות פירוק פורייה על הקונבולוציה. מתוך זה נוכל לראות מדוע זהו.low-pass filter אינטגרל פורייה של קונבולוציה: ניתן להגדיר את הפונקציות B, C במרחב התדר עבור F(t) ועבור,G(τ) כלומר: B(f), C(f); B G (f), C G (f) ולא נוכיח זאת אבל, הפירוק פורייה על הקונבולוציה (t) F: * כלומר ישנו קשר בין מקדמי פורייה של הקונבולוציה, ובין מקדמי פורייה של הפונקציות המקוריות,F, G ללא שום אינטגרל. תצוגה זו היא נוסחת הקונבולוציה במרחב התדר. ניתן להסתכל על הפונקציות (f) :B G (f), C G ה- B הוא אפס כי הפונקציה היא זוגית. אפשר לראות גם את הנוכחות של התדרים הנמוכים גם ב- C וגם ב- A (. נהוג לומר כי ישנה "אנרגיה" גבוהה בתדרים הנמוכים, והיא יורדת ככל שהתדר עולה. זה מתאר את האמפליטודה. משום ש-( f ) B G היא אפס, אז אפשר להגיד על מקדמי פורייה של הקונבולוציה כי: ניתן לראות כי הביטוי אף פשוט יותר ממה שהיה. -66-

67 אם נבחן את הביטוי הזה, אז נראה כי צריך לקחת את טרנספורם פורייה של פונקצית הגבשושית, ולכפול אותו בטרנספורם פורייה של הפונקציה המקורית על מנת לקבל את טרנספורם פורייה של פונקצית הקונבולוציה. כזכור, מקדמי פורייה של פונקצית הגבשושית הם "בעלי אנרגיה" בתדרים הנמוכים וכמעט אפסיים בתדרים הגבוהים. לכן אותה מכפלה תאפס את התדרים הגבוהים בפונקציה המקורית F. זו הסיבה שקונבולוציה עם פונקצית גבשושית היא.low pass filter באופן גרפי, ניתן לראות איך האנרגיה המעטה שהייתה ל- F בתדרים הגבוהים נעלמה לאחר בתוך הממוצע הרץ: הפונקציה המקורית ECG( ) הממוצע הרץ בתהליך ההפוך, ניתן לקבוע איך תראה פונקצית הגבשושית במרחב התדר, ואז לייצר את הפונקציה במרחב הזמן. כך נחליט מראש על הפילטר. דוגמא- נבחר את הפונקציה G(tau) במרחב התדר כך: זהו low pass filter כי איפסנו את התדרים הגבוהים, והשארנו רק את התדירויות בין 0-1 הרץ. יש בה רכיב זוגי ואי זוגי. כאשר נרכיב את הפונקציה G(tau) במרחב הזמן: -67-

68 דוגמא נוספת: פונקצית G במרחב התדר: ובמרחב הזמן: הפונקציה הזו אינה סימטרית ואינה א-סימטרית, היא מכילה רכיב של B ושל C. כאן השינויים באמפליטודה של התדרים היא יותר הדרגתית בהשוואה לדוגמא הקודמת. כעת נראה דוגמא ל- filter :high pass במרחב התדר: ובמרחב הזמן: ניתן לראות כי התנודות בפונקציה G במרחב הזמן הן גדולות. זה משום שנשארו התדרים הגבוהים. יש לזכור כי הפונקציה הזו תעבור קונבולוציה עם פונקציה f, ואז תייצר עליה.high pass filter -68-

69 תרגול -69-

70 תרגול בניתוח אותות ומערכות מתרגל- גיא יונה סביבת העבודה של מטלב: את הפקודות רושמים ב- window.command יש גם את ההיסטוריה של הפקודות ב- history.command ב- workspace אפשר לראות את המשתנים שלנו. בדיוק מה הערכים שלהם והמאפיינים שלהם )למשל סוג המשתנה ומימדיו(. פעולות בסיסיות שניתן לעשות במטלב: ב- window command )וגם על משתנים( ניתן לעשות פעולות חשבון רגילות: ^,/, x, -, +. *הדרך הנכונה לעשות חילוק היא באלכסון הבא: / כדי לבצע שורש יש צורך בפונקציה מובנת. פונקציות: כדי לחפש פונקציות ומידע עליהם צריך לרשום ב- window command את הפקודה doc ואחריה את הפונקציה שאנחנו רוצים לחפש. למשל.doc sqrt כדי להפעיל את הפונקציה צריך לרשום אותה ולהכניס בסוגרים ארגומנטים של קלט. לכל פונקציה יש הגדרות של כמה קלטים היא אמורה לקבל. למשל הפונקציה sqrt תקבל רק ארגומנט אחד והוא המספר/משתנה שעליו נרצה לעשות שורש. נכתוב את הפונקציה בצורה הבאה:.sqrt(9) הארגומנט קלט הוא 9. הפלט שנקבל הוא 3. מעבר לפונקציות מובנות יש גם קבועים אחרים. למשל π. אם רוצים לקבל אותו רושמים.pi משתנים: דיברנו בהרצאה. -70-

71 תרגיל קטן:.a=6, b=-6 אם היינו רוצים להפוך את הערכים של a ו- b כדאי להשתמש במשתנה ביניים: b=d; (1) b=a; (2) a=d; (3) פקודות שימושיות: כדי לנקות את ה- workspace )כל המשתנים בעצם( עושים.clear כדי לנקות את ה- window command עושים.clc את ה- clear אפשר לעשות ספציפי למשתנה מסוים, נניח.clear a דיברנו בהרצאה גם על מערכים, שיכולים לקבל מספר איברים. ניתן לעשות פעולות מתמטיות על מערכים באותם מימדים. כדי לעשות כפל או חילוק, או חזקה, צריך לרשום נקודה ).( לפני הסימן המתמטי, באופן הבא: יש שני מערכים:,a, b ופעולת הכפל תכתב:.a.*b התוצאה תהיה כפילה של איבר איבר )בהתאמה של האינדקסים(. אם נרצה לעשות פעולה מתמטית על המערך שכוללת רק הכפלה בסקלאר או חילוק בסקלאר, לא צריך את הנקודה. יש מערכים שיש להם חוקיות והם לא רק אוסף נתונים. נניח אם הינו רוצים להגדיר מערך של 5 מספרים רצופים מ- 1 ועד 5, יכולנו לרשום 1:5=a. אם נוסיף עוד ארגומנט באמצע נוכל להגדיר קפיצות שונות מאחד. למשל: 1:0.2:2 יתן מערך מ- 1 ועד 2 בקפיצות של 0.2. כדי ליצור מערך יורד צריך לרשום את הקפיצות במינוס: למשל הכיתוב: 0.5:1-:2=a יתן לנו מערך יורד מ- 2 ועד 1 בקפיצות של חצי. -71-

72 אם נרצה לשלוף מתוך מערך אינדקסים ספציפיים- למשל יש מערך [4,5,7,8]=b, ונרצה לשלוף את איברים 2 ו- 3, יכולנו לרשום:.b[(2:3)] או,b([2,3]) או b(2:3) אם נרשום b(2:) נקבל את כל האיברים ב- b, החל מהאיבר השני עד הסוף. זה בקפיצות של 1. אם היינו מוסיפים עוד ספרה באמצע עם : משני הצדדים, אז היה אפשר גם לשנות את הקפיצות. לשים לב: סוגרים עגולים זה לאינדקסים, וסוגרים מרובעים זה מערך. a. נותן את האורך של המערך length(a) יש חלון שנקרא.count folder שם יש את הפירוט של כל הקבצים שנמצאים בתיקייה עליה אנו עובדים. ניתן לשמור נתונים של מטלב בסיום.mat כדי להעלות אותו למקום בו אנחנו עובדים אפשר לבקש,load('data'.mat) כאשר data הוא השם של הקובץ, ו- load זו הפקודה. אם נעשה זאת נראה ב- space work את כל המשתנים שהיו באותו קובץ, ואם המאפיינים שלהם- סוג, גודל, מינימום ומקסימום של האיברים בהם. כדי שקובץ יעלה הוא חייב להיות באותו directory כמו הקובץ עליו אנחנו עובדים. כלומר באותה תיקיית עבודה. הצגה גרפית של נתונים: הפקודה scatter תאפשר לנו לשרטט את הנתונים. צריך להכניס לה 2 נתונים- את הנקודות של ציר ה- X ואת הנקודות של ציר ה- Y. בדוגמא בכיתה יש משתנה שנקרא pulse_admit ויש משתנה שנקרא,temperature_admit שהם הערכים שאנו רוצים לשרטט על ציר ה- x וה- y בהתאמה. לכן נרשום: temperature_admit).scatter(pulse_admit, אם נוסיף עוד מאפיינים אחרי המשתנים של x ו- y נוכל לשלוט במאפיינים ויזואלים של הגרף. למשל אם היינו מוספים 'r' אנחנו יכולים לבקש שהנקודות יהיו באדום. אם נרצה לשרטט על אותו הגרף יותר מזוג נתונים אחד, ניתן לשרטט את הנתונים של המשתנים הראשונים, ואז,hold on ואז את הנתונים של הזוג משתנים הנוסף. -72-

73 כדי לרשום כותרות לצירים: כמובן שגם ל- y..xlable('pulse/[1/min]') כדי לשלוט בסקלאה של הצירים: axis(xmax, xmin, ymax, ymin) הפקודה doc scatter תתן לנו רשימה ארוכה, בה נוכל לקרוא איך לשלוט על המאפיינים הויזואלים של הגרף. בתרגול הבית נצטרך לשנות את צורת הנקודות למעויינים התייחסות לשאלה מתוך שיעורי הבית )שאלה 3(, להדגיש איך יותר נכון לכתוב קוד: Result=[sqrt(arr.^2+1)/pi] לשים לב כי הסוגריים המרובעים הם מיותרים. Result=sqrt(arr.^2+1)./pi פה הנקודה לפני החילוק בפאי הם מיותרים, כי פאי אינו מערך. Result=(sqrt(arr.^2+1))/pi פה הסוגריים העגולים הם מיותרים. סקריפט: עד כה עבדנו רק ב- window.command אם אנחנו רוצים לכתוב קוד ארוך, ולשמור את הפקודות שלנו, עלינו לכתוב סקריפט. כדי לפתוח סקריפט ניתן ללחוץ new script בלשוניות למעלה או לרשום edit ב- window.command כדי להריץ את הסקריפט ניתן לרשום את השם שלו בתוך ה- window,command או ללחוץ על בתוך הסקריפט, או ללחוץ F5. play כאשר רושמים סקריפט נהוג לרשום הערות המסבירות אותו. אם פותחים שורה ב-% זה יכתוב הכל בהערה ולא פקודה. ישנה אפשרות לשלוט על הזרימה של התוכנה: משפטי תנאי ולולאות. -73-

74 משפטי תנאי: יתחיל בביטוי תנאי: if פקודה אם התנאי שרשום בשורה העליונה נכון תתקיים הפקודה שרשומה באמצע, ואם התנאי אינו מתקיים הסקריפט ידלג על מה שרשום באמצע. במשפטי תנאי יותר מורכבים מוסיפים גם,else ואז משהו חייב לקרות- או מה שכתוב בתנאי,if או הפקודה שאחרי ה- else. תנאים אפשריים למשפטי תנאים: >=, <=, ~=, ==, >, < כל אחד מאלו הוא פעולה לוגית, אשר לה יש תשובה: 1 או 0. אפשר גם לעשות פעולות לוגיות על ערכים לוגים ולא על מספרים. הדוגמא הפשוטה ביותר היא -not היא הופכת משהו שהוא (1) true להיות (0) false ולהפך. למשל, בהנחה ויש לנו שני משתנים, 5=d,3=a, ואז נרשום: Var1=a>d Var2=~Var1 יצא לנו כי.Var2=1 פעולות לוגיות נוספות הן.and, or. בפעולה and יופיעו שני תנאים, ורק אם שניהם נכונים התוצאה תהיה 1. סימון &. בפעולה or יופיעו גם שני תנאים, אבל מספיק שאחד מהם יהיה נכון והתוצאה תהיה 1. סימון תרגיל: a=5; b=7; (b-a)>=0 (a*b)<0 (2>=0) (35<0)

75 תרגיל: ( (b/a+14)>0 & b<2 ) ~( (a+b)>4) (1&0) ~(1) ((0) (0)) 0 לולאות for מבנה לולאה דומה למבנה של משפט תנאי: for i=[ ] disp(i) ה- i פה אינו וקטור אלא הוא שווה כל פעם לערך אחר מתוך המערך [4 1]. 2 3 דוגמא: x=[ ]; for i=1:length(x) disp(x(i)) הלולאה מבקשת להציג כל פעם את האיבר ה- i במערך x. הלולאה רצה על i מ- 1 ועד 6 )אורכו של x(. הפלט יהיה האיברים של x בסדר יורד. דוגמא: x=4:-1:1 for i=4:-1:1 disp(x(i)) פה הפלט יהיה: 1, 2, 3,4 )בסדר עולה(. -75-

76 דוגמא: m=1 b=5 for i=1:b m=m*i disp(m) התוצאה תהיה!5. ניפוי שגיאות :)debugging( במקום להריץ את התוכנה ב- run, מריצים אותה שלב שלב על ידי F10. צריך לשים עצור אדום בצד שמאל של השורה )זה נקרא.)break point ברגע שנריץ את התוכנה היא תעצור על נקודת העצירה הזו, ותכנס למצב.debugging אפשר להתחיל להתקדם שורה שורה ולעקוב אחרי המשתנים ומה קורה להם. דוגמא: a=[3 4 6] for i=1:length(a) for j=0:length(a) if i+j<=length(a) disp(a(i+j)) לולאה ראשונה i תרוץ מ- 1 ועד 3. לולאה פנימית j תרוץ מ- 0 ועד 3. זה בסדר כי 0 הוא לא אינדקס במערך אלא מספר ש- j רץ עליו. -76-

77 בסיבוב הראשון i שווה ל- 1 ו- j שוה ל- 0, ולכן התנאי מתקיים. לכן יוצג האיבר הראשון בתוך a, שהוא 3..4 בסיבוב השני, i נותר 1 ואילו j עובר ל- 1. התנאי עדיין מתקיים, ולכן יוצג האיבר השני ב- a, שהוא בסיבוב השלישי, i נותר 1 ו- j עובר ל- 2. התנאי עדיין מתקיים ויוצג 6. בסיבוב הרביעי, i נותר 1 ו- j עובר ל- 3. התנאי כבר לא מתקיים ולכן לא מוצג כלום. הלולאה עוברת לסיבוב הבא בו 2=i.. תוצאה סופית: 6].[ פקודת break יוצאת מתוך הלולאה ומפסיקה את הביצוע שלה גם אם היא לא הסתיימה. פקודת continue קופצת למחזור הבא של הלולאה, תוך הפסקת הביצוע הנוכחי של הלולאה. יש לנו דוגמא על לולאה שרושמת את המספרים הראשוניים: idx=1; for i=2:100 for j=2:100 if ((round(i/j)==(i/j) break if (j==i) numb(idx)=i disp(i); idx=idx+1; -77-

78 נשים לב, ברגע שנגיע למצב בו המספר j הוא מחלק של i )כלומר נותן מספר שלם ללא שארית כאשר מחלקים אותו(, אז התנאי שב- if יתקיים. ואז צריך לעשות,break ואנחנו נצא מהלולאה שעוברת על j. אז נבחן את התנאי,if i==j שזה אומר שהמחלק היה המספר עצמו. אם אכן המחלק הוא גם המספר עצמו, אז המספר i הוא ראשוני, ואנחנו נכניס אותו לתוך מערך.numb יש מספר דרכים לייעל את הלולאה. קודם כל אפשר להריץ את הלולאה של j עד i ולא עד 100, ואז אנחנו לא מוגבלים במספרים עד 100. אפשר אפילו לעשות את זה עד.sqrt(i) לא הבנתי את ההסבר מדוע. פונקציות לפונקציה נותנים שם, אחריה שמה שמים את הארגומנטים של הקלט. אותה מיישמים לתוך משתנה הפלט. ניקח דוגמא בה אנחנו מחפשים את הפתרונות של משוואה ריבועית: function [x1, x2] = eq_solver (a, b, c) d=b^2-4*a*c; x1= -b+sqrt(d)/(2*a); x2= -b-sqrt(d)/(2*a); הארגומנטים של הקלט הם.a,b,c שם הפונקציה היא.eq_solver הפלטים של הפונקציה הם x1 ו- x2. תמיד יהיה לנו 2 פתרונות, אבל יתכן כי פתרון אחד יהיה פתרון לא ממשי, ויתכן כי שני הפתרונות יהיו אותו הדבר. לכן הפונקציה לא תתקע. לולאת :while כמו,for גם זו לולאה שרצה על מספרים, אבל כל עוד מתקיים איזשהוא תנאי. דוגמא ללולאה שמחשבת עצרת: -78-

79 function t3s4 n=10 f=n while n>1 n=n-1 f=f*n disp (f) הלולאה תפסיק כאשר 1=n )אז כבר היא לא תכנס אל תוך התנאי(. אם עשינו לולאת,while שבה יש תנאי שתמיד יתקיים, היא לא תפסיק לרוץ. כדי לעצור אותה אפשר ללחוץ.Ctrl+C דוגמא: נרשום פונקציה המקבלת מערך a, ומחזירה מערך עם כל הערכים החיוביים במקומות האי-זוגיים. העזרו ב- while : function b = tirgul3(a) ind=1; b_ind=1; while ind <= length (a) if a(ind)>0 & round(ind)/2~=ind/2 b(b_ind)=a(ind); b_ind=b_ind+1; -79-

80 כדי למצוא את האינדקסים האי זוגיים, עשינו פקודה המשווה בין round של ind/2 ל- ind/2. אופציה אחרת הייתה לא לשים תנאי על האינדקס, אבל כל פעם להגדיל אותו ב- 2 )זה היה בתוך הלולאת,while אבל בסופה-מחוץ לתנאי.)ind=ind+2 :if אפשר היה לעשות גם את הלולאה ב- for. b=[]; for ind=1:2:length(a) if a(ind)>0 b(length(b)+1)=a(ind) האינדקס ב- b שירוץ בתוך הלולאה הוא.length(b)+1 זה אומר לקחת את האורך הנוכחי של b, להוסיף 1, וזה יהיה האינדקס. גם כל פעם נגדיל את המערך b לפי הצורך. נכתוב פונקציה שמנטרת רמות גלוקוז. היא מקבלת את הארגומנטים הבאים כקלט: -Glu רמות הגלוקוז -Day היום של הבדיקה Meal -מתחלק ל- 2 אופציות: 1 אם לאחר הארוחה. 2 אם בצום. יש בתוך הפונקציה כמה בעיות שנצטרך לפתור: 1. אנחנו נרצה לבדוק אם יש לפחות 6 בדיקות שנעשו במשך שלושה ימים רצופים. למשל המערך [5 day=[ התנאי מתקיים )היו לנו מדידות בשלושה ימים רצופים, והם הגיעו ל- 6 מדידות(. אבל המערך [9 day=[ אינו מקיים את התנאי. כדי שנוכל לבדוק את זה, נוכל להגדיר את התנאי כך שאם ההפרש בין הערך הראשון לאחרון הוא קטן או שווה ל

81 function check = checkglucose (glu, day, meal) ind=0; for i=1:length(day)-5 if (day(i+5) day (i) ) <=2 ind = i; if i==0 זה בודק האם יתכן שבמערך שקיבלנו לא היה בכלל בדיקות מתאימות שהיו בשלושת הימים הרצופים %%% disp('insufficiant data') stop; הבעייה השנייה היא לסווג את הערכים של הגלוקוז, אבל רק אלו שהיה במדידות הנכונות )6 בדיקות בשלושה ימים(, לאלו שנעשו לאחר ארוחה ולאלו שנעשו לאחר צום. glu_fast=[]; glu_meal=[]; for i=ind:ind+5 if meal(i)==1 glu_meal(length(glu_meal)+1)=glu(i); else glu_fast(length(glu_fast)+1)=glu(i) -81-

82 פעולות לוגיות במערכים: עד כה ראינו פעולות לוגיות בסקלארים. אבל אפשר לעשות גם פעולה לוגית על מערכים. דוגמא:.a= [4, 6]; b= [6, 4] הפעולה הלוגית a<b תעשה השוואה איבר איבר, ואז תוציא לנו וקטור כפלט: a<b= [1, 0] יכולנו גם להשוות את המערך עצמו לסקלאר: 0<a---< היינו מקבלים פלט שהוא [1,1]. אינדקסים לוגיים: דוגמא: נתון הוקטור 0].a=[4 6 7 אם היינו רוצים מערך b, המכיל רק את האיברים 6 ו- 7 מתוך מערך a, יכולנו לרשום: ([3.b=a([2, אבל, יש לנו את האפשרות להשתמש במערך לוגי כאינדקסים, באופן הבא: 6]=b(. 7 )[ אז היינו מקבלים את אותה התוצאה.b=a(a>5) נשים לב: a(a>5) יתן לנו מערך, אבל זהו מערך לוגי ולא מערך מסוג double כמו משתנים שאנחנו בדר"כ בונים. הוא יהיה (l) 0]=b. 1 1 [0 ואם נשתמש במערך הלוגי בתוך אינדקסים )כמו בדוגמא שלנו(, הוא יבנה את המערך רק מהאיברים שהם 1 בתוך המערך הלוגי )כפי שהוא שם ב- b רק את האיברים 6 ו- 7 (. אם היינו רוצים לעשות את הפעולה ההפוכה, למשל לקחת את האיברים הקטנים מ- 5 בתוך a, יכולנו לעשות.b=a(~(a>5)) אם היינו רוצים להוציא איבר אחד מתוך מערך. נניח של- a יש עשרה איברים, והיינו רוצים להוציא את האיבר השמיני, אפשר היה לעשות כך:.a=a([1:7, 9:]) גיאומטריה אנליטית: נתחיל ממשוואת קו ישר שאנו מכירים: x. 2 =ax 1 b+ החסרון של תצוגה אנליטית זו היא שלא ניתן באמצעותה להציג קוים אנכיים )אנכיים לציר ה- x (; )אופקיים כן(; ויש מקרים בהם קו ההפרדה דווקא כן יהיה מסוג של קו אנכי לציר ה- x. לכן אנחנו נעבוד עם משוואה פולינומית מהצורה: 0 ) 2,c(a 0 + a 1 x 1 + a 2 x כאשר.c 0-82-

83 המשמעות של a 1 ו- a 2 במשוואת הפולינום הם גם של שיפועים, בדומה למשוואה קו הישר המוכרת. ככל ש- a 1 גדל, השיפוע הוא יותר חד )אבל באופן מוזר הוא יורד, כאילו היה שלילי, למרות שהוא חיובי(. יש דוגמא לכך במתלב, כולל השרטוט של העקומות השונות בהתאם ל- a1 : x1=-1:0.1:3; a2=1; a0=1; for a1= 0:0.5:4 plot (x1, -a1/a2*x1-a0/a2) hold on בעצם הגדרנו את x. 1, a 2, a 0 ה- a 1 משתנה, ולכן יהיו לו גרפים שונים כשהוא כל פעם ערך אחר. כששרטטנו, שמנו את ערכי x, 1 ואת ערכי x 2 בתוך הפונקציה.plot כדי לבטא את x 2 היה צריך לבודד אותו מתוך המשוואה הפולינומית:.x 2 = -a 1 /a 2 *x 1 - a 0 /a 2 פונקצית מחיר דוגמא: פונקציה הבוחרת מספרים רנדומלים בין הטווח המבוקש- rand =x1 rand,1) ;100*(100 ## x2= rand (1, 100)*200; scatter(x1, x2) הפלט של הפונקציה שמקבלת את yhat= x1 x2 +1 >= 0; ## x1, x2 למעשה בדקנו האם הערכים של הפונקציה גדולים או שווים לאפס, ואת התוצאות הכנסנו לתוך מערך הנקרא.yhat הוא מערך מסוג לוגי. הרעיון הוא שנקבל קו הפרדה, שמצד אחד שלו, כל הערכים יהיו 1, ומצד שני שלו כל הערכים יהיו

84 כדי להבין את זה נניח כי המערכים הם כאלו: x1= [1 3 6 ] x2= [4 5 7 ] f(x1, x2)= [ ].f(x1, זה המערך הלוגי שמתקבל כשמבקשים x2)>=0 -logic= [0 0 1 ] המערך הלוגי הזה אומר לנו אילו נקודות נמצאות מצד אחד של הקו ואילו נקודות נמצאות מהצד השני של הקו. אם נרצה לשרטט את הנקודות בצבעים שונים )כלומר אלו שמעל הקו באדום ואלו שמתחת לקו בירוק(, אנחנו צריכים להשתמש בשרטוט בו יש שימוש באינדקסים לוגיים:.Scatter(x1(yhat), x2(yhat), 'g') yhat הוא כאמור מערך לוגי, באורך של,x1. x2 כאשר נשים אותו בתור האינדקסים של המערכים,x1, x2 הוא יבחר רק את הערכים בתוכם שתוצאתם במערך הלוגי היה 1. במילים אחרות שהיו מהצד החיובי של הקו. בפונקצית המחיר, אנחנו רוצים לדעת כמה טעויות היו לנו. כמה ערכים שהיו צריכים להיות 1 סווגו 0, וכמה ערכים שהיו צריכים להיות 0 סווגו 1. function cost= calcerror (x1, x2, y, a0, a1, a2) yhat = a0 +a1x1 + a2x2 >=0; cost = sum(yhat ~=y)/length(y); אז yhat הוא מערך לוגי, הוא אינו תלוי ב- y אלא רק ב- x1 וב- x2. הוא הניבוי שלנו עבור מה צריך להיות ה- y. המשתנה cost יסכום את כל המקרים בהם אין התאמה בין ה- y הנתון ל- y המנובא. החילוק באורך y הוא כדי לקבל את הממוצע. כאשר עושים את הפעולה הלוגית yhat~=y נקבל מערך לוגי, שבו הערכים 1 אומרים שאין התאמה בין y לyhat )דהיינו טעות( והערכים אפס אומרים שיש התאמה ביניהם )דהיינו אין טעות(. -84-

85 אנו ממשיכים לעסוק בבעיות סיווג. בעיות הסיווג שעסקנו בהם עד כה הם בסיווג לוגי- הניבוי הוא להשתייך לקבוצה אחת או אחרת )0/1(. היום נלמד על התאמת עקום, בו ננסה לנבא לכל ערך ב- x את ציונו ב- y, כאשר התוצאות האפשריות של הניבוי הן מתחום המספרים הממשיים, ולא רק הערכים הלוגים 0/1. פונקצית המחיר בבעיות הסיווג הייתה ממוצע של המקרים בהם.yhat~=y פונקצית המחיר בהתאמת העקום היא ממוצע של הסטייה הריבועית בין הערך האמיתי )y( לערך המנובא >--)yhat(.ʃ(yhat-y)^2/n משוואת הקו שאנחנו עובדים איתה היא גם משוואה קו ישר, אבל עם פחות פרמטרים )היא מהסוג הרגיל(:.yhat=a1x1+a0 יעול של תוכניות: אנחנו יכולים למדוד את הזמן שלקח לתוכנה שלנו לרוץ )או לכל מקטע בתוך התוכנה שאנחנו מעוניינים(. שמים לפני הקטע את הפקודה tic ובסוף הקטע את הפקודה.toc בחזרה אל ניבוי: כאשר אנחנו מחפשים את הפרמטר a 1 )זאת בהנחה ש- a 0 הוא אפס(, דרך אחת היא לעשות לולאה שרצה על כל מיני ערכי a 1 אפשריים ומחפשת את ה- a 1 שיתן את השגיאה המינימלית. דרך אחרת ויותר נבונה היא לקחת את הפונקציה של השגיאה כפונקציה של )שמחשבת את ממוצע a 1 הסטייה הריבועית של,yhat-y עבור ערכים משתנים של a(, 1 ולמצוא את ערך a 1 שמקיים את המינימום שלה. כדי לעשות זאת גוזרים את הפונקציה לפי a, 1 משווים לאפס, ומבודדים את a. 1 מקבלים את הדבר הבא: ערך a 1 = x 1ny n 2 x 1n a 1 זה יתן לנו את הפרמטר שמביא את השגיאה אל המינימום. היתרון הגדול של השיטה הזו היא שזה חוסך לנו להריץ לולאות של ערכים שונים של a. 1 זה גם מייעל את התוכנה, וגם מאפשר לנו למצוא את ה- a הטוב ביותר שניתן, בעוד שבלולאות אנחנו בוחרים מראש ערכי a 1 שיבדקו )בוחרים גם את הטווח של המספרים עליו נרוץ וגם את הרזולוציה של השינוי(. במתלב זה יהיה כך: Best_a1 = sum (x1.* y)/ sum (x1.^2) -85-

86 כאמור, זה רלוונטי אם 0= 0 a. נחזור למצב בו a0 הוא אינו ידוע. מגדירים מראש טווח ורזולוציה לשני הפרמטרים, ומגדירים את הטעות הראשונית להיות אינסוף: a1=1:0.1:10 a0=1:0.1:20 best_error=inf for i=1: length (a1) %%עובר על כל ערכי a1 האפשריים for j=1:length (a0) %%עובר על כל ערכי a0 האפשריים temp_error=calcerror(x1, y, a1(i), a0(j)) If best_error>temp_error best_a1=a1(i); best_a0=a0(j); best_error=temp_error; 2 אם היינו רוצים להתאים עקום שהוא לא קו ישר, אלא פרבולה, משוואה מהסוג:.y=ax 1 2 הטריק הוא להגדיר כי.k=x 1 ואז ניתן לומר כי.y=ak מכאן ההמשך הוא כמו שאנחנו מכירים בקו ישר )דוגמא למעלה). זה מבחינה רעיונית. במתלב, בכל מקום בנוסחא שהיה צריך להיות x1, נשים 2^.x1. Best_a1=sum ((x1.^2).*y) / sum ((x1.^2).^2) -86-

87 מטריצות כדי להגדיר וקטור עמודה צריך להשתמש ב-;. כאשר שמים את זה בוקטור או מטריצה, זה מסמן לרדת שורה. ככה יוצרים עמודה. *אלא אם כן נעשה טרנספוז לוקטור שורה. יפורט בהמשך. כאשר רוצים לשלוף איבר מתוך מטריצה, צריך לשים אינדקס שורה ואינדקס עמודה. למשל, אם היינו רושמים (2,3)a נקבל את האיבר השלישי בשורה השנייה. אם נרצה לשלוף שורה שלמה או עמודה שלמה, צריך לשים ':'. למשל (3,:)c יתן את כל הטור השלישי )זה כאילו אומר כל השורות בטור השלישי(. דוגמא נוספת: ([4,3],:)c יתן את כל הטור השלישי והרביעי, זה כאילו "כל השורות" בטור השלישי והרביעי. כדי לעשות טרנספוז במתלב, צריך לרשום את המטריצה ו-'. למשל: 'c זה c טרנספוז. נכתוב פונקציה שמוציאה מטריצה 4*20, כל שורה מתחילה במספר השורה, וממשיכה בקפיצות של 1 לעוד 20 מספרים ( ) mat=[]; for i=1:4 mat= [mat; i:(i+19)]; כדי להגדיר במתלב מטריצת יחידה, הפקודה היא.eye צריך רק להגדיר את המימדים: למשל יתן מטריצת יחידה 3x3. Eye(3) אם נרצה לקחת את המטריצה x, ולהכפיל רק את האיבר השני בה ב- 2, נוכל לעשות זאת תוך שימוש במטריצת היחידה בכמה שלבים: -87-

88 יתן מטריצת יחידה של A=eye(3); %% 3 ישנה את האיבר השני בשורה השנייה ל- 2 ;2=(2,2)A %% יגרום לכך שכל האיברים באיקס ישארו אותו דבר, למעט האיבר השני %% A*x בשורה השנייה שיוכפל ב- 2. דוגמא: ניצור מטריצה של אפסים, שבתוכה יש מעגל בקוטר r של אחדות. function mat = circ (r) m_size=201; cent=ceil (m_size/2); mat=zeros(m_size); for i=1:m_size for j=1:m_size mat(i,j)=(i-cent)^2 + (j-cent)^2 <=r^2 באמצעות שתי הלולאות רצים על כל האיברים במטריצה, ועל כך איבר שואלים תנאי לוגי: האם הוא נמצא בתוך המעגל או לא. אם כן הוא יקבל 1, אם לא הוא ישאר אפס להשלים עיבוד אותות

89 הגדרות בסיסות: אות- אות הוא כל גודל כמותי התלוי בזמן או במרחב ויכול להכיל מידע כשלהו. לדוגמא: מדד הדאו-ג'ונס, רישום,EEG רישום.ECG בדוגמא לפנינו רישום EEG שהוא רישום של פעילות חשמלית במוח לאורך זמן. המידע שמכיל האות הוא מידת ההכרה של הנבדק- אם הוא במצב ערות, או באחד ממצבי השינה. דגימה של אותות: רוב האותות בטבע )אור, טמפ', ריכוז הורמון בדם( משתנים כתלות בזמן, וההשתנות שלהם היא רציפה. המחשב עובד בצורה דיגיטלית ולא רציפה, כלומר הזמנים שלו הם בדידים. לפיכך, בתהליך עיבוד האותות אנחנו הופכים קלט מאנלוגי )רציף( לדיגיטלי )בדיד(. כדי לעשות תרגום זה אנחנו לוקחים מדידות של המשתנה המעניין במרווחי זמן קבועים. זה אומר כי יש לנו קצב דגימה קבוע. -89-

90 אנחנו יכולים לקחת אות דגום דיגיטלית ולדגום אותו מחדש לקצב דגימה חדש. נניח כי יש לנו דאטה שנמדד בקצב גבוה מאוד של 1000 הרץ )שהוא כמעט רציף(, ונוריד אותו למדידה של תדירות יותר נמוכה של 100 הרץ. זה נקרא.down sampling כיצד עושים זאת? נתחיל בשרטוט הדאטה figure plot (time, ecg) שני המשתנים time ו- ecg הם וקטורים בעלי אותו גודל. בתהליך ה- sampling down ניצור שני וקטורים חדשים: down_sample_ecg ו-.down_sample_time הם יהיו יותר קצרים. בכל בין בתוכם יהיה ממוצע של x ערכים מהוקטורים המקוריים. נניח כי נחליט להוריד את קצב הדגימה פי 10, אז הוקטורים החדשים יהיו קצרים פי 10 מהוקטורים המקוריים, ובכל בין של הוקטורים החדשים ישב ממוצע של עשרה ערכים רצופים מהוקטור המקורי. מבחינה ויזואלית אנחנו נראה כי העקום של הדאטה הוא "חלק" יותר לאחר הורדת קצב הדגימה. נחזור לדוגמא של המתלב: יש לנו דאטה שנמדד ב הרץ ואנחנו רוצים לעשות down sampling ל- 100 הרץ. מספר הדגימות שהיו בוקטור הדאטה המקורי length(ecg);%% nsamples = ערך התדירות שאנחנו רוצים %% ;100 = freq חישוב של כמות הבינים שיש לקבץ בהורדת הקצב (sampling_rate/freq);%% samp = round הורדת קצב הדגימה יעשה בלולאה, שרצה של הערכים של הוקטורים החדשים )שהם ה- down :)sampled i=0 for start_ind = 1:samp: (nsamples-samp+1) הלולאה תרוץ מ- 1 ועד 991, בקפיצות של 10. הסיבה היא שזה עד 991, היא שלא יווצר מצב בו נצטרך לרוץ על איברים מחוץ לוקטורים המקוריים. i=i+1; -90-

91 ECG_downsampled (i) = mean (ecg(start_ind:start_ind+samp-1); מכניסים לתוך ה- ECG שהוא down sampled באיבר ה- i, את הממוצע של עשרת האיברים העוקבים בוקטור,ecg שמתחילים ב- start_ind )שתואם לאינדקס בוקטור המטרה( ומסתיים עשרה איברים אחר כך. האיטרציה הבאה של הלולאה היא כאשר start_ind גדל ב- 10. לכן האיבר הבא בוקטור המטרה יהיה ממוצע של עשרת האיברים העוקבים ב- ecg. הוא יכנס לתוך האיבר השני ב- ECG,downsample זה משום שהאינדקס שלו הוא i, אשר גדל כל פעם באחד בתוך הלולאה. time_downsampled (i) = mean (time(start_ind:start_ind-1); מהו קצב הדגימה הטוב ביותר? משפט הדגימה אומר כי אם יש אות בקצב מסוים, ורוצים לקבל את הסיגנל )כך שגם נראה אותו וגם לא נדגום דאטה מיותר( קצב הדגימה המומלץ הוא כפול. למשל, אם יש פעימות לב בקצב של 3 הרץ, כדאי למדוד ב- 6 הרץ. ניתן לראות זאת בדוגמא הבאה: כאן הקצב הוא 3 הרץ ומדדנו ב- 3 הרץ. ראינו רק את הפיקים, ופיספסנו את העובדה כי היו ירידות ועליות. פה מדדנו בקצב של 3/f*4, זה לא קצב כפול, הוא יותר גדול מקצב הסיגנל )זה למדוד ב- 4 הרץ כאשר הסיגנל הוא ב- 3 הרץ(. ניתן לראות איך לא קיבלנו דאטה שנראה כמו הדאטה המקורי. -91-

92 פה ניתן לראות מה קרה כאשר מדדנו בקצב כפול מהסיגנל )למעשה רואים את כל המחזור של הגל(: הדבר הזה הוא נכון לכל סוג של דאטה- גם אם הוא מחזורי וגם אם הוא לא )כי ניתן למעשה לקרב דאטה לא מחזורי לדאטה מחזורי סינוסידיאלי(. תדר נייקוויסט: התדר המקסימלי שנוכל לשחזר אם אנו מודדים בקצב דגימה מסוים. כלומר אם מדדנו ב- 6 הרץ, נוכל לשחזר דאטה ב- 3 הרץ. הוא שווה למחצית מקצב הדגימה. ממוצע רץ: כאמור אות הוא אנלוגי, ואנחנו הופכים אותם לדיגיטלי. אחד השימושים של ממוצע רץ הוא לתקן את השגיאה שנוצרת בעת דיגיטיזציה של אות אנלוגי. )כאשר הופכים אות רציף לבדיד, הקפיצות בין bin ל- bin הופכות להיות חדות, ומכניסות רעש לתוך האות שלנו. ממוצע רץ מפחית מהרעש הזה "ומחליקות" את הסיגנל הנמדד כך שהוא קרוב יותר לסיגנל האמיתי(. נמשיך עם הדוגמא של ecg התלוי בזמן. לכל אחד מהוקטורים האלו יש 1000 בינים, שכל בין מייצג מדידה אחת. אנחנו רוצים להפחית מכל מדידה את הממוצע של 2L איברים הצמודים אליו. נניח הוקטור הוא כך: ואנחנו רוצים להפחית מכל איבר ממוצע המורכב מ- 3 האיברים מלפניו ואחריו )כלומר 6=2L(. אז מהאיבר ה- i נרצה להפחית ממוצע המורכב מהמספרים i-l ועד i+l )נניח נסתכל על האיבר העשירי. כדי לנקות אותו נחשב ממוצע שמתחיל מהאיבר השביעי, ומסתיים באיבר ה- 13, ואז נפחית מהאיבר העשירי את הממוצע הזה(. הבעיות הם בקצוות, כאשר 1=i, אז האינדקס i-l הוא שלילי, ולכן האיברים האלו לא קיימים. הפתרון הוא לקבוע שהאינדקס השמאלי יהיה או ה- i-l או 1 )המקסימלי ביניהם(. כך יוצא שכל פעם ש- i-l הוא שלילי, המיצוע יתחיל מהאיבר הראשון, ועד.i+L -92-

93 לשים לב שזה מבלבל, כי הפקודה max משמשת למציאת האינדקס המינימלי: min_i = max(i-l, 1) על אותו הרעיון בונים את האינדקס המקסימלי: max_i = min (i+l, length(ecg)) חזרה לקוד: זה החלטה שלנו. זה אומר מה יהיה כמות האיברים בממוצע smoothing_window=101; %% וקטור הממוצעים%% length(ecg)); smoothed_ecg = zeros (1, זהו גודל "החלון"/"כנף"%% -1)/2; (smoothing_window L = for i = 1:length(ecg) min_i = max(i-l,1) max_i= min (i+l, length(ecg)); smoothed_ecg(i) = mean (ecg (min_i, max_i) ); הגודל של ה- ECG smoothed יהיה כמו הגודל של.ecg בכל איבר שלו יהיה את הממוצע הרץ. אם נשרטט את שני הוקטורים האלו על פני הזמן באותו הגרף, נוכל לראות כי הצורה של העקומים היא דומה, אבל העקום שנוצר מוקטור הממוצעים הרצים הוא "חלק" יותר ונמוך יותר באמפליטודות שלו. זה נקרא low pass filter וזה משום שהתדרים הגבוהים לא עוברים את הפילטר ואילו הנמוכים כן. כך עושים למעשה "ניקוי" של התדרים הגבוהים. איך נדע מה עבר? אם הדאטה המקורי היה ב הרץ, והחלון הוא ב- 100 הרץ, אז כל מה שנמוך מ- 10 הרץ יכנס:.1000/100=10Hz אם נעשה חלון של 10 הרץ, אז מה שיכנס הוא מה שמתחת ל- 100 הרץ )100=1000/10(. -93-

94 כדי לקחת את התדרים הגבוהים, צריך להפחית את הוקטור ממוצעים רצים מוקטור הדאטה המקורי. זה.high pass filter שם למעשה "ננקה" את התדרים הנמוכים, ונראה רק את התדרים הגבוהים. כדי לקחת בחשבון תדרים גבוהים, צריך להקטין את החלון פתרון בעיות סיווג באמצעות רגרסיה: נתחיל לראות את הנתונים. יש לנו וקטור כניסה P, ווקטור כניסה T, והסיווג של הערכים הוא בוקטור y )הוא קובע האם הם שייכים לקבוצה אחת שמסומנת ב- 1, או לקבוצה אחרת שמסומנת ב- 1 -(. scatter (P(y==1), T(y==1), 'r'); hold on scatter (P(y==-1), T(y==-1), 'b')) למעשה עשינו פה שימוש באינדקסים לוגים כדי לבחור את שתי הקבוצות ב- P וב- T. נתחיל בדוגמא פשוטה בה המסווג הוא קו ישר. שלב ראשון הוא להגדיר את מטריצת הכניסות והיציאות )במטריצת הכניסות X, כל שורה היא משתנה כניסה אחר, ואם צריך יש שורת אחדות, ומטריצת היציאות Y היא כפי שקיבלנו בבעיה(. לאחר מכן צריך למצוא את וקטור הערכים האופטימלים של Aשל פי הפתרון האנליטי שדיברנו עליו ( inv(x*x'),)yx' * ואז להגדיר את yhat באופן הבא: )שזה כמו yhat = a1x1+a2x2 (AX פה הערכים של yhat לא יהיו ±1 אלא ערכים רציפים. בשלב הבא נעשה עליהם סיווג, ונקבע האם הם שייכים לקבוצה הראשונה )שמסומנת ב- 1 ( או לקבוצה השנייה )שמסומנת ב- 1 -(. נעשה זאת על ידי הפונקציה sign שתעבור על הערכים של.yhat אם נרצה לשרטט את קו הסיווג זה יהיה כך: )צריך להגדיר לשם כך את הנקודות שעליהם נעשה :)Plot בחרנו על סמך השרטוט של הנתונים%% ;[2:2-] = x1_plot המשתנה הזה הוא פונקציה של הראשון על פי הנוסחא:%% [-A(1)*x1_plot)/A(2)]; x2_plot = -94-

95 x2 = - a1/a2 * x1 plot (x1_plot, x2_plot, 'k'); נעבור לבעיות אחרות בהם יש לנו כמה מדדים של כניסות ואנחנו רוצים לסווג באמצעות חלק מהם סט של נתונים. נניח רוצים לאבחן אלצהיימר, והמדדים לרשותנו הם ADAS_cog,.MMSE, QSM, qeeg אנחנו מעוניינים לעשות סיווג באמצעות זוג מדדים שיתן את הסיווג האופטימלי. אם נרצה לעבור על כל הזוגות האפשריים, אפשר לעשות לולאה קנונית וכך לעבור על כל הסטים הקיימים של הזוגות. לאחר מכן לעשות סיווג באמצעות התאמת עקום ולמצוא את הסט שיתן את השגיאה המינימלית. choosex = [QSM; qeeg; ADAS_cog; MMSE] ; y= -1 +2*AD; השורה הזו הופכת לנו את הערכים ב- AD להיות 1 או מינוס 1. צריך להגדיר את הטעות הכי טובה בהתחלה כי בהמשך נשתמש בה%%; best_err=inf for i= 1:4 for j=1:4 מטריצת הכניסות%% :)]; choosex(j, X = [choosex(i, :) ; A = y*x' *inv(x*x'); yhat = sign (A*X); tmp_err = mean (yhat ~=y); if tmp_err < best_err best_err = tmp_err; best_i=i; best_j=j; אפשר לראות כי יהיו מצבים בהם i=j ואז במטריצת הכניסות יהיו לעיתים את אותו המסווג פעמיים. אבל מסיבה מסוימת זה לא משנה את התוצאה. זה רק עושה את הקוד פחות יעיל וגורם לנו לעבור על פתרונות מיותרים. -95-

96 כדי לשרטט את הפתרון: firstx = choosex(best_i, :); secondx = choosex(best_j, :); scatter (firstx(ad==1), secondx(ad==1), 'r') hold on scatter (firstx(ad==0), second(ad==0), 'b') נעבור לדבר על סוגי טעויות. יש שני סוגי טעויות לכל בעיית סיווג: ערכים שהיו צריכים להיות 1 וסווגו מינוס 1, וערכים שהיו צריכים להיות מינוס 1 וסווגו 1. יש מקרים בהם טעות אחת היא יותר חמורה מהשנייה, ולכן אנחנו רוצים להתחשב בה יותר מאשר בטעות השנייה. כדי לקבוע את המשקל של כל טעות נשתמש בפרמטר אלפא, שהוא בין 0 ל- 1. כאשר הוא קרוב יותר ל- 1, אז הוא יתן יותר משקל לטעות הראשונה, וכאשר הוא קרוב ל- 0 הוא יתן יותר משקל לטעות השנייה: err = alpha*f1 + (1-alpha)*f2 ניקח דוגמא בה מסווגים חולים בתור "יש מחלה" ו"אין מחלה". אם כך, טעות בקבוצה אחת היא להגיד כי יש מחלה למרות שאין. זה נקרא,false positive או.type 1 error טעות בקבוצה השנייה היא להגיד כי אין מחלה למרות שיש. זה נקרא,false negative או.type 2 error נכתוב פונקציה שמתחשבת בסוגי הטעויות בעת בחירת המודל, בהינתן כניסה אחת, יציאה אחת, מודל אופטימלי, ואלפא: function error = calcerr (x, y, A, alpha) yhat = sign(a*x); err1 = mean (yhat == 1 & y==-1); err2 = mean (yhat ==-1 &y==1); error = alpha*err1 +(1-alpha)*err2; -96-

97 כדי לראות את ההשפעה של בחירת המדדים על השגיאות אפשר לשרטט את גודל השגיאה כקומבינציה של המסווגים בפקודת imagesc )זה כמובן אם שמרנו את השגיאות עבור כל סט של בדיקות(. כך תיווצר לנו מעין תמונת חום של השגיאה, והאזורים בכחול הכהה ביותר זה איפה שהשגיאה המינימלית )כמובן שהמטריצת תמונה שתתקבל היא סימטרית, כי.)i,j=j,i ניתן גם לראות שאם נשנה את אלפא, כך שינתן משקל גבוה יותר לסוג אחר של שגיאה, המטריצה תשתנה עיבוד אותות-המשך: אותות יכולים להיות בדידים ורציפים. עד כה ראינו אותות התלויים בזמן, אולם יש גם אותות התלויים בתדר. אות שמשתנה בתדר הוא הצגה שונה של האות המשתנה בזמן, מבחינת הגדרה אות תלוי בזמן. כדי לייצג אותו לפי תדרים, צריך לפרק אותו לתדרים ממנו הוא בנוי. ניתן לעשות זאת אם מפרקים את האות לפונקציות סינוס מחזוריות רבות בעלות תדרים שונים. תזכורת לגבי פונקצית סינוס: נתון מעגל בעל רדיוס 1. יוצא ממנו רדיוס שנמצא בזוית אלפא על הכיוון החיובי של ציר ה- x. ההיטל של הרדיוס על ציר ה- y הוא סינוס הזוית אלפא )זה האנך שיורד מנקודת החיתוך אל ציר ה- x (. אילו אותו קו שיוצר את אלפא היה נע על פי זמן t, היה אפשר לתאר את מיקומו כתלות ב- t, והיינו מוצאים כי זו פונקציה מחזורית הנראית כך: האמפליטודה של הפונקציה היא הגובה המקסימלי אליו היא מגיעה )פה זה 1(. זה לא ההבדל בין הנקודת מינימום למקסימום. -97-

98 במתלב הפונקציות הטריגונומטריות הם על רדיאנים ולא זויות. פונקצית הסינוס היא: Asin(2πft + φ) האמפליטודה היא A, התדר הוא f )זה כמה מחזורים יש בשנייה, זה ביחידות של הרץ. הוא שווה ל-זמן מחזור/ 1 (, הפאזה היא φ. הפאזה אומרת באיזה נקודה אנחנו מתחילים. כאשר ה- 0 = φ, זו הפונקציה הרגילה של סינוס המוכרת לנו, כאשר החיתוך עם ציר ה- y הוא בראשית הצירים. אבל אם היינו מתחילים את העלייה לא בראשית הצירים, אלא יותר ימינה או שמאלה על ציר ה- x, אז הייתה פאזה שונה מאפס. )כדי לדמיין מה יקרה, צריך להזיז את מערכת הצירים ב- φ ; נניח שהוא שווה ל- 1/2, אז כל מערכת הצירים תזוז חצי ימינה. אם הוא שווה ל- 1/2 -, אז כל מערכת הצירים תזוז 1/2 שמאלה(. *כדי להפוך פונקציה סינוס לקוסינוס, אפשר לעשות את הפאזה ל- π/2. ציור פונקצית סינוס במתלב: צריך קודם להגדיר את הפרמטרים של הפונקציה: f=1; phi=0; t= 0:0.01:1; for A=1:5 wave = A*sin (f*t*2*pi + phi); plot(t, wave)l נשים לב כי A אינו פרמטר כרגע אלא משתנה )בהתאם לאיטרציות של הלולאה(. אפשר לשנות את הקוד, כך ש- A יהיה קבוע, והתדר ישתנה בלולאה, וכנ"ל לגבי הפי )פאזה(. ישנה דרך להיפטר מהפאזה בעת הייצוג של פונקצית הסינוס, על ידי שימוש בזהות טריגונומטרית )היה בהרצאה(. נקבל כי: Asin(2πft + φ) = Acos(φ) sin(2πft) + Asin(φ)cos (2πft) -98-

99 ואם נגדיר כי: Acos(φ) = B ו- C, Asin(φ) = נוכל לקבל פונקצית סינוס המיוצגת באמצעות חיבור פונקציה סינוס ופונקציה קוסינוס, אשר בשתיהן הפאזה היא 0, ומתקיים קשר בין האמפליטודות שלהם כך ש:.A 2 =B 2 + C 2 חיבור פונקציות סינוס בתדרים שונים: n g(t) = A(f) sin(2πft + φ(f)) f=0 הפונקציה g היא פונקציה המורכבת מסכימה של פונקציות סינוס שונות, שלכל אחת תדר שונה, אמפליטודה שונה ופאזה שונה )גם האמפליטודה וגם הפאזה תלוית ב- f (. חיבור של פונקציות סינוס בעלות תכונות )תדר, פאזה ואמפליטודה( שונות מאפשר לנו ליצור את כל הפונקציות שאנחנו רוצים- גם פונקציות לא מחזוריות. מפה עולה כי ניתן לייצג את האות a גם בזמן וגם בתדר. כאשר הוקטורים,f A and phi הם בדידים, אז כדי לקבל את g(t) סכמנו אותם. אבל במידה והם יהיו רציפים, במקום לסכום אותם נעשה עליהם אינטגרל כדי לקבל את g )בעצם האות הוא בדיד תמיד, כי הוא נמדד ככה, אבל בחישוב אינטגרל, האות נהיה רציף כי אנחנו למעשה לוקחים בחשבון גם נקודות שלא דגמנו על ידי חישוב של השטח( : fmax g(t) = A(f) sin(2πft + φ(f)) df 0 *צריך לשים לב כי הסכימה פה היא לא של ערכים או מספרים, אלא של פונקציות. וכדי שכל פונקציה תקבל את המשקל שהיא צריכה לקבל, מכפילים את הפונקציה שסוכמים ב- df, שזה המידה בה התדר משתנה )זה מתקשר למלבן שדובר עליו בהרצאה(. -99-

100 נכתוב פונקציה שמשחזרת את האות מתוך מרכיבי התדר שלו )דהיינו צריך לקבל את ה-( g(t מתוך הערכים של phi(f) :) f, A(f), מהם הקלטים של הפונקציה? מרכיבי התדר כוללים וקטור של אמפליטודות ו-וקטור של פאזות, וגם וקטור התדרים שהאמפליטודות והפאזות מתייחסות אליהם. מאחר והאות המקורי תלוי בזמן, יהיה לנו גם וקטור של זמן. function sig = freq2time (A, phi, f, t) המשתנה הזה מתחיל באפס, אבל החל מהאיטרציה הראשונה של הלולאה הוא יהיה מערך%%; 0 = sig df= f(2)-f(1); for i=1:length(f) sig = sig + A(i)*sin (2*pi*f*t +phi(i))*df ניתוח אותות בזמן ובמרחב-המשך: דיברנו על אות שתלוי בזמן שניתן לפרק אותו לפונקציות סינוס וקוסינוס: Fmax F(t) = [B f sin(2πft) + C f cos(2πft)] f=0 למעשה אפשר להתחיל את הסכום על הסינוס מ- 1, כי סינוס של אפס הוא אפס, ולכן הוא אינו תורם לסכום. לעומת זאת לקוסינוס הוא כן תורם כי קוסינוס אפס הוא 1. נדבר על מקרה פרטי של אותו אות: F1(t) = sin(2π 2 t) cos(2π 50t) B(f) = { B(2) = 1 = 0.2 } ; C(f) = {C(50) else = 0 else = 0 } -100-

101 אם היינו מציירים אותה היינו רואים פונקציה מחזורית בה יש תדר נמוך ולו אמפליטודה גדולה )2 מחזורים בשנייה עם אמפליטודה אחת( ותדר נוסף גבוה עם אמפליטודה קטנה )50 מחזורים בשנייה עם אמפליטודה 0.2(. עכשיו כדי למצוא את הפונקציות B(f) ו-( C(f ניתן לעשות טרנספורם פורייה: 1 B(f) = 2 F1(t)sin (2πft)dt 0 1 = 2 sin(2π2t) sin(2πft) dt cos(2π50t) sin(2πft) dt החלק של ה- cos*sin יתאפס, משום ש- f=2 וה- cos מתאפס בחלק זה )ע"פ מה שהגדרנו את ה- C(, והחלק של הסינוס בריבוע ישאר ואם נשרטט אותו הוא יראה כך )העקום האדום זה הגרף והאינטגרל זה החלק השחור( -101-