精华内容
下载资源
问答
  • 于是便有了正则化方法的出现,通过收缩方法(正则化方法)进行回归。正则化方法主要包括岭回归与LASSO回归。/ 01 / 岭回归岭回归通过人为加入的惩罚项(约束项),对回归系数进行估计,为有偏估计。有偏估计,允许估计有...

    dfb42a9e0ced59918cfef1b08ef5199d.gif

    接之前的线性回归文章,传送门如下。

    上面这篇文章是利用方差膨胀因子,去诊断与减轻多重共线性对线性回归的影响。

    需要人为介入(根据得到的方差膨胀值去判断),耗费过多的时间。

    于是便有了正则化方法的出现,通过收缩方法(正则化方法)进行回归。

    正则化方法主要包括岭回归与LASSO回归。

    / 01 / 岭回归

    岭回归通过人为加入的惩罚项(约束项),对回归系数进行估计,为有偏估计。

    有偏估计,允许估计有不大的偏度,以换取估计的误差显著减小,并在其残差平方和为最小的原则下估计回归系数。

    通常岭回归方程中的R²会稍低于线性回归分析,但回归系数的显著性往往明显高于普通线性回归。

    这里不对相应的理论知识进行细说,说实话小F也是晕乎乎...

    所以选择先调包,看看效果是啥样的。

    使用机器学习框架scikit-learn进行岭回归参数的选择(正则化系数)。

    数据是书中的数据,已上传网盘,公众号回复「正则化」,即可获取。

    scikit-learn当中的模型不会默认对数据标准化,必须手动执行。

    标准化后的数据可以消除量纲,让每个变量的系数在一定意义下进行直接比较。

    import numpy as np

    import pandas as pd

    import matplotlib.pyplot as plt

    from sklearn.linear_model import Ridge

    from sklearn.linear_model import RidgeCV

    from sklearn.preprocessing import StandardScaler

    # 消除pandas输出省略号情况及换行情况

    pd.set_option('display.max_columns', 500)

    pd.set_option('display.width', 1000)

    # 读取数据,skipinitialspace:忽略分隔符后的空白

    df = pd.read_csv('creditcard_exp.csv', skipinitialspace=True)

    # 获取信用卡有支出的行数据

    exp = df[df['avg_exp'].notnull()].copy().iloc[:, 2:].drop('age2', axis=1)

    # 获取信用卡无支出的行数据,NaN

    exp_new = df[df['avg_exp'].isnull()].copy().iloc[:, 2:].drop('age2', axis=1)

    # 选择4个连续变量,分别是年龄 收入 当地小区价格 当地人均收入

    continuous_xcols = ['Age', 'Income', 'dist_home_val', 'dist_avg_income']

    # 标准化

    scaler = StandardScaler()

    # 解释变量,二维数组

    X = scaler.fit_transform(exp[continuous_xcols])

    # 被解释变量,一维数组

    y = exp['avg_exp_ln']

    # 生成正则化系数

    alphas = np.logspace(-2, 3, 100, base=10)

    # 使用不同的正则化系数对模型进行交叉验证

    rcv = RidgeCV(alphas=alphas, store_cv_values=True)

    # 使用数据集训练(fit)

    rcv.fit(X, y)

    # 输出最优参数,正则化系数及相应模型R²

    print('The best alpha is {}'.format(rcv.alpha_))

    print('The r-square is {}'.format(rcv.score(X, y)))

    # 训练好后使用transform进行数据转换

    X_new = scaler.transform(exp_new[continuous_xcols])

    # 使用模型对数据做预测

    print(np.exp(rcv.predict(X_new)[:5]))

    输出结果如下。

    c0e76aca546c61e976b58c8dbcceaff3.png

    最优正则化系数为0.29,模型R²为0.475。

    并使用最优正则化系数下的岭回归模型预测数据。

    对不同正则化系数下模型的均方误差进行可视化。

    # 正则化系数搜索空间当中每轮交叉验证的结果,模型的均方误差

    cv_values = rcv.cv_values_

    n_fold, n_alphas = cv_values.shape

    # 模型均方误差上下波动值

    cv_mean = cv_values.mean(axis=0)

    cv_std = cv_values.std(axis=0)

    ub = cv_mean + cv_std / np.sqrt(n_fold)

    lb = cv_mean - cv_std / np.sqrt(n_fold)

    # 绘制折线图,x轴是指数型形式

    plt.semilogx(alphas, cv_mean, label='mean_score')

    # y1(lb)和y2(ub)之间进行填充

    plt.fill_between(alphas, lb, ub, alpha=0.2)

    plt.xlabel('$\\alpha$')

    plt.ylabel('mean squared errors')

    plt.legend(loc='best')

    plt.show()

    输出结果如下。

    2c8e319ba8293cf95092d2fe575f366b.png

    发现正则化系数在40或50以下时,模型的均方误差相差不大。

    当系数超过该阈值时,均方误差则快速上升。

    所以正则化系数只要小于40或50,模型的拟合效果应该都不错。

    正则化系数越小则模型拟合越好,但过拟合情况也越容易发生。

    正则化系数越大,则越不容易过拟合,但模型的偏差越大。

    RidgeCV通过交叉验证,可以快速返回“最优”的正则化系数。

    当这只是基于数值计算的,可能最终结果并不符合业务逻辑。

    比如本次模型的变量系数。

    # 输出模型的变量系数

    print(rcv.coef_)

    # 输出结果

    [ 0.03321449 -0.30956185  0.05551208  0.59067449]

    发现收入的系数为负值,这肯定是不合理的。

    下面通过岭迹图进行进一步分析。

    岭迹图是在不同正则化系数下变量系数的轨迹。

    ridge = Ridge()

    coefs = []

    # 不同正则化系数下的变量系数

    for alpha in alphas:

    ridge.set_params(alpha=alpha)

    ridge.fit(X, y)

    coefs.append(ridge.coef_)

    # 绘制变量系数随正则化系数变化的轨迹

    ax = plt.gca()

    ax.plot(alphas, coefs)

    ax.set_xscale('log')

    plt.xlabel('alpha')

    plt.ylabel('weights')

    plt.title('Ridge coefficients as a function of the regularization')

    plt.axis('tight')

    plt.show()

    输出结果。

    900bbf7551bd72b677f2fa99e0b2c897.png

    ①有两个变量的系数在不同的正则化系数下都很接近于0,那么可以选择删除。

    ②正则化系数越大,对变量系数的惩罚越大,所有变量的系数都趋近于0。

    ③有一个变量的系数变化非常大(有正有负),说明该系数的方差大,存在共线性的情况。

    综合模型均方误差和岭迹图的情况,选取正则化系数为40。

    如果大于40,则模型均方误差增大,模型拟合效果变差。

    如果小于40,则变量系数不稳定,共线性没有得到抑制。

    那么就来看看,当正则化系数为40时,模型变量系数的情况。

    ridge.set_params(alpha=40)

    ridge.fit(X, y)

    # 输出变量系数

    print(ridge.coef_)

    # 输出模型R²

    print(ridge.score(X, y))

    # 预测数据

    print(np.exp(ridge.predict(X_new)[:5]))

    # 输出结果

    [0.03293109 0.09907747 0.04976305 0.12101456]

    0.4255673043353688

    [934.79025945 727.11042209 703.88143602 759.04342764 709.54172995]

    发现变量系数都为正值,符合业务直觉。

    收入和当地人均收入这两个变量可以保留,另外两个删除。

    / 02/ LASSO回归

    LASSO回归,在令回归系数的绝对值之和小于一个常数的约束条件下,使残差平方和最小化。

    从而能够产生某些严格等于0的回归系数,得到解释力较强的模型。

    相比岭回归,LASSO回归还可以进行变量筛选。

    使用LassoCV交叉验证确定最优的正则化系数。

    # 生成正则化系数

    lasso_alphas = np.logspace(-3, 0, 100, base=10)

    # 使用不同的正则化系数对模型进行交叉验证

    lcv = LassoCV(alphas=lasso_alphas, cv=10)

    # 使用数据集训练(fit)

    lcv.fit(X, y)

    # 输出最优参数,正则化系数及相应模型R²

    print('The best alpha is {}'.format(lcv.alpha_))

    print('The r-square is {}'.format(lcv.score(X, y)))

    # 输出结果

    The best alpha is 0.04037017258596556

    The r-square is 0.4426451069862233

    发现最优的正则化系数为0.04,模型R²为0.443。

    接下来获取不同正则化系数下的变量系数轨迹。

    lasso = Lasso()

    lasso_coefs = []

    # 不同正则化系数下的变量系数

    for alpha in lasso_alphas:

    lasso.set_params(alpha=alpha)

    lasso.fit(X, y)

    lasso_coefs.append(lasso.coef_)

    # 绘制变量系数随正则化系数变化的轨迹

    ax = plt.gca()

    ax.plot(lasso_alphas, lasso_coefs)

    ax.set_xscale('log')

    plt.xlabel('alpha')

    plt.ylabel('weights')

    plt.title('Lasso coefficients as a function of the regularization')

    plt.axis('tight')

    plt.show()

    输出结果。

    98e0264d3dfa0d9568b0057e93517031.png

    发现随着正则化系数的增大,所有变量的系数会在某一阈值突降为0。

    其中缘由与LASSO回归方程有关,不细说。

    输出LASSO回归的变量系数。

    print(lcv.coef_)

    # 输出结果

    [0.         0.         0.02789489 0.26549855]

    发现前两个变量被筛选掉了,即年龄和收入。

    为啥和岭回归的结果不一样呢???

    / 03 / 总结

    坑留的有点多,待小F慢慢填...

    相关资料获取,请点击阅读原文。

    ···  END  ···

    fffc1759cf2e2d2c23933e266dccaedc.png

    展开全文
  • 数据归一化、数据标准化、数据正则化 数据归一化:将数据集中某一列数值特征的值缩放到0-1区间内 数据标准化:将数据集中某一列数值特征的值缩放成平均值为0,标准差为1的状态 数据正则化:将数据集中某一个...

    数据归一化、数据标准化、数据正则化

    数据归一化:将数据集中某一列数值特征的值缩放到0-1区间内

    数据标准化:将数据集中某一列数值特征的值缩放成平均值为0,标准差为1的状态

     

    数据正则化:将数据集中某一个样本缩放成单位标准

                  

    归一化特点:

    对不同特征维度进行伸缩变换,把有量纲表达式变为无量纲表达式;

    改变原始数据的分布,使得各个特征维度对目标函数的影响权重归于一致

    最大值与最小值非常容易受异常点影响,鲁棒性较差。

    标准化特点:

    对不同特征维度的伸缩变换使其不同度量之间的特征具有可比性;

    不改变原始数据的分布,保持各个特征维度对目标函数的影响权重

    对目标函数的影响体现在几何分布上。

    应用场景:

    1. 数据归一化

    不涉及距离度量、协方差计算、数据不符合正态分布的时候,可以使用归一化方法

    2. 数据标准化:

    分类、聚类算法中,需要使用距离来度量相似性的时候、或者使用PCA技术进行降维的时候,标准化(Z-score standardization)表现更好

    1. 聚类过程中,标准化显得尤为重要。这是因为聚类操作依赖于对类间距离和类内聚类之间的衡量。如果一个变量的衡量标准高于其他变量,那么我们使用的任何衡量标准都将受到该变量的过度影响。
    2. 主成分分析PCA之前,对变量进行标准化至关重要。这是因为PCA给那些方差较高的变量比那些方差非常小的变量赋予更多的权重。而标准化原始数据会产生相同的方差,因此高权重不会分配给具有较高方差的变量。
    3. SVM中,使用所有跟距离计算相关的kernel都需要对数据进行标准化。
    4. 在选择岭回归和Lasso时候,标准化是必须的。原因是正则化是有偏估计,会对权重进行惩罚。在量纲不同的情况,正则化会带来更大的偏差
    5. 当采用普通的线性回归的时候,是无需标准化的。因为标准化前后,不会影响线性回归预测值。
    6. 标准化不会影响logistic回归,决策树及其他一些集成学习算法:such as random forest and gradient boosting。

     

    3. 数据正则化:

    主要应用于文本分类和聚类中。

    就实际应用而言,数据归一化、标准化(预处理)使用较多。

    参考:

    https://blog.csdn.net/abcdefg90876/article/details/108395986

    https://blog.csdn.net/u014381464/article/details/81101551

    https://blog.csdn.net/shwan_ma/article/details/80154888

    https://blog.csdn.net/qq_22690765/article/details/84837540

    https://blog.csdn.net/Anne033/article/details/107489208

     

    展开全文
  • 正则化:一般可以通过减少特征或者惩罚不重要特征的权重来缓解过拟合,但是我们通常不知道该惩罚那些特征的权重,而正则化就是帮助我们惩罚特征权重的,即特征的权重也会成为模型的损失函数一部分。可以理解为, ...

    正则化:

    一般可以通过减少特征或者惩罚不重要特征的权重来缓解过拟合,但是我们通常不知道该惩罚那些特征的权重,而正则化就是帮助我们惩罚特征权重的,即特征的权重也会成为模型的损失函数一部分。可以理解为, 为了使用某个特征,我们需要付出loss的代价(loss为给权重weight加的一个loss,正则化),除非这个特征非常有效,否贼就会被loss上的增加覆盖效果。这样我们就能筛选出最有效的特征,减少特征权重防止过拟合。

    一般来说,L1正则会制造稀疏的特征,大部分无用特征的权重会被至为0,

    L2正则会让特征的权重不过大,使得特征的权重比较平均。       tensorflow.nn.l2_loss(weight) 就是计算weight的L2 loss。

    数据增强:

    tf.image.random_flip_left_right(): 照片的随机水平翻转        //这里没写参数列表,下同

    tf.random_crop():从照片中随机剪切一块照片

    tf.image.random_brightness():设置随机的亮度

    tf.image.random_contrast():设置随机的对比度

    tf.image.per_image_whitening():对数据进行标准化(对数据减去均值,除去方差,保证数据0平均, 方差为1)

    展开全文
  • 日后有更多关于正则化的学习、应用,也将会分享于此。 一:re.findall 在做数据处理的时候,最烦遇到的是一种什么情况呢? 数据有规律的存储了 然后存储好的一堆数据,又需要解析出来用 一组数据里面各种...

    正则表达式,可谓是数据处理的神器,我算是见识到了它的威力。之前也接触过,但一直没有搞明白。今再次接触,定要学个明明白白。算有一些入门了,就分享到此处。一是方便日后自己查找,二是方便小伙伴一起交流学习。日后有更多关于正则化的学习、应用,也将会分享于此。

    一:re.findall

    在做数据处理的时候,最烦遇到的是一种什么情况呢?

    1. 数据有规律的存储了
    2. 然后存储好的一堆数据,又需要解析出来用
    3. 一组数据里面各种形形色色的格式

    如果是CSV文件,读取出来的,都当做字符串。要想取个什么东西,就要按照字符串的处理方式,例如find,split等等,较为繁琐。但是,正则化就显得尤为的简单,然而,这就需要找到数据中的一般规律,然后用re取出来,这个流程就较为的简单了。

    本小节主要知识点如下:

    1. re.findall 在字符串中返回正则表达式所匹配的的所有子串,并返回一个列表。如果一个都没有匹配上,则返回空列表
    2. \d 匹配字符串中的数字
    3. *  重复0次或更多次  例如:35.26  35 + . + 26  [0-9] + . + [0-9]
    4. 真 . 需加 \ ,即 \.;当然,要查找\本身,你也得用\\

    正则匹配中的元字符有: . ^ $ * + ? { [ ] \ | ( )。这些元字符的主要作用是跟其它的标准字符一起组成匹配的规则,所以可以认为它们是带有其它作用的特殊字符。

     匹配字符的规则

    (1)通过正反括号"["和"]"确定要匹配的字符

             “[]”这个括号里面可以例举出想要匹配的字符集合,也可以通过限定字符集的范围确定。例如,[abc] 和[a-c]都表示匹配"a", "b", 或 "c"中的任意一个字符。

            如果字符本身是元字符,那么它在 “[]”里面的时候就是一个普通字符,例如:[[]就是表示匹配字符“[”。

    (2)取反元字符 ^ 的使用

            在方括号中,首字符如果使用取反字符^的话,就表示匹配初括号中的字符之外的其它字符。例如,[^5] 将匹配除 "5" 之外的任意字符。

    (3)反斜杠“\”的使用

    作用1:将那些在正则匹配中有特殊意义的字符转换成普通的字符,或者将普通字符标记成它代表的特殊意义

    作用2:用来确定要匹配的字符类型,规则如下:

    \d  匹配任何十进制数;它相当于类 [0-9]。
    \D  匹配任何非数字字符;它相当于类 [^0-9]。


    \s  匹配任何空白字符;它相当于类  [ \t\n\r\f\v]。
    \S  匹配任何非空白字符;它相当于类 [^ \t\n\r\f\v]。


    \w  匹配任何字母数字字符;它相当于类 [a-zA-Z0-9_]。
    \W  匹配任何非字母数字字符;它相当于类 [^a-zA-Z0-9_]。

     

    匹配字符的个数

            re中主要使用*、+、?还有花括号{}来确定匹配的字符的个数

    (1)* 指定前一个字符可以被匹配零次或更多次,而不是只有一次。ca*t 将匹配 "ct" (0 个 "a" 字符), "cat" (1 个 "a"), "caaat" (3 个 "a" 字符)等等

    (2)+ 表示匹配一或更多次。用同一个例子,ca+t 就可以匹配 "cat" (1 个 "a"), "caaat" (3 个 "a"), 但不能匹配 "ct"。

    (3)?  匹配一次或零次;你可以认为它用于标识某事物是可选的。例如:home-?brew 匹配 "homebrew" 或 "home-brew"。

    (4){m,n},其中 m 和 n 是十进制整数。该限定符的意思是至少有 m 个重复,至多到 n 个重复。举个例子,a/{1,3}b 将匹配 "a/b","a//b" 和 "a///b"。它不能匹配 "ab" 因为没有斜杠,也不能匹配 "ab" ,因为有四个。

     

    光说不练假把式。下面,就用一个案例,来将上面四点,做个实践。上面4点看不懂的不要紧,下面的案例包你看明白,为你初入正则化,做开门解惑。

    案例:今有一张数据统计表,数据存储为CSV格式,数据共四列(没看到四列的,光标放到表格里面,向右移动,即可看到),内容如下:

    ddaae641bf2af78c1a02ba43575b0d51_3001_2849_0.1440486666667_0.1440486666667.png[0][0.6761001944541931][[273.28466796875, 175.67626953125, 402.2430419921875, 328.661865234375]]
    2.25.136083661060415706315254052090742684427_4000_3000_0_0.png[0, 0][0.7710305452346802, 0.5624949932098389][[190.70089721679688, 38.103851318359375, 450.9465637207031, 446.1026916503906], [615.7803955078125, 33.51222229003906, 808.9849853515625, 279.001953125]]
    2.25.325405860827049753751982304033775186562_3370_3214_0_0.png[0, 0, 0][0.8847285509109497, 0.7925058603286743, 0.5061626434326172][[61.759857177734375, 317.8360595703125, 316.9251708984375, 758.53271484375], [119.5316162109375, 86.29457092285156, 465.26458740234375, 359.308349609375], [676.3946533203125, 208.73971557617188, 899.0660400390625, 524.486328125]]

     截图的样子如下 ,下面这个表格截图看着直观些:

     做AI图像这块的,应该很容易可以看出来,这四列是有具体含义的。我这是做目标检测任务,四列分别是:

    1. 图像名
    2. 标签0 or 1 list
    3. 疑似度分数 list
    4. 目标框的坐标 list

    后面,我们看看操作过程:(不为什么目的,就学习数据的正则化)

    import pandas as pd
    import re
    import numpy as np
    
    my_csv_path = r'tb.csv'
    
    content = pd.read_csv(my_csv_path, delimiter=',', header=None, index_col=False)
    
    name = content[0].values     # 第一列,文件名
    pcls = content[1].values      # 第二列,类别
    scores = content[2].values    # 第三列,分数
    bbox = content[3].values      # 第四列,坐标
    
    # re.findall在字符串中返回正则表达式所匹配的的所有子串,并返回一个列表。如果一个都没有匹配上,则返回空列表。
    # \d 匹配字符串中的数字
    # * 重复0次或更多次  例如:35.26  35+.+26  [0-9]+.+[0-9] 真.需加\,即\.
    def cls2list(i):
        print("i:", i)
        # \d 匹配数字 [0, 0]
        cls_str = re.findall("(\d)",i)
        print("cls_str:", cls_str)
        cls_list = [float(i) for i in cls_str]
        print("cls_list:", cls_list)
        print("cls_list.type:", type(cls_list))
        return cls_list
    
    def score2list(i):
        # \d 匹配数字,真.需加\,即\.
        # 例如:[0.7710305452346802, 0.5624949932098389]  0 + . + 7710305452346802
        print("i:", i)
        score_str = re.findall("(\d*\.\d*)",i)
        print("score_str:", score_str)
        score_list = [float(i) for i in score_str]
        print("score_list:", score_list)
        print("score_list.type:", type(score_list))
        return score_list
    
    def box2list(i):
        """
        :param i: 一張圖片中文本類型的box xmin,ymin,xmax,ymax
        :return: 二維數組描述框
        """
        print(i)
        # [0-9] 匹配字符串中的所有数字
        # * 重复0次或更多次  例如:35.26  35+.+26  [0-9]+.+[0-9] 真.需加\,即\.
        box_str = re.findall("([0-9]*\.[0-9]*)", i)
        print("box_str:", box_str)
        box_list =[float(i) for i in box_str]
        print("box_list:", box_list)
        print("box_list.type:", type(box_list))
        return box_list
    
    for i in range(2):
        name_i = name[i]
        cls_i = pcls[i]
        scores_i = scores[i]
        bboxes_i = bbox[i]
    
        print(name_i, cls_i, scores_i, bboxes_i)
        print(type(name_i), type(cls_i), type(scores_i), type(bboxes_i))
    
        # 1.对cls做数据正则化  [0, 0]
        cls_i_list = cls2list(cls_i)
        print("\n")
    
        # 2.对score做数据正则化 ['0.7710305452346802', '0.5624949932098389']
        score_i_list = score2list(scores_i)
        print("\n")
    
        # 3.对bbox做数据正则化
        # [[190.70089721679688, 38.103851318359375, 450.9465637207031, 446.1026916503906],
        # [615.7803955078125, 33.51222229003906, 808.9849853515625, 279.001953125]]
        bbox_i_list = box2list(bboxes_i)
        print("\n")

    打印的结果显示如下:

    ddaae641bf2af78c1a02ba43575b0d51_3001_2849_0.1440486666667_0.1440486666667.png [0] [0.6761001944541931] [[273.28466796875, 175.67626953125, 402.2430419921875, 328.661865234375]]
    <class 'str'> <class 'str'> <class 'str'> <class 'str'>
    i: [0]
    cls_str: ['0']
    cls_list: [0.0]
    cls_list.type: <class 'list'>
    
    
    i: [0.6761001944541931]
    score_str: ['0.6761001944541931']
    score_list: [0.6761001944541931]
    score_list.type: <class 'list'>
    
    
    [[273.28466796875, 175.67626953125, 402.2430419921875, 328.661865234375]]
    box_str: ['273.28466796875', '175.67626953125', '402.2430419921875', '328.661865234375']
    box_list: [273.28466796875, 175.67626953125, 402.2430419921875, 328.661865234375]
    box_list.type: <class 'list'>
    
    
    2.25.136083661060415706315254052090742684427_4000_3000_0_0.png [0, 0] [0.7710305452346802, 0.5624949932098389] [[190.70089721679688, 38.103851318359375, 450.9465637207031, 446.1026916503906], [615.7803955078125, 33.51222229003906, 808.9849853515625, 279.001953125]]
    <class 'str'> <class 'str'> <class 'str'> <class 'str'>
    i: [0, 0]
    cls_str: ['0', '0']
    cls_list: [0.0, 0.0]
    cls_list.type: <class 'list'>
    
    
    i: [0.7710305452346802, 0.5624949932098389]
    score_str: ['0.7710305452346802', '0.5624949932098389']
    score_list: [0.7710305452346802, 0.5624949932098389]
    score_list.type: <class 'list'>
    
    
    [[190.70089721679688, 38.103851318359375, 450.9465637207031, 446.1026916503906], [615.7803955078125, 33.51222229003906, 808.9849853515625, 279.001953125]]
    box_str: ['190.70089721679688', '38.103851318359375', '450.9465637207031', '446.1026916503906', '615.7803955078125', '33.51222229003906', '808.9849853515625', '279.001953125']
    box_list: [190.70089721679688, 38.103851318359375, 450.9465637207031, 446.1026916503906, 615.7803955078125, 33.51222229003906, 808.9849853515625, 279.001953125]
    box_list.type: <class 'list'>
    
    补充:取整数:value = re.findall("(\d+)", contour_value)    例如:“563,849,698”  
    补充:整数或小数,lineArr = re.findall('\d+\.*\d*', contour_value)    例如:56,98,53.635,1296.36598
    
    备注:\d+ 不配小数点前面的
         \.就是.  \.*表示可以匹配0次或多次.   \d*匹配小数点后面的

    看明白上面代码里面的注释了吗?思路和过程都打印了出来。

    re.findall 在字符串中返回正则表达式所匹配的的所有子串,并返回一个列表。如果一个都没有匹配上,则返回空列表。

    1. 类, [0, 0],单个的数字,用 \d 来做数字匹配。就可以全取出来了,正则表达式为:(\d)
    2. 疑似度分数,[0.984,0.765],拆分来看,是由数字和.(点)组成的,通俗点就是:0 + . + 984,正则表达式为:(\d*\.\d*)
    3. 坐标框,[[273.28466796875, 175.67626953125, 402.2430419921875, 328.661865234375]],拆分来看,是由273 + . +28466796875,正则表达式为:([0-9]*\.[0-9]*),[0-9] 表示匹配字符串中的0-9所有数字,*为多次,\. 就表示为.,后面重复

    这就是正则表达式的入门,为有些明白正则表达式其中的内涵了。emeditor文档编辑软件里面,就可以直接在上面进行正则化匹配,方便验证。

    后面继续学习,将继续分享到这里。喜欢和感兴趣的,欢迎持续关注和收藏,有任何疑问的,可以在下方留言,一起交流。

    补充1:如何取出一组字符串中的数字(整数或小数)

    import re
    >>> s = '4 and 10.2356'
    >>> re.findall(r'\d+(?:\.\d+)?', s)
    ['4', '10.2356']
    >>> print(int(re.findall(r'\d+(?:\.\d+)?', s)[0]))
    4
    >>> print(float(re.findall(r'\d+(?:\.\d+)?', s)[1]))
    10.2356
    
    • \d+: matches one or more digits.
    • \d+.\d+ :matches one or more digits plus any single character plus one or more digits.
    • \d+.\d+ :matches one or more digit characters pus a literal dot plus one or more digits.
    • \d+(?:.\d+)? :matches integer as well as floating point numbers because we made the pattern which matches the decimal part as optional. ? after a capturing or non-capturing group would turn the whole group to an optional one.

    原文链接:https://blog.csdn.net/irober/article/details/107091418

    补充二:字符补全

    任务:只知道前面,或者中间的字符,想要匹配所有的字符

    def re_name(raw_string, cop_string):
        findword = cop_string+r'.\d*'  # 取该字符串以及其后面任意多个数字字符
        pattern = re.compile(findword)
        results = re.findall(pattern, raw_string)
        print(results)
        return results
    
    temp = '1235_5_5, 1235_5_61, 123_5_6,1298'
    re_name(temp, cop_string='1235_5_')

    输出打印结果:

    ['1235_5_5', '1235_5_61']

    其他类似补充:

    def re_name(raw_string, cop_string):
        findword = cop_string+r'.{2}'  # 取该字符串以及其后面2个字符数据
        pattern = re.compile(findword)
        results = re.findall(pattern, raw_string)
        print(results)
    
    temp = '1235_5_5, 1235_5_61, 1235_5_623, 1298'
    re_name(temp, cop_string='1235_5_')
    
    output:
    ['1235_5_5,', '1235_5_61', '1235_5_62']
    
    #######################################################################
    
    def re_name(raw_string, cop_string):
        findword = r'.{1}' + cop_string+r'.{2}'  # 取该字符串以及其后面2个字符数据
        pattern = re.compile(findword)
        results = re.findall(pattern, raw_string)
        print(results)
    
    temp = '1235_5_5, 1235_5_61, 1235_5_623, 1298'
    re_name(temp, cop_string='35_5_')
    
    output:
    ['235_5_5,', '235_5_61', '235_5_62']
    
    #######################################################################
    
    def re_name(raw_string, cop_string):
        findword = cop_string + r'.\d?_\d?_\d?_\d?'  # _2103845659_4_6_1_5.png
        pattern = re.compile(findword)
        results = re.findall(pattern, raw_string)
        print(results)
        return results
    
    temp = '1235_5_5_2_1_1, 1235_5_61_6_3_6, 123_5_6_5, 1298'
    re_name(temp, cop_string='1235_5_')
    
    output:
    ['1235_5_5_2_1_1', '1235_5_61_6_3_6']
    

    参考地址:在Python中使用正则re查找特定字符串、去除重复数据、取固定格式的特定字符串_小白_努力-CSDN博客https://blog.csdn.net/laobai1015/article/details/88541055

     Python用re正则匹配处理字符_u011412768的博客-CSDN博客https://blog.csdn.net/u011412768/article/details/109559870

    展开全文
  • 我们试着用正则化分类数据,不过除了应用正则化以外,如果能通过比较过拟合时图的状态和应用了正则化后图的状态,具体总结出正则化对模型施加了什么样的影响就更好了。 我们先构造一个函数 我们造一些向这个g(x)...
  • 正则化方法及Python实现

    千次阅读 2020-12-28 23:41:38
    正则化有助于克服过度拟合模型的问题。过度拟合是偏差和方差平衡的概念。如果过度拟合,机器学习模型将具有较低的准确性。...不同的正则化技术:L1和L2正则化Dropout数据增强提前停止(Early stoppi...
  • 为了解决神经网络过拟合问题,相较于添加数据量的难度于开销,正则化应是我们的首选方法。本实验利用Python,分别实现了L2正则化和dropout两种方法。 L2正则化 L2正则化是解决过拟合的常用方法之一。 实现L2正则化...
  • 1、归一(Normalization): 1.1 归一概念与作用 1)概念: 将一列数据变化到某个固定区间(范围)中,通常,这个区间是[0, 1],广义的讲,可以是各种区间,比如映射到[0,1]一样可以继续映射到其他范围,图像...
  • 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 = ...
  • 一、什么是正则化,用来干嘛的? 正则化(regularization),是指在线性代数理论中,不适定问题通常是由一组线性代数方程定义的,而且这组方程组通常来源于有着很大的条件数的不适定反问题。大条件数意味着舍入误差或...
  • from paddle.vision.transforms import Compose, Normalize transform = Compose([Normalize(mean=[127.5],std=[127.5],data_format='CHW')]) # 使用transform对数据集做归一 print('下载并加载训练数据') train_...
  • 也就是说,使用L1正则化的神经元最后使用的是它们最重要的输入数据的稀疏子集,同时对于噪音输入则几乎是不变的了。相较L1正则化,L2正则化中的权重向量大多是分散的小数字。 在实践中,如果不是特别关注某些明确的...
  • 正则化处理

    2020-12-23 06:35:51
    过拟合过拟合本质上是模型太过复杂,复杂到消弱了模型的泛化...正则化正则化是用于抑制过拟合方法的统称,通过动态调整模型参数的取值 来降低模型的复杂度。这是因为当一些参数的取值足够小时,参数对应的属性对结...
  • 正则化(L1正则化、L2参数正则化)L1范数正则化L2参数正则化 正则化是机器学习中通过显式的控制模型复杂度来避免模型过拟合、确保泛化能力的一种有效方式。 L1范数正则化 L1范数正则化( L1 regularization 或 ...
  • 正则化主要是在定义优化器的时候使用 改变的地方放在这里 LR = 0.5 # 定义模型 model = Net() # 定义代价函数 mse_loss = nn.CrossEntropyLoss() # 定义优化器,设置L2正则化 ''' 只需要改这个地方就可以了 ''' ...
  •  今天算是复习了一下正则化吧,主要也是这个在实习面试中也经常会被问到(一直想系统的记录下找实习的面试的坎坷历程,也记录下被问到的问题,方便后面再面试复习,但一直懒,这周我会完成吧?)  言归正传,废话...
  • 四、为什么正则化能够防止过拟合?4.2 为什么L1正则具有稀疏性或者说L1正则能够进行特征选择?4.2.1 从解空间的形状角度来看例子(二维)4.3 L1正则和L2正则的区别 一、什么是过拟合? 过拟合与欠拟合问题 过拟合...
  • 在看完大佬们写的几篇很有启示的文章后,链接:机器学习中常常提到的正则化到底是什么意思?​www.zhihu.comElasticNet回归及机器学习正则化_人工智能_曾时明月-CSDN博客​blog.csdn.net以下为个人对正则化...
  • 正则化的通俗理解

    2021-11-05 15:12:18
    一直很好奇,模式识别理论中,常提到的正则化到底是干什么的?在这里真心感谢 迷雾forest 那么费脑组织语言、那么费卡路里打字、那么有责任心的分享! 正则化正则化的目的:防止过拟合! 正则化的本质:约束...
  • tf.reduce_mean(tf.square(y_ - y)) + tf.contrib.layers.l2_regularizer(λ)(w) loss为定义的损失函数,它由两个部分组成,第一个部分是均方误差损失函数,它刻画了模型在训练数据上的表现,第二个部分就是正则化,...
  • 数据增强3.L2正则化4.L1 正则化5.L1和L2正则化的对比5.1 L1和L2正则化防止过拟合原因5.2 L1使得权值稀疏原因6.Dropout7.Drop Connect8. 最大约束范式9.基于优化过程的正则化:早停法10.基于函数模型的正则化10.1 ...
  • (本文会不断补充)正则化方法:防止过拟合,提高泛化能力在训练数据不够多时,或者overtraining时,常常会导致overfitting(过拟合)。其直观的表现如下图所示,随着训练过程的进行,模型复杂度增加,在training data上...
  • 正则化技术总结

    2021-08-20 00:06:44
    正则化方法总结概念正则化方法L2-NormL1-NormDropout思考 概念 过拟合与正则化 在机器学习里,使用少量样本去拟合了所有没见过的样本, 我们叫这种现象为“过拟合”。另外,我们训练模型的数据不可避免的存在一些测量...
  • 网络正则化

    2020-12-24 22:35:15
    网络正则化L2正则化L1正则化最大范数约束随机失活验证集的使用总结 机器学习的一个核心问题就是如何使学习算法[learning algorithm],不仅能在训练样本上表现良好,并且在新数据或测试集上同样奏效,学习算法在新数据...
  • 机器学习中L1正则化和L2正则化是什么?区别是什么? 我们所说的正则化,就是在原来的loss function的基础上,加上了一些正则化项或者称为模型复杂度惩罚项。 结构风险最小化: 在经验风险最小化的基础上(也...
  • 正则化方法小结

    2021-12-06 01:18:54
    点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达阅读目录LP范数L1范数L2范数L1范数和L2范数的区别DropoutBatch Normalization归一、标...
  • 深度学习离不开梯度下降: (1) 优化器也是做上述公式。 正则化: ...在下图中,虽然绿线完美的匹配训练数据,但太过依赖,并且与黑线相比,对于新的测试数据上会具有更高...正则化在损失函数中引入模型复杂度指标..
  • loss正则化

    2021-07-27 19:48:47
    tensorflow2 正则化主要是防止过拟合,用标准写法
  • 为了避免过拟合,最常用的一种方法是使用使用正则化,例如 L1 和 L2 正则化。但是,正则化项是如何得来的?其背后的数学原理是什么?L1 正则化和 L2 正则化之间有何区别?本文将给出直观的解释。 在机器学习和深度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 306,099
精华内容 122,439
关键字:

数据正则化