Sklearn-SVM&Tensorflow MLP fashion_mnist

# encoding = utf-8

import tensorflow as tf
from tensorflow import keras

from sklearn import neighbors, datasets
from sklearn.model_selection import train_test_split

(X_train, y_train), (X_test, y_test) = keras.datasets.fashion_mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], -1)
X_test = X_test.reshape(X_test.shape[0], -1)

assert X_train.shape == (60000, 784)  #checks if it's been reshaped - flattended here.Execution stops if not true
assert X_test.shape == (10000, 784)
X_train.dtype
#X_train[1]
#y_train[1:100]


train_df = pd.DataFrame(X_train)
train_df['label'] = pd.DataFrame(y_train)

test_df = pd.DataFrame(X_test)
test_df['label'] = pd.DataFrame(y_test)


for i in range(784):
    train_df[i] = train_df[i].apply(lambda x:x/255)
    test_df[i] = test_df[i].apply(lambda x:x/255)

from sklearn.svm import SVC

model = SVC(kernel='linear') 
model.fit(train_df.drop('label',1), train_df[['label']])

test_predict = model.predict(test_df.drop('label', 1))

from sklearn.metrics import classification_report
 
print(classification_report(y_test, test_predict))


precision    recall  f1-score   support

           0       0.75      0.81      0.78      1000
           1       0.97      0.96      0.97      1000
           2       0.74      0.77      0.75      1000
           3       0.85      0.84      0.85      1000
           4       0.76      0.77      0.77      1000
           5       0.93      0.94      0.93      1000
           6       0.63      0.56      0.59      1000
           7       0.92      0.93      0.93      1000
           8       0.95      0.93      0.94      1000
           9       0.95      0.94      0.95      1000

    accuracy                           0.85     10000
   macro avg       0.85      0.85      0.85     10000
weighted avg       0.85      0.85      0.85     10000


from sklearn.metrics import accuracy_score

print("accuracy:", accuracy_score(y_test, test_predict))

accuracy: 0.8464

class FashionMnistLoader():
    def __init__(self):
        mnist = tf.keras.datasets.mnist
        (self.train_data, self.train_label), (self.test_data, self.test_label) = keras.datasets.fashion_mnist.load_data()

        self.train_data = np.expand_dims(
            self.train_data.astype(
                np.float32) / 255.0,
            axis=-1)  # [60000, 28, 28, 1]
        self.test_data = np.expand_dims(
            self.test_data.astype(np.float32) / 255.0,axis=-1)   # [10000, 28, 28, 1]
        self.train_label = self.train_label.astype(np.int32)    # [60000]
        self.test_label = self.test_label.astype(np.int32)      # [10000]
        self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]

    def get_batch(self, batch_size):
        index = np.random.randint(0, np.shape(self.train_data)[0], batch_size)
        return self.train_data[index, :], self.train_label[index]


class MLP(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.flatten = tf.keras.layers.Flatten()
        self.dense1 = tf.keras.layers.Dense(units=100, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=10)

    def call(self, inputs):         # [batch_size, 28, 28, 1]
        x = self.flatten(inputs)    # [batch_size, 784]
        x = self.dense1(x)          # [batch_size, 100]
        x = self.dense2(x)          # [batch_size, 10]
        output = tf.nn.softmax(x)
        return output


import numpy as np

num_epochs = 5
batch_size = 50
learning_rate = 0.001
model = MLP()
data_loader = FashionMnistLoader()
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)

num_batches = int(data_loader.num_train_data // batch_size * num_epochs)
for batch_index in range(num_batches):
    X, y = data_loader.get_batch(batch_size)
    with tf.GradientTape() as tape:
        y_pred = model(X)
        loss = tf.keras.losses.sparse_categorical_crossentropy(
            y_true=y, y_pred=y_pred)
        loss = tf.reduce_mean(loss)
        print("batch %d: loss %f" % (batch_index, loss.numpy()))
    grads = tape.gradient(loss, model.variables)
    optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))

sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
num_batches = int(data_loader.num_test_data // batch_size)
for batch_index in range(num_batches):
    start_index, end_index = batch_index * \
        batch_size, (batch_index + 1) * batch_size
    y_pred = model.predict(data_loader.test_data[start_index: end_index])
    sparse_categorical_accuracy.update_state(
        y_true=data_loader.test_label[start_index: end_index], y_pred=y_pred)
print("test accuracy: %f" % sparse_categorical_accuracy.result())

batch 5999: loss 0.326429
test accuracy: 0.871800