Bối cảnh và Tuyên bố miễn trừ trách nhiệm: Trong công ty tôi đang làm việc, Chúng tôi đã phân khách hàng của mình thành bốn loại dựa trên hành vi thanh toán của họ. Thông thường, khi phân khúc khách hàng trong môi trường kinh doanh, ba tham số được sử dụng: Lần gần đây (khách hàng đã mua hàng như thế nào gần đây), Tần suất (tần suất khách hàng mua hàng) và Tiền tệ (số tiền khách hàng chi cho mỗi lần mua hàng). Tuy nhiên, trong trường hợp này, tôi sẽ chỉ sử dụng Tần suất để giải thích khái niệm tạo thùng. Trong tương lai, tôi sẽ cung cấp giải thích toàn diện hơn về phân khúc khách hàng.

Nhưng binning là gì?

Data binning là quá trình tổ chức dữ liệu của bạn thành một phạm vi khoảng thời gian hữu hạn. Những khoảng thời gian đó được gọi là "thùng".

Data binning, còn được gọi là “ data bucketing ”, là một kỹ thuật tiền xử lý dữ liệu được sử dụng trong máy học và khai thác dữ liệu để nhóm các giá trị dữ liệu liên tục thành các khoảng hoặc “bin” rời rạc. Binning có thể phục vụ nhiều mục đích, bao gồm giảm lỗi dữ liệu bằng cách làm mịn các dao động trong dữ liệu, hiểu rõ hơn về phân phối dữ liệu và chuyển đổi các tính năng có giá trị thực thành các khoảng rời rạc, còn được gọi là mã hóa một lần.

Có hai loại phương pháp tạo tệp chính: tạo tệp tần số và tạo tệp theo chiều rộng bằng nhau. Các biến thể của các phương pháp này tồn tại, nhưng về cơ bản chúng đều dựa trên một trong hai cách tiếp cận này. Trong hướng dẫn này, trọng tâm là triển khai thuật toán tạo thùng có độ dài bằng nhau cơ bản. Tạo thùng theo chiều rộng bằng nhau liên quan đến việc chia phạm vi giá trị trong tập dữ liệu thành một số lượng khoảng cách đều nhau được chỉ định giữa các giá trị tối thiểu và tối đa.

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

Để minh họa khái niệm data binning, chúng ta hãy xem xét một ví dụ thực tế sử dụng Typescript. Giả sử chúng ta có một bộ dữ liệu ghi lại số lần mua hàng của khách hàng trong một khoảng thời gian cụ thể. Tập dữ liệu được thể hiện trong mảng sau:

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

Để phân tích tập dữ liệu về tần suất mua hàng của khách hàng, cần phải chia dữ liệu thành bốn nhóm riêng biệt có nhãn `Khách hàng D` đến `Khách hàng A`. Để thực hiện điều này, trước tiên chúng tôi sẽ tạo một cấu trúc dữ liệu đơn giản để lưu trữ các thùng của chúng tôi.

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

Mã cho toBinchức năng có thể giống như thế này:

/**
 * 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: Tần suất mua thấp nhất / Khách hàng may mắn
• Bin 2: Tần suất mua hàng thấp / Ít khách hàng quan tâm
• Bin 3: Tần suất mua vừa phải / Khách hàng ổn
• Bin 4: Tần suất mua hàng cao / Khách hàng tốt

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

Chiều rộng ngăn được tính bằng cách lấy chênh lệch giữa giá trị lớn nhất và nhỏ nhất rồi chia cho số lượng ngăn mong muốn. Chiều rộng này sẽ được sử dụng để nhóm các giá trị vào các ngăn thích hợp của chúng.

Cuối cùng, chúng tôi tạo một mảng trống để chứa các thùng của chúng tôi, chúng tôi sẽ điền dữ liệu vào trong bước tiếp theo của thuật toán. Bằng cách tạo các thùng trống này, chúng tôi thiết lập khuôn khổ cho việc nhóm dữ liệu tiếp theo vào các thùng.

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

Điều quan trọng cần lưu ý là bước này yêu cầu tập dữ liệu phải được sắp xếp theo thứ tự tăng dần để xác định vị trí các chỉ số thích hợp. Việc không sắp xếp tập dữ liệu trước sẽ dẫn đến việc tạo thùng không chính xác.

Để xem thuật toán đang hoạt động, một ví dụ hoạt động đầy đủ được đưa ra dưới đây.

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
}

Khi toBinchức năng đã được triển khai, nó có thể được gọi bằng mã máy khách để tạo ra một mảng các Binđối tượng đại diện cho dữ liệu được nhóm. Để làm như vậy, mã máy khách phải chuyển tập dữ liệu đầu vào, số lượng thùng mong muốn và tùy chọn, một mảng nhãn cho hàm toBin.

Ví dụ: chúng tôi có thể cung cấp các giao dịch mẫu và gọi hàm toBintrên tập dữ liệu này để tạo ra một mảng các Binđối tượng đại diện cho dữ liệu được nhóm.

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

Điều đáng chú ý là thuật toán mà chúng tôi đã triển khai có độ phức tạp về thời gian là O(n log n) do cần phải sắp xếp tập dữ liệu đầu vào. Ngoài ra, độ phức tạp không gian của thuật toán là O(k) , trong đó k là số thùng.

Ghi chú kết thúc và Takeaways:

Tóm lại, trong hướng dẫn này, chúng tôi đã đề cập đến một thuật toán tạo thùng theo chiều rộng bằng nhau đơn giản và cung cấp một ví dụ về cách sử dụng thuật toán này để phân nhóm khách hàng dựa trên tần suất mua hàng của họ. Binning là một kỹ thuật tiền xử lý dữ liệu phổ biến có thể được sử dụng để giảm lỗi, hiểu rõ hơn về tập dữ liệu hoặc chuyển đổi các giá trị thực thành các khoảng rời rạc. Tuy nhiên, có một số thách thức liên quan đến kỹ thuật này, chẳng hạn như quyết định kích thước thùng thích hợp cho một tập dữ liệu nhất định.

Tùy thuộc vào trường hợp sử dụng cụ thể, các kỹ thuật thay thế có thể được sử dụng để sắp xếp tập dữ liệu thành các nhóm xác định, chẳng hạn như thuật toán k-Láng giềng gần nhất (kNN). Điều quan trọng là phải xem xét cẩn thận các yêu cầu cụ thể của một dự án để xác định kỹ thuật tiền xử lý thích hợp nhất để sử dụng.

Nếu bạn muốn tìm hiểu thêm về cách tạo thùng hoặc các kỹ thuật xử lý trước dữ liệu khác, hãy nhớ khám phá các bài viết của tôi để biết thêm các bài viết, hướng dẫn và tài nguyên. Chọn tham gia nhận email khi tôi xuất bản bài viết mới. Hãy theo dõi để biết thêm thông tin chi tiết và lời khuyên thiết thực về các xu hướng mới nhất trong học máy và khoa học dữ liệu!

Cuối cùng, Đây là repo github cho hướng dẫn này Cảm ơn bạn!