recovered tp3.py

tp3.py

@@ -9,6 +9,8 @@ from sklearn.neural_network import MLPClassifier
 from sklearn.model_selection import train_test_split
 from sklearn.model_selection import KFold
 from sklearn.metrics import precision_score
+from sklearn.metrics import confusion_matrix
+from sklearn.svm import SVC
 import random
 import time
 
@@ -18,7 +20,6 @@ mnist = fetch_openml('mnist_784')
 """
 
 """
----Ex 1---
 images = mnist.data.values.reshape((-1, 28, 28)) 
 plt.imshow(images[0],cmap=plt.cm.gray_r,interpolation="nearest") 
 plt.show()
@@ -26,8 +27,6 @@ plt.show()
 print(mnist.target[0])
 """
 
-"""
----Ex 2---
 """
 indices = [i for i in range(len(mnist.data))]
 random.shuffle(indices)
@@ -35,60 +34,47 @@ indices = indices[:15000]
 
 data = [mnist.data.values[i] for i in indices]
 target = [mnist.target[i] for i in indices]
-
-bestClf = None
-bestScore = 0
-scores = []
-
-train_sizes = [0.05*i for i in range(1,20)]
-
+"""
 
 xtrain,  xtest,  ytrain,  ytest  =  train_test_split(data, target, train_size=0.7)
-"""
-network = MLPClassifier(hidden_layer_sizes = (50))
-network.fit(xtrain, ytrain)
-ytest_pred = clf.predict(xtest)
-print("Average = macro:")
-print(precision_score(ytest, ytest_pred, average = "macro"))
-print("Average = None:")
-print(precision_score(ytest, ytest_pred, average = None))
 
+clf = SVC()   
+clf.fit(xtrain, ytrain) 
+ypred = clf.predict(xtest)
+print(confusion_matrix(ytest, ypred))
+"""
 print(target[4])
-print(network.predict(data[4].reshape(1,-1)))
+print(clf.predict(data[4].reshape(1,-1)))
 plt.imshow(data[4].reshape(28, 28), cmap=plt.cm.gray_r, interpolation="nearest")
 plt.show()
 """
 
-"""
-n_layers = [i for i in range(1,51)]
-
-
-for n in n_layers:
-    print(n)
-    network = MLPClassifier(hidden_layer_sizes = (50,)*n)
-    network.fit(xtrain, ytrain)
-    scores += [network.score(xtest, ytest)]
-
-plt.plot(n_layers, scores)
-"""
 
 """
-for _ in range(5):
-    n_layers = random.randint(1,3)
-    layer_size = tuple([random.randint(10,300) for _ in range(n_layers)]) 
-    print(layer_size)
-    
-    network = MLPClassifier(hidden_layer_sizes = layer_size, solver = "adam", activation = "relu")
-    network.fit(xtrain, ytrain)
-    print(f"training time = {time.time() - start_time}, score = {network.score(xtest, ytest)}")
-"""
-
-"""
-solvers = ["lbfgs", "sgd", "adam"]
-for s in solvers:
-    print(s + ":")
+kernels = ["linear", "poly", "rbf", "sigmoid"]
+for k in kernels:
+    print(k + ":")
     start_time = time.time() 
-    network = MLPClassifier(hidden_layer_sizes = (50,)*5, solver = s)
-    network.fit(xtrain, ytrain)
-    print(f"training time = {time.time() - start_time}, score = {network.score(xtest, ytest)}")
+    clf = SVC(kernel = k)
+    clf.fit(xtrain, ytrain)
+    print(f"training time = {time.time() - start_time}, score = {clf.score(xtest, ytest)}")
+"""
+
+"""
+scores = []
+times = []
+tolerance=[i*0.1 for i in range(1,10,2)]
+for C in tolerance:
+    print(f"C = {C} :")
+    start_time = time.time() 
+    clf = SVC(C = C)
+    clf.fit(xtrain, ytrain)
+    training_time = time.time() - start_time
+    score = clf.score(xtest, ytest)
+    times += [training_time]
+    scores += [score]
+    
+plt.plot(tolerance, scores)
+plt.show()
+plt.plot(tolerance, times)
 """