机器学习：Chap1 Regression

最新推荐文章于 2024-08-30 16:54:17 发布
最新推荐文章于 2024-08-30 16:54:17 发布
阅读量187 收藏 1
点赞数 1
文章标签： 机器学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sue_Yuan/article/details/107836366
版权

Chap1_回归

梯度下降法

梯度下降法——一元线性回归

import numpy as np
import matplotlib.pyplot as plt

# 载入数据
data = np.genfromtxt("data.csv", delimiter=",")
# 切分数据
x_data = data[:,0]
y_data = data[:,1]
# 绘制散点图
plt.scatter(x_data,y_data)
plt.show()

# 建模
# 学习率learning rate
lr = 0.0001
# 截距
b = 0 
# 斜率
k = 0 
# 最大迭代次数
epochs = 50

# 最小二乘法-定义代价函数
def compute_error(b, k, x_data, y_data):
    totalError = 0
    for i in range(0, len(x_data)):
        totalError += (y_data[i] - (k * x_data[i] + b)) ** 2
    return totalError/float(len(x_data))/2.0

# 梯度下降
def gradient_descent_runner(x_data, y_data, b, k, lr, epochs):
    # 计算总数据量
    m = float(len(x_data))
    # 循环epochs次
    for i in range(epochs):
        b_grad = 0
        k_grad = 0
        # 计算梯度的总和再求平均
        for j in range(0, len(x_data)):
            b_grad += (1/m) * (((k * x_data[j]) + b) - y_data[j])
            k_grad += (1/m) * x_data[j] * (((k * x_data[j]) + b) - y_data[j])
        # 更新b和k
        b = b - (lr * b_grad)
        k = k - (lr * k_grad)
        # 每迭代5次，输出一次图像
        if i % 5==0:
            print("epochs:",i)
            plt.plot(x_data, y_data, 'b.')
            plt.plot(x_data, k*x_data + b, 'r')
            plt.show()
    return b, k

# 计算
print("Starting b = {0}, k = {1}, error = {2}".format(b, k, compute_error(b, k, x_data, y_data)))
print("Running...")
b, k = gradient_descent_runner(x_data, y_data, b, k, lr, epochs)
print("After {0} iterations b = {1}, k = {2}, error = {3}".format(epochs, b, k, compute_error(b, k, x_data, y_data)))

# 画图（最后结果）
plt.plot(x_data, y_data, 'b.')
plt.plot(x_data, k*x_data + b, 'r')
plt.show()

梯度下降法——多元线性回归

import numpy as np
import matplotlib.pyplot as plt

# 读入数据 
data = np.genfromtxt("Delivery.csv",delimiter=',')
print(data)
# 切分数据
x_data = data[:,:-1] 
y_data = data[:,-1]
print(x_data)
print(y_data)

# 建模
# 学习率learning rate
lr = 0.0001
# 参数
theta0 = 0
theta1 = 0
theta2 = 0
# 最大迭代次数
epochs = 1000

# 计算误差
def compute_error(theta0, theta1, theta2, x_data, y_data):
    totalError = 0
    for i in range(0, len(x_data)):
        totalError += (y_data[i] - (theta1 * x_data[i,0] + theta2*x_data[i,1] + theta0)) ** 2
    return totalError / float(len(x_data))
    
# 梯度下降
def gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs):
    # 计算总数据量
    m = float(len(x_data))
    # 循环epochs次
    for i in range(epochs):
        theta0_grad = 0
        theta1_grad = 0
        theta2_grad = 0
        # 计算梯度的总和再求平均
        for j in range(0, len(x_data)):
            theta0_grad += (1/m) * ((theta1 * x_data[j,0] + theta2*x_data[j,1] + theta0) - y_data[j])
            theta1_grad += (1/m) * x_data[j,0] * ((theta1 * x_data[j,0] + theta2*x_data[j,1] + theta0) - y_data[j])
            theta2_grad += (1/m) * x_data[j,1] * ((theta1 * x_data[j,0] + theta2*x_data[j,1] + theta0) - y_data[j])
        # 更新b和k
        theta0 = theta0 - (lr*theta0_grad)
        theta1 = theta1 - (lr*theta1_grad)
        theta2 = theta2 - (lr*theta2_grad)
    return theta0, theta1, theta2

