コード例 #1
0
        public override Dictionary <int, Vector <double> > Assemble()
        {
            Dictionary <int, Vector <double> > globalLoadVectors = new Dictionary <int, Vector <double> >();

            foreach (var loadCase in this.dbctx.LoadCases)
            {
                int             vectorDimension = this.dbctx.Nodes.Count * 6;
                Vector <double> globalVector    = SparseVector.Create(vectorDimension, 0.0);

                foreach (var node in this.dbctx.Nodes)
                {
                    foreach (var load in node.Loads)
                    {
                        if (load.LoadCase.Number == loadCase.Number)
                        {
                            Vector <double> generatedLoad = load.GenerateLoad();

                            globalVector[6 * node.Number + 0] += generatedLoad[0];
                            globalVector[6 * node.Number + 1] += generatedLoad[1];
                            globalVector[6 * node.Number + 2] += generatedLoad[2];
                            globalVector[6 * node.Number + 3] += generatedLoad[3];
                            globalVector[6 * node.Number + 4] += generatedLoad[4];
                            globalVector[6 * node.Number + 5] += generatedLoad[5];
                        }
                    }
                }

                globalLoadVectors.Add(loadCase.Number, globalVector);
            }

            return(globalLoadVectors);
        }
コード例 #2
0
        } //Получение J для оценки правильности обучения

        private List <SparseMatrix> getDerivatives(SparseMatrix Y, SparseMatrix X, List <List <SparseVector> > activations)
        {
            List <Vector <double> > delta = new List <Vector <double> >();
            List <SparseMatrix>     D     = new List <SparseMatrix>();

            for (int i = 0; i < _layers.Count; i++)
            {
                D.Add(SparseMatrix.Create(_layers[i].Weights.RowCount, _layers[i].Weights.ColumnCount, 0));
            }
            for (int k = 0; k < m; k++)
            {
                delta = new List <Vector <double> >();
                for (int i = 0; i < _layers.Count; i++)
                {
                    delta.Add(new SparseVector(_layers[i].Activations.Count));
                }
                for (int i = delta.Count - 1; i >= 0; i--)
                {
                    if (i == delta.Count - 1)
                    {
                        for (int j = 0; j < activations[k][i].Count; j++)
                        {
                            delta[delta.Count - 1][j] = (activations[k][i][j] - Y.Row(k)[j]);
                        }
                    }
                    else
                    {
                        delta[i] = _layers[i + 1].Weights.Transpose().Multiply((delta[i + 1]));
                        delta[i] = SparseVector.OfVector(multiplayOnSigmoidGradient(delta[i], activations[k][i]));
                        D[i + 1] = D[i + 1] + (SparseMatrix)(delta[i + 1].OuterProduct(activations[k][i]));
                    }
                    if (i == 0)
                    {
                        Vector <double> tempVector = SparseVector.Create(X.Row(k).Count, 1);
                        if (tempVector.Count != D[i].ColumnCount)
                        {
                            SparseVector tmp = SparseVector.Create(D[i].ColumnCount, 1);
                            for (int j = 1; j < tmp.Count; j++)
                            {
                                tmp[j] = X.Row(k)[j - 1];
                            }
                            tempVector = tmp;
                        }
                        Matrix <double> tempMatrix = delta[i].OuterProduct(tempVector);
                        D[i] = D[i] + (SparseMatrix)(tempMatrix);
                    }
                }
            }
            List <SparseMatrix> derivatives = new List <SparseMatrix>();

            for (int i = 0; i < D.Count; i++)
            {
                derivatives.Add(D[i] * (1f / m));
            }
            return(derivatives);
        } //Получение частных производных
コード例 #3
0
        public static void Main(String[] args)
        {
            Stopwatch st = new Stopwatch();

            st.Start();

            // generate tensor
            int    n     = 100;
            int    m     = 100;
            int    k     = 100;
            int    elems = 10000;
            Tensor a     = new Tensor(n, m, k, elems, 1000);

            Console.WriteLine("Tensor generated");
            Tensor aOld = a.Clone();

            Console.WriteLine("Cloned");

            // slice tensor by one dimension and concat received matricies consequently.
            for (int i = 1; i <= f; i++)
            {
                a.calcSlices();
                Console.WriteLine("Slices calculated");
                Solver.solve(
                    a,
                    a.sliceN,       // n x (m*k)
                    a.sliceM,       // m x (n*k)
                    a.sliceK,       // k x (n*m)
                    steps,
                    SparseVector.Create(a.n, 1),
                    SparseVector.Create(a.m, 1),
                    SparseVector.Create(a.k, 1),
                    i);
            }

            double av = 0;

            for (int i = 0; i < aOld.k; ++i)
            {
                var els = aOld.a[i].EnumerateIndexed(Zeros.AllowSkip);
                foreach (var elem in els)
                {
                    av += Math.Abs(elem.Item3 - Solver.getAns(elem.Item1, elem.Item2, i));
                }
            }
            Console.WriteLine("|| Diff || = " + (av / (a.n * a.m * a.k)));

            st.Stop();
            Console.WriteLine(st.ElapsedMilliseconds / 1000.0);
        }
