Eduardobernardi/NN_in_Trading
Watch
1
0
Fork
You've already forked NN_in_Trading
 0
forked from dng/NN_in_Trading
Code Pull requests Activity
NN_in_Trading/Experts/Unsupervised/K-means/kmeans.mqh
DNG DNG 0f9b8cf008 VLADriver-RAG
2026-08-13 23:48:47 +03:00
755 lines
25 KiB
MQL5
RawPermalinkBlameHistory
//+------------------------------------------------------------------+
//| kmeans.mqh |
//| Copyright 2022, DNG |
//| https://www.mql5.com/ru/users/dng |
//+------------------------------------------------------------------+
#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
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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; }
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CKmeans::CKmeans(void) : m_iClusters(2),
m_iVectorSize(1),
m_dLoss(-1),
//| Implements m_bTrained |
m_bTrained(false)
{
c_aMeans = new CBufferFloat();
if(CheckPointer(c_aMeans) != POINTER_INVALID)
c_aMeans.BufferInit(m_iClusters * m_iVectorSize, 0);
c_OpenCL = NULL;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | S et Op en CL implementation. |
//+------------------------------------------------------------------+
bool CKmeans::SetOpenCL(COpenCLMy *context)
{
c_OpenCL = context;
//---
return (c_OpenCL == context);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | I ni t implementation. |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | S tu dy implementation. |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | C lu st er in g implementation. |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | G et Lo ss implementation. |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | S ta ti st ic implementation. |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | S av e implementation. |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| | L oa d implementation. |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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;
}
//+------------------------------------------------------------------+
View git blameCopy permalink