public void SetUp()
{
networkMock = new Mock <INetwork>();
layerMock = new Mock <ILayer>();
layerMock.SetupGet(m => m.NumInputs).Returns(NumInputs);
neuron = new NeuronStub(layerMock.Object, 0);
}
public void ShouldCrudNeuron()
{
IConfigurationRoot configuration = GetConfiguration();
using (UnitOfWork unitOfWork = new UnitOfWork(configuration))
{
NeuronBase insertedNeuron = null;
NetworkBase network = null;
try
{
network = new NetworkBase()
{
Name = "Test network"
};
var networkId = unitOfWork.NetworkRepository.Insert(network);
network = unitOfWork.NetworkRepository.GetByID(networkId);
// Create
var neuron = new NeuronBase()
{
NetworkId = network.NetworkId,
NeuronNumber = 2
};
var id = unitOfWork.NeuronRepository.Insert(neuron);
Assert.IsTrue(id > 0);
// Read
insertedNeuron = unitOfWork.NeuronRepository.GetByID(id);
Assert.IsNotNull(insertedNeuron);
Assert.AreEqual(id, insertedNeuron.NeuronId);
// Update
insertedNeuron.NeuronNumber = 3;
unitOfWork.NeuronRepository.Update(insertedNeuron);
insertedNeuron = unitOfWork.NeuronRepository.GetByID(id);
Assert.IsNotNull(insertedNeuron);
Assert.AreEqual(id, insertedNeuron.NeuronId);
Assert.AreEqual(3, insertedNeuron.NeuronNumber);
// Delete
unitOfWork.NeuronRepository.Delete(insertedNeuron);
insertedNeuron = unitOfWork.NeuronRepository.GetByID(id);
Assert.IsNull(insertedNeuron);
}
finally
{
if (insertedNeuron != null)
{
unitOfWork.NeuronRepository.Delete(insertedNeuron);
}
if (network != null)
{
unitOfWork.NetworkRepository.Delete(network);
}
}
}
}
/// <summary>
/// Найти евклидово расстояние от входного вектора до центра кластера.
/// </summary>
/// <param name="neuron">Нейрон.</param>
/// <param name="inputVector">Входной вектор.</param>
/// <returns>Евклидово расстояние от входного вектора до центра кластера.</returns>
public double GetEuclideanDistance(NeuronBase neuron, IEnumerable <InputAttributeValue> inputVector)
{
double distance = 0;
var neuronWeights = Weights
.Where(e => e.NeuronNumber == neuron.NeuronNumber);
foreach (var input in inputVector)
{
var neuronWeight = neuronWeights
.FirstOrDefault(e => e.InputAttributeNumber == input.InputAttributeNumber);
distance += Math.Pow(neuronWeight.Value - input.Value, 2);
}
return(Math.Sqrt(distance));
}
/// <summary>
/// Получить нейрон-победитель.
/// </summary>
/// <param name="inputEntity">Входной вектор.</param>
/// <returns>Нейрон-победитель для входного вектора.</returns>
public override NeuronBase GetNeuronWinner(IEnumerable <InputAttributeValue> attributeValues)
{
double minDistance = GetEuclideanDistance(Neurons[0], attributeValues);
NeuronBase neuronWinner = Neurons[0];
for (int i = 1; i < Neurons.Count; i++)
{
double currentDistance = GetEuclideanDistance(Neurons[i], attributeValues);
if (currentDistance < minDistance)
{
minDistance = currentDistance;
neuronWinner = Neurons[i];
}
}
return(neuronWinner);
}
/// <summary>
/// Найти евклидово расстояние между 2 нейронами.
/// </summary>
/// <param name="neuron1">Первый нейрон.</param>
/// <param name="neuron2">Второй нейрон.</param>
/// <returns>Евклидово расстояние между 2 нейронами.</returns>
public double GetEuclideanDistance(NeuronBase neuron1, NeuronBase neuron2)
{
double distance = 0;
var firstNeuronWeights = Weights
.Where(e => e.NeuronNumber == neuron1.NeuronNumber);
var secondNeuronWeights = Weights
.Where(e => e.NeuronNumber == neuron2.NeuronNumber);
foreach (var firstNeuronWeight in firstNeuronWeights)
{
var secondNeuronWeight = secondNeuronWeights
.FirstOrDefault(e => e.InputAttributeNumber == firstNeuronWeight.InputAttributeNumber);
distance += Math.Pow(firstNeuronWeight.Value - secondNeuronWeight.Value, 2);
}
return(Math.Sqrt(distance));
}
void CheckConnection(Link pre, NeuronBase post, ref int i)
{
var bridge = from a in pre.Next join b in post.Previous on a equals b select a;
Assert.AreEqual(bridge.Count(), 1);
Connection inp = bridge.First();
Assert.AreEqual(inp.Previous, pre);
Assert.AreEqual(inp.Next, post);
i++;
if (post.Next != null)
{
foreach (var n in post.Next)
{
var pp = n.Next;
CheckConnection(post, pp, ref i);
}
}
}
HashSet <Connection> GetConnections(Link[] network, bool next, bool previous)
{
HashSet <Connection> hs = new HashSet <Connection>();
foreach (Link link in network)
{
if (next && link.Next != null)
{
foreach (Connection c in link.Next)
{
hs.Add(c);
}
}
if (previous && link is NeuronBase)
{
NeuronBase nb = (NeuronBase)link;
foreach (Connection c in nb.Previous)
{
hs.Add(c);
}
}
}
return(hs);
}
/// <summary>
/// Удалить существующий экземпляр сущности.
/// </summary>
/// <param name="item">Модель экземпляра сущности.</param>
public void Delete(NeuronBase item)
{
_dataContext.Connection.Delete(item, _dataContext.Transaction);
}
/// <summary>
/// Вставить новый экземпляр сущности.
/// </summary>
/// <param name="item">Модель нового экземпляра сущности.</param>
/// <returns>Идентификатор нового экземпляра сущности.</returns>
public int Insert(NeuronBase item)
{
return((int)_dataContext.Connection.Insert(item, _dataContext.Transaction));
}
public void TearDown()
{
networkMock = null;
layerMock = null;
neuron = null;
}
public virtual double TrainNetwork(TrainingTemplate trainingTemplate, NeuronBase neuron, int maxGenerations)
{
throw new NotImplementedException();
}
public void AppendNeuron(Guid id, NeuronBase neuron)
{
_neurons.Add(id, neuron);
//neuron.Select(v => v.ToString(CultureInfo.InvariantCulture)).Subscribe(_logAggregator);
neuron.Output = _rnd.NextDouble();
}
public NeuronData(NeuronBase neuron, NeuralNetworkData network = null)
{
Neuron = neuron;
Network = network;
}
