2026-08-13 23:48:47 +03:00 | | | //+------------------------------------------------------------------+
|
| | | //| kmeans.mqh |
|
| | | //| Copyright 2022, DNG |
|
| | | //| https://www.mql5.com/ru/users/dng |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | #property copyright "Copyright 2022, DNG"
|
| | | #property link "https://www.mql5.com/ru/users/dng"
|
| | | #property version "1.00"
|
| | | //+------------------------------------------------------------------+
|
| | | //| includes |
|
| | | //+------------------------------------------------------------------+
|
| | | #include "..\..\NeuroNet_DNG\NeuroNet.mqh"
|
| | | #resource "unsupervised.cl" as string cl_unsupervised
|
| | | //+------------------------------------------------------------------+
|
| | | //| Defines |
|
| | | //+------------------------------------------------------------------+
|
| | | #define defUnsupervisedKmeans 0x7901
|
| | | //---
|
| | | #define def_k_kmeans_distance 0
|
| | | #define def_k_kmd_data 0
|
| | | #define def_k_kmd_means 1
|
| | | #define def_k_kmd_distance 2
|
| | | #define def_k_kmd_vector_size 3
|
| | | //---
|
| | | #define def_k_kmeans_clustering 1
|
| | | #define def_k_kmc_distance 0
|
| | | #define def_k_kmc_clusters 1
|
| | | #define def_k_kmc_flags 2
|
| | | #define def_k_kmc_total_k 3
|
| | | //---
|
| | | #define def_k_kmeans_updates 2
|
| | | #define def_k_kmu_data 0
|
| | | #define def_k_kmu_clusters 1
|
| | | #define def_k_kmu_means 2
|
| | | #define def_k_kmu_total_m 3
|
| | | //---
|
| | | #define def_k_kmeans_loss 3
|
| | | #define def_k_kml_data 0
|
| | | #define def_k_kml_clusters 1
|
| | | #define def_k_kml_means 2
|
| | | #define def_k_kml_loss 3
|
| | | #define def_k_kml_vector_size 4
|
| | | //---
|
| | | #define def_k_kmeans_statistic 4
|
| | | #define def_k_kms_clusters 0
|
| | | #define def_k_kms_targers 1
|
| | | #define def_k_kms_probability 2
|
| | | #define def_k_kms_total_m 3
|
| | | //---
|
| | | #define def_k_kmeans_softmax 5
|
| | | #define def_k_kmsm_distance 0
|
| | | #define def_k_kmsm_softmax 1
|
| | | #define def_k_kmsm_total_k 2
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | COpenCLMy *OpenCLCreate(string programm)
|
| | | {
|
| | | COpenCL *result = new COpenCLMy();
|
| | | if(CheckPointer(result) == POINTER_INVALID)
|
| | | return NULL;
|
| | | //---
|
| | | if(!result.Initialize(programm, true))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | if(!result.SetKernelsCount(6))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | if(!result.KernelCreate(def_k_kmeans_distance, "KmeansCulcDistance"))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | if(!result.KernelCreate(def_k_kmeans_clustering, "KmeansClustering"))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | if(!result.KernelCreate(def_k_kmeans_updates, "KmeansUpdating"))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | if(!result.KernelCreate(def_k_kmeans_loss, "KmeansLoss"))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | if(!result.KernelCreate(def_k_kmeans_statistic, "KmeansStatistic"))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | if(!result.KernelCreate(def_k_kmeans_softmax, "KmeansSoftMax"))
|
| | | {
|
| | | delete result;
|
| | | return NULL;
|
| | | }
|
| | | //---
|
| | | return result;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | class CKmeans : public CObject
|
| | | {
|
| | | protected:
|
| | | int m_iClusters;
|
| | | int m_iVectorSize;
|
| | | double m_dLoss;
|
| | | bool m_bTrained;
|
| | |
|
| | | CBufferFloat *c_aMeans;
|
| | | COpenCLMy *c_OpenCL; ///< Object for working with OpenCL
|
| | | //---
|
| | | CBufferFloat *c_aDistance;
|
| | | CBufferFloat *c_aClasters;
|
| | | CBufferFloat *c_aFlags;
|
| | | CBufferFloat *c_aSoftMax;
|
| | | CBufferFloat *c_aLoss;
|
| | | CBufferFloat *c_aProbability;
|
| | |
|
| | | public:
|
| | | CKmeans(void);
|
| | | ~CKmeans(void);
|
| | | //---
|
| | | bool SetOpenCL(COpenCLMy *context);
|
| | | bool Init(COpenCLMy *context, int clusters, int vector_size);
|
| | | bool Study(CBufferFloat *data, bool init_means = true);
|
| | | bool Clustering(CBufferFloat *data);
|
| | | CBufferFloat *SoftMax(CBufferFloat *data);
|
| | | bool Statistic(CBufferFloat *data, CBufferFloat *targets);
|
| | | double GetLoss(CBufferFloat *data);
|
| | | CBufferFloat *GetProbability(CBufferFloat *data);
|
| | | //---
|
| | | virtual bool Save(const int file_handle);
|
| | | virtual bool Load(const int file_handle);
|
| | | //---
|
| | | virtual int Type(void) { return defUnsupervisedKmeans; }
|
| | | };
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | void CKmeans::CKmeans(void) : m_iClusters(2),
|
| | | m_iVectorSize(1),
|
| | | m_dLoss(-1),
|
2026-08-13 23:48:47 +03:00 | | | //| Implements m_bTrained |
|
2026-03-12 15:02:23 +02:00 | | | m_bTrained(false)
|
| | | {
|
| | | c_aMeans = new CBufferFloat();
|
| | | if(CheckPointer(c_aMeans) != POINTER_INVALID)
|
| | | c_aMeans.BufferInit(m_iClusters * m_iVectorSize, 0);
|
| | | c_OpenCL = NULL;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | void CKmeans::~CKmeans(void)
|
| | | {
|
| | | if(CheckPointer(c_aMeans) == POINTER_DYNAMIC)
|
| | | delete c_aMeans;
|
| | | if(CheckPointer(c_aDistance) == POINTER_DYNAMIC)
|
| | | delete c_aDistance;
|
| | | if(CheckPointer(c_aClasters) == POINTER_DYNAMIC)
|
| | | delete c_aClasters;
|
| | | if(CheckPointer(c_aFlags) == POINTER_DYNAMIC)
|
| | | delete c_aFlags;
|
| | | if(CheckPointer(c_aSoftMax) == POINTER_DYNAMIC)
|
| | | delete c_aSoftMax;
|
| | | if(CheckPointer(c_aLoss) == POINTER_DYNAMIC)
|
| | | delete c_aLoss;
|
| | | if(CheckPointer(c_aProbability) == POINTER_DYNAMIC)
|
| | | delete c_aProbability;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | S et Op en CL implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | bool CKmeans::SetOpenCL(COpenCLMy *context)
|
| | | {
|
| | | c_OpenCL = context;
|
| | | //---
|
| | | return (c_OpenCL == context);
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | I ni t implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | bool CKmeans::Init(COpenCLMy *context, int clusters, int vector_size)
|
| | | {
|
| | | if(CheckPointer(context) == POINTER_INVALID || clusters < 2 || vector_size < 1)
|
| | | return false;
|
| | | //---
|
| | | c_OpenCL = context;
|
| | | m_iClusters = clusters;
|
| | | m_iVectorSize = vector_size;
|
| | | if(CheckPointer(c_aMeans) == POINTER_INVALID)
|
| | | {
|
| | | c_aMeans = new CBufferFloat();
|
| | | if(CheckPointer(c_aMeans) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | c_aMeans.BufferFree();
|
| | | if(!c_aMeans.BufferInit(m_iClusters * m_iVectorSize, 0))
|
| | | return false;
|
| | | m_bTrained = false;
|
| | | m_dLoss = -1;
|
| | | //---
|
| | | return true;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | S tu dy implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | bool CKmeans::Study(CBufferFloat *data, bool init_means = true)
|
| | | {
|
| | | if(CheckPointer(data) == POINTER_INVALID || CheckPointer(c_OpenCL) == POINTER_INVALID)
|
| | | return false;
|
| | | //---
|
| | | int total = data.Total();
|
| | | if(total <= 0 || m_iClusters < 2 || (total % m_iVectorSize) != 0)
|
| | | return false;
|
| | | //---
|
| | | int rows = total / m_iVectorSize;
|
| | | if(rows <= (10 * m_iClusters))
|
| | | return false;
|
| | | //---
|
| | | bool flags[];
|
| | | if(ArrayResize(flags, rows) <= 0 || !ArrayInitialize(flags, false))
|
| | | return false;
|
| | | //---
|
| | | for(int i = 0; (i < m_iClusters && init_means); i++)
|
| | | {
|
| | | Comment(StringFormat("Cluster initialization %d of %d", i, m_iClusters));
|
| | | int row = (int)((double)MathRand() * MathRand() / MathPow(32767, 2) * (rows - 1));
|
| | | if(flags[row])
|
| | | {
|
| | | i--;
|
| | | continue;
|
| | | }
|
| | | int start = row * m_iVectorSize;
|
| | | int start_c = i * m_iVectorSize;
|
| | | for(int c = 0; c < m_iVectorSize; c++)
|
| | | {
|
| | | if(!c_aMeans.Update(start_c + c, data.At(start + c)))
|
| | | return false;
|
| | | }
|
| | | flags[row] = true;
|
| | | }
|
| | | //---
|
| | | if(CheckPointer(c_aDistance) == POINTER_INVALID)
|
| | | {
|
| | | c_aDistance = new CBufferFloat();
|
| | | if(CheckPointer(c_aDistance) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | c_aDistance.BufferFree();
|
| | | if(!c_aDistance.BufferInit(rows * m_iClusters, 0))
|
| | | return false;
|
| | | //---
|
| | | if(CheckPointer(c_aClasters) == POINTER_INVALID)
|
| | | {
|
| | | c_aClasters = new CBufferFloat();
|
| | | if(CheckPointer(c_aClasters) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | c_aClasters.BufferFree();
|
| | | if(!c_aClasters.BufferInit(rows, 0))
|
| | | return false;
|
| | | //---
|
| | | if(CheckPointer(c_aFlags) == POINTER_INVALID)
|
| | | {
|
| | | c_aFlags = new CBufferFloat();
|
| | | if(CheckPointer(c_aFlags) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | c_aFlags.BufferFree();
|
| | | if(!c_aFlags.BufferInit(rows, 0))
|
| | | return false;
|
| | | //---
|
| | | if(!data.BufferCreate(c_OpenCL) ||
|
| | | !c_aMeans.BufferCreate(c_OpenCL) ||
|
| | | !c_aDistance.BufferCreate(c_OpenCL) ||
|
| | | !c_aClasters.BufferCreate(c_OpenCL) ||
|
| | | !c_aFlags.BufferCreate(c_OpenCL))
|
| | | return false;
|
| | | //---
|
| | | int count = 0;
|
| | | do
|
| | | {
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_data, data.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_means, c_aMeans.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_distance, c_aDistance.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_distance, def_k_kmd_vector_size, m_iVectorSize))
|
| | | return false;
|
| | | uint global_work_offset[2] = {0, 0};
|
| | | uint global_work_size[2];
|
| | | global_work_size[0] = rows;
|
| | | global_work_size[1] = m_iClusters;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_distance, 2, global_work_offset, global_work_size))
|
| | | return false;
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_clustering, def_k_kmc_flags, c_aFlags.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_clustering, def_k_kmc_clusters, c_aClasters.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_clustering, def_k_kmc_distance, c_aDistance.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_clustering, def_k_kmc_total_k, m_iClusters))
|
| | | return false;
|
| | | uint global_work_offset1[1] = {0};
|
| | | uint global_work_size1[1];
|
| | | global_work_size1[0] = rows;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_clustering, 1, global_work_offset1, global_work_size1))
|
| | | return false;
|
| | | if(!c_aFlags.BufferRead())
|
| | | return false;
|
| | | m_bTrained = (c_aFlags.Maximum() == 0);
|
| | | if(m_bTrained)
|
| | | {
|
| | | if(!c_aClasters.BufferRead())
|
| | | return false;
|
| | | break;
|
| | | }
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_updates, def_k_kmu_data, data.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_updates, def_k_kmu_means, c_aMeans.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_updates, def_k_kmu_clusters, c_aClasters.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_updates, def_k_kmu_total_m, rows))
|
| | | return false;
|
| | | global_work_size[0] = m_iVectorSize;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_updates, 2, global_work_offset, global_work_size))
|
| | | return false;
|
| | | count++;
|
| | | Comment(StringFormat("Study iterations %d", count));
|
| | | }
|
| | | while(!m_bTrained && !IsStopped());
|
| | | //---
|
| | | if(!c_aMeans.BufferRead())
|
| | | return false;
|
| | | data.BufferFree();
|
| | | c_aDistance.BufferFree();
|
| | | c_aFlags.BufferFree();
|
| | | //---
|
| | | return true;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | C lu st er in g implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | bool CKmeans::Clustering(CBufferFloat *data)
|
| | | {
|
| | | if(!m_bTrained && !Study(data, (c_aMeans.Maximum() == 0)))
|
| | | return false;
|
| | | //---
|
| | | if(CheckPointer(data) == POINTER_INVALID || CheckPointer(c_OpenCL) == POINTER_INVALID)
|
| | | return false;
|
| | | //---
|
| | | int total = data.Total();
|
| | | if(total <= 0 || m_iClusters < 2 || (total % m_iVectorSize) != 0)
|
| | | return false;
|
| | | //---
|
| | | int rows = total / m_iVectorSize;
|
| | | if(rows < 1)
|
| | | return false;
|
| | | //---
|
| | | if(CheckPointer(c_aDistance) == POINTER_INVALID)
|
| | | {
|
| | | c_aDistance = new CBufferFloat();
|
| | | if(CheckPointer(c_aDistance) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | c_aDistance.BufferFree();
|
| | | if(!c_aDistance.BufferInit(rows * m_iClusters, 0))
|
| | | return false;
|
| | | //---
|
| | | if(CheckPointer(c_aClasters) == POINTER_INVALID)
|
| | | {
|
| | | c_aClasters = new CBufferFloat();
|
| | | if(CheckPointer(c_aClasters) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | c_aClasters.BufferFree();
|
| | | if(!c_aClasters.BufferInit(rows, 0))
|
| | | return false;
|
| | | //---
|
| | | if(CheckPointer(c_aFlags) == POINTER_INVALID)
|
| | | {
|
| | | c_aFlags = new CBufferFloat();
|
| | | if(CheckPointer(c_aFlags) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | c_aFlags.BufferFree();
|
| | | if(!c_aFlags.BufferInit(rows, 0))
|
| | | return false;
|
| | | //---
|
| | | if(!data.BufferCreate(c_OpenCL) ||
|
| | | !c_aMeans.BufferCreate(c_OpenCL) ||
|
| | | !c_aDistance.BufferCreate(c_OpenCL) ||
|
| | | !c_aClasters.BufferCreate(c_OpenCL) ||
|
| | | !c_aFlags.BufferCreate(c_OpenCL))
|
| | | return false;
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_data, data.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_means, c_aMeans.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_distance, c_aDistance.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_distance, def_k_kmd_vector_size, m_iVectorSize))
|
| | | return false;
|
| | | uint global_work_offset[2] = {0, 0};
|
| | | uint global_work_size[2];
|
| | | global_work_size[0] = rows;
|
| | | global_work_size[1] = m_iClusters;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_distance, 2, global_work_offset, global_work_size))
|
| | | return false;
|
| | | if(!c_aDistance.BufferRead())
|
| | | return false;
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_clustering, def_k_kmc_flags, c_aFlags.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_clustering, def_k_kmc_clusters, c_aClasters.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_clustering, def_k_kmc_distance, c_aDistance.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_clustering, def_k_kmc_total_k, m_iClusters))
|
| | | return false;
|
| | | uint global_work_offset1[1] = {0};
|
| | | uint global_work_size1[1];
|
| | | global_work_size1[0] = rows;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_clustering, 1, global_work_offset1, global_work_size1))
|
| | | return false;
|
| | | if(!c_aClasters.BufferRead())
|
| | | return false;
|
| | | //---
|
| | | data.BufferFree();
|
| | | c_aDistance.BufferFree();
|
| | | c_aFlags.BufferFree();
|
| | | //---
|
| | | return true;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | G et Lo ss implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | double CKmeans::GetLoss(CBufferFloat *data)
|
| | | {
|
| | | if(!Clustering(data))
|
| | | return -1;
|
| | | //---
|
| | | int total = data.Total();
|
| | | int rows = total / m_iVectorSize;
|
| | | //---
|
| | | if(CheckPointer(c_aLoss) == POINTER_INVALID)
|
| | | {
|
| | | c_aLoss = new CBufferFloat();
|
| | | if(CheckPointer(c_aLoss) == POINTER_INVALID)
|
| | | return -1;
|
| | | }
|
| | | if(!c_aLoss.BufferInit(rows, 0))
|
| | | return -1;
|
| | | //---
|
| | | if(!data.BufferCreate(c_OpenCL) ||
|
| | | !c_aLoss.BufferCreate(c_OpenCL))
|
| | | return -1;
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_loss, def_k_kml_data, data.GetIndex()))
|
| | | return -1;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_loss, def_k_kml_means, c_aMeans.GetIndex()))
|
| | | return -1;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_loss, def_k_kml_clusters, c_aClasters.GetIndex()))
|
| | | return -1;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_loss, def_k_kml_loss, c_aLoss.GetIndex()))
|
| | | return -1;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_loss, def_k_kml_vector_size, m_iVectorSize))
|
| | | return -1;
|
| | | uint global_work_offset[1] = {0};
|
| | | uint global_work_size[1];
|
| | | global_work_size[0] = rows;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_loss, 1, global_work_offset, global_work_size))
|
| | | return -1;
|
| | | if(!c_aLoss.BufferRead())
|
| | | return -1;
|
| | | //---
|
| | | m_dLoss = 0;
|
| | | for(int i = 0; i < rows; i++)
|
| | | m_dLoss += c_aLoss.At(i);
|
| | | m_dLoss /= rows;
|
| | | //---
|
| | | data.BufferFree();
|
| | | c_aLoss.BufferFree();
|
| | | return m_dLoss;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | S ta ti st ic implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | bool CKmeans::Statistic(CBufferFloat *data, CBufferFloat *targets)
|
| | | {
|
| | | if(CheckPointer(targets) == POINTER_INVALID ||
|
| | | !Clustering(data))
|
| | | return false;
|
| | | //---
|
| | | if(CheckPointer(c_aProbability) == POINTER_INVALID)
|
| | | {
|
| | | c_aProbability = new CBufferFloat();
|
| | | if(CheckPointer(c_aProbability) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | if(!c_aProbability.BufferInit(3 * m_iClusters, 0))
|
| | | return false;
|
| | | //---
|
| | | int total = c_aClasters.Total();
|
| | | if(!targets.BufferCreate(c_OpenCL) ||
|
| | | !c_aProbability.BufferCreate(c_OpenCL))
|
| | | return false;
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_statistic, def_k_kms_probability, c_aProbability.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_statistic, def_k_kms_targers, targets.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_statistic, def_k_kms_clusters, c_aClasters.GetIndex()))
|
| | | return false;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_statistic, def_k_kms_total_m, total))
|
| | | return false;
|
| | | uint global_work_offset[1] = {0};
|
| | | uint global_work_size[1];
|
| | | global_work_size[0] = m_iClusters;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_statistic, 1, global_work_offset, global_work_size))
|
| | | return false;
|
| | | if(!c_aProbability.BufferRead())
|
| | | return false;
|
| | | //---
|
| | | data.BufferFree();
|
| | | targets.BufferFree();
|
| | | //---
|
| | | return true;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | CBufferFloat *CKmeans::GetProbability(CBufferFloat *data)
|
| | | {
|
| | | if(CheckPointer(c_aProbability) == POINTER_INVALID ||
|
| | | !Clustering(data))
|
| | | return NULL;
|
| | | //---
|
| | | CBufferFloat *result = new CBufferFloat();
|
| | | if(CheckPointer(result) == POINTER_INVALID)
|
| | | return result;
|
| | | //---
|
| | | int total = c_aClasters.Total();
|
| | | if(!result.Reserve(total * 3))
|
| | | {
|
| | | delete result;
|
| | | return result;
|
| | | }
|
| | | for(int i = 0; i < total; i++)
|
| | | {
|
| | | int k = (int)c_aClasters.At(i) * 3;
|
| | | if(!result.Add(c_aProbability.At(k)) ||
|
| | | !result.Add(c_aProbability.At(k + 1)) ||
|
| | | !result.Add(c_aProbability.At(k + 2))
|
| | | )
|
| | | {
|
| | | delete result;
|
| | | return result;
|
| | | }
|
| | | }
|
| | | //---
|
| | | return result;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | S av e implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | bool CKmeans::Save(const int file_handle)
|
| | | {
|
| | | if(file_handle == INVALID_HANDLE)
|
| | | return false;
|
| | | if(FileWriteInteger(file_handle, Type()) < INT_VALUE)
|
| | | return false;
|
| | | if(FileWriteInteger(file_handle, m_iClusters) < INT_VALUE)
|
| | | return false;
|
| | | if(FileWriteInteger(file_handle, m_iVectorSize) < INT_VALUE)
|
| | | return false;
|
| | | if(FileWriteInteger(file_handle, (int)m_bTrained) < INT_VALUE)
|
| | | return false;
|
| | | if(!c_aMeans.Save(file_handle))
|
| | | return false;
|
| | | if(CheckPointer(c_aProbability) == POINTER_INVALID)
|
| | | {
|
| | | if(FileWriteInteger(file_handle, 0) < INT_VALUE)
|
| | | return false;
|
| | | return true;
|
| | | }
|
| | | if(!c_aProbability.Save(file_handle))
|
| | | return false;
|
| | | //---
|
| | | return true;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | //| | L oa d implementation. |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | bool CKmeans::Load(const int file_handle)
|
| | | {
|
| | | if(file_handle == INVALID_HANDLE)
|
| | | return false;
|
| | | //---
|
| | | if(FileIsEnding(file_handle))
|
| | | return false;
|
| | | m_iClusters = FileReadInteger(file_handle);
|
| | | //---
|
| | | if(FileIsEnding(file_handle))
|
| | | return false;
|
| | | m_iVectorSize = FileReadInteger(file_handle);
|
| | | //---
|
| | | if(FileIsEnding(file_handle))
|
| | | return false;
|
| | | m_bTrained = (bool)FileReadInteger(file_handle);
|
| | | //---
|
| | | if(CheckPointer(c_aMeans) == POINTER_INVALID)
|
| | | {
|
| | | c_aMeans = new CBufferFloat();
|
| | | if(CheckPointer(c_aMeans) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | if(FileIsEnding(file_handle) ||
|
| | | !c_aMeans.Load(file_handle))
|
| | | return false;
|
| | | //---
|
| | | if(FileIsEnding(file_handle))
|
| | | return true;
|
| | | //---
|
| | | if(CheckPointer(c_aProbability) == POINTER_INVALID)
|
| | | {
|
| | | c_aProbability = new CBufferFloat();
|
| | | if(CheckPointer(c_aProbability) == POINTER_INVALID)
|
| | | return false;
|
| | | }
|
| | | if(!c_aProbability.Load(file_handle))
|
| | | return FileIsEnding(file_handle);
|
| | | //---
|
| | | return true;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | | //| |
|
2026-03-12 15:02:23 +02:00 | | | //+------------------------------------------------------------------+
|
| | | CBufferFloat *CKmeans::SoftMax(CBufferFloat *data)
|
| | | {
|
| | | if(!m_bTrained && !Study(data, (c_aMeans.Maximum() == 0)))
|
| | | return NULL;
|
| | | //---
|
| | | if(CheckPointer(data) == POINTER_INVALID || CheckPointer(c_OpenCL) == POINTER_INVALID)
|
| | | return NULL;
|
| | | //---
|
| | | int total = data.Total();
|
| | | if(total <= 0 || m_iClusters < 2 || (total % m_iVectorSize) != 0)
|
| | | return NULL;
|
| | | //---
|
| | | int rows = total / m_iVectorSize;
|
| | | if(rows < 1)
|
| | | return NULL;
|
| | | //---
|
| | | if(CheckPointer(c_aDistance) == POINTER_INVALID)
|
| | | {
|
| | | c_aDistance = new CBufferFloat();
|
| | | if(CheckPointer(c_aDistance) == POINTER_INVALID)
|
| | | return NULL;
|
| | | }
|
| | | c_aDistance.BufferFree();
|
| | | if(!c_aDistance.BufferInit(rows * m_iClusters, 0))
|
| | | return NULL;
|
| | | //---
|
| | | if(CheckPointer(c_aSoftMax) == POINTER_INVALID)
|
| | | {
|
| | | c_aSoftMax = new CBufferFloat();
|
| | | if(CheckPointer(c_aSoftMax) == POINTER_INVALID)
|
| | | return NULL;
|
| | | }
|
| | | c_aSoftMax.BufferFree();
|
| | | if(!c_aSoftMax.BufferInit(rows * m_iClusters, 0))
|
| | | return NULL;
|
| | | //---
|
| | | if(!data.BufferCreate(c_OpenCL) ||
|
| | | !c_aMeans.BufferCreate(c_OpenCL) ||
|
| | | !c_aDistance.BufferCreate(c_OpenCL) ||
|
| | | !c_aSoftMax.BufferCreate(c_OpenCL))
|
| | | return NULL;
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_data, data.GetIndex()))
|
| | | return NULL;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_means, c_aMeans.GetIndex()))
|
| | | return NULL;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_distance, def_k_kmd_distance, c_aDistance.GetIndex()))
|
| | | return NULL;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_distance, def_k_kmd_vector_size, m_iVectorSize))
|
| | | return NULL;
|
| | | uint global_work_offset[2] = {0, 0};
|
| | | uint global_work_size[2];
|
| | | global_work_size[0] = rows;
|
| | | global_work_size[1] = m_iClusters;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_distance, 2, global_work_offset, global_work_size))
|
| | | return NULL;
|
| | | if(!c_aDistance.BufferRead())
|
| | | return NULL;
|
| | | //---
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_softmax, def_k_kmsm_distance, c_aDistance.GetIndex()))
|
| | | return NULL;
|
| | | if(!c_OpenCL.SetArgumentBuffer(def_k_kmeans_softmax, def_k_kmsm_softmax, c_aSoftMax.GetIndex()))
|
| | | return NULL;
|
| | | if(!c_OpenCL.SetArgument(def_k_kmeans_softmax, def_k_kmsm_total_k, m_iClusters))
|
| | | return NULL;
|
| | | uint global_work_offset1[1] = {0};
|
| | | uint global_work_size1[1];
|
| | | global_work_size1[0] = rows;
|
| | | if(!c_OpenCL.Execute(def_k_kmeans_softmax, 1, global_work_offset1, global_work_size1))
|
| | | return NULL;
|
| | | if(!c_aSoftMax.BufferRead())
|
| | | return NULL;
|
| | | //---
|
| | | data.BufferFree();
|
| | | c_aDistance.BufferFree();
|
| | | //---
|
| | | return c_aSoftMax;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-08-13 23:48:47 +03:00 | | |
|