# 计算
print("Starting theta0 = {0}, theta1 = {1}, theta2 = {2}, error = {3}".
      format(theta0, theta1, theta2, compute_error(theta0, theta1, theta2, x_data, y_data)))
print("Running...")
theta0, theta1, theta2 = gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs)
print("After {0} iterations theta0 = {1}, theta1 = {2}, theta2 = {3}, error = {4}".
      format(epochs, theta0, theta1, theta2, compute_error(theta0, theta1, theta2, x_data, y_data)))

sklearn

sklearn——一元线性回归

from sklearn.linear_model import LinearRegression
import numpy as np
import matplotlib.pyplot as plt

# 载入数据
data = np.genfromtxt("data.csv", delimiter=",")
x_data = data[:,0]
y_data = data[:,1]
plt.scatter(x_data,y_data)
plt.show()
print(x_data.shape) #展示x_data的维度（100个一维数据）
print(y_data.shape) #展示y_data的维度（100个一维数据）

x_data = data[:,0,np.newaxis] #给x_data添加一个维度
y_data = data[:,1,np.newaxis] #给y_data添加一个维度
print(x_data.shape)
print(y_data.shape)

# 创建并训练模型
model = LinearRegression()  
model.fit(x_data, y_data)

print(model.coef_)
print(model.intercept_ )
model.score(x_data, y_data) # R^2

# 画图
plt.plot(x_data, y_data, 'b.')
plt.plot(x_data, model.predict(x_data), 'r')
#plt.plot(x_data,1.32243102 * x_data + 7.99102098, 'r')
plt.show()

sklearn——多元线性回归

import numpy as np
from sklearn import linear_model

# 读入数据 
data = np.genfromtxt("Delivery.csv",delimiter=',')
x_data = data[:,:-1]
y_data = data[:,-1]
print(x_data)
print(y_data)

# 创建模型
model = linear_model.LinearRegression()
model.fit(x_data, y_data)
print(model.coef_)
print(model.intercept_)
print(model.score(x_data,y_data))

# 预测
predict = model.predict(x_data)
print(predict)

x_test = [[102,4]]
predict = model.predict(x_test)
print("predict:",predict)

特征缩放

特征缩放的目的是让每个特征在建模过程中发挥同等重要的作用

min-max标准化

x ∗ = x − m i n m a x − m i n ∈ [ 0 , 1 ] x^* = \frac{x-min}{max-min} \in [0,1] x∗=max−minx−min​∈[0,1]

Z-score标准化

x ∗ = x − μ σ x^* = \frac{x-\mu}{\sigma} x∗=σx−μ​

交叉验证

数据样本非常少

在这里插入图片描述

过拟合与正则化

underfitting  欠拟合
overfitting  过拟合：过分追求精度，使得样本残差平方和尽量地小，而去覆盖（拟合）样本中较异常的数据

防止过拟合

1.减少特征
2.增加数据量
3.正则化（regularized）

正则化

L1正则化：

J ( θ ) = 1 2 m [ ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ j = 1 n ∣ θ j ∣ ] J(\theta)=\frac{1}{2m} [\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}|\theta_j|] J(θ)=2m1​[∑i=1m​(hθ​(x(i))−y(i))2+λ∑j=1n​∣θj​∣]

L2正则化：

J ( θ ) = 1 2 m [ ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ j = 1 n θ j 2 ] J(\theta)=\frac{1}{2m} [\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}\theta^2_j] J(θ)=2m1​[∑i=1m​(hθ​(x(i))−y(i))2+λ∑j=1n​θj2​]

岭回归、LASSO、弹性网

岭回归（ridge regression）

1.处理特征数多于样本的情况
2.用于在估计中加入偏差，从而得到更好的估计
3.解决多重共线性问题

岭回归代价函数

J ( θ ) = 1 2 m [ ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ j = 1 n θ j 2 ] J(\theta)=\frac{1}{2m} [\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}\theta^2_j] J(θ)=2m1​[∑i=1m​(hθ​(x(i))−y(i))2+λ∑j=1n​θj2​]

