কোনও আর সেশনে উপলভ্য মেমরিটি পরিচালনা করার কৌশল

Question

একটি ইন্টারেক্টিভ আর সেশনের উপলভ্য মেমরিটি পরিচালনা করতে লোকেরা কোন কৌশল ব্যবহার করে? আমি নীচের ফাংশনগুলি [পেট্র পিকাল এবং ডেভিড হিন্ডসের পোস্টের উপর ভিত্তি করে ২০০৪-এর আর-সহায়তার তালিকায়] বৃহত্তম অবজেক্টের তালিকা তৈরি করতে (এবং / অথবা বাছাই করা) এবং সেগুলির মধ্যে কিছু ঘটনাক্রমে rm()ব্যবহার করতে চাই। তবে এখন পর্যন্ত সবচেয়ে কার্যকর সমাধানটি ছিল ... যথেষ্ট স্মৃতি নিয়ে .৪-বিট লিনাক্সের অধীনে চালানো।

অন্য কোনও সুন্দর কৌশল লোকেরা ভাগ করতে চান? প্রতি পোস্টে একজন, দয়া করে।

# improved list of objects
.ls.objects <- function (pos = 1, pattern, order.by,
                        decreasing=FALSE, head=FALSE, n=5) {
    napply <- function(names, fn) sapply(names, function(x)
                                         fn(get(x, pos = pos)))
    names <- ls(pos = pos, pattern = pattern)
    obj.class <- napply(names, function(x) as.character(class(x))[1])
    obj.mode <- napply(names, mode)
    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
    obj.size <- napply(names, object.size)
    obj.dim <- t(napply(names, function(x)
                        as.numeric(dim(x))[1:2]))
    vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
    obj.dim[vec, 1] <- napply(names, length)[vec]
    out <- data.frame(obj.type, obj.size, obj.dim)
    names(out) <- c("Type", "Size", "Rows", "Columns")
    if (!missing(order.by))
        out <- out[order(out[[order.by]], decreasing=decreasing), ]
    if (head)
        out <- head(out, n)
    out
}
# shorthand
lsos <- function(..., n=10) {
    .ls.objects(..., order.by="Size", decreasing=TRUE, head=TRUE, n=n)
}

Comments

দ্রষ্টব্য, আমি এতে সন্দেহ করি না, তবে এর ব্যবহার কী? আমি আর-তে মেমরির সমস্যার ক্ষেত্রে বেশ নতুন, তবে আমি ইদানীং কিছুটা অভিজ্ঞতার মুখোমুখি হয়েছি (এ কারণেই আমি এই পোস্টটি সন্ধান করছিলাম :) - তাই আমি কেবল এই সমস্তটি দিয়েই শুরু করছি। এটি কীভাবে আমার প্রতিদিনের কাজে সহায়তা করে?

— ম্যাট ব্যানার

