精华内容
下载资源
问答
  • 拉普拉斯正则化
    2020-11-17 10:05:24
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from pathlib import Path
    from copy import deepcopy
    from collections import OrderedDict
    from sklearn.linear_model import LogisticRegression
    from sklearn.svm import SVC
    from sklearn import datasets
    from sklearn.model_selection import StratifiedKFold
    from sklearn.metrics import accuracy_score, f1_score, mean_absolute_error
    from scipy.spatial.distance import pdist,squareform
    import cvxpy as cvx
    
    class LRLR(object):
        def __init__(self,X_labeled,y_labeled,lap_Matrix,X_Pool):
            self.X = deepcopy(X_labeled)
            self.y = np.vstack(deepcopy(y_labeled))
            self.N = len(y_labeled)
            self.d = X_labeled.shape[1]
            self.lap_matrix = lap_Matrix
            ####------------------------------
            self.lambd1 = 0.1
            self.lambd2 = 0.1
            self.w = cvx.Variable((self.d, 1))
            self.P = X_Pool @ self.w
            ####-----------------------------
            self.loglikehood = cvx.sum(cvx.multiply(self.y, self.X @ self.w) - cvx.logistic(self.X @ self.w))
            self.L2regu = self.lambd1 * cvx.pnorm(self.w, p=2)**2
            self.Lapregu = self.lambd2 * cvx.quad_form(self.P,self.lap_matrix)
            self.obj = cvx.Maximize(self.loglikehood - self.Lapregu - self.L2regu)
            self.prob = cvx.Problem(self.obj).solve()
    
        def predict_proba(self, X_test):
            prob = 1 / (1 + cvx.exp(-(X_test @ self.w)).value)
            return prob
    
        def predict(self, X_test):
            result = []
            for ele in 1 / (1 + cvx.exp(-(X_test @ self.w)).value):
                if ele >= 0.5:
                    result.append(1)
                else:
                    result.append(0)
            return np.array(result)
    
    class BDOR():
        def __init__(self,X_train,y_train,labeled,X_test,y_test):
            self.X = X_train
            self.y = y_train
            self.X_test = X_test
            self.y_test = y_test
            self.N = len(y_train)
            #######################
            self.absLabeled = list(deepcopy(labeled))
            self.unLabeled = self.init_unlabeled()
            #####################
            self.labels = np.unique(y_train)
            self.target = np.array([_ for _ in np.arange(self.labels[0], self.labels[-1], 1)])
            self.labNum = len(self.labels)
            ############################
            self.ocModel = self.init_LR_model()
            self.trainIndex = OrderedDict()
            self.trainTarget = OrderedDict()
            ######################################
            self.neiNum = 5
            self.poolN = len(self.y)
            self.dist_matrix = squareform(pdist(X=self.X, metric='euclidean'))
            self.nn_matrix = np.zeros((self.poolN, self.neiNum))
            self.adj_matrix = self.adjacency_matrix()
            self.lap_matrix = self.laplace_matrix()
            ######################################
            # self.semiModel = self.init_learning_model()
            # self.trainIndex = OrderedDict()
            # self.trainTarget = OrderedDict()
            ######################################
            self.Acc_1 = None
            self.MAE_1 = None
            self.F1_1 = None
            self.Acc_2 = None
            self.MAE_2 = None
            self.F1_2 = None
            self.Acc_3 = None
            self.MAE_3 = None
            self.F1_3 = None
            self.Acc_4 = None
            self.MAE_4 = None
            self.F1_4 = None
            self.Acc_5 = None
            self.MAE_5 = None
            self.F1_5 = None
            ########################################
    
        def init_unlabeled(self):
            unlabeled = [_ for _ in range(self.N)]
            for ele in self.absLabeled:
                unlabeled.remove(ele)
            return unlabeled
    
        def init_LR_model(self):
            model_dict = OrderedDict()
            for tar in self.target:
                model_dict[tar] = LogisticRegression(solver='newton-cg', penalty='l2')
            return model_dict
    
        def adjacency_matrix(self):
            for i in range(self.poolN):
                ord_idx = np.argsort(self.dist_matrix[i])
                neibor = []
                for j in range(self.neiNum + 1):
                    if i != ord_idx[j]:
                        neibor.append(ord_idx[j])
                neibor = np.array(neibor)
                self.nn_matrix[i] = neibor
            adj_matrix = np.zeros((self.poolN,self.poolN))
            for i in range(self.poolN-1):
                for j in range(i,self.poolN):
                    if i in self.nn_matrix[j] or j in self.nn_matrix[i]:
                        adj_matrix[i,j] = 1
                        adj_matrix[j,i] = 1
            return adj_matrix
    
        def laplace_matrix(self):
            colum_sum = np.sum(self.adj_matrix,0)   ##列相加
            D = np.zeros((self.poolN,self.poolN))
            for i in range(self.poolN):
                D[i,i] = colum_sum[i]
            lap_matrix = D - self.adj_matrix
            return lap_matrix
    
    
        def init_semiLR_model(self):
            model_dict = OrderedDict()
            for tar in self.target:
                model_dict[tar] = LRLR(X_labeled=self.X[self.absLabeled],y_labeled=self.y[self.absLabeled],lap_Matrix=self.lap_matrix,X_Pool=self.X)
    
        def predict(self,X_test):
            model = LRLR(X_labeled=self.X[self.absLabeled],y_labeled=self.y[self.absLabeled],lap_Matrix=self.lap_matrix,X_Pool=self.X)
            y_pred = model.predict(X_test=X_test)
            return y_pred
    
    
    if __name__ == '__main__':
        p = Path("D:\OCdata")
        # names = ["abalone15-5bin", "balance-scale", "bank15-5bin", "car", "computer15-5bin", "ERA", "ESL", "eucalyptus",
        #          "housing-5bin", "LEV", "machine-5bin", "newthyroid", "stock-5bin", "SWD", "winequality-red"]
        # names = ["car","housing-5bin", "LEV", "machine-5bin", "newthyroid", "stock-5bin", "SWD", "winequality-red"]
        names = ["housing-5bin"]
    
        for name in names:
            path = p.joinpath(name + ".csv")
            print("#####################################################{}".format(path))
            # data = np.array(pd.read_csv(path, header=None))
            # X = data[:, :-1]
            # y = data[:, -1]
    
            X, y = datasets.make_blobs(n_samples=500, n_features=2, centers=2, cluster_std=[3, 3], random_state=123)
    
    
            Rounds = 5
            labNum = len(np.unique(y))
            print("数据集信息{}".format(set(y)))
            budgetlist = np.array([labNum * i for i in range(1, 21)])
            Budget = labNum * 20
            ###------------------------------
            Acc_1_list = []
            Acc_2_list = []
            Acc_3_list = []
            Acc_4_list = []
            MAE_1_list = []
            MAE_2_list = []
            MAE_3_list = []
            MAE_4_list = []
            F1_1_list = []
            F1_2_list = []
            F1_3_list = []
            F1_4_list = []
            for r in range(Rounds):
                SKF = StratifiedKFold(n_splits=10, shuffle=True)
                for train_idx, test_idx in SKF.split(X, y):
                    # print("类别个数=",labNum,"训练数据=",len(train_idx),"测试数据=",len(test_idx))
                    train_X = X[train_idx]
                    train_y = y[train_idx]
                    test_X = X[test_idx]
                    test_y = y[test_idx]
                    labeled = []
                    label_dict = OrderedDict()
                    for lab in np.unique(train_y):
                        label_dict[lab] = []
                    for idx in range(len(train_y)):
                        label_dict[train_y[idx]].append(idx)
                    for idxlist in label_dict.values():
                        for jdx in np.random.choice(idxlist, size=5, replace=False):
                            labeled.append(jdx)
                    # print("已标记样本:",labeled)
                    # labeled = range(len(train_idx))
    
                    plt.scatter(X[:, 0], X[:, 1], c=y)
                    plt.scatter(train_X[:,0],train_X[:,1],c=train_y)
                    plt.scatter(train_X[labeled][:,0],train_X[labeled][:,1],c='r', marker="*", s=200, label="Labeled instance")
                    plt.legend()
                    plt.show()
    
    
                    model = BDOR(X_train=train_X, y_train=train_y, labeled=labeled,  X_test=test_X, y_test=test_y)
                    y_pred = model.predict(X_test=test_X)
                    Acc = accuracy_score(y_true=test_y, y_pred=y_pred)
                    print("拉普拉斯正则逻辑回归=",Acc)
    
                    model_lr = LogisticRegression(solver='lbfgs', penalty="l2")
                    model_lr.fit(X=train_X[labeled], y=train_y[labeled])
                    #####-----------------下面的是调用sklearn工具包实现的。
                    ypred = model_lr.predict(X=test_X)
                    acc = accuracy_score(y_true=test_y, y_pred=ypred)
                    print("sklearn调包逻辑回归", acc)
    
                    break
                break
            break

    更多相关内容
  • 引入基于分析的超拉普拉斯先验模型对全局频谱结构进行建模,以间接减轻空间域中的振铃伪影。 与现有方法相比,该方法的优点是多方面的:更合理的结构相关可表示性,更少的处理时间以及重叠区域中更少的伪影。 所...
  • 基于多视图拉普拉斯正则化的半监督稀疏特征选择,
  • 致力于设计基于风险的安全拉普拉斯正则化最小二乘法
  • 基于拉普拉斯正则化概率主元分析的故障检测
  • 传统的低秩表示模型LRR对高维数据聚类精确度低,针对这一情况提出一种基于拉普拉斯正则化双曲正切函数低秩子空间聚类算法(LRHT-LRSC).该算法利用双曲正切函数代替核范数以便更紧凑地逼近秩函数,并利用拉普拉斯正则项...
  • 拉普拉斯矩阵与正则化

    千次阅读 多人点赞 2020-07-07 21:44:43
    拉普拉斯矩阵正则化: L 左乘度矩阵的-1/2 次,再右乘度矩阵的-1/2 次,展开得到单位矩阵I 减去 A左乘度矩阵的-1/2 次,再右乘度矩阵的-1/2 次 本质的意义就是,把邻接矩阵的对角线用1代替,其他表示边的1,用该边...

    给定无向图G = (V,E) 如下图所示,V是顶点集合,顶点数为6,E为边集合
    在这里插入图片描述
    其邻接矩阵如下,为一个对称矩阵,记为A
    在这里插入图片描述
    其度矩阵为一个对角矩阵,Aii 为 第i行的求和,即顶点vi 的邻居数
    在这里插入图片描述
    拉普拉斯矩阵的定义为L = D - A
    在这里插入图片描述

    拉普拉斯矩阵正则化:

    L 左乘度矩阵的-1/2 次,再右乘度矩阵的-1/2 次,展开得到单位矩阵I 减去 A左乘度矩阵的-1/2 次,再右乘度矩阵的-1/2 次
    在这里插入图片描述
    本质的意义就是,把邻接矩阵的对角线用1代替,其他表示边的1,用该边所连接的两个顶点的度数乘积的-1/2 次方的相反数代替。

    下面是假定有简单矩阵A 和 对应的D,计算对应的正则化的拉普拉斯矩阵。
    在这里插入图片描述

    展开全文
  • from copy import deepcopy import numpy as np import matplotlib.pyplot as plt from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_...
    '''
    auther:Deniu He
    date:2020-09-26
    '''
    
    from copy import deepcopy
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn import datasets
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    from sklearn.linear_model import LogisticRegression
    from scipy.spatial.distance import pdist,squareform
    import cvxpy as cvx
    
    
    class LR():
        def __init__(self, X, y, X_pool, y_pool):
            self.X = X
            self.y = np.vstack(y)
            self.N = self.X.shape[0]
            print("标记数据个数=",self.N)
            self.d = self.X.shape[1]
            ###--------------------------------
            self.X_pool = X_pool
            self.y_pool = y_pool
            self.poolN = self.X_pool.shape[0]
            print("全体数据个数=",self.poolN)
            self.neiNum = 5
            self.dist_matrix = squareform(pdist(X=self.X_pool, metric='euclidean'))
            self.nn_matrix = np.zeros((self.poolN,self.neiNum))
            self.adj_matrix = self.adjacency_matrix()
            self.lap_matrix = self.laplace_matrix()
            ####------------------------------
            self.lambd1 = 0.1
            self.lambd2 = 0.1
            self.w = cvx.Variable((self.d, 1))
            self.P = self.P_matrix()
            ####-----------------------------
            self.loglikehood = cvx.sum(cvx.multiply(self.y, self.X @ self.w) - cvx.logistic(self.X @ self.w) )
            self.L2regu = self.lambd1 * cvx.norm(self.w, 1)
            self.Lapregu = self.lambd2 * cvx.quad_form(self.P,self.lap_matrix)
            self.obj = cvx.Maximize(self.loglikehood - self.Lapregu - self.L2regu)
            # self.obj = cvx.Maximize(self.loglikehood - self.Lapregu)
            self.prob = cvx.Problem(self.obj).solve()
            ####------------------------------
            print(self.w.value)
        def adjacency_matrix(self):
            for i in range(self.poolN):
                ord_idx = np.argsort(self.dist_matrix[i])
                neibor = []
                for j in range(self.neiNum + 1):
                    if i != ord_idx[j]:
                        neibor.append(ord_idx[j])
                neibor = np.array(neibor)
                self.nn_matrix[i] = neibor
            adj_matrix = np.zeros((self.poolN,self.poolN))
            for i in range(self.poolN-1):
                for j in range(i,self.poolN):
                    if i in self.nn_matrix[j] or j in self.nn_matrix[i]:
                        adj_matrix[i,j] = 1
                        adj_matrix[j,i] = 1
            return adj_matrix
    
        def laplace_matrix(self):
            colum_sum = np.sum(self.adj_matrix,0)   ##列相加
            D = np.zeros((self.poolN,self.poolN))
            for i in range(self.poolN):
                D[i,i] = colum_sum[i]
            lap_matrix = D - self.adj_matrix
            return lap_matrix
    
        def P_matrix(self):
            P = self.X_pool @ self.w
            return P
    
        def pred_prob(self, X_test):
            prob = 1 / (1 + cvx.exp(-(X_test @ self.w)).value)
            return prob
    
        def pred(self, X_test):
            result = []
            for ele in 1 / (1 + cvx.exp(-(X_test @ self.w)).value):
                if ele >= 0.5:
                    result.append(1)
                else:
                    result.append(0)
            return np.array(result)
    
    
    if __name__ == '__main__':
        X, y = datasets.make_blobs(n_samples=500, n_features=2, centers=2, cluster_std=[3, 3], random_state=123)
        # X, y = datasets.load_iris(return_X_y=True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
        print("测试数据个数=",len(y_test))
        X_unlabeled, X_labeled, y_unlabeled, y_labeled = train_test_split(X_train,y_train,test_size=0.02,random_state=0)
        plt.scatter(X[:,0],X[:,1],c=y)
        plt.scatter(X_labeled[:,0],X_labeled[:,1],c='r',marker="*",s=200,label="Labeled instance")
        plt.legend()
        plt.show()
    
        model = LR(X=X_labeled,y=y_labeled,X_pool=X_train,y_pool=y_train)
        prob = model.pred_prob(X_test=X_test)
        y_pred = model.pred(X_test=X_test)
        Acc = accuracy_score(y_true=y_test,y_pred=y_pred)
        print("拉普拉斯正则逻辑回归=",Acc)
        model_lr = LogisticRegression()
        model_lr.fit(X=X_labeled,y=y_labeled)
        #####-----------------下面的是调用sklearn工具包实现的。
        ypred = model_lr.predict(X=X_test)
        acc = accuracy_score(y_true=y_test,y_pred=y_pred)
        print("sklearn调包逻辑回归",acc)

    感觉就是个垃圾!没有体现出效果来呢?

    分类效果跟调包sklearn一模一样,而且还多出了一个超参数!垃圾!

    注释:LaplaRegu= f^T L f

    f = w^T X

    有文献使用概率LapRegu = P^T L P

    P= \frac{1}{1+e^{-w ^TX}}

    很显然会使得拉普拉斯正则项非凸。所以,才会使用上面拉普拉斯正则项。

    展开全文
  • 流形正则化matlab代码使用图维拉普拉斯正则化的低维流形模型进行3D点云降噪 作者:曾增,张Gene,吴敏,庞佳豪,成阳 出现在IEEE Trans上。 关于图像处理 组织 |--- main_addnoise.m : main for adding noise to gt ...
  • 之前的博客介绍过自己对于正则化的理解,经过这段时间的进一步接触,尤其是看了一些关于这一方面的paper,做了一些简短的实验,发现正则化真是一个很给力的建模方法。近期,看到了Laplacian Smoothing,相信很多童鞋...

    之前的博客介绍过自己对于正则化的理解,经过这段时间的进一步接触,尤其是看了一些关于这一方面的paper,做了一些简短的实验,发现正则化真是一个很给力的建模方法。近期,看到了Laplacian Smoothing,相信很多童鞋遇到过这两个单词,但是,论文中关于这点的介绍往往都很“随意”,甚至出现了很多雷同,这里谈谈我对“拉普拉斯平滑”的一些理解。

    首先,说说为什么要“平滑”,换句话说,平滑究竟有什么用。

    平滑的目的也是正则化的目的之一,它是针对参数w而言,本质上就是要使得w的变化不要那么剧烈,有如下数学模型(假设最小化J):
    在这里插入图片描述

    左侧是一个典型的线性回归模型,(xi,yi)就是实际的观测值,w就是估计的参数,右侧就是一个正则化项。可以直观的感受到,正则化项实际上起到了限制参数w的“变化程度或变化幅值”的作用,具体来说,它可以令w的任何一个分量相比较于剩余分量变化程度保持一致,不至于出现变化特别明显的分量。直接的作用就是防止模型“过拟合”,提高了模型的泛化性能。关于这一点,具体请见http://blog.csdn.net/wsj998689aa/article/details/39547771

    其次,知道了平滑,就开始说说拉普拉斯平滑到底是怎么一回事。这里分为两点介绍,先介绍定义,再介绍如何应用。

    定义:假设f是定义在d维子空间中的一个实函数,该子空间上的拉普拉斯算子和拉普拉斯代价函数分别为:

    在这里插入图片描述

    数学上的定义一般是让人看不懂的,大家都喜欢听例子,我们现在想象一副图像,这幅图像如果含有噪声,或者色彩变化剧烈,就说明其不够平滑,那个算子就好比一个“小刷子”,不仅可以刷去“小黑点(噪声的一种)“,也可以模糊图像。而下面的代价函数就好比用这个”小刷子“去刷一整副图像,使得整幅图像变得平滑了。

    然后,当d=2(图像就是2维的)的时候,并且积分号变成和号的时候(连续变为离散),就是拉普拉斯平滑在图像上的应用。

    这种”小刷子“有很多种,下面就是一个比较经典的:
    在这里插入图片描述

    这种算子就是第二个公式的离散近似(具体名称:修正的Neuman),起到的作用就是二阶差分。一阶差分就是相邻元素xi,xi+1相减得到的值yi,二阶差分就是yi - yi+1,可以在纸上推推这个矩阵乘以一个向量。值得一提的是,二阶差分其实就起到了平滑(模糊)图像的作用,想通了有木有?

    最后,聊聊拉普拉斯平滑在正则化上的应用,这个时候,它的名字往往就叫做”拉普拉斯惩罚“。惩罚的是谁?显然是参数w了!

    说说背景,机器学习中,大部分算法直接将图像(假设为M*N)按行或者列拉成向量,这样肯定会损失结构化信息,结构化信息是啥?很好理解,一个像素本来和它周围8个像素都有关系,你直接给拉成向量了,那么这种关系就直接被你给毁掉了,这就叫空间结构信息。这种信息属于先验信息,NFL定理说的很清楚:能够尽可能利用先验信息的学习算法才是好算法。看来,空间结构信息的破坏,会降低算法的”品味“。别担心,拉普拉斯惩罚帮助你找回品味。

    扯多了,回到正题,一幅图像拉成向量x(M*N维),如果我们要通过拉普拉斯惩罚,补偿x上失去的结构信息。很简单,如下式:
    在这里插入图片描述

    那个乘法是Kronecke积,相当于将乘号右边的每个元素替换成为左边矩阵数乘对应元素,如果A是一个 m x n 的矩阵,而B是一个 p x q 的矩阵,克罗内克积则是一个 mp x nq 的矩阵。
    在这里插入图片描述

    上述公式实际上起到的效果是,求一个矩阵中每个元素的水平方向和垂直方向的二阶差分之和,这个矩阵在这里可以被看错参数w的矩阵形式(按列reshape)。

    进一步,如果我们对一个线性回归模型加上拉普拉斯惩罚,模型就会变为如下形式:

    在这里插入图片描述

    拉普拉斯惩罚使得模型更加平滑,比简单的2范数(岭回归)要好,因为它考虑了空间结构信息。常被用于PCA,LDA,LPP,NPE等子空间学习算法的改造上面,一般会使算法性能得到提升。

    给出一篇参考文献,里面介绍的比较深刻,喜欢看英文的朋友可以仔细的看看《Learning a Spatially Smooth Subspace for Face Recognition》这篇文章。

    作者:迷雾forest
    来源:CSDN
    原文:https://blog.csdn.net/wsj998689aa/article/details/40303561
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 通过混合图拉普拉斯正则化进行渐进图像复原
  • 故L1正则化相当于对模型参数引入了拉普拉斯先验,L2正则化相当于引入了高斯先验。高斯分布在0点处是平滑的,也就是高斯先验分布认为w在极值点附近取不同值可能性是接近的。只会让w接近0,不会等于0。但拉普拉斯分布...
  • MATLAB 中 正则化函数是什么?

    千次阅读 2020-12-28 23:20:18
    2016-12-17 回答matlab归一化(正则化)函数mapminmax语法[y,ps] = mapminmax(ymin,ymax)[y,ps] = mapminmax(x,fp)y = mapminmax('apply',x,ps)x = mapminmax('reverse',y,ps)dx_dy = mapminmax('dx',x,y,ps)dx_dy = ...
  • Laplace(拉普拉斯)先验与L1正则化 在之前的一篇博客中L1正则化及其推导推导证明了L1正则化是如何使参数稀疏化人,并且提到过L1正则化如果从贝叶斯的观点看来是Laplace先验,事实上如果从贝叶斯的观点,所有的正则...
  • 拉普拉斯平滑和正则化

    千次阅读 2019-10-18 13:40:45
    https://blog.csdn.net/wsj998689aa/article/details/40303561 https://blog.csdn.net/wsj998689aa/article/details/40378547
  • 高光谱图像(HSI)通常在采集过程中由于各种噪声的混合而降低质量,这些噪声可能包括高斯噪声,脉冲噪声,虚线,条纹等。 本文介绍了一种基于低秩矩阵恢复(LRMR)的HSI恢复新方法,该方法可以同时去除高斯噪声,...
  • 今天看了B站一位up主解释L1和L2正则化,感觉讲解的很不错,自己总结一下。 面试常见问题: 如何防止模型过拟合。 为什么正则化可以防止过拟合?...L1正则化是先验概率为拉普拉斯分布;L2正则是...
  • 一、正则化 一般来说,监督学习可以看做最小化下面的目标函数: 其中,第一项L(yi,f(xi;w)) 衡量我们的模型(分类或者回归)对第i个样本的预测值f(xi;w)和真实的标签yi之前的误差。因为我们的模型是要拟合我们的...
  • 正则化最小二乘估计

    千次阅读 2018-12-18 00:30:22
    对于给定的训练样本{xi,di}i=1N\lbrace x_i, d_i\rbrace _{i=1} ^{N}{xi​,di​}i=1N​,最小二乘估计的正则化代价函数由下式定义: ε(w)=12∑i=1N(di−wTXi)2+12λ∣∣w∣∣2 \varepsilon (w) = \frac{1}{2} \sum...
  • rilt 正则化拉普拉斯逆变换[g,yfit,cfg] = rilt(t,y,s,g0,alpha) 数组 g(s) 是数组 y(t) 的拉普拉斯逆变换,通过正则化最小二乘法计算。 该脚本是 S. Provencher CONTIN 程序的仿真,用 Fortran 编写。 请参阅...
  • 此外,GMCF还在每层中都包含了图拉普拉斯正则化,以有效保留数据的多种结构。 开发了一种有效的迭代更新方案来优化GMCF。 严格证明了该算法的收敛性。 详细分析了计算复杂度。 大量实验表明,GMCF在数据表示和聚类...
  • 流形正则化matlab代码近似流形正则化:可扩展算法和泛化分析 该存储库提供了用于运行论文“近似流形正则化:可伸缩算法和泛化分析”的实验的代码。 该论文已发表在。 论文借鉴了Nystom和PCG的LapRLS的思想。 该实现...
  • 图拉普拉斯正则

    千次阅读 2019-04-06 12:08:46
    http://www.cnblogs.com/xingshansi/articles/6702188.html
  • 流形正则化matlab代码LapEMR-1.0 林晨,2012年6月 ...Xu:可扩展流形正则化拉普拉斯嵌入式回归。 IEEE Transactions on Neural Networks and Learning Systems(TNNLS)23(6):902-915,2012年6月
  • 在不对称拉普拉斯分布的误差项下,统计仿真结果表明,贝叶斯正则化分位数回归在所有分位数上均优于其他分布。 并且基于非对称拉普拉斯分布,贝叶斯正则化分位数回归方法在参数估计和预测方面要比非贝叶斯方法更好。...
  • http://blog.sina.com.cn/s/blog_53f29119010009uf.html正则表达式这个词上大学的时候就听同寝室的一个家伙常念叨——那家伙当然很厉害啦,现在已经发洋财去了——直到昨天又遇到,想起还有...不过,要想把正则表...
  • L1正则化与L2正则化(详解)

    千次阅读 2020-04-09 15:38:31
    L1正则化与L2正则化 正则化之所以能够降低过拟合的原因在于,正则化是结构风险最小化(模型结构最简单,经验风险最小化就是训练误差小)的一种策略实现。 给loss function加上正则化项,能使得新得到的优化目标函数h...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,817
精华内容 1,926
关键字:

拉普拉斯正则化