程序员经验分享-hwhale

回归分析及实际案例：预测鲍鱼年龄

2023-11-16

上一篇文章：线性回归（Linear regression）算法

引入：

 1、线性回归：

算法的优点：

 结果易于理解，计算不复杂

缺点：对非线性数据拟合不好

目标：平方误差和最小

 求解（对参数w求导等于0）的回归系数：

模型预测：

f(x)=W^{T}X

"""
函数说明:标准回归

Parameters:
    xArr - 特征矩阵
    yArr -响应值


Returns:
     ws- 回归系数

Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2020-01-10
"""   
def standRegres(xArr,yArr):
    xMat = mat(xArr); yMat = mat(yArr).T
    xTx = xMat.T*xMat#计算xTx
    if linalg.det(xTx) == 0.0:#判断行列式是否为0
        print("This matrix is singular, cannot do inverse")
        return
    ws = xTx.I * (xMat.T*yMat)#计算回归系数
    return ws

注意行列式不为零才可以计算逆矩阵

#加载测试数据 

from numpy import *

def loadDataSet(fileName):      #general function to parse tab -delimited floats
    numFeat = len(open(fileName).readline().split('\t')) - 1 #get number of fields 
    dataMat = []; labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr =[]
        curLine = line.strip().split('\t')
        for i in range(numFeat):
            lineArr.append(float(curLine[i]))
        dataMat.append(lineArr)
        labelMat.append(float(curLine[-1]))
    return dataMat,labelMat

数据描述：

特征：2，响应:数值型

使用线性回归预测数据并绘制散点图+计算模型的效果（相关系数计算）

 ##测试线性回归
 xArr,yArr=loadDataSet('ex0.txt')
 xArr[0:2]
 ws=standRegres(xArr,yArr)#计算回归系数
 xMat=mat(xArr)
 yMat=mat(yArr)
 #绘散点图
 import matplotlib.pyplot as plt
 fig=plt.figure()
 ax=fig.add_subplot(111)
 ax.scatter(xMat[:,1].flatten().A[0],yMat.T[:,0].flatten().A[0])#.A转变为数组
 xCopy=xMat.copy()
 xCopy.sort(0)#维度，行排序
 yHat=xCopy*ws
 ax.plot(xCopy[:,1],yHat)
 plt.show
 #求预测值和真实值的相关系数
 yHat1=xMat*ws
 corrcoef(yHat1.T,yMat)

2、局部加权线性回归

Locally Weighted Linear Regression， LWLR
线性回归存在的问题是：出现欠拟合

解决方法：在估计中引入偏差，从而降低预测的均方误差

   也即是通过在每一小段进行拟合，以逼近真实的数据

局部加权线性回归相比普通线性回归的问题是：每次必须在整个数据集上运行，也即是必须要保存所有的训练数据

思路：在待预测点附近的每个点赋予一定的权重

求解的回归系数：

对比线性回归：

其中的W矩阵用于给每个数据点赋予权重

权重W的选择，通过使用不同的核：

例如高斯核

需要调节的参数：一个 k

#对单点估计

"""
函数说明:局部加权线性回归

Parameters:
    testPoint x空间的任意一点
    xArr - 特征矩阵
    yArr -响应值
    k 和权重有关，当k越小则使用的越少的局部数据集进行训练，k=1相当于标准线性回归

Returns:
    某个点的预测结果  testPoint * ws - 

Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2020-01-10
"""   
def lwlr(testPoint,xArr,yArr,k=1.0):
    xMat = mat(xArr); yMat = mat(yArr).T
    m = shape(xMat)[0]
    weights = mat(eye((m)))#定义一个权值矩阵
    for j in range(m):                      #next 2 lines create weights matrix
        diffMat = testPoint - xMat[j,:]     #x-x[i]
        weights[j,j] = exp(diffMat*diffMat.T/(-2.0*k**2))
    xTx = xMat.T * (weights * xMat)
    if linalg.det(xTx) == 0.0:
        print("This matrix is singular, cannot do inverse")
        return
    ws = xTx.I * (xMat.T * (weights * yMat))#计算回归系数
    return testPoint * ws

#对多点（数据集）估计