যদি আপনি কোনও ফাংশনের মধ্যে অবজেক্টগুলি দেখতে চান তবে আপনাকে ব্যবহার করতে হবে: lsos (pos = পরিবেশ ()), অন্যথায় এটি কেবল বিশ্বব্যাপী ভেরিয়েবলগুলি প্রদর্শন করবে। স্ট্যান্ডার্ড ত্রুটিতে লিখতে: write.table (lsos (pos = পরিবেশ ()), স্টার্ডার (), উক্তি = FALSE, sep = '' t ')

— মাইকেল কুহন

কেন 64-বিট লিনাক্স এবং 64-বিট উইন্ডোজ নয়? আমার কাছে ৩২ জিবি র‌্যাম ব্যবহার করার পরে ওএস-এর পছন্দটি কি কোনও বেআইনী তাত্পর্য তৈরি করে?

— জেস 10

@pepsimax: এটি প্যাকেজ হয়েছে multilevelPSAপ্যাকেজ । প্যাকেজটি অন্য কোনও কিছুর জন্য ডিজাইন করা হয়েছে তবে আপনি প্যাকেজটি লোড না করে সেখান থেকে ফাংশনটি ব্যবহার করতে পারেন requireNamespace(multilevelPSA); multilevelPSA::lsos(...)। বা Dmiscপ্যাকেজে (CRAN এ নয়)।

— krlmlr

যদি ডেটা সেটটি পরিচালনাযোগ্য আকারের হয় তবে আমি সাধারণত আর স্টুডিও> পরিবেশ> গ্রিড ভিউতে যাই। এখানে আপনি আকারের উপর নির্ভর করে আপনার বর্তমান পরিবেশে সমস্ত আইটেম দেখতে এবং বাছাই করতে পারেন।

— kRazzy আর

Answer 1

নিশ্চিত করুন যে আপনি আপনার কাজকে একটি পুনরুত্পাদনযোগ্য স্ক্রিপ্টে রেকর্ড করবেন। সময়ে সময়ে, পুনরায় খুলুন, তারপরে source()আপনার স্ক্রিপ্ট। আপনি আর ব্যবহার করছেন না এমন কোনও জিনিস আপনি মুছে ফেলবেন এবং একটি অতিরিক্ত সুবিধা হিসাবে আপনার কোডটি পরীক্ষা করে নেবে।

Comments

আমার কৌশলটি হ'ল আমার স্ক্রিপ্টগুলি লোড.আর এবং ড.আর এর লাইন ধরে ভেঙে দেওয়া, যেখানে লোড.আর ফাইল বা একটি ডাটাবেস থেকে ডেটা লোড করতে বেশ কিছুটা সময় নিতে পারে এবং কোনও ন্যূনতম প্রাক-প্রক্রিয়াজাতকরণ / মার্জ করে যে তথ্য। লোডের শেষ লাইন.আর ওয়ার্কস্পেসের অবস্থাটি সংরক্ষণ করার জন্য কিছু। তারপরে do.R হ'ল আমার স্ক্র্যাচপ্যাড যার মাধ্যমে আমি আমার বিশ্লেষণের কার্যগুলি তৈরি করি। আমি প্রায়শই do.R পুনরায় লোড করি (প্রয়োজনের সাথে লোড.আর থেকে ওয়ার্কস্পেসের স্থিতি পুনরায় লোড না করে)।

— জোশ রিখ

এটি একটি ভাল কৌশল। ফাইলগুলি যে মত একটি নির্দিষ্ট অনুক্রমে চালিত হয়, আমি প্রায়ই একটি সংখ্যা সঙ্গে তাদের উপসর্গ: 1-load.r, 2-explore.r, 3-model.r- যে এটা অন্যদের কাছে সুস্পষ্ট কিছু অর্ডার উপস্থিত হয়।

— হ্যাডলি

আমি এই ধারণাটি যথেষ্ট পরিমাণে ব্যাক আপ করতে পারি না। আমি কয়েকটি লোককে আর শিখিয়েছি এবং এটি আমার প্রথম কথাগুলির মধ্যে একটি। এটি যে কোনও ভাষার ক্ষেত্রেও প্রযোজ্য যেখানে উন্নয়ন একটি আরপিএল এবং সম্পাদিত একটি ফাইল (অর্থাত পাইথন) অন্তর্ভুক্ত করে। rm (ls = list ()) এবং উত্স () খুব কার্যকর, তবে পুনরায় খোলার কাজটি ভাল (প্যাকেজগুলি সাফ হয়ে গেছে)।

— ভিনস

শীর্ষ ভোটের উত্তরে আর পুনরায় চালু করা জড়িত এই বিষয়টি আর-এর সবচেয়ে খারাপ সমালোচনা।

— এসডিএস

@ মার্টনবেল যা কেবলমাত্র বিশ্বব্যাপী পরিবেশে তৈরি বস্তুগুলি সরিয়ে দেয়। এটি প্যাকেজগুলি বা এস 4 অবজেক্টস বা অন্যান্য অনেক কিছুই আনলোড করে না।

— হ্যাডলি

Answer 2

আমি ডেটা টেবিল প্যাকেজটি ব্যবহার করি । এর :=অপারেটরের সাহায্যে আপনি এটি করতে পারেন:

• রেফারেন্স অনুসারে কলাম যুক্ত করুন
• রেফারেন্স দ্বারা এবং গ্রুপ দ্বারা রেফারেন্স দ্বারা বিদ্যমান কলামগুলির সাবসেটগুলি সংশোধন করুন
• রেফারেন্স দিয়ে কলামগুলি মুছুন

এই অপারেশনগুলির কোনওটিই (সম্ভাব্য বৃহত) একবারেও অনুলিপি করে data.tableনা।

• সমষ্টিটি বিশেষত দ্রুত কারণ কারণ data.tableখুব কম কাজের মেমরি ব্যবহার করে।

সম্পর্কিত লিংক :

• ডেটা টেবিলের সংবাদ, লন্ডন আর উপস্থাপনা, ২০১২
• আমি কখন :=ডেটা টেবিলটিতে অপারেটরটি ব্যবহার করব?

Answer 3

এটি একটি টুইটার পোস্টে দেখেছেন এবং মনে করুন এটি ডার্কের দ্বারা দুর্দান্ত কাজ! জেডি লং এর উত্তর অনুসরণ করে, আমি ব্যবহারকারী বান্ধব পড়ার জন্য এটি করব:

# improved list of objects
.ls.objects <- function (pos = 1, pattern, order.by,
                        decreasing=FALSE, head=FALSE, n=5) {
    napply <- function(names, fn) sapply(names, function(x)
                                         fn(get(x, pos = pos)))
    names <- ls(pos = pos, pattern = pattern)
    obj.class <- napply(names, function(x) as.character(class(x))[1])
    obj.mode <- napply(names, mode)
    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
    obj.prettysize <- napply(names, function(x) {
                           format(utils::object.size(x), units = "auto") })
    obj.size <- napply(names, object.size)
    obj.dim <- t(napply(names, function(x)
                        as.numeric(dim(x))[1:2]))
    vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
    obj.dim[vec, 1] <- napply(names, length)[vec]
    out <- data.frame(obj.type, obj.size, obj.prettysize, obj.dim)
    names(out) <- c("Type", "Size", "PrettySize", "Length/Rows", "Columns")
    if (!missing(order.by))
        out <- out[order(out[[order.by]], decreasing=decreasing), ]
    if (head)
        out <- head(out, n)
    out
}

# shorthand
lsos <- function(..., n=10) {
    .ls.objects(..., order.by="Size", decreasing=TRUE, head=TRUE, n=n)
}

lsos()

যা নিম্নলিখিতগুলির মতো কিছুতে ফলাফল দেয়:

                      Type   Size PrettySize Length/Rows Columns
pca.res                 PCA 790128   771.6 Kb          7      NA
DF               data.frame 271040   264.7 Kb        669      50
factor.AgeGender   factanal  12888    12.6 Kb         12      NA
dates            data.frame   9016     8.8 Kb        669       2
sd.                 numeric   3808     3.7 Kb         51      NA
napply             function   2256     2.2 Kb         NA      NA
lsos               function   1944     1.9 Kb         NA      NA
load               loadings   1768     1.7 Kb         12       2
ind.sup             integer    448  448 bytes        102      NA
x                 character     96   96 bytes          1      NA

দ্রষ্টব্য: আমি যে প্রধান অংশটি যুক্ত করেছি তা হ'ল (আবার, জেডি এর উত্তর থেকে অভিযোজিত):

obj.prettysize <- napply(names, function(x) {
                           print(object.size(x), units = "auto") })

Comments

এই ফাংশনটি dplyr বা কিছু অন্যান্য কী প্যাকেজের সাথে যুক্ত করা যেতে পারে?

— ইউজারজেটি

লক্ষ করার মতো যে (কমপক্ষে বেস -৩.৩.২ সহ) capture.outputআর প্রয়োজনীয় নয়, এবং obj.prettysize <- napply(names, function(x) {format(utils::object.size(x), units = "auto") })পরিষ্কার আউটপুট উত্পাদন করে। আসলে, এটি অপসারণ না করে আউটপুটগুলিতে অর্থাত্ [1] "792.5 Mb"পরিবর্তে অযাচিত উদ্ধৃতি উত্পন্ন করে 792.5 Mb।

— বাদাম

@ নিউটল অসাধারণ, আমি সেই অনুযায়ী কোডটি আপডেট করেছি :)

— টনি ব্রেকিয়াল

আমি এখন থেকে সর্বদা অক্ষরের একটি ভেক্টরকে এখনই ফিরিয়ে obj.class <- napply(names, function(x) as.character(class(x))[1])আনতে চাই (বেস -৩.০.০)। obj.class <- napply(names, function(x) class(x)[1])class

— ডেল্টাভ

Answer 4

রিগ্রেশন ফাংশনের যুক্তিতে subsetডেটাফ্রেমগুলি পাস করার সময় আমি কেবলমাত্র প্রয়োজনীয় ভেরিয়েবলগুলি নির্বাচন করে প্যারামিটারের আক্রমণাত্মক ব্যবহার করি data=। যদি আমি সূত্র এবং select=ভেক্টর উভয়কেই ভেরিয়েবল যুক্ত করতে ভুলে যাই তবে এর ফলে কিছু ত্রুটি ঘটায় তবে বস্তুর অনুলিপি হ্রাসের কারণে এটি এখনও অনেক সময় সাশ্রয় করে এবং মেমরির পদক্ষেপকে উল্লেখযোগ্যভাবে হ্রাস করে। বলুন আমার ১১০ টি ভেরিয়েবল (এবং আমি করি)) এর সাথে 4 মিলিয়ন রেকর্ড রয়েছে উদাহরণ:

