গোষ্ঠী ফাংশন (আলিঙ্গন করে, সমষ্টিগত) এবং * পরিবার প্রয়োগ করুন


1040

আমি যখনই আর-তে কিছু "মানচিত্র" পাই করতে চাই, আমি সাধারণত applyপরিবারে কোনও ফাংশন ব্যবহার করার চেষ্টা করি ।

যাইহোক, আমি তাদের মধ্যে পার্থক্যগুলি কখনই বুঝতে পারি নি - কীভাবে { sapply, lapplyইত্যাদি} ইনপুট / গ্রুপযুক্ত ইনপুটটিতে ফাংশনটি প্রয়োগ করে, আউটপুটটি কেমন হবে, এমনকি ইনপুটটি কী হতে পারে - তাই আমি প্রায়শই আমি যা চাই তা না পাওয়া পর্যন্ত কেবল তাদের সকলের মধ্য দিয়ে চলুন।

কেউ কখন কী ব্যবহার করবেন তা ব্যাখ্যা করতে পারেন?

আমার বর্তমান (সম্ভবত ভুল / অসম্পূর্ণ) বোঝাপড়াটি হ'ল ...

  1. sapply(vec, f): ইনপুট একটি ভেক্টর। আউটপুট হ'ল ভেক্টর / ম্যাট্রিক্স, যেখানে উপাদানটি iথাকে f(vec[i]), fএকটি মাল্টি-এলিমেন্ট আউটপুট থাকলে আপনাকে ম্যাট্রিক্স দেয়

  2. lapply(vec, f): হিসাবে একই sapply, কিন্তু আউটপুট একটি তালিকা?

  3. apply(matrix, 1/2, f): ইনপুট একটি ম্যাট্রিক্স। আউটপুট একটি ভেক্টর, যেখানে উপাদান iচ (ম্যাট্রিক্সের সারি / কর্ন i) হয়
  4. tapply(vector, grouping, f): আউটপুট একটি ম্যাট্রিক্স / অ্যারে, যেখানে ম্যাট্রিক্স / অ্যারেতে থাকা একটি উপাদানটি ভেক্টরের fএকটি গ্রুপিংয়ের মান হয় এবং সারি / কর্নেল নামগুলিতে ঠেলে যায়gg
  5. by(dataframe, grouping, f): gএকটি গ্রুপিং করা যাক । fগ্রুপ / ডাটাফ্রেমের প্রতিটি কলামে প্রয়োগ করুন । fপ্রতিটি কলামে গোষ্ঠীকরণের মান এবং মানটি প্রিন্ট করুন ।
  6. aggregate(matrix, grouping, f): এর মতো by, তবে আউটপুট প্রিন্ট করার পরিবর্তে, সামগ্রিকভাবে সমস্ত কিছু একটি ডেটা ফ্রেমে স্টিক করে।

পার্শ্ব প্রশ্ন: আমি এখনও প্লাইর বা পুনরায় আকার শিখি নি - এই সমস্তগুলি পুরোপুরি প্রতিস্থাপন করব plyrবা করব reshape?


33
আপনার পার্শ্ব প্রশ্নে: অনেক কিছুর জন্য প্লেয়ার হ'ল সরাসরি প্রতিস্থাপন *apply()এবং by। প্লাইয়ার (কমপক্ষে আমার কাছে) অনেক বেশি সুসংগত মনে হয় যা আমি সর্বদা জানি যে এটি কোন ডেটা ফর্ম্যাটটি প্রত্যাশা করে এবং ঠিক কী তা ছুঁড়ে দেয়। যা আমাকে অনেক ঝামেলা বাঁচায়।
জেডি লং

12
এছাড়াও, আমি যুক্ত করার পরামর্শ দেব: doByএবং এর নির্বাচন এবং এর ক্ষমতা প্রয়োগ করুন data.table
ইটরেটর

7
sapplyঠিক হয় lapplyযোগে সঙ্গে simplify2arrayআউটপুট উপর। applyপারমাণবিক ভেক্টরকে বাধ্য করে, তবে আউটপুট ভেক্টর বা তালিকা হতে পারে। byডেটাফ্রেমগুলি উপ-ডেটাফ্রেমে বিভক্ত করে, তবে এটি fকলামগুলিতে পৃথকভাবে ব্যবহার করে না । কেবলমাত্র 'ডাটা.ফ্রেম'-শ্রেণীর জন্য কোনও পদ্ধতি থাকলে fকলাম অনুসারে প্রয়োগ হতে পারে byaggregateজেনেরিক তাই প্রথম যুক্তির বিভিন্ন শ্রেণীর জন্য বিভিন্ন পদ্ধতি বিদ্যমান methods
আইআরটিএফএম

8
স্মৃতিভিত্তিক: l 'তালিকার জন্য', s 'সরলকরণের জন্য', টি 'টাইপ প্রতি টাইপ' এর জন্য (গ্রুপিংয়ের প্রতিটি স্তর একটি প্রকারের জন্য)
লুটজ প্রেশেল্ট

প্যাকেজ রাফস্টে কিছু ফাংশন রয়েছে, যেমন: প্রতিটিকোল.এপ্লি, অ্যাপলিকেশন শর্ত এবং আরও অনেক কিছু যা আর এর সমতুল্যর চেয়ে দ্রুত
স্টেফানোস

উত্তর:


1330

আর এর অনেকগুলি * প্রয়োগের ফাংশন রয়েছে যা সহায়তা ফাইলগুলিতে (উদাহরণস্বরূপ ?apply) বর্ণিত । এগুলির মধ্যে পর্যাপ্ত পরিমাণ রয়েছে, তবে, যে প্রারম্ভিক ব্যবহারের ক্ষেত্রে তাদের অবস্থার জন্য কোনটি উপযুক্ত তা সিদ্ধান্ত নিতে বা এমনকি তাদের সমস্ত মনে রাখতে অসুবিধা হতে পারে। তাদের সাধারণ ধারণা থাকতে পারে যে "আমার এখানে একটি * প্রয়োগের ফাংশন ব্যবহার করা উচিত" তবে প্রথমে এগুলি সবথেকে সোজা রাখা শক্ত হতে পারে।

এই সত্যটি সত্ত্বেও (অন্যান্য উত্তরে উল্লিখিত) যে * প্রয়োগ পরিবারের বেশিরভাগ কার্যকারিতা অত্যন্ত জনপ্রিয় plyrপ্যাকেজ দ্বারা আচ্ছাদিত , বেস ফাংশনগুলি দরকারী এবং জানার যোগ্য।

