डेटा बिनिंग समझाया

Feb 20 2023

पृष्ठभूमि और अस्वीकरण: जिस कंपनी में मैं काम कर रहा हूं, हमने अपने ग्राहकों को उनके भुगतान व्यवहार के आधार पर चार वर्गों में बांटा है। आमतौर पर, जब किसी व्यवसाय सेटिंग में ग्राहकों को विभाजित किया जाता है, तो तीन मापदंडों का उपयोग किया जाता है: रीसेंसी (कितनी हाल ही में ग्राहक ने खरीदारी की), फ़्रीक्वेंसी (कितनी बार ग्राहक खरीदारी करता है), और मौद्रिक (ग्राहक प्रत्येक खरीदारी पर कितना खर्च करता है)।

ग्राहकों के खरीद इतिहास पर बिनिंग का उदाहरण

लेकिन बिनिंग क्या है?

डेटा बिनिंग आपके डेटा को अंतरालों की परिमित श्रेणी में व्यवस्थित करने की प्रक्रिया है। अंतराल की उन सीमाओं को "डिब्बे" कहा जाता है।

डेटा बिनिंग, जिसे " डेटा बकेटिंग " के रूप में भी जाना जाता है, एक डेटा प्री-प्रोसेसिंग तकनीक है जिसका उपयोग मशीन लर्निंग और डेटा माइनिंग में निरंतर डेटा मानों को असतत अंतराल या "डिब्बे" में समूहित करने के लिए किया जाता है। बिनिंग कई उद्देश्यों की पूर्ति कर सकता है, जिसमें डेटा में उतार-चढ़ाव को सुचारू करके डेटा त्रुटियों को कम करना, डेटा वितरण के बारे में जानकारी प्राप्त करना और वास्तविक-मूल्यवान सुविधाओं को असतत अंतराल में परिवर्तित करना शामिल है, जिसे वन-हॉट एन्कोडिंग भी कहा जाता है।

बिनिंग विधियों के दो प्राथमिक प्रकार हैं: फ़्रीक्वेंसी बिनिंग और समान चौड़ाई वाली बिनिंग। इन विधियों की विविधताएँ मौजूद हैं, लेकिन वे सभी अनिवार्य रूप से इन दो दृष्टिकोणों में से एक पर आधारित हैं। इस ट्यूटोरियल में, बुनियादी समान-लंबाई वाले बिनिंग एल्गोरिथम को लागू करने पर ध्यान केंद्रित किया गया है। समान चौड़ाई बिनिंग में डेटासेट में मानों की श्रेणी को न्यूनतम और अधिकतम मानों के बीच समान दूरी वाले अंतरालों की निर्दिष्ट संख्या में विभाजित करना शामिल है।

const width = (max - min) / number_of_bins
const bins_values = [min, min + width, min + 2 * width, ..., min + number_of_bins * width]

डेटा बिनिंग की अवधारणा को स्पष्ट करने के लिए, आइए टाइपस्क्रिप्ट का उपयोग करते हुए एक व्यावहारिक उदाहरण पर विचार करें। मान लीजिए कि हमारे पास एक डेटासेट है जो एक विशिष्ट समय अवधि के भीतर ग्राहकों द्वारा की गई खरीदारी की संख्या को रिकॉर्ड करता है। डेटासेट निम्नलिखित सरणी में दर्शाया गया है:

const trxFreq = [229, 293, 394, 39, 39, 49, 93, 100, 29, 48, 188]

ग्राहक खरीद आवृत्ति के डेटासेट का विश्लेषण करने के लिए, डेटा को `ए-ग्राहक` के माध्यम से `डी-ग्राहक` लेबल वाले चार अलग-अलग डिब्बे में विभाजित करना आवश्यक है। इसे पूरा करने के लिए, हम सबसे पहले अपने बिन्स को स्टोर करने के लिए एक साधारण डेटा स्ट्रक्चर तैयार करेंगे।

/**
 * Structure of each bin
 */
export interface Bin {
  /**
   * Bucket.
   */
  item: {
    value: number
    label?: string
  }

  /**
   * Values in a bin
   */
  values: number[]
}

/**
 * Array type of bins
 */
export type Bins = Bin[]

समारोह के लिए कोड toBinकुछ इस तरह दिख सकता है:

/**
 * Convert input dataset array of numbers into bins.
 *
 * @param data dataset array
 * @param binSize Number of bins
 * @param labels Optional labels for the bins
 */
