feat: add use cases

ANN_Tifinagh_MNIST_Model.py

@@ -0,0 +1,130 @@
+# Classification by a classical ANN (MLP) - Tifinagh-MNIST
+
+## The libraries we will use
+"""
+
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+import cv2
+import keras
+from keras.models import Sequential
+from keras.layers import Dense, Dropout
+from tensorflow.keras.utils import to_categorical
+
+"""## Data loading and adaptation"""
+
+def upload_data(path_name, number_of_class, number_of_images): 
+    X_Data = []
+    Y_Data = []
+    for i in range(number_of_class):
+        images = os.listdir(path_name + str(i))
+        for j in range(number_of_images):
+            img = cv2.imread(path_name + str(i)+ '/' + images[j], 0)
+            X_Data.append(img)
+            Y_Data.append(i)
+        print("> the " + str(i) + "-th file is successfully uploaded.", end='\r') 
+    return np.array(X_Data), np.array(Y_Data)
+
+n_class = 33
+n_train = 2000
+n_test = 500
+#here we upload our data (Tifinagh data)
+x_train, y_train = upload_data('/media/etabook/etadisk1/EducFils/PFE/DATA2/train_data/', n_class, n_train)
+x_test, y_test = upload_data('/media/etabook/etadisk1/EducFils/PFE/DATA2/test_data/', n_class, n_test)
+
+
+print("The x_train's shape is :", x_train.shape)
+print("The x_test's shape is :", x_test.shape)
+print("The y_train's shape is :", y_train.shape)
+print("The y_test's shape is :", y_test.shape)
+
+def plot_data(num=3):
+    fig, axes = plt.subplots(1, num, figsize=(12, 8))
+    for i in range(num):
+        index = np.random.randint(len(x_test))
+        axes[i].imshow(np.reshape(x_test[index], (28, 28)))
+        axes[i].set_title('image label: %d' % y_test[index])
+        axes[i].axis('off')
+    
+    plt.show()
+        
+plot_data(num=5)
+
+plot_data(num=5)
+
+num_classes = 33
+size = 28
+
+x_train = x_train.astype('float32')
+x_test = x_test.astype('float32')
+x_train = np.reshape(x_train, (x_train.shape[0], size*size))
+x_test = np.reshape(x_test, (x_test.shape[0], size*size))
+x_train /= 255
+x_test /= 255
+print('x_train shape:', x_train.shape)
+print(x_train.shape[0], 'train samples')
+print(x_test.shape[0], 'test samples')
+
+# convert class vectors to binary class matrices
+y_train = to_categorical(y_train, num_classes)
+y_test = to_categorical(y_test, num_classes)
+
+"""## Define our neural network model (Architecture)"""
+
+model = Sequential()
+model.add(Dense(512, input_shape=(size*size,), activation='relu'))
+model.add(Dense(128, activation='relu'))
+model.add(Dropout(0.3))
+model.add(Dense(num_classes, activation='softmax'))
+
+model.compile(loss=keras.losses.categorical_crossentropy,
+              metrics=['accuracy'])
+
+model.summary()
+
+"""## Model prediction on test data before training  """
+
+def plot_predictions(model, num=3):
+    fig, axes = plt.subplots(1, num, figsize=(12, 8))
+    for i in range(num):
+        index = np.random.randint(len(x_test))
+        pred = np.argmax(model.predict(np.reshape(x_test[index], (1, size*size))))
+        axes[i].imshow(np.reshape(x_test[index], (size, size)))
+        axes[i].set_title('Predicted label: '+ str(pred) + '\n/ true label :'+ str([e for e, x in enumerate(y_test[index]) if x == 1][0]))
+        axes[i].axis('off')
+    
+    plt.show()
+        
+plot_predictions(model, num=5)
+
+"""## Training"""
+
+history = model.fit(x_train, y_train, batch_size=128, epochs=20, validation_data=(x_test, y_test))
+
+"""## Model prediction on test data after training"""
+
+plot_predictions(model, num=5)
+score = model.evaluate(x_test, y_test, verbose = 0)
+print('Test loss:', score[0])
+print('Test accuracy:', score[1])
+
+"""## Model history during training"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+with plt.xkcd():
+    plt.plot(history.history['accuracy'], color='c')
+    plt.plot(history.history['val_accuracy'], color='red')
+    plt.title('Tifinagh-MNIST model accuracy')
+    plt.legend(['acc', 'val_acc'])
+    plt.savefig('acc_Tifinagh_MNIST.png')
+    plt.show()
+
+with plt.xkcd():
+    plt.plot(history.history['loss'], color='c')
+    plt.plot(history.history['val_loss'], color='red')
+    plt.title('Tifinagh-MNIST model loss')
+    plt.legend(['loss', 'val_loss'])
+    plt.savefig('loss_Tifinagh_MNIST.png')
+    plt.show()

CNN_Tifinagh_MNIST_Model.py

@@ -0,0 +1,133 @@
+# CNN - Tifinagh-MNIST
+
+## Libraries
+"""
+
+import numpy as np
+import os
+import cv2
+from matplotlib import pyplot as plt
+from tensorflow import keras
+from keras.models import *
+from keras.layers import *
+from keras.utils import *
+from tensorflow.keras.utils import to_categorical
+from keras.utils.vis_utils import plot_model
+
+"""## Data loading and adaptation """
+
+def upload_data(path_name, number_of_class, number_of_images): 
+    X_Data = []
+    Y_Data = []
+    for i in range(number_of_class):
+        images = os.listdir(path_name + str(i))
+        for j in range(number_of_images):
+            img = cv2.imread(path_name + str(i)+ '/' + images[j], 0)
+            X_Data.append(img)
+            Y_Data.append(i)
+        print("> the " + str(i) + "-th file is successfully uploaded.", end='\r') 
+    return np.array(X_Data), np.array(Y_Data)
+
+
+n_class = 33
+n_train = 2000
+n_test = 500
+#here we upload our data (Tifinagh data)
+x_train, y_train = upload_data('drive/MyDrive/DATA2/train_data/', n_class, n_train)
+x_test, y_test = upload_data('drive/MyDrive/DATA2/test_data/', n_class, n_test)
+
+
+print("The x_train's shape is :", x_train.shape)
+print("The x_test's shape is :", x_test.shape)
+print("The y_train's shape is :", y_train.shape)
+print("The y_test's shape is :", y_test.shape)
+
+def plot_data(num=3):
+    fig, axes = plt.subplots(1, num, figsize=(12, 8))
+    for i in range(num):
+        index = np.random.randint(len(x_test))
+        axes[i].imshow(np.reshape(x_test[index], (28, 28)))
+        axes[i].set_title('image label: %d' % y_test[index])
+        axes[i].axis('off')
+    
+    plt.show()
+        
+plot_data(num=5)
+
+x_train = x_train.astype('float32')
+x_test = x_test.astype('float32')
+x_train /= 255
+x_test /= 255
+print('x_train shape:', x_train.shape)
+print(x_train.shape[0], 'train samples')
+print(x_test.shape[0], 'test samples')
+y_train = to_categorical(y_train, n_class)
+y_test = to_categorical(y_test, n_class)
+
+"""## Architecture of the model"""
+
+def define_model(input_size = (28, 28, 1)):
+    inputs = Input(input_size)
+    conv1 = Conv2D(128, 3, activation='relu', padding='same')(inputs)
+    conv1 = Conv2D(128, 3, activation='relu', padding='same')(conv1)
+    pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
+    
+
+    conv3 = Conv2D(64, 3, activation='relu', padding='same')(pool1)
+    conv3 = Conv2D(64, 3, activation='relu', padding='same')(conv3)
+    pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
+    
+    conv4 = Conv2D(32, 3, activation='relu', padding='same')(pool3)
+    
+    fltt = Flatten()(conv4)
+    
+    dan = Dense(33, activation='softmax')(fltt)
+    
+    model = Model(inputs=inputs, outputs=dan)
+    
+    model.compile(loss='categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(), metrics=['accuracy'])
+   
+    
+    return model
+
+model = define_model((28, 28, 1))
+model.summary()
+
+his = model.fit(x_train, y_train, epochs=10, batch_size=128, validation_data=(x_test, y_test))
+
+"""## Model prediction on test data after training"""
+
+def plot_predictions(model, num=3):
+    fig, axes = plt.subplots(1, num, figsize=(12, 8))
+    for i in range(num):
+        index = np.random.randint(len(y_test))
+        pred = np.argmax(model.predict(np.reshape(x_test[index], (1, 28, 28))))
+        axes[i].imshow(np.reshape(x_test[index], (28, 28)))
+        axes[i].set_title('Predicted label: '+ str(pred) + '\n/ true label :'+ str([e for e, x in enumerate(y_test[index]) if x == 1][0]))
+        axes[i].axis('off')
+    
+    plt.show()
+
+
+plot_predictions(model, num=5)
+score = model.evaluate(x_test, y_test, verbose = 0)
+print('Test loss:', score[0])
+print('Test accuracy:', score[1])
+
+import matplotlib.pyplot as plt
+import numpy as np
+with plt.xkcd():
+    plt.plot(his.history['accuracy'], color='c')
+    plt.plot(his.history['val_accuracy'], color='red')
+    plt.title('Tifinagh-MNIST model accuracy')
+    plt.legend(['acc', 'val_acc'])
+    plt.savefig('acc_Tifinagh_MNIST_cnn.png')
+    plt.show()
+
+with plt.xkcd():
+    plt.plot(his.history['loss'], color='c')
+    plt.plot(his.history['val_loss'], color='red')
+    plt.title('Tifinagh-MNIST model loss')
+    plt.legend(['loss', 'val_loss'])
+    plt.savefig('loss_Tifinagh_MNIST_cnn.png')
+    plt.show()

Gans_For_One_Simples_Tifinagh_MNIST.py

@@ -0,0 +1,172 @@
+# Gans for one Tifinagh-MNIST letter
+
+## The libraries we will use
+"""
+
+import os
+import cv2
+from numpy import array
+from numpy import expand_dims
+from numpy import zeros
+from numpy import ones
+from numpy import vstack
+from numpy.random import randn
+from numpy.random import randint
+from keras.datasets.mnist import load_data
+from keras.optimizer_v2.adam import Adam
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Reshape
+from keras.layers import Flatten
+from keras.layers import Conv2D
+from keras.layers import Conv2DTranspose
+from keras.layers import LeakyReLU
+from keras.layers import Dropout
+from matplotlib import pyplot
+
+n_class = 1 #number of classes 
+n_train_Tifinagh_mnist = 2000 
+
+def upload_data_Tfinagh_MNIST(path_name, number_of_class, number_of_images): 
+    X_Data = []
+    for i in range(number_of_class):
+        images = os.listdir(path_name + str(i+11))
+        for j in range(number_of_images):
+            img = cv2.imread(path_name + str(i+11)+ '/' + images[j], 0)
+            X_Data.append(img)
+        print("> the " + str(i) + "-th file is successfully uploaded.", end='\r') 
+    return array(X_Data)
+
+n_class = 1 #number of classes 
+n_train_Tifinagh_mnist = 2000 
+
+def upload_data_Tfinagh_MNIST(path_name, num_of_class, number_of_images): 
+    X_Data = []
+    images = os.listdir(path_name + str(num_of_class))
+    for j in range(len(images)):
+            img = cv2.imread(path_name + str(num_of_class) + '/' + images[j], 0)
+            X_Data.append(img)
+    return array(X_Data)
+
+def define_discriminator(in_shape=(28,28,1)):
+	model = Sequential()
+	model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same', input_shape=in_shape))
+	model.add(LeakyReLU(alpha=0.2))
+	model.add(Dropout(0.4))
+	model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same'))
+	model.add(LeakyReLU(alpha=0.2))
+	model.add(Dropout(0.4))
+	model.add(Flatten())
+	model.add(Dense(1, activation='sigmoid'))
+	# compile model
+	opt = Adam(lr=0.0002, beta_1=0.5)
+	model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
+	return model
+
+def define_generator(latent_dim):
+	model = Sequential()
+	n_nodes = 128 * 7 * 7
+	model.add(Dense(n_nodes, input_dim=latent_dim))
+	model.add(LeakyReLU(alpha=0.2))
+	model.add(Reshape((7, 7, 128)))
+	model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
+	model.add(LeakyReLU(alpha=0.2))
+	model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
+	model.add(LeakyReLU(alpha=0.2))
+	model.add(Conv2D(1, (7,7), activation='sigmoid', padding='same'))
+	return model
+
+def define_gan(g_model, d_model):
+	d_model.trainable = False
+	model = Sequential()
+	model.add(g_model)
+	model.add(d_model)
+	opt = Adam(lr=0.0002, beta_1=0.5)
+	model.compile(loss='binary_crossentropy', optimizer=opt)
+	return model
+
+def load_real_samples(num_class):
+	trainX = upload_data_Tfinagh_MNIST('drive/MyDrive/DATA2/train_data/', num_class, n_train_Tifinagh_mnist)
+	X = expand_dims(trainX, axis=-1)
+	X = X.astype('float32')
+	X = X / 255.0
+	return X
+
+def generate_real_samples(dataset, n_samples):
+	ix = randint(0, dataset.shape[0], n_samples)
+	X = dataset[ix]
+	y = ones((n_samples, 1))
+	return X, y
+
+def generate_latent_points(latent_dim, n_samples):
+	x_input = randn(latent_dim * n_samples)
+	x_input = x_input.reshape(n_samples, latent_dim)
+	return x_input
+
+def generate_fake_samples(g_model, latent_dim, n_samples):
+	x_input = generate_latent_points(latent_dim, n_samples)
+	X = g_model.predict(x_input)
+	y = zeros((n_samples, 1))
+	return X, y
+
+def save_plot(examples, epoch, n=10):
+	for i in range(n * n):
+		pyplot.subplot(n, n, 1 + i)
+		pyplot.axis('off')
+		pyplot.imshow(examples[i, :, :, 0], cmap='gray_r')
+	filename = 'generated_plot_e%03d.png' % (epoch+1)
+	pyplot.savefig(filename)
+	pyplot.close()
+
+def summarize_performance(epoch, g_model, d_model, dataset, latent_dim, n_samples=100):
+	X_real, y_real = generate_real_samples(dataset, n_samples)
+	_, acc_real = d_model.evaluate(X_real, y_real, verbose=0)
+	x_fake, y_fake = generate_fake_samples(g_model, latent_dim, n_samples)
+	_, acc_fake = d_model.evaluate(x_fake, y_fake, verbose=0)
+	print('>Accuracy real: %.0f%%, fake: %.0f%%' % (acc_real*100, acc_fake*100))
+	#save_plot(x_fake, epoch)
+	filename = 'generator_model_%03d.h5' % (epoch + 1)
+	g_model.save(filename)
+
+def train(g_model, d_model, gan_model, dataset, latent_dim, n_epochs=100, n_batch=128):
+	bat_per_epo = int(dataset.shape[0] / n_batch)
+	half_batch = int(n_batch / 2)
+	for i in range(n_epochs):
+		for j in range(bat_per_epo):
+			X_real, y_real = generate_real_samples(dataset, half_batch)
+			X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
+			X, y = vstack((X_real, X_fake)), vstack((y_real, y_fake))
+			d_loss, _ = d_model.train_on_batch(X, y)
+			X_gan = generate_latent_points(latent_dim, n_batch)
+			y_gan = ones((n_batch, 1))
+			g_loss = gan_model.train_on_batch(X_gan, y_gan)
+			print('>%d, %d/%d, d=%.3f, g=%.3f' % (i+1, j+1, bat_per_epo, d_loss, g_loss))
+		if (i+1) % 10 == 0:
+			summarize_performance(i, g_model, d_model, dataset, latent_dim)
+
+# size of the latent space
+latent_dim = 100
+# create the discriminator
+d_model = define_discriminator()
+# create the generator
+g_model = define_generator(latent_dim)
+# create the gan
+gan_model = define_gan(g_model, d_model)
+# load image data
+dataset = load_real_samples(29)
+# train model
+train(g_model, d_model, gan_model, dataset, latent_dim)
+
+z = generate_latent_points(100, 9)
+im = g_model.predict(z)
+
+from matplotlib import pyplot as plt
+plt.figure(figsize=(9, 9))
+for i in range(9):
+  orig_map=plt.cm.get_cmap()
+  
+  # reversing the original colormap using reversed() function
+  reversed_map = orig_map.reversed()
+  plt.subplot(3, 3, i+1)
+  plt.imshow(im[i, :, :, 0], cmap = reversed_map);
+  plt.axis('off')

README.md

@@ -0,0 +1,10 @@
+
+# Contribution to creation, classification and generation of a new hand-written Tifinagh alphabet letters dataset using ANN, CNN and GAN
+
+In this work, we present a new dataset called Tifinagh-MNIST: handwritten letters of the Tifinagh alphabetic script, which is used to write the Tamazight languages. The presented dataset contains 82,500 gray scale images of size 28 x 28 pixels belonging to 33 classes (letters), with 2500 images per class. In particular, the training set is composed of 66,000 images while the test set contains 16,500 images. Tifinagh-MNIST is intended for the development of AI tools to process handwritten Tifinagh characters. We also propose use cases of this corpus through neural network models for classification and data generation. The corpus will be made available to the public in order to promote the development of artificial intelligence solutions for the processing of handwritten Tamazight texts.
+
+
+
+
+![Logo](https://media.licdn.com/dms/image/C4E22AQGE6ZG-gNJhXg/feedshare-shrink_800/0/1656066492444?e=1678924800&v=beta&t=6on0spkXPm5NK4kY4SFEttnzkUrII9OUfvHxWeM8zO0)
+

T_SNE_Tifinagh_MNIST.py

@@ -0,0 +1,88 @@
+# Visualization of the Tifinag-MNIST database using the T-SNE algorithm
+
+## The libraries we will use
+"""
+
+import time
+import os
+import cv2
+import numpy as np
+import pandas as pd
+from sklearn.manifold import TSNE
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+"""## Data loading and adaptation"""
+
+def upload_data(path_name, number_of_class, number_of_images): 
+    X_Data = []
+    Y_Data = []
+    for i in range(number_of_class):
+        images = os.listdir(path_name + str(i))
+        for j in range(number_of_images):
+            img = cv2.imread(path_name + str(i)+ '/' + images[j], 0)
+            X_Data.append(img)
+            Y_Data.append(i)
+        print("> the " + str(i) + "-th file is successfully uploaded.", end='\r') 
+    return np.array(X_Data), np.array(Y_Data)
+
+n_class = 33
+n_train = 2000
+
+x_data, y_data = upload_data('/media/etabook/etadisk1/EducFils/PFE/DATA2/train_data/', n_class, n_train)
+
+x_data = x_data.astype('float32')
+x_data = np.reshape(x_data, (x_data.shape[0], 28*28))
+x_data /= 255
+print('x_data shape:', x_data.shape)
+print(x_data.shape[0], 'data samples')
+
+"""## Convert images and label vector to a Pandas DataFrame"""
+
+feat_cols = [ 'pixel'+str(i) for i in range(x_data.shape[1]) ]
+df = pd.DataFrame(x_data,columns=feat_cols)
+df['y'] = y_data
+df['label'] = df['y'].apply(lambda i: str(i))
+x_data, y_data = None, None
+print('Size of the dataframe: {}'.format(df.shape))
+df.head()
+
+"""## Displaying images from the Dataframe"""
+
+np.random.seed(42)
+rndperm = np.random.permutation(df.shape[0])
+
+plt.gray()
+fig = plt.figure( figsize=(18,12) )
+for i in range(0,15):
+    ax = fig.add_subplot(3,5,i+1, title="Letter: {}".format(str(df.loc[rndperm[i],'label'])) )
+    ax.matshow(df.loc[rndperm[i],feat_cols].values.reshape((28,28)).astype(float))
+plt.show()
+
+"""## Launch of the T-SNE algorithm
+
+
+"""
+
+N = 50000
+df_subset = df.loc[rndperm[:N],:].copy()
+data_subset = df_subset[feat_cols].values
+
+time_start = time.time()
+tsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)
+tsne_results = tsne.fit_transform(data_subset)
+print('t-SNE done! Time elapsed: {} seconds'.format(time.time()-time_start))
+
+"""## Visualisation"""
+
+df_subset['tsne-2d-one'] = tsne_results[:,0]
+df_subset['tsne-2d-two'] = tsne_results[:,1]
+plt.figure(figsize=(16,10))
+sns.scatterplot(
+    x="tsne-2d-one", y="tsne-2d-two",
+    hue="y",
+    palette=sns.color_palette("hls", 33),
+    data=df_subset,
+    legend="full",
+    alpha=0.3
+)