public string ProcessMessage(Command msgObj, SyftController ctrl)
{
switch (msgObj.functionCall)
{
case "abs_":
{
// calls the function on our tensor object
Abs_();
// returns the function call name with the OK status
return(id.ToString());
}
case "add_":
{
Add_((float)msgObj.tensorIndexParams[0]);
return(msgObj.functionCall + ": OK");
}
case "add":
{
var tensor_1 = ctrl.getTensor(msgObj.tensorIndexParams[0]);
var result = tensor_1.Add(tensor_1);
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "addmm_":
{
var tensor_1 = ctrl.getTensor(msgObj.tensorIndexParams[0]);
var tensor_2 = ctrl.getTensor(msgObj.tensorIndexParams[1]);
AddMatrixMultiply(tensor_1, tensor_2);
return(msgObj.functionCall + ": OK");
}
case "ceil":
{
var result = Ceil();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "cpu":
{
Cpu();
return(msgObj.functionCall + ": OK");
}
case "floor_":
{
Floor_();
return(id.ToString());
}
case "gpu":
{
if (Gpu())
{
return(msgObj.functionCall + ": OK : Moved data to GPU.");
}
else
{
return(msgObj.functionCall + ": FAILED : Did not move data.");
}
}
case "mul":
{
FloatTensor tensor_1 = ctrl.getTensor(msgObj.tensorIndexParams[0]);
var result = MulElementwise(tensor_1);
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "mul_scalar":
{
var result = MulScalar((float)msgObj.tensorIndexParams[0]);
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "neg":
{
var result = Neg();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "print":
{
bool dataOriginallyOnGpu = dataOnGpu;
if (dataOnGpu)
{
Cpu();
}
string data = string.Join(", ", Data);
Debug.LogFormat("<color=cyan>print:</color> {0}", data);
if (dataOriginallyOnGpu)
{
Gpu();
}
return(data);
}
case "sub_":
{
var tensor1 = ctrl.getTensor(msgObj.tensorIndexParams[0]);
var result = SubtractElementwise(tensor1);
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "zero_":
{
Zero_();
return(msgObj.functionCall + ": OK");
}
default: break;
}
return("SyftController.processMessage: Command not found.");
}
public string ProcessMessage(Command msgObj, SyftController ctrl)
{
switch (msgObj.functionCall)
{
case "abs":
{
// calls the function on our tensor object
var result = this.Abs();
// returns the function call name with the OK status
return(result.id + "");
}
case "abs_":
{
// calls the function on our tensor object
this.Abs(inline: true);
// returns the function call name with the OK status
return(id.ToString());
}
case "add_elem":
{
Debug.LogFormat("add_elem");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Add(tensor_1);
return(result.id + "");
}
case "acos":
{
var result = Acos();
return(result.Id.ToString());
}
case "acos_":
{
Acos(inline: true);
return(Id.ToString());
}
case "asin":
{
var result = Asin();
return(result.Id.ToString());
}
case "asin_":
{
Asin(inline: true);
return(Id.ToString());
}
case "atan":
{
var result = Atan();
return(result.Id.ToString());
}
case "atan_":
{
Atan(inline: true);
return(Id.ToString());
}
case "add_elem_":
{
Debug.LogFormat("add_elem_");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Add(tensor_1, inline: true);
return(this.id + "");
}
case "add_scalar":
{
Debug.LogFormat("add_scalar");
FloatTensor result = Add(float.Parse(msgObj.tensorIndexParams[0]));
return(result.Id + "");
}
case "add_scalar_":
{
Debug.LogFormat("add_scalar_");
this.Add(float.Parse(msgObj.tensorIndexParams[0]), inline: true);
return(this.id + "");
}
case "addmm_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var tensor_2 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[1]));
AddMatrixMultiply(tensor_1, tensor_2);
return(msgObj.functionCall + ": OK");
}
case "addmv_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var tensor_2 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[1]));
AddMatrixVectorProduct(tensor_1, tensor_2);
return(msgObj.functionCall + ": OK");
}
case "backward":
{
if (msgObj.tensorIndexParams.Length > 0)
{
var grad = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
Backward(grad);
}
else
{
Backward();
}
return("");
}
case "ceil":
{
var result = this.Ceil();
return(result.id + "");
}
case "ceil_":
{
this.Ceil(inline: true);
return(this.id + "");
}
case "copy":
{
var result = Copy();
return(result.Id.ToString());
}
case "cos":
{
var result = Cos();
return(result.Id.ToString());
}
case "cos_":
{
Cos(inline: true);
return(Id.ToString());
}
case "cosh":
{
var result = Cosh();
return(result.Id.ToString());
}
case "Cosh_":
{
Cosh(inline: true);
return(Id.ToString());
}
case "cpu":
{
Cpu();
return(msgObj.functionCall + ": OK");
}
case "div_elem":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Div(tensor_1);
return(result.Id + "");
}
case "div_elem_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Div(tensor_1, inline: true);
return(this.id + "");
}
case "div_scalar":
{
FloatTensor result = Div(float.Parse(msgObj.tensorIndexParams[0]));
return(result.Id + "");
}
case "div_scalar_":
{
this.Div(float.Parse(msgObj.tensorIndexParams[0]), inline: true);
return(this.id + "");
}
case "exp":
{
var result = Exp();
return(result.Id.ToString());
}
case "exp_":
{
Exp(inline: true);
return(Id.ToString());
}
case "mul_scalar":
{
FloatTensor result = Mul(float.Parse(msgObj.tensorIndexParams[0]));
return(result.id + "");
}
case "mul_scalar_":
{
this.Mul(float.Parse(msgObj.tensorIndexParams[0]), inline: true);
return(this.id + "");
}
case "pow_elem":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Pow(tensor_1);
return(result.id + "");
}
case "floor":
{
var result = this.Floor();
return(result.id + "");
}
case "floor_":
{
this.Floor(inline: true);
return(this.id + "");
}
case "round":
{
var result = Round();
return(result.Id.ToString());
}
case "get":
{
var param_to_get = msgObj.tensorIndexParams[0];
switch (param_to_get)
{
case "autograd":
{
if (this.autograd)
{
return("1");
}
return("0");
}
case "children":
{
if (children != null)
{
string children_str = "";
foreach (KeyValuePair <int, int> entry in children)
{
children_str += (entry.Key + ",");
}
return(children_str);
}
else
{
return("");
}
}
case "creation_op":
{
if (creation_op != null)
{
return(creation_op);
}
return("");
}
case "creators":
{
if (creators != null)
{
string creators_str = "";
foreach (FloatTensor entry in creators)
{
creators_str += (entry.id + ",");
}
return(creators_str);
}
else
{
return("");
}
}
case "data":
{
string out_str = "";
if (dataOnGpu)
{
int[] temp_data = new int[size];
dataBuffer.GetData(temp_data);
for (int i = 0; i < size; i++)
{
out_str += temp_data[i] + ",";
}
}
else
{
for (int i = 0; i < size; i++)
{
out_str += data[i] + ",";
}
}
return(out_str);
}
case "dataOnGpu":
{
if (dataOnGpu)
{
return("1");
}
return("0");
}
case "grad":
{
if (Grad == null)
{
return("");
}
return(Grad.id + "");
}
case "id":
{
return(this.id + "");
}
case "keepgrads":
{
if (this.keepgrads)
{
return("1");
}
return("0");
}
case "size":
{
return(this.size + "");
}
case "shape":
{
string shape_str = "";
for (int i = 0; i < shape.Length; i++)
{
shape_str += (shape[i] + ",");
}
return(shape_str);
}
}
return("param not found or not configured with a getter");
}
case "gpu":
{
if (Gpu(ctrl.GetShader()))
{
return(msgObj.functionCall + ": OK : Moved data to GPU.");
}
else
{
return(msgObj.functionCall + ": FAILED : Did not move data.");
}
}
case "log1p":
{
var result = Log1p();
return(result.Id.ToString());
}
case "mul_elem":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Mul(tensor_1);
return(result.id + "");
}
case "mul_elem_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Mul(tensor_1, inline: true);
return(this.id + "");
}
case "mm":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.MM(tensor_1);
return(result.id + "");
}
case "pow_elem_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Pow(tensor_1, inline: true);
return(this.id + "");
}
case "pow_scalar":
{
FloatTensor result = Pow(float.Parse(msgObj.tensorIndexParams[0]));
return(result.id + "");
}
case "pow_scalar_":
{
this.Pow(float.Parse(msgObj.tensorIndexParams[0]), inline: true);
return(this.id + "");
}
case "set":
{
var param_to_set = msgObj.tensorIndexParams[0];
switch (param_to_set)
{
case "autograd":
{
if (msgObj.tensorIndexParams[1] == "1")
{
InitAutograd();
return("1");
}
else
{
autograd = false;
return("0");
}
}
}
return("setter not recognized");
}
case "sigmoid_":
{
this.Sigmoid(inline: true);
return(this.id + "");
}
case "sigmoid":
{
var result = this.Sigmoid();
return(result.id + "");
}
case "sub_elem":
{
Debug.LogFormat("sub_elem");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Sub(tensor_1);
return(result.Id + "");
}
case "sub_elem_":
{
Debug.LogFormat("sub_elem_");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Sub(tensor_1, inline: true);
return(this.id + "");
}
case "neg":
{
var result = Neg();
return(result.Id.ToString());
}
case "neg_":
{
Neg(inline: true);
return(Id.ToString());
}
case "rsqrt":
{
var result = Rsqrt();
return(result.Id.ToString());
}
case "print":
{
bool dataOriginallyOnGpu = dataOnGpu;
if (dataOnGpu)
{
Cpu();
}
string data = this.Print();
Debug.LogFormat("<color=cyan>Print:</color> {0}", string.Join(",", this.Data));
if (dataOriginallyOnGpu)
{
Gpu(ctrl.GetShader());
}
return(data);
}
case "sign":
{
Debug.LogFormat("sign");
var result = this.Sign();
return(result.Id + "");
}
case "sign_":
{
Debug.LogFormat("sign_");
Sign(inline: true);
return(Id.ToString());
}
case "sin":
{
var result = Sin();
return(result.Id.ToString());
}
case "sin_":
{
Sin(inline: true);
return(Id.ToString());
}
case "sqrt":
{
var result = Sqrt();
return(result.id.ToString());
}
case "size":
{
var result = SizeTensor();
return(result.id.ToString());
}
case "sub_scalar":
{
Debug.LogFormat("sub_scalar");
FloatTensor result = Sub(float.Parse(msgObj.tensorIndexParams[0]));
return(result.Id + "");
}
case "sub_scalar_":
{
Debug.LogFormat("sub_scalar_");
this.Sub(float.Parse(msgObj.tensorIndexParams[0]), inline: true);
return(this.id + "");
}
case "to_numpy":
{
return(string.Join(" ", data));
}
case "tan":
{
var result = Tan();
return(result.Id.ToString());
}
case "tan_":
{
Tan(inline: true);
return(Id.ToString());
}
case "tanh":
{
var result = Tanh();
return(result.Id.ToString());
}
case "sinh":
{
var result = Sinh();
return(result.Id.ToString());
}
case "sinh_":
{
Sinh(inline: true);
return(Id.ToString());
}
case "trace":
{
var result = Trace();
return(result.ToString());
}
case "transpose":
{
var result = Transpose();
return(result.Id.ToString());
}
case "triu":
{
var K = int.Parse(msgObj.tensorIndexParams[0]);
var result = Copy();
result.Triu_(K);
return(result.Id.ToString());
}
case "triu_":
{
var K = int.Parse(msgObj.tensorIndexParams[0]);
Triu_(K);
return(Id.ToString());
}
case "trunc":
{
var result = Trunc();
return(result.Id.ToString());
}
case "view":
{
int[] new_dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
new_dims[i] = int.Parse(msgObj.tensorIndexParams[i]);
}
var result = View(new_dims);
return(result.Id.ToString());
}
case "view_":
{
int[] new_dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
new_dims[i] = int.Parse(msgObj.tensorIndexParams[i]);
}
View(new_dims, inline: true);
return(Id.ToString());
}
case "view_as":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams [0]));
var result = ViewAs(tensor_1, false);
return(result.Id.ToString());
}
case "view_as_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams [0]));
this.ViewAs(tensor_1, true);
return(Id.ToString());
}
case "zero_":
{
Zero_();
return(msgObj.functionCall + ": OK");
}
case "is_contiguous":
{
return(Convert.ToString(IsContiguous()));
}
case "squeeze":
{
if (msgObj.tensorIndexParams.Length > 0)
{
int dim = int.Parse(msgObj.tensorIndexParams[0]);
var result = Squeeze(dim: dim);
ctrl.addTensor(result);
return(result.Id.ToString());
}
else
{
var result = Squeeze();
ctrl.addTensor(result);
return(result.Id.ToString());
}
}
case "sqeeze_":
{
if (msgObj.tensorIndexParams.Length > 0)
{
int dim = int.Parse(msgObj.tensorIndexParams[0]);
Squeeze(dim: dim, inline: true);
return(Id.ToString());
}
else
{
Squeeze(inline: true);
return(Id.ToString());
}
}
case "min":
{
int dim = -1;
bool keepdim = false;
if (msgObj.tensorIndexParams.Length > 0)
{
dim = int.Parse(msgObj.tensorIndexParams[0]);
keepdim = bool.Parse(msgObj.tensorIndexParams[1]);
}
return(Min(dim: dim, keepdim: keepdim).Id.ToString());
}
case "max":
{
int dim = -1;
bool keepdim = false;
if (msgObj.tensorIndexParams.Length > 0)
{
dim = int.Parse(msgObj.tensorIndexParams[0]);
keepdim = bool.Parse(msgObj.tensorIndexParams[1]);
}
return(Max(dim: dim, keepdim: keepdim).Id.ToString());
}
case "sum":
{
int dim = -1;
bool keepdim = false;
if (msgObj.tensorIndexParams.Length > 0)
{
dim = int.Parse(msgObj.tensorIndexParams[0]);
keepdim = bool.Parse(msgObj.tensorIndexParams[1]);
}
return(Sum(dim: dim, keepdim: keepdim).Id.ToString());
}
case "prod":
{
int dim = -1;
bool keepdim = false;
if (msgObj.tensorIndexParams.Length > 0)
{
dim = int.Parse(msgObj.tensorIndexParams[0]);
keepdim = bool.Parse(msgObj.tensorIndexParams[1]);
}
return(Prod(dim: dim, keepdim: keepdim).Id.ToString());
}
case "mean":
{
int dim = -1;
bool keepdim = false;
if (msgObj.tensorIndexParams.Length > 0)
{
dim = int.Parse(msgObj.tensorIndexParams[0]);
keepdim = bool.Parse(msgObj.tensorIndexParams[1]);
}
return(Mean(dim: dim, keepdim: keepdim).Id.ToString());
}
default:
break;
}
return("SyftController.processMessage: Command not found.");
}
public string ProcessMessage(Command msgObj, SyftController ctrl)
{
switch (msgObj.functionCall)
{
case "abs":
{
// calls the function on our tensor object
var result = this.Abs();
// returns the function call name with the OK status
return(ctrl.addTensor(result) + "");
}
case "abs_":
{
// calls the function on our tensor object
Abs_();
// returns the function call name with the OK status
return(id.ToString());
}
case "add_elem":
{
Debug.LogFormat("add_elem");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Add(tensor_1);
return(ctrl.addTensor(result) + "");
}
case "add_elem_":
{
Debug.LogFormat("add_elem_");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Add_(tensor_1);
return(this.id + "");
}
case "add_scalar":
{
Debug.LogFormat("add_scalar");
FloatTensor result = Add(float.Parse(msgObj.tensorIndexParams[0]));
return(ctrl.addTensor(result) + "");
}
case "add_scalar_":
{
Debug.LogFormat("add_scalar_");
this.Add_(float.Parse(msgObj.tensorIndexParams[0]));
return(this.id + "");
}
case "addmm_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var tensor_2 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[1]));
AddMatrixMultiply(tensor_1, tensor_2);
return(msgObj.functionCall + ": OK");
}
case "ceil":
{
var result = Ceil();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "copy":
{
var result = Copy();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "cos":
{
var result = Cos();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "cos_":
{
Cos_();
return(Id.ToString());
}
case "cosh":
{
var result = Cosh();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "Cosh_":
{
Cosh_();
return(Id.ToString());
}
case "cpu":
{
Cpu();
return(msgObj.functionCall + ": OK");
}
case "div_elem":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Div(tensor_1);
return(ctrl.addTensor(result) + "");
}
case "div_elem_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Div_(tensor_1);
return(this.id + "");
}
case "div_scalar":
{
FloatTensor result = Div(float.Parse(msgObj.tensorIndexParams[0]));
return(ctrl.addTensor(result) + "");
}
case "div_scalar_":
{
this.Div_(float.Parse(msgObj.tensorIndexParams[0]));
return(this.id + "");
}
case "floor_":
{
Floor_();
return(id.ToString());
}
case "gpu":
{
if (Gpu())
{
return(msgObj.functionCall + ": OK : Moved data to GPU.");
}
else
{
return(msgObj.functionCall + ": FAILED : Did not move data.");
}
}
case "mul_elem":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Mul(tensor_1);
return(ctrl.addTensor(result) + "");
}
case "mul_elem_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Mul_(tensor_1);
return(this.id + "");
}
case "mul_scalar":
{
FloatTensor result = Mul(float.Parse(msgObj.tensorIndexParams[0]));
return(ctrl.addTensor(result) + "");
}
case "mul_scalar_":
{
this.Mul_(float.Parse(msgObj.tensorIndexParams[0]));
return(this.id + "");
}
case "neg":
{
var result = Neg();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "print":
{
bool dataOriginallyOnGpu = dataOnGpu;
if (dataOnGpu)
{
Cpu();
}
string data = this.Print();
Debug.LogFormat("<color=cyan>Print:</color> {0}", this.Data);
if (dataOriginallyOnGpu)
{
Gpu();
}
return(data);
}
case "sigmoid_":
{
Sigmoid_();
return(msgObj.functionCall + ": OK");
}
case "sqrt":
{
var result = Sqrt();
ctrl.addTensor(result);
return(result.id.ToString());
}
case "sub_elem":
{
Debug.LogFormat("sub_elem");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Sub(tensor_1);
return(ctrl.addTensor(result) + "");
}
case "sub_elem_":
{
Debug.LogFormat("sub_elem_");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Sub_(tensor_1);
return(this.id + "");
}
case "sub_scalar":
{
Debug.LogFormat("sub_scalar");
FloatTensor result = Sub(float.Parse(msgObj.tensorIndexParams[0]));
return(ctrl.addTensor(result) + "");
}
case "sub_scalar_":
{
Debug.LogFormat("sub_scalar_");
this.Sub_(float.Parse(msgObj.tensorIndexParams[0]));
return(this.id + "");
}
case "sum_dim":
{
Debug.LogFormat("sum_dim");
FloatTensor result = this.Sum(int.Parse(msgObj.tensorIndexParams[0]));
return(ctrl.addTensor(result) + "");
}
case "tanh":
{
var result = Tanh();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "sinh":
{
var result = Sinh();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "sinh_":
{
Sinh_();
return(Id.ToString());
}
case "transpose":
{
var result = Copy();
result = result.Transpose();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "triu":
{
var K = int.Parse(msgObj.tensorIndexParams[0]);
var result = Copy();
result.Triu_(K);
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "triu_":
{
var K = int.Parse(msgObj.tensorIndexParams[0]);
Triu_(K);
return(Id.ToString());
}
case "trunc":
{
var result = Trunc();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "view":
{
int [] new_dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
new_dims [i] = int.Parse(msgObj.tensorIndexParams [i]);
}
var result = View(new_dims);
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "view_":
{
int [] new_dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
new_dims [i] = int.Parse(msgObj.tensorIndexParams [i]);
}
View_(new_dims);
return(Id.ToString());
}
case "zero_":
{
Zero_();
return(msgObj.functionCall + ": OK");
}
case "is_contiguous":
{
return(Convert.ToString(IsContiguous()));
}
default: break;
}
return("SyftController.processMessage: Command not found.");
}
public FloatTensor(SyftController _ctrl,
int[] _shape,
float[] _data = null,
ComputeBuffer _dataBuffer = null,
ComputeBuffer _shapeBuffer = null,
ComputeShader _shader = null,
bool _copyData = true,
bool _dataOnGpu = false,
bool _autograd = false,
bool _keepgrads = false,
string _creation_op = null)
{
ctrl = _ctrl;
dataOnGpu = _dataOnGpu;
autograd = _autograd;
keepgrads = _keepgrads;
creation_op = _creation_op;
if (autograd)
{
InitAutograd();
}
// First: check that shape is valid.
if (_shape == null || _shape.Length == 0)
{
throw new InvalidOperationException("Tensor shape can't be an empty array.");
}
// Second: since shape is valid, let's save it
shape = (int[])_shape.Clone();
setStridesAndCheckShape();
// Third: let's see what kind of data we've got. We should either have
// a GPU ComputeBuffer or a data[] object.
if (_data != null && _shapeBuffer == null && _dataBuffer == null)
{
InitCpu(_data: _data, _copyData: _copyData);
}
else if (_dataBuffer != null && _shapeBuffer != null && SystemInfo.supportsComputeShaders && _data == null)
{
// looks like we have GPU data being passed in... initialize a GPU tensor.
InitGpu(_shader, _dataBuffer, _shapeBuffer, _copyData);
}
else
{
// no data seems to be passed in... or its got missing stuff
// if CPU works... go with that
if (_data != null)
{
InitCpu(_data, _copyData);
}
else if (_dataBuffer != null && _shader != null)
{
if (SystemInfo.supportsComputeShaders)
{
// seems i'm just missing a shape buffer - no biggie
shapeBuffer = new ComputeBuffer(shape.Length, sizeof(int));
shapeBuffer.SetData(shape);
InitGpu(_shader, _dataBuffer, _shapeBuffer, _copyData);
}
else
{
throw new InvalidOperationException(
"You seem to be trying to create a GPU tensor without having access to a GPU...");
}
}
else
{
// nothing else seems to work - i suppose i'm just supposed to initialize an empty tensor.
long acc = 1;
for (var i = shape.Length - 1; i >= 0; --i)
{
acc *= shape[i];
}
if (_dataOnGpu)
{
_shapeBuffer = new ComputeBuffer(shape.Length, sizeof(int));
_shapeBuffer.SetData(shape);
_dataBuffer = new ComputeBuffer(size, sizeof(float));
InitGpu(_shader: _shader, _dataBuffer: _dataBuffer, _shapeBuffer: _shapeBuffer,
_copyData: false);
this.Zero_();
}
else
{
_data = new float[acc];
InitCpu(_data, false);
}
}
}
// // Lastly: let's set the ID of the tensor.
// // IDEs might show a warning, but ref and volatile seems to be working with Interlocked API.
#pragma warning disable 420
id = System.Threading.Interlocked.Increment(ref nCreated);
ctrl.addTensor(this);
if (SystemInfo.supportsComputeShaders && shader == null)
{
shader = ctrl.GetShader();
}
//
//
}
public string ProcessMessage(Command msgObj, SyftController ctrl)
{
switch (msgObj.functionCall)
{
case "abs":
{
// calls the function on our tensor object
var result = this.Abs();
// returns the function call name with the OK status
return(ctrl.addTensor(result) + "");
}
case "abs_":
{
// calls the function on our tensor object
Abs_();
// returns the function call name with the OK status
return(id.ToString());
}
case "add_elem":
{
Debug.LogFormat("add_elem");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Add(tensor_1);
return(ctrl.addTensor(result) + "");
}
case "add_elem_":
{
Debug.LogFormat("add_elem_");
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Add_(tensor_1);
return(this.id + "");
}
case "add_scalar":
{
Debug.LogFormat("add_scalar");
FloatTensor result = Add(float.Parse(msgObj.tensorIndexParams[0]));
return(ctrl.addTensor(result) + "");
}
case "add_scalar_":
{
Debug.LogFormat("add_scalar_");
this.Add_(float.Parse(msgObj.tensorIndexParams[0]));
return(this.id + "");
}
case "addmm_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var tensor_2 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[1]));
AddMatrixMultiply(tensor_1, tensor_2);
return(msgObj.functionCall + ": OK");
}
case "ceil":
{
var result = Ceil();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "copy":
{
var result = Copy();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "cpu":
{
Cpu();
return(msgObj.functionCall + ": OK");
}
case "floor_":
{
Floor_();
return(id.ToString());
}
case "gpu":
{
if (Gpu())
{
return(msgObj.functionCall + ": OK : Moved data to GPU.");
}
else
{
return(msgObj.functionCall + ": FAILED : Did not move data.");
}
}
case "mul_elem":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = this.Mul(tensor_1);
return(ctrl.addTensor(result) + "");
}
case "mul_elem_":
{
var tensor_1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
this.Mul_(tensor_1);
return(this.id + "");
}
case "mul_scalar":
{
FloatTensor result = Mul(float.Parse(msgObj.tensorIndexParams[0]));
return(ctrl.addTensor(result) + "");
}
case "mul_scalar_":
{
this.Mul_(float.Parse(msgObj.tensorIndexParams[0]));
return(this.id + "");
}
case "neg":
{
var result = Neg();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "print":
{
bool dataOriginallyOnGpu = dataOnGpu;
if (dataOnGpu)
{
Cpu();
}
string data = this.Print();
Debug.LogFormat("<color=cyan>Print:</color> {0}", this.Data);
if (dataOriginallyOnGpu)
{
Gpu();
}
return(data);
}
case "sigmoid_":
{
Sigmoid_();
return(msgObj.functionCall + ": OK");
}
case "sub_elem":
{
var tensor1 = ctrl.getTensor(int.Parse(msgObj.tensorIndexParams[0]));
var result = SubtractElementwise(tensor1);
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "tanh":
{
var result = Tanh();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "transpose":
{
var result = Copy();
result = result.Transpose();
ctrl.addTensor(result);
return(result.Id.ToString());
}
case "zero_":
{
Zero_();
return(msgObj.functionCall + ": OK");
}
default: break;
}
return("SyftController.processMessage: Command not found.");
}