এই উত্তরটি তাদের বিশেষ সমস্যার জন্য সঠিক * প্রযোজ্য ফাংশনটি সঠিকভাবে পরিচালিত করতে সহায়তা করতে নতুন ইউজারের জন্য এক ধরণের সাইনপোস্ট হিসাবে কাজ করার উদ্দেশ্যে is দ্রষ্টব্য, এটি কেবল আর ডকুমেন্টেশনগুলিকে পুনরায় সাজানো বা প্রতিস্থাপনের উদ্দেশ্যে নয় ! আশা করা যায় যে এই উত্তরটি আপনাকে কী * প্রয়োগের ফাংশনটি আপনার পরিস্থিতির পক্ষে উপযুক্ত তা সিদ্ধান্ত নিতে সহায়তা করে এবং তারপরে আরও গবেষণা করার বিষয়টি আপনার উপর নির্ভর করবে। একটি ব্যতিক্রম সহ, পারফরম্যান্সের পার্থক্যগুলি মোকাবেলা করা হবে না।

  • প্রয়োগ করুন - আপনি যখন কোনও ম্যাট্রিক্সের সারি বা কলামগুলিতে (এবং উচ্চ-মাত্রিক এনালগগুলি) কোনও ফাংশন প্রয়োগ করতে চান; ডেটা ফ্রেমের জন্য সাধারণত পরামর্শ দেওয়া হয় না কারণ এটি প্রথমে ম্যাট্রিক্সে বাধ্য করে।

    # Two dimensional matrix
    M <- matrix(seq(1,16), 4, 4)
    
    # apply min to rows
    apply(M, 1, min)
    [1] 1 2 3 4
    
    # apply max to columns
    apply(M, 2, max)
    [1]  4  8 12 16
    
    # 3 dimensional array
    M <- array( seq(32), dim = c(4,4,2))
    
    # Apply sum across each M[*, , ] - i.e Sum across 2nd and 3rd dimension
    apply(M, 1, sum)
    # Result is one-dimensional
    [1] 120 128 136 144
    
    # Apply sum across each M[*, *, ] - i.e Sum across 3rd dimension
    apply(M, c(1,2), sum)
    # Result is two-dimensional
         [,1] [,2] [,3] [,4]
    [1,]   18   26   34   42
    [2,]   20   28   36   44
    [3,]   22   30   38   46
    [4,]   24   32   40   48

    যদি আপনি চান সারি / কলাম উপায়ে বা 2D ম্যাট্রিক্স জন্য অঙ্কের তাহলে নিশ্চিত তদন্ত করতে হবে অত্যন্ত অপ্টিমাইজ, বাজ-দ্রুত colMeans, rowMeans, colSums, rowSums

  • ল্যাপ্লি - আপনি যখন তালিকার প্রতিটি উপাদানগুলিতে কোনও ফাংশন প্রয়োগ করতে চান এবং একটি তালিকা ফিরে পান।

    এটি অন্যান্য * প্রয়োগ ফাংশনগুলির অনেকেরই ওয়ার্কহর্স। তাদের কোডটি ফিরুন এবং আপনি প্রায়শই lapplyনীচে পাবেন ।

    x <- list(a = 1, b = 1:3, c = 10:100) 
    lapply(x, FUN = length) 
    $a 
    [1] 1
    $b 
    [1] 3
    $c 
    [1] 91
    lapply(x, FUN = sum) 
    $a 
    [1] 1
    $b 
    [1] 6
    $c 
    [1] 5005
  • স্যাপলি - আপনি যখন তালিকার প্রতিটি উপাদানগুলিতে কোনও ফাংশন প্রয়োগ করতে চান, তবে আপনি তালিকার চেয়ে ভেক্টর ফিরে চান ।

    আপনি যদি নিজেকে টাইপ করে খুঁজে পান তবে unlist(lapply(...))থামুন এবং বিবেচনা করুন sapply

    x <- list(a = 1, b = 1:3, c = 10:100)
    # Compare with above; a named vector, not a list 
    sapply(x, FUN = length)  
    a  b  c   
    1  3 91
    
    sapply(x, FUN = sum)   
    a    b    c    
    1    6 5005 

    এর আরও উন্নত ব্যবহারে sapplyফলাফলটি বাধ্যতামূলক করার চেষ্টা করা হবে যদি উপযুক্ত হয় তবে এটি একটি বহুমাত্রিক অ্যারেতে বাধ্য করা হবে। উদাহরণস্বরূপ, যদি আমাদের ফাংশন একই দৈর্ঘ্যের ভেক্টরগুলিকে ফেরত দেয় তবে sapplyএগুলি ম্যাট্রিক্সের কলাম হিসাবে ব্যবহার করবে:

    sapply(1:5,function(x) rnorm(3,x))

    যদি আমাদের ফাংশনটি 2 টি মাত্রিক ম্যাট্রিক্স দেয়, sapplyতবে প্রতিটি প্রত্যাবর্তিত ম্যাট্রিক্সকে একক দীর্ঘ ভেক্টর হিসাবে বিবেচনা করে মূলত একই কাজ করবে:

    sapply(1:5,function(x) matrix(x,2,2))

    যতক্ষণ না আমরা নির্দিষ্ট না করি simplify = "array", এক্ষেত্রে এটি পৃথক ম্যাট্রিকগুলি বহু-মাত্রিক অ্যারে তৈরি করতে ব্যবহার করবে:

    sapply(1:5,function(x) matrix(x,2,2), simplify = "array")

    এই আচরণগুলির প্রত্যেকটি অবশ্যই আমাদের ফাংশনে ফেরত ভেক্টর বা একই দৈর্ঘ্য বা মাত্রার ম্যাট্রিক্সের উপর নির্ভরশীল।

  • vapply - আপনি যখন ব্যবহার করতে চান sapplyতবে সম্ভবত আপনার কোডের বাইরে আরও কিছু গতি বার করতে হবে।

    কারণ vapply, আপনি মূলত আর কে আপনার ফাংশনটি কী ধরণের জিনিস ফিরে আসবে তার উদাহরণ দিয়েছিলেন যা কোনও একক পরমাণু ভেক্টরে ফিট করার জন্য ফিরে আসা মানকে কিছুটা সময় সাশ্রয় করতে পারে।

    x <- list(a = 1, b = 1:3, c = 10:100)
    #Note that since the advantage here is mainly speed, this
    # example is only for illustration. We're telling R that
    # everything returned by length() should be an integer of 
    # length 1. 
    vapply(x, FUN = length, FUN.VALUE = 0L) 
    a  b  c  
    1  3 91
  • ম্যাপ্লি - যখন আপনার বেশ কয়েকটি ডেটা স্ট্রাকচার রয়েছে (যেমন: ভেক্টর, তালিকা) এবং আপনি প্রতিটিটির 1 ম উপাদান এবং তারপরে প্রতিটি দ্বিতীয় উপাদান ইত্যাদির জন্য একটি ফাংশন প্রয়োগ করতে চান, ফলাফলটিকে কোনও ভেক্টর / অ্যারেতে বাধ্য করে sapply

    আপনার ক্রিয়াকলাপে একাধিক যুক্তি গ্রহণ করতে হবে এই অর্থে এটি বহুবিচিত্র।

    #Sums the 1st elements, the 2nd elements, etc. 
    mapply(sum, 1:5, 1:5, 1:5) 
    [1]  3  6  9 12 15
    #To do rep(1,4), rep(2,3), etc.
    mapply(rep, 1:4, 4:1)   
    [[1]]
    [1] 1 1 1 1
    
    [[2]]
    [1] 2 2 2
    
    [[3]]
    [1] 3 3
    
    [[4]]
    [1] 4
  • মানচিত্র - একটি মোড়কের mapplyসঙ্গে SIMPLIFY = FALSE, তাই এটি একটি তালিকা ফিরতে নিশ্চিত করা হয়।

    Map(sum, 1:5, 1:5, 1:5)
    [[1]]
    [1] 3
    
    [[2]]
    [1] 6
    
    [[3]]
    [1] 9
    
    [[4]]
    [1] 12
    
    [[5]]
    [1] 15
  • র‌্যাপলি - যখন আপনি কোনও নেস্টেড তালিকার কাঠামোর প্রতিটি উপাদানগুলিতে একটি ক্রিয়াকলাপটি পুনঃসংশ্লিষ্টভাবে প্রয়োগ করতে চান For

    আপনাকে কতটা অস্বাভাবিক rapplyসে সম্পর্কে কিছু ধারণা দেওয়ার জন্য, এই উত্তরটি পোস্ট করার সময় আমি এটির কথা ভুলে গিয়েছিলাম! স্পষ্টতই, আমি নিশ্চিত যে অনেকে এটি ব্যবহার করে তবে ওয়াইএমএমভি। rapplyপ্রয়োগ করার জন্য একটি ব্যবহারকারী-সংজ্ঞায়িত ফাংশন দিয়ে সচিত্রভাবে বর্ণনা করা হয়:

    # Append ! to string, otherwise increment
    myFun <- function(x){
        if(is.character(x)){
          return(paste(x,"!",sep=""))
        }
        else{
          return(x + 1)
        }
    }
    
    #A nested list structure
    l <- list(a = list(a1 = "Boo", b1 = 2, c1 = "Eeek"), 
              b = 3, c = "Yikes", 
              d = list(a2 = 1, b2 = list(a3 = "Hey", b3 = 5)))
    
    
    # Result is named vector, coerced to character          
    rapply(l, myFun)
    
    # Result is a nested list like l, with values altered
    rapply(l, myFun, how="replace")
  • ট্যাপ্লি - যখন আপনি কোনও ভেক্টরের সাবসেটগুলিতে কোনও ফাংশন প্রয়োগ করতে চান এবং সাবটেটগুলি অন্য কোনও ভেক্টর দ্বারা সংজ্ঞায়িত করা হয়, সাধারণত একটি ফ্যাক্টর।

    * * এর কালো মেষগুলি পরিবারের প্রযোজ্য। "র‌্যাগড অ্যারে" বাক্যাংশটি হেল্প ফাইলের ব্যবহারটি কিছুটা বিভ্রান্তিকর হতে পারে তবে এটি আসলে বেশ সহজ।

    একজন ভেক্টর:

    x <- 1:20

    সংজ্ঞায়িত গোষ্ঠী (একই দৈর্ঘ্যের!) একটি ফ্যাক্টর:

    y <- factor(rep(letters[1:5], each = 4))

    xদ্বারা সংজ্ঞায়িত প্রতিটি উপগোষ্ঠীর মধ্যে মানগুলি জুড়ুন y:

    tapply(x, y, sum)  
     a  b  c  d  e  
    10 26 42 58 74 

    আরও জটিল উদাহরণগুলি পরিচালনা করা যেতে পারে যেখানে সাবগ্রুপগুলি কয়েকটি কারণের একটি তালিকার অনন্য সংমিশ্রণ দ্বারা সংজ্ঞায়িত করা হয়। tapplyবিভক্ত-প্রয়োগ- মেশা আর ইন ফাংশান যে সাধারণ হয় (আত্মা মধ্যে অনুরূপ aggregate, by, ave, ddply, ইত্যাদি) অত: পর তার কুলাঙ্গার অবস্থা।


