Results 1 to 1 of 1

Thread: How to modify Adaline Stochastic gradient descent

  1. #1
    Newbie
    Joined
    Oct 2018
    From
    Taiwan
    Posts
    11

    How to modify Adaline Stochastic gradient descent



    Dear


    May I know how to modify my own Python programming so that I will get the
    same picture as refer to the attached file - Adaline Stochastic gradient descent


    (I am using the Anaconda Python 3.7)

    Prayerfully


    Tron Orino Yeong
    tcynotebook@yahoo.com
    0916643858





    from matplotlib.colors import ListedColormap
    import matplotlib.pyplot as plt
    import numpy as np
    from numpy.random import seed
    import pandas as pd


    # Stochastic Gradient Descent
    class SGD(object):
    def __init__(self, rate = 0.01, niter = 10,
    shuffle=True, random_state=None):
    self.rate = rate
    self.niter = niter
    self.weight_initialized = False


    # If True, Shuffles training data every epoch
    self.shuffle = shuffle


    # Set random state for shuffling and initializing the weights.
    if random_state:
    seed(random_state)


    def fit(self, X, y):
    """Fit training data
    X : Training vectors, X.shape : [#samples, #features]
    y : Target values, y.shape : [#samples]
    """


    # weights
    self.initialize_weights(X.shape[1])


    # Cost function
    self.cost = []


    for i in range(self.niter):
    if self.shuffle:
    X, y = self.shuffle_set(X, y)
    cost = []
    for xi, target in zip(X, y):
    cost.append(self.update_weights(xi, target))
    avg_cost = sum(cost)/len(y)
    self.cost.append(avg_cost)
    return self


    def partial_fit(self, X, y):
    """Fit training data without reinitializing the weights"""
    if not self.weight_initialized:
    self.initialize_weights(X.shape[1])
    if y.ravel().shape[0] > 1:
    for xi, target in zip(X, y):
    self.update_weights(xi, target)
    else:
    self.up
    return self


    def shuffle_set(self, X, y):
    """Shuffle training data"""
    r = np.random.permutation(len(y))
    return X[r], y[r]


    def initialize_weights(self, m):
    """Initialize weights to zeros"""
    self.weight = np.zeros(1 + m)
    self.weight_initialized = True


    def update_weights(self, xi, target):
    """Apply SGD learning rule to update the weights"""
    output = self.net_input(xi)
    error = (target - output)
    self.weight[1:] += self.rate * xi.dot(error)
    self.weight[0] += self.rate * error
    cost = 0.5 * error**2
    return cost


    def net_input(self, X):
    """Calculate net input"""
    return np.dot(X, self.weight[1:]) + self.weight[0]


    def activation(self, X):
    """Compute linear activation"""
    return self.net_input(X)


    def predict(self, X):
    """Return class label after unit step"""
    return np.where(self.activation(X) >= 0.0, 1, -1)


    def plot_decision_regions(X, y, classifier, resolution=0.02):
    # setup marker generator and color map
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])


    # plot the decision surface
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
    np.arange(x2_min, x2_max, resolution))
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())


    # plot class samples
    for idx, cl in enumerate(np.unique(y)):
    plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],
    alpha=0.8, c=cmap(idx),
    marker=markers[idx], label=cl)


    df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)


    y = df.iloc[0:100, 4].values
    y = np.where(y == 'Iris-setosa', -1, 1)
    X = df.iloc[0:100, [0, 2]].values


    # standardize
    X_std = np.copy(X)
    X_std[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std()
    X_std[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()


    sgd1 = SGD(niter=100, rate=0.01, random_state=1)
    sgd2 = SGD(niter=50, rate=0.01, random_state=1)
    sgd3 = SGD(niter=10, rate=0.01, random_state=1)


    sgd1.fit(X_std, y)
    sgd2.fit(X_std, y)
    sgd3.fit(X_std, y)


    plt.plot(range(1, len(sgd1.cost) + 1), sgd1.cost,
    marker='o', linestyle='oo', label='batch=1')
    plt.plot(range(1, len(sgd2.cost_) + 1), np.array(sgd2.cost_) / len(y_train),
    marker='o', linestyle='--', label='batch=2')
    plt.plot(range(1, len(sgd3.cost_) + 1), np.array(sgd3.cost_) / len(y_train),
    marker='o', linestyle='xx', label='batch=3')


    plt.xlabel('Epochs')
    plt.ylabel('Average Cost')
    plt.show()
    Attached Files Attached Files
    Last edited by vokoyo; Mar 13th 2019 at 01:00 PM.
    Follow Math Help Forum on Facebook and Google+

Similar Math Help Forum Discussions

  1. Programming gradient descent for local minima
    Posted in the Advanced Applied Math Forum
    Replies: 3
    Last Post: May 7th 2010, 11:05 PM
  2. Max rate of descent , gradient?
    Posted in the Calculus Forum
    Replies: 0
    Last Post: Oct 12th 2009, 07:02 PM
  3. Gradient - Steepest Descent
    Posted in the Calculus Forum
    Replies: 2
    Last Post: Oct 12th 2009, 05:52 PM
  4. Modify TI89 Menus
    Posted in the Calculators Forum
    Replies: 2
    Last Post: May 6th 2009, 04:35 PM
  5. Replies: 0
    Last Post: Feb 16th 2009, 05:36 AM

/mathhelpforum @mathhelpforum