public string TrainModel(IpfsJob job)
{
var tmpInput = Ipfs.Get <JToken>(job.input);
var tmpTarget = Ipfs.Get <JToken>(job.target);
var seq = CreateSequential(job.Model);
var inputData = tmpInput.SelectToken("data").ToObject <float[]>();
var inputShape = tmpInput.SelectToken("shape").ToObject <int[]>();
var inputTensor = controller.floatTensorFactory.Create(_data: inputData, _shape: inputShape, _autograd: true);
var targetData = tmpTarget.SelectToken("data").ToObject <float[]>();
var targetShape = tmpTarget.SelectToken("shape").ToObject <int[]>();
var targetTensor = controller.floatTensorFactory.Create(_data: targetData, _shape: targetShape, _autograd: true);
var grad = controller.floatTensorFactory.Create(_data: new float[] { 1, 1, 1, 1 },
_shape: new int[] { 4, 1 });
Loss loss;
switch (job.config.criterion)
{
case "mseloss":
loss = new MSELoss(this.controller);
break;
case "categorical_crossentropy":
loss = new CategoricalCrossEntropyLoss(this.controller);
break;
case "cross_entropy_loss":
loss = new CrossEntropyLoss(this.controller, 1); // TODO -- real value
break;
case "nll_loss":
loss = new NLLLoss(this.controller);
break;
default:
loss = new MSELoss(this.controller);
break;
}
var optimizer = new SGD(this.controller, seq.getParameters(), job.config.lr, 0, 0);
for (var i = 0; i < job.config.iters; ++i)
{
var pred = seq.Forward(inputTensor);
var l = loss.Forward(pred, targetTensor);
l.Backward();
// TODO -- better batch size
optimizer.Step(100, i);
}
var resultJob = new Ipfs();
var response = resultJob.Write(new IpfsJob(job.input, job.target, seq.GetConfig(), job.config));
return(response.Hash);
}
public string processMessage(string json_message)
{
//Debug.LogFormat("<color=green>SyftController.processMessage {0}</color>", json_message);
Command msgObj = JsonUtility.FromJson <Command> (json_message);
try
{
switch (msgObj.objectType)
{
case "FloatTensor":
{
if (msgObj.objectIndex == 0 && msgObj.functionCall == "create")
{
FloatTensor tensor = floatTensorFactory.Create(_shape: msgObj.shape, _data: msgObj.data, _shader: this.Shader);
return(tensor.Id.ToString());
}
else
{
FloatTensor tensor = floatTensorFactory.Get(msgObj.objectIndex);
// Process message's function
return(tensor.ProcessMessage(msgObj, this));
}
}
case "IntTensor":
{
if (msgObj.objectIndex == 0 && msgObj.functionCall == "create")
{
int[] data = new int[msgObj.data.Length];
for (int i = 0; i < msgObj.data.Length; i++)
{
data[i] = (int)msgObj.data[i];
}
IntTensor tensor = intTensorFactory.Create(_shape: msgObj.shape, _data: data, _shader: this.Shader);
return(tensor.Id.ToString());
}
else
{
IntTensor tensor = intTensorFactory.Get(msgObj.objectIndex);
// Process message's function
return(tensor.ProcessMessage(msgObj, this));
}
}
case "model":
{
if (msgObj.functionCall == "create")
{
string model_type = msgObj.tensorIndexParams[0];
if (model_type == "linear")
{
Debug.LogFormat("<color=magenta>createModel:</color> {0} : {1} {2}", model_type,
msgObj.tensorIndexParams[1], msgObj.tensorIndexParams[2]);
Linear model = new Linear(this, int.Parse(msgObj.tensorIndexParams[1]), int.Parse(msgObj.tensorIndexParams[2]));
return(model.Id.ToString());
}
else if (model_type == "sigmoid")
{
Debug.LogFormat("<color=magenta>createModel:</color> {0}", model_type);
Sigmoid model = new Sigmoid(this);
return(model.Id.ToString());
}
else if (model_type == "sequential")
{
Debug.LogFormat("<color=magenta>createModel:</color> {0}", model_type);
Sequential model = new Sequential(this);
return(model.Id.ToString());
}
else if (model_type == "policy")
{
Debug.LogFormat("<color=magenta>createModel:</color> {0}", model_type);
Policy model = new Policy(this, (Layer)getModel(int.Parse(msgObj.tensorIndexParams[1])));
return(model.Id.ToString());
}
else if (model_type == "tanh")
{
Debug.LogFormat("<color=magenta>createModel:</color> {0}", model_type);
Tanh model = new Tanh(this);
return(model.Id.ToString());
}
else if (model_type == "crossentropyloss")
{
Debug.LogFormat("<color=magenta>createModel:</color> {0}", model_type);
CrossEntropyLoss model = new CrossEntropyLoss(this);
return(model.Id.ToString());
}
else if (model_type == "mseloss")
{
Debug.LogFormat("<color=magenta>createModel:</color> {0}", model_type);
MSELoss model = new MSELoss(this);
return(model.Id.ToString());
}
}
else
{
Model model = this.getModel(msgObj.objectIndex);
return(model.ProcessMessage(msgObj, this));
}
return("Unity Error: SyftController.processMessage: Command not found:" + msgObj.objectType + ":" + msgObj.functionCall);
}
case "controller":
{
if (msgObj.functionCall == "num_tensors")
{
return(floatTensorFactory.Count() + "");
}
else if (msgObj.functionCall == "num_models")
{
return(models.Count + "");
}
else if (msgObj.functionCall == "new_tensors_allowed")
{
Debug.LogFormat("New Tensors Allowed:{0}", msgObj.tensorIndexParams[0]);
if (msgObj.tensorIndexParams[0] == "True")
{
allow_new_tensors = true;
}
else if (msgObj.tensorIndexParams[0] == "False")
{
allow_new_tensors = false;
}
else
{
throw new Exception("Invalid parameter for new_tensors_allowed. Did you mean true or false?");
}
return(allow_new_tensors + "");
}
return("Unity Error: SyftController.processMessage: Command not found:" + msgObj.objectType + ":" + msgObj.functionCall);
}
default:
break;
}
}
catch (Exception e)
{
Debug.LogFormat("<color=red>{0}</color>", e.ToString());
return("Unity Error: " + e.ToString());
}
// If not executing createTensor or tensor function, return default error.
return("Unity Error: SyftController.processMessage: Command not found:" + msgObj.objectType + ":" + msgObj.functionCall);
}