32
বিশ্বাস করুন আপনি পাবেন যে byবিশুদ্ধ বিভক্ত-lapply এবং aggregateহয় tapplyতাদের কোর করেন। আমি মনে করি কালো মেষগুলি দুর্দান্ত ফ্যাব্রিক তৈরি করে।
IRTFM

21
কল্পনাপ্রসূত সাড়া! এটি অফিসিয়াল আর ডকুমেন্টেশনের অংশ হওয়া উচিত :) :) একটি ক্ষুদ্র পরামর্শ: সম্ভবত ব্যবহার করতে aggregateএবং byপাশাপাশি কিছু গুলি যুক্ত করুন ? (আপনার বর্ণনার পরে আমি এগুলি শেষ পর্যন্ত বুঝতে পারি!) তবে তারা বেশ সাধারণ, তাই এই দুটি ফাংশনের জন্য আলাদা হওয়া এবং নির্দিষ্ট উদাহরণ থাকতে পারে
it

3
@ গ্রেটুর আমি এ উত্তরটি থেকে (ক) খুব দীর্ঘ হওয়া এবং (খ) নথিটির পুনরায় লিখন এড়াতে সক্রিয়ভাবে এই উত্তর থেকে জিনিসগুলি ছাঁটাই করছি। আমি সিদ্ধান্ত নিয়েছি যে , ইত্যাদি aggregate, যখন by* প্রয়োগ ফাংশনগুলির উপর ভিত্তি করে থাকে, আপনি যেভাবে তাদের ব্যবহার করে চলেছেন সেগুলি ব্যবহারকারী দৃষ্টিকোণ থেকে যথেষ্ট আলাদা যে তাদের পৃথক উত্তরে সংক্ষিপ্ত করা উচিত। আমি চেষ্টা করতে পারি যে আমার কাছে সময় থাকলে বা অন্য কেউ আমাকে এটিকে মারবে এবং আমার উপার্জনটি অর্জন করবে।
জোড়ান

4
এছাড়াও, ?Mapএকটি আপেক্ষিক যেমনmapply
Baptiste

3
@ জাসান্ডার্স - আমি এর সাথে মোটেও একমত হব না। data.frameগুলি আর এর একেবারে কেন্দ্রীয় অংশ এবং একটি listবস্তু হিসাবে lapplyবিশেষত ব্যবহার করে প্রায়শই হেরফের হয় । তারা প্রচলিত আয়তক্ষেত্রাকার ডেটাসেটে এক সাথে বহু ধরণের ভেক্টর / উপাদানগুলির গ্রুপিংয়ের জন্য ধারক হিসাবেও কাজ করে। যদিও data.tableএবং plyrএমন একটি নির্দিষ্ট ধরণের সিনট্যাক্স যুক্ত করতে পারে যা কিছুকে আরও স্বাচ্ছন্দ্য বোধ করে, তারা data.frameযথাক্রমে প্রসারিত এবং অভিনয় করছেন ।
thelatemail

191

