Latar Belakang dan Penafian: Di perusahaan tempat saya bekerja, Kami telah mengelompokkan pelanggan kami ke dalam empat kelas berdasarkan perilaku pembayaran mereka. Biasanya, saat mensegmentasi pelanggan dalam pengaturan bisnis, tiga parameter digunakan: Keterkinian (seberapa lama pelanggan melakukan pembelian), Frekuensi (seberapa sering pelanggan melakukan pembelian), dan Moneter (berapa banyak yang dibelanjakan pelanggan untuk setiap pembelian). Namun, dalam hal ini, saya hanya akan menggunakan Frekuensi untuk menjelaskan konsep binning. Ke depan, saya akan memberikan penjelasan segmentasi pelanggan yang lebih komprehensif.

Tapi apa itu binning?

Data binning adalah proses mengatur data Anda ke dalam rentang interval yang terbatas. Kisaran interval tersebut disebut "tempat sampah".

Data binning, juga dikenal sebagai " pengelompokan data ", adalah teknik pra-pemrosesan data yang digunakan dalam pembelajaran mesin dan penambangan data untuk mengelompokkan nilai data kontinu ke dalam interval diskrit atau "tempat sampah". Binning dapat melayani berbagai tujuan, termasuk mengurangi kesalahan data dengan menghaluskan fluktuasi data, mendapatkan wawasan tentang distribusi data, dan mengubah fitur bernilai nyata menjadi interval diskrit, juga dikenal sebagai penyandian satu-panas.

Ada dua jenis utama metode binning: binning frekuensi dan binning lebar yang sama. Ada variasi dari metode ini, tetapi semuanya pada dasarnya didasarkan pada salah satu dari dua pendekatan ini. Dalam tutorial ini, fokusnya adalah pada penerapan algoritme binning dengan panjang yang sama. Binning dengan lebar yang sama melibatkan pembagian rentang nilai dalam kumpulan data menjadi sejumlah interval jarak yang sama antara nilai minimum dan maksimum.

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

Untuk mengilustrasikan konsep data binning, mari kita perhatikan contoh praktis menggunakan TypeScript. Misalkan kita memiliki kumpulan data yang mencatat jumlah pembelian yang dilakukan oleh pelanggan dalam periode waktu tertentu. Dataset direpresentasikan dalam larik berikut:

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

Untuk menganalisis kumpulan data frekuensi pembelian pelanggan, perlu untuk membagi data menjadi empat kotak berbeda yang berlabel `D-Pelanggan` hingga `Pelanggan-A`. Untuk melakukannya, pertama-tama kita akan membuat struktur data sederhana untuk menyimpan tempat sampah kita.

/**
 * 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[]

Kode untuk toBinfungsi tersebut mungkin terlihat seperti ini:

/**
 * 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
}

• Bin 1: Pembelian dengan frekuensi terendah / Pelanggan yang beruntung
• Bin 2: Pembelian frekuensi rendah / Pelanggan yang kurang tertarik
• Bin 3: Pembelian frekuensi sedang / Pelanggan oke
• Bin 4: Pembelian dengan frekuensi tinggi / Pelanggan yang baik

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
   }))

Lebar nampan dihitung dengan mengambil selisih antara nilai maksimum dan minimum dan membaginya dengan jumlah nampan yang diinginkan. Lebar ini akan digunakan untuk mengelompokkan nilai ke dalam nampan yang sesuai.

Terakhir, kami membuat larik kosong untuk menampung tempat sampah kami, yang akan kami isi dengan data di langkah algoritme berikutnya. Dengan membuat tempat sampah kosong ini, kami menetapkan kerangka kerja untuk pengelompokan data berikutnya ke dalam tempat sampah.

// 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
}

Penting untuk dicatat bahwa langkah ini memerlukan kumpulan data untuk diurutkan dalam urutan menaik untuk menemukan indeks yang sesuai. Kegagalan untuk mengurutkan dataset sebelumnya akan menghasilkan binning yang salah.

Untuk melihat algoritme dalam tindakan, contoh yang berfungsi penuh diberikan di bawah ini.

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
}

Setelah toBinfungsi diimplementasikan, itu dapat dipanggil oleh kode klien untuk menghasilkan larik Binobjek yang mewakili data yang dikelompokkan. Untuk melakukannya, kode klien harus meneruskan input dataset, jumlah bin yang diinginkan, dan secara opsional, array label ke fungsi toBin.

Sebagai contoh, kami dapat memberikan contoh transaksi dan memanggil toBinfungsi pada kumpulan data ini untuk menghasilkan larik Binobjek yang mewakili data yang dikelompokkan.

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 ]
//    }
// ]

Perlu dicatat bahwa algoritme yang telah kami terapkan memiliki kompleksitas waktu O(n log n) karena kebutuhan untuk mengurutkan input dataset. Selain itu, kompleksitas ruang dari algoritme adalah O(k) , di mana k adalah jumlah tempat sampah.

Catatan Penutup dan Catatan:

Untuk meringkas, dalam tutorial ini kita telah membahas algoritme binning lebar sama sederhana dan memberikan contoh bagaimana hal itu dapat digunakan untuk mengelompokkan pelanggan berdasarkan frekuensi pembelian mereka. Binning adalah teknik pra-pemrosesan data umum yang dapat digunakan untuk mengurangi kesalahan, mendapatkan wawasan tentang kumpulan data, atau mengubah nilai nyata menjadi interval diskrit. Namun, ada beberapa tantangan terkait dengan teknik ini, seperti menentukan ukuran bin yang sesuai untuk kumpulan data tertentu.

Bergantung pada kasus penggunaan tertentu, teknik alternatif dapat digunakan untuk mengatur kumpulan data ke dalam grup yang ditentukan, seperti algoritme k-Nearest Neighbors (kNN). Penting untuk mempertimbangkan dengan hati-hati persyaratan khusus dari suatu proyek untuk menentukan teknik pra-pemrosesan yang paling tepat untuk digunakan.

Jika Anda tertarik untuk mempelajari lebih lanjut tentang binning atau teknik pra-pemrosesan data lainnya, pastikan untuk menjelajahi artikel saya untuk mendapatkan lebih banyak artikel, tutorial, dan sumber daya. Ikut serta untuk menerima email saat saya menerbitkan artikel baru. Nantikan wawasan dan kiat praktis lainnya tentang tren terbaru dalam pembelajaran mesin dan ilmu data!

Akhirnya, Inilah repo github untuk tutorial ini Terima kasih!