python机器学习-逻辑回归(14)

作者 : 慕源网 本文共13884个字,预计阅读时间需要35分钟 发布时间: 2021-10-21 共265人阅读

python机器学习-逻辑回归(14)

本文是Python 机器学习系列的一部分。您可以在此处找到本系列之前所有帖子的链接

介绍

在上一章中,我们研究了线性回归。

在本章中,我们将学习逻辑回归。

注意:如果您可以将任何事物与您自己或您的生活联系起来,那么理解这个概念的机会就更大。因此,尝试通过将一切与人类联系起来来理解一切。

什么是逻辑回归?

Logistic 回归是当因变量是二分(二进制)时要进行的适当回归分析。与所有回归分析一样,逻辑回归是一种预测分析。Logistic 回归用于描述数据并解释一个因二元变量与一个或多个名义、有序、区间或比率级别的自变量之间的关系。Logistic 回归对具有两种可能结果的分类问题的概率进行建模。它是用于分类问题的线性回归模型的扩展。

它是干什么用的?

Logistic 回归用于描述数据并解释一个因二元变量与一个或多个名义、有序、区间或比率级别的自变量之间的关系。

线性回归和逻辑回归的区别

比较基础 线性回归 物流回归
基本的 数据使用直线建模。 某些获得事件的概率表示为预测变量组合的线性函数。
因变量和自变量之间的线性关系 是必须的 不需要
自变量 可以相互关联。(特别是在多元线性回归中) 不应相互关联(不存在多重共线性)。
结果 结果(因变量)是连续的。它可以有无数个可能值中的任何一个。 结果(因变量)只有有限数量的可能值。
因变量 当您的响应变量是连续的时,使用线性回归。例如,体重、身高、小时数等。 当响应变量本质上是分类变量时,使用逻辑回归。例如,yes/no、true/false、red/green/blue、1st/2nd/3rd/4th 等。
方程 线性回归给出形式为 Y = MX + C 的方程,这意味着方程的阶数为 1。 逻辑回归给出了一个方程,其形式为 Y = e X + e -X
系数解释 自变量的系数解释非常简单(即保持所有其他变量不变,随着该变量的单位增加,因变量预计会增加/减少 xxx)。 取决于您使用的族(二项式、泊松等)和链接(log、logit、inverse-log 等),解释不同。
误差最小化技术 使用普通最小二乘法来最小化误差并达到最佳拟合 使用最大似然法得出解决方案。

为什么叫逻辑回归?

术语回归的含义非常简单:任何试图找出变量之间关系的过程都称为回归。逻辑回归是一种回归,因为它发现变量之间的关系。它是逻辑的,因为它使用逻辑函数作为链接函数。因此全名。

逻辑回归的目标是什么?

逻辑回归的目标是使用最简约的模型正确预测单个案例的结果类别。为实现此目标,创建了一个模型,其中包含对预测响应变量有用的所有预测变量。换句话说,逻辑回归的目标是找到最佳拟合(但生物学上合理)的模型来描述感兴趣的二分特征(因变量=响应或结果变量)和一组独立的(预测变量或解释变量)之间的关系变量。

Logistic 回归的类型

1. 二元逻辑回归

分类响应只有两个 2 可能的结果。示例:垃圾邮件与否

2. 多项 Logistic 回归

三个或更多类别,无需订购。示例:预测哪种食物更受欢迎(素食、非素食、素食)

3.序数逻辑回归

三个或更多类别的排序。示例:电影评级从 1 到 5

关键术语

1.Logit

在统计学中,logit 函数或 log-odds 是概率p /(1 − p )的对数,其中 p 是概率。它是一种创建从 [0,1] 到概率值映射的函数。{\displaystyle (-\infty ,+\infty )}它是数学中使用的 Sigmoidal“逻辑”函数或逻辑变换的逆函数,尤其是在统计学中。