"""
函数说明:为数据集中的每个点调用lwlr
  
Parameters:
    testArr 测试的数据集
    xArr - 特征矩阵
    yArr -响应值
    k

Returns:
     testPoint * ws - 

Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2020-01-10
"""  
def lwlrTest(testArr,xArr,yArr,k=1.0):  #loops over all the data points and applies lwlr to each one
    m = shape(testArr)[0]
    yHat = zeros(m)
    for i in range(m):
        yHat[i] = lwlr(testArr[i],xArr,yArr,k)#要使用之前的数据集参与预测
    return yHat

对数据进行预测+绘制散点图

 ##测试局部加权线性回归
 xArr,yArr=loadDataSet('ex0.txt')
 #对单点估计
 yArr[0]
 lwlr(xArr[0],xArr,yArr,1.0)
 lwlr(xArr[0],xArr,yArr,0.001)
 #数据集中所有点的估计
 yHat=lwlrTest(xArr,xArr,yArr,0.01)
 #绘制散点图
 xMat=mat(xArr)
 srtInd=xMat[:,1].argsort(0)
 xSort=xMat[srtInd][:,0,:] #等价于xMat[srtInd.flatten().A[0]]
 import matplotlib.pyplot as plt
 fig=plt.figure()
 ax=fig.add_subplot(111)
 ax.plot(xSort[:,1],yHat[srtInd])#拟合曲线
 ax.scatter(xMat[:,1].flatten().A[0],mat(yArr).T.flatten().A[0],s=2,c='red')#.A转变为数组
 plt.show()

设置参数k值为0.01

问题：

数据的特征比样本点多时，计算矩阵的(XTX)的逆出错，也即是输入数据（特征）矩阵不是满秩的矩阵

或者是数据特征之间是高度相关时也不能计算

如何减少特征数，如何减少不重要的特征？

解决方法：缩减系数

1）岭回归

2）lasso

3）LAR

4）PCA回归

5）子集选择

1）岭回归

X^{T}X的基础上加\lambda I使得矩阵非奇异，从而能对X^{T}X+\lambda I求逆

求解的回归系数：

对比标准线性回归：

选择的参数：\lambda    可通过交叉验证确定

注意：数据需要先标准化处理（X-mean）/var

"""
函数说明：岭回归
  
Parameters:
    xMat- 数据的特征 假设有n 样本个数有m
    yMat- 响应值
    lam-- 调节的参数
Returns:
     ws-- 计算出的回归系数
Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2020-01-10
"""  
def ridgeRegres(xMat,yMat,lam=0.2):
    xTx = xMat.T*xMat#2*2   n*n
    denom = xTx + eye(shape(xMat)[1])*lam#n*n
    if linalg.det(denom) == 0.0:
        print("This matrix is singular, cannot do inverse")
        return
    ws = denom.I * (xMat.T*yMat)
    return ws
"""
函数说明：岭回归参数lambda调节
  
Parameters:
    xArr- 特征矩阵
    yArr- 响应值

Returns:
    wMat - 返回一组w（维数和特征数对应）系数
Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2020-01-10
"""  
def ridgeTest(xArr,yArr):
    xMat = mat(xArr); yMat=mat(yArr).T
    #数据标准化处理
    yMean = mean(yMat,0)
    yMat = yMat - yMean     #to eliminate X0 take mean off of Y
    #regularize X's
    xMeans = mean(xMat,0)   #calc mean then subtract it off
    xVar = var(xMat,0)      #calc variance of Xi then divide by it
    xMat = (xMat - xMeans)/xVar
    numTestPts = 30#设置lambda参数迭代次数
    wMat = zeros((numTestPts,shape(xMat)[1]))#30*2的矩阵
    for i in range(numTestPts):
        ws = ridgeRegres(xMat,yMat,exp(i-10))
        wMat[i,:]=ws.T
    return wMat

2)lasso

对回归系数的约束：

3）前向逐步回归

每一步都尽可能的减少误差，通过设置初始权重为1，每一步所做的决策是对某个权重增加或减少一个很小的值

算法步骤：

通过多次迭代后得到趋于稳定的回归参数！ 

可调节的参数：步长和迭代次数 