# library(rms); library(Hmisc) for the cph,and rcs functions
Mayo.PrCr.rbc.mdl <- 
cph(formula = Surv(surv.yr, death) ~ age + Sex + nsmkr + rcs(Mayo, 4) + 
                                     rcs(PrCr.rat, 3) +  rbc.cat * Sex, 
     data = subset(set1HLI,  gdlab2 & HIVfinal == "Negative", 
                           select = c("surv.yr", "death", "PrCr.rat", "Mayo", 
                                      "age", "Sex", "nsmkr", "rbc.cat")
   )            )

প্রসঙ্গ এবং কৌশল নির্ধারণের পদ্ধতিতে: gdlab2চলকটি একটি লজিকাল ভেক্টর যা একটি ডেটাসেটের বিষয়গুলির জন্য নির্মিত হয়েছিল যা পরীক্ষাগার পরীক্ষার জন্য একসাথে সমস্ত স্বাভাবিক বা প্রায় সাধারণ মান HIVfinalছিল এবং এইচআইভির প্রাথমিক এবং নিশ্চিতকরণ পরীক্ষার সংক্ষিপ্তসারকারী একটি চরিত্র ভেক্টর ছিল was ।

Answer 5

আমি ডার্কের .ls.objects () স্ক্রিপ্টটি পছন্দ করি তবে আকার কলামে অক্ষর গণনা করতে আমি স্কুইটিং করতে থাকি। তাই আকারের জন্য সুন্দর বিন্যাস সহ এটি উপস্থাপনের জন্য আমি কিছু কুরুচিপূর্ণ হ্যাক করেছি:

.ls.objects <- function (pos = 1, pattern, order.by,
                        decreasing=FALSE, head=FALSE, n=5) {
    napply <- function(names, fn) sapply(names, function(x)
                                         fn(get(x, pos = pos)))
    names <- ls(pos = pos, pattern = pattern)
    obj.class <- napply(names, function(x) as.character(class(x))[1])
    obj.mode <- napply(names, mode)
    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
    obj.size <- napply(names, object.size)
    obj.prettysize <- sapply(obj.size, function(r) prettyNum(r, big.mark = ",") )
    obj.dim <- t(napply(names, function(x)
                        as.numeric(dim(x))[1:2]))
    vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
    obj.dim[vec, 1] <- napply(names, length)[vec]
    out <- data.frame(obj.type, obj.size,obj.prettysize, obj.dim)
    names(out) <- c("Type", "Size", "PrettySize", "Rows", "Columns")
    if (!missing(order.by))
        out <- out[order(out[[order.by]], decreasing=decreasing), ]
        out <- out[c("Type", "PrettySize", "Rows", "Columns")]
        names(out) <- c("Type", "Size", "Rows", "Columns")
    if (head)
        out <- head(out, n)
    out
}

Answer 6

এটি একটি ভাল কৌশল।

অন্য একটি পরামর্শ হ'ল মেমরি দক্ষ বস্তুগুলি যেখানেই সম্ভব ব্যবহার করুন: উদাহরণস্বরূপ, ডেটা.ফ্রেমের পরিবর্তে ম্যাট্রিক্স ব্যবহার করুন।

এটি মেমরি ম্যানেজমেন্টকে সত্যিই সম্বোধন করে না, তবে একটি গুরুত্বপূর্ণ ফাংশন যা বহুলভাবে জানা যায় না তা হ'ল মেমরি.লিট ()। আপনি এই কমান্ডটি ব্যবহার করে ডিফল্ট বৃদ্ধি করতে পারেন, মেমরি.লিট (আকার = 2500), যেখানে আকার এমবিতে থাকে। ডার্ক যেমন উল্লেখ করেছেন, এর আসল সুবিধা নিতে আপনার প্রয়োজন 64-বিট ব্যবহার করা।

Comments

এটি কি কেবল উইন্ডোজে প্রযোজ্য নয়?

— ক্রিস্টোফার ডুবুইস

> memory.limit () [1] ইনফ সতর্কতা বার্তা: 'મેમરી.limit ()' উইন্ডোজ-নির্দিষ্ট

— এলজেটি

ডেটা পরিবর্তে টিবল ব্যবহার করা কি ফ্রেম আমাদের স্মৃতিশক্তি বাঁচাতে আরও উন্নত করে?

Answer 7

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

showMemoryUse <- function(sort="size", decreasing=FALSE, limit) {

  objectList <- ls(parent.frame())

  oneKB <- 1024
  oneMB <- 1048576
  oneGB <- 1073741824

  memoryUse <- sapply(objectList, function(x) as.numeric(object.size(eval(parse(text=x)))))

  memListing <- sapply(memoryUse, function(size) {
        if (size >= oneGB) return(paste(round(size/oneGB,2), "GB"))
        else if (size >= oneMB) return(paste(round(size/oneMB,2), "MB"))
        else if (size >= oneKB) return(paste(round(size/oneKB,2), "kB"))
        else return(paste(size, "bytes"))
      })

  memListing <- data.frame(objectName=names(memListing),memorySize=memListing,row.names=NULL)

  if (sort=="alphabetical") memListing <- memListing[order(memListing$objectName,decreasing=decreasing),] 
  else memListing <- memListing[order(memoryUse,decreasing=decreasing),] #will run if sort not specified or "size"

  if(!missing(limit)) memListing <- memListing[1:limit,]

  print(memListing, row.names=FALSE)
  return(invisible(memListing))
}

এবং এখানে কিছু উদাহরণ আউটপুট:

> showMemoryUse(decreasing=TRUE, limit=5)
      objectName memorySize
       coherData  713.75 MB
 spec.pgram_mine  149.63 kB
       stoch.reg  145.88 kB
      describeBy    82.5 kB
      lmBandpass   68.41 kB

Answer 8

আমি কখনই কোনও আর ওয়ার্কস্পেস সংরক্ষণ করি না। আমি আমদানি স্ক্রিপ্ট এবং ডেটা স্ক্রিপ্ট ব্যবহার করি এবং বিশেষত কোনও বড় ডেটা অবজেক্ট আউটপুট করি যা আমি প্রায়শই ফাইলগুলিতে পুনরায় তৈরি করতে চাই না। এইভাবে আমি সর্বদা একটি নতুন ওয়ার্কস্পেস দিয়ে শুরু করি এবং বড় অবজেক্টগুলি পরিষ্কার করার দরকার নেই। যদিও এটি একটি খুব সুন্দর ফাংশন।

Answer 9