L2正则项

岭系数

λ ∈ [ 0 , 1 ] \lambda \in[0,1] λ∈[0,1]

1.各回归系数的岭估计基本稳定
2.残差平方和增大不太多

岭系数越大， θ j \theta_j θj​越小
在这里插入图片描述

LASSO

1.多重共线性问题
2.岭回归估计系数等于0的机会微乎其微，造成筛选变量困难

LASSO代价函数

J ( θ ) = 1 2 m [ ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ j = 1 n ∣ θ j ∣ ] J(\theta)=\frac{1}{2m} [\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}|\theta_j|] J(θ)=2m1​[∑i=1m​(hθ​(x(i))−y(i))2+λ∑j=1n​∣θj​∣]

L1正则项

LASSO与岭回归

在这里插入图片描述
λ \lambda λ限制 ∑ j = 1 n θ j 2 ≤ t \sum_{j=1}^{n}\theta_j^2≤t ∑j=1n​θj2​≤t
λ \lambda λ限制 ∑ j = 1 n ∣ θ j ∣ ≤ t \sum_{j=1}^{n}|\theta_j|≤t ∑j=1n​∣θj​∣≤t
在这里插入图片描述

LASSO倾向于使个别参数为0  （降维）

弹性网（elastic net）

结合岭回归和LASSO

弹性网代价函数

J ( θ ) = 1 2 m [ ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ j = 1 n ( α θ j 2 + ( 1 − α ) ∣ θ j ∣ ) ] J(\theta)=\frac{1}{2m} [\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}(\alpha\theta^2_j+(1-\alpha)|\theta_j|)] J(θ)=2m1​[∑i=1m​(hθ​(x(i))−y(i))2+λ∑j=1n​(αθj2​+(1−α)∣θj​∣)]

sklearn实现–岭回归

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

# 读入数据 
data = np.genfromtxt("longley.csv",delimiter=',')
print(data)

# 切分数据
x_data = data[1:,2:]
y_data = data[1:,1]
print(x_data)
print(y_data)

# 生成50个alpha值
alphas_to_test = np.linspace(0.001, 1)  #默认num为50
print(alphas_to_test)

# 建模
# 创建模型，保存误差值
model = linear_model.RidgeCV(alphas=alphas_to_test, store_cv_values=True)
model.fit(x_data, y_data)

# 打印最佳岭系数、交叉验证误差、系数
print(model.alpha_)
print(model.cv_values_)
print(model.cv_values_.shape)
print(model.coef_)
print(model.intercept_)

# 可视化
# 岭系数跟loss值的关系
plt.plot(alphas_to_test, model.cv_values_.mean(axis=0))
# 选取的最佳岭系数值的位置
plt.plot(model.alpha_, min(model.cv_values_.mean(axis=0)),'ro')
plt.show()
print(min(model.cv_values_.mean(axis=0))) #打印最小测试误差
print(model.score(x_data, y_data))

# 预测
model.predict(x_data[2,np.newaxis]) #将x_data从一维数据变成二维数据
predect_result = model.predict(x_data)
print(predect_result)
sum(abs(predect_result - y_data))/len(y_data) #计算训练误差

sklearn实现–LASSO

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

# 读入数据 
data = np.genfromtxt("longley.csv",delimiter=',')
print(data)

# 切分数据
x_data = data[1:,2:]
y_data = data[1:,1]
print(x_data)
print(y_data)

# 建模
# 创建模型（默认尝试100个不同的alpha值）
model = linear_model.LassoCV()  # 默认分五组
model.fit(x_data,y_data)

# lasso系数
print(model.alpha_)
print(model.coef_)
print(model.intercept_)

print(model.mse_path_.shape) #打印误差矩阵的形状
print(min(model.mse_path_.mean(axis=1)))#打印最小误差值
print(model.score(x_data, y_data)) # R^2

# 可视化
# alpha跟loss值的关系
plt.plot(model.alphas_, model.mse_path_.mean(axis=1))
# 选取的岭系数值的位置
plt.plot(model.alpha_, min(model.mse_path_.mean(axis=1)),'ro')
plt.show()

