def plot_boundary(theta, grau): x = np.linspace(-1,1.5,50) y = np.linspace(-0.8,1.2,50) xx, yy = np.meshgrid(x, y) theta = np.matrix(theta) X_poly = mapFeature(xx.ravel(), yy.ravel(), grau) Z = sigmoide(X_poly.dot(theta.T)) Z = Z.reshape(xx.shape) plt.title('lambda = 1') plt.contour(x, y, Z, [0.5], linewidths=1, colors='green') legendas = [Line2D([0], [0], marker='+', color='k', lw=0, label='Aceito (y = 1)'), Line2D([0], [0], marker='o',color='y', lw=0, label='Rejeitado (y = 0)'), Line2D([0], [0], color='g', lw=2, label='Fronteira de Decisão')] plt.legend(handles=legendas) dirname = os.path.dirname(__file__) plt.savefig(dirname + os.path.sep + '/plot4.2.png') plt.show()
def plotReg(x, y, theta, degree): pos = np.where(y == 1) neg = np.where(y == 0) p.scatter(x[0, pos], x[1, pos], marker='o') p.scatter(x[0, neg], x[1, neg], marker='x') nx = 100 rangex = np.array([np.amin(x[0, :]), np.amax(x[0, :])]) dx = (rangex[1] - rangex[0]) / nx ny = 100 rangey = np.array([np.amin(x[1, :]), np.amax(x[1, :])]) dy = (rangey[1] - rangey[0]) / ny xplot = np.empty([2, 1]) xcontour = np.empty(nx) ycontour = np.empty(ny) zcontour = np.empty([nx, ny]) for ii in range(nx): for jj in range(ny): xplot[0, 0] = rangex[0] + ii * dx xcontour[ii] = xplot[0, 0] xplot[1, 0] = rangey[0] + jj * dy ycontour[jj] = xplot[1, 0] (zplot, nfeatures) = mapFeature(xplot, degree) zcontour[ii, jj] = np.dot(zplot[:, 0], theta) p.contour(xcontour, ycontour, zcontour, levels=[0]) p.show()
def plotReg(x,y,theta,degree): pos = np.where(y==1) neg = np.where(y==0) p.scatter(x[0,pos],x[1,pos],marker='o') p.scatter(x[0,neg],x[1,neg],marker='x') nx = 100 rangex = np.array([np.amin(x[0,:]),np.amax(x[0,:])]) dx = (rangex[1]-rangex[0])/nx ny = 100 rangey = np.array([np.amin(x[1,:]),np.amax(x[1,:])]) dy = (rangey[1]-rangey[0])/ny xplot = np.empty([2,1]) xcontour = np.empty(nx) ycontour = np.empty(ny) zcontour = np.empty([nx,ny]) for ii in range(nx): for jj in range(ny): xplot[0,0] = rangex[0] + ii*dx xcontour[ii] = xplot[0,0] xplot[1,0] = rangey[0] + jj*dy ycontour[jj] = xplot[1,0] (zplot,nfeatures) = mapFeature(xplot,degree) zcontour[ii,jj] = np.dot(zplot[:,0],theta) # endfor jj in range(ny) # endfor ii in range(nx) p.contour(xcontour,ycontour,zcontour,levels=[0]) p.show()
def plotDecisionBoundary(theta, u, v): z = np.zeros((len(u), len(v))) for i in range(len(u)): for j in range(len(v)): z[i, j] = np.dot(mapFeature(u[i], v[j]), theta) return z
def plotDecisionBoundary(theta, X, y): """ Plots the data points X and y into a new figure with the decision boundary defined by theta. Parameters ---------- theta : ndarray, shape (n_features,) Linear regression parameter. X : ndarray, shape (n_samples, n_features) Training data, where n_samples is the number of samples and n_features is the number of features. y : ndarray, shape (n_samples,) Labels. """ if X.shape[1] <= 3: plot_X = np.array([np.amin(X[:, 1]) - 2, np.amax(X[:, 1]) + 2]) plot_y = -1.0 / theta[2] * (theta[1] * plot_X + theta[0]) plt.plot(plot_X, plot_y) else: u = np.linspace(-1, 1.5, 50) # u.resize((len(u), 1)) v = np.linspace(-1, 1.5, 50) # v.resize((len(v), 1)) z = np.zeros((len(u), len(v))) for i in range(len(u)): for j in range(len(v)): z[i, j] = mapFeature(u[i:i + 1], v[j:j + 1]).dot(theta) z = z.T u, v = np.meshgrid(u, v) cs = plt.contour(u, v, z, levels=[0]) fmt = {} strs = ['Decision boundary'] for l, s in zip(cs.levels, strs): fmt[l] = s plt.clabel(cs, cs.levels[::2], inline=True, fmt=fmt, fontsize=10)
def plotDecisionBoundary(theta, X, y): # Plot Data f,j1,a,b=plotData.plotData(X[:,1:3], y) if X.shape[1]<= 3: ## Only need 2 points to define a line, so choose two endpoints plot_x = [np.amin(X[:,1:2],axis=0)-2, np.amax(X[:,1:2],axis=0)+2] ## Calculate the decision boundary line list1=[i*theta[1,0] for i in plot_x] list1=[j+theta[0,0] - 0.5 for j in list1] x=-(1/theta[2,0]) plot_y = [k*x for k in list1] plot_y = np.matrix(plot_y) ## Plot, and adjust axes for better viewing c, =j1.plot(plot_x, plot_y) c.set_label('Decision Boundary') plt.axis([30,100,30,100]) else: ## Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) ## Evaluate z = theta*x over the grid for i in range(len(u)): for j in range(len(v)): qa=mapFeature.mapFeature(u[i], v[j]) z[i,j] = qa@theta z = z.T ## important to transpose z before calling contour c=j1.contour(u,v,z,levels=0) c.collections[0].set_label('Decision Boundary') return f,j1,a,b;
def plotDecisionBoundary(theta, X, y, xlabel='', ylabel='', legends=[]): pos = y[:, 0] == 1 neg = y[:, 0] == 0 plt.scatter(X[pos, 0], X[pos, 1], c='k', marker='+', label=legends[0]) plt.scatter(X[neg, 0], X[neg, 1], c='y', marker='o', label=legends[1], alpha=0.5) if X.shape[1] <= 2: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:, 0]) - 2, max(X[:, 0]) + 2]) plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) plt.plot(plot_x, plot_y, label=legends[2]) else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((u.size, v.size)) for i in range(u.size): for j in range(v.size): z[i, j] = mapFeature( np.array(u[i]).reshape((1, 1)), np.array(v[j]).reshape((1, 1))).dot(theta) plt.contour(u, v, z.T, levels=[0.0], label=legends[2]) plt.xlabel(xlabel) plt.ylabel(ylabel) plt.legend() plt.show()
def plotDecisionBoundary(theta, X, y): plt.figure() pos = np.where(y == 1) neg = np.where(y == 0) plt.scatter(X[pos[0], 1], X[pos[0], 2], color='red', marker='o') plt.scatter(X[neg[0], 1], X[neg[0], 2], color='blue', marker='x') # plt.xlim(30, 100) # plt.ylim(30, 100) # plt.xlim(-1, 1.5) # plt.ylim(-1, 1.5) plt.xlabel('Exam 1 score') plt.ylabel('Exam 2 score') plt.legend(['Admitted', 'Not admitted']) if len(theta) <= 3: plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2]) plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0]) plt.plot(plot_x, plot_y) else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) for i in range(len(u)): for j in range(len(v)): z[i, j] = mapFeature(u[i], v[j]).dot(theta) z = z.T plt.contour(u, v, z) plt.show()
def plotDecisionBoundary(theta, X, y): # Create New Figure plotData(X[:,1:3],y.T[0]) if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([np.min(X[:,1]), np.max(X[:,1])]) # Calculate the decision boundary line plot_y = (-1/theta[2])*(theta[1]*plot_x + theta[0]) # Plot, and adjust axes for better viewing plt.plot(plot_x,plot_y) # Legend, specific for the exercise plt.legend(['Admitted', 'Not admitted', 'Decision Boundary']) plt.axis([30, 100, 30, 100]) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((u.shape[0], v.shape[0])) # Evaluate z = theta*x over the grid for i in range(0,u.shape[0]): for j in range(0,v.shape[0]): z[i,j] = np.dot(theta.T, mapFeature(u[i],v[j])) # !!! important for plot u, v = np.meshgrid(u, v) # Plot z = 0 # Notice you need to specify the range [0, 0] plt.contour(u, v, z.T, (0,), colors='g', linewidths=2)
def plotDecisionBoundary(theta, X, y): plt, pos, neg = plotData(X[:, 1:3], y) r, c = X.shape if c <= 3: plot_x = np.array([min(X[:, 1]) - 2, max(X[:, 1]) + 2]) plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0]) db = plt.plot(plot_x, plot_y)[0] plt.legend((pos, neg, db), ('Admitted', 'Not Admitted', 'Decision Boundary'), loc='lower left') plt.axis([30, 100, 30, 100]) else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) for i in range(1, len(u)): for j in range(1, len(v)): z[i, j] = np.dot( mapFeature(np.asarray([[u[i]]]), np.asarray([[v[j]]])), theta) z = z.T #print(z) CS = plt.contour(u, v, z, levels=[0]) db = CS.collections[0] plt.clabel(CS, fmt='%2.1d', colors='g', fontsize=14) plt.legend((pos, neg, db), ('y = 1', 'y = 0', 'Decision Boundary'), loc='upper right') return plt
def plotDecisionBoundary(theta, X, y): # Create New Figure plotData(X[:, 1:3], y.T[0]) if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([np.min(X[:, 1]), np.max(X[:, 1])]) # Calculate the decision boundary line plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) # Plot, and adjust axes for better viewing plt.plot(plot_x, plot_y) # Legend, specific for the exercise plt.legend(['Admitted', 'Not admitted', 'Decision Boundary']) plt.axis([30, 100, 30, 100]) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((u.shape[0], v.shape[0])) # Evaluate z = theta*x over the grid for i in range(0, u.shape[0]): for j in range(0, v.shape[0]): z[i, j] = np.dot(theta.T, mapFeature(u[i], v[j])) # !!! important for plot u, v = np.meshgrid(u, v) # Plot z = 0 # Notice you need to specify the range [0, 0] plt.contour(u, v, z.T, (0, ), colors='g', linewidths=2)
def plotDecisionBoundary(theta, X, y, xlabel='', ylabel='', legends=[]): pos = y[:, 0] == 1 neg = y[:, 0] == 0 plt.scatter(X[pos, 0], X[pos, 1], c='k', marker='+', label=legends[0]) plt.scatter(X[neg, 0], X[neg, 1], c='y', marker='o', label=legends[1], alpha=0.5) if X.shape[1] <= 2: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:, 0]) - 2, max(X[:, 0]) + 2]) plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) plt.plot(plot_x, plot_y, label=legends[2]) else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((u.size, v.size)) for i in range(u.size): for j in range(v.size): z[i, j] = mapFeature(np.array(u[i]).reshape((1, 1)), np.array(v[j]).reshape((1, 1))).dot(theta) plt.contour(u, v, z.T, levels=[0.0], label=legends[2]) plt.xlabel(xlabel) plt.ylabel(ylabel) plt.legend() plt.show()
def plotDecisionBoundary(theta, X, y): import matplotlib.pyplot as plt import numpy as np import mapFeature as mf import plotData as pd # Plot Data fig = plt.figure() plt, p1, p2 = pd.plotData(X[:, 1:3], y) plt.hold(True) if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:, 1]), max(X[:, 1])]) # Calculate the decision boundary line plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0]) # Plot, and adjust axes for better viewing p3 = plt.plot(plot_x, plot_y) # Legend, specific for the exercise plt.legend((p1, p2, p3[0]), ('Admitted', 'Not Admitted', 'Decision Boundary'), numpoints=1, handlelength=0.5) plt.axis([30, 100, 30, 100]) plt.show() else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) # Evaluate z = theta*x over the grid for i in range(len(u)): for j in range(len(v)): z[i, j] = np.dot( mf.mapFeature(np.array([u[i]]), np.array([v[j]])), theta) z = np.transpose(z) # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the level 0 # we get collections[0] so that we can display a legend properly p3 = plt.contour(u, v, z, levels=[0], linewidth=2).collections[0] # Legend, specific for the exercise plt.legend((p1, p2, p3), ('y = 1', 'y = 0', 'Decision Boundary'), numpoints=1, handlelength=0) plt.show() plt.hold(False) # prevents further drawing on plot
def plot_data(X, y, theta=np.array([])): """ Plot student admission data on a graph """ # Set y and x axis labels for scatter plot plt.ylabel('Exam 2 score') plt.xlabel('Exam 1 score') admitted = np.where(y == 1)[0] not_admitted = np.where(y == 0)[0] # Plot all admitted students plt.scatter(X[admitted, :1], X[admitted, 1:], marker='+', label='Admitted', c='black') # Plot all non-admitted students plt.scatter(X[not_admitted, :1], X[not_admitted, 1:], marker='o', label='Not admitted', c='yellow', edgecolors='black') # Set legend for scatter plot plt.legend(loc='upper right', fontsize=8) # Show best fit line if theta.size != 0: if theta.size <= 3: x_coords = np.array([np.min(X[:, 1]), np.max(X[:, 1])]) y_coords = (-1 / theta[2]) * (theta[0] + theta[1] * x_coords) plt.plot(x_coords, y_coords, 'b-', label='Decision boundary') else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((u.size, v.size)) # Evaluate z = theta*x over the grid for i, ui in enumerate(u): for j, vj in enumerate(v): z[i, j] = np.dot(mapFeature(ui, vj), theta) z = z.T # important to transpose z before calling contour # print(z) # Plot z = 0 pyplot.contour(u, v, z, levels=[0], linewidths=2, colors='g') pyplot.contourf(u, v, z, levels=[np.min(z), 0, np.max(z)], cmap='Greens', alpha=0.4) plt.show()
def plotDecisionBoundary(theta, X, y): #PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with #the decision boundary defined by theta # PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the # positive examples and o for the negative examples. X is assumed to be # a either # 1) Mx3 matrix, where the first column is an all-ones column for the # intercept. # 2) MxN, N>3 matrix, where the first column is all-ones # Plot Data plt, p1, p2 = pd.plotData(X[:, 1:3], y) if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:, 1]) - 2, max(X[:, 1]) + 2]) # Calculate the decision boundary line plot_y = (-1.0 / theta[2]) * (theta[1] * plot_x + theta[0]) # Plot, and adjust axes for better viewing p3 = plt.plot(plot_x, plot_y) # Legend, specific for the exercise plt.legend((p1, p2, p3[0]), ('Admitted', 'Not Admitted', 'Decision Boundary'), numpoints=1, handlelength=0.5) plt.axis([30, 100, 30, 100]) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) # Evaluate z = theta*x over the grid for i in range(len(u)): for j in range(len(v)): z[i, j] = np.dot( mf.mapFeature(np.array([u[i]]), np.array([v[j]])), theta) z = z.transpose() # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the level 0 # we get collections[0] so that we can display a legend properly p3 = plt.contour(u, v, z, levels=[0], linewidth=2).collections[0] # Legend, specific for the exercise plt.legend((p1, p2, p3), ('y = 1', 'y = 0', 'Decision Boundary'), numpoints=1, handlelength=0) return plt, p1, p2
def plotDecisionBoundary(theta, X, y, labels): #PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with #the decision boundary defined by theta # PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the # positive examples and o for the negative examples. X is assumed to be # a either # 1) Mx3 matrix, where the first column is an all-ones column for the # intercept. # 2) MxN, N>3 matrix, where the first column is all-ones # Plot Data pos_handle, neg_handle = plotData(X[:, 1:3], y, labels) #hold on if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = [np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2] # Calculate the decision boundary line plot_y = np.dot((-1.0 / theta[2]), (np.dot(theta[1], plot_x) + theta[0])) # Plot, and adjust axes for better viewing boundary_handle = plt.plot(plot_x, plot_y, label='Decision Boundary')[0] # Legend, specific for the exercise #axis([30, 100, 30, 100]) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((u.size, v.size)) # Evaluate z = theta*x over the grid for i in range(u.size): for j in range(v.size): z[i, j] = np.dot(mapFeature(np.array([u[i]]), np.array([v[j]])), theta) z = z.T # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the range [0, 0] u, v = np.meshgrid(u, v) boundary_handle = plt.contour(u, v, z, [0], linewidth=2).collections[0] boundary_handle.set_label('Decision Boundary') #hold off return (pos_handle, neg_handle, boundary_handle)
def plotDecisionBoundary(theta, X, y): #PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with #the decision boundary defined by theta # PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the # positive examples and o for the negative examples. X is assumed to be # a either # 1) Mx3 matrix, where the first column is an all-ones column for the # intercept. # 2) MxN, N>3 matrix, where the first column is all-ones # Plot Data plotData(X[:,1:], y) plt.hold(True) if np.size(X, 1) <= 3: #Only need 2 points to define a line, so choose two endpoints plot_x = np.array([np.min(X[:,1])-2, np.max(X[:,1])+2]) # Calculate the decision boundary line plot_y = (-1./theta[2])*(theta[1]*plot_x + theta[0]) # Plot, and adjust axes for better viewing plt.plot(plot_x, plot_y) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) grid_num_u = u.shape[0] grid_num_v = u.shape[0] z = np.zeros((grid_num_u, grid_num_v)) # Evaluate z = theta*x over the grid for i in range(0,grid_num_u): for j in range(0,grid_num_v): z[i,j] = mapFeature(u[i], v[j]).dot(theta) z = z.T # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the range [0, 0] #plt.contour(theta0_vals, theta1_vals, J_vals, linespace=np.logspace(-2, 3, num=100)) plt.contour(u, v, z)
def plotDecisionBoundary(theta, X, y): # plotDecisionBoundary plots the data points with + for the positive examples # and o for the negative examples. X is assumed to be a either # 1) Mx3 matrix, where the first column is an all-ones column for the intercept. # 2) MxN, N>3 matrix, where the first column is all-ones # Plot the data plotData(X[:, 1:3], y) if X.shape[1] <= 3: # only need 2 points to define a line, so choose two endpoints plot_x = array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2]) # Calculate the decision boundary line plot_y = array((-1 / theta[2]) * (theta[1] * plot_x + theta[0])) # Plot and adjust axes for better viewing plt.plot(plot_x, plot_y) # Legend, specific # plt.legend(['Admitted', 'Not admitted', 'Decision Boundary']) plt.axis([30, 105, 30, 105]) else: # Here is the grid range u = linspace(-1, 1.5, 50) v = linspace(-1, 1.5, 50) z = np.zeros((u.size, v.size)) # Evaluate z = theta*x over the grid for i in range(u.size): for j in range(v.size): z[i, j] = np.dot( mapFeature(u[i].reshape((1, 1)), v[j].reshape(1, 1)), theta) z = z.T # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify range [0,0] plt.contour(u, v, z, [0], linewidth=2)
def plotDecisionBoundary(theta, X, y): """PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with the decision boundary defined by theta PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the positive examples and o for the negative examples. X is assumed to be a either 1) Mx3 matrix, where the first column is an all-ones column for the intercept. 2) MxN, N>3 matrix, where the first column is all-ones""" if X.shape[1] <= 3: #Only need 2 points to define a line, so choose two endpoints plot_x = np.c_[np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2] #Calculate the decision boundary line left = -1 / theta[2] right = theta[1] * plot_x + theta[0] plot_y = left * right #Plot, and adjust axes for better viewing line, = plt.plot(plot_x.flatten(), plot_y.flatten(), c='b', label="Decision Boundary", marker="*") plt.axis([30, 100, 30, 100]) return line else: #Here is the grid range u = np.linspace(-1, 1.5, num=50) v = np.linspace(-1, 1.5, num=50) A, B = np.meshgrid(u, v) z = np.zeros((u.size, v.size)) #Evaluate z = theta*x over the grid for i in range(u.size): for j in range(v.size): z[i, j] = np.dot(mapFeature(u[i], v[j]), theta) z = z.T # important to transpose z before calling contour #Plot z = 0 #Notice you need to specify the range [0, 0] return plt.contour(A, B, z)
def plotDecisionBoundary(theta, X, y): #PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with #the decision boundary defined by theta # PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the # positive examples and o for the negative examples. X is assumed to be # a either # 1) Mx3 matrix, where the first column is an all-ones column for the # intercept. # 2) MxN, N>3 matrix, where the first column is all-ones # Plot Data fig = plotData(X[:,1:], y) hold(True) if size(X, 1) <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = array([min(X[:,1])-2, max(X[:,1])+2]) # Calculate the decision boundary line plot_y = (-1/theta[2]) * (theta[1] * plot_x + theta[0]) # Plot, and adjust axes for better viewing plot(plot_x, plot_y) # Legend, specific for the exercise legend(('Admitted', 'Not admitted', 'Decision Boundary'), numpoints=1) axis([30, 100, 30, 100]) else: # Here is the grid range u = linspace(-1, 1.5, 50) v = linspace(-1, 1.5, 50) z = zeros((len(u), len(v))) # Evaluate z = theta*x over the grid for i in range(len(u)): for j in range(len(v)): z[i,j] = dot(mapFeature(u[i], v[j]), theta) z = z.T # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the level as [0] contour(u, v, z, [0], linewidth=2) hold(False) return fig
def plotDecisionBoundary(theta, X, y, degree): #PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with #the decision boundary defined by theta # PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the # positive examples and o for the negative examples. X is assumed to be # a either # 1) Mx3 matrix, where the first column is an all-ones column for the # intercept. # 2) MxN, N>3 matrix, where the first column is all-ones # plot Data index0 = np.where(y == 0)[0] index1 = np.where(y == 1)[0] plt.plot(X[index0, 1], X[index0, 2], 'ro') plt.plot(X[index1, 1], X[index1, 2], 'g+') if X.shape[1] <= 3: # only need 2 points to define a line, so choose two endpoints plot_x = np.array([np.amin(X[:, 1]) - 2, np.amax(X[:, 1]) + 2]) # calculate the decision boundary line plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) # plot, and adjust axes for better viewing plt.plot(plot_x, plot_y) # legend, specific for the exercise plt.legend(['Admitted', 'Not admitted', 'Decision Boundary']) plt.axis([30, 100, 30, 100]) else: # here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) # evaluate z = theta*x over the grid for i in range(len(u)): for j in range(len(v)): model = mapFeature(u[i], v[j], degree) z[i, j] = np.dot(model, theta) # end # end z = z.T plt.contour(u, v, z, 0)
def plotDecisionBoundary(theta, X, y): '''Plots the data points X and y into a new figure with the decision boundary defined by theta''' # plots the data points with + for the # positive examples and o for the negative examples. X is assumed to be # a either # 1) Mx3 matrix, where the first column is an all-ones column for the # intercept. # 2) MxN, N>3 matrix, where the first column is all-ones # Plot Data if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([np.min(X[:, 1])-2, np.max(X[:, 1])+2]) # Calculate the decision boundary line # plot_y = (-1./theta(3)).*(theta(2).*plot_x + theta(1)) plot_y = -(plot_x*theta[1]+theta[0])/theta[2] # Plot, and adjust axes for better viewing plt.plot(plot_x, plot_y, label='Decision Boundary') # Legend, specific for the exercise plt.axis([30, 100, 30, 100]) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) # Evaluate z = theta*x over the grid # for i = 1:length(u) # for j = 1:length(v) # z(i,j) = mapFeature(u(i), v(j))*theta # end # end for i in range(len(u)): for j in range(len(v)): z[i, j] = mapFeature(np.array(u[i]), np.array(v[j])).dot(theta) u, v = np.meshgrid(u, v) z = z.T # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the range [0, 0] plt.contour(u, v, z, levels=0)
def plotDecisionBoundary(theta, X, y): if(np.size(X, 1) <= 3): plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 2]) + 2]) plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) plt.plot(plot_x, plot_y) else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) for i,ui in enumerate(u): for j,vi in enumerate(v): z[i, j] = mapFeature(ui.reshape(-1,1), vi.reshape(-1,1)) @ theta plt.contour(u,v, z.T, 0) return z
def plotDecisionBoundary(theta, X, y): # Plos the data points X and y into a new figure with # the decision boundary defined by theta # ------------------------------ # This function plots the data point + for the # positive examples and o the negative examples. # X is assumed to be a either # 1) Mx3 Matrix, where the first column is an all ones # columns for the intercept # 2) MxN, N > 3 matrix, where the first column is all-ones\ # plot data plotData(X[:, 1:], y) if X.shape[1] <= 3: # Only need 2 points to define line, so choose two endpoints plot_x = np.array([[np.min(X[:, 1]) - 2], [np.max(X[:, 1]) - 2]]) # Caculate the decision boundary line plot_y = -1. / theta[2] * (theta[1] * plot_x + theta[0]) # Plot, and adjust axes for better viewing plt.plot(plot_x, plot_y) else: # Here is the grid range u = np.linspace(-1, 1.25, 50) v = np.linspace(-1, 1.25, 50) u = u.reshape((50, 1)) v = v.reshape((50, 1)) z = np.zeros((len(u), len(v))) # Evaluate z = theta*x over the grid for i in range(len(u)): for j in range(len(v)): f = mapFeature(u[i], v[j]) f = f.reshape((len(f), 1)) z[i][j] = f.T.dot(theta) uu, vv = np.meshgrid(u, v) plt.contour(uu, vv, z, 0)
def plotDecisionBoundary(theta, X, y): PD.plotData(X[:,[1,2]], y) if X.shape[1] <= 3: slope = -theta[1]/theta[2] intercept = -theta[0]/theta[2] plot_x = np.array([min(X[:,1])-2, max(X[:,2])+2]) #X-co-ordinate of the end points of decision line plot_y = slope*plot_x + intercept #Decison line plt.plot(plot_x, plot_y, c="orange", label="decision boundary") plt.legend() else: u_vals = np.linspace(-1, 1.5, 50) v_vals = np.linspace(-1, 1.5, 50) z = np.zeros((len(u_vals), len(v_vals))) for i in range(len(u_vals)): for j in range(len(v_vals)): X1 = np.array([u_vals[i]]) X2 = np.array([v_vals[j]]) z[i, j] = MP.mapFeature(X1,X2)@theta plt.contour(u_vals, v_vals, z.T, 0)
def plotDecisionBoundary(X, y, theta): if X.shape[1] <= 3: plotData(X[:, 1:], y) plot_x = np.array([[np.min(X[:, 2]), np.max(X[:,2])]]) plot_y = (-1./theta[2])*(theta[1]*plot_x + theta[0]) plt.plot(np.squeeze(plot_x), np.squeeze(plot_y)) else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((u.shape[0], v.shape[0])) for i in range(u.shape[0]): for j in range(v.shape[0]): z[i, j] = mapFeature( np.array( [[u[i]]] ) , np.array( [[v[j]]] ) ).dot(theta) cset = plt.contour(u, v, z.T, [0, 100]) cset.collections[1].set_label('Decision Boundary')
def plotDecisionBoundary(theta, X, y): """PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with the decision boundary defined by theta PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the positive examples and o for the negative examples. X is assumed to be a either 1) Mx3 matrix, where the first column is an all-ones column for the intercept. 2) MxN, N>3 matrix, where the first column is all-ones""" if X.shape[1] <= 3: #Only need 2 points to define a line, so choose two endpoints plot_x = np.c_[np.min(X[:,1]) - 2, np.max(X[:,1]) + 2]; #Calculate the decision boundary line left = -1 / theta[2] right = theta[1] * plot_x + theta[0] plot_y = left * right #Plot, and adjust axes for better viewing line, = plt.plot(plot_x.flatten(), plot_y.flatten(), c = 'b', label="Decision Boundary", marker="*") plt.axis([30, 100, 30, 100]) return line else: #Here is the grid range u = np.linspace(-1, 1.5, num=50) v = np.linspace(-1, 1.5, num=50) A, B = np.meshgrid(u, v) z = np.zeros((u.size, v.size)) #Evaluate z = theta*x over the grid for i in range(u.size): for j in range(v.size): z[i,j] = np.dot(mapFeature(u[i], v[j]), theta) z = z.T # important to transpose z before calling contour #Plot z = 0 #Notice you need to specify the range [0, 0] return plt.contour(A, B, z)
def plotDecisionBoundary(ax, theta, X, y): ''' %PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with %the decision boundary defined by theta % PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the % positive examples and o for the negative examples. X is assumed to be % a either % 1) Mx3 matrix, where the first column is an all-ones column for the % intercept. % 2) MxN, N>3 matrix, where the first column is all-ones ''' if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:, 2]), max(X[:, 2])]) # Calculate the decision boundary line plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0]) # Plot, and adjust axes for better viewing ax.plot(plot_x, plot_y) # Legend, specific for the exercise plt.legend(['Admitted', 'Not admitted'], loc='upper right', fontsize='x-small', numpoints=1) plt.axis([30, 100, 30, 100]) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.array([ mapFeature(u[i], v[j]).dot(theta) for i in range(len(u)) for j in range(len(v)) ]) #Reshape to get a 2D array z = np.reshape(z, (50, 50)) #Draw the plot plt.contour(u, v, z, levels=[0.0])
def plot(data, theta): t1 = np.arange(-1,1.5,0.01) t2 = np.arange(-1,1.5,0.01) T1, T2 = np.meshgrid(t1,t2) T1_flat = T1.ravel() T2_flat = T2.ravel() pontos = np.array([T1_flat, T2_flat]).T X_pontos = mapFeature(pontos[:,0],pontos[:,1], 6) y_pred = predict(X_pontos,theta) Z = np.array(y_pred, ndmin=2) Z = Z.reshape(T1.shape) plot_ex2data2.plot(data) plt.contour(T1, T2, Z, levels=[0], linewidths=2, colors='g',alpha=0.8)
def plotDecisionBoundary(theta, X, y, legend, label, title=None): plt.ion() plotData(X[:, 1:], y, legend, label) n = X.shape[1] if n <= 3: plot_x = np.array([X[:, 1].min(axis=0) - 2, X[:, 1].max(axis=0) + 2]) plot_y = -1 / theta[2] * (theta[1] * plot_x + theta[0]) plt.plot(plot_x, plot_y, label='Decision Boundary') else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros([len(u), len(v)]) for i in range(len(u)): for j in range(len(v)): z[i, j] = mapFeature(u[i], v[j], 1) @ theta plt.contour(u, v, z.T, [0], linewidths=2) if title: plt.title(title) plt.legend() plt.ioff() plt.show() plt.close('all')
def plotDecisionBoundary(theta,X,y): #importing some useful modules import plotData as pD #linear algebra computations using numpy import numpy as np #plotting module import pylab as plt import mapFeature as mF # plot the Data pD.plotData(X[:,1:3],y) #getting the shape of the matrix x m,n=np.shape(X) #starting an interactive mode in pylab plt.ion() if (n<=3): #Only need 2 points to define a line, so choose two endpoints plot_x= np.min(X[:,1])-2,np.max(X[:,1])+2 #plot plot_y=np.dot((-1./theta[2]),np.dot(theta[1],plot_x)+theta[0]) plt.plot(plot_x, plot_y) else: u =np.linspace(-1, 1.5, 50); u=u.reshape(np.size(u),1); v = np.linspace(-1, 1.5, 50); v=v.reshape(np.size(v),1); z = np.matrix(np.zeros((len(u), len(v)),dtype=float)); for i in range (len(u)): for j in range(len(v)): z[i,j]=np.dot(mF.mapFeature(u[i], v[j]),theta) #reshaping back to original way to enable the plotting u =np.linspace(-1, 1.5, 50); v =np.linspace(-1, 1.5, 50); #plotting a contour for the decision boundary z is transposed plt.contour(u, v,np.transpose( z),(0,0),label="decision")
def plotDecisionBoundary(theta, X, y): f2 = plotData(X[:, 1:], y) # print(X[:, 1:]) m, n = X.shape if n <= 3: # Only need 2 points to define a line, so choose two endpoints minVals = X[:, 1].min(0)-2 maxVals = X[:, 1].max(0)+2 plot_x = np.array([minVals, maxVals]) plot_y = (-1 / theta[2]) * (plot_x.dot(theta[1]) + theta[0]) f2.plot(plot_x, plot_y, label="Test Data", color='b') plt.show() else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) for i in range(len(u)): for j in range(len(v)): z[i, j] = mapFeature.mapFeature(u[i], v[j])* theta
def plotDecisionBoundary(theta, X, y): theta = np.array(theta) if X.shape[1] <= 3: plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2]) #calcular fronteira de decisão plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0]) #ajuste plt.plot(plot_x, plot_y) #legendas plt.legend(['Admitido', 'Não admitido', 'Fronteira de decisão']) plt.xlim([30, 100]) plt.ylim([30, 100]) else: #alcance do grid u = np.linspace(-1, 1.5, 50) v = np.linspace(-0.8, 1.2, 50) z = np.zeros((u.size, v.size)) for i, ui in enumerate(u): for j, vj in enumerate(v): z[i, j] = np.dot(mapFeature(ui, vj), theta) z = z.T plt.contour(u, v, z, levels=[0], linewidths=2, colors='g') plt.contourf(u, v, z, levels=[np.min(z), 0, np.max(z)], cmap='Greens', alpha=0.4)
def plotDecisionBoundary(theta, X, y): # Plot Data plotData(X[:, 1:3], y) if size(X, 1) <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = array([min(X[:, 1]) - 2, max(X[:, 1]) + 2]) # Calculate the decision boundary line plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) # Plot, and adjust axes for better viewing plt.plot(plot_x, plot_y) # Legend, specific for the exercise plt.legend(['Admitted', 'Not admitted', 'Decision Boundary']) plt.xlim([30, 100]) plt.ylim([30, 100]) else: # Here is the grid range u = linspace(-1, 1.5, 50) v = linspace(-1, 1.5, 50) z = zeros((u.size, v.size)) # Evaluate z = theta*x over the grid for i in range(size(u, 0)): for j in range(size(v, 0)): z[i, j] = mapFeature(array([u[i]]), array([v[j]])) @ theta z = z.T # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the range [0, 0] plt.contour(u, v, z, levels=[0], linewidths=2, colors='c')
def plotDecisionBoundary(theta, X, y): """Plots the data points with + for the positive examples and o for the negaive examples. X is assumed to be a either 1) Mx3 matrix, where the first column is an all-ones column for the intercept. 2) MxN, N>3 matrix, where the first column is all-ones """ # Plot Data plotData(X[:, 1:], y) plt.ion() if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:, 1]) - 2, max(X[:, 1]) + 2]) # Calculate the decision boundary line plot_y = (-1 / theta[2]) * (theta[2] * plot_x + theta[0]) # Plot plt.plot(plot_x, plot_y) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) # Evaluate z = theta*x over the gird for i, u_ in enumerate(u): for j, v_ in enumerate(v): z[i, j] = mapFeature(u_, v_) @ theta z = z.T # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the range [0, 0] plt.contour(u, v, z, levels=[0], linewidths=2) plt.ioff()
def main(): config_path = './config.json' model_path = './model.json' names_path = './price.json' accuracy_path = './accuracy.json' config = pd.read_json(config_path, typ='series') data_path = config['Dataset'] theta = np.array([config['Theta']]).T alpha = config['Alpha'] lamb = 0 num_iter = config['NumIter'] with open(data_path, 'rb') as csvfile: data = np.loadtxt(csvfile, delimiter=',') new_data = mF.mapFeature(data[:, 0], data[:, 1]) length = len(new_data) X = np.array(new_data) y = np.array(data[:, -1]).reshape((length, 1)) theta = gradientDescent(X, y, theta, lamb, alpha, num_iter) THETA = theta.T THETA = THETA.tolist() model = {'Cost': computeCost(X, y, theta, lamb), 'Theta': THETA} MODEL = json.dumps(model) with open(model_path, 'w') as fm: fm.write(MODEL) accuracy = {'Accuracy': precison(y, predict(X, theta))} ACCURACY = json.dumps(accuracy) with open(accuracy_path, 'w') as fa: fa.write(ACCURACY) fa.close() fm.close()
def plotDecisionBoundary(theta, X, y): plt.figure() plotData(X[:, 1:], y) if X.shape[1] <= 3: #Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:, 2]), max(X[:, 2])]) #Calculate the decision boundary line #theta0 + theta1*x1 + theta2*x2 = 0 #y=mx+b is replaced by x2 = (-1/thetheta2)(theta0 + theta1*x1) plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) plt.plot(plot_x, plot_y) else: u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros((len(u), len(v))) for i in range(len(u)): for j in range(len(v)): z[i, j] = np.dot(mapFeature(np.array([u[i]]), np.array([v[j]])), theta) z = np.transpose(z) plt.contour(u, v, z, levels=[0], linewidth=2).collections[0]
from scipy.optimize import fmin_bfgs from plotData import plotData from plotDecisionBoundary import plotDecisionBoundary from mapFeature import mapFeature from costFunctionReg import costFunctionReg from predict import predict data = np.loadtxt("ex2data2.txt", usecols=(0,1,2), delimiter=',',dtype=None) X = data[:, 0:2] y = data[:, 2] y = y[:, np.newaxis] l = 1 m, n = X.shape plotData(X, y) X = mapFeature(X[:, 0][np.newaxis].T, X[:, 1][np.newaxis].T) m, n = X.shape theta = np.zeros((1, n)) #find out why is there so huge difference between fmin and fmin_bfgs ? #fmin gives totaly wrong result options = {'full_output': True, 'retall': True} theta, cost, _, _, _, _, _, allvecs = fmin_bfgs(lambda t: costFunctionReg(X, y, t, l), theta, maxiter=400, **options) plotDecisionBoundary(X, y, theta) #plt.show() p = predict(X, theta[np.newaxis])[np.newaxis] print np.mean((p.T == y)) * 100
import numpy as np import readData import plotData from computeCost import computeRegularizedCost from gradientDescent import regularizedLogisiticDeriv from mapFeature import mapFeature from scipy.optimize import fmin_bfgs if __name__=="__main__": (x,y,nexamples) = readData.readSecond() #plotData.plotPoints(x,y) degree = 6 (X,nfeatures) = mapFeature(x,degree) theta = np.zeros(nfeatures+1) lam = 1 # should return 0.693 for the second data set print computeRegularizedCost(theta,X,y,lam) # this code is only used for my gradient descent # which converges quite slowly compared to bfgs method #iterations = 100000 #alpha = 0.001 #gradientDescent.gradientDescent(X,y,theta,alpha,iterations) theta=fmin_bfgs(computeRegularizedCost,theta,fprime=regularizedLogisiticDeriv,args=(X,y,lam))
from cost_function import cost_function from batch_gradient_update import batch_gradient_update from sigmoid_function import sigmoid_function from featureNormalize import featureNormalize import numpy as np from mapFeature import mapFeature from regularized_cost_function import regularize_cost_function import scipy as sp X,y=read_data("ex2data2.txt") # after featureNormalize it accuarcy could get 89% X,X_mu,X_sigma=featureNormalize(X) #plot_data(X,y) y=np.reshape(y,(y.size,1)) #*********** mapFeature 2D-->28D X=mapFeature(X) X=np.concatenate((np.ones([len(X[0,:]),1]),X.T),axis=1) llambda=1 m,n=X.shape initial_theta=np.zeros([n,1]) cost,grad=regularize_cost_function(initial_theta,X,y,llambda) theta=batch_gradient_update(initial_theta,X,y,llambda) print theta prob=sigmoid_function(np.dot(X,theta)) print prob prob[prob>0.5]=1.0 prob[prob<0.5]=0.0 print prob y=np.reshape(y,prob.shape) print "accuracy:",tuple(1-sum(abs(prob-y))/100)
# =========== Part 1: Regularized Logistic Regression ============ # In this part, you are given a dataset with data points that are not # linearly separable. However, you would still like to use logistic # regression to classify the data points. # # To do so, you introduce more features to use -- in particular, you add # polynomial features to our data matrix (similar to polynomial # regression). # # Add Polynomial Features # Note that mapFeature also adds a column of ones for us, so the intercept # term is handled X = mapFeature(X[:, 0], X[:, 1]) # Initialize fitting parameters initial_theta = np.zeros(X.shape[1],) # Set regularization parameter lambda to 1 lmbda = 1 # Compute and display initial cost and gradient for regularized logistic # regression cost, grad = costFunctionReg(initial_theta, X, y, lmbda) print('Cost at initial theta (zeros): %f' % cost) input('Program paused. Press enter to continue.\n')
if __name__ == "__main__": # Load Data filename = 'data/data2.dat' data = loadtxt(filename, delimiter=',') X = data[:, 0:2] y = np.array([data[:, 2]]).T n,d = X.shape # Standardize the data mean = X.mean(axis=0) std = X.std(axis=0) X = (X - mean) / std # map features into a higher dimensional feature space X = mapFeature(X[:,0],X[:,1]) # train logistic regression logregModel = LogisticRegression() logregModel.fit(X,y) # reload the data for 2D plotting purposes data = loadtxt(filename, delimiter=',') PX = data[:, 0:2] y = data[:, 2] # Standardize the data mean = PX.mean(axis=0) std = PX.std(axis=0) PX = (PX - mean) / std
plotData(X, y, xlabel='Microchip Test 1', ylabel='Microchip Test 2', legends=['y = 1', 'y = 0']) # =========== Part 1: Regularized Logistic Regression ============ # In this part, you are given a dataset with data points that are not # linearly separable. However, you would still like to use logistic # regression to classify the data points. # # To do so, you introduce more features to use -- in particular, you add # polynomial features to our data matrix (similar to polynomial # regression). # Note that mapFeature also adds a column of ones for us, so the intercept # term is handled X = mapFeature(X[:, [0]], X[:, [1]]) # Initialize fitting parameters initial_theta = np.zeros(X.shape[1]) # Set regularization parameter lambda to 1 lamda = 1 cost, _ = costFunctionReg(initial_theta, X, y, lamda) print('Cost at initial theta (zeros):', cost) # ============= Part 2: Regularization and Accuracies ============= # Optional Exercise: # In this part, you will get to try different values of lambda and # see how regularization affects the decision coundart
def plotDecisionBoundary(theta, X, y): #PLOTDECISIONBOUNDARY Plots the data points X and y into a new figure with #the decision boundary defined by theta # PLOTDECISIONBOUNDARY(theta, X,y) plots the data points with + for the # positive examples and o for the negative examples. X is assumed to be # a either # 1) Mx3 matrix, where the first column is an all-ones column for the # intercept. # 2) MxN, N>3 matrix, where the first column is all-ones import matplotlib.pyplot as plt import numpy as np import mapFeature as mf import plotData as pd # Plot Data fig = plt.figure() plt, p1, p2 = pd.plotData(X[:,1:3], y) plt.hold(True) if X.shape[1] <= 3: # Only need 2 points to define a line, so choose two endpoints plot_x = np.array([min(X[:,1])-2, max(X[:,1])+2]) # Calculate the decision boundary line plot_y = (-1./theta[2])*(theta[1]*plot_x + theta[0]) # Plot, and adjust axes for better viewing p3 = plt.plot(plot_x, plot_y) # Legend, specific for the exercise plt.legend((p1, p2, p3[0]), ('Admitted', 'Not Admitted', 'Decision Boundary'), numpoints=1, handlelength=0.5) plt.axis([30, 100, 30, 100]) plt.show(block=False) else: # Here is the grid range u = np.linspace(-1, 1.5, 50) v = np.linspace(-1, 1.5, 50) z = np.zeros(( len(u), len(v) )) # Evaluate z = theta*x over the grid for i in xrange(len(u)): for j in xrange(len(v)): z[i,j] = np.dot(mf.mapFeature(np.array([u[i]]), np.array([v[j]])),theta) z = np.transpose(z) # important to transpose z before calling contour # Plot z = 0 # Notice you need to specify the level 0 # we get collections[0] so that we can display a legend properly p3 = plt.contour(u, v, z, levels=[0], linewidth=2).collections[0] # Legend, specific for the exercise plt.legend((p1,p2, p3),('y = 1', 'y = 0', 'Decision Boundary'), numpoints=1, handlelength=0) plt.show(block=False) plt.hold(False) # prevents further drawing on plot
## =========== Part 1: Regularized Logistic Regression ============ # In this part, you are given a dataset with data points that are not # linearly separable. However, you would still like to use logistic # regression to classify the data points. # # To do so, you introduce more features to use -- in particular, you add # polynomial features to our data matrix (similar to polynomial # regression). # # Add Polynomial Features # Note that mapFeature also adds a column of ones for us, so the intercept # term is handled X = mapFeature(X[:,0], X[:,1]) # Initialize fitting parameters initial_theta = zeros(size(X, 1)) # Set regularization parameter lambda to 1 lambda_ = 1. # Compute and display initial cost and gradient for regularized logistic # regression cost, grad = costFunctionReg(initial_theta, X, y, lambda_) print('Cost at initial theta (zeros): %f' % cost) print('\nProgram paused. Press enter to continue.') input()
% % To do so, you introduce more features to use -- in particular, you add % polynomial features to our data matrix (similar to polynomial % regression). % % Add Polynomial Features % Note that mapFeature also adds a column of ones for us, so the intercept % term is handled """ # Note that mapFeature also adds a column of ones for us, so the intercept term is handled X = mF.mapFeature(X[:,0], X[:,1]); #Initialize fitting parameters m,n=np.shape(X) #initial guess initial_theta =np.zeros((n, 1),dtype=float); #regularization parameter .this can be changed labda = 1.; #importing optimization module and costfunction with regularization lambda from scipy import optimize; import costFunctionReg as cFR #getting the cost from the function cost=cFR.costFunctionReg(initial_theta,X,y,labda) #optimizing using BFGS important to set jac=False i.e. jacobian is set to false res = optimize.minimize(cFR.costFunctionReg, initial_theta, args=(X,y,labda), \ method='BFGS',jac=False, options={'maxiter':400})