https://github.com/windowsnt/directmllib
A clean way to use DirectML for machine learning
https://github.com/windowsnt/directmllib
cplusplus directml machine-learning
Last synced: 3 months ago
JSON representation
A clean way to use DirectML for machine learning
- Host: GitHub
- URL: https://github.com/windowsnt/directmllib
- Owner: WindowsNT
- License: mit
- Created: 2025-02-18T21:34:16.000Z (over 1 year ago)
- Default Branch: master
- Last Pushed: 2025-03-03T05:12:53.000Z (about 1 year ago)
- Last Synced: 2025-03-03T05:24:57.627Z (about 1 year ago)
- Topics: cplusplus, directml, machine-learning
- Language: C++
- Homepage:
- Size: 106 KB
- Stars: 2
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
# DirectML Lib
A quick way to use Direct ML for machine learning with a clean interface.
# Quick Usage
```
int main()
{
CoInitializeEx(NULL, COINIT_MULTITHREADED);
ML ml(true);
auto hr = ml.On();
if (FAILED(hr))
return 0;
MLOP op1(&ml);
op1.
AddInput({ DML_TENSOR_DATA_TYPE_FLOAT32, { 10,10} }).
AddInput({ DML_TENSOR_DATA_TYPE_FLOAT32, { 10,10} }).
AddIntermediate(dml::Sin(op1.Item(0))).
AddIntermediate(dml::Cos(op1.Item(2))).
AddOutput(dml::Add(op1.Item(3), op1.Item(1)));
ml.ops.push_back(op1.Build());
// Initialize
ml.Prepare();
// Run it 5 times
for (int y = 0; y < 5; y++)
{
// Upload data
std::vector data(100);
for (int i = 0; i < 100; i++)
data[i] = (float)(i * (y + 1));
op1.Item(0).buffer->Upload(&ml, data.data(), data.size() * sizeof(float));
op1.Item(1).buffer->Upload(&ml, data.data(), data.size() * sizeof(float));
ml.Run();
// Download data
std::vector fdata(100);
std::vector cdata(400);
op1.Item(4).buffer->Download(&ml, 400, cdata);
memcpy(fdata.data(), cdata.data(), 400);
}
}
```
Example of executing a Linear Regression operator
```
auto LinearRegressionCPU(float* px, float* py, size_t n)
{
// Sx
float Sx = 0, Sy = 0, Sxy = 0, Sx2 = 0;
for (size_t i = 0; i < n; i++)
{
Sx += px[i];
Sx2 += px[i] * px[i];
Sy += py[i];
Sxy += px[i] * py[i];
}
float B = (n * Sxy - Sx * Sy) / ((n * Sx2) - (Sx * Sx));
float A = (Sy - (B * Sx)) / n;
printf("Linear Regression CPU:\r\nSx = %f\r\nSy = %f\r\nSxy = %f\r\nSx2 = %f\r\nA = %f\r\nB = %f\r\n\r\n", Sx, Sy, Sxy, Sx2, A, B);
return std::tuple(A, B);
}
void LinearRegressionDML(float* px, float* py, unsigned int n)
{
ML ml(true);
ml.SetFeatureLevel(DML_FEATURE_LEVEL_6_4);
auto hr = ml.On();
if (FAILED(hr))
return;
MLOP op1(&ml);
// Input X [0]
op1.AddInput({ DML_TENSOR_DATA_TYPE_FLOAT32, { 1,n} });
// Input Y [1]
op1.AddInput({ DML_TENSOR_DATA_TYPE_FLOAT32, { 1,n} });
// Constant n [2]
op1.AddIntermediate(ml.ConstantValueTensor(*op1.GetGraph().get(), (float)n, { 1,1 }));
// Sx [3]
op1.AddIntermediate(dml::Slice(dml::CumulativeSummation(op1.Item(0), 1, DML_AXIS_DIRECTION_INCREASING, false), { 0, n - 1 }, { 1, 1 }, { 1, 1 }));
// Sy [4]
op1.AddIntermediate(dml::Slice(dml::CumulativeSummation(op1.Item(1), 1, DML_AXIS_DIRECTION_INCREASING, false), { 0, n - 1 }, { 1, 1 }, { 1, 1 }));
// Sxy [5]
op1.AddIntermediate(dml::Slice(dml::CumulativeSummation(dml::Multiply(op1.Item(0), op1.Item(1)), 1, DML_AXIS_DIRECTION_INCREASING, false), { 0, n - 1 }, { 1, 1 }, { 1, 1 }));
// Sx2 [6]
op1.AddIntermediate(dml::Slice(dml::CumulativeSummation(dml::Multiply(op1.Item(0), op1.Item(0)), 1, DML_AXIS_DIRECTION_INCREASING, false), { 0, n - 1 }, { 1, 1 }, { 1, 1 }));
// float B = (n * Sxy - Sx * Sy) / ((n * Sx2) - (Sx * Sx));
// B [7]
op1.AddOutput((
dml::Divide(
dml::Subtract(
dml::Multiply(
op1.Item(2),
op1.Item(5)
),
dml::Multiply(
op1.Item(3),
op1.Item(4)
)
),
dml::Subtract(
dml::Multiply(
op1.Item(2),
op1.Item(6)
),
dml::Multiply(
op1.Item(3),
op1.Item(3)
)
)
)
));
// float A = (Sy - (B * Sx)) / n; [8]
op1.AddOutput(dml::Divide(
dml::Subtract(
op1.Item(4),
dml::Multiply(
op1.Item(7),
op1.Item(3)
)
),
op1.Item(2)
));
ml.ops.push_back(op1.Build());
ml.Prepare();
ml.ops[0].Item(0).buffer->Upload(&ml, px, n * sizeof(float));
ml.ops[0].Item(1).buffer->Upload(&ml, py, n * sizeof(float));
ml.Run();
std::vector cdata;
float A = 0, B = 0;
ml.ops[0].Item(7).buffer->Download(&ml, (size_t)-1, cdata);
memcpy(&B, cdata.data(), 4);
ml.ops[0].Item(8).buffer->Download(&ml, (size_t)-1, cdata);
memcpy(&A, cdata.data(), 4);
printf("Linear Regression GPU:\r\nA = %f\r\nB = %f\r\n\r\n", A, B);
}
```