# 预测
model.predict(x_data[-2,np.newaxis])# 预测输入需为2维
predect_result = model.predict(x_data)
sum(abs(predect_result - y_data))/len(y_data)  #计算训练误差

sklearn实现–弹性网

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

# 读入数据 
data = np.genfromtxt("longley.csv",delimiter=',')
print(data)

# 切分数据
x_data = data[1:,2:]
y_data = data[1:,1]
print(x_data)
print(y_data)

# 建模
model = linear_model.ElasticNetCV()
model.fit(x_data, y_data)
# 弹性网系数
print(model.alpha_)
# 相关系数
print(model.coef_)
print(model.intercept_)
print(model.score(x_data, y_data))

print(model.mse_path_.shape) #打印误差矩阵的形状
print(model.mse_path_.mean(axis=1))
print(min(model.mse_path_.mean(axis=1)))#打印最小测试误差值

# 可视化
# alpha跟loss值的关系
plt.plot(model.alphas_, model.mse_path_.mean(axis=1))
# 选取的岭系数值的位置
plt.plot(model.alpha_, min(model.mse_path_.mean(axis=1)),'ro')
plt.show()

# 预测
model.predict(x_data[-2,np.newaxis])
predect_result = model.predict(x_data)
sum(abs(predect_result - y_data))/len(y_data)  #打印训练误差
Sue_Yuan
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
机器学习实战—— Chap08.Regression
Ivan Zhang的博客
12-13 245
Linear Regression import matplotlib.pyplot as plt import numpy as np """ Desc: 加载数据 Parameters: filename - 文件名 Returns: xArr - x数据集 yArr - y数据集 """ def loadDataSet(filename): ...
【邱希鹏】nndl-chap2-linear_regression
豆子
07-11 3370
线性回归 问题描述 有一个函数 ，使得。现 在不知道函数 \(f(\cdot)\)的具体形式，给定满足函数关系的一组训练样本，请使用线性回归模型拟合出函数\(y=f(x)\)。 (可尝试一种或几种不同的基函数，如多项式、高斯或sigmoid基函数) 数据集 根据某种函数关系生成的train 和test 数据。 题目要求： [ ] 按顺序完成 exercise-linear_regre...
【机器学习】回归过程中的数据标准化
热门推荐
Shwan_ma的博客
05-01 5万+
最近一直很困惑，因为有些资料在进行回归的时候，往往需要数据标准化。然而也有些资料说对于线性回归是不需要标准化。在查询了大量的资料后，准备在这篇博客上做一个总结。 为什么要数据标准化 数据标准化的原理往往是来自于独立连续变量的量纲。举一个例子，如果我们要对人口进行回归，采取“个数”的量纲和“百万个”的量纲得到的回归系数会差的相当大。而进行处理时，采取“个数”的量纲的回归系数太小。这时候便有必要需...
一天一个机器学习小知识——Lasso、Ridge以及ElasticNet
qq_43019258的博客
10-06 3408
文章目录前言一、算法推导1.1 Lasso模型1.2 Lasso策略1.3 Lasso算法2.1 Ridge模型2.2 Ridge策略2.3 Ridge算法二、应用场景三、代码实现1.导入相关库2.读取样例数据3.划分训练集和测试集4.建立模型5.评估模型四、优缺点1.优点2.缺点 前言 上一小节主要介绍了线性回归算法，并且在文章的末尾提到了它所存在的一些缺陷，事实上在线性回归的基础上稍作改进就可以很好的客服这些缺陷。因此本小节主要介绍线性回归的几个拓展模型：Lasso、Ridge以及ElasticNe
岭回归(Ridge Regression)和Lasso回归
Above the cloud
09-11 2万+
1、岭回归（Ridge Regression） 标准线性回归（简单线性回归）中： 如果想用这个式子得到回归系数，就要保证(X^TX)是一个可逆矩阵。 下面的情景：如果特征的数据比样本点还要多，数据特征n,样本个数m，如果n>m,则计算(XTX)−1会出错。因为(X^TX)不是满秩矩阵（行数小于列数），所有不可逆。 为了解决这个问题，统计学家引入了岭回归的概念： λ为岭系数, I为单位矩阵（对角线上全为1，其他元素为0）。单位矩阵为满秩矩阵，乘以λ仍然为满秩矩阵。 岭回归的代价函数： 附： 正则化
scikit-learn：回归分析——多重共线性：岭回归与Lasso
错位的梦寐的博客
10-22 3056
1.过拟合 当样本特征很多，样本数相对较少时，模型容易陷入过拟合。为了缓解过拟合问题，有两种方法： 方法一：减少特征数量（人工选择重要特征来保留，会丢弃部分信息）。 方法二：正则化（减少特征参数w ^的数量级）。 2.正则化（Regularization） 正则化是结构风险（损失函数+正则化项）最小化策略的体现，是在经验风险（平均损失函数）上加一个正则化项。正则化的作用就是选择经验风险和模型复杂度...
一元线性回归——梯度下降法
江南小帅瓜的博客
06-03 1900
梯度下降法实现一元线性回归(代码实现） 这篇博客只是针对用代码实现的部分 导入需要用到的包 import numpy as np import matplotlib.pyplot as plt 载入数据 data = np.genfromtxt("data.csv", delimiter=",") x_data = data[:, 0]#所有行第0列 y_data = data[:, 1]#所有...
ISL-Chap1&2.1笔记
KK写字的地方
01-01 318
ISL-Chap1&2.1笔记写在前面Chap1 IntroductionChap2 Statistical Learning2.1 什么是 Statistical Learning2.1.1 Why Estimate $f$2.1.1 How Do We Estimate $f$2.1.3 The Trade-Off Between Prediction Accuracy and Mod...
【邱希鹏】nndl-chap3-逻辑回归&softmax
豆子
07-14 1751
1. 逻辑回归解决二分类问题 1.1 生成数据集 '+' 从高斯分布采样 (X, Y) ~ N(3, 6, 1, 1, 0). 'o' 从高斯分布采样 (X, Y) ~ N(6, 3, 1, 1, 0) import tensorflow as tf import matplotlib.pyplot as plt from matplotlib import animat...
机器学习（10）——假设检验和回归分析
WHJ226的博客
06-26 3387
假设检验是统计推断中的一个重要内容,它是利用样本数据对某个事先做出的统计假设,按照某种设计好的方法进行检验,判断此假设是否正确。假设检验的基本思想为概率性质的反证法。为了推断总体,首先对总体的未知参数或分布做出某种假设HO(原假设),然后在HO成立的条件下若通过抽样分析发现“小概率事件”竟然在一次实验中发生了,则表明HO 很可能不成立,从而拒 绝HO;相反,若没有导致上述“不合理”现象的发生,则没有理由拒绝HO,从而接受HO。 要求“小概率事件”发生的概率小于等于某一给定的临界概率a,称a为检验的显著性水平
机器学习——回归问题(2020最新版)
沉浮于世的博客
07-28 4976
回归：从一组数据出发，确定某些变量之间的定量关系式；即建立数学模型并估计未知参数。 回归的目的是预测数值型的目标值，它的目标是接受连续数据，寻找最适合数据的方程，并能够对特定值进行预测。这个方程称为回归方程，而求回归方程显然就是求该方程的回归系数，求这些回归系数的过程就是回归。
机器学习-梯度下降法—一元线性回归
weixin_42030577的博客
04-11 398
直接上代码吧： import numpy as np import matplotlib.pyplot as plt 载入数据 用，进行切分 data = np.genfromtxt(r"G:\work\python\jupyter_notebook_work\机器学习\回归\data.csv",delimiter = “,”) print(data) 此处截取局部 [[ 32.50234527 ...
《机器学习》—— OpenCV 对图片的各种操作
weixin_73504499的博客
08-25 1554
1、安装OpenCV库、2、读取、显示、查看图片、3、对图片进行切割、4、改变图像的大小、5、图片打码、6、图片组合、7、图像运算、8、图像加权运算
深度学习实战3--GAN：基础手写数字对抗生成
最新发布
m0_63860007的博客
08-30 447
生成器 G 是创造者，负责生成新的数据实例，而判别器 D 是鉴别者，负责评估数据实例的真伪。两者相互竞争，推动对方不断进步，从而提高生成数据的质量。缩进错误很难分清，代码又一样，写的时候需要仔细看清，找了好久才发现这个错误。是Binary_Cross_Entropy的缩写，可以理解为二分类问题。的任务是生成，用两个模型相互对抗，来增强生成模型的效果。的任务是生成，用两个模型相互对抗，来增强生成模型的效果。手写数字，希望生成类似的手写数字的图像。(1)GAN 的损失函数与BCE。给定条件进行指定数字的生成。
《机器学习》 贝叶斯分类器 原理、参数讲解及代码演示
wx_AHao1004Y的博客
08-26 1246
贝叶斯算法是一种基于贝叶斯定理的统计学习方法。在机器学习中，贝叶斯算法用于推断模型参数或预测未知数据的概率分布。贝叶斯定理是概率论中的一个基本定理，用于描述在已知某些条件下，另一事件发生的概率。贝叶斯算法利用该定理在训练阶段根据样本数据和先验知识估计参数的后验分布，然后在预测阶段根据后验分布计算未知数据的概率分布。贝叶斯算法的基本思想是将概率视为对不确定性的衡量，并通过不断更新先验概率来得到后验概率。
【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch12 随机森林（Random Forest）
2201_76026029的博客
08-26 1341
本学习笔记 仅为以防自己忘记了，顺便分享给一起学习的网友们参考。如有不同意见/建议，可以友好讨论。本学习笔记 所有的代码和数据都可以从陈强老师的个人主页上下载陈强.机器学习及Python应用. 北京：高等教育出版社, 2021.数学原理等 详见陈强老师的PPT网友阡之尘埃的Python机器学习09——随机森林另：各位同学能不能帮我看看习题（分类问题的随机森林：Mushroom.csv）,我是不是处理X没处理对啊？为什么不管是单个决策树还是随机森林，R^2都是1.0 啊啊啊？！！！我已经纠结了好几天了。
模糊C-means算法原理及Python实践
u013571432的博客
08-26 1468
模糊C-means（Fuzzy C-Means，简称FCM）算法是一种经典的模糊聚类算法，它在数据分析、数据挖掘、图像处理等多个领域有着广泛的应用。总的来说，模糊C-means算法通过优化目标函数和迭代更新隶属度矩阵及聚类中心的方式，实现了对数据集的模糊聚类分析。在这种情况下，你可能需要考虑使用更快的聚类算法或优化FCM算法的实现（例如，使用并行计算、减少迭代次数、使用近似方法等）。FCM算法的核心是优化一个目标函数，该目标函数本质上是各个点到各个聚类中心的欧氏距离的平方和的一个加权形式。
机器学习-朴素贝叶斯
2301_77698138的博客
08-26 1276
朴素贝叶斯分类器因其简单性和高效性，在文本分类、垃圾邮件检测、情感分析等领域有着广泛的应用。但同时也有着自己的优缺点。优点简单高效：由于假设特征之间相互独立，大大简化了计算。处理缺失数据：对缺失数据不敏感，可以通过忽略该特征或使用该特征的先验概率来处理。易于实现：算法实现相对简单，易于理解和应用。缺点特征独立性假设：现实中特征之间往往存在相关性，这一假设限制了朴素贝叶斯的性能。
《机器学习》—— K-means 聚类算法
weixin_73504499的博客
08-28 2114
一、什么是K-means 聚类算法？、二、聚类效果评价方式——轮廓系数、三、示例：代码实现、四、聚类算法的优缺点
PPP身份验证详解：CHAP与PAP
pppd使用单独的文件，/etc/ppp/chap-secrets和pap-secrets，存储CHAP和PAP的认证信息。默认情况下，pppd会尝试使用CHAP进行身份验证，如果对等端不支持或找不到对应的密钥，则回退到PAP。如果两者都不支持，连接会被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值