在深度学习中,术语 logits 层通常用于分类任务的神经网络的最后一个神经元层,它产生原始预测值作为实数,范围从{\displaystyle (-\infty ,+\infty )}.

2.Logit函数

logit 函数是一个 sigmoid 函数,它接受任何实数输入 t, ( {\displaystyle t\in \mathbb {R} }),并输出一个介于 0 和 1 之间的值;对于 logit,这被解释为采用输入对数赔率并具有输出概率。的标准logit 函数{\displaystyle \sigma :\mathbb {R} \rightarrow (0,1)}被定义为如下:

\sigma (t)={\frac {e^{t}}{e^{t}+1}}={\frac {1}{1+e^{-t}}}

3.Logistic函数的反函数

我们现在可以将 logit(对数赔率)函数定义为{\displaystyle g=\sigma ^{-1}}标准logistic函数的反函数。不难看出,它满足:

{\displaystyle g(p(x))=\sigma ^{-1}(p(x))=\operatorname {logit} p(x)=\ln \left({\frac {p(x)}{ 1-p(x)}}\right)=\beta _{0}+\beta _{1}x,}

等价地,在对双方取幂后,我们有赔率:

{\displaystyle {\frac {p(x)}{1-p(x)}}=e^{\beta _{0}+\beta _{1}x}.}

在哪里,

  • g 是 logit 函数。g(p(x)) 的等式说明 logit(即对数赔率或赔率的自然对数)等效于线性回归表达式。
  • ln 表示自然对数。
  • p(x) 的公式说明给定案例的因变量的概率等于线性回归表达式的逻辑函数值。这很重要,因为它表明线性回归表达式的值可以从负无穷大到正无穷大变化,但在转换之后,结果概率 p(x) 的范围在 0 和 1 之间。
  • \beta _{0} 是线性回归方程的截距(预测变量为零时的标准值)。
  • \beta _{1}x 是回归系数乘以预测变量的某个值。
  • 基数“e”表示指数函数。

4. 概率

因变量等于个案的概率(给定预测变量的一些线性组合 x)等价于线性回归表达式的指数函数。这说明了 logit 如何充当概率和线性回归表达式之间的链接函数。鉴于 logit 的范围在负无穷大和正无穷大之间,它提供了一个足够的标准来进行线性回归,并且 logit 很容易转换回赔率。

所以我们定义因变量等于一个案例的概率(给定预测变量的一些线性组合 x)如下:

{\text{odds}}=e^{\beta _{0}+\beta _{1}x}。

5. 赔率比

对于连续自变量,优势比可以定义为:

{\displaystyle \mathrm {OR} ={\frac {\operatorname {odds} (x+1)}{\operatorname {odds} (x)}}={\frac {\left({\frac {F(x) +1)}{1-F(x+1)}}\right)}{\left({\frac {F(x)}{1-F(x)}}\right)}}={\frac {e^{\beta _{0}+\beta _{1}(x+1)}}{e^{\beta _{0}+\beta _{1}x}}}=e^{\测试版 _{1}}}

这种指数关系提供了以下解释\beta _{1}:e^{\beta _{1}}x 每增加 1 个单位,几率就会乘以。

对于二元自变量,优势比定义为{\frac {ad}{bc}}其中abd是 2×2 列联表中的单元格。

6. 多重解释变量

如果有多个解释变量,则\beta _{0}+\beta _{1}x可以将上述表达式修改为

{\displaystyle \beta _{0}+\beta _{1}x_{1}+\beta _{2}x_{2}+\cdots +\beta _{m}x_{m}=\beta _{ 0}+\sum _{i=1}^{m}\beta _{i}x_{i}}

然后,当将其用于将成功的对数几率与预测变量的值相关联的方程中时,线性回归将是具有m 个解释器的多元回归;参数β _{j}对于所有Ĵ = 0,1,2,…,都估计。

同样,更传统的方程是:

{\displaystyle \log {\frac {p}{1-p}}=\beta _{0}+\beta _{1}x_{1}+\beta _{2}x_{2}+\cdots + \beta _{m}x_{m}}