export function toBins(data: number[], binSize: number, labels?: string[]) {
   // Implementation
}

बिन 1: सबसे कम बारंबारता वाली खरीदारी / भाग्यशाली ग्राहक
बिन 2: कम बारंबारता वाली खरीदारी / कम दिलचस्पी वाले ग्राहक
बिन 3: मध्यम आवृत्ति खरीदारी / ठीक ग्राहक
बिन 4: उच्च आवृत्ति खरीदारी / अच्छे ग्राहक

const sampleCount = data.length

// Sort data in descending order
const sortedData = data.sort((lhs, rhs) => lhs - rhs)
// Find min and max samples
const minSample = sortedData[0]
const maxSample = sortedData[sampleCount - 1]

// Create equal spaced bins
const binWidth = (maxSample - minSample) / binSize
const bins: Bins = Array(binSize)
  .fill({ values: [] })
  .map((bin, i) => ({
    item: {
      value: minSample + binWidth * i,
      label: labels?.[i]
    },
    ...bin
   }))

बिन चौड़ाई की गणना अधिकतम और न्यूनतम मूल्यों के बीच के अंतर को लेकर और इसे वांछित डिब्बे की संख्या से विभाजित करके की जाती है। इस चौड़ाई का उपयोग मूल्यों को उनके उचित डिब्बे में समूहित करने के लिए किया जाएगा।

अंत में, हम अपने डिब्बे को रखने के लिए एक खाली सरणी बनाते हैं, जिसे हम एल्गोरिथम के अगले चरण में डेटा से भर देंगे। इन खाली डिब्बे को बनाकर, हम डेटा के बाद के समूह को डिब्बे में रखने के लिए रूपरेखा तैयार करते हैं।

// Search for the next chunk from the sorted array to add into the bin values
let minIndex = 0
let maxIndex = sampleCount - 1

for (let i = 0; i < binSize; i++) {
  while (
    minIndex < sampleCount &&
    sortedData[minIndex] < bins[i].item.value
  ) {
    minIndex++
  }
  while (
    maxIndex >= 0 &&
    sortedData[maxIndex] > bins[i].item.value + binWidth
  ) {
    maxIndex--
  }
  for (let j = minIndex; j <= maxIndex; j++) {
    bins[i].values.push(sortedData[j])
  }

  // Slice item from the sorted array into the bin
  bins[i].values = sortedData.slice(minIndex, maxIndex + 1)

  // Get the maxIndex ready for the next iteration.
  maxIndex = sampleCount - 1
}

यह ध्यान रखना महत्वपूर्ण है कि इस कदम के लिए उपयुक्त सूचकांकों का पता लगाने के लिए डेटासेट को आरोही क्रम में क्रमबद्ध करने की आवश्यकता है। डेटासेट को पहले से क्रमित करने में विफलता के परिणामस्वरूप गलत बाइनिंग होगी।

एल्गोरिथ्म को क्रिया में देखने के लिए, एक पूरी तरह से कार्यशील उदाहरण नीचे दिया गया है।


export interface Bin {
  
  item: {
    value: number
    label?: string
  }

  values: number[]
}

export type Bins = Bin[]

export function toBins(data: number[], binSize: number, labels?: string[]) {
  const sampleCount = data.length

  if (binSize >= sampleCount) {
    throw new RangeError(
      `Bin size ${binSize} should be less than sample size: ${sampleCount}`
    )
  }

  // Sort data in descending order
  const sortedData = data.sort((lhs, rhs) => lhs - rhs)
  // Find min and max samples
  const minSample = sortedData[0]
  const maxSample = sortedData[sampleCount - 1]

  // Create equal spaced bins
  const binWidth = (maxSample - minSample) / binSize
  const bins: Bins = Array(binSize)
    .fill({ values: [] })
    .map((bin, i) => ({
      item: {
        value: minSample + binWidth * i,
        label: labels?.[i]
      },
      ...bin
    }))

  let minIndex = 0
  let maxIndex = sampleCount - 1

  for (let i = 0; i < binSize; i++) {
    while (
      minIndex < sampleCount &&
      sortedData[minIndex] < bins[i].item.value
    ) {
      minIndex++
    }
    while (
      maxIndex >= 0 &&
      sortedData[maxIndex] > bins[i].item.value + binWidth
    ) {
      maxIndex--
    }

    // Slice a bucket
    bins[i].values = sortedData.slice(minIndex, maxIndex + 1)

    // Get the maxIndex ready for the next iteration.
    maxIndex = sampleCount - 1
  }

  return bins
}