দুর্ভাগ্যক্রমে আমার এটির ব্যাপকভাবে পরীক্ষা করার সময় ছিল না তবে এখানে একটি স্মৃতি টিপ রয়েছে যা আমি আগে দেখিনি। আমার জন্য প্রয়োজনীয় মেমরিটি 50% এরও বেশি হ্রাস পেয়েছিল। আপনি যখন আর-তে স্টাফ পড়েন উদাহরণস্বরূপ read.csv এর জন্য তাদের একটি নির্দিষ্ট পরিমাণের স্মৃতি দরকার। এর পরে আপনি এগুলি সেভ করতে পারবেন save("Destinationfile",list=ls()) পরের বার আপনি আর খুললে আপনি load("Destinationfile") এখন ব্যবহার করতে পারবেন মেমরির ব্যবহার হ্রাস পেয়েছে। এটি কোনও ভিন্ন ডেটাসেটের সাথে একই রকম ফলাফল উত্পন্ন করে কিনা তা যদি কেউ নিশ্চিত করতে পারত তবে ভাল লাগবে।

Comments

হ্যাঁ, আমিও একই অভিজ্ঞতা পেয়েছি। আমার ক্ষেত্রে স্মৃতি ব্যবহারের পরিমাণ এমনকি 30% এ নেমে আসে। 1.5 গিগাবাইট মেমরি ব্যবহার করা হয়েছে .RData (~ 30MB) এ সংরক্ষণ করা হয়েছে। লোড করার পরে নতুন অধিবেশন .আরডেটা 500 এমবি এর চেয়ে কম মেমরি ব্যবহার করে।

— f3lix

আমি ডেটা-টেবিলের সাহায্যে লোড হওয়া 2 ডেটাসেট (100MB এবং 2.7 গিগাবাইট) দিয়ে চেষ্টা করেছি fread, তারপরে .আরডিটাতে সংরক্ষণ করেছি। আরডিটা ফাইলগুলি প্রকৃতপক্ষে প্রায় 70% ছোট ছিল তবে পুনরায় লোড করার পরে ব্যবহৃত মেমরিটি একই রকম ছিল। আশা করছিলাম যে এই কৌশলটি মেমরির পদচিহ্নগুলি হ্রাস করবে ... আমি কি কিছু মিস করছি?

— নভিশপোগ

@ নভিশপ্রোগ আমি মনে করি না যে আপনি কিছু হারিয়েছেন, তবে এটি একটি কৌশল, আমি অনুমান করি এটি সমস্ত পরিস্থিতিতে কার্যকর হবে না। আমার ক্ষেত্রে পুনরায় লোড করার পরে স্মৃতিটি বর্ণিত হিসাবে হ্রাস পেয়েছে।

— ডেনিস জাহেরুদ্দিন

পছন্দ করুন প্রথমত, ভয়ঙ্কর, নিম্নলিখিত ডেটা. টেবিলের ক্রেডো সম্ভবত রিড সিএসভি-র চেয়ে ফাইল লোড করার ক্ষেত্রে আরও মেমরির দক্ষ। দ্বিতীয়ত, মেমরি সঞ্চয় লোকেরা এখানে লক্ষ করছে যে মূলত আর প্রক্রিয়াটির মেমরি আকারের সাথে করতে হবে (যা আবর্জনা সংগ্রহ করার সময় বস্তুগুলি ধরে রাখতে এবং প্রত্যাহার করতে প্রসারিত হয়)। তবে আবর্জনা সংগ্রহ সবসময় র‍্যামের সমস্ত কিছুই ওএস-এ ছেড়ে দেয় না। আর সেশনটি থামানো এবং আইটেমটি এটি সংরক্ষণ করা হয়েছে সেখান থেকে লোড করা যতটা সম্ভব র‌্যাম প্রকাশ করবে ... তবে যদি ওভারহেড শুরু করা ছোট ছিল ... কোনও লাভ নেই।

— রাসেলপিয়ার্স

Answer 10

ঘন ঘন পুনঃসূচনাগুলির সাধারণ কৌশলটি আরও চিত্রিত করার জন্য, আমরা লিটার ব্যবহার করতে পারি যা কমান্ড-লাইন থেকে আমাদের সরাসরি অভিব্যক্তি চালানোর অনুমতি দেয়। এখানে একটি উদাহরণ যা আমি মাঝে মাঝে একটি সাধারণ ক্রসপডের জন্য বিভিন্ন বিএলএএস টাইম করি।

 r -e'N<-3*10^3; M<-matrix(rnorm(N*N),ncol=N); print(system.time(crossprod(M)))'

একইভাবে,

 r -lMatrix -e'example(spMatrix)'

ম্যাট্রিক্স প্যাকেজ লোড করে (--packages | -l সুইচের মাধ্যমে) এবং spMatrix ফাংশনের উদাহরণ চালায়। যেহেতু সবসময় 'ফ্রেশ' শুরু হয়, প্যাকেজ বিকাশের সময় এই পদ্ধতিটিও একটি ভাল পরীক্ষা।

'#! / Usr / bin / r' শেবাং-শিরোনামটি ব্যবহার করে স্ক্রিপ্টগুলিতে স্বয়ংক্রিয় ব্যাচ মোডের জন্য সর্বশেষ তবে অন্তত r নয় দুর্দান্ত কাজ করে। রুপি স্ক্রিপ্ট এমন বিকল্প যেখানে ছোট্ট অনুপলব্ধ (যেমন উইন্ডোজে)।

Answer 11

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

dfinal <- NULL
first <- TRUE
tempfile <- "dfinal_temp.csv"
for( i in bigloop ) {
    if( !i %% 10000 ) { 
        print( i, "; flushing to disk..." )
        write.table( dfinal, file=tempfile, append=!first, col.names=first )
        first <- FALSE
        dfinal <- NULL   # nuke it
    }

    # ... complex operations here that add data to 'dfinal' data frame  
}
print( "Loop done; flushing to disk and re-reading entire data set..." )
write.table( dfinal, file=tempfile, append=TRUE, col.names=FALSE )
dfinal <- read.table( tempfile )

Answer 12

কেবলমাত্র নোট করুন যে data.tableপ্যাকেজটি tables()ডার্কের .ls.objects()কাস্টম ফাংশনের (পূর্ববর্তী উত্তরগুলিতে বিশদ) বিশিষ্ট একটি ভাল প্রতিস্থাপন বলে মনে হচ্ছে , যদিও কেবল ডাটা.ফ্রেম / টেবিলের জন্য এবং যেমন ম্যাট্রিক, অ্যারে, তালিকার জন্য নয়।

Comments

এটি কোনও

— ডেটা.ফ্রেমে তালিকাবদ্ধ করে

Answer 13