"""
函数说明：前向逐步线性回归
  
Parameters:
    xArr- 特征矩阵
    yArr- 响应值
    eps=0.01  每次迭代需要调整的步长
    numIt=100 迭代次数
Returns:
    returnMat - 返回一组w（维数和特征数对应）系数
Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2020-01-11
"""  
def stageWise(xArr,yArr,eps=0.01,numIt=100):
    xMat = mat(xArr); yMat=mat(yArr).T
    #数据的标准化
    yMean = mean(yMat,0)
    yMat = yMat - yMean     #can also regularize ys but will get smaller coef
    xMat = regularize(xMat)
    m,n=shape(xMat)
    returnMat = zeros((numIt,n)) #testing code remove
    ws = zeros((n,1)); wsTest = ws.copy(); wsMax = ws.copy()
    for i in range(numIt):
        print(ws.T)
        lowestError = inf; #一开始的误差设置很大
        for j in range(n):#n个特征也即是n个回归系数参与逐步回归
            for sign in [-1,1]:#有两种情况的迭代加或减
                wsTest = ws.copy()
                wsTest[j] += eps*sign#用于减去或增加步长
                yTest = xMat*wsTest
                rssE = rssError(yMat.A,yTest.A)#计算平方误差
                if rssE < lowestError:
                    lowestError = rssE
                    wsMax = wsTest#找到具有最小误差的回归系数
        ws = wsMax.copy()#迭代numIt次找到最小误差的回归系数
        returnMat[i,:]=ws.T
    return returnMat

 案例1：预测鲍鱼年龄

问题出发点是：鲍鱼的年龄是通过贝壳的年轮计数确定，此方法耗时费力，如何依据其它的一些参数来推测鲍鱼的年龄？

数据集来源：UCI Machine Learning Repository: Abalone Data Set

数据集的描述：

上述的数据集给出的8个特征属性

Name / Data Type / Measurement Unit / Description 
----------------------------- 
Sex / nominal / -- / M, F, and I (infant) 
Length / continuous / mm / Longest shell measurement 
Diameter / continuous / mm / perpendicular to length 
Height / continuous / mm / with meat in shell 
Whole weight / continuous / grams / whole abalone 
Shucked weight / continuous / grams / weight of meat 
Viscera weight / continuous / grams / gut weight (after bleeding) 
Shell weight / continuous / grams / after being dried 

响应值：

构建模型预测

1）使用标准线性回归模型预测鲍鱼年龄

 ##使用标准线性回归模型
 ws=standRegres(abX[0:99],abY[0:99])
 yHat=mat(abX[100:199])*ws
 rssError(abY[100:199],yHat.T.A)

    新数据上表现平方误差=518.6 

2）使用局部线性加权线性回归模型预测鲍鱼年龄

 ##使用局部加权线性回归
 abX,abY=loadDataSet('abalone.txt')
 yHat01=lwlrTest(abX[0:99],abX[0:99],abY[0:99],0.1)
 yHat1=lwlrTest(abX[0:99],abX[0:99],abY[0:99],1)
 yHat10=lwlrTest(abX[0:99],abX[0:99],abY[0:99],10)
 #平方误差和
 rssError(abY[0:99],yHat01.T)
 rssError(abY[0:99],yHat1.T)
 rssError(abY[0:99],yHat10.T)
 #测试集表现
 yHat01=lwlrTest(abX[100:199],abX[100:199],abY[100:199],0.1)
 yHat1=lwlrTest(abX[100:199],abX[100:199],abY[100:199],1)
 yHat10=lwlrTest(abX[100:199],abX[100:199],abY[100:199],10)
 x1=rssError(abY[100:199],yHat01.T)
 print(x1)
 x2=rssError(abY[100:199],yHat1.T)
 print(x2)
 x3=rssError(abY[100:199],yHat10.T)
 print(x3)

在不同的参数k下的效果，以及在训练集和测试集上的表现：

平方误差结果：

训练集下：

测试集下：

在未知数据上比较效果才可以很好的选择模型，10折交叉验证

3）岭回归模型预测鲍鱼年龄

 ##使用岭回归
 abX,abY=loadDataSet('abalone.txt')
 ridgeWeights=ridgeTest(abX,abY)#得到不同lambda下计算出的回归系数
 #绘制回归系数
 import matplotlib.pyplot as plt
 fig=plt.figure()
 ax=fig.add_subplot(111)
 ax.plot(ridgeWeights)
 plt.show()

横坐标为lambda值，y轴为各回归系数 

通过上图看看出哪些变量对结果的预测具有影响力

为定量找到最佳参数值lambda，需要进行交叉验证获得误差最小的lambda

