| /// \file
|
| /// \brief unsupervised.cl
|
| /// Library consist OpenCL kernels
|
| /// \author <A HREF="https://www.mql5.com/en/users/dng"> DNG </A>
|
| /// \copyright Copyright 2022, DNG
|
| //---
|
| //--- by default some GPU doesn't support floats
|
| //--- cl_khr_fp64 directive is used to enable work with floats
|
| #pragma OPENCL EXTENSION __opencl_c_fp64 /*cl_khr_fp64*/ : enable
|
| //+------------------------------------------------------------------+
|
| ///\ingroup k-means K means clustering
|
| /// Describes the process of distance calculation for the class CKmeans (#CKmeans).
|
| ///\details Detailed description on <A HREF="https://www.mql5.com/ru/articles/10947#distance">the link.</A>
|
| //+------------------------------------------------------------------+
|
| __kernel void KmeansCulcDistance(__global float *data,///<[in] Inputs data matrix m*n, where m - number of patterns and n - size of vector to describe 1 pattern
|
| __global float *means,///<[in] Means tensor k*n, where k - number of clasters and n - size of vector to describe 1 pattern
|
| __global float *distance,///<[out] distance tensor m*k, where m - number of patterns and k - number of clasters
|
| int vector_size///< Size of vector
|
| )
|
| {
|
| int m = get_global_id(0);
|
| int k = get_global_id(1);
|
| int total_k = get_global_size(1);
|
| float sum = 0.0;
|
| int shift_m = m * vector_size;
|
| int shift_k = k * vector_size;
|
| for(int i = 0; i < vector_size; i++)
|
| sum += pow(data[shift_m + i] - means[shift_k + i], 2);
|
| distance[m * total_k + k] = sum;
|
| }
|
| //+------------------------------------------------------------------+
|
| ///\ingroup k-means K means clustering
|
| /// Describes the process of clustering for the class CKmeans (#CKmeans).
|
| ///\details Detailed description on <A HREF="https://www.mql5.com/ru/articles/10947#clustering">the link.</A>
|
| //+------------------------------------------------------------------+
|
| __kernel void KmeansClustering(__global float *distance,///<[in] distance tensor m*k, where m - number of patterns and k - number of clasters
|
| __global float *clusters,///<[out] Numbers of cluster tensor m-size
|
| __global float *flags,///[out] Flags of changes
|
| int total_k///< Number of clusters
|
| )
|
| {
|
| int i = get_global_id(0);
|
| int shift = i * total_k;
|
| float value = distance[shift];
|
| int result = 0;
|
| for(int k = 1; k < total_k; k++)
|
| {
|
| if(value <= distance[shift + k])
|
| continue;
|
| value = distance[shift + k];
|
| result = k;
|
| }
|
| flags[i] = (float)(clusters[i] != (float)result);
|
| clusters[i] = (float)result;
|
| }
|
| //+------------------------------------------------------------------+
|
| ///\ingroup k-means K means clustering
|
| /// Describes the process of updates means vectors
|
| ///\details Detailed description on <A HREF="https://www.mql5.com/ru/articles/10947#updates">the link.</A>
|
| //+------------------------------------------------------------------+
|
| __kernel void KmeansUpdating(__global float *data,///<[in] Inputs data matrix m*n, where m - number of patterns and n - size of vector to describe 1 pattern
|
| __global float *clusters,///<[in] Numbers of cluster tensor m-size
|
| __global float *means,///<[out] Means tensor k*n, where k - number of clasters and n - size of vector to describe 1 pattern
|
| int total_m///< number of patterns
|
| )
|
| {
|
| int i = get_global_id(0);
|
| int vector_size = get_global_size(0);
|
| int k = get_global_id(1);
|
| float sum = 0;
|
| int count = 0;
|
| for(int m = 0; m < total_m; m++)
|
| {
|
| if(clusters[m] != k)
|
| continue;
|
| sum += data[m * vector_size + i];
|
| count++;
|
| }
|
| if(count > 0)
|
| means[k * vector_size + i] = sum / count;
|
| }
|
| //+------------------------------------------------------------------+
|
| ///\ingroup k-means K means clustering
|
| /// Describes the process of loss function
|
| ///\details Detailed description on <A HREF="https://www.mql5.com/ru/articles/10947#loss">the link.</A>
|
| //+------------------------------------------------------------------+
|
| __kernel void KmeansLoss(__global float *data,///<[in] Inputs data matrix m*n, where m - number of patterns and n - size of vector to describe 1 pattern
|
| __global float *clusters,///<[in] Numbers of cluster tensor m-size
|
| __global float *means,///<[in] Means tensor k*n, where k - number of clasters and n - size of vector to describe 1 pattern
|
| __global float *loss,///<[out] Loss tensor m-size
|
| int vector_size///< Size of vector
|
| )
|
| {
|
| int m = get_global_id(0);
|
| int c = clusters[m];
|
| int shift_c = c * vector_size;
|
| int shift_m = m * vector_size;
|
| float sum = 0;
|
| for(int i = 0; i < vector_size; i++)
|
| sum += pow(data[shift_m + i] - means[shift_c + i], 2);
|
| loss[m] = sum;
|
| }
|
| //+------------------------------------------------------------------+
|
| ///\ingroup k-means K means clustering
|
| /// Describes the calculation of probability
|
| ///\details Detailed description on <A HREF="https://www.mql5.com/ru/articles/10947#statistic">the link.</A>
|
| //+------------------------------------------------------------------+
|
| __kernel void KmeansStatistic(__global float *clusters,///<[in] Numbers of cluster tensor m-size
|
| __global float *target,///<[in] Targets tensor 3*m, where m - number of patterns
|
| __global float *probability,///<[out] Probability tensor 3*k, where k - number of clasters
|
| int total_m///< number of patterns
|
| )
|
| {
|
| int c = get_global_id(0);
|
| int shift_c = c * 3;
|
| float buy = 0;
|
| float sell = 0;
|
| float skip = 0;
|
| for(int i = 0; i < total_m; i++)
|
| {
|
| if(clusters[i] != c)
|
| continue;
|
| int shift = i * 3;
|
| buy += target[shift];
|
| sell += target[shift + 1];
|
| skip += target[shift + 2];
|
| }
|
| //---
|
| int total = buy + sell + skip;
|
| if(total < 10)
|
| {
|
| probability[shift_c] = 0;
|
| probability[shift_c + 1] = 0;
|
| probability[shift_c + 2] = 0;
|
| }
|
| else
|
| {
|
| probability[shift_c] = buy / total;
|
| probability[shift_c + 1] = sell / total;
|
| probability[shift_c + 2] = skip / total;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| ///\ingroup k-means K means clustering
|
| /// Describes the process of softmax normalization distance for the class CKmeans (#CKmeans).
|
| ///\details Detailed description on <A HREF="https://www.mql5.com/ru/articles/10943#para4">the link.</A>
|
| //+------------------------------------------------------------------+
|
| __kernel void KmeansSoftMax(__global float *distance,///<[in] distance tensor m*k, where m - number of patterns and k - number of clasters
|
| __global float *softmax,///<[out] softmax tensor m*k, where m - number of patterns and k - number of clasters
|
| int total_k///< Number of clusters
|
| )
|
| {
|
| int i = get_global_id(0);
|
| int shift = i * total_k;
|
| float m=distance[shift];
|
| for(int k = 1; k < total_k; k++)
|
| m = max(distance[shift + k],m);
|
| float sum = 0;
|
| for(int k = 0; k < total_k; k++)
|
| {
|
| float value = exp(1-distance[shift + k]/m);
|
| sum += value;
|
| softmax[shift + k] = value;
|
| }
|
| for(int k = 0; k < total_k; k++)
|
| {
|
| softmax[shift + k] /= sum;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
