public void TrainModel(IpfsModel model)
{
var seq = CreateSequential(model.Model);
var tmpInput = Ipfs.Get(model.input);
var tmpTarget = Ipfs.Get(model.target);
var input = controller.floatTensorFactory.Create(_data: tmpInput.Data,
_shape: tmpInput.Shape,
_autograd: true);
var target = controller.floatTensorFactory.Create(_data: tmpTarget.Data,
_shape: tmpTarget.Shape,
_autograd: true);
var grad = controller.floatTensorFactory.Create(_data: new float[] { 1, 1, 1, 1 },
_shape: new int[] { 4, 1 });
var pred = seq.Forward(input);
var loss = pred.Sub(target).Pow(2);
loss.Backward(grad);
foreach (var p in seq.getParameters())
{
var pTensor = controller.floatTensorFactory.Get(p);
pTensor.Sub(pTensor.Grad, inline: true);
}
var layerIdxs = seq.getLayers();
Linear lin = (Linear)controller.getModel(layerIdxs[0]);
Debug.Log(string.Join(",", loss.Data));
}
public async void CheckStatus(string experimentId, Action <string> response)
{
var experiment = Ipfs.Get <IpfsExperiment>(experimentId);
var results = new bool[experiment.jobs.Count()];
for (var i = 0; i < experiment.jobs.Count(); ++i)
{
results[i] = await CheckModelFromJob(experiment.jobs[i]);
}
var allLoaded = true;
for (var i = 0; i < results.Count(); ++i)
{
if (!results[i])
{
allLoaded = false;
}
}
if (allLoaded)
{
response("Complete");
}
else
{
response("In progress");
}
return;
}
private async Task <int> LoadModelFromJob(string job)
{
var getResultRequest = new GetResultsRequest(job);
getResultRequest.RunRequestSync();
var responseHash = getResultRequest.GetResponse().resultAddress;
while (responseHash == "")
{
Debug.Log(string.Format("Could not load job {0}. Trying again in 1 seconds.", job));
await Task.Delay(1000);
// run the request again
getResultRequest = new GetResultsRequest(job);
getResultRequest.RunRequestSync();
responseHash = getResultRequest.GetResponse().resultAddress;
}
// load the model into memory
var response = Ipfs.Get <IpfsJob>(responseHash);
var modelDefinition = response.Model;
var model = this.CreateSequential(modelDefinition);
return(model.Id);
}
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 async void GetResults(string experimentId, Action <string> response)
{
var experiment = Ipfs.Get <IpfsExperiment>(experimentId);
var results = new int[experiment.jobs.Count()];
for (var i = 0; i < experiment.jobs.Count(); ++i)
{
results[i] = await LoadModelFromJob(experiment.jobs[i]);
}
response(JsonConvert.SerializeObject(results));
return;
}
public void Run(int inputId, int targetId, List <GridConfiguration> configurations, MonoBehaviour owner)
{
Debug.Log("Grid.Run");
string ipfsHash = "";
var inputTensor = controller.floatTensorFactory.Get(inputId);
var targetTensor = controller.floatTensorFactory.Get(targetId);
// write the input and target tensors to Ipfs
var inputJob = new Ipfs();
var targetJob = new Ipfs();
var inputIpfsResponse = inputJob.Write(inputTensor.GetConfig());
var targetIpfsResponse = targetJob.Write(targetTensor.GetConfig());
Debug.Log("Input Hash: " + inputIpfsResponse.Hash);
Debug.Log("Target Hash: " + targetIpfsResponse.Hash);
var jobs = new string[configurations.Count];
for (var i = 0; i < configurations.Count; ++i)
{
var config = configurations[i];
var model = controller.getModel(config.model) as Sequential;
var serializedModel = model.GetConfig();
var configJob = new Ipfs();
var ipfsJobConfig = new IpfsJobConfig(config.lr);
var response = configJob.Write(new IpfsJob(serializedModel, ipfsJobConfig));
jobs[i] = response.Hash;
}
var experiment = new IpfsExperiment(inputIpfsResponse.Hash, targetIpfsResponse.Hash, jobs);
var experimentWriteJob = new Ipfs();
var experimentResult = experimentWriteJob.Write(experiment);
var request = new Request();
owner.StartCoroutine(request.AddModel(owner, experimentResult.Hash));
PollNext(owner, request);
}
public string Run(int inputId, int targetId, List <GridConfiguration> configurations, MonoBehaviour owner)
{
Debug.Log("Grid.Run");
var inputTensor = controller.floatTensorFactory.Get(inputId);
var targetTensor = controller.floatTensorFactory.Get(targetId);
// write the input and target tensors to Ipfs
var inputJob = new Ipfs();
var targetJob = new Ipfs();
var inputIpfsResponse = inputJob.Write(inputTensor.GetConfig());
var targetIpfsResponse = targetJob.Write(targetTensor.GetConfig());
Debug.Log("Input Hash: " + inputIpfsResponse.Hash);
Debug.Log("Target Hash: " + targetIpfsResponse.Hash);
var jobs = new string[configurations.Count];
for (var i = 0; i < configurations.Count; ++i)
{
var config = configurations[i];
var model = controller.GetModel(config.model) as Sequential;
var serializedModel = model.GetConfig();
var configJob = new Ipfs();
var ipfsJobConfig = new IpfsJobConfig(config.lr, config.criterion, config.iters);
var response = configJob.Write(new IpfsJob(inputIpfsResponse.Hash, targetIpfsResponse.Hash, serializedModel, ipfsJobConfig));
jobs[i] = response.Hash;
}
var experiment = new IpfsExperiment(jobs);
var experimentWriteJob = new Ipfs();
var experimentResult = experimentWriteJob.Write(experiment);
BlockChain chain = Camera.main.GetComponent <BlockChain>();
owner.StartCoroutine(chain.AddExperiment(experimentResult.Hash, jobs));
experiments.Add(experimentResult.Hash);
return(experimentResult.Hash);
}
public void Run(int inputId, int targetId, List <GridConfiguration> configurations, MonoBehaviour owner)
{
Debug.Log("Grid.Run");
string ipfsHash = "";
var inputTensor = controller.floatTensorFactory.Get(inputId);
var targetTensor = controller.floatTensorFactory.Get(targetId);
// write the input and target tensors to Ipfs
var inputJob = new Ipfs();
var targetJob = new Ipfs();
var inputIpfsResponse = inputJob.Write(inputTensor);
var targetIpfsResponse = targetJob.Write(targetTensor);
Debug.Log("Input Hash: " + inputIpfsResponse.Hash);
Debug.Log("Target Hash: " + targetIpfsResponse.Hash);
configurations.ForEach((config) => {
var model = controller.getModel(config.model) as Sequential;
var layers = model.getLayers();
var serializedModel = new List <String>();
layers.ForEach((layerId) => {
var layer = controller.getModel(layerId);
var json = layer.GetConfig().ToString(Formatting.None);
serializedModel.Add(json);
});
var configJob = new Ipfs();
var response = configJob.Write(new IpfsModel(inputIpfsResponse.Hash, targetIpfsResponse.Hash, serializedModel, config.lr));
ipfsHash = response.Hash;
Debug.Log("Model Hash: " + ipfsHash);
});
var request = new Request();
owner.StartCoroutine(request.AddModel(owner, ipfsHash));
}
public void TrainModel(MonoBehaviour owner, string input, string target, IpfsJob job, int modelId)
{
var tmpInput = Ipfs.Get <JToken>(input);
var tmpTarget = Ipfs.Get <JToken>(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 });
// 10 epochs .. make configurable
for (var i = 0; i < 10; ++i)
{
var pred = seq.Forward(inputTensor);
var loss = pred.Sub(targetTensor).Pow(2);
loss.Backward(grad);
foreach (var p in seq.getParameters())
{
var pTensor = controller.floatTensorFactory.Get(p);
pTensor.Sub(pTensor.Grad, inline: true);
}
}
var resultJob = new Ipfs();
var config = new IpfsJobConfig(job.config.lr);
var response = resultJob.Write(new IpfsJob(seq.GetConfig(), config));
var req = new Request();
owner.StartCoroutine(req.AddWeights(owner, modelId, response.Hash));
}
public async void CheckStatus(string experimentId, Action <string> response)
{
var experiment = Ipfs.Get <IpfsExperiment>(experimentId);
var results = new bool[experiment.jobs.Count()];
for (var i = 0; i < experiment.jobs.Count(); ++i)
{
results[i] = await CheckModelFromJob(experiment.jobs[i]);
}
var allLoaded = true;
int not_loaded = 0;
int loaded = 0;
for (var i = 0; i < results.Count(); ++i)
{
if (!results[i])
{
allLoaded = false;
not_loaded = not_loaded + 1;
}
else
{
loaded = loaded + 1;
}
}
if (allLoaded)
{
response("Complete");
}
else
{
response("In progress (" + loaded.ToString() + "/" + (loaded + not_loaded).ToString() + " models are done)");
}
return;
}
IEnumerator PollNetwork()
{
var getJobIdRequest = new GetAvailableJobIdRequest();
yield return(getJobIdRequest.RunRequest());
var jobId = getJobIdRequest.GetResponse().jobId;
if (jobId == null)
{
yield return(new WaitForSeconds(10));
PollNext();
}
else
{
var getJobRequest = new GetJobRequest(jobId);
yield return(getJobRequest.RunRequest());
var jobHash = getJobRequest.GetResponse().jobAddress;
var job = Ipfs.Get <IpfsJob>(jobHash);
var controller = Camera.main.GetComponent <SyftServer>().controller;
var grid = new OpenMined.Network.Controllers.Grid(controller);
var result = grid.TrainModel(job);
var response = new AddResultRequest(jobHash, result);
yield return(response.RunRequest());
Debug.Log("did a job");
yield return(new WaitForSeconds(10));
PollNext();
}
}
public string processMessage(string json_message, MonoBehaviour owner)
{
//Debug.LogFormat("<color=green>SyftController.processMessage {0}</color>", json_message);
Command msgObj = JsonUtility.FromJson <Command> (json_message);
try
{
switch (msgObj.objectType)
{
case "Optimizer":
{
if (msgObj.functionCall == "create")
{
string optimizer_type = msgObj.tensorIndexParams[0];
// Extract parameters
List <int> p = new List <int>();
for (int i = 1; i < msgObj.tensorIndexParams.Length; i++)
{
p.Add(int.Parse(msgObj.tensorIndexParams[i]));
}
List <float> hp = new List <float>();
for (int i = 0; i < msgObj.hyperParams.Length; i++)
{
hp.Add(float.Parse(msgObj.hyperParams[i]));
}
Optimizer optim = null;
if (optimizer_type == "sgd")
{
optim = new SGD(this, p, hp[0], hp[1], hp[2]);
}
else if (optimizer_type == "rmsprop")
{
optim = new RMSProp(this, p, hp[0], hp[1], hp[2], hp[3]);
}
else if (optimizer_type == "adam")
{
optim = new Adam(this, p, hp[0], hp[1], hp[2], hp[3], hp[4]);
}
return(optim.Id.ToString());
}
else
{
Optimizer optim = this.getOptimizer(msgObj.objectIndex);
return(optim.ProcessMessage(msgObj, this));
}
}
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 "agent":
{
if (msgObj.functionCall == "create")
{
Layer model = (Layer)getModel(int.Parse(msgObj.tensorIndexParams[0]));
Optimizer optimizer = optimizers[int.Parse(msgObj.tensorIndexParams[1])];
return(new Syft.NN.RL.Agent(this, model, optimizer).Id.ToString());
}
//Debug.Log("Getting Model:" + msgObj.objectIndex);
Syft.NN.RL.Agent agent = this.getAgent(msgObj.objectIndex);
return(agent.ProcessMessageLocal(msgObj, this));
}
case "model":
{
if (msgObj.functionCall == "create")
{
string model_type = msgObj.tensorIndexParams[0];
Debug.LogFormat("<color=magenta>createModel:</color> {0}", model_type);
if (model_type == "linear")
{
return(this.BuildLinear(msgObj.tensorIndexParams).Id.ToString());
}
else if (model_type == "relu")
{
return(this.BuildReLU().Id.ToString());
}
else if (model_type == "log")
{
return(this.BuildLog().Id.ToString());
}
else if (model_type == "dropout")
{
return(this.BuildDropout(msgObj.tensorIndexParams).Id.ToString());
}
else if (model_type == "sigmoid")
{
return(this.BuildSigmoid().Id.ToString());
}
else if (model_type == "sequential")
{
return(this.BuildSequential().Id.ToString());
}
else if (model_type == "softmax")
{
return(this.BuildSoftmax(msgObj.tensorIndexParams).Id.ToString());
}
else if (model_type == "logsoftmax")
{
return(this.BuildLogSoftmax(msgObj.tensorIndexParams).Id.ToString());
}
else if (model_type == "tanh")
{
return(new Tanh(this).Id.ToString());
}
else if (model_type == "crossentropyloss")
{
return(new CrossEntropyLoss(this, int.Parse(msgObj.tensorIndexParams[1])).Id.ToString());
}
else if (model_type == "categorical_crossentropy")
{
return(new CategoricalCrossEntropyLoss(this).Id.ToString());
}
else if (model_type == "nllloss")
{
return(new NLLLoss(this).Id.ToString());
}
else if (model_type == "mseloss")
{
return(new MSELoss(this).Id.ToString());
}
else if (model_type == "embedding")
{
return(new Embedding(this, int.Parse(msgObj.tensorIndexParams[1]), int.Parse(msgObj.tensorIndexParams[2])).Id.ToString());
}
else
{
Debug.LogFormat("<color=red>Model Type Not Found:</color> {0}", model_type);
}
}
else
{
//Debug.Log("Getting Model:" + msgObj.objectIndex);
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 + "");
}
else if (msgObj.functionCall == "load_floattensor")
{
FloatTensor tensor = floatTensorFactory.Create(filepath: msgObj.tensorIndexParams[0], _shader: this.Shader);
return(tensor.Id.ToString());
}
else if (msgObj.functionCall == "set_seed")
{
Random.InitState(int.Parse(msgObj.tensorIndexParams[0]));
return("Random seed set!");
}
else if (msgObj.functionCall == "concatenate")
{
List <int> tensor_ids = new List <int>();
for (int i = 1; i < msgObj.tensorIndexParams.Length; i++)
{
tensor_ids.Add(int.Parse(msgObj.tensorIndexParams[i]));
}
FloatTensor result = Functional.Concatenate(floatTensorFactory, tensor_ids, int.Parse(msgObj.tensorIndexParams[0]));
return(result.Id.ToString());
}
else if (msgObj.functionCall == "ones")
{
int[] dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
dims[i] = int.Parse(msgObj.tensorIndexParams[i]);
}
FloatTensor result = Functional.Ones(floatTensorFactory, dims);
return(result.Id.ToString());
}
else if (msgObj.functionCall == "randn")
{
int[] dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
dims[i] = int.Parse(msgObj.tensorIndexParams[i]);
}
FloatTensor result = Functional.Randn(floatTensorFactory, dims);
return(result.Id.ToString());
}
else if (msgObj.functionCall == "random")
{
int[] dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
dims[i] = int.Parse(msgObj.tensorIndexParams[i]);
}
FloatTensor result = Functional.Random(floatTensorFactory, dims);
return(result.Id.ToString());
}
else if (msgObj.functionCall == "zeros")
{
int[] dims = new int[msgObj.tensorIndexParams.Length];
for (int i = 0; i < msgObj.tensorIndexParams.Length; i++)
{
dims[i] = int.Parse(msgObj.tensorIndexParams[i]);
}
FloatTensor result = Functional.Zeros(floatTensorFactory, dims);
return(result.Id.ToString());
}
else if (msgObj.functionCall == "model_from_json")
{
Debug.Log("Loading Model from JSON:");
var json_str = msgObj.tensorIndexParams[0];
var config = JObject.Parse(json_str);
Sequential model;
if ((string)config["class_name"] == "Sequential")
{
model = this.BuildSequential();
}
else
{
return("Unity Error: SyftController.processMessage: while Loading model, Class :" + config["class_name"] + " is not implemented");
}
for (int i = 0; i < config["config"].ToList().Count; i++)
{
var layer_desc = config["config"][i];
var layer_config_desc = layer_desc["config"];
if ((string)layer_desc["class_name"] == "Linear")
{
int previous_output_dim;
if (i == 0)
{
previous_output_dim = (int)layer_config_desc["batch_input_shape"][layer_config_desc["batch_input_shape"].ToList().Count - 1];
}
else
{
previous_output_dim = (int)layer_config_desc["units"];
}
string[] parameters = new string[] { "linear", previous_output_dim.ToString(), layer_config_desc["units"].ToString(), "Xavier" };
Layer layer = this.BuildLinear(parameters);
model.AddLayer(layer);
string activation_name = layer_config_desc["activation"].ToString();
if (activation_name != "linear")
{
Layer activation;
if (activation_name == "softmax")
{
parameters = new string[] { activation_name, "1" };
activation = this.BuildSoftmax(parameters);
}
else if (activation_name == "relu")
{
activation = this.BuildReLU();
}
else
{
return("Unity Error: SyftController.processMessage: while Loading activations, Activation :" + activation_name + " is not implemented");
}
model.AddLayer(activation);
}
}
else
{
return("Unity Error: SyftController.processMessage: while Loading layers, Layer :" + layer_desc["class_name"] + " is not implemented");
}
}
return(model.Id.ToString());
}
return("Unity Error: SyftController.processMessage: Command not found:" + msgObj.objectType + ":" + msgObj.functionCall);
}
case "Grid":
if (msgObj.functionCall == "learn")
{
var inputId = int.Parse(msgObj.tensorIndexParams[0]);
var targetId = int.Parse(msgObj.tensorIndexParams[1]);
return(this.grid.Run(inputId, targetId, msgObj.configurations, owner));
}
if (msgObj.functionCall == "getResults")
{
// TODO -- This will be converted to poll blockchain
// It is written to poll IPFS right now so it
// appears to be working client side.
var experiment = Ipfs.Get <IpfsExperiment>(msgObj.experimentId);
var results = experiment.jobs.Select((job) =>
{
var getResultRequest = new GetResultsRequest(job);
getResultRequest.RunRequestSync();
var responseHash = getResultRequest.GetResponse().resultAddress;
// load the model into memory
var modelDefinition = Ipfs.Get <IpfsJob>(responseHash).Model;
var model = this.grid.CreateSequential(modelDefinition);
return(model.Id);
});
var modelIdsString = JsonConvert.SerializeObject(results.ToArray());
return(modelIdsString);
}
break;
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);
}