1. আমি ভাগ্যবান এবং আমার বড় ডেটা সেটগুলি প্রায় 100 এমবি (32 বিট বাইনারি) এর "অংশগুলি" (সাবসেট) এ ইনস্ট্রুমেন্ট দ্বারা সংরক্ষণ করা হয়। সুতরাং আমি ডেটা সেটটি ফিউজ করার আগে ক্রমহীন প্রাক প্রসেসিং পদক্ষেপগুলি (অপ্রয়োজনীয় অংশগুলি মুছে ফেলা, ডাউনস্যাম্পলিং) করতে পারি।

2. gc ()"হাত ধরে" কল করা যদি ডেটার আকার উপলব্ধ মেমরির কাছাকাছি আসে তবে সহায়তা করতে পারে।

3. কখনও কখনও একটি পৃথক অ্যালগরিদমের স্মৃতিশক্তি খুব কম হয়।
   কখনও কখনও ভেক্টরাইজেশন এবং মেমরি ব্যবহারের মধ্যে একটি বাণিজ্য বন্ধ থাকে।
   তুলনা করুন: splitএবং lapplyবনাম একটি forলুপ।

4. দ্রুত এবং সহজ ডেটা বিশ্লেষণের স্বার্থে, আমি প্রায়শই একটি ছোট এলোমেলো উপসেট নিয়ে প্রথম কাজ করি (sample () ) নিয়ে । একবার ডেটা অ্যানালাইসিস স্ক্রিপ্ট / .আরএনডাব্লু ডেটা এনালাইসিস কোড শেষ হয়ে গেলে এবং পুরো ডেটা বেশি রাত / সপ্তাহান্তে / ... গণনার জন্য গণনা সার্ভারে যায়।

Answer 14

কার্যক্ষম স্মৃতিশক্তি একটি উল্লেখযোগ্য পরিমাণ দখল করে এমন বস্তুর সংগ্রহগুলি পরিচালনা করতে তালিকার পরিবর্তে পরিবেশের ব্যবহার।

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

এখানে একটি উদাহরণ:

get.data <- function(x)
{
  # get some data based on x
  return(paste("data from",x))
}

collect.data <- function(i,x,env)
{
  # get some data
  data <- get.data(x[[i]])
  # store data into environment
  element.name <- paste("V",i,sep="")
  env[[element.name]] <- data
  return(NULL)  
}

better.list <- new.env()
filenames <- c("file1","file2","file3")
lapply(seq_along(filenames),collect.data,x=filenames,env=better.list)

# read/write access
print(better.list[["V1"]])
better.list[["V2"]] <- "testdata"
# number of list elements
length(ls(better.list))

কাঠামোগুলির সাথে যেমন big.matrixবা data.tableযেগুলি তাদের সামগ্রীগুলিকে স্থানে পরিবর্তনের জন্য মঞ্জুরি দেয়, খুব দক্ষ মেমরির ব্যবহার অর্জন করা যায়।

Comments

এটি আর সত্য নয়: হ্যাডলির উন্নত আর থেকে , "৩.১.০-তে পরিবর্তনগুলি এই ব্যবহারকে [পরিবেশের] যথেষ্ট পরিমাণে কম গুরুত্বপূর্ণ করেছে কারণ একটি তালিকা পরিবর্তন করে আর কোনও অনুলিপি তৈরি করা হয় না।"

— পেট্রেলহর্প

Answer 15

llফাংশন gDataপ্যাকেজ প্রতিটি বস্তুর মেমোরি ব্যবহার পাশাপাশি দেখাতে পারেন।

gdata::ll(unit='MB')

Comments

আমার সিস্টেমে নেই: আর সংস্করণ 3.1.1 (2014-07-10), x86_64-pc-linux-gnu (64-বিট), gdata_2.13.3, gtools_3.4.1।

— krlMLr

আপনি ঠিক বলেছেন আমি একবার এটি সুযোগ দিয়ে আদেশ দেওয়া হয়েছিল পরে পরীক্ষা!

— ব্যবহারকারী 1436187

দয়া করে জিবি, এমবি

— ব্যবহারকারী জেটি

Answer 16

আপনি যদি সত্যিই ফাঁসগুলি এড়াতে চান তবে বিশ্ব পরিবেশে আপনার কোনও বড় বস্তু তৈরি করা এড়ানো উচিত।

আমি সাধারণত যা করি তা হ'ল একটি ফাংশন যা কাজটি করে এবং ফিরে আসে NULL- সমস্ত ডেটা এই ফাংশনটিতে বা অন্যদের যা কল করে তা পড়তে হয় এবং ম্যানিপুলেটেড হয়।

Answer 17

মাত্র 4 জিবি র‌্যামের সাথে (উইন্ডোজ 10 চালানো, সুতরাং প্রায় 2 বা আরও বাস্তবসম্মতভাবে 1GB করুন) বরাদ্দটি সম্পর্কে আমাকে সত্যই যত্নবান হতে হয়েছিল।

আমি ডেটা.ট্যাবলটি প্রায় একচেটিয়াভাবে ব্যবহার করি।

'ফ্রিড' ফাংশন আপনাকে আমদানিতে ক্ষেত্রের নাম অনুসারে তথ্য উপসেট করতে দেয়; কেবলমাত্র সেই ক্ষেত্রগুলি আমদানি করুন যা শুরু করতে প্রয়োজন। আপনি যদি বেস আর রিড ব্যবহার করছেন তবে আমদানির পরপরই স্পিউরিয়াস কলামগুলি বাতিল করুন।

৪২- হিসাবে প্রস্তাবিত হয়েছে, যেখানেই সম্ভব আমি তথ্যটি আমদানির পরপরই কলামগুলির মধ্যে সাবসেট করব।

আমি প্রায়শই পরিবেশ থেকে বস্তুগুলিকে আরএমএস () এর আর প্রয়োজন না হওয়ার সাথে সাথেই দেখি, যেমন অন্য কিছু সাবসেট করতে তাদের ব্যবহারের পরের লাইনে এবং জিসি () কল করুন।

ডেটা থেকে 'ফ্রেড' এবং 'ফ্রিটাইট' বেজ আর পড়া এবং লেখার সাথে তুলনা করে খুব দ্রুত হতে পারে ।

হিসাবে kpierce8 প্রস্তাব দেওয়া, আমি প্রায় সবসময় পরিবেশের বাইরে কি fwrite সবকিছু এবং এটা ফিরে fread, এমনকি ছোট ফাইল মাধ্যমে পেতে হাজার হাজার হাজার / শত শত। এটি কেবল পরিবেশকে 'পরিষ্কার' রাখে না এবং মেমরির বরাদ্দকে কম রাখে তবে সম্ভবত র‍্যামের তীব্র অভাবের কারণে, আমার কম্পিউটারে প্রায়শই ক্র্যাশ হওয়ার প্রবণতা রয়েছে; সত্যিই ঘন ঘন। কোডটি বিভিন্ন পর্যায়ে এগিয়ে যাওয়ার সাথে সাথেই ড্রাইভে নিজেই তথ্য ব্যাক আপ করে রাখার অর্থ হ'ল ক্রাশ হয়ে গেলে আমাকে শুরু থেকে শুরু করতে হবে না।

