python机器学习-逻辑回归（14）

%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)  

# 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})  
        # 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)) 

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))