{\displaystyle p={\frac {1}{1+b^{-(\beta _{0}+\beta _{1}x_{1}+\beta _{2}x_{2}+\cdots +\beta _{m}x_{m})}}}}

通常 b = e。

逻辑回归

逻辑回归生成逻辑曲线,该曲线仅限于 0 到 1 之间的值。逻辑回归类似于线性回归,但该曲线是使用目标变量“几率”的自然对数而非概率构建的。此外,预测变量不必呈正态分布或在每组中具有相等的方差。

逻辑回归方程由下式给出

\displaystyle \frac {p}{1-p} = e^{b_0+b_1*x}

两边取自然对数得到

\displaystyle \ln{\frac {p}{1-p}} = b_0+b_1*x

到现在为止,我们已经看到了一个变量的方程,所以现在下面是变量数量大于1时的方程

{\displaystyle p={\frac {1}{1+b^{-(\beta _{0}+\beta _{1}x_{1}+\beta _{2}x_{2}+\cdots +\beta _{m}x_{m})}}}}

通常 b = e。或者

{\displaystyle \log {\frac {p}{1-p}}=\beta _{0}+\beta _{1}x_{1}+\beta _{2}x_{2}+\cdots + \beta _{m}x_{m}}

让我用一个例子来解释在哪些情况下我们将使用逻辑回归:

在预先定义边界的情况下,线性回归将失败,就像我们使用线性回归一样,它可能会预测边界外。例如,我们以上一章中使用的房价预测为例,因此在预测时,线性回归可能会预测价格过高,这实际上可能不可行,或者损失太大,例如可能消极。

由于在二元分类的情况下,只有两种可能的结果,但输入数据不一定要均匀分布,所以经常看到如果在类’1的决策边界内找到’0’类数据点’。由于 sigmoid 函数是一条曲线,因此得到完美拟合的可能性增加,因此解决了具有

python机器学习-逻辑回归(14)

逻辑回归示例

以IRIS数据集为例,可以直接从sklearn数据集仓库中导入。随意使用任何数据集,kaggle 和 Google Colab 上有一些非常好的数据集。

1. 使用 SKLearn

%matplotlib inline  
import numpy as np  
import matplotlib.pyplot as plt  
import seaborn as sns  
from sklearn import datasets  
from sklearn.linear_model import LogisticRegression

在上面的代码中,我们导入了将要使用的所需库。

iris = datasets.load_iris()  

从 sklearn 数据集存储库加载 IRIS 数据集

X = iris.data[:, :2]  
y = (iris.target != 0) * 1  

操作和预处理数据,以便将其提供给模型。

plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend();  

让我们尝试将导入的数据可视化

python机器学习-逻辑回归(14)

model = LogisticRegression(C=1e2)  
%time model.fit(X, y)  
print(model.intercept_, model.coef_,model.n_iter_) 

在上面的代码中,我们使用“%time”为训练过程计时,然后打印模型参数。

我得到的训练输出是:

CPU 时间:用户 2.45 毫秒,系统:1.06 毫秒,总计:3.51 毫秒挂墙时间:1.76 毫秒
model.itercept: [-33.08987216]
model.coeffiecent: [[ 14.75218964 -14.87575477]]

迭代次数:[12]

plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend()  
x1_min, x1_max = X[:,0].min(), X[:,0].max(),  
x2_min, x2_max = X[:,1].min(), X[:,1].max(),  
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))  
grid = np.c_[xx1.ravel(), xx2.ravel()]  
probs = model.predict(grid).reshape(xx1.shape)  
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='black');  

上面的代码,让我们可视化输入数据的回归线。

python机器学习-逻辑回归(14)

pred = model.predict(X[1:2])  
print(pred)  

在上面的代码中,我们预测样本的类别为X[1:2],类别结果为[0],这是正确的

LR_Sklearn.py