एक बार toBinफ़ंक्शन लागू हो जाने के बाद, Binसमूहीकृत डेटा का प्रतिनिधित्व करने वाली वस्तुओं की एक सरणी बनाने के लिए क्लाइंट कोड द्वारा इसे लागू किया जा सकता है। ऐसा करने के लिए, क्लाइंट कोड को इनपुट डेटासेट, डिब्बे की वांछित संख्या, और वैकल्पिक रूप से, फ़ंक्शन के लिए लेबल की एक सरणी पास करनी होगी toBin।

एक उदाहरण के रूप में, हम नमूना लेनदेन प्रदान कर सकते हैं और समूहीकृत डेटा का प्रतिनिधित्व करने वाली वस्तुओं toBinकी एक सरणी बनाने के लिए इस डेटासेट पर फ़ंक्शन को लागू कर सकते हैं।Bin

const trxFreq = [229, 293, 394, 39, 39, 49, 93, 100, 29, 48, 188]
const labels = ['D-Customers', 'C-Customers', 'B-Customers', 'A-Customers']
const bins = toBins(trxFreq, labels.length, labels)

console.log(bins)
// Prints
// [
//    {
//      "item": { "value": 29, "label": "D-Customers" },
//      "item": [29, 39, 39, 48, 49, 93, 100 ]
//    },
//    {
//      "iem": { "value": 120.25, "label": "C-Customers" },
//      "values": [ 188 ]
//    },
//    {
//      "item": { "value": 211.5, "label": "B-Customers" },
//      "values": [ 229, 293 ]
//    },
//    {
//      "item": { "value": 302.75, "label": "A-Customers" },
//      "values": [ 394 ]
//    }
// ]

यह ध्यान देने योग्य है कि इनपुट डेटासेट को सॉर्ट करने की आवश्यकता के कारण हमने जो एल्गोरिथ्म लागू किया है, उसमें O(n log n) की समय जटिलता है। इसके अतिरिक्त, एल्गोरिथम की अंतरिक्ष जटिलता O(k) है , जहाँ k डिब्बे की संख्या है।

क्लोजिंग नोट्स और टेक अवे:

सारांशित करने के लिए, इस ट्यूटोरियल में हमने एक साधारण समान चौड़ाई वाली बिनिंग एल्गोरिथम को कवर किया है और एक उदाहरण प्रदान किया है कि इसका उपयोग ग्राहकों को उनकी क्रय आवृत्ति के आधार पर समूह में कैसे किया जा सकता है। बिनिंग एक सामान्य डेटा प्री-प्रोसेसिंग तकनीक है जिसे त्रुटि को कम करने, डेटासेट के बारे में जानकारी प्राप्त करने या वास्तविक मानों को असतत अंतराल में परिवर्तित करने के लिए नियोजित किया जा सकता है। हालाँकि, इस तकनीक से जुड़ी कुछ चुनौतियाँ हैं, जैसे किसी दिए गए डेटासेट के लिए उपयुक्त बिन आकार तय करना।

विशिष्ट उपयोग के मामले के आधार पर, डेटासेट को परिभाषित समूहों में व्यवस्थित करने के लिए वैकल्पिक तकनीकों को नियोजित किया जा सकता है, जैसे कि k-निकटतम पड़ोसी (kNN) एल्गोरिथम। नियोजित करने के लिए सबसे उपयुक्त पूर्व-प्रसंस्करण तकनीक निर्धारित करने के लिए किसी परियोजना की विशिष्ट आवश्यकताओं पर सावधानीपूर्वक विचार करना महत्वपूर्ण है।

यदि आप बिनिंग या अन्य डेटा पूर्व-प्रसंस्करण तकनीकों के बारे में अधिक जानने में रुचि रखते हैं, तो अधिक लेखों, ट्यूटोरियल और संसाधनों के लिए मेरे लेखों को एक्सप्लोर करना सुनिश्चित करें। मेरे द्वारा नए लेख प्रकाशित करने पर ईमेल प्राप्त करने के लिए ऑप्ट इन करें। मशीन लर्निंग और डेटा साइंस में नवीनतम रुझानों पर अधिक जानकारी और व्यावहारिक सुझावों के लिए हमारे साथ बने रहें!