使用10折交叉验证计算得出最佳的岭回归系数，参与预测新的数据

在岭回归中要求数据要标准化再参与计算，那么在训练完成后新的数据如何进行预测？这个新的数据怎么利用训练的数据进行标准化？

解决方法是：利用在训练数据中得出的回归参数，通过变换实现变相的在新数据预测时的标准化

 新的数据一般预测过程：

数据标准化：XT=（XTest-mean（XTrain））/Var(XTrain)

 预测：Ytest=XT*Ws+mean(YTrain)

将上述的公式变换：

Ytest=(（XTest-mean（XTrain））/Var(XTrain))*Ws+mean(YTrain)

设UnReg=Ws/Var(XTrain)

constantTerm=-mean（XTrain）*Ws/Var(XTrain)+mean(YTrain)

则Ytest=XTest*UnReg+constantTerm（现在的新变换后的预测过程）

###交叉验证--岭回归
ridgeWs,ridgeunReg,ridgeConstantTerm=crossValidation(abX[0:99],abY[0:99],10)#目的是找出最佳的岭回归系数
##测试均方误差
####和标准线性回归的比较
xMat=mat(abX[100:199])
yMat=mat(abY[100:199]).T
ridgeyHat=xMat*ridgeunReg.T+ridgeConstantTerm#岭回归预测
rssError(abY[100:199],ridgeyHat.T.A)#误差计算

换种写法：

###交叉验证--岭回归
ridgeWs,ridgeunReg,ridgeConstantTerm=crossValidation(abX[0:99],abY[0:99],10)#目的是找出最佳的岭回归系数
##测试均方误差
####和标准线性回归的比较
xMat=mat(abX[100:199])
yMat=mat(abY[100:199])
ridgeyHat=xMat*ridgeunReg.T+ridgeConstantTerm#岭回归预测
rssError(yMat.A,ridgeyHat.T.A)#误差计算
xxx=yMat.A
yyy=ridgeyHat.T.A

"""
函数说明：交叉验证测试岭回归
  
Parameters:
    xArr - 特征
    yArr - 标签
    numVal=10 - 交叉验证的次数

Returns: 
    bestWeights 最佳的岭回归参数
    为了和标准线性回归比较
    unReg,constantTerm 数据标准化还原后的特征参数和常量参数
Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2020-01-28
""" 
def crossValidation(xArr,yArr,numVal=10):
    m = len(yArr)#样本点个数                           
    indexList = list(range(m))
    errorMat = zeros((numVal,30))#create error mat 30columns numVal rows
    for i in range(numVal):#交叉验证
        trainX=[]; trainY=[]
        testX = []; testY = []
        random.shuffle(indexList)#随机打乱样本索引
        #训练集和测试集的划分 90%训练  10%测试
        for j in range(m):#create training set based on first 90% of values in indexList
            if j < m*0.9: 
                trainX.append(xArr[indexList[j]])
                trainY.append(yArr[indexList[j]])
            else:
                testX.append(xArr[indexList[j]])
                testY.append(yArr[indexList[j]])
        #岭回归(岭回归次数默认)
        wMat = ridgeTest(trainX,trainY)    #30*特征数 get 30 weight vectors from ridge
        #30组回归系数
        for k in range(30):#loop over all of the ridge estimates
            matTestX = mat(testX); matTrainX=mat(trainX)
            meanTrain = mean(matTrainX,0)
            varTrain = var(matTrainX,0)
            
            matTestX = (matTestX-meanTrain)/varTrain #regularize test with training params
            yEst = matTestX * mat(wMat[k,:]).T + mean(trainY)#test ridge results and store
            errorMat[i,k]=rssError(yEst.T.A,array(testY))
            #print errorMat[i,k]
    #计算所有这些误差值的均值
    meanErrors = mean(errorMat,0)#errorMat为 10*30   30个岭回归参数  10次交叉验证  按照把轴向数据求平均  得到每列数据的平均值，也即是10折交叉验证的平均   calc avg performance of the different ridge weight vectors
    
    minMean = float(min(meanErrors))#哪个岭回归参数下的误差最小
    bestWeights = wMat[nonzero(meanErrors==minMean)]#找出误差最小的回归参数
    #can unregularize to get model
    #when we regularized we wrote Xreg = (x-meanX)/var(x)
    #we can now write in terms of x not Xreg:  x*w/var(x) - meanX/var(x) +meanY
    xMat = mat(xArr); yMat=mat(yArr).T
    meanX = mean(xMat,0); varX = var(xMat,0)
    unReg = bestWeights/varX
    print("the best model from Ridge Regression is:\n",unReg)
    #标准化后数据还原
    constantTerm=-1*sum(multiply(meanX,unReg)) + mean(yMat)
    print("with constant term: ",constantTerm)
    return bestWeights,unReg,constantTerm