2017 হিসাবে, আমি মনে করি দ্রুততম এসএসডি এম 2 বন্দর দিয়ে কয়েক সেকেন্ডে কয়েক গিগাবাইটের কাছাকাছি চলছে। আমার কাছে সত্যিই বেসিক 50 জিবি কিংস্টন ভি 300 (এসএসডি) রয়েছে যা আমি আমার প্রাথমিক ডিস্ক হিসাবে ব্যবহার করি (এতে উইন্ডোজ এবং আর রয়েছে)। আমি সমস্ত বাল্কের তথ্য একটি সস্তা 500 জিবি ডাব্লুডি প্ল্যাটারে রাখি on আমি এসএসডি-তে ডেটা সেটগুলি যখন কাজ শুরু করি তখন তা সরান। এটি, 'ফ্রিডিং' এবং 'লিখিতকরণ' সবকিছু মিলিয়ে দুর্দান্ত কাজ করছে। আমি 'ff' ব্যবহার করার চেষ্টা করেছি তবে আগেরটি পছন্দ করি prefer 4K পড়ার / লেখার গতি এটির সাথে সমস্যা তৈরি করতে পারে; এসএসডি থেকে প্ল্যাটারে এক মিলিয়ন 1 কে ফাইল (250MBs মূল্য) ব্যাক আপ করতে কয়েক ঘন্টা সময় নিতে পারে। যতদূর আমি সচেতন, এখনও কোনও আর প্যাকেজ উপলব্ধ নেই যা স্বয়ংক্রিয়ভাবে 'শঙ্কিফিকেশন' প্রক্রিয়াটিকে অনুকূল করতে পারে; উদাহরণস্বরূপ ব্যবহারকারীর কতটা র‌্যাম রয়েছে তা দেখুন র‌্যামের / পড়ার গতি পরীক্ষা করুন / সংযুক্ত সমস্ত ড্রাইভ এবং তারপরে একটি অনুকূল 'শঙ্কিফিকেশন' প্রোটোকল প্রস্তাব করুন। এটি কিছু উল্লেখযোগ্য ওয়ার্কফ্লো উন্নতি / সংস্থান উত্সকরণ করতে পারে; যেমন এটিকে বিভক্ত করুন ... র‌্যামের জন্য এমবি -> এটিকে বিভক্ত করুন ... এসএসডি এর জন্য এমবি -> এটিকে বিভক্ত করুন ... প্ল্যাটারে এমবি -> এটিকে বিভক্ত করুন ... টেপটিতে এমবি করুন। এটি থেকে আরও বাস্তবসম্মত গেজ স্টিকটি দেওয়ার জন্য এটি ডেটা সেটগুলি আগেই নমুনা করতে পারে।

আরে আমি যে সমস্যার মুখোমুখি হয়েছি সেগুলির মধ্যে অনেকগুলি সংমিশ্রণ এবং ক্রম জুটি, ট্রিপল ইত্যাদি গঠন অন্তর্ভুক্ত রয়েছে যা কেবলমাত্র সীমিত র‌্যামের সীমাবদ্ধতা বেশি করে তোলে কারণ তারা প্রায়শই কোনও কোনও সময়ে তাত্পর্যপূর্ণভাবে প্রসারিত হবে। এটি আমার উপর মনোযোগ অনেকটা ফোকাস করেছেন মানের যেমন উল্টোদিকে পরিমাণ তথ্য তাদের মধ্যে যাওয়া বরং পরে এটা পরিষ্কার করতে চেষ্টা করার পরিবর্তে, দিয়ে শুরু করতে, এবং (দিয়ে শুরু দিয়ে শুরু করতে তথ্য প্রস্তুত অপারেশনের ক্রম উপর সহজ অপারেশন এবং জটিলতা বৃদ্ধি); যেমন সাবসেট, তারপরে মার্জ / জয়েন করুন, তারপরে কম্বিনেশন / ক্রমায়ন গঠন করুন etc.