পার্শ্ব নোটে, এখানে বিভিন্ন plyrফাংশনগুলি বেস *applyফাংশনগুলির সাথে কীভাবে মিলিত হয় (প্লেয়ার ওয়েবপৃষ্ঠা থেকে প্লাইডার ডকুমেন্ট থেকে ইন্ট্রো থেকে http://had.co.nz/plyr/ )

Base function   Input   Output   plyr function 
---------------------------------------
aggregate        d       d       ddply + colwise 
apply            a       a/l     aaply / alply 
by               d       l       dlply 
lapply           l       l       llply  
mapply           a       a/l     maply / mlply 
replicate        r       a/l     raply / rlply 
sapply           l       a       laply 

এর অন্যতম লক্ষ্য plyrহ'ল ফাংশনটির প্রতিটি ইনপুট এবং আউটপুট ডেটা প্রকারগুলি এনকোড করে প্রতিটি ফাংশনের জন্য নিয়মিত নামকরণের কনভেনশন সরবরাহ করা। এটি আউটপুটটিতেও ধারাবাহিকতা সরবরাহ করে, সেই আউটপুট থেকে dlply()সহজেই কার্যকর ldply()আউটপুট উত্পাদন করতে পারা যায় etc.

ধারণাগতভাবে, plyrবেস *applyফাংশনগুলি বোঝার চেয়ে শেখা আর কোনও কঠিন নয় ।

plyrএবং reshapeফাংশনগুলি আমার প্রতিদিনের ব্যবহারে এই প্রায় সমস্ত ফাংশন প্রতিস্থাপন করেছে। তবে, ইন্ট্রো থেকে প্লাইর নথিতেও:

সম্পর্কিত ফাংশন tapplyএবং এতে sweepকোনও সম্পর্কিত ফাংশন নেই plyrএবং কার্যকর থাকবেন। mergeমূল ডেটার সাথে সংক্ষিপ্তসারগুলি একত্রিত করার জন্য দরকারী।


13
যখন আমি স্ক্র্যাচ থেকে আর শিখতে শুরু করি তখন প্লেয়ারটি *apply()ফাংশনগুলির পরিবারের চেয়ে শেখার পক্ষে অনেক সহজ ছিল । আমার জন্য, ddply()খুব স্বজ্ঞাত ছিল যেহেতু আমি এসকিউএল সমষ্টি ফাংশনগুলির সাথে পরিচিত ছিল। ddply()অনেক সমস্যা সমাধানের জন্য আমার হাতুড়ি হয়ে গিয়েছিল, যার কয়েকটি অন্যান্য আদেশের সাথে আরও ভাল সমাধান করা যেতে পারে।
জেডি লং

1
আমি অনুমান করেছি যে আমি বুঝতে পেরেছি যে plyrফাংশনগুলির পিছনে ধারণাটি ফাংশনের অনুরূপ *apply, সুতরাং আপনি যদি এটি করতে পারেন তবে আপনি অন্যটি করতে পারেন, তবে plyrফাংশনগুলি মনে রাখা সহজ। তবে আমি ddply()হাতুড়িটির সাথে পুরোপুরি একমত !
জোফ্রহ্ল্ড

1
প্লায়ার প্যাকেজটিতে join()ফাংশন রয়েছে যা মার্জ করার মতো কাজগুলি করে। প্লেয়ারের প্রসঙ্গে এটি উল্লেখ করা আরও বেশি বিষয়।
মার্বেল

আসুন আমরা ভুলে যাব না, ভুলে যাবeapply
জেডিএল

সাধারণভাবে দুর্দান্ত উত্তর, তবে আমি মনে করি এটির ইউটিলিটি vapplyএবং ডাউনসাইডগুলি ডাউনপ্লাই করে sapply। এর একটি বড় সুবিধা vapplyহ'ল এটি আউটপুট প্রকার এবং দৈর্ঘ্য প্রয়োগ করে, তাই আপনি সঠিক প্রত্যাশিত আউটপুট বা তথ্যমূলক ত্রুটি দিয়ে শেষ করবেন। অন্যদিকে, sapplyসর্বদা সুস্পষ্ট নয় এমন নিয়মগুলি অনুসরণ করে আউটপুটকে সহজ করার চেষ্টা করবে এবং অন্যথায় কোনও তালিকায় ফিরে যাবে। উদাহরণস্বরূপ, আউটপুট ধরণ এই উত্পাদন করা হবে ভবিষ্যদ্বাণী করা চেষ্টা করুন: sapply(list(1:5, 6:10, matrix(1:4, 2)), function(x) head(x, 1))। কি হবে sapply(list(matrix(1:4, 2), matrix(1:4, 2)), ...)?
অ্যালেক্সি শিক্লোমানভ

133

স্লাইড 21 থেকে http://www.slideshare.net/hadley/plyr-one-data-analytic-strategy :

একত্রিত, প্রয়োগ করুন

(আশা এটা পরিষ্কার যে applyসাথে সঙ্গতিপূর্ণ @ হ্যাডলি এর aaplyএবং aggregateঅনুরূপ @ হ্যাডলি এর ddplyইত্যাদি একই SlideShare এর মধ্যে স্লাইড 20 যদি আপনি এটি এই চিত্র থেকে পাবেন না নির্মল হবে।)

(বামদিকে ইনপুট রয়েছে, উপরে রয়েছে আউটপুট)


4
স্লাইডে টাইপো আছে? উপরের বাম ঘরটি এপলি হওয়া উচিত
JHowIX

100

জোড়ানের দুর্দান্ত উত্তর দিয়ে প্রথমে শুরু করুন - সন্দেহজনক যে কোনও কিছুই এটি আরও ভাল করতে পারে।

তারপরে নীচের স্তন্যপুনিগুলি প্রতিটি মধ্যে পার্থক্য মনে রাখতে সহায়তা করতে পারে। যদিও কিছু সুস্পষ্ট, অন্যেরা এর চেয়ে কম হতে পারে --- এর জন্য আপনি জোড়ানের আলোচনায় ন্যায়সঙ্গততা খুঁজে পাবেন।

স্মৃতিবর্ধনবিদ্যা

  • lapplyএকটি তালিকা প্রয়োগ করা হয় যা একটি তালিকা বা ভেক্টরের সাথে কাজ করে এবং একটি তালিকা দেয়।
  • sapplyএকটি সাধারণ lapply (সম্ভব হলে ভেক্টর বা ম্যাট্রিক্স ফেরত ফাংশন ডিফল্ট)
  • vapplyএকটি হল যাচাই প্রয়োগ (আগমন অবজেক্ট প্রকারটি prespecified হতে দেয়)
  • rapplyএকটি হল রিকার্সিভ নেস্টেড তালিকা, তালিকা মধ্যে অর্থাত তালিকা জন্য আবেদন
  • tapplyএকটি হল বাঁধা প্রয়োগ যেখানে ট্যাগ সাব-সেট নির্বাচন চিহ্নিত
  • apply হয় জেনেরিক : একটি ম্যাট্রিক্স এর সারি বা কলাম থেকে একটি ফাংশন প্রযোজ্য (অথবা, আরো সাধারণভাবে, একটি অ্যারের মাত্রা পর্যন্ত)

ডান পটভূমি নির্মাণ

যদি applyপরিবারটি ব্যবহার করে এখনও আপনার কাছে কিছুটা এলিয়েন বোধ হয়, তবে এটি হতে পারে আপনি কোনও মূল দৃষ্টিকোণ মিস করছেন।

এই দুটি নিবন্ধ সাহায্য করতে পারে। তারা কার্যকরী প্রোগ্রামিং কৌশলগুলি অনুপ্রাণিত করার জন্য প্রয়োজনীয় ব্যাকগ্রাউন্ড সরবরাহ করে যা applyফাংশনগুলির পরিবার সরবরাহ করে ।

লিস্পের ব্যবহারকারীরা তাত্ক্ষণিকভাবে দৃষ্টান্তটি স্বীকৃতি দেবেন। আপনি যদি লিস্পের সাথে পরিচিত না হন, একবার আপনি এফপির চারপাশে মাথা পেলে, আপনি আর-এ ব্যবহারের জন্য একটি শক্তিশালী দৃষ্টিকোণ অর্জন করতে পারেন - এবং applyআরও অনেক কিছু বোঝাতে সক্ষম হবেন।


51

যেহেতু আমি বুঝতে পেরেছিলাম যে এই পোস্টটির (খুব দুর্দান্ত) উত্তরগুলির ব্যাখ্যা byএবং aggregateব্যাখ্যা নেই। আমার অবদান এখানে।

দ্বারা

byফাংশন, যেমন ডকুমেন্টেশন বিবৃত যদিও হতে পারে, জন্য একটি "মোড়কের" হিসাবে tapplybyযখন আমরা কোনও কাজটি tapplyপরিচালনা করতে পারি না যে কোনও কাজ গণনা করতে চাই তখন শক্তি দেখা দেয় । একটি উদাহরণ এই কোড:

ct <- tapply(iris$Sepal.Width , iris$Species , summary )
cb <- by(iris$Sepal.Width , iris$Species , summary )

 cb
iris$Species: setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 
-------------------------------------------------------------- 
iris$Species: versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 
-------------------------------------------------------------- 
iris$Species: virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 


ct
$setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 

$versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 

$virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 

আমরা যদি এই দুটি বস্তু মুদ্রণ ctএবং cb, আমরা "মূলত" একই ফলাফল এবং শুধুমাত্র পার্থক্য কিভাবে তারা দেখানো হয় এবং বিভিন্ন হয় classযথাক্রমে বৈশিষ্ট্যাবলী byজন্য cbএবং arrayজন্য ct

আমি যেমন বলেছি, byযখন আমরা ব্যবহার করতে পারি না তখন শক্তি দেখা দেয় tapply; নিম্নলিখিত কোডটি একটি উদাহরণ:

 tapply(iris, iris$Species, summary )
Error in tapply(iris, iris$Species, summary) : 
  arguments must have same length

আর বলেছেন যে আর্গুমেন্টগুলির একই দৈর্ঘ্য থাকতে হবে, বলুন "আমরা ফ্যাক্টর বরাবর summaryসমস্ত ভেরিয়েবলের গণনা করতে চাই ": তবে আর কেবল এটি করতে পারে না কারণ এটি কীভাবে পরিচালনা করতে হয় তা জানে না।irisSpecies

byফাংশনটি দিয়ে data frameক্লাসের জন্য একটি নির্দিষ্ট পদ্ধতি প্রেরণ করুন এবং তারপরে summaryপ্রথম আর্গুমেন্টের দৈর্ঘ্য (এবং প্রকারটিও) পৃথক হলেও ফাংশনটি কাজ করতে দিন।

bywork <- by(iris, iris$Species, summary )

bywork
iris$Species: setosa
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.300   Min.   :2.300   Min.   :1.000   Min.   :0.100   setosa    :50  
 1st Qu.:4.800   1st Qu.:3.200   1st Qu.:1.400   1st Qu.:0.200   versicolor: 0  
 Median :5.000   Median :3.400   Median :1.500   Median :0.200   virginica : 0  
 Mean   :5.006   Mean   :3.428   Mean   :1.462   Mean   :0.246                  
 3rd Qu.:5.200   3rd Qu.:3.675   3rd Qu.:1.575   3rd Qu.:0.300                  
 Max.   :5.800   Max.   :4.400   Max.   :1.900   Max.   :0.600                  
-------------------------------------------------------------- 
iris$Species: versicolor
  Sepal.Length    Sepal.Width     Petal.Length   Petal.Width          Species  
 Min.   :4.900   Min.   :2.000   Min.   :3.00   Min.   :1.000   setosa    : 0  
 1st Qu.:5.600   1st Qu.:2.525   1st Qu.:4.00   1st Qu.:1.200   versicolor:50  
 Median :5.900   Median :2.800   Median :4.35   Median :1.300   virginica : 0  
 Mean   :5.936   Mean   :2.770   Mean   :4.26   Mean   :1.326                  
 3rd Qu.:6.300   3rd Qu.:3.000   3rd Qu.:4.60   3rd Qu.:1.500                  
 Max.   :7.000   Max.   :3.400   Max.   :5.10   Max.   :1.800                  
-------------------------------------------------------------- 
iris$Species: virginica
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.900   Min.   :2.200   Min.   :4.500   Min.   :1.400   setosa    : 0  
 1st Qu.:6.225   1st Qu.:2.800   1st Qu.:5.100   1st Qu.:1.800   versicolor: 0  
 Median :6.500   Median :3.000   Median :5.550   Median :2.000   virginica :50  
 Mean   :6.588   Mean   :2.974   Mean   :5.552   Mean   :2.026                  
 3rd Qu.:6.900   3rd Qu.:3.175   3rd Qu.:5.875   3rd Qu.:2.300                  
 Max.   :7.900   Max.   :3.800   Max.   :6.900   Max.   :2.500     

এটি সত্যই কাজ করে এবং ফলাফলটি খুব অবাক করে। এটি শ্রেণীর একটি বস্তু byযা বরাবর Species(তাদের প্রত্যেকের জন্য) summaryপ্রতিটি ভেরিয়েবলের গণনা করে ।

মনে রাখবেন যে প্রথম আর্গুমেন্টটি যদি একটি হয় data frameতবে প্রেরিত ফাংশনটিতে সেই শ্রেণীর অবজেক্টের জন্য একটি পদ্ধতি থাকতে হবে। উদাহরণস্বরূপ আমরা meanফাংশন সহ এই কোডটি ব্যবহার করি আমাদের এই কোডটি থাকবে যা মোটেই কোনও বুদ্ধিমান নয়:

 by(iris, iris$Species, mean)
iris$Species: setosa
[1] NA
------------------------------------------- 
iris$Species: versicolor
[1] NA
------------------------------------------- 
iris$Species: virginica
[1] NA
Warning messages:
1: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
2: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
3: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA

সামগ্রিক

aggregateঅন্যটিকে ব্যবহারের ভিন্ন উপায় হিসাবে দেখা যেতে পারে tapplyযদি আমরা এটিকে এটি ব্যবহার করি।

at <- tapply(iris$Sepal.Length , iris$Species , mean)
ag <- aggregate(iris$Sepal.Length , list(iris$Species), mean)

 at
    setosa versicolor  virginica 
     5.006      5.936      6.588 
 ag
     Group.1     x
1     setosa 5.006
2 versicolor 5.936
3  virginica 6.588

দুটি তাত্ক্ষণিক পার্থক্য হ'ল দ্বিতীয় আর্গুমেন্টটি aggregate অবশ্যই একটি তালিকা থাকতে হবে যখন তালিকা হতে tapply পারে (বাধ্যতামূলক নয়) এবং এর আউটপুটটি aggregateএকটি ডেটা ফ্রেমের হয় যখন এর tapplyমধ্যে একটি হয় array

এর ক্ষমতাটি aggregateহ'ল এটি subsetআর্গুমেন্টের সাহায্যে ডেটার সহজেই উপগ্রহগুলি পরিচালনা করতে পারে এবং এটিতে tsবস্তুর জন্য পদ্ধতিও রয়েছে এবং formulaপাশাপাশি।

এই উপাদানগুলি কিছু পরিস্থিতিতে aggregateএটির সাথে কাজ করা সহজ করে তোলে tapply। এখানে কয়েকটি উদাহরণ (ডকুমেন্টেশনে উপলব্ধ):

ag <- aggregate(len ~ ., data = ToothGrowth, mean)

 ag
  supp dose   len
1   OJ  0.5 13.23
2   VC  0.5  7.98
3   OJ  1.0 22.70
4   VC  1.0 16.77
5   OJ  2.0 26.06
6   VC  2.0 26.14

আমরা এর মাধ্যমে এটি অর্জন করতে পারি tapplyতবে বাক্য গঠনটি আরও শক্ত এবং আউটপুট (কিছু পরিস্থিতিতে) কম পাঠযোগ্য:

att <- tapply(ToothGrowth$len, list(ToothGrowth$dose, ToothGrowth$supp), mean)

 att
       OJ    VC
0.5 13.23  7.98
1   22.70 16.77
2   26.06 26.14

অন্যান্য বার যখন আমরা ব্যবহার করতে পারবেন না আছে byবা tapplyআমরা ব্যবহার করতে হবে aggregate

 ag1 <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, mean)

 ag1
  Month    Ozone     Temp