平方误差结果：

4）前向逐步回归模型预测鲍鱼年龄

 ##使用逐步回归
 xArr,yArr=loadDataSet('abalone.txt')
 returnMat1=stageWise(xArr,yArr,0.01,200)#出现来回震荡情况，原因是步长太大？原因是系数已经饱和需要调小系数
 #对比更小的步长
 returnMat2=stageWise(xArr,yArr,0.001,200)
 #绘制回归系数
 import matplotlib.pyplot as plt
 fig=plt.figure()
 ax=fig.add_subplot(111)
 ax.plot(returnMat2)
 plt.show()

参数：步长和迭代次数 

基于上图可以较好的发现重要特征

定量的选择模型参数：使用类似交叉验证方法

实验结果：

##数据训练
returnMat2=stageWise(xArr,yArr,0.001,5000)
###预测
####数据标准化
xMat = mat(xArr); yMat=mat(yArr).T
xMean=mean(xMat,0)
VarX=var(xMat,0)
yMean = mean(yMat,0)

Xtest=(mat(xArr[100:199])-xMean)/VarX#标准化后的测试数据
yMat=mat(yArr[100:199])#实际标签数据

Ytest=Xtest*mat(returnMat2[4999,:]).T+yMean
rssError(yMat.A,Ytest.T.A)#.A转变为数组

均方误差： 

参考：

《机器学习实战》

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

机器学习

回归

监督学习

回归分析及实际案例：预测鲍鱼年龄 的相关文章

  • Centos7.4制作简易RPM包

    准备nginx 1 10 1 tar gz 准备php 7 1 7 tar bz2 这两个源码编译tar包 1 准备制作环境 yum y install rpm build 安装rpm build软件 rpmbuild ba xx spec

  • SpringSecurity最全实战讲解

    文章目录 Spring Security 专题 一 基本概念 认证 授权 会话 RBAC模型 二 一个自己实现的权限模型 BasicAuth 三 SpringBoot Security 快速上手 1 项目搭建步骤 2 用SpringBoot

  • AIF360入门教学

    1 AIF360简介 AI Fairness 360 工具包 AIF360 是一个开源软件工具包 可以帮助检测和缓解整个AI应用程序生命周期中机器学习模型中的偏见 在整个机器学习的过程中 偏见可能存在于初始训练数据 创建分类器的算法或分类器

