wip

Author: whyboris

.gitignore

@@ -0,0 +1,6 @@
+.ipynb_checkpoints
+.vscode
+__pycache__
+output
+venv
+

con-net-mnist.py

@@ -0,0 +1,53 @@
+print('Convnet solution to MNIST dataset')
+
+from hack import hack
+
+hack()
+
+from keras import datasets
+
+from keras.utils.np_utils import to_categorical
+
+(train_images, train_labels), (validation_images, validation_labels) = datasets.mnist.load_data()
+
+train_images = train_images.reshape((60000, 28, 28, 1))
+train_images = train_images.astype('float32') / 255
+
+validation_images = validation_images.reshape((10000, 28, 28, 1))
+validation_images = validation_images.astype('float32') / 255
+
+train_labels = to_categorical(train_labels)
+validation_labels = to_categorical(validation_labels)
+
+
+from keras import models
+from keras import layers
+
+model = models.Sequential()
+
+model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
+model.add(layers.MaxPooling2D((2, 2)))
+model.add(layers.Conv2D(64, (3, 3), activation='relu'))
+model.add(layers.MaxPooling2D((2, 2)))
+model.add(layers.Conv2D(64, (3, 3), activation='relu'))
+model.add(layers.Flatten())
+model.add(layers.Dense(64, activation='relu'))
+model.add(layers.Dense(10, activation='softmax'))
+
+model.summary()
+
+model.compile(optimizer='rmsprop',
+              loss='categorical_crossentropy',
+              metrics=['accuracy'])
+
+model.fit(train_images, train_labels, epochs=5, batch_size=64)
+
+test_loss, test_accuracy = model.evaluate(validation_images, validation_labels)
+
+print(test_accuracy)
+
+
+
+
+
+

hack.py

@@ -0,0 +1,19 @@
+import os
+import ssl
+
+def hack():
+  
+    # --------------------------------------------------------------------
+    # disable the error:
+    # `Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA`
+    # --------------------------------------------------------------------
+    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+    # --------------------------------------------------------------------
+    # hack to avoid SSL download error
+    # --------------------------------------------------------------------
+    if (not os.environ.get('PYTHONHTTPSVERIFY', '') and
+            getattr(ssl, '_create_unverified_context', None)):
+        ssl._create_default_https_context = ssl._create_unverified_context
+
+

imdb.py

@@ -0,0 +1,83 @@
+print('IMDB classification')
+
+from hack import hack
+
+hack()
+
+
+import keras
+print('keras version ' + keras.__version__)
+
+import numpy as np
+
+def vectorize_sequences(sequences, dimension=10000):
+    results = np.zeros((len(sequences), dimension))
+    for i, sequence in enumerate(sequences):
+        results[i, sequence] = 1.
+    return results
+
+
+
+from keras.datasets import imdb
+
+(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)
+
+# print(train_data[0])
+
+x_train = vectorize_sequences(train_data)
+x_test = vectorize_sequences(test_data)
+
+# print(x_train[0])
+
+y_train = np.asarray(train_labels).astype('float32')
+y_test = np.asarray(test_labels).astype('float32')
+
+
+from keras import layers
+from keras import models
+# from keras import optimizers
+
+model = models.Sequential()
+model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
+model.add(layers.Dense(16, activation='relu'))
+model.add(layers.Dense(1, activation='sigmoid'))
+
+model.compile(optimizer='rmsprop',
+              loss='binary_crossentropy',
+              metrics=['accuracy'])
+
+x_val = x_train[:10000]
+partial_x_train = x_train[10000:]
+
+y_val = y_train[:10000]
+partial_y_train = y_train[10000:]
+
+history = model.fit(partial_x_train,
+                    partial_y_train,
+                    epochs=4,
+                    batch_size=512,
+                    validation_data=(x_val, y_val))
+
+
+history_dict = history.history
+print(history_dict.keys())
+
+import matplotlib.pyplot as plt
+
+acc = history.history['acc']
+loss_values = history_dict['loss']
+val_loss_values = history_dict['val_loss']
+
+epochs = range(1, len(acc) + 1)
+
+plt.plot(epochs, loss_values, 'bo', label='Training loss')
+plt.plot(epochs, val_loss_values, 'b', label='Validation loss')
+plt.title('Training and validation loss')
+plt.xlabel('Epochs')
+plt.ylabel('Loss')
+plt.legend()
+
+plt.show()
+
+# print(model.predict(x_test))
+

news.py

@@ -0,0 +1,113 @@
+print('Newswire classification')
+
+from hack import hack
+
+hack()
+
+
+from keras.datasets import reuters
+
+(train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000)
+
+print('train data: ' + str(len(train_data)))
+print('test data: ' + str(len(test_data)))
+
+print(train_data[10])
+
+# -- if you want to see inside the train_data, here's an example:
+# word_index = reuters.get_word_index()
+# reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
+# decoded_newswire = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])
+# print(decoded_newswire)
+
+import numpy as np 
+
+def vectorize_sequences(sequences, dimension=10000):
+    results = np.zeros((len(sequences), dimension))
+    for i, sequence in enumerate(sequences):
+      results[i, sequence] = 1.
+    return results
+
+x_train = vectorize_sequences(train_data)
+x_test = vectorize_sequences(test_data)
+
+# create a one-hot (categorical) encoding
+def to_one_hot(labels, dimension=46):
+    results = np.zeros((len(labels), dimension))
+    for i, label in enumerate(labels):
+        results[i, label] = 1.
+    return results
+
+one_hot_train_lables = to_one_hot(train_labels)
+one_hot_test_labels = to_one_hot(test_labels)
+
+
+# or more-simply use the pre-built keras method
+from keras.utils.np_utils import to_categorical
+
+one_hot_train_labels = to_categorical(train_labels)
+one_hot_test_labels = to_categorical(test_labels)
+
+
+from keras import models
+from keras import layers
+
+model = models.Sequential()
+
+model.add(layers.Dense(46, activation='relu', input_shape=(10000,)))
+model.add(layers.Dense(46, activation='relu'))
+model.add(layers.Dense(46, activation='softmax'))
+
+model.compile(optimizer='rmsprop',
+              loss='categorical_crossentropy',
+              metrics=['accuracy'])
+
+x_val = x_train[:1000]
+partial_x_train = x_train[1000:]
+
+y_val = one_hot_train_labels[:1000]
+partial_y_train = one_hot_train_labels[1000:]
+
+history = model.fit(partial_x_train,
+                    partial_y_train,
+                    epochs=20,
+                    batch_size=516,
+                    validation_data=(x_val, y_val))
+
+import matplotlib.pyplot as plt # pylint disable=E0401
+
+loss = history.history['loss']
+val_loss = history.history['val_loss']
+
+epochs = range(1, len(loss) + 1)
+
+plt.plot(epochs, loss, 'bo', label='Training loss')
+plt.plot(epochs, val_loss, 'b', label='Validation loss')
+plt.title('Training and validation loss')
+plt.xlabel('Epochs')
+plt.ylabel('Loss')
+plt.legend()
+
+plt.show()
+
+plt.clf()
+
+accuracy = history.history['acc']
+val_acc = history.history['val_acc']
+
+plt.plot(epochs, accuracy, 'bo', label='Accuracy')
+plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
+plt.title('Training and validation accuracy')
+plt.xlabel('Epochs')
+plt.ylabel('Accuracy')
+plt.legend()
+
+plt.show()
+
+
+
+
+
+
+
+