%matplotlib inline  
import numpy as np  
import matplotlib.pyplot as plt  
import seaborn as sns  
from sklearn import datasets  
from sklearn.linear_model import LogisticRegression  
  
iris = datasets.load_iris()  
  
X = iris.data[:, :2]  
y = (iris.target != 0) * 1  
  
plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend();  
  
model = LogisticRegression(C=1e2)  
%time model.fit(X, y)  
print(model.intercept_, model.coef_,model.n_iter_)  
  
plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend()  
x1_min, x1_max = X[:,0].min(), X[:,0].max(),  
x2_min, x2_max = X[:,1].min(), X[:,1].max(),  
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))  
grid = np.c_[xx1.ravel(), xx2.ravel()]  
probs = model.predict(grid).reshape(xx1.shape)  
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='black');  

2. 使用 Numpy

%matplotlib inline  
import numpy as np  
import matplotlib.pyplot as plt  
import seaborn as sns  
from sklearn import datasets  a

在上面的代码中,我们导入了将要使用的所需库。

iris = datasets.load_iris()  

从 sklearn 数据集存储库加载 IRIS 数据集

X = iris.data[:, :2]  
y = (iris.target != 0) * 1  

操作和预处理数据,以便将其提供给模型。

plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend();  

让我们尝试将导入的数据可视化

python机器学习-逻辑回归(14)

class LogisticRegression:  
    def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):  
        self.lr = lr  
        self.num_iter = num_iter  
        self.fit_intercept = fit_intercept  
        self.verbose = verbose  
      
    def __add_intercept(self, X):  
        intercept = np.ones((X.shape[0], 1))  
        return np.concatenate((intercept, X), axis=1)  
      
    def __sigmoid(self, z):  
        return 1 / (1 + np.exp(-z))  
    def __loss(self, h, y):  
        return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()  
      
    def fit(self, X, y):  
        if self.fit_intercept:  
            X = self.__add_intercept(X)  
          
        # weights initialization  
        self.theta = np.zeros(X.shape[1])  
          
        for i in range(self.num_iter):  
            z = np.dot(X, self.theta)  
            h = self.__sigmoid(z)  
            gradient = np.dot(X.T, (h - y)) / y.size  
            self.theta -= self.lr * gradient  
              
            z = np.dot(X, self.theta)  
            h = self.__sigmoid(z)  
            loss = self.__loss(h, y)  
                  
            if(self.verbose ==True and i % 10000 == 0):  
                print(f'loss: {loss} \t')  
      
    def predict_prob(self, X):  
        if self.fit_intercept:  
            X = self.__add_intercept(X)  
      
        return self.__sigmoid(np.dot(X, self.theta))  
      
    def predict(self, X):  
        return self.predict_prob(X).round() 

在上面的代码中,我们创建了一个用户定义的类“LogisticRegression”,其中包含生成所需回归线所需的所有方法

  • __init__ – 使用默认值或初始值初始化所有必需变量的构造函数
  • __add_intercept – 找到模型截取值
  • __sigmoid – 返回 sigmoid 曲线的函数
  • __loss – 返回损失的函数
  • fit – 计算和返回回归线的函数
  • predict_prob – 用于预测的辅助函数
  • predict – 返回预测值的函数
model = LogisticRegression(lr=0.1, num_iter=3000)  
%time model.fit(X, y)  

在上面的代码中,我们初始化了 LogisticRegression 类,然后将 ‘X’ 和 ‘y’ 作为参数提供给 fit 函数以得到所需的回归线

preds = model.predict(X[1:2])  
print(preds)  

在上面的代码中,我们让模型告诉我们的样本 X[1:2] 所属的类,我们得到的结果是 [0.],这是正确的

print(model.theta)  

现在我们打印结果模型的参数值。

我的模型的参数值为:

[-1.44894305 4.25546329 -6.89489245]

plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend()  
x1_min, x1_max = X[:,0].min(), X[:,0].max(),  
x2_min, x2_max = X[:,1].min(), X[:,1].max(),  
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))  
grid = np.c_[xx1.ravel(), xx2.ravel()]  
probs = model.predict_prob(grid).reshape(xx1.shape)  
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='black');  

上面的代码将为我们提供与输入数据相关的生成回归线的可视化。

python机器学习-逻辑回归(14)

LR_NumPy.py
%matplotlib inline  
import numpy as np  
import matplotlib.pyplot as plt  
import seaborn as sns  
from sklearn import datasets  
  
iris = datasets.load_iris()  
  
X = iris.data[:, :2]  
y = (iris.target != 0) * 1  
plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend();  
  
class LogisticRegression:  
    def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):  
        self.lr = lr  
        self.num_iter = num_iter  
        self.fit_intercept = fit_intercept  
        self.verbose = verbose  
      
    def __add_intercept(self, X):  
        intercept = np.ones((X.shape[0], 1))  
        return np.concatenate((intercept, X), axis=1)  
      
    def __sigmoid(self, z):  
        return 1 / (1 + np.exp(-z))  
    def __loss(self, h, y):  
        return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()  
      
    def fit(self, X, y):  
        if self.fit_intercept:  
            X = self.__add_intercept(X)  
          
        # weights initialization  
        self.theta = np.zeros(X.shape[1])  
          
        for i in range(self.num_iter):  
            z = np.dot(X, self.theta)  
            h = self.__sigmoid(z)  
            gradient = np.dot(X.T, (h - y)) / y.size  
            self.theta -= self.lr * gradient  
              
            z = np.dot(X, self.theta)  
            h = self.__sigmoid(z)  
            loss = self.__loss(h, y)  
                  
            if(self.verbose ==True and i % 10000 == 0):  
                print(f'loss: {loss} \t')  
      
    def predict_prob(self, X):  
        if self.fit_intercept:  
            X = self.__add_intercept(X)  
      
        return self.__sigmoid(np.dot(X, self.theta))  
      
    def predict(self, X):  
        return self.predict_prob(X).round()  
  
model = LogisticRegression(lr=0.1, num_iter=3000)  
%time model.fit(X, y)  
  
preds = model.predict(X[1:2])  
print(preds)  
  
print(model.theta)  
plt.figure(figsize=(10, 6))  
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')  
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')  
plt.legend()  
x1_min, x1_max = X[:,0].min(), X[:,0].max(),  
x2_min, x2_max = X[:,1].min(), X[:,1].max(),  
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))  
grid = np.c_[xx1.ravel(), xx2.ravel()]  
probs = model.predict_prob(grid).reshape(xx1.shape)  
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='black');

3. 使用 TensorFlow

from __future__ import print_function  
  
import tensorflow as tf  

在上面的代码中,我们正在导入所需的库

# Import MNIST data  
from tensorflow.examples.tutorials.mnist import input_data  
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)  

使用 TensorFlow 的数据集库,我们导入 MNIST 数据集

# Parameters  
learning_rate = 0.01  
training_epochs = 100  
batch_size = 100  
display_step = 50  

在上面的代码中,我们将值分配给所有全局参数。

# tf Graph Input  
x = tf.placeholder(tf.float32, [None, 784]) # mnist data image of shape 28*28=784  
y = tf.placeholder(tf.float32, [None, 10]) # 0-9 digits recognition => 10 classes  
  
# Set model weights  
W = tf.Variable(tf.zeros([784, 10]))  
b = tf.Variable(tf.zeros([10]))   

这里我们将 X 和 Y 设置为实际训练数据,将 W 和 b 设置为可训练数据,其中:

  • W 表示重量
  • b 表示 bais
  • X 表示因变量
  • Y 表示自变量
# Construct model  
pred = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax  
  
# Minimize error using cross entropy  
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), reduction_indices=1))  
# Gradient Descent  
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)  
  
# Initialize the variables (i.e. assign their default value)  
init = tf.global_variables_initializer()

