public void CanCompileLinearRegressionKernel()
{
TileCompiler compiler = new TileCompiler();
var(yactual, x) = new Vector(5, out Index i).Two("yactual", "x");
Scalar a = new Scalar("a"), b = new Scalar("b");
var ypred = a * x + b;
var yloss = MEAN[SQUARE[yactual - ypred]];
Kernel <int> loss = new Kernel <int>(yloss, compiler);
Assert.True(loss.Compile());
}
public void SumExpression()
{
var compiler = new TileCompiler();
var(linear, a, x, b, res) = LinearTile();
var kernel = compiler.Compile(linear);
var tensors = new ITensor[] { a, x, b, res };
kernel.Eval(tensors);
CheckRes(res);
}
public void LookupExpression()
{
var compiler = new TileCompiler();
var(tile, input, lookup, res) = LookupTile();
var kernel = compiler.Compile(tile);
var tensors = new ITensor[] { input, lookup, res };
kernel.Eval(tensors);
CheckRes(res);
}
public void MaxExpression()
{
var compiler = new TileCompiler();
var(simpleMax, input, res) = SimpleMaxTile();
var kernel = compiler.Compile(simpleMax);
var tensors = new ITensor[] { input, res };
kernel.Eval(tensors);
CheckRes(res);
}
public void ElementWiseExpression()
{
var compiler = new TileCompiler();
var(transpose, input, res) = TransposeTile();
var kernel = compiler.Compile(transpose);
var tensors = new ITensor[] { input, res };
kernel.Eval(tensors);
CheckRes(res);
}
public void CanComputeGradient()
{
string code = @"function(I)-> (O) {
O = I * I;
}";
TileCompiler c = new TileCompiler();
Assert.True(c.Compile(5, code, out IRunnable <int> result));
var O = new Vector("O", 5).Var(new int[5]);
IVariable <int> G = new Vector("G", 5).Var(new int[5]);
var I = new Vector("I", 5).Var(1, 2, 3, 4, 5);
Assert.Equal(RunStatus.Success, result.Run(O, ref G, I));
Assert.Equal(8, G[3]);
}
public void CanCompileLinearRegressionKernel()
{
TileCompiler compiler = new TileCompiler();
var(x, ypred, yactual, yerror, yloss) = new Vector(5, out Index i).Five("x", "ypred", "yactual", "yerror",
"yloss");
var(a, b) = new Scalar().Two("a", "b");
var N = yactual[0];
ypred.def = a * x + b;
Kernel <int> predict = new Kernel <int>(ypred, compiler);
Assert.True(predict.Compile());
yerror.def = SQUARE[yactual - ypred];
Kernel <int> error = new Kernel <int>(yerror, compiler);
Assert.True(error.Compile());
Assert.Contains(a, error.InputShapes);
Assert.Contains(b, error.InputShapes);
Assert.Contains(x, error.InputShapes);
Assert.Contains(yactual, error.InputShapes);
Assert.Equal(4, error.InputShapes.Count);
Assert.Equal(yerror, error.OutputShape);
var va = a.Var(5);
var vb = b.Var(6);
var vx = x.Var(1, 2, 3, 4, 5);
var vya = yactual.Var(new [] { 10, 20, 30, 40, 50 });
var vyerror = yerror.Var <int>();
Assert.Equal(RunStatus.Success, error.CompilerResult.Run(vyerror, vya, va, vx, vb));
Assert.Equal(System.Math.Pow(vya[0] - ((5 * 1) + 6), 2), vyerror[0]);
for (int index = 0; index < vyerror.ElementCount; index++)
{
Assert.Equal(System.Math.Pow(vya[index] - ((va * vx[index]) + vb), 2), vyerror[index]);
}
yloss[i, N] = MEAN[yerror[i]];
Assert.True(yloss.IsDefined);
Assert.Equal(N, yloss.ContractionDefinition.Expression.Shape[0]);
Kernel <int> loss = new Kernel <int>(yloss, compiler);
Assert.True(loss.Compile());
}
public void ZeroAndSum()
{
var compiler = new TileCompiler();
var(linear, a, x, b, res) = LinearTile();
var kernel = compiler.Compile(linear);
var tensors = new ITensor[] { a, x, b, res };
var sr = res.Buffer.Span;
for (var i = 0; i < sr.Length; i++)
{
sr[i] = i; // non-zero initialization
}
kernel.Eval(tensors);
// correct only if 'res' is re-initialized before the sum
CheckRes(res);
}
public void CanCompileTileCode()
{
string code = @"function(I[N])-> (O) {
O[i: N] = +(I[k]), i - k < N;
}";
TileCompiler c = new TileCompiler();
Assert.True(c.Compile(5, code, out IRunnable <int> result));
var O = new Vector("O", 5).Var(new int[5]);
var I = new Vector("I", 5).Var(1, 2, 3, 4, 5);
Assert.Equal(RunStatus.Success, result.Run(O, I));
Assert.Equal(I[0] + I[1] + I[2] + I[3], O[3]);
code = @"function(I)-> (O) {
O = I * I;
}";
Assert.True(c.Compile(6, code, out result));
O = new Vector("O", 6).Var(new int[6]);
I = new Vector("I", 6).Var(2, 4, 6, 8, 10, 12);
Assert.Equal(RunStatus.Success, result.Run(O, I));
Assert.Equal(16, O[1]);
code = @"
function(I0[N], I1[N])-> (O) {
S = (I1 - I0) * (I1 - I0);
O[n:N] = +(S[n]);
}";
Assert.True(c.Compile(2, 6, code, out result));
var I0 = new Vector("I0", 6).Var(1, 2, 3, 4, 5, 6);
var I1 = new Vector("I1", 6).Var(5, 5, 6, 6, 7, 7);
Assert.Equal(RunStatus.Success, result.Run(O, I0, I1));
Assert.Equal(16, O[0]);
Assert.Equal(9, O[1]);
//I.=l
}
private void Compile()
{
Console.WriteLine("Compiling resources...");
using (var sprites_texture = new TextureCompiler(Path.Combine(OutputDirectory, "SpritesTexture")))
using (var tiles_texture = new TextureCompiler(Path.Combine(OutputDirectory, "TilesTexture")))
using (var interfaces_texture = new TextureCompiler(Path.Combine(OutputDirectory, "InterfacesTexture")))
{
foreach (var cat in Table.Categories)
{
var type = Enum.Parse <ResourceType>(cat.Key);
string output = "";
Compiler compiler = null;
switch (type)
{
case ResourceType.Entity:
compiler = new EntityCompiler();
compiler.Texture = sprites_texture;
output = Path.Combine(OutputDirectory, "Entities");
break;
case ResourceType.Event:
compiler = new EventCompiler();
compiler.Texture = sprites_texture;
output = Path.Combine(OutputDirectory, "Events");
break;
case ResourceType.Interface:
compiler = new InterfaceCompiler();
compiler.Texture = interfaces_texture;
output = Path.Combine(OutputDirectory, "Interfaces");
break;
//case ResourceType.Item:
// compiler = new ItemCompiler();
// break;
case ResourceType.Tile:
compiler = new TileCompiler();
compiler.Texture = tiles_texture;
output = Path.Combine(OutputDirectory, "Tiles");
break;
}
if (compiler != null)
{
using (compiler.Writer = new BinaryWriter(File.OpenWrite(output)))
{
compiler.RootDirectory = InputDirectory;
compiler.Table = Table;
compiler.Writer.Write(Table.GetLastID(cat.Key) + 1);
int id = 0;
foreach (var item in cat.Value)
{
while (id < item.ID)
{
compiler.Placeholder();
id++;
}
compiler.Compile(item.Path);
id++;
}
}
}
else
{
Console.WriteLine($"Warning: Unsupported resource type [{type}].");
}
//foreach (var v in cat.Value)
// Console.WriteLine(v.Path);
}
}
Console.WriteLine("Compilation done.");
Console.WriteLine();
}