随机推荐

  • MessageDigest（加密）

    MessageDigest类 MessageDigest 类是一个引擎类 它是为了提供诸如 SHA1 或 MD5 等密码上安全的报文摘要功能而设计的 密码上安全的报文摘要可接受任意大小的输入 一个字节数组 并产生固定大小的输出 该输出称为一

  • 使用 Cloudflare Zero Trust 通过 SSH 连接到 GitHub Actions 的 Runner 机器以进行调试

    GitHub Actions 的 Runner Images 包含了很多常用的开发环境 使用它来构建一些软件是很方便的 不过 构建过程难免会遇到问题 而在 GitHub Actions 上进行构建和在本地有很多不同之处 首先 Runner

  • 服务器装系统都会有哪些坑,小白装机避坑——电脑装系统篇 二

    装机系统分区 首先你需要安装好你的固态硬盘 开机 进入系统 一般用的分区工具都是 DiskGenius 这个软件 粗暴的组装 不需要机箱 一台电脑里面只能设置一个盘作为系统盘 也就是我们的主分区 切记 先对硬件进行测试组装 看看能不能正常启

  • 1125 斐波那契数列

    题目描述 输入整数n 输出斐波那契数列的前n项 输入要求 输入一个整数n 1 lt n lt 12 输出要求 输出斐波那契数列的前n项 每个数后面都有空格 输入样例 6 输出样例 1 1 2 3 5 8 提示 斐波那契数列的排列规则为 第1

  • echarts legend文字颜色

    legend textStyle color fft

  • 一个有意思的let面试题

    今天看到一个面试题 let des 我在外边 let obj des 我在里面 foo function console log this des let bar obj foo bar 这个bar 调用后会打印出什么 本以为是考 this

  • 查看微信小程序的appID和secret

    https mp weixin qq com wxopen devprofile action get profile token 1504304474 lang zh CN 转载于 https www cnblogs com fuckin

  • springmvc源码学习（三十）@ControllerAdvice 全局异常处理

    目录 前言 一 示例 二 原理 前言 在请求到达了 DispatcherServlet 的处理流程 进入 doDispatch 以及后续流程处理业务的过程中出现异常 会进入到 processDispatchResult 处理异常 此时 如果

  • C++-- 如何在类外访问一个类中私有的成员变量？

    如何在类外访问一个类中私有的成员变量 我在网上搜答案的时候看到大部分回答都是在类内部创建一个接口 所以此方法我就不再多做赘述 今天我说的是利用指针 边看代码边理解 上代码 class Test private int a 10 int b

  • win32汇编语言实现冒泡排序

    1 背景 现在大多数的大规模程序并不是由汇编语言来编写 原因很简单 因为太耗时了 但是汇编语言仍然被广泛运用在配置硬件设备以及优化程序的执行速度和尺寸大小等方面 特别是在逆向工程方面 更需要深入理解与熟练掌握汇编语言 针对现阶段 看汇编基本

  • unity04 解决导入fbx文件黑模问题

    左上角window gt rendering gt lighting gt new lighting settings gt 勾选auto generating

  • TensorFlow在MNIST中的应用-卷积神经网络CNN

    参考 TensorFlow技术解析与实战 用TensorFlow搭建一个卷积神经网络CNN模型 并用来训练MNIST数据集 coding utf 8 20171115 HelloZEX 卷积神经网络

  • 【软件测试】----自动化测试详解

    自动化测试指软件测试的自动化 在预设状态下运行应用程序或者系统 预设条件包括正常和异常 最后评估运行 结果 将人为驱动的测试行为转化为机器执行的过程 常见的自动化测试工具 QTP selenium Rational Robot jmeter

  • QtDesigner设计中关于PyQt5与pyside2的报错坑

    关注公众号可获取资料分享 0 前言 Qt Designer是使用Qt部件设计和构建图形用户界面 gui 的Qt工具 您可以以 what you see is what you get WYSIWYG 的方式组合和自定义窗口或对话框 并使用不

  • JSON取值(key是中文或者数字)方式详解

    先准备一个json对象用于演示 var json name zhangsan 年龄 23 404 你可能迷路了 使用JS中with关键字 with json console log name 输出 zhangsan console log

  • 基于STM32的智能电子药盒设计

    1 前言 据报告显示中国有2 3亿的60岁以上老人 占全国总人口的六分之一 在老年人中 有65 以上的老年人都是慢性病患者 其中失能和半失能老人将近四千万 并且人口还在以加速度增长 老年人的身体健康成为社会密切关注的问题 大部分的老年人都患

  • JavaScript基本包装类型

    基本包装类型 为了便于操作基本类型值 ECMAScript还提供了3个特殊的引用类型 Boolean Number和String 这些类型与其它引用类型相似 但同时也具有与各自的基本类型相应的特殊行为 实际上 每当读取一个基本类型值的时候

  • ElasticSearch-全文检索-简单使用

    简介 https www elastic co cn what is elasticsearch 全文搜索属于最常见的需求 开源的 Elasticsearch 是目前全文搜索引擎的首选 它可以快速地储存 搜索和分析海量数据 维基百科 Sta

  • 类和对象

    一 类 类描述了一组具有相同属性和行为特征的对象 对象是类的实例 类是一种数据类型 而对象是该类型的变量 在c 语言中 一个类的定义包含数据成员和成员函数两部分内容 数据成员定义该类对象的属性 不同对象的属性值可以不同 成员函数定义了该类对

  • 回归分析及实际案例：预测鲍鱼年龄

    上一篇文章 线性回归 Linear regression 算法 引入 1 线性回归 算法的优点 结果易于理解 计算不复杂 缺点 对非线性数据拟合不好 目标 平方误差和最小 求解 对参数w求导等于0 的回归系数 模型预测 函数说明 标准回归

热门标签