שְׁאֵלָה:
ממוצע של חלון הזזה ב- R
T-Burns
2010-09-24 19:41:32 UTC
view on stackexchange narkive permalink

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

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

  4, 5, 7, 3, 9, 8  

גודל חלון של 3 ושקופית של 2 יעשו את הפעולות הבאות:

  ( 4 + 5 + 7) / 3 = 5.33 (7 + 3 + 9) / 3 = 6.33 (9 + 8) / 3 = 5.67  

והחזר וקטור מהערכים הבאים:

  5.33, 6.33, 5.67  

האם יש פונקציה פשוטה שתעשה זאת עבורי? אם הוא גם יחזיר את מדדי החלון זה יהיה בונוס נוסף. בדוגמה זו זה יהיה 1,3,5

האם ראית את [זה] (http://rss.acs.unt.edu/Rdoc/library/TTR/html/MovingAverages.html)?
אתה יכול לתת קצת רקע על הרעיון "שקופית" הזה?
@J.M - לא הייתי! תודה! אני עומד לראות איך זה עובד.
@Shane - כן! אני מצטער שלא היה ברור. השקופית היא מספר המיקומים / המדדים שאתה מעביר כדי להתחיל לחשב את חלון הממוצעים הבא. אז במקום שהחלון הבא יתחיל אחרי סוף האחרון יש חפיפה כלשהי כאשר השקופית קטנה מגודל החלון שלך. הרעיון הוא להחליק מעט את נקודות הנתונים.
תודה, הייתה לי אותה שאלה. עכשיו, מצאתי שזה שימושי בפונקציה "rollapply".
שבע תשובות:
#1
+25
Gavin Simpson
2010-09-24 20:36:42 UTC
view on stackexchange narkive permalink

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

  > require (zoo) > TS <- zoo (c (4, 5, 7, 3, 9, 8)) > rollapply (TS, width = 3, by = 2, FUN = mean, align = "left") 1 3 5.333333 6.333333  

זה פשוט לא יחשב את הערך האחרון עבורך מכיוון שהוא אינו מכיל 3 תצפיות. אולי זה יספיק לבעיה האמיתית שלך? כמו כן, שים לב שהאובייקט שהוחזר מכיל את המדדים שאתה רוצה כ שמות קוד> של הווקטור שהוחזר.

הדוגמה שלך מניחה שיש בחלון האחרון 0 שלא נצפה. . זה יכול להיות שימושי או מציאותי יותר לרפד עם NA כדי לייצג את המידע החסר ולהגיד ל- mean לטפל בערכים חסרים. במקרה זה יהיה לנו (8 + 9) / 2 כערך החלון הסופי שלנו.

  > TS <- zoo (c (4, 5, 7, 3, 9, 8, NA )) > rollapply (TS, width = 3, by = 2, FUN = mean, na.rm = TRUE, align = "left") 1 3 5 5.333333 6.333333 8.500000  
BTW, כתבתי פעם על שימוש בפונקציה זו ליישום המושג "לס קוונטי": http://www.r-statistics.com/2010/04/quantile-loess-combining-a-moving-quantile-window -עם-לס-פונקציה /
אתה יכול להוסיף 0 בסוף x (`x <-c (x, 0)`) כדי לקבל את האלמנט האחרון של התשובה.
@mbq; ההנחה היא כי התצפית היא 0. הייתי שוקל את הנקודה הזו ו- T-Burns מניח את אותה ההנחה (0 ללא הבחנה). הייתי מעדיף אולי לרפד עם NA ולהעביר את הטיעון 'na.rm = TRUE' ל'מתכוון '. התשובה לא תהיה זהה למה שה- OP ביקשה, אך נראה שהיא שימושית יותר. אני אערוך את תשובתי כדי לכלול זאת.
@ucfagls אולם קל לשנות זאת וכפי שאמרת הנחה זו הונחתה על ידי ה- OP. מצד שני, הייתי מגביל עוד יותר ומסיר את הממוצע האחרון.
תודה! במיוחד לציין את הערך האחרון כהנחה אפסית, לא שקלתי את זה. בהחלט אכפת לי מהחלון האחרון הזה !!
#2
+14
r_evolutionist
2014-04-08 19:08:56 UTC
view on stackexchange narkive permalink

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

הפונקציה הבאה מהירה במיוחד.

  data <- c (runif (100000, min = 0, max = .1), runif (100000, min =. 05, max = .1), runif (10000, min = .05, max = 1), runif (100000, min = 0, max = .2)) slideFunct <- פונקציה (נתונים, חלון, שלב) {total < - אורך (נתונים) כתמים <- seq (מ = 1, ל- = (חלון כולל), לפי = שלב) תוצאה <- וקטור (אורך = אורך (נקודות)) עבור (אני ב 1: אורך (נקודות)) { תוצאה [i] <- ממוצע (נתונים [כתמים [i] :( כתמים [i] + חלון)])} החזר (תוצאה)}  

http: // coleoguy .blogspot.com / 2014/04 / sliding-window-analysis.html

די מועיל.אך שים לב, כי חלון = 3 יחזיר את הממוצע של 4 (!) ערכים, אלא אם כן תוסיף '-1' (לטווח) ו- '+ 1' (לולאה).
בדיוק כרמז, פונקציה זו אינה מהירה כפי שניתן היה לצפות: שיניתי אותה כדי לחשב חציון במקום הממוצע והשתמשתי בו לנתוני נתונים של 17 מיליון שורות בגודל חלון של 3600 (שלב = 1).זה לקח 25 דקות להשלים.בנוסף כתבתי תוכנית Go לאותה משימה והיא הסתיימה תוך 21 שניות.אבל הבעיה היא לא השפה, אלא האלגוריתם.עבור אלגוריתם זה, יש חשיבות קריטית לגודל החלון.אני חושב שהאפשרויות מחבילת TTR הן אופציה הרבה יותר טובה אם אתה מחפש חישוב ממוצע נע פשוט (עיין בתשובות האחרות).
#3
+5
user1414
2010-09-24 20:27:14 UTC
view on stackexchange narkive permalink

שורת קוד פשוטה זו עושה את הדבר:

  ((c (x, 0,0) + c (0, x, 0) + c (0,0, x) ) / 3) [3: (אורך (x) -1)]  

אם x הוא הווקטור המדובר.

זה לא מחזיר את מה ששואל רצה, אלא 5.33 5.00 6.33. עם זאת, זה נראה די מעניין. אתה יכול להסביר את הרעיון שלך, כי אני לא מבין אותו.
@Henric אני משתמש בתכסיס זה לעיתים קרובות, ובכל זאת קוד user1414 מחזיר את הגליל הזה עם שקופית 1, ולא 2, כמתוכנן על ידי OP. בדוק '(c (0,0, x) + c (0, x, 0) + c (x, 0,0)) / 3' כדי לראות למה אני מתכוון (ואיך זה עובד). הנוסחה המתאימה תהיה: `(c (0,0, x) + c (0, x, 0) + c (x, 0,0)) [1: (אורך (x) -3) * 2 + 1 ] / 3 '(עלינו לחתוך 0 ריפוד בהתחלה ולבחור אז אפילו אלמנטים.
#4
+4
RockScience
2010-10-21 14:17:02 UTC
view on stackexchange narkive permalink
  ספרייה (גן חיות) x = c (4, 5, 7, 3, 9, 8) rollmean (x, 3)  

או

  ספרייה (TTR) x = c (4, 5, 7, 3, 9, 8) SMA (x, 3)  
האם זה עובד עבור מטריצות דו ממדיות? כמו איך? אם גודל החלון הוא 3 * 3 כדוגמה
זה רק כיוון אחד
#5
+3
shabbychef
2010-09-25 10:51:59 UTC
view on stackexchange narkive permalink

אני יכול לעשות זאת בקלות ב- Matlab ובברווז בזמן שאתה מצביע עלי:

 % נתון וקטור x, גודל חלון, שקופית idx1 = 1: שקופית: מספר (x); idx2 = דקה ( מספרים (x) + 1, idx1 + גודל חלון); % sic ב- +1 כאן ולא -1; cx = [0; cumsum (x (:))]; % רפד אפס, בצע סכום מצטבר; rv = (cx (idx2) - cx (idx1)) / windowsize; % טאדה! התשובה!  

כתופעת לוואי, idx1 הוא האינדקס של האלמנט בסכום. אני בטוח שאפשר לתרגם את זה בקלות ל- R. האידיום ראשון: דלג: אחרון ב- Matlab נותן למערך ראשון, ראשון + דלג, ראשון + 2 ספינת, ..., דלג ראשון + n האלמנט האחרון במערך אינו גדול מ- אחרון קוד>.

עריכה : השמטתי את החלק הממוצע (חלקי גודל חלון ).

+1 לא טאדה, rv / windowsize ;-)
תיבת ההערות השולית ... צרה מדי עבור הקוד הזה, אז פרסמתי תשובה חדשה.
תודה, אבל MATLAB לא בחינם !!
אוקטבת @T-Burns: היא בחינם, עם זאת; גם R קרוב מספיק ל- Matlab כדי שניתן יהיה לתרגם את הקוד הזה בקלות. למעשה, @mbq עשה את זה ..
#6
+3
user88
2010-09-25 13:31:03 UTC
view on stackexchange narkive permalink

התשובה של shabbychef ב- R:

  slideMean<-function (x, windowsize = 3, slide = 2) {idx1<-seq (1, אורך (x) , על ידי = שקופית); idx1 + windowsize->idx2; idx2 [idx2> (אורך (x) +1)] <- אורך (x) +1; c (0, cumsum (x)) - >cx; return ((cx [idx2] -cx [idx1]) / windowsize);}  

EDIT: המדדים שאתה מחפש הם רק idx1 ... ניתן לשנות פונקציה זו בקלות כדי להחזיר אותם גם, אך כמעט באותה מידה ליצור אותם מחדש עם שיחה נוספת ל seq (1, length (x), by = slide) .

תודה על התרגום. חשבתי שזה יהיה תרגיל קל, ולמדתי ממנו קצת R
התשובה המעודכנת שלי היא שימוש `from :: running_mean` מגרסת ה- edge edge של [from package] שלי (https://github.com/shabbychef/fromo/tree/dev).
#7
+1
Matt Parker
2010-09-24 21:40:33 UTC
view on stackexchange narkive permalink

זה יביא לך את אמצעי החלון ואת האינדקס של הערך הראשון של החלון:

  # datax <- c (4, 5, 7, 3, 9, 8) # הגדר גודל חלון ו- slidewin.size <- 3slide <- 2 # הגדר את טבלת התוצאות תוצאות <- data.frame (index = numeric (), win.mean = numeric ()) # i מוסיף ערך ראשון לחלון (אדן?) i <- 1 # j מאנדקס את שורת התוצאות שנוספו nextj <- 1 while (i < אורך (x)) {# פירוש הדבר משמר את המכנה של 3 win. כלומר <- סכום (x [ i: (i + 2)], na.rm = TRUE) / win.size # הכנס את תוצאות התוצאות [j,] <- c (i, win.mean) # הגדל את המדדים למעבר הבא i <- i + שקופית j <- j + 1}  

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

אנא אל תצביעו מטה מבלי לספק תגובה. איך אני אמור לדעת מה לא בסדר?
לא הייתי אני, אבל זה איטי (אבל לא הרבה יותר איטי מ- 'rollapply').
גם אני לא הייתי, אך כאמור בעצמך, הקצאה מראש של אובייקט התוצאה תעזור לנושא המהירות. טריק אחד, אם אתה לא יודע, או שהוא מייגע / קשה לקבוע, את גודל אובייקט התוצאה שאתה צריך. הקצה משהו סביר, אולי מילוי מראש עם NA. לאחר מכן מלא עם הלולאה שלך, אך הוסף בדיקה שאם אתה מתקרב לגבול האובייקט שהוקצב מראש, הקצה עוד נתח גדול והמשיך במילוי.
@mbq; מהירות התוצאות, למרות שהיא חשובה, אינה השיקול היחיד. במקום שיהיה צורך להמציא את הזמן מחדש ולהתמודד עם כל האינדקסים וכד 'בפתרונות המותאמים אישית, הקו אחד-ליניארי שהוא' גליל 'הוא הרבה יותר קל להבין ולכוון את הכוונה. כמו כן, סביר להניח של'החלפה 'היו הרבה יותר גלגלי עיניים בודקים את הקוד שלה מאשר משהו שאוכל לבשל אחר הצהריים. סוסים לקורסים.
ucfagls, תודה שהוספת מידע על הקצאה מראש כשאינך יודע את הגודל האולטימטיבי של האובייקט - זה מועיל. ובעוד אני מסכים ש- rollapply הוא כנראה כמעט בהחלט הדרך, אני א) רציתי לספק דוגמה שתחשב את מקרי הקצה בפחות משלושה ערכים, ו- b) רק רציתי להשתמש ב- while (), אשר אני עדיין אין לך שימוש ב;)
שינוי '[i: (i + 2)]' ל- '[i: (i + win.size-1)]' יהפוך את הקוד לכללי יותר, אני חושב.


שאלה ותשובה זו תורגמה אוטומטית מהשפה האנגלית.התוכן המקורי זמין ב- stackexchange, ואנו מודים לו על רישיון cc by-sa 2.0 עליו הוא מופץ.
Loading...