在上面的代码中,我们是

  • 使用 Softmax 方法设置模型
  • 成本计算将基于缩减平均法
  • 优化器被选择为梯度下降,以最小化成本
  • 变量初始化器被选为全局变量初始化器
# Start training  
with tf.Session() as sess:  
  
  # Run the initializer  
  sess.run(init)  
  
  # Training cycle  
  for epoch in range(training_epochs):  
    avg_cost = 0.  
    total_batch = int(mnist.train.num_examples/batch_size)  
    # Loop over all batches  
    for i in range(total_batch):  
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)  
        # Run optimization op (backprop) and cost op (to get loss value)  
        _, c = sess.run([optimizer, cost], feed_dict={x: batch_xs,  
                                                      y: batch_ys})  
        # Compute average loss  
        avg_cost += c / total_batch  
    # Display logs per epoch step  
    if (epoch+1) % display_step == 0:  
        print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))  
  training_cost = sess.run(cost, feed_dict ={x: batch_xs,  
                                                      y: batch_ys})       
  weight = sess.run(W)       
  bias = sess.run(b) 

在上面的代码中,我们开始训练,每 50 个 epoch 后打印成本。这里由于数据点数量较多,一次处理可能会导致crash,所以我们分批训练。

print("W",weight,"\nb",bias)  
eq= tf.math.sigmoid((tf.matmul(x, weight) + bias)) 

在上面的代码中,我们打印了学习模型的权重和偏差,然后形成了逻辑回归方程。

LR_tensorflow.py

from __future__ import print_function  
  
import tensorflow as tf  
  
# Import MNIST data  
from tensorflow.examples.tutorials.mnist import input_data  
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)  
  
# Parameters  
learning_rate = 0.01  
training_epochs = 100  
batch_size = 100  
display_step = 50  
  
# tf Graph Input  
x = tf.placeholder(tf.float32, [None, 784]) # mnist data image of shape 28*28=784  
y = tf.placeholder(tf.float32, [None, 10]) # 0-9 digits recognition => 10 classes  
  
# Set model weights  
W = tf.Variable(tf.zeros([784, 10]))  
b = tf.Variable(tf.zeros([10]))  
  
# Construct model  
pred = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax  
  
# Minimize error using cross entropy  
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), reduction_indices=1))  
# Gradient Descent  
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)  
  
# Initialize the variables (i.e. assign their default value)  
init = tf.global_variables_initializer()  
  
# Start training  
with tf.Session() as sess:  
  
  # Run the initializer  
  sess.run(init)  
  
  # Training cycle  
  for epoch in range(training_epochs):  
    avg_cost = 0.  
    total_batch = int(mnist.train.num_examples/batch_size)  
    # Loop over all batches  
    for i in range(total_batch):  
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)  
        # Run optimization op (backprop) and cost op (to get loss value)  
        _, c = sess.run([optimizer, cost], feed_dict={x: batch_xs,  
                                                      y: batch_ys})  
      &nbstsp; # Compute average loss  
        avg_cost += c / total_batch  
    # Display logs per epoch step  
    if (epoch+1) % display_step == 0:  
        print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))  
  training_cost = sess.run(cost, feed_dict ={x: batch_xs,  
                                                      y: batch_ys})       
  weight = sess.run(W)       
  bias = sess.run(b)    
  
print("W",weight,"\nb",bias)  
eq= tf.math.sigmoid((tf.matmul(x, weight) + bias))

我得到的输出是

python机器学习-逻辑回归(14)

结论

在本章中,我们研究了简单的逻辑回归。

在下一章中,我们将学习多元线性回归。


慕源网 » python机器学习-逻辑回归(14)

常见问题FAQ

程序仅供学习研究,请勿用于非法用途,不得违反国家法律,否则后果自负,一切法律责任与本站无关。
请仔细阅读以上条款再购买,拍下即代表同意条款并遵守约定,谢谢大家支持理解!

发表评论

开通VIP 享更多特权,建议使用QQ登录