def main(): # MNIST path data data_path = './Data/' mndata = MNIST(data_path) images_training, labels_training = mndata.load_training() images_testing, labels_testing = mndata.load_testing() images_training = np.asarray(images_training) images_testing = np.asarray(images_testing) # Normalize data images_training_normalize = preprocessing.normalize(images_training) labels_training = np.asarray(labels_training) # # This converts and plots the pca of a c x_hat, D = convert_pca(images_training_normalize[1]) data = np.array(images_training_normalize[1]).reshape(28, 28) plot_demo(data, x_hat) # We can plot our scree plot to determine what percentage of our variance is attributed to those features plot_scree(D) # Adding noise images_training_noise = create_noise(images_training) images_training_noise = np.array(images_training_noise) images_training_noise = preprocessing.normalize(images_training_noise) x_hat, D = convert_pca(images_training_noise[1]) data = np.array(images_training_noise[1]).reshape(28, 28) plot_demo(data, x_hat, fname='Noise_Comparison') plot_scree(D, n=15, name='Scree_Plot_Noise')
def get_mnist(): mnist = MNIST('../datasets/MNIST') print("Loading Data ... ") x_train, y_train = mnist.load_training() #60000 samples x_test, y_test = mnist.load_testing() #10000 samples x_train = np.asarray(x_train).astype(np.float32) / 255 y_train = np.asarray(y_train).astype(np.int32) x_test = np.asarray(x_test).astype(np.float32) / 255 y_test = np.asarray(y_test).astype(np.int32) print("formatting data") training_labels = [] for y in y_train: label = np.zeros((10, 1)) label[y] = 1 training_labels.append(label) testing_labels = [] for y in y_test: label = np.zeros((10, 1)) label[y] = 1 testing_labels.append(label) training_data = [] for x, y in zip(x_train, training_labels): training_data.append((x.reshape(784, 1), y)) testing_data = [] for x, y in zip(x_test, testing_labels): testing_data.append((x.reshape(784, 1), y)) return (training_data, testing_data)
def MnistData(filepath = mnistpath): '''Loads Mnist and converts it into a pytorch tensor Input ----- filepath - 'string' Filepath for the location of the MNIST dataset Output ------ Xtrain - 'torch.tensor' Training set for the Mnist dataset trainLabels - 'torch.tensor' train labels Xtest - 'torch.tensor' Test set for the Mnist dataset testLabels - 'torch.tensor' test labels ''' # Load the MNIST Dataset mndata = MNIST(filepath) Xtrain, trainLabels = map(torch.tensor, mndata.load_training()) Xtest, testLabels = map(torch.tensor, mndata.load_testing()) Xtrain = Xtrain/255.0 # normalize dataset Xtest = Xtest/255.0 return Xtrain, trainLabels, Xtest, testLabels
def MnistData(filepath=mnistpath): '''Loads Mnist and converts it into a np.array Input ----- filepath - 'string' Filepath for the location of the MNIST dataset Output ------ Xtrain - 'np.array' Training set for the Mnist dataset Xtest - 'np.array' Test set for the Mnist dataset ''' # Load the MNIST Dataset mndata = MNIST(filepath) X, Labels = map(np.array, mndata.load_training()) Xtrain = X[:50000] Xtest = X[50000:] Xtrain = Xtrain / 255.0 # normalize dataset Xtest = Xtest / 255.0 return Xtrain, Labels, Xtest
def get_mnist_data(): mnist_data = MNIST('python-mnist/data') train_X, train_y = mnist_data.load_training() test_X, test_y = mnist_data.load_testing() train_X = np.array(train_X).reshape(-1, 28, 28) test_X = np.array(test_X).reshape(-1, 28, 28) train_y, test_y = np.array(train_y), np.array(test_y) return train_X, train_y, test_X, test_y
def load_data(self): mndata = MNIST('data') # This will load the train and test data x_train, y_train = mndata.load( './data/character/emnist-byclass-train-images-idx3-ubyte', './data/character/emnist-byclass-train-labels-idx1-ubyte') x_test, y_test = mndata.load( './data/character/emnist-byclass-test-images-idx3-ubyte', './data/character/emnist-byclass-test-labels-idx1-ubyte') # Convert data to numpy arrays and normalize images to the interval [0, 1] x_train = np.array(x_train) / 255.0 y_train = np.array(y_train) x_test = np.array(x_test) / 255.0 y_test = np.array(y_test) # Reshaping all images into 28*28 for pre-processing x_train = x_train.reshape(x_train.shape[0], 28, 28) x_test = x_test.reshape(x_test.shape[0], 28, 28) # for train data for t in range(697932): x_train[t] = np.transpose(x_train[t]) # for test data for t in range(116323): x_test[t] = np.transpose(x_test[t]) print('Process Complete: Rotated and reversed test and train images!') # Reshaping train and test data again for input into model x_train = x_train.reshape(x_train.shape[0], 784, 1) x_test = x_test.reshape(x_test.shape[0], 784, 1) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train = resh(x_train) x_test = resh(x_test) # one-hot encoding: y_train = np_utils.to_categorical(y_train, 62) y_test = np_utils.to_categorical(y_test, 62) print('EMNIST data loaded: train:', len(x_train), 'test:', len(x_test)) print('Flattened X_train:', x_train.shape) print('Y_train:', y_train.shape) print('Flattened X_test:', x_test.shape) print('Y_test:', y_test.shape) self.train_images = x_train self.test_images = x_test self.train_labels = y_train self.test_labels = y_test
def classifier(): mndata = MNIST("src/data/") images, labels = mndata.load_training() clf = KNeighborsClassifier() train_x = images[:100] train_y = labels[:100] clf.fit(train_x, train_y) return clf
def save(): mndata = MNIST(PATH_RAW) images, labels = mndata.load_training() data = list(zip(images, labels)) random.shuffle(data) images = [d[0] for d in data] labels = [d[1] for d in data] images = torch.tensor([[float(j) / 256.0 for j in i] for i in images], dtype=torch.float) labels = torch.tensor([[j] for j in labels], dtype=torch.long) torch.save(images, PATH_IMAGES) torch.save(labels, PATH_LABELS)
def __init__(self, cv_iters): """ create df for features and labels remove samples that are not shared between the two tables """ assert cv_iters > 2, 'Cross validation folds must be more than 2 folds' self.cv_iters = cv_iters mndata = MNIST('data') self.features, self.labels = mndata.load_training() images, labels = mndata.load_testing() self.features = self.features + images self.features = np.array(self.features) self.labels = self.labels + labels self.labels = np.reshape(np.array(self.labels), (-1, 1)) self.labels = self.labels == 8 #6825 samles of 8 in total of 70000 samples self.shuffle()
def MnistData(filepath=mnistpath): '''Loads Mnist and one hot encodes Y variable for both train and test variables Input ----- filepath - 'string' Filepath for the location of the MNIST dataset Output ------ Xtrain - 'np.array' Training set for the Mnist dataset Ytrain - 'np.array' One-hot encoded Y trained labels Xtest - 'np.array' Training set for the Mnist dataset Ytest - 'np.array' One-hot encoded Y trained labels ''' # Load the MNIST Dataset mndata = MNIST(filepath) Xtrain, labels_train = map(np.array, mndata.load_training()) Xtest, labels_test = map(np.array, mndata.load_testing()) Xtrain = Xtrain / 255.0 # normalize dataset Xtest = Xtest / 255.0 n, d = Xtrain.shape k = labels_train.max() + 1 # number of classes m = len(labels_test) # number of test observations Ytrain = np.zeros((n, k)) Ytrain[np.arange(n), labels_train] = 1 Ytest = np.zeros((m, k)) Ytest[np.arange(m), labels_test] = 1 return Xtrain, Ytrain, labels_train, Xtest, Ytest, labels_test
def EncodeMnist(values=(2, 7), encodingVal=(-1, 1), filepath=mnistpath): '''Function loads the mnist data, filters out anything outside of values indicated and encodes the labels with the encoded values indicated Input ----- filepath - 'string' Currently set to a global variable where the location of the mnist path values - 'list or tuple' Two values(0-9) to use for selecting binary values Output ------ X_trainC - 'np.array' training data set for the selected values X_testC - 'np.array' test data set for the selected values Y_train_lab - 'np.array' encoded values for the Y Values of the training set Y_test_lab - 'np.array' encoded values for the Y Values of the training set ''' # Load the MNIST Dataset mndata = MNIST(filepath) X_train, labels_train = map(np.array, mndata.load_training()) X_test, labels_test = map(np.array, mndata.load_testing()) X_train = X_train / 255.0 # normalize dataset X_test = X_test / 255.0 XtrainC, trainLab = binaryData(values, X_train, labels_train) XtestC, testLab = binaryData(values, X_test, labels_test) Ytrainlab = binarycode(trainLab, values, encodingVal) Ytestlab = binarycode(testLab, values, encodingVal) return XtrainC, Ytrainlab, XtestC, Ytestlab
def load_dataset(ds_path, training=True, mnist_format=True): if mnist_format: dataset = MNIST(ds_path) if training: return (dataset.load_training()[0], dataset.train_labels) else: return (dataset.load_testing()[0], dataset.test_labels) else: if training: with open(ds_path + "/training.json") as training_json: dataset = json.load(training_json) else: with open(ds_path + "/training.json") as testing_json: dataset = json.load(testing_json) imgs = [ast.literal_eval(img) for img in list(dataset.keys())] labels = list(dataset.values()) return (imgs, labels)
""" Render the image in each of it's retinal 'zones' This will be the basis of what each retinal unit views as we progress. Not that the pixels that will have the strongest stimuli are white (as they are closer to 1), areas of least stimuli are black (value close to 0). """ import random import numpy as np import matplotlib.pyplot as plt from mnist.loader import MNIST mndata = MNIST('/home/niloofar/snn-Akhil/Spiking-Neural-Network/mnist') images, labels = mndata.load_training() def get_next_image(index=0, pick_random = False, display=True): if pick_random: index = random.randint(0, len(images)-1) image = images[index] label = labels[index] if display: print('Label: {}'.format(label)) print(mndata.display(image)) image = np.asarray(image).reshape((28,28)) image_norm = (image * 255.0/image.max()) / 255. return image_norm, label def graph_retinal_image(image, stride): fig = plt.figure()
from mnist.loader import MNIST from PIL import Image mndata = MNIST('src/data/') images, labels = mndata.load_training() i = 4 image, label = images[i], labels[i] output = Image.new("L", (28, 28)) output.putdata(image) output.save("output.png")
# set1 = [ # SimpleExample([1, 1, 1], 1), # SimpleExample([0, 1, 1], 1), # SimpleExample([1, 1, 0], 0), # SimpleExample([0, 1, 0], 0), # SimpleExample([0, 0, 1], 0) # ] # pn = PerceptronNetwork(3, 1) # for i in range(100): # pn.fit(set1) # print(pn.testClassifier(set1)) mndata = MNIST(".") # mndata.load_training() mndata.load_testing() examples = [] # size = len(mndata.test_images) size = 50 for i in range(size): inpt = mndata.test_images[i] outpt = mndata.test_labels[i] example = SimpleExample(inpt, outpt) examples.append(example) pn = PerceptronNetwork(784, 10, 300) pn.fit(examples) print(pn.testClassifier(examples))
import numpy as np from deep_neural_network_batch_normalization import * from nn_utils import * from mnist.loader import MNIST # Loading data. db = '/Users/aclaudioquiros/Documents/NN Data/Data/MNIST_database/' mndata = MNIST(db) images, labels = mndata.load_training() images_test, labels_test = mndata.load_testing() images = np.array(images).T images_test = np.array(images_test).T labels = onehot(labels, images.shape) labels_test = onehot(labels_test, images_test.shape) images = normalize(images) images_test = normalize(images_test) # Playing with data to over fit model. # samples = 1e+3 # images = images[:, :int(samples)] # labels = labels[:, :int(samples)] # images = np.random.normal(0, 1, size=(400, 1000)) # layer_dim = [images.shape[0], 400, 400, 400, 400, 400, 400, 400, 400, 400, labels.shape[0]] # activations = [None, 'relu', 'relu', 'relu', 'relu', 'relu', 'relu', 'relu', 'relu', 'relu', 'softmax'] layer_dim = [images.shape[0], 125, 40, labels.shape[0]] activations = [None, 'relu', 'relu', 'softmax'] deep_nn = NeuralNetwork(layer_dim, activations, learning_rate=0.2, num_iterations=1000,
import numpy as np import scipy.sparse from mnist.loader import MNIST mndata = MNIST('./data') images, labels = mndata.load_training() t_images, t_labels = mndata.load_testing() images = np.array(images) t_images = np.array(t_images) labels = np.array(labels) t_labels = np.array(t_labels) print("training instances:", images.shape[0]) print("testing instances:", t_images.shape[0]) num_class = len(np.unique(labels)) print("There are", num_class, "classes") print("statistics for training") for i in range(num_class): print("class", i, "instances: ", np.sum(labels == i)) print("statistics for testing") for i in range(num_class): print("class", i, "instances: ", np.sum(t_labels == i))
import numpy as np import cv2 from collections import deque from mnist.loader import MNIST from sklearn.model_selection import train_test_split from keras.utils import np_utils from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten from keras.callbacks import ModelCheckpoint # Use python-mnist library to import pre-shuffled EMNIST letters data emnist_data = MNIST(path='data\\', return_type='numpy') emnist_data.select_emnist('letters') X, y = emnist_data.load_training() # Reshape the data X = X.reshape(124800, 28, 28) y = y.reshape(124800, 1) # Make it 0 based indices y = y - 1 # Split test and train X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=111) # Rescale the Images by Dividing Every Pixel in Every Image by 255 # Rescale [0,255] --> [0,1] X_train = X_train.astype('float32') / 255
# 1. prepare data import numpy as np import keras #from __future__ import print_function from keras.datasets import fashion_mnist from mnist.loader import MNIST ''' (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data() print('x_train shape:\t', x_train.shape) print('x_test shape:\t', x_test.shape) print('y_train shape:\t', y_train.shape) print('y_test shape:\t', y_test.shape) ''' mndata = MNIST('E:/AI/example/fashion') mndata.load_testing() mndata.load_training() x_test = mndata.test_images x_train = mndata.train_images y_test = np.asarray(mndata.test_labels) y_train = np.asarray(mndata.train_labels) x_test = np.asarray(x_test) x_train = np.asarray(x_train) y_test = np.asarray(y_test) y_train = np.asarray(y_train) x_test = x_test.reshape(10000, 28,28) x_train = x_train.reshape(60000, 28,28)
ridge regression. First, a the raw input of the MNIST used to test the accuracy of the closed formed solution with a fixed ridge regression regularization term Next, we explore the use of an affine transformation of the pixel values from d features to p features in an effor to increase our accuracy. We finally see performance of choosing a p and its test accuracy. @author: Christopher Salazar """ import numpy as np from mnist.loader import MNIST import matplotlib.pyplot as plt # Load the MNIST Dataset mndata = MNIST( r'C:\Users\salez\Documents\MISE Work\CSE 546\Homework\HW1\Programming\mnist' ) X_train, labels_train = map(np.array, mndata.load_training()) X_test, labels_test = map(np.array, mndata.load_testing()) X_train = X_train / 255.0 # normalize dataset X_test = X_test / 255.0 # Transform X_train and X_test into corresponding Y form d = len(X_train[0]) # Number of outputs k = 10 # Construct Y_train array per the form required for closed form solution n_train = len(X_train) Y_train = np.zeros((n_train, k))
#%% from mnist.loader import MNIST import base64 import struct #%% mndata = MNIST("./data") images, labels = mndata.load_testing() num_images = len(images) print(num_images) #%% def map_pixel_float(p): return float(p) / 256.0 #%% def image_to_float(image): return map(map_pixel_float, image) #%%
predictions[i] = perceptrons[i].predict(data.images[n]) prediction = np.argmax(predictions) if prediction == data.labels[n]: correct += 1 return correct / data.size def make_conf_matrix(data, perceptrons): predictions = np.zeros(CLASSES) matrix = np.zeros((CLASSES, CLASSES)) for n in range(0, data.size): for i in range(0, CLASSES): predictions[i] = perceptrons[i].predict(data.images[n]) prediction = np.argmax(predictions) matrix[prediction, data.labels[n]] += 1 return print(matrix) if __name__ == '__main__': mndata = MNIST('./images/') train_images, train_labels = mndata.load_training() test_images, test_labels = mndata.load_testing() train_data = data.Data() train_data.load(60000, train_images, train_labels) test_data = data.Data() test_data.load(10000, test_images, test_labels) perceps = [perceptron.Perceptron(784) for i in range(CLASSES)] # weights = np.random.rand(10, 785) - .5 train_on_set(train_data, test_data, perceps, ETA, 70) make_conf_matrix(test_data, perceps)
self.W = self.W - learning_rate * grad #Updating weight if it % 1000 == 0: #Checking if iteration%1000=0 and performing prediction y_train_pred = self.predict(X_test) plotnum1.append((np.mean(Y_test == y_train_pred), )) plt.plot() return loss_history class LinearSVM(LinearClassifier): def loss(self, X_batch, y_batch, reg): return compute_loss(self.W, X_batch, y_batch, reg) # In[5]: mndata = MNIST('E:/Grad School/Semester 2/ML/Homeworks/MNIST/') # In[6]: X_train, Y_train = mndata.load_training() #60000 samples X_test, Y_test = mndata.load_testing() #10000 samples # In[7]: X_train = np.asarray(X_train).astype(np.float32) Y_train = np.asarray(Y_train).astype(np.int32) X_test = np.asarray(X_test).astype(np.float32) Y_test = np.asarray(Y_test).astype(np.int32) # In[8]:
@author: phamk """ # %reset import numpy as np from mnist.loader import MNIST # require `pip install python-mnist` # https://pypi.python.org/pypi/python-mnist/ import matplotlib.pyplot as plt from sklearn import neighbors from sklearn.metrics import accuracy_score import time # you need to download the MNIST dataset first # at: http://yann.lecun.com/exdb/mnist/ mndata = MNIST('E:/AI/example/MNIST/') mndata.load_testing() mndata.load_training() X_test = mndata.test_images X_train = mndata.train_images y_test = np.asarray(mndata.test_labels) y_train = np.asarray(mndata.train_labels) start_time = time.time() clf = neighbors.KNeighborsClassifier(n_neighbors=1, p=2) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) end_time = time.time() print("Accuracy of 1NN for MNIST: %.2f %%" % (100 * accuracy_score(y_test, y_pred))) print("Running time: %.2f (s)" % (end_time - start_time))
from mnist.loader import MNIST import random import numpy as np mndata = MNIST('data') features, labels = mndata.load_training() images, tlabels = mndata.load_testing() features = features + images features = np.array(features) labels = labels + tlabels labels = np.reshape(np.array(labels),(-1,1)) for i in range(50): from PIL import Image img = Image.fromarray(np.reshape(features[i].astype(np.uint8),(28,28)), 'L') img.resize((256,256)).save('HD{}.png'.format(labels[i])) ''' labels = labels == 8 ones = np.array([i for i in range(labels.shape[0]) if labels[i]==1]) np.random.shuffle(ones) ones = np.reshape(ones,(5, -1)) #keys to feature where label is 0 zeros = np.array([i for i in range(labels.shape[0]) if labels[i]==0]) np.random.shuffle(zeros) zeros = np.reshape(zeros,(5, -1)) ind = list(range(5)) ind = np.delete(ind, 2) print(zeros[ind].flatten())
from keras.layers import Dense, Activation from keras import optimizers, regularizers from keras.models import Sequential import time import numpy as np import cv2 from mnist.loader import MNIST m = MNIST('./data') import os os.environ["CUDA_VISIBLE_DEVICES"] = "1" classes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] x_train, y_train = m.load_training() x_test, y_test = m.load_testing() x_train = np.asarray(x_train).astype(np.float32) y_train = np.asarray(y_train).astype(np.float32) x_test = np.asarray(x_test).astype(np.float32) y_test = np.asarray(y_test).astype(np.float32) n_classes = len(classes) #0-1 Hot encoding label_train = np.zeros((y_train.shape[0], n_classes)) a = np.arange(y_train.shape[0], dtype=np.int64) b = np.array(y_train, dtype=np.int64).reshape((y_train.shape[0], )) label_train[a, b] = 1 label_test = np.zeros((y_test.shape[0], n_classes)) c = np.arange(y_test.shape[0], dtype=np.int64) d = np.array(y_test, dtype=np.int64).reshape((y_test.shape[0], )) label_test[c, d] = 1
import pandas as pd from sklearn.model_selection import StratifiedKFold from mnist.loader import MNIST import numpy as np if __name__ == '__main__': mnist = MNIST('../input') x_train, y_train = mnist.load_training() #x_test, y_test = mnist.load_testing() x_train = np.asarray(x_train).astype(np.float32) y_train = np.asarray(y_train).astype(np.int32) #x_test = np.asarray(x_test).astype(np.float32) #y_test = np.asarray(y_test).astype(np.int32) print(f'Shape of X Train is {x_train.shape}') df = pd.DataFrame(data=x_train) df["label"] = y_train df = df.sample(frac=1).reset_index(drop=True) df['kfold'] = -1 kf = StratifiedKFold(n_splits=5) for f, (t_, v_) in enumerate(kf.split(X=df, y=y_train)): df.loc[v_, 'kfold'] = f print(df.head()) df.to_csv("../input/mnist_train_folds.csv", index=False)
def main(): # MNIST path data data_path = './Data/' mndata = MNIST(data_path) images_training, labels_training = mndata.load_training() images_testing, labels_testing = mndata.load_testing() images_training = np.asarray(images_training) images_testing = np.asarray(images_testing) images_training_noise = create_noise(images_training) images_testing_noise = create_noise(images_testing) labels_training = np.asarray(labels_training) labels_testing = np.asarray(labels_testing) # Normalize data images_training = preprocessing.normalize(images_training) images_testing = preprocessing.normalize(images_testing) images_training_noise = preprocessing.normalize(images_training_noise) images_testing_noise = preprocessing.normalize(images_testing_noise) images_training_pca_noise, images_testing_pca_noise = create_training_and_testing_data( images_training_noise, labels_training, images_testing_noise, labels_testing, n=15) pca_accuracy_list = deque() accuracy_list = deque() print('Starting classification') # KNN print('Starting KNN') knn_score = deque() knn_pca_score = deque() knn = KNeighborsClassifier() knn = knn.fit(images_training_noise, labels_training) knn_score.append(knn.score(images_testing_noise, labels_testing)) knn_pca = KNeighborsClassifier() knn_pca = knn_pca.fit(images_training_pca_noise, labels_training) knn_pca_score.append( knn_pca.score(images_testing_pca_noise, labels_testing)) knn_score = np.array(knn_score) knn_pca_score = np.array(knn_pca_score) accuracies_df = pd.DataFrame({ 'Scores': knn_score, 'PCA_Scores': knn_pca_score }).to_csv('KNNAccuracies_noise.csv', index=False) # Random Forest Accuracies clf_score = deque() clf_pca_score = deque() for n in range(1, 10): print('Iteration {} of Random Forest Classifier'.format(n)) clf = RandomForestClassifier(n_estimators=100) clf = clf.fit(images_training_noise, labels_training) clf_score.append(clf.score(images_testing_noise, labels_testing)) clf_pca = RandomForestClassifier(n_estimators=100) clf_pca = clf_pca.fit(images_training_pca_noise, labels_training) clf_pca_score.append( clf_pca.score(images_testing_pca_noise, labels_testing)) clf_score = np.array(clf_score) clf_pca_score = np.array(clf_pca_score) accuracies_df = pd.DataFrame({ 'Scores': clf_score, 'PCA_Scores': clf_pca_score }).to_csv('RandomForestAccuracies_noise.csv', index=False) # Decision Tree Accuracies dtc_score = deque() dtc_pca_score = deque() for n in range(1, 10): print('Iteration {} of Decision Tree Accuracies'.format(n)) dtc = tree.DecisionTreeClassifier() dtc = dtc.fit(images_training_noise, labels_training) dtc_score.append(dtc.score(images_testing_noise, labels_testing)) dtc_pca = tree.DecisionTreeClassifier() dtc_pca = dtc_pca.fit(images_training_pca_noise, labels_training) dtc_pca_score.append( dtc_pca.score(images_testing_pca_noise, labels_testing)) dtc_score = np.array(dtc_score) dtc_pca_score = np.array(dtc_pca_score) accuracies_df = pd.DataFrame({ 'Scores': dtc_score, 'PCA_Scores': dtc_pca_score }).to_csv('DecisionTreeAccuracies_noise.csv', index=False)
""" https://umap-learn.readthedocs.io/en/latest/supervised.html#using-labels-to-separate-classes-supervised-umap 公式リファレンス MNISTデータを使うために "https://pypi.org/project/python-mnist/" を参照してダウンロード、インストールしておく 教師付き次元削減とMetric learning """ import numpy as np from mnist.loader import MNIST import matplotlib.pyplot as plt import seaborn as sns sns.set(style='white', context='poster') mndata = MNIST('/Users/hamamatsuikadaigakubyouribu/UMAP_python/python-mnist/data') mndata train, train_labels = mndata.load_training() test, test_labels = mndata.load_testing() data = np.array(np.vstack([train, test]), dtype=np.float64) / 255.0 target = np.hstack([train_labels, test_labels]) classes = [ 'T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
from MNISTModule.classification_set import ClassificationSet from MNISTModule.classification import Classification from mnist.loader import MNIST import numpy as np import os samples_path = './SampleData/MNIST' write_path = './accuracy.txt' mndata = MNIST(samples_path) mnist_training_set = ClassificationSet() if os.path.exists(write_path): mode = 'a+' else: f = open(write_path, "w+") test_sigma = 8.5 images_training, labels_training = mndata.load_training() images_testing, labels_testing = mndata.load_testing() classification = Classification(images_training, labels_training, images_testing, labels_testing, sigma=test_sigma) classification.create_model() print(classification.calculate_accuracy(mode='verbose')) # with open(write_path, 'a+') as file: # file.write(str(test_sigma) + ',' + classification.calculate_accuracy(calculate=False, mode='return')) # file.write('\n')