1     5 23.61538 66.73077
2     6 29.44444 78.22222
3     7 59.11538 83.88462
4     8 59.96154 83.96154
5     9 31.44828 76.89655

আমরা tapplyএকটি কল দিয়ে পূর্ববর্তী ফলাফলটি অর্জন করতে পারি না তবে Monthপ্রতিটি উপাদানগুলির জন্য আমাদের গড় গণনা করতে হবে এবং তারপরে তাদের একত্রিত করতে হবে (এটিও লক্ষ করুন যে আমাদের কল করতে হবে na.rm = TRUE, কারণ ফাংশনের formulaপদ্ধতিগুলি aggregateডিফল্টরূপে আছে na.action = na.omit):

ta1 <- tapply(airquality$Ozone, airquality$Month, mean, na.rm = TRUE)
ta2 <- tapply(airquality$Temp, airquality$Month, mean, na.rm = TRUE)

 cbind(ta1, ta2)
       ta1      ta2
5 23.61538 65.54839
6 29.44444 79.10000
7 59.11538 83.90323
8 59.96154 83.96774
9 31.44828 76.90000

যদিও byআমরা কেবল এটি অর্জন করতে পারি না যে প্রকৃতপক্ষে নিম্নলিখিত ফাংশন কলটি একটি ত্রুটি প্রদান করে (তবে সম্ভবত এটি সরবরাহিত ফাংশন সম্পর্কিত, mean):

