public void InstantiationTest()
{
container = new NetworkContainer();
EncogWrapper.Instantiate(ref container);
Assert.IsNotNull(container.network);
}
//----------------------------------------
#region Constructor
internal NetworkReportDialog(NetworkContainer networkContainer, NetworkDatabase networkDatabase)
{
this.m_database = networkDatabase;
this.m_network = networkContainer;
this.InitializeComponent();
}
internal NetworkReportDialog(NetworkContainer networkContainer, NetworkDatabase networkDatabase)
{
this.m_database = networkDatabase;
this.m_network = networkContainer;
this.InitializeComponent();
}
private TreeNode createNode(NetworkContainer container)
{
TreeNode node = new TreeNode("Network");
node.Tag = container;
return(node);
}
//---------------------------------------------
#region Public Methods
public NetworkContainer CreateNetworkContainer()
{
NetworkContainer neuralNetwork = null;
int[] hiddenLayers = new int[cbHiddenLayerNumber.SelectedIndex];
switch (hiddenLayers.Length)
{
case 0:
break;
case 1:
hiddenLayers[0] = (int)this.nHidden1.Value;
break;
case 2:
hiddenLayers[1] = (int)this.nHidden2.Value;
goto case 1;
case 3:
hiddenLayers[2] = (int)this.nHidden3.Value;
goto case 2;
case 4:
hiddenLayers[3] = (int)this.nHidden4.Value;
goto case 3;
default:
break;
}
IActivationFunction activationFunction = null;
if (this.rbBipolarSigmoid.Checked)
{
activationFunction = new BipolarSigmoidFunction((double)numSigmoidAlpha.Value);
}
else if (this.rbSigmoid.Checked)
{
activationFunction = new SigmoidFunction((double)numSigmoidAlpha.Value);
}
else if (this.rbThreshold.Checked)
{
activationFunction = new ThresholdFunction();
}
neuralNetwork = new NetworkContainer(
tbNetworkName.Text,
m_networkSchema,
activationFunction,
hiddenLayers);
// neuralNetwork.Schema.DataRanges.ActivationFunctionRange = new AForge.DoubleRange((double)numRangeLow.Value, (double)numRangeHigh.Value);
return(neuralNetwork);
}
public void SendChatMessage(string sMessage)
{
NetworkContainer cMessage = new NetworkContainer();
cMessage.Command = "SEND_MESSAGE";
cMessage.Message = m_sUsername + ": " + sMessage;
byte[] acData = NetworkManager.Instance.getBytes(cMessage);
m_cUdpClient.Send(acData, acData.Length, m_cServer);
}
public void ShowDetails(NetworkContainer network)
{
this.Show();
this.BringToFront();
this.m_networkContainer = network;
this.lbType.Text = "Type: " + network.ActivationNetwork.GetType().Name;
this.lbFunction.Text = "Function: " + m_networkContainer.Function;
this.lbInputs.Text = "Inputs: " + network.ActivationNetwork.InputsCount;
this.lbOutputs.Text = "Outputs: " + network.ActivationNetwork[network.ActivationNetwork.LayersCount - 1].NeuronsCount;
}
//----------------------------------------
#region Public Methods
public void ShowDetails(NetworkContainer network)
{
this.Show();
this.BringToFront();
this.m_networkContainer = network;
this.lbType.Text = "Type: " + network.ActivationNetwork.GetType().Name;
this.lbFunction.Text = "Function: " + m_networkContainer.Function;
this.lbInputs.Text = "Inputs: " + network.ActivationNetwork.InputsCount;
this.lbOutputs.Text = "Outputs: " + network.ActivationNetwork[network.ActivationNetwork.LayersCount - 1].NeuronsCount;
}
public byte[] getBytes(NetworkContainer str)
{
int size = Marshal.SizeOf(str);
byte[] arr = new byte[size];
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(str, ptr, true);
Marshal.Copy(ptr, arr, 0, size);
Marshal.FreeHGlobal(ptr);
return(arr);
}
public void SaveAndRestoreModelFS()
{
NetworkContainer container2 = new NetworkContainer();
EncogWrapper.SaveNetworkToFS(ref container, "./unittest.bin");
EncogWrapper.LoadNetworkFromFS(ref container2, "./unittest.bin");
var Layers = container.network.Structure.Flat.LayerCounts;
var Layers2 = container2.network.Structure.Flat.LayerCounts;
Assert.AreEqual(Layers, Layers2);
}
// Use this for initialization
void Start()
{
if (isLocalPlayer)
{
playerNumber = FindObjectOfType <PlayerNumber>();
}
GoButtom = GameObject.Find("GoButton");
if (isServer && isLocalPlayer)
{
GoButtom.transform.localPosition = new Vector3(0, 0, 0);
GoButtom.SetActive(false);
}
networkContainer = FindObjectOfType <NetworkContainer>();
if (isLocalPlayer && !isServer)
{
color = new Color(Random.value, Random.value, Random.value);
CmdSyncColor(color);
if (!networkContainer.playerTwo)
{
SetupPlayerSlot(1);
}
else if (!networkContainer.playerThree)
{
SetupPlayerSlot(2);
}
else if (!networkContainer.playerFour)
{
SetupPlayerSlot(3);
}
else if (!networkContainer.playerFive)
{
SetupPlayerSlot(4);
}
else
{
Debug.LogError("Too much player");
Destroy(gameObject);
}
}
if (isLocalPlayer && isServer)
{
Debug.Log("PlayerOne");
SetupPlayerSlot(0);
}
}
public NetworkContainer fromBytes(byte[] arr)
{
NetworkContainer str = new NetworkContainer();
int size = Marshal.SizeOf(str);
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.Copy(arr, 0, ptr, size);
str = (NetworkContainer)Marshal.PtrToStructure(ptr, str.GetType());
Marshal.FreeHGlobal(ptr);
return(str);
}
private IEnumerator ListeningUDP()
{
m_cUdpClient = new UdpClient();
m_cUdpClient.Client.Bind(new IPEndPoint(IPAddress.Any, m_nPort));
IPEndPoint cEnd = new IPEndPoint(0, 0);
m_acClients = new List <IPAddress>();
Task.Run(() => {
while (true)
{
var cBuffer = m_cUdpClient.Receive(ref cEnd);
if (cBuffer != null)
{
if (Encoding.UTF8.GetString(cBuffer) == "SERVER_SEARCH")
{
byte[] acResponse = Encoding.UTF8.GetBytes("SERVER_RESPONSE");
m_cUdpClient.Send(acResponse, acResponse.Length, cEnd.Address.ToString(), m_nPort);
}
else
{
Debug.Log("Trying to join " + cEnd.Address.ToString());
NetworkContainer cMessage = NetworkManager.Instance.fromBytes(cBuffer);
if (cMessage.Command == "JOIN_SERVER")
{
m_acClients.Add(cEnd.Address);
Debug.Log("Joined server successfully " + cEnd.Address.ToString());
NetworkContainer cResponse = new NetworkContainer();
cResponse.Command = "ADD_CHAT_LOG";
cResponse.Message = cMessage.Message + " ist dem Server beigetreten!";
foreach (IPAddress cIP in m_acClients)
{
m_cUdpClient.Send(NetworkManager.Instance.getBytes(cResponse), NetworkManager.Instance.getBytes(cResponse).Length, new IPEndPoint(cIP, m_nPort));
}
}
}
}
}
});
yield return(new WaitForEndOfFrame());
}
//----------------------------------------
#region Private Methods
private void populateTreeView(NetworkContainer networkContainer)
{
treeView.BeginUpdate();
treeView.Nodes.Clear();
TreeNode networkNode;
TreeNode[] layerNodes;
TreeNode[] neuronNodes;
TreeNode[] weightNodes;
layerNodes = new TreeNode[networkContainer.ActivationNetwork.LayersCount];
for (int i = 0; i < networkContainer.ActivationNetwork.LayersCount; ++i)
{
neuronNodes = new TreeNode[networkContainer.ActivationNetwork[i].NeuronsCount];
for (int j = 0; j < networkContainer.ActivationNetwork[i].NeuronsCount; ++j)
{
weightNodes = new TreeNode[networkContainer.ActivationNetwork[i][j].InputsCount];
for (int k = 0; k < networkContainer.ActivationNetwork[i][j].InputsCount; ++k)
{
weightNodes[k] = new TreeNode(String.Format("[{0}]: {1}", k + 1,
networkContainer.ActivationNetwork[i][j][k]), 3, 3);
weightNodes[k].Tag = networkContainer.ActivationNetwork[i][j];
weightNodes[k].ForeColor = Color.Gray;
}
neuronNodes[j] = new TreeNode(String.Format("Neuron {0}", j + 1), 2, 2,
weightNodes);
neuronNodes[j].Tag = networkContainer.ActivationNetwork[i][j];
}
layerNodes[i] = new TreeNode(String.Format("Layer {0}", i + 1), 1, 1,
neuronNodes);
layerNodes[i].Tag = networkContainer.ActivationNetwork[i];
}
networkNode = new TreeNode(networkContainer.Name, 0, 0, layerNodes);
networkNode.Tag = networkContainer;
treeView.Nodes.Add(networkNode);
treeView.SelectedNode = networkNode;
treeView.EndUpdate();
}
private IEnumerator Communicating()
{
Task.Run(() => {
while (m_bCommunicating)
{
byte[] cResponseBuffer = m_cUdpClient.Receive(ref m_cServer);
if (cResponseBuffer != null)
{
NetworkContainer cMessage = NetworkManager.Instance.fromBytes(cResponseBuffer);
if (cMessage.Command == "ADD_CHAT_LOG")
{
LogicManager.Instance.ServerLobbyLogic.AddMessage(cMessage.Message);
}
}
}
});
yield return(new WaitForEndOfFrame());
}
public void ConnectToServer(string sIP)
{
m_cServer = new IPEndPoint(IPAddress.Parse(sIP), m_nPort);
/*
* StopClient();
*
* m_cUdpClient = new UdpClient();
* m_cUdpClient.Client.Bind(m_cServer);
*/
m_bCommunicating = true;
NetworkContainer cMessage = new NetworkContainer();
cMessage.Command = "JOIN_SERVER";
cMessage.Message = m_sUsername;
byte[] acData = NetworkManager.Instance.getBytes(cMessage);
m_cUdpClient.Send(acData, acData.Length, m_cServer);
StartCoroutine(Communicating());
}
static void Main(string[] args)
{
// Main program.
// A Network container is used to control and hold a network
NetworkContainer container = new NetworkContainer
{
verbose = true
};
// Used to declare settings for a particular network
CountNetworkTrainSettings trainSettings = new CountNetworkTrainSettings
{
correctInputDirectory = @"./Data_Correct",
incorrectInputDirectory = @"./Data_Incorrect",
outputDirectory = @"./Data_Out",
outputName = "DemoNetwork",
sampleCount = 20
};
CountNetworkTrainController.PrepareData(ref container, ref trainSettings);
CountNetworkTrainController.PrepareNetwork(ref container, ref trainSettings);
CountNetworkTrainController.Train(ref container, ref trainSettings);
CountNetworkPredictSettings predictSettings = new CountNetworkPredictSettings
{
trainedNetwork = @"./Data_Out/DemoNetwork.eg",
predictData = @"./Data_Predict/good.csv",
sampleCount = 20,
predictSettings = new EncogPredictSettings
{
threshold = 0.92
}
};
CountNetworkPredictController.PreparePredictor(ref container, ref predictSettings);
Console.WriteLine("The given file is: " + CountNetworkPredictController.Predict(ref container, ref predictSettings));
}
private TreeNode createNode(NetworkContainer container)
{
TreeNode node = new TreeNode("Network");
node.Tag = container;
return node;
}
//----------------------------------------
#region Constructor
public NetworkInspectorDialog(NetworkContainer networkContainer)
{
this.m_networkContainer = networkContainer;
InitializeComponent();
}
public NetworkInspectorDialog(NetworkContainer networkContainer)
{
this.m_networkContainer = networkContainer;
InitializeComponent();
}
private void populateTreeView(NetworkContainer networkContainer)
{
treeView.BeginUpdate();
treeView.Nodes.Clear();
TreeNode networkNode;
TreeNode[] layerNodes;
TreeNode[] neuronNodes;
TreeNode[] weightNodes;
layerNodes = new TreeNode[networkContainer.ActivationNetwork.LayersCount];
for (int i = 0; i < networkContainer.ActivationNetwork.LayersCount; ++i)
{
neuronNodes = new TreeNode[networkContainer.ActivationNetwork[i].NeuronsCount];
for (int j = 0; j < networkContainer.ActivationNetwork[i].NeuronsCount; ++j)
{
weightNodes = new TreeNode[networkContainer.ActivationNetwork[i][j].InputsCount];
for (int k = 0; k < networkContainer.ActivationNetwork[i][j].InputsCount; ++k)
{
weightNodes[k] = new TreeNode(String.Format("[{0}]: {1}", k + 1,
networkContainer.ActivationNetwork[i][j][k]), 3, 3);
weightNodes[k].Tag = networkContainer.ActivationNetwork[i][j];
weightNodes[k].ForeColor = Color.Gray;
}
neuronNodes[j] = new TreeNode(String.Format("Neuron {0}", j + 1), 2, 2,
weightNodes);
neuronNodes[j].Tag = networkContainer.ActivationNetwork[i][j];
}
layerNodes[i] = new TreeNode(String.Format("Layer {0}", i + 1), 1, 1,
neuronNodes);
layerNodes[i].Tag = networkContainer.ActivationNetwork[i];
}
networkNode = new TreeNode(networkContainer.Name, 0, 0, layerNodes);
networkNode.Tag = networkContainer;
treeView.Nodes.Add(networkNode);
treeView.SelectedNode = networkNode;
treeView.EndUpdate();
}
// Use this for initialization
void Start()
{
networkContainer = FindObjectOfType <NetworkContainer>();
//Recherche si un slot est libre dans la partie
if (isDirectSpawn)
{
if (isLocalPlayer && !isServer)
{
if (!networkContainer.playerTwo)
{
SetupPlayer(1);
}
else if (!networkContainer.playerThree)
{
SetupPlayer(2);
}
else if (!networkContainer.playerFour)
{
SetupPlayer(3);
}
else if (!networkContainer.playerFive)
{
SetupPlayer(4);
}
else
{
Debug.LogError("Too much player");
Destroy(gameObject);
}
}
}
else
{
if (isLocalPlayer)
{
playerSlot = FindObjectOfType <PlayerNumber>().playerSlotNumber;
Debug.Log("playerSlot : " + playerSlot);
SetupPlayer(playerSlot);
}
}
if (playerSlot == 0 && isLocalPlayer && isServer && isDirectSpawn)
{
PlayerGirl = true;
SetupPlayer(0);
}
rigid = GetComponent <Rigidbody2D>();
board = FindObjectOfType <BoardCreator>();
Grid = board.Grid;
Sprite = GetComponent <SpriteRenderer>();
AssignBegingingNode();
if (isLocalPlayer && isServer)
{
StartCoroutine(ShearchTracker());
}
}
public NetworkContainer CreateNetworkContainer()
{
NetworkContainer neuralNetwork = null;
int[] hiddenLayers = new int[cbHiddenLayerNumber.SelectedIndex];
switch (hiddenLayers.Length)
{
case 0:
break;
case 1:
hiddenLayers[0] = (int)this.nHidden1.Value;
break;
case 2:
hiddenLayers[1] = (int)this.nHidden2.Value;
goto case 1;
case 3:
hiddenLayers[2] = (int)this.nHidden3.Value;
goto case 2;
case 4:
hiddenLayers[3] = (int)this.nHidden4.Value;
goto case 3;
default:
break;
}
IActivationFunction activationFunction = null;
if (this.rbBipolarSigmoid.Checked)
{
activationFunction = new BipolarSigmoidFunction((double)numSigmoidAlpha.Value);
}
else if (this.rbSigmoid.Checked)
{
activationFunction = new SigmoidFunction((double)numSigmoidAlpha.Value);
}
else if (this.rbThreshold.Checked)
{
activationFunction = new ThresholdFunction();
}
neuralNetwork = new NetworkContainer(
tbNetworkName.Text,
m_networkSchema,
activationFunction,
hiddenLayers);
// neuralNetwork.Schema.DataRanges.ActivationFunctionRange = new AForge.DoubleRange((double)numRangeLow.Value, (double)numRangeHigh.Value);
return neuralNetwork;
}
