/// <summary>
/// Uniform Random Matrix
/// </summary>
/// <param name="rows"></param>
/// <param name="cols"></param>
/// <returns></returns>
public static RealMatrix UniformRandromMatrix(int rows, int cols)
{
var matrix = new RealMatrix(rows, cols);
Parallel.For(0, rows, i => Parallel.For(0, cols, j =>
{
matrix[i, j] = GetRandomDouble();
}));
return matrix;
}
public RBM(int numVisible, int numHidden, double learningRate = 0.1)
{
m_numHiddenElements = numHidden;
m_numVisibleElements = numVisible;
m_learningRate = learningRate;
m_weights = 0.1*Distributions.GaussianMatrix(numVisible, numHidden);
m_weights = m_weights.InsertRow(0);
m_weights = m_weights.InsertCol(0);
}
public static RealVector getColumn(int column, RealMatrix m)
{
RealVector v = new RealVector(m.Count());
int i = 0;
foreach (List<double> vecM in m)
{
v[i] = vecM[column];
i++;
}
return v;
}
private static readonly Random Random = new Random(); //reuse this if you are generating many non time dependant numbers
#endregion Fields
#region Methods
/// <summary>
/// Random Gaussian Matrix
/// </summary>
/// <param name="rows"></param>
/// <param name="cols"></param>
/// <returns></returns>
public static RealMatrix GaussianMatrix(int rows, int cols)
{
var matrix = new RealMatrix(rows, cols);
Parallel.For(0, rows, i => Parallel.For(0, cols, j =>
{
matrix[i, j] = GaussianNormal();
}));
return matrix;
}
// public bool getTyp() { return getFunkcjaCelu().getTypFunkcji(); }
public RealMatrix getMtx()
{
RealMatrix temp = new RealMatrix();
foreach(Funkcja e in ograniczenia){
RealVector t = new RealVector();
for (int i = 0; i <e.getWspZmiennych().Count; i++) {
t.Add(double.Parse(e.getWspZmiennych()[i]));
}
temp.Add(t);
}
return temp;
}
public void setMacierz(RealMatrix m)
{
Wektor temp= new Wektor(Start, Wektor.Type.Horizontal);
temp.setElementy(m[0]);
Mtx.Add(temp);
for (int i = 1; i < m.Count; i++)
{
temp = new Wektor(Mtx.Last().pobierzPozycjeNastDol(),
Wektor.Type.Horizontal,m[i]);
Mtx.Add(temp);
}
}
/// <summary>
/// Apply a logistic function on all elements of a matrix
/// </summary>
/// <param name="matrix">Matrix</param>
/// <returns>Logistic matrix</returns>
public static RealMatrix Logistic(RealMatrix matrix)
{
var result = new RealMatrix(matrix.Height, matrix.Width);
for (int i = 0; i < matrix.Height; i++)
{
for (int j = 0; j < matrix.Width; j++)
{
result[i, j] = Logistic(matrix[i, j]);
}
}
return result;
}
public override void inicjalizacja(
RealVector wekC, List<String> wekCNazwy, List<String> bazaNaz, RealVector bazaWart,
RealMatrix m, RealVector prawaStr)
{
tab = new tabela.Tabela();
tab.setWielkoscIInit(wekC.Count,
bazaWart.Count);
tab.updateWektorC(wekC);
tab.updateWektorNazwC(wekCNazwy);
tab.updateWektorBazaNazwy(bazaNaz);
tab.updateWektorBazaWart(bazaWart);
tab.updateMtx(m);
tab.updatePrawaStronaWart(prawaStr);
}
public void odswiez(RealMatrix m)
{
int i = 0, j = 0;
foreach (Wektor vec in Mtx)
{
i = 0;
foreach (PodstElem e in vec.getElementy())
{
e.setTekst(m[j][i].ToString("0.00"));
i++;
}
j++;
}
}
bool typZadania; // 0 -max, 1-min
#endregion Fields
#region Constructors
public Algorytm(RealVector wekC,List<String> wekCNazwy, List<String> bazaNaz,RealVector bazaWart,
RealMatrix m,RealVector prawaStr,bool typ )
{
WektorC = wekC;
WektorNazwC = wekCNazwy;
BazaNazwy = bazaNaz;
BazaWartosci = bazaWart;
mtx = m;
prawaStrona = prawaStr;
typZadania = typ;
Z = new RealVector(WektorC.Count);
Zc = new RealVector(WektorC.Count);
obserw = new List<Obserwator>();
nrIteracji = 0;
nrKroku = 0;
}
/// <summary>
/// Get the hidden layer features from a visible layer
/// </summary>
/// <param name="dataArray"></param>
/// <returns></returns>
public double[][] GetHiddenLayer(double[][] dataArray)
{
var num_examples = dataArray.Length;
// Create a matrix, where each row is to be the hidden units (plus a bias unit)
// sampled from a training example.
var hidden_states = RealMatrix.Ones(num_examples, m_numHiddenElements + 1);
var data = new RealMatrix(dataArray);
// Insert bias units of 1 into the first column of data.
data = data.InsertCol(1); // np.insert(data, 0, 1, axis = 1)
// Calculate the activations of the hidden units.
var hiddenActivations = data * m_weights;
// Calculate the probabilities of turning the hidden units on.
var hiddenProbs = ActivationFunctions.Logistic(hiddenActivations);
// Turn the hidden units on with their specified probabilities.
hidden_states = hiddenProbs > Distributions.UniformRandromMatrix(num_examples, m_numHiddenElements + 1);
// Ignore the bias units.
hidden_states = hidden_states.RemoveFirstCol(); // hidden_states[:,1:]
return hidden_states;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Interface Methods
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static Pi_Class1.Plane getPlaneParams(List<Point3D> pointsOfPlane)
{
/*int a = 1;
int b = 2;
int c = -3;
int d = 1;
pointsOfPlane = new List<Point3D>();
for (int x = 0; x < 4; x++)
{
for (int y = 0; y < 4; y++)
{
var newPoint = new Point3D(x, y, -(x*a + y*b + d)/c);
pointsOfPlane.Add(newPoint);
}
}*/
var result = new Pi_Class1.Plane();
var initMatrix = new double[pointsOfPlane.Count(),4];
for (int j = 0; j < pointsOfPlane.Count(); j++)
{
for (int i = 0; i < 4; i++)
{
if (i == 0)
{
initMatrix[j, i] = pointsOfPlane[j].x;
}
else if (i == 1)
{
initMatrix[j, i] = pointsOfPlane[j].y;
}
else if (i == 2)
{
initMatrix[j, i] = pointsOfPlane[j].z;
}
else if (i == 3)
{
initMatrix[j, i] = 1;
}
}
}
var initialMatrix = new RealMatrix(initMatrix);
var transposedMatrix = initialMatrix.GetTransposedMatrix();
var multMatrix = transposedMatrix*initialMatrix;
double deter = multMatrix.GetDeterminant();
//RealMatrix conjMatrix = multMatrix.GetAlgebraicalComplement()
var complementData = new double[4,4];
for (int j = 0; j < 4; j++)
{
for (int i = 0; i < 4; i++)
{
complementData[j, i] = multMatrix.GetAlgebraicalComplement(j, i);
}
}
var complementMatrix = new RealMatrix(complementData);
RealMatrix transposedMatrix2 = complementMatrix.GetTransposedMatrix();
RealMatrix obrMatrix = transposedMatrix2*(1.0/deter);
var onesVector = new double[4,1];
onesVector[0, 0] = 1;
onesVector[1, 0] = 1;
onesVector[2, 0] = 1;
onesVector[3, 0] = 1;
var onesMatrix = new RealMatrix(onesVector);
RealMatrix resultMatrix = obrMatrix*onesMatrix;
double[,] resultData = resultMatrix.GetDataArray();
result.a = resultData[0, 0];
result.b = resultData[1, 0];
result.c = resultData[2, 0];
result.d = resultData[3, 0];
result.a = result.a/result.d;
result.b = result.b / result.d;
result.c = result.c / result.d;
result.d = result.d / result.d;
/*List<Point3D> pointsOfPlane2 = new List<Point3D>();
for (double x = 0; x < 4; x++)
{
for (double y = 0; y < 4; y++)
{
var newPoint = new Point3D((int) x, (int) y, (int) ((x * result.a + y * result.b + result.d) / result.c));
pointsOfPlane2.Add(newPoint);
}
}*/
return result;
}
public Macierz(Point s,RealMatrix matrix)
{
Mtx = new List<Wektor>();
Start = s;
setMacierz(matrix);
}
public void updateMtx(RealMatrix m)
{
mtx.odswiez(m);
}
public override void updateStep7(RealVector pStrona, RealMatrix mtx)
{
tab.updatePrawaStronaWart(pStrona);
tab.updateMtx(mtx);
}
internal static HandleRef getCPtr(RealMatrix obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
public virtual void inicjalizacja(RealVector wekC, List<String> wekCNazwy, List<String> bazaNaz, RealVector bazaWart,
RealMatrix m, RealVector prawaStr)
{
}
public virtual void updateStep7(RealVector pStrona, RealMatrix mtx)
{
}
/// <summary>
/// Get the visible layer from a hidden layer
/// </summary>
/// <param name="dataArray"></param>
/// <returns></returns>
public double[][] GetVisibleLayer(double[][] dataArray)
{
var numExamples = dataArray.Length;
// Create a matrix, where each row is to be the visible units (plus a bias unit)
// sampled from a training example.
var data = new RealMatrix(dataArray);
// Insert bias units of 1 into the first column of data.
data = data.InsertCol(1);
// Calculate the activations of the visible units.
var visibleActivations = data * m_weights.Transpose;
// Calculate the probabilities of turning the visible units on.
var visibleProbs = ActivationFunctions.Logistic(visibleActivations);
// Turn the visible units on with their specified probabilities.
var visibleStates = visibleProbs > Distributions.UniformRandromMatrix(numExamples, m_numVisibleElements + 1);
// Ignore the bias units.
visibleStates = visibleStates.RemoveFirstCol(); //visible_states[:,1:]
return visibleStates;
}
public RealMatrix(RealMatrix orig) : this(modshogunPINVOKE.new_RealMatrix__SWIG_5(RealMatrix.getCPtr(orig)), true) {
if (modshogunPINVOKE.SWIGPendingException.Pending) throw modshogunPINVOKE.SWIGPendingException.Retrieve();
}
public void Train(double[][] dataArray, int maxEpochs, out double error)
{
error = 0;
var numExamples = dataArray.Length;
var data = new RealMatrix(dataArray);
data = data.InsertCol(1);
Stopwatch sw = new Stopwatch();
for (int i = 0; i < maxEpochs; i++)
{
sw.Start();
var posHiddenActivations = data * m_weights;
var posHiddenProbs = ActivationFunctions.Logistic(posHiddenActivations);
var posHiddenStates = posHiddenProbs > Distributions.UniformRandromMatrix(numExamples, m_numHiddenElements + 1);
var posAssociations = data.Transpose * posHiddenProbs;
var negVisibleActivations = posHiddenStates * m_weights.Transpose;
var negVisibleProbs = ActivationFunctions.Logistic(negVisibleActivations);
negVisibleProbs = negVisibleProbs.Update(0, 1, 1);
var negHiddenActivations = negVisibleProbs * m_weights;
var negHiddenProbs = ActivationFunctions.Logistic(negHiddenActivations);
var negAssociations = negVisibleProbs.Transpose * negHiddenProbs;
m_weights = m_weights + (m_learningRate * ((posAssociations - negAssociations) / numExamples));
sw.Stop();
error = ((data - negVisibleProbs) ^ 2).Sum();
RaiseEpochEnd(i, error);
Console.WriteLine("Epoch {0}: error is {1}, computation time (ms): {2}", i, error,sw.ElapsedMilliseconds);
sw.Reset();
}
RaiseTrainEnd(maxEpochs, error);
}
