# K-Means initialization¶

The K-Means initialization algorithm receives $$n$$ feature vectors as input and chooses $$k$$ initial centroids. After initialization, K-Means algorithm uses the initialization result to partition input data into $$k$$ clusters.

 Operation Computational methods Programming Interface Computing Dense compute(…) compute_input compute_result

## Mathematical formulation¶

### Computing¶

Given the training set $$X = \{ x_1, \ldots, x_n \}$$ of $$p$$-dimensional feature vectors and a positive integer $$k$$, the problem is to find a set $$C = \{ c_1, \ldots, c_k \}$$ of $$p$$-dimensional initial centroids.

### Computing method: dense¶

The method chooses first $$k$$ feature vectors from the training set $$X$$.

## Usage example¶

### Computing¶

table run_compute(const table& data) {
const auto kmeans_desc = kmeans_init::descriptor<float,
kmeans_init::method::dense>{}
.set_cluster_count(10)

const auto result = compute(kmeans_desc, data);

print_table("centroids", result.get_centroids());

return result.get_centroids();
}


## Examples¶

Batch Processing:

Batch Processing:

## Programming Interface¶

All types and functions in this section are declared in the oneapi::dal::kmeans_init namespace and be available via inclusion of the oneapi/dal/algo/kmeans_init.hpp header file.

### Descriptor¶

template<typename Float = detail::descriptor_base<>::float_t, typename Method = detail::descriptor_base<>::method_t, typename Task = detail::descriptor_base<>::task_t>
class descriptor
Template Parameters
• Float – The floating-point type that the algorithm uses for intermediate computations. Can be float or double.

• Method – Tag-type that specifies an implementation of K-Means Initialization algorithm.

• Task – Tag-type that specifies the type of the problem to solve. Can be task::v1::init.

Constructors

descriptor(std::int64_t cluster_count = 2)

Creates a new instance of the class with the given cluster_count.

Public Methods

auto &set_cluster_count(int64_t value)

#### Method tags¶

struct dense

Tag-type that denotes dense computational method.

struct parallel_plus_dense
struct plus_plus_dense
struct random_dense
using by_default = dense

struct init

Tag-type that parameterizes entities used for obtaining the initial K-Means centroids.

using by_default = init

Alias tag-type for the initialization task.

### Computing compute(...)¶

#### Input¶

template<typename Task = task::by_default>
class compute_input
Template Parameters

Task – Tag-type that specifies type of the problem to solve. Can be task::v1::init.

Constructors

compute_input(const table &data)

Creates a new instance of the class with the given data.

Properties

const table &data = table{}

An $$n \times p$$ table with the data to be clustered, where each row stores one feature vector.

Getter & Setter
const table & get_data() const
auto & set_data(const table &data)

#### Result¶

template<typename Task = task::by_default>
class compute_result
Template Parameters

Task – Tag-type that specifies type of the problem to solve. Can be oneapi::dal::kmeans::task::v1::clustering.

Constructors

compute_result()

Creates a new instance of the class with the default property values.

Properties

const table &centroids = table{}

A $$k \times p$$ table with the initial centroids. Each row of the table stores one centroid.

Getter & Setter
const table & get_centroids() const
auto & set_centroids(const table &value)

#### Operation¶

template<typename Descriptor>
kmeans_init::compute_result compute(const Descriptor &desc, const kmeans_init::compute_input &input)
Template Parameters
• desc – K-Means algorithm descriptor kmeans_init::desc

• input – Input data for the computing operation

Preconditions
input.data.has_data == true
input.data.row_count == desc.cluster_count
Postconditions
result.centroids.has_data == true
result.centroids.row_count == desc.cluster_count
result.centroids.column_count == input.data.column_count