by(airquality[c("Ozone", "Temp")], airquality$Month, mean, na.rm = TRUE)

অন্য সময় ফলাফলগুলি একই হয় এবং পার্থক্যগুলি কেবল শ্রেণিতে থাকে (এবং তারপরে এটি কীভাবে প্রদর্শিত / মুদ্রিত হয় এবং কেবল তা নয় - উদাহরণস্বরূপ, কীভাবে এটি উপসেট করা যায়) বস্তু:

byagg <- by(airquality[c("Ozone", "Temp")], airquality$Month, summary)
aggagg <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, summary)

পূর্ববর্তী কোডটি একই লক্ষ্য এবং ফলাফল অর্জন করে, কিছু পয়েন্টে কোন সরঞ্জামটি ব্যবহার করতে হবে তা কেবল ব্যক্তিগত স্বাদ এবং প্রয়োজনের বিষয়; পূর্ববর্তী দুটি বস্তুর সাবসেটিংয়ের ক্ষেত্রে খুব আলাদা প্রয়োজন।


আমি যেমন বলেছি, যখন আমরা টেপলি ব্যবহার করতে পারি না তখন এর শক্তি উত্থাপিত হয়; নিম্নলিখিত কোডটি একটি উদাহরণ: এই শব্দগুলি যা আপনি উপরে ব্যবহার করেছেন। এবং আপনি সারাংশের কম্পিউটিংয়ের একটি উদাহরণ দিয়েছেন। ওয়েল বলে যে সারসংক্ষেপ পরিসংখ্যান শুধুমাত্র নির্ণিত যেতে পারে যে এটা পরিস্কার করতে হবে দেয়: যেমন data.frame(tapply(unlist(iris[,-5]),list(rep(iris[,5],ncol(iris[-5])),col(iris[-5])),summary))এই একটি ব্যবহার tapply . With the right splitting there is nothing you cant do with tapply . The only thing is it returns a matrix. Please be careful by saying we cant use tapply`
Onyambu

35

প্রচুর দুর্দান্ত উত্তর রয়েছে যা প্রতিটি ফাংশনের জন্য ব্যবহারের ক্ষেত্রে পার্থক্য নিয়ে আলোচনা করে। উত্তরের কোনওটিই পারফরম্যান্সের পার্থক্য নিয়ে আলোচনা করে না। এটি যুক্তিসঙ্গত কারণ বিভিন্ন ফাংশন বিভিন্ন ইনপুট প্রত্যাশা করে এবং বিভিন্ন আউটপুট উত্পাদন করে, তবুও তাদের বেশিরভাগেরই সিরিজ / গোষ্ঠীগুলি দ্বারা মূল্যায়নের একটি সাধারণ সাধারণ উদ্দেশ্য রয়েছে। আমার উত্তর পারফরম্যান্স উপর ফোকাস করতে যাচ্ছে। উপরের কারণে ভেক্টরগুলি থেকে ইনপুট তৈরির সময় অন্তর্ভুক্ত করা হয়, এছাড়াও applyফাংশনটি পরিমাপ করা হয় না।

আমি দুটি ভিন্ন ফাংশন sumএবং lengthএকবারে পরীক্ষা করেছি । ভলিউম পরীক্ষিত ইনপুটটিতে 50 এম এবং আউটপুটে 50 কে। আমি দুটি জনপ্রিয় প্যাকেজও অন্তর্ভুক্ত করেছি যা প্রশ্ন জিজ্ঞাসা করার সময় ব্যাপকভাবে ব্যবহৃত হয়নি, data.tableএবং dplyr। আপনি ভাল পারফরম্যান্সের জন্য লক্ষ্য রাখছেন কিনা তা উভয়ই অবশ্যই দেখার জন্য উপযুক্ত।

library(dplyr)
library(data.table)
set.seed(123)
n = 5e7
k = 5e5
x = runif(n)
grp = sample(k, n, TRUE)

timing = list()

# sapply
timing[["sapply"]] = system.time({
    lt = split(x, grp)
    r.sapply = sapply(lt, function(x) list(sum(x), length(x)), simplify = FALSE)
})

# lapply
timing[["lapply"]] = system.time({
    lt = split(x, grp)
    r.lapply = lapply(lt, function(x) list(sum(x), length(x)))
})

# tapply
timing[["tapply"]] = system.time(
    r.tapply <- tapply(x, list(grp), function(x) list(sum(x), length(x)))
)

# by
timing[["by"]] = system.time(
    r.by <- by(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# aggregate
timing[["aggregate"]] = system.time(
    r.aggregate <- aggregate(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# dplyr
timing[["dplyr"]] = system.time({
    df = data_frame(x, grp)
    r.dplyr = summarise(group_by(df, grp), sum(x), n())
})

# data.table
timing[["data.table"]] = system.time({
    dt = setnames(setDT(list(x, grp)), c("x","grp"))
    r.data.table = dt[, .(sum(x), .N), grp]
})

# all output size match to group count
sapply(list(sapply=r.sapply, lapply=r.lapply, tapply=r.tapply, by=r.by, aggregate=r.aggregate, dplyr=r.dplyr, data.table=r.data.table), 
       function(x) (if(is.data.frame(x)) nrow else length)(x)==k)
#    sapply     lapply     tapply         by  aggregate      dplyr data.table 
#      TRUE       TRUE       TRUE       TRUE       TRUE       TRUE       TRUE 

# print timings
as.data.table(sapply(timing, `[[`, "elapsed"), keep.rownames = TRUE
              )[,.(fun = V1, elapsed = V2)
                ][order(-elapsed)]
#          fun elapsed
#1:  aggregate 109.139
#2:         by  25.738
#3:      dplyr  18.978
#4:     tapply  17.006
#5:     lapply  11.524
#6:     sapply  11.326
#7: data.table   2.686

এটি কি স্বাভাবিক যে অ্যাপ্লাইটি ফাংশনগুলির চেয়ে ডিপি্লায়ার কম?
মোস্তফা

1
@ দিমিত্রিপেতেনকো আমি এটি মনে করি না, কেন এটি এখানে রয়েছে তা নিশ্চিত নয়। আপনার নিজের ডেটাটির বিরুদ্ধে পরীক্ষা করা ভাল, কারণ এমন অনেক কারণ রয়েছে যা খেলতে আসে।
জঙ্গোরেকি

28

সমস্ত দুর্দান্ত উত্তর সত্ত্বেও, এখানে আরও দুটি বেস ফাংশন রয়েছে যা উল্লেখ করার উপযুক্ত, কার্যকর outerফাংশন এবং অস্পষ্ট eapplyফাংশন

বহি: স্থ

outerআরও জাগ্রত হিসাবে লুকানো একটি খুব দরকারী ফাংশন। আপনি যদি outerএর বিবরণটির জন্য সহায়তাটি পড়েন তবে বলেছেন:

The outer product of the arrays X and Y is the array A with dimension  
c(dim(X), dim(Y)) where element A[c(arrayindex.x, arrayindex.y)] =   
FUN(X[arrayindex.x], Y[arrayindex.y], ...).

যা দেখে মনে হয় এটি কেবল রৈখিক বীজগণিত ধরণের জিনিসগুলির জন্যই কার্যকর। যাইহোক, এটি mapplyইনপুটগুলির দুটি ভেক্টরগুলিতে কোনও ফাংশন প্রয়োগ করার মতো ব্যবহার করা যেতে পারে । পার্থক্যটি হ'ল mapplyপ্রথম দুটি উপাদান এবং তারপরে দ্বিতীয় দুটি ইত্যাদির outerক্ষেত্রে ফাংশনটি প্রয়োগ করা হবে , যেখানে প্রথম ভেক্টর থেকে একটি উপাদান এবং দ্বিতীয় থেকে একটিতে প্রতিটি উপাদানের সমন্বয় ফাংশনটি প্রয়োগ করা হবে। উদাহরণ স্বরূপ:

 A<-c(1,3,5,7,9)
 B<-c(0,3,6,9,12)

mapply(FUN=pmax, A, B)

> mapply(FUN=pmax, A, B)
[1]  1  3  6  9 12

outer(A,B, pmax)

 > outer(A,B, pmax)
      [,1] [,2] [,3] [,4] [,5]
 [1,]    1    3    6    9   12
 [2,]    3    3    6    9   12
 [3,]    5    5    6    9   12
 [4,]    7    7    7    9   12
 [5,]    9    9    9    9   12

আমি যখন মূল্যবোধের ভেক্টর এবং শর্তগুলির একটি ভেক্টর থাকি তখন আমি ব্যক্তিগতভাবে এটি ব্যবহার করেছি এবং কোন মানগুলি কোন শর্ত পূরণ করে তা দেখতে চাই wish

eapply

eapplyভালো হয় lapplyছাড়া বরং একটি তালিকা প্রতিটি উপাদান একটি ফাংশন প্রয়োগের পরিবর্তে, এটি একটি ফাংশন যে উপাদানে একটা পরিবেশে প্রযোজ্য। উদাহরণস্বরূপ, যদি আপনি বিশ্ব পরিবেশে ব্যবহারকারীর সংজ্ঞায়িত ফাংশনগুলির একটি তালিকা পেতে চান:

A<-c(1,3,5,7,9)
B<-c(0,3,6,9,12)
C<-list(x=1, y=2)
D<-function(x){x+1}

> eapply(.GlobalEnv, is.function)
$A
[1] FALSE

$B
[1] FALSE

$C
[1] FALSE

$D
[1] TRUE 

সত্যই আমি এটি খুব বেশি ব্যবহার করি না তবে আপনি যদি অনেকগুলি প্যাকেজ তৈরি করে থাকেন বা প্রচুর পরিবেশ তৈরি করেন এটি কার্যকর হতে পারে।


25

এটি সম্ভবত উল্লেখযোগ্য aveaveহয় tapplyএর বন্ধুত্বপূর্ণ চাচাত ভাই। এটি এমন ফর্মের ফলাফল দেয় যা আপনি সরাসরি আপনার ডেটা ফ্রেমে প্লাগ করতে পারেন।

dfr <- data.frame(a=1:20, f=rep(LETTERS[1:5], each=4))
means <- tapply(dfr$a, dfr$f, mean)
##  A    B    C    D    E 
## 2.5  6.5 10.5 14.5 18.5 

## great, but putting it back in the data frame is another line:

dfr$m <- means[dfr$f]

dfr$m2 <- ave(dfr$a, dfr$f, FUN=mean) # NB argument name FUN is needed!
dfr
##   a f    m   m2
##   1 A  2.5  2.5
##   2 A  2.5  2.5
##   3 A  2.5  2.5
##   4 A  2.5  2.5
##   5 B  6.5  6.5
##   6 B  6.5  6.5
##   7 B  6.5  6.5
##   ...

বেস প্যাকেজের মধ্যে কিছুই যে ভালো কাজ নেই aveপুরো ডেটা ফ্রেমের জন্য (যেমন byভালো হয় tapplyডেটা ফ্রেম জন্য)। তবে আপনি এটি লজ্জা করতে পারেন:

dfr$foo <- ave(1:nrow(dfr), dfr$f, FUN=function(x) {
    x <- dfr[x,]
    sum(x$m*x$m2)
})
dfr
##     a f    m   m2    foo
## 1   1 A  2.5  2.5    25
## 2   2 A  2.5  2.5    25
## 3   3 A  2.5  2.5    25
## ...

12

আমি সম্প্রতি পরিবর্তে দরকারী sweepকার্যকারিতাটি আবিষ্কার করেছি এবং সম্পূর্ণতার স্বার্থে এটি এখানে যুক্ত করেছি:

পরিষ্কার করা

মৌলিক ধারণা হয় কুড়ান একটি অ্যারের row- বা কলাম ভিত্তিক দিয়ে একটি পরিবর্তিত অ্যারে ফিরে যান। একটি উদাহরণ এটি পরিষ্কার করে দেবে (উত্স: ডেটাচ্যাম্প ):

ধরা যাক আপনার একটি ম্যাট্রিক্স রয়েছে এবং এটি কলাম অনুসারে মানক করতে চান :

dataPoints <- matrix(4:15, nrow = 4)

# Find means per column with `apply()`
dataPoints_means <- apply(dataPoints, 2, mean)

# Find standard deviation with `apply()`
dataPoints_sdev <- apply(dataPoints, 2, sd)

# Center the points 
dataPoints_Trans1 <- sweep(dataPoints, 2, dataPoints_means,"-")
print(dataPoints_Trans1)
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Return the result
dataPoints_Trans1
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Normalize
dataPoints_Trans2 <- sweep(dataPoints_Trans1, 2, dataPoints_sdev, "/")

# Return the result
dataPoints_Trans2
##            [,1]       [,2]       [,3]
## [1,] -1.1618950 -1.1618950 -1.1618950
## [2,] -0.3872983 -0.3872983 -0.3872983
## [3,]  0.3872983  0.3872983  0.3872983
## [4,]  1.1618950  1.1618950  1.1618950

নোট: এই সাধারণ উদাহরণের জন্য একই ফলাফল অবশ্যই আরও সহজেই অর্জন করা যেতে পারে
apply(dataPoints, 2, scale)


1
এটি কি গ্রুপিংয়ের সাথে সম্পর্কিত?
ফ্রাঙ্ক

2
@ ফ্র্যাঙ্ক: ঠিক আছে, আপনার সাথে সত্য কথা বলতে এই পোস্টের শিরোনাম বরং বিভ্রান্তিকর: আপনি যখন নিজেই প্রশ্নটি পড়েন তখন এটি "প্রয়োগ পরিবার" সম্পর্কে হয়। sweepসব অন্যদের মতো একটি উচ্চ-অর্ডার ফাংশন এখানে উল্লেখ করা হয়েছে, যেমন হয় apply, sapply, lapplyতাই একই প্রশ্ন ও 1000 upvotes সঙ্গে গৃহীত উত্তর সম্পর্কে জিজ্ঞাসা করা যেতে পারে উদাহরণ তাতে দেওয়া। applyসেখানে দেওয়া উদাহরণটি একবার দেখুন ।
ভনজড

2
সুইপের একটি বিভ্রান্তিমূলক নাম, বিভ্রান্তিকর ডিফল্ট এবং বিভ্রান্তিমূলক প্যারামিটারের নাম :)। এটি আমার পক্ষে এটি বোঝা আরও সহজ: 1) স্ট্যাটাসটি ভেক্টর বা একক মান যা প্রথম ইনপুট হিসাবে একই আকারের ম্যাট্রিক্স গঠনের জন্য পুনরাবৃত্তি হবে, 2) 1 ম ইনপুট এবং এই নতুন ম্যাট্রিক্সে FUN প্রয়োগ করা হবে। হয়তো ভাল দ্বারা চিত্রিত: sweep(matrix(1:6,nrow=2),2,7:9,list)। এটি applyযেখানে applyলুপগুলি, sweepভেক্টোরাইজড ফাংশনগুলি ব্যবহার করতে সক্ষম তার চেয়ে সাধারণত কার্যকর efficient
মুডি_ মুডস্কিপার

2

ইন পতন সম্প্রতি Cran মুক্তি প্যাকেজ, আমি কম্প্রেস সাধারণ অধিকাংশ মাত্র 2 ফাংশন মধ্যে কার্যকারিতা প্রয়োগ চেষ্টা করেছেন:

  1. dapply(ডেটা-প্রয়োগ) ম্যাট্রিকেস এবং ডেটা.ফ্রেমগুলির সারি বা (ডিফল্ট) কলামগুলিতে ফাংশন প্রয়োগ করে এবং (ডিফল্ট) একই ধরণের একটি অবজেক্ট এবং একই বৈশিষ্ট্যগুলি সহ (প্রতিটি সংখ্যার ফলাফল অণু এবং না হলে drop = TRUE) প্রদান করে। কর্মক্ষমতা lapplyডেটা.ফ্রেম কলামগুলির সাথে তুলনাযোগ্য এবং applyম্যাট্রিক্স সারি বা কলামগুলির চেয়ে প্রায় 2x দ্রুত faster সমান্তরালতা mclapply(কেবল ম্যাকের জন্য) এর মাধ্যমে উপলব্ধ ।

বাক্য গঠন:

dapply(X, FUN, ..., MARGIN = 2, parallel = FALSE, mc.cores = 1L, 
       return = c("same", "matrix", "data.frame"), drop = TRUE)

উদাহরণ:

# Apply to columns:
dapply(mtcars, log)
dapply(mtcars, sum)
dapply(mtcars, quantile)
# Apply to rows:
dapply(mtcars, sum, MARGIN = 1)
dapply(mtcars, quantile, MARGIN = 1)
# Return as matrix:
dapply(mtcars, quantile, return = "matrix")
dapply(mtcars, quantile, MARGIN = 1, return = "matrix")
# Same for matrices ...
  1. BYভেক্টর, ম্যাট্রিক্স এবং ডেটা.ফ্রেম পদ্ধতির সাথে স্প্লিট-অ্যাপ্লিকেশন-কম্বাইনিং কম্পিউটিংয়ের জন্য একটি এস 3 জেনেরিক। এটি উল্লেখযোগ্যভাবে দ্রুততর চেয়ে tapply, byএবং aggregate(একটি এছাড়াও যতো তাড়াতাড়ি plyr, বড় ডেটার উপর dplyrদ্রুত যদিও)।

বাক্য গঠন:

BY(X, g, FUN, ..., use.g.names = TRUE, sort = TRUE,
   expand.wide = FALSE, parallel = FALSE, mc.cores = 1L,
   return = c("same", "matrix", "data.frame", "list"))

উদাহরণ:

# Vectors:
BY(iris$Sepal.Length, iris$Species, sum)
BY(iris$Sepal.Length, iris$Species, quantile)
BY(iris$Sepal.Length, iris$Species, quantile, expand.wide = TRUE) # This returns a matrix 
# Data.frames
BY(iris[-5], iris$Species, sum)
BY(iris[-5], iris$Species, quantile)
BY(iris[-5], iris$Species, quantile, expand.wide = TRUE) # This returns a wider data.frame
BY(iris[-5], iris$Species, quantile, return = "matrix") # This returns a matrix
# Same for matrices ...

গ্রুপিং ভেরিয়েবলের তালিকাগুলিতেও সরবরাহ করা যেতে পারে g

পারফরম্যান্স সম্পর্কে কথা বলা: ধসের মূল লক্ষ্য হ'ল আর-তে উচ্চ-পারফরম্যান্স প্রোগ্রামিং উত্সাহিত করা এবং সম্পূর্ণরূপে স্প্লিট-প্রয়োগ-সংযুক্তির বাইরে চলে যাওয়া। এই উদ্দেশ্যে প্যাকেজ C- এর একটি পূর্ণ সেট ++, ভিত্তি করে দ্রুত জেনেরিক ফাংশন: fmean, fmedian, fmode, fsum, fprod, fsd, fvar, fmin,fmax , ffirst, flast, fNobs, fNdistinct, fscale, fbetween, fwithin, fHDbetween, fHDwithin, flag, fdiffএবং fgrowth। তারা ডেটাগুলির মাধ্যমে একক পাসে গোষ্ঠীযুক্ত গণনা সম্পাদন করে (অর্থাত্ বিভাজন এবং পুনরায় সংযোজন নয়)।

বাক্য গঠন:

fFUN(x, g = NULL, [w = NULL,] TRA = NULL, [na.rm = TRUE,] use.g.names = TRUE, drop = TRUE)

উদাহরণ:

v <- iris$Sepal.Length
f <- iris$Species

# Vectors
fmean(v)             # mean
fmean(v, f)          # grouped mean
fsd(v, f)            # grouped standard deviation
fsd(v, f, TRA = "/") # grouped scaling
fscale(v, f)         # grouped standardizing (scaling and centering)
fwithin(v, f)        # grouped demeaning

w <- abs(rnorm(nrow(iris)))
fmean(v, w = w)      # Weighted mean
fmean(v, f, w)       # Weighted grouped mean
fsd(v, f, w)         # Weighted grouped standard-deviation
fsd(v, f, w, "/")    # Weighted grouped scaling
fscale(v, f, w)      # Weighted grouped standardizing
fwithin(v, f, w)     # Weighted grouped demeaning

# Same using data.frames...
fmean(iris[-5], f)                # grouped mean
fscale(iris[-5], f)               # grouped standardizing
fwithin(iris[-5], f)              # grouped demeaning

# Same with matrices ...

প্যাকেজ ভিগনেটে আমি মাপদণ্ড সরবরাহ করি। দ্রুত ফাংশনগুলির সাথে প্রোগ্রামিং ডিপিপ্লায়ার বা ডেটা.টিটেবলের সাথে প্রোগ্রামিংয়ের তুলনায় উল্লেখযোগ্যভাবে দ্রুত , বিশেষত ছোট ডেটাতে, তবে বড় ডেটাতেও

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.