কিছু বেস বেস পড়তে এবং লিখতে কিছু সুবিধা আছে বলে মনে হচ্ছে। উদাহরণস্বরূপ, 'ফ্রেড' এর মধ্যে ত্রুটি সনাক্তকরণ এত ভাল যে এটি পরিষ্কার করার জন্য আর এর মধ্যে সত্যিই অগোছালো তথ্য পাওয়ার চেষ্টা করা কঠিন হতে পারে। আপনি লিনাক্স ব্যবহার করলে বেস আর অনেক সহজ বলে মনে হয়। বেস আর লিনাক্সে দুর্দান্ত কাজ করে বলে মনে হয়, উইন্ডোজ 10 ~ 20 গিগাবাইটের ডিস্ক স্পেস ব্যবহার করে যেখানে উবুন্টুকে কেবল কয়েকটি জিবি প্রয়োজন হয়, উবুন্টু সহ র‌্যামটি কিছুটা কম হয়। তবে আমি (এল) উবুন্টুতে তৃতীয় পক্ষের প্যাকেজ ইনস্টল করার সময় বিপুল পরিমাণে সতর্কতা এবং ত্রুটি লক্ষ্য করেছি। আমি লিনাক্সের সাথে উবুন্টু বা অন্যান্য স্টক ডিস্ট্রিবিউশনগুলি থেকে খুব দূরে সরে যাওয়ার পরামর্শ দিচ্ছি না কারণ আপনি সামগ্রিক সামঞ্জস্যতাটি মুক্ত করতে পারেন এটি প্রক্রিয়াটিকে প্রায় অর্থহীন করে তোলে (আমার ধারণা 'উবুন্টুতে 2017 এর হিসাবে' unityক্য 'বাতিল হওয়ার কারণ রয়েছে) )।

আশা করি এর মধ্যে কিছু অন্যকে সাহায্য করতে পারে।

Answer 18

এটি উপরেরটিতে কিছুই জুড়ে না, তবে আমার পছন্দ মতো সহজ এবং ভারী মন্তব্য করা শৈলীতে লেখা হয়েছে। আকারে অর্ডার করা বস্তুগুলির সাথে এটি একটি টেবিল দেয়, তবে উপরের উদাহরণগুলিতে প্রদত্ত কিছু বিবরণ ছাড়াই:

#Find the objects       
MemoryObjects = ls()    
#Create an array
MemoryAssessmentTable=array(NA,dim=c(length(MemoryObjects),2))
#Name the columns
colnames(MemoryAssessmentTable)=c("object","bytes")
#Define the first column as the objects
MemoryAssessmentTable[,1]=MemoryObjects
#Define a function to determine size        
MemoryAssessmentFunction=function(x){object.size(get(x))}
#Apply the function to the objects
MemoryAssessmentTable[,2]=t(t(sapply(MemoryAssessmentTable[,1],MemoryAssessmentFunction)))
#Produce a table with the largest objects first
noquote(MemoryAssessmentTable[rev(order(as.numeric(MemoryAssessmentTable[,2]))),])

Answer 19

এটি এই দুর্দান্ত পুরানো প্রশ্নের নতুন উত্তর। হ্যাডলির অ্যাডভান্সড আর থেকে:

install.packages("pryr")

library(pryr)

object_size(1:10)
## 88 B

object_size(mean)
## 832 B

object_size(mtcars)
## 6.74 kB

( http://adv-r.had.co.nz/memory.html )

Answer 20

আপনার উপর কাজ করেন, তাহলে লিনাক্স এবং ব্যবহার করতে চান বিভিন্ন প্রসেস এবং শুধুমাত্র যা করতে হবে পঠিত এক বা একাধিক অপারেশন বৃহৎ বস্তু ব্যবহার makeForkClusterএকটি পরিবর্তে makePSOCKcluster। এটি অন্যান্য প্রক্রিয়াগুলিতে বড় অবজেক্টটি প্রেরণের সময় সাশ্রয় করে।

Answer 21

আমি @ হ্যাডলি এবং @ ডার্ককে অনুসরণ করে উপরের কয়েকটি জবাবের সত্যই প্রশংসা করি যা আর বন্ধ করার পরামর্শ দেয় sourceএবং কমান্ড লাইন জারি করে এবং ব্যবহার করে আমি এমন একটি সমাধান নিয়ে আসি যা আমার জন্য খুব ভালভাবে কাজ করেছিল। আমাকে শত শত ভর স্প্র্যাটার্সের সাথে ডিল করতে হয়েছিল, প্রতিটিই প্রায় 20 এমবি মেমরি দখল করে তাই আমি দুটি আর স্ক্রিপ্ট ব্যবহার করেছি, নিম্নরূপ:

প্রথমে একটি মোড়ক:

#!/usr/bin/Rscript --vanilla --default-packages=utils

for(l in 1:length(fdir)) {

   for(k in 1:length(fds)) {
     system(paste("Rscript runConsensus.r", l, k))
   }
}

এই স্ক্রিপ্টটির সাহায্যে আমি মূলত আমার মূল স্ক্রিপ্টটি কী তা নিয়ন্ত্রণ করি runConsensus.r এবং আমি আউটপুটটির জন্য ডেটা উত্তর লিখি। এটির সাহায্যে, প্রতিটি সময় মোড়ক স্ক্রিপ্টকে কল করে মনে হয় আর পুনরায় খোলা আছে এবং স্মৃতিটি মুক্ত হয়েছে।

আশা করি এটা সাহায্য করবে.

Answer 22

পাশাপাশি উপরের উত্তরে প্রদত্ত আরও সাধারণ মেমরি পরিচালনার কৌশলগুলি, আমি সর্বদা আমার বস্তুর আকার যতদূর সম্ভব হ্রাস করার চেষ্টা করি। উদাহরণস্বরূপ, আমি খুব বড় তবে খুব স্পার্স ম্যাট্রিক্স নিয়ে কাজ করি, অন্য কথায় ম্যাট্রিক যেখানে বেশিরভাগ মান শূন্য। 'ম্যাট্রিক্স' প্যাকেজটি ব্যবহার করে (মূলধন গুরুত্বপূর্ণ) আমি আমার গড় অবজেক্টের মাপগুলি 2GB থেকে 200MB হিসাবে কমিয়ে দিতে সক্ষম হয়েছি:

my.matrix <- Matrix(my.matrix)

ম্যাট্রিক্স প্যাকেজে এমন ডেটা ফর্ম্যাট রয়েছে যা নিয়মিত ম্যাট্রিক্সের মতো হ'ল ব্যবহার করা যেতে পারে (আপনার অন্যান্য কোড পরিবর্তন করার দরকার নেই) তবে স্মৃতিতে লোড হওয়া বা ডিস্কে সেভ করা হোক না কেন অনেক বেশি দক্ষতার সাথে স্পার্স ডেটা সংরক্ষণ করতে সক্ষম।

অতিরিক্তভাবে, আমি প্রাপ্ত কাঁচা ফাইলগুলি 'দীর্ঘ' ফর্ম্যাটে যেখানে প্রতিটি ডেটা পয়েন্টের ভেরিয়েবল থাকে x, y, z, i। x * y * zকেবলমাত্র ভেরিয়েবলের সাথে ডেটা ডাইমেনশন অ্যারে রূপান্তর করতে আরও বেশি দক্ষ i।

আপনার ডেটা জানুন এবং কিছুটা সাধারণ জ্ঞান ব্যবহার করুন।

Answer 23

ভারী মধ্যবর্তী গণনার প্রয়োজনযুক্ত বস্তুগুলির সাথে ডিল করার জন্য পরামর্শ: যখন এমন বস্তুগুলি ব্যবহার করতে হয় যেগুলি তৈরি করতে প্রচুর ভারী গণনা এবং মধ্যবর্তী পদক্ষেপের প্রয়োজন হয় তখন আমি প্রায়শই বস্তুটি তৈরি করতে ফাংশনটির সাথে একটি কোডের কিছু অংশ লিখতে দরকারী এবং তারপরে একটি পৃথক অংশ কোডের কোডটি আমাকে একটি rmdফাইল হিসাবে বস্তুটি উত্পন্ন এবং সংরক্ষণ করার বিকল্প দেয় বা rmdআমি ইতিমধ্যে সংরক্ষণ করা কোনও ফাইল থেকে বাহ্যিকভাবে লোড করতে পারি। R Markdownনিম্নলিখিত কোড-অংশ কাঠামোটি ব্যবহার করে এটি বিশেষত সহজ ।

```{r Create OBJECT}

COMPLICATED.FUNCTION <- function(...) { Do heavy calculations needing lots of memory;
                                        Output OBJECT; }

```
```{r Generate or load OBJECT}

LOAD <- TRUE;
#NOTE: Set LOAD to TRUE if you want to load saved file
#NOTE: Set LOAD to FALSE if you want to generate and save

if(LOAD == TRUE) { OBJECT <- readRDS(file = 'MySavedObject.rds'); } else
                 { OBJECT <- COMPLICATED.FUNCTION(x, y, z);
                             saveRDS(file = 'MySavedObject.rds', object = OBJECT); }

```

এই কোড কাঠামোর সাহায্যে আমাকে যা করতে হবে তা হ'ল LOADআমি অবজেক্টটি উত্পন্ন এবং সংরক্ষণ করতে চাই বা তার উপর নির্ভর করে কোনও বিদ্যমান সংরক্ষিত ফাইল থেকে সরাসরি লোড করতে চাই change (অবশ্যই, আমি এটি তৈরি এবং প্রথমবার এটি সংরক্ষণ করতে হবে, তবে এটির পরে আমার এটি লোড করার বিকল্প রয়েছে)) সেটআপ করা LOAD = TRUEআমার জটিল ফাংশনটির বাইপাসগুলি সেট করে এবং এতে প্রচুর ভারী গণনা এড়ানো যায়। এই পদ্ধতিটিতে এখনও আগ্রহের অবজেক্টটি সংরক্ষণ করার জন্য পর্যাপ্ত মেমরির প্রয়োজন হয় তবে প্রতিবার আপনি আপনার কোড চালানোর সময় এটি গণনা করা থেকে বাঁচায়। মধ্যবর্তী পদক্ষেপগুলির প্রচুর ভারী গণনা প্রয়োজন এমন বস্তুর জন্য (উদাহরণস্বরূপ, বড় অ্যারেগুলিতে লুপ জড়িত গণনার জন্য) এটি যথেষ্ট পরিমাণ সময় এবং গণনা বাঁচাতে পারে।

Answer 24

চলমান

for (i in 1:10) 
    gc(reset = T)

সময়ে সময়ে R টি অব্যবহৃত তবে এখনও মেমরি প্রকাশিত হয়নি মুক্ত করতে সহায়তা করে।

Comments

forলুপ এখানে কি করে ? কোন ব্যাপার iমধ্যে gcকল।

— উমোমামামাও

@qqq এটি কেবল gc(reset = T)নয় বার অনুলিপি-এড়ানোর জন্য রয়েছে

— মার্সেলো ভেনচুরা

তবে কেন আপনি এটি 9 বার চালাবেন? (কৌতূহলী, সমালোচক নয়)

— উমোমামামাও

Answer 25

আপনি নিটার ব্যবহার করে এবং স্ক্রিপ্টটি আরএমডি খণ্ডে রেখে কিছু সুবিধা পেতে পারেন।

আমি সাধারণত কোডটিকে বিভিন্ন খণ্ডে বিভক্ত করি এবং কোনটি একটি ক্যাশে বা কোনও আরডিএস ফাইলে একটি চেকপয়েন্ট সংরক্ষণ করতে পারে তা নির্বাচন করি এবং

সেখানে আপনি "ক্যাশে" তে সংরক্ষণ করার জন্য একটি অংশ নির্ধারণ করতে পারেন, বা আপনি কোনও নির্দিষ্ট অংশ চালানোর বা না রাখার সিদ্ধান্ত নিতে পারেন। এইভাবে, প্রথম রানটিতে আপনি কেবল "পার্ট 1" প্রক্রিয়াকরণ করতে পারবেন, অন্য একটি নির্বাহী আপনি কেবল "পার্ট 2" ইত্যাদি নির্বাচন করতে পারেন etc.

উদাহরণ:

part1
```{r corpus, warning=FALSE, cache=TRUE, message=FALSE, eval=TRUE}
corpusTw <- corpus(twitter)  # build the corpus
```
part2
```{r trigrams, warning=FALSE, cache=TRUE, message=FALSE, eval=FALSE}
dfmTw <- dfm(corpusTw, verbose=TRUE, removeTwitter=TRUE, ngrams=3)
```

পার্শ্ব প্রতিক্রিয়া হিসাবে, এটি পুনরুত্পাদনযোগ্যতার ক্ষেত্রে আপনাকে কিছু মাথাব্যথা বাঁচাতে পারে :)

Answer 26

@ ডির্ক এবং @ টনির উত্তরের ভিত্তিতে আমি সামান্য আপডেট করেছি। ফলাফলটি [1]আকারের মানগুলির আগে ফলাফল হচ্ছিল , সুতরাং আমি capture.outputসমস্যার সমাধান করলাম :

.ls.objects <- function (pos = 1, pattern, order.by,
                     decreasing=FALSE, head=FALSE, n=5) {
napply <- function(names, fn) sapply(names, function(x)
    fn(get(x, pos = pos)))
names <- ls(pos = pos, pattern = pattern)
obj.class <- napply(names, function(x) as.character(class(x))[1])
obj.mode <- napply(names, mode)
obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
obj.prettysize <- napply(names, function(x) {
    format(utils::object.size(x),  units = "auto") })
obj.size <- napply(names, utils::object.size)

obj.dim <- t(napply(names, function(x)
    as.numeric(dim(x))[1:2]))
vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
obj.dim[vec, 1] <- napply(names, length)[vec]
out <- data.frame(obj.type, obj.size, obj.prettysize, obj.dim)
names(out) <- c("Type", "Size", "PrettySize", "Rows", "Columns")
if (!missing(order.by))
    out <- out[order(out[[order.by]], decreasing=decreasing), ]
if (head)
    out <- head(out, n)

return(out)
}

# shorthand
lsos <- function(..., n=10) {
    .ls.objects(..., order.by="Size", decreasing=TRUE, head=TRUE, n=n)
}

lsos()

Answer 27

অনেক বড় মাঝারি পদক্ষেপ নিয়ে বড় প্রকল্পে কাজ করার সময় আমি বস্তুর পরিমাণ কম রাখার চেষ্টা করি। পরিবর্তে কল হিসাবে অনেক অনন্য বস্তু তৈরি

dataframe-> step1-> step2-> step3->result

raster-> multipliedRast-> meanRastF-> sqrtRast->resultRast

আমি যে অস্থায়ী বস্তুগুলিকে কল করি তার সাথে আমি কাজ করি temp।

dataframe-> temp-> temp-> temp->result

যা আমাকে কম মধ্যবর্তী ফাইল এবং আরও ওভারভিউ দিয়ে ফেলেছে।

raster  <- raster('file.tif')
temp <- raster * 10
temp <- mean(temp)
resultRast <- sqrt(temp)

আরও স্মৃতি সঞ্চয় করতে আমি tempযখন আর প্রয়োজন হয় না তখন কেবল সরিয়ে ফেলতে পারি ।

rm(temp)

আমি বিভিন্ন অন্তর্বর্তী ফাইল প্রয়োজন হয়, তাহলে আমি ব্যবহার temp1, temp2, temp3।

পরীক্ষা আমি ব্যবহার জন্য test, test2...