def plot(self, mode='Learning Curves', source='Logs', logPath=None, title=''): ''' Description: This function is a wrapper for the appropriate plot function Found in the Tools package. It handles any architecture spec cific details, that the general plot function does not, such as: how many logs to read and plot in the same graph. Arguments: logPath (string): Location of the log files to read. If None, function will read the logs in the default location. mode (String): The plotting mode. Can be Learning Curves for the moment. title (String): A title for the plot. If left '', the default title is formed as defined in self.defPlotTitle ''' # Args is currently empty. Might have a use for some plotting arguments # In the future. Currently none are implemented. args = [] if source == 'Logs': if logPath is not None: logPath = logPath else: logPath = os.path.join( self.saveHisFolder, self.sep.join((self.defSavePrefix, "log1.txt"))) # Form plot title and facilate plotting title = self.descr + ' ' + mode self.plots[pidx.lrCurve] = utils.plot_classifier(filesPath=logPath, title=title, mode=mode) elif source == 'History': title = self.descr + mode self.plots[pidx.lrCurve] = utils.plot_classifier( inReps=self.history, title=title, mode=mode) self.plots[pidx.predCurve] = utils.plot_classifier( inReps=self.predHistory, title=title, mode='Prediction History')
plt.show() #------------------------------------------------------------------------------- # Part 2 - Linear Models #------------------------------------------------------------------------------- # K(x_j, x_i) = x_j * x_i # phi: [x1, x2] ==> [x1, x2] def linear_kernel(x_j, x_i): return np.dot(x_j, x_i) clf = lab4.KernelPerceptron(kernel=linear_kernel) clf.fit(X, y_linear) ax1 = plt.subplot(121) utils.plot_classifier(ax1, X, y_linear, clf, title='Linear Perceptron') clf = svm.SVC(kernel='linear') clf.fit(X, y_linear) ax2 = plt.subplot(122) utils.plot_classifier(ax2, X, y_linear, clf, title='Linear SVM') plt.show() #------------------------------------------------------------------------------- # Part 3 - Quadratic Models #-------------------------------------------------------------------------------
y.append(data[-1]) X = np.array(X) y = np.array(y) ## Create and Train Gaussian Naive Bayes Classifier classifier_gaussian_nb = GaussianNB() classifier_gaussian_nb.fit(X, y) ## Predict Y y_pred = classifier_gaussian_nb.predict(X) ## Compute Accuracy of classifier accuracy = 100.0 * (y == y_pred).sum() / X.shape[0] print("Accuracy of the classifier =", round(accuracy, 2), "%") plot_classifier(classifier_gaussian_nb, X, y) # Create Training / Test Data # 75% for Training, 25% for Testing # Model_Selection = Train/Test Split X_train, X_test, y_train, y_test = model_selection.train_test_split( X, y, test_size=0.25, random_state=5) X_train, X_test, y_train, y_test = model_selection.train_test_split( X, y, test_size=0.25, random_state=5) classifier_gaussian_nb_new = GaussianNB() classifier_gaussian_nb_new.fit(X_train, y_train) ## Test Accuracy of Model y_test_pred = classifier_gaussian_nb_new.predict(X_test) accuracy = 100.0 * (y_test == y_test_pred).sum() / X.shape[0] print("Accuracy of the classifier =", round(accuracy, 2), "%")
#reduce pixel features X = reducer.features(pixels) for c,v in testing.classMap.iteritems(): print "%s (%d): %d items in training set"%(c,v,np.sum(Y==v)) # PREDICT probs = np.array(model.predict_proba(X)) numClasses = probs.shape[1] #visualize model if called for if options.visualize: y_graph = Y[testing.classes!="noclass"] x_graph = X[testing.classes!="noclass"] print "shapes: ", y_graph.shape, x_graph.shape plot_classifier(x_graph, y_graph, model, testing.classMap) #confusion matrix and accuracy Y_pred = probs.argmax(1) confMat = metrics.confusion_matrix(Y, Y_pred) printConfusionMatrix(confMat, testing.intToClass) #classification report? report = metrics.classification_report(Y, Y_pred, target_names=testing.intToClass) print report # print accuracy for c in range(numClasses): correct = float(np.sum(Y_pred[Y==c]==c)) num = float(np.sum(Y==c)) print "Class %s (%d) accuracy: %f"%(testing.intToClass[c], c, correct/num)
random_state=0) # Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) # Fitting Decision Tree Classification to the Training set from sklearn.tree import DecisionTreeClassifier classifier = DecisionTreeClassifier(criterion='entropy', random_state=0) classifier.fit(X_train, y_train) # Predicting the Test set results y_pred = classifier.predict(X_test) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) # Visualising the Training and Test sets results from utils import plot_classifier plot_classifier(X_train, y_train, plot_title='Decision Tree Classification (Training set)', classifier=classifier) plot_classifier(X_test, y_test, plot_title='Decision Tree Classification (Test set)', classifier=classifier)
import numpy as np from sklearn import linear_model import matplotlib.pyplot as plt import utils ## Create Data Points X = np.array([[4, 7], [3.5, 8], [3.1, 6.2], [0.5, 1], [1, 2], [1.2, 1.9], [6, 2], [5.7, 1.5], [5.4, 2.2]]) y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2]) ## Initialize Logistic Classifier ## As we increase C, we increase the penalty for misclassification ## getting closer to optimal. classifier = linear_model.LogisticRegression(solver='liblinear', C=100) ## Train the classifier classifier.fit(X, y) ## Draw DataPoints utils.plot_classifier(classifier, X, y)
test_size=0.25, random_state=0) # Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) # Fitting Naive Bayes to the Training set from sklearn.naive_bayes import GaussianNB classifier = GaussianNB() classifier.fit(X_train, y_train) # Predicting the Test set results y_pred = classifier.predict(X_test) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) # Visualising the Training and Test sets results from utils import plot_classifier plot_classifier(X_train, y_train, plot_title='Naive Bayes (Training set)', classifier=classifier) plot_classifier(X_test, y_test, plot_title='Naive Bayes (Test set)', classifier=classifier)
test_size=0.25, random_state=0) # Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) # Fitting SVM to the Training set from sklearn.svm import SVC classifier = SVC(kernel='linear', random_state=0) classifier.fit(X_train, y_train) # Predicting the Test set results y_pred = classifier.predict(X_test) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) # Visualising the Training and Test sets results from utils import plot_classifier plot_classifier(X=X_train, y=y_train, plot_title="SVM (Training set)", classifier=classifier) plot_classifier(X=X_test, y=y_test, plot_title="SVM (Test set)", classifier=classifier)
random_state=0) # Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) # Fitting Kernel SVM to the Training set from sklearn.svm import SVC classifier = SVC(kernel='rbf', random_state=0) classifier.fit(X_train, y_train) # Predicting the Test set results y_pred = classifier.predict(X_test) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) # Visualising the Training and Test sets results from utils import plot_classifier plot_classifier(X=X_train, y=y_train, plot_title='Kernel SVM (Training set)', classifier=classifier) plot_classifier(X=X_test, y=y_test, plot_title='Kernel SVM (Test set)', classifier=classifier)
#reduce pixel features X = reducer.features(pixels) for c, v in testing.classMap.iteritems(): print "%s (%d): %d items in training set" % (c, v, np.sum(Y == v)) # PREDICT probs = np.array(model.predict_proba(X)) numClasses = probs.shape[1] #visualize model if called for if options.visualize: y_graph = Y[testing.classes != "noclass"] x_graph = X[testing.classes != "noclass"] print "shapes: ", y_graph.shape, x_graph.shape plot_classifier(x_graph, y_graph, model, testing.classMap) #confusion matrix and accuracy Y_pred = probs.argmax(1) confMat = metrics.confusion_matrix(Y, Y_pred) printConfusionMatrix(confMat, testing.intToClass) #classification report? report = metrics.classification_report(Y, Y_pred, target_names=testing.intToClass) print report # print accuracy for c in range(numClasses): correct = float(np.sum(Y_pred[Y == c] == c))
# Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) # Fitting Random Forest Classification to the Training set from sklearn.ensemble import RandomForestClassifier classifier = RandomForestClassifier(n_estimators=10, criterion='entropy', random_state=0) classifier.fit(X_train, y_train) # Predicting the Test set results y_pred = classifier.predict(X_test) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) # Visualising the Training and Test sets results from utils import plot_classifier plot_classifier(X_train, y_train, plot_title='Random Forest Classification (Training set)', classifier=classifier) plot_classifier(X_test, y_test, plot_title='Random Forest Classification (Test set)', classifier=classifier)
sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) # Fitting K-NN to the Training set from sklearn.neighbors import KNeighborsClassifier classifier = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2) classifier.fit(X_train, y_train) # Predicting the Test set results y_pred = classifier.predict(X_test) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) # Visualising the Training and Test sets results from utils import plot_classifier plot_classifier(X_train, y_train, plot_title="K-NN (Training set)", classifier=classifier) plot_classifier(X_test, y_test, plot_title="K-NN (Test set)", classifier=classifier)
reducer = PCAFeatures(n_comp=options.complexity) X = reducer.features(pixels) model = MultiSVM() model.fit(X,Y) #Logistic Regression if options.modelType=="ilogreg": reducer = NaiveFeatures() X = reducer.features(pixels) model = MultiLogReg() model.fit(X,Y) if options.modelType=="ilogreg_lda": reducer = LDAFeatures(n_comp=options.complexity) X = reducer.features(pixels, Y) model = MultiLogReg() model.fit(X,Y) #write model out if specified print "Model learned: %s"%model print "saving model as ", options.modelOut out = open(options.modelOut, 'wb') pickle.dump(model, out) pickle.dump(reducer, out) pickle.dump(options.pixels, out) out.close() #visualize model if called for if options.visualize: plot_classifier(X,Y,model,training.classMap)
# plt.show() #------------------------------------------------------------------------------- # Part 4.2 - Radial Kernel #------------------------------------------------------------------------------- def radial_kernel(x_j, x_i): return np.exp(np.linalg.norm(x_j - x_i)**2 / 2) clf = lab4.KernelPerceptron(kernel=radial_kernel) clf.fit(X, y_radial) ax1 = plt.subplot(121) utils.plot_classifier(ax1, X, y_radial, clf, title='RBF Perceptron') clf = svm.SVC(kernel='rbf') clf.fit(X, y_radial) ax2 = plt.subplot(122) utils.plot_classifier(ax2, X, y_radial, clf, title='RBF SVM') plt.show() #------------------------------------------------------------------------------- # Part 5 - Angle Models #------------------------------------------------------------------------------- # def phi_angular(x): # mag = np.linalg.norm(x)
if options.modelType == "isvm_pca": reducer = PCAFeatures(n_comp=options.complexity) X = reducer.features(pixels) model = MultiSVM() model.fit(X, Y) #Logistic Regression if options.modelType == "ilogreg": reducer = NaiveFeatures() X = reducer.features(pixels) model = MultiLogReg() model.fit(X, Y) if options.modelType == "ilogreg_lda": reducer = LDAFeatures(n_comp=options.complexity) X = reducer.features(pixels, Y) model = MultiLogReg() model.fit(X, Y) #write model out if specified print "Model learned: %s" % model print "saving model as ", options.modelOut out = open(options.modelOut, 'wb') pickle.dump(model, out) pickle.dump(reducer, out) pickle.dump(options.pixels, out) out.close() #visualize model if called for if options.visualize: plot_classifier(X, Y, model, training.classMap)
# plt.show() #------------------------------------------------------------------------------- # Part 4.2 - Radial Kernel #------------------------------------------------------------------------------- def radial_kernel(x_j, x_i): return np.exp(-np.sum(np.square(x_j - x_i)) / 2) clf = lab4.KernelPerceptron(kernel=radial_kernel) clf.fit(X, y_radial) ax1 = plt.subplot(121) utils.plot_classifier(ax1, X, y_radial, clf, title='RBF Perceptron') clf = svm.SVC(kernel='rbf') clf.fit(X, y_radial) ax2 = plt.subplot(122) utils.plot_classifier(ax2, X, y_radial, clf, title='RBF SVM') plt.show() #------------------------------------------------------------------------------- # Part 5 - Angle Models #------------------------------------------------------------------------------- # def phi_angular(x): # d = math.sqrt(x[0]*x[0]+x[1]*x[1])