コード例 #4
0
        public override Dictionary <int, Vector <double> > Assemble()
        {
            Dictionary <int, Vector <double> > globalLoadVectors = new Dictionary <int, Vector <double> >();

            foreach (var loadCase in this.dbctx.LoadCases)
            {
                int             vectorDimension = this.dbctx.Nodes.Count * 6;
                Vector <double> globalVector    = SparseVector.Create(vectorDimension, 0.0);

                foreach (var frameElement in this.dbctx.FrameElements)
                {
                    foreach (var load in frameElement.Loads)
                    {
                        if (load.LoadCase.Number == loadCase.Number)
                        {
                            Vector <double> globalLoadVector = frameElement.TransformationMatrix.Transpose() * frameElement.GeneratedLocalLoadVectors[load.LoadCase.Number];

                            double constant = Math.Pow(10.0, -10.0);
                            for (int i = 0; i < globalLoadVector.Count; i++)
                            {
                                globalLoadVector[i] = Math.Round(globalLoadVector[i], 5);
                            }

                            globalVector[6 * frameElement.Node1.Number + 0] += globalLoadVector[0];
                            globalVector[6 * frameElement.Node1.Number + 1] += globalLoadVector[1];
                            globalVector[6 * frameElement.Node1.Number + 2] += globalLoadVector[2];
                            globalVector[6 * frameElement.Node1.Number + 3] += globalLoadVector[3];
                            globalVector[6 * frameElement.Node1.Number + 4] += globalLoadVector[4];
                            globalVector[6 * frameElement.Node1.Number + 5] += globalLoadVector[5];

                            globalVector[6 * frameElement.Node2.Number + 0] += globalLoadVector[6];
                            globalVector[6 * frameElement.Node2.Number + 1] += globalLoadVector[7];
                            globalVector[6 * frameElement.Node2.Number + 2] += globalLoadVector[8];
                            globalVector[6 * frameElement.Node2.Number + 3] += globalLoadVector[9];
                            globalVector[6 * frameElement.Node2.Number + 4] += globalLoadVector[10];
                            globalVector[6 * frameElement.Node2.Number + 5] += globalLoadVector[11];
                        }
                    }
                }

                globalLoadVectors.Add(loadCase.Number, globalVector);
            }

            return(globalLoadVectors);
        }
コード例 #5
0
        public static LPSTerm[] IdentityMatrix(int howmany)
        {
            //Matrix<double> coeffs = DenseMatrix.CreateIdentity(howmany);
            //Vector<double> interc = DenseVector.Create(howmany, 0.0);

            // return new LPSTerm[](coeffs, interc);

            LPSTerm[] terms = new LPSTerm[howmany];
            int       pos   = 0;

            for (int i = 0; i < howmany; i++)
            {
                Vector <double> coeffs = SparseVector.Create(howmany, 0.0);
                coeffs[pos++] = 1.0;
                terms[i]      = new LPSTerm(coeffs, 0.0);
            }
            return(terms);
        }
コード例 #6
0
 private List <float> forward(SparseVector input)
 {
     Layer[] tempLayers = new Layer[_layers.Count];
     _layers.CopyTo(tempLayers);
     for (int i = 0; i < tempLayers.Length; i++)
     {
         if (i == 0)
         {
             if (input.Count != tempLayers[i].Weights.ColumnCount)
             {
                 SparseVector tmp = SparseVector.Create(tempLayers[i].Weights.ColumnCount, 1);
                 for (int j = 1; j < tmp.Count; j++)
                 {
                     tmp[j] = input[j - 1];
                 }
                 input = tmp;
             }
             tempLayers[i].Activations = SparseVector.OfVector((tempLayers[i].Weights * input));
         }
         else
         {
             if (tempLayers[i].Weights.ColumnCount != tempLayers[i - 1].Activations.Count)
             {
                 SparseVector tmp = SparseVector.Create(tempLayers[i].Weights.ColumnCount, 1);
                 for (int j = 1; j < tmp.Count; j++)
                 {
                     tmp[j] = tempLayers[i - 1].Activations[j - 1];
                 }
                 tempLayers[i - 1].Activations = tmp;
             }
             else
             {
                 tempLayers[i - 1].Activations[0] = 1;
             }
             tempLayers[i].Activations = SparseVector.OfVector((tempLayers[i].Weights * tempLayers[i - 1].Activations));
         }
         tempLayers[i].Activations = parallelSigmoid(tempLayers[i].Activations);
     }
     return(_layers.Last().Activations.ToList());
 }
コード例 #7
0
 public void ForwardPropagation()
 {
     for (int i = 0; i < _layers.Count; i++)
     {
         if (i == 0)
         {
             if (Inputs.Count != _layers[i].Weights.ColumnCount)
             {
                 SparseVector tmp = SparseVector.Create(_layers[i].Weights.ColumnCount, 1);
                 for (int j = 1; j < tmp.Count; j++)
                 {
                     tmp[j] = Inputs[j - 1];
                 }
                 Inputs = tmp;
             }
             _layers[i].Activations = SparseVector.OfVector((_layers[i].Weights * Inputs));
         }
         else
         {
             if (_layers[i].Weights.ColumnCount != _layers[i - 1].Activations.Count)
             {
                 SparseVector tmp = SparseVector.Create(_layers[i].Weights.ColumnCount, 1);
                 for (int j = 1; j < tmp.Count; j++)
                 {
                     tmp[j] = _layers[i - 1].Activations[j - 1];
                 }
                 _layers[i - 1].Activations = tmp;
             }
             else
             {
                 _layers[i - 1].Activations[0] = 1;
             }
             _layers[i].Activations = SparseVector.OfVector((_layers[i].Weights * _layers[i - 1].Activations));
         }
         sigmoid(ref _layers[i].Activations);
     }
 } //Прохождение вперёд
コード例 #8
0
 public Vector <double> CreateVector(int capacity)
 {
     return(SparseVector.Create(capacity, 0.0));
 }
コード例 #9
0
 private LPSTerm()
 {
     coefficients_ = SparseVector.Create(vcinfo_.total_varcount_, 0.0);
     intercept_    = 0.0;
 }
コード例 #10
0
 public VCInfo(int total_varcount)
 {
     total_varcount_ = total_varcount;
     tempmultstorage = new ThreadLocal <Vector <double> >(() => SparseVector.Create(total_varcount, 0.0));
 }