c#常规梯度下降及其优化

最新推荐文章于 2024-05-21 17:31:17 发布
最新推荐文章于 2024-05-21 17:31:17 发布
阅读量109 收藏
点赞数 1
文章标签： c# 开发语言 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JAYLEE900/article/details/132508103
版权 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;

namespace MulLinearRegression
{
    public class Perceptron
    {
        /// <summary>
        /// 梯度下降类型
        /// </summary>
        public enum DescType
        {
            BATCH_GRAD_DESC,//
            STOCH_GRAD_DESC,
            MINI_BATCH_GRAD_DESC,
            MOMENTUM_GRAD_DESC,
            ADAGRAD,
            RMSProp,
            ADAM,
        }
        public static int Sign(double x)
        {
            return x > 0 ? 1 : x == 0 ? 0 : -1;
        }

        /// <summary>
        /// 感知机
        /// </summary>
        /// <param name="DataSet"></param>
        /// <param name="Labels"></param>
        /// <param name="Params">
        /// [lr]={BGD,SGD}
        /// [lr,batchSize]={MBGD}
        /// [lr,beta(0.5,0.99)]={MOMENTUM}
        /// [lr,epsilon]={ADAGRAD}
        /// [beta1,beta2]={ADAM}
        /// </param>
        /// <param name="Iterations"></param>
        /// <param name="GDType"></param>
        /// <returns></returns>
        public static double[,] PerceptronModel(double[,] DataSet, double[,] Labels, double[] Params, 
            double Iterations = 1e4,DescType GDType=DescType.ADAM)
        {
            int p = DataSet.GetLength(1);
            int n = DataSet.GetLength(0);
            double[,] weights = new double[p, 1];
            double[,] v = new double[p, 1];//momentum->v;adagrad->s
            double[,] s = new double[p, 1];//adam
            int check = -1;
            int t = (int)Iterations;
            while(((GDType != DescType.STOCH_GRAD_DESC) ? check != 0 : true) && t>=0)
            {
                double[,] shuffled = Matrix.MatrixCombine(Labels, DataSet, false);
                Matrix.MatrixShuffle(shuffled, out shuffled);
                double[,] shedLabels = Matrix.SubMatrix(shuffled, 0);
                shuffled = Matrix.MatrixRemoveVector(shuffled, 0);
                check = 0;
                switch (GDType)
                {
                    case DescType.BATCH_GRAD_DESC:
                        {
                            for(int i = 0; i < n; i++)
                            {
                                double[,] cx = Matrix.SubMatrix(shuffled, i, RowGet: true);
                                double preY = Matrix.MultiplyMatrix(cx, weights)[0, 0];
                                double signY = Sign(preY);
                                if (-signY * shedLabels[i, 0] >= 0)
                                {
                                    check += 1;
                                    double[,] lossGrad = Matrix.MultiplyConst(cx, Params[0] * shedLabels[i, 0]);
                                    weights = Matrix.AddMatrix(weights, Matrix.Transpose(lossGrad));
                                }
                            }
                            break;
                        }
                    case DescType.STOCH_GRAD_DESC: 
                        {
                            int rID = new Random().Next(n);
                            double[,] cx = Matrix.SubMatrix(shuffled, rID, RowGet: true);
                            double preY = Matrix.MultiplyMatrix(cx, weights)[0, 0];
                            if (-preY * shedLabels[rID, 0] >= 0)
                            {
                                double[,] lossGrad = Matrix.MultiplyConst(cx, shedLabels[rID, 0] * Params[0]);
                                weights = Matrix.AddMatrix(weights, Matrix.Transpose(lossGrad));
                                break;
                            }
                            else
                            {
                                break;
                            }
                        }
                    case DescType.MINI_BATCH_GRAD_DESC:
                        {
                            int rID = new Random().Next(n - (int)Params[1]);
                            for(int i = rID; i < rID + Params[1]; i++)
                            {
                                double[,] cx = Matrix.SubMatrix(shuffled, i, RowGet: true);
                                double preY = Matrix.MultiplyMatrix(cx, weights)[0, 0];
                                if (-preY * shedLabels[i, 0] < 0) continue;
                                check += 1;
                                double[,] lossGrad = Matrix.MultiplyConst(cx, Params[0] * shedLabels[i, 0]);
                                weights = Matrix.AddMatrix(weights, Matrix.Transpose(lossGrad));
                            }
                            break;
                        }
                    case DescType.MOMENTUM_GRAD_DESC:
                        {
                            double lr = Params[0];
                            double beta = Params[1];
                            int rID = new Random().Next(n - (int)Params[2]);
                            for (int i = rID; i < rID + Params[2]; i++)
                            {
                                double[,] cx = Matrix.SubMatrix(shuffled, i, RowGet: true);
                                double preY = Matrix.MultiplyMatrix(cx, weights)[0, 0];
                                if (-preY * shedLabels[i, 0] < 0) continue;
                                check += 1;
                                double[,] lossGrad = Matrix.MultiplyConst(cx, shedLabels[i, 0]);
                                v = Matrix.MultiplyConst(v, beta);
                                lossGrad = Matrix.MultiplyConst(lossGrad, 1 - beta);
                                v = Matrix.MultiplyConst(Matrix.AddMatrix(v, Matrix.Transpose(lossGrad)),lr);
                                weights = Matrix.AddMatrix(weights, v);
                            }
                            break;
                        }
                    case DescType.ADAGRAD:
                        {
                            double lr = Params[0];
                            double epsilon = Params[1];
                            int rID = new Random().Next(n - (int)Params[2]);
                            for (int i = rID; i < rID + Params[2]; i++)
                            {
                                double[,] cx = Matrix.SubMatrix(shuffled, i, RowGet: true);
                                double preY = Matrix.MultiplyMatrix(cx, weights)[0, 0];
                                if (-preY * shedLabels[i, 0] < 0) continue;
                                check += 1;
                                double[,] lossGrad = Matrix.MultiplyConst(cx, shedLabels[i, 0]);//行向量
                                double[,] lossGradSqua = Matrix.HadamardProduct(lossGrad, lossGrad);
                                s = Matrix.AddMatrix(s, Matrix.Transpose(lossGradSqua));//列向量
                                double[,] temp = Matrix.AddMatrix(Matrix.MatrixElementSqrt(s),Matrix.VectorGenerate(p,epsilon,false));//列向量
                                temp = Matrix.MultiplyConst(Matrix.MatrixElementReciprocal(temp), lr);//列向量
                                double[,] back = Matrix.HadamardProduct(temp, Matrix.Transpose(lossGrad));//列向量
                                weights = Matrix.AddMatrix(weights, back);
                            }
                            break;
                        }
                    case DescType.RMSProp:
                        {
                            double lr = Params[0];
                            double beta = Params[1];
                            double epsilon = Params[2];
                            int rID = new Random().Next(n - (int)Params[3]);
                            for (int i = rID; i < rID + Params[3]; i++)
                            {
                                double[,] cx = Matrix.SubMatrix(shuffled, i, RowGet: true);
                                double preY = Matrix.MultiplyMatrix(cx, weights)[0, 0];
                                if (-preY * shedLabels[i, 0] < 0) continue;
                                check += 1;
                                double[,] lossGrad = Matrix.MultiplyConst(cx, shedLabels[i, 0]);//行向量
                                //列向量
                                double[,] lossGradSqua = Matrix.HadamardProduct(lossGrad,lossGrad);
                                s = Matrix.MultiplyConst(s, beta);//列向量
                                lossGradSqua = Matrix.MultiplyConst(lossGradSqua, 1 - beta);
                                s = Matrix.AddMatrix(s, Matrix.Transpose(lossGradSqua));
                                double[,] sSqrt = Matrix.MatrixElementSqrt(s);
                                sSqrt = Matrix.AddMatrix(sSqrt,Matrix.VectorGenerate(p,epsilon,RowVec:false));
                                sSqrt = Matrix.MatrixElementReciprocal(sSqrt);
                                sSqrt = Matrix.MultiplyConst(sSqrt, lr);
                                sSqrt = Matrix.HadamardProduct(sSqrt, Matrix.Transpose(lossGrad));
                                weights = Matrix.AddMatrix(weights, sSqrt);
                            }
                            break;
                        }
                    case DescType.ADAM:
                        {
                            double lr = Params[0];
                            double beta1 = Params[1];
                            double beta2 = Params[2];
                            double epsilon = Params[3];
                            int rID = new Random().Next(n - (int)Params[4]);
                            for (int i = rID; i < rID + Params[4]; i++)
                            {
                                double[,] cx = Matrix.SubMatrix(shuffled, i, RowGet: true);
                                double preY = Matrix.MultiplyMatrix(cx, weights)[0, 0];
                                if (-preY * shedLabels[i, 0] < 0) continue;
                                check += 1;
                                double[,] lossGrad = Matrix.MultiplyConst(cx, shedLabels[i, 0]);//行向量
                                //列向量
                                double[,] lossGradSqua = Matrix.Transpose(Matrix.HadamardProduct(lossGrad, lossGrad));


                                v = Matrix.MultiplyConst(v, beta1);
                                double[,] vback = Matrix.MultiplyConst(lossGrad, 1 - beta1);
                                v = Matrix.AddMatrix(v, Matrix.Transpose(vback));

                                s = Matrix.MultiplyConst(s, beta2);//列向量
                                lossGradSqua = Matrix.MultiplyConst(lossGradSqua, 1 - beta2);
                                s = Matrix.AddMatrix(s, lossGradSqua);
                                double[,] sSqrt = Matrix.MatrixElementSqrt(s);
                                sSqrt = Matrix.AddMatrix(sSqrt, Matrix.VectorGenerate(p, epsilon, RowVec: false));
                                sSqrt = Matrix.MatrixElementReciprocal(sSqrt);
                                sSqrt = Matrix.MultiplyConst(sSqrt, lr);
                                sSqrt = Matrix.HadamardProduct(sSqrt, v);
                                weights = Matrix.AddMatrix(weights, sSqrt);
                            }
                            break;
                        }
                }
                t -= 1;
            }
            double[,] fRes = new double[Labels.GetLength(0), Labels.GetLength(1)];
            string[] result = new string[fRes.Length];
            for(int i = 0; i < fRes.GetLength(0); i++)
            {
                double ps = Matrix.MultiplyMatrix(Matrix.SubMatrix(DataSet, i, RowGet: true), weights)[0, 0];
                fRes[i, 0] = Sign(ps);
                result[i]=($"check:{fRes[i, 0]}，Real:{Labels[i, 0]}");
            }
            return weights;
        }
    }
}
JAYLEE900
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
c语言 自适应模式算术编码,JPEG-LS图像编码算法分析和研究
weixin_35257663的博客
05-18 2137
JPEG-LS图像编码算法分析和研究JPEG-LS是在ISO/ITU的新标准中用于对静态连续色调图像进行无损或进无损压缩的一种算法。该算法具有实现复杂度低，保真度高等特点，因而广泛应用于数字相机、网络传输、无线通讯以及医学成像等领域。本文就JPEG-LS的核心算法LOCO-I以及其编码流程进行详细的分析和研究。1.简介无损压缩就是指经过压缩并重建后的图像和原图像完全一样，没有任何损失。如果重建图像...
c#实现梯度下降算法
06-13
c#实现梯度下降算法逻辑回归c#实现梯度下降算法逻辑回归c#实现梯度下降算法逻辑回归
深度模型优化性能 调参
热门推荐
心之所向
03-17 2万+
注意 调参看验证集。trainset loss通常能够一直降低，但validation set loss在经过一段降低期后会开始逐渐上升，此时模型开始在训练集上过拟合。 着重关注val loss变化，val acc可能会突变，但loss衡量的整体目标。 优先调参学习率。 通过对模型预测结果，可以判断模型的学习程度，如果softmax输出在0或1边缘说明还不错，如果在0.5边缘说明模型有待提高。 调参
最受欢迎的算法之一：反向传播训练
人邮异步社区
03-24 3646
反向传播是训练神经网络的最常用方法之一。Rumelhart、Hinton和Williams（1986）引入了反向传播，该方法到今天仍然很流行。程序员经常使用反向传播训练深层神经网络，因为在图形处理单元上运行时，它的伸缩性很好。要了解这种用于神经网络的算法，我们必须探讨如何训练它，以及它如何处理模式。 经典的反向传播已得到扩展和修改，产生了许多不同的训练算法。本章中将讨论神经网络最常用的训练算法。我们从经典的反向传播开始，然后以随机梯度下降结束本章。 6.1　理解梯度 反向传播是梯度下降的一种，许多教科
(转) 深度模型优化性能 调参
diezhai9068的博客
08-03 169
原地址：https://blog.csdn.net/qq_16234613/article/details/79596609 注意 调参看验证集。trainset loss通常能够一直降低，但validation set loss在经过一段降低期后会开始逐渐上升，此时模型开始在训练集上过拟合。 着重关注val loss变化，val acc可能会突变，但loss衡量的整体目标。 ...
###好好好好########深度模型优化性能 调参
木东的博客
11-15 743
注意     调参看验证集。trainset loss通常能够一直降低，但validation set loss在经过一段降低期后会开始逐渐上升，此时模型开始在训练集上过拟合。     着重关注val loss变化，val acc可能会突变，但loss衡量的整体目标，但是你的测试集是验证集的话还是看评判标准为佳。     优先调参学习率。     通过对模型预测结果，可以判断模型的学习程度，如果...
最全的机器学习资料
喜欢打酱油的老鸟
10-08 3227
原文 机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。机器学习牵涉的编程语言十分之广，包括了MATLAB、Julia、R、Perl、Python、Clojure、Ruby等等。 为了让开发者更加广...
机器学习中常见知识点总结
Yasin的博客
08-30 1万+
Adam 优化器 结合 AdaGrad 和 RMSProp 两种优化算法的优点。对梯度的一阶矩估计（First Moment Estimation，即梯度的均值）和二阶矩估计（Second Moment Estimation，即梯度的未中心化的方差）进行综合考虑，计算出更新步长。 二阶矩： 梯度平方累积和的平方根 （时间上）。此项能够累积各个参数 gt,i 的历史梯度平方，频繁更新的梯度，则累积的......
AI学习路线和书籍分享
weixin_30505043的博客
03-12 765
阶段一、人工智能基础 －　高等数学必知必会 本阶段主要从数据分析、概率论和线性代数及矩阵和凸优化这四大块讲解基础，旨在训练大家逻辑能力，分析能力。拥有良好的数学基础，有利于大家在后续课程的学习中更好的理解机器学习和深度学习的相关算法内容。同时对于AI研究尤为重要，例如人工智能中的智能很大一部分依托“概率论”实现的。 PDF下载地址https://pan.baidu.com/s/1s...
c# 一维优化下料 源码
06-07
c# 一维优化下料 源码
C#界面优化库
01-09
irisskin2.dll and irisskin4.dll换肤控件，内涵大量的 *.ssk 文件。
C#067梯度渐变
12-14
C#067梯度渐变
C# 创建线性梯度
04-23
C# 创建线性梯度C# 创建线性梯度C# 创建线性梯度C# 创建线性梯度
c#多态性的应用
m0_51648467的博客
05-14 277
继承和多态性是开发复杂软件的关键技术，特别适合于分层软 件系统。操作系统可以设计一个抽象基类，提供 Read()和 Write()两个抽象函数，各种硬件的驱动程序被编写为该抽象基类的 派生类，具体实现Read()和Write()操作。设计一个电脑游戏，游戏中有猪、牛、兔子、青蛙、鸭子等动物，这些动 物都继承于Vertebrata 类（脊椎动物类），Vertebrata类有一个抽象方法Display()，每个动 物都从Vertebrata 类那里继承并重写了Display()方法，用来把动物本身画在屏幕上。
C#上位机1ms级高精度定时任务
anlog的专栏
05-10 483
【免费】c#高精度毫秒定时器，实现windows高精度定时器功能资源-CSDN文库。高精度定时器的使用以及实现_c# precisiontimer-CSDN博客。C#上位机1ms级高精度定时任务讲解_哔哩哔哩_bilibili。2024年5月10日。
c# mysql 加锁解锁
最新发布
photon222的博客
05-21 73
然后使用LOCK TABLES语句对mytable进行写操作锁定，这将阻止其他事务对该表进行写操作。在完成了需要执行的业务逻辑之后，使用UNLOCK TABLES解锁表，并提交事务。在C#中操作MySQL实现加锁和解锁，通常是通过执行特定的SQL语句来完成。MySQL支持表级锁定和行级锁定。请注意，行级锁定通常是通过在SELECT语句中使用FOR UPDATE子句来实现的，这通常在事务中进行处理。务必确保在使用事务和锁定的时候遵循最佳实践，例如尽可能减少锁定的时间和范围，以避免阻塞其他数据库操作。
C#-获取DataTable最新数据--Linq
Blue
05-14 174
C#-获取DataTable最新数据--Linq
C#解析JSON的常用库--Newtonsoft.Json
weixin_46158019的博客
05-21 147
在C#中，解析JSON的常用库有（也称为）和（从**.NET Core 3.0**开始引入）。本文主要介绍。
使用c# 梯度下降法实现双色球预测
06-08
使用梯度下降法实现双色球预测需要以下步骤： 1. 数据采集：收集历史双色球开奖数据，并对其进行预处理和归一化处理。 2. 特征提取：根据历史数据计算出每个数字的出现频率、平均值、方差等特征，并将其作为模型的输入特征。 3. 模型构建：使用C#编写梯度下降算法，并构建双色球预测模型。模型可以是线性回归、逻辑回归或神经网络等。 4. 参数调优：根据预测结果和实际开奖结果，对模型的参数进行调优，以提高预测准确率。 5. 模型评估：使用交叉验证等方法对模型进行评估，以检验其预测能力和泛化能力。 6. 预测应用：将模型应用于新的双色球数据，进行预测并输出结果。 需要注意的是，双色球预测是一项复杂的任务，预测结果可能存在误差，因此预测结果仅供参考。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值