Skip to content
Snippets Groups Projects
Commit 69a500aa authored by Jean-Luc Parouty's avatar Jean-Luc Parouty
Browse files

Add MNIST, add multishape support in fidle/pwk:plot_images() 

Former-commit-id: 5f28a53b
parent 3e43760f
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
GTSRB/01-Preparation-of-data.ipynb
+ 15
− 2
View file @ 69a500aa
%% Cell type:markdown id: tags:
German Traffic Sign Recognition Benchmark (GTSRB)
=================================================
---
Introduction au Deep Learning (IDLE) - S. Arias, E. Maldonado, JL. Parouty - CNRS/SARI/DEVLOG - 2020
## Episode 1 : Preparation of data
- Understanding the dataset
- Preparing and formatting enhanced data
- Save enhanced datasets in h5 file format
%% Cell type:markdown id: tags:
## 1/ Import and init
%% Cell type:code id: tags:
``` python
import os, time, sys
import csv
import math, random
import numpy as np
import matplotlib.pyplot as plt
import h5py
from skimage.morphology import disk
from skimage.filters import rank
from skimage import io, color, exposure, transform
import fidle.pwk as ooo
from importlib import reload
ooo.init()
```
%% Output
IDLE 2020 - Practical Work Module
Version : 0.1.5
Run time : Wednesday 22 January 2020, 19:21:15
Matplotlib style : fidle/talk.mplstyle
TensorFlow version : 2.0.0
Keras version : 2.2.4-tf
%% Cell type:markdown id: tags:
## 2/ Read the dataset
Description is available there : http://benchmark.ini.rub.de/?section=gtsrb&subsection=dataset
- Each directory contains one CSV file with annotations ("GT-<ClassID>.csv") and the training images
- First line is fieldnames: Filename;Width;Height;Roi.X1;Roi.Y1;Roi.X2;Roi.Y2;ClassId
### 2.1/ Usefull functions
%% Cell type:code id: tags:
``` python
def read_dataset_dir(csv_filename):
'''Reads traffic sign data from German Traffic Sign Recognition Benchmark dataset.
Arguments: csv filename
Example /data/GTSRB/Train.csv
Returns: np array of images, np array of corresponding labels'''
# ---- csv filename and path
#
name=os.path.basename(csv_filename)
path=os.path.dirname(csv_filename)
# ---- Read csv file
#
f,x,y = [],[],[]
with open(csv_filename) as csv_file:
reader = csv.DictReader(csv_file, delimiter=',')
for row in reader:
f.append( path+'/'+row['Path'] )
y.append( int(row['ClassId']) )
csv_file.close()
nb_images = len(f)
# ---- Read images
#
for filename in f:
image=io.imread(filename)
x.append(image)
ooo.update_progress(name,len(x),nb_images)
# ---- Return
#
return np.array(x),np.array(y)
```
%% Cell type:markdown id: tags:
### 2.2/ Read the data
We will read the following datasets:
- **x_train, y_train** : Learning data
- **x_test, y_test** : Validation or test data
- x_meta, y_meta : Illustration data
The learning data will be randomly mixted and the illustration data sorted.
Will take about 2-3'
%% Cell type:code id: tags:
``` python
%%time
# ---- Read datasets
(x_train,y_train) = read_dataset_dir('./data/origine/Train.csv')
(x_test ,y_test) = read_dataset_dir('./data/origine/Test.csv')
(x_meta ,y_meta) = read_dataset_dir('./data/origine/Meta.csv')
# ---- Shuffle train set
combined = list(zip(x_train,y_train))
random.shuffle(combined)
x_train,y_train = zip(*combined)
# ---- Sort Meta
combined = list(zip(x_meta,y_meta))
combined.sort(key=lambda x: x[1])
x_meta,y_meta = zip(*combined)
```
%% Cell type:markdown id: tags:
## 3/ Few statistics about train dataset
We want to know if our images are homogeneous in terms of size, ratio, width or height.
### 3.1/ Do statistics
%% Cell type:code id: tags:
``` python
train_size = []
train_ratio = []
train_lx = []
train_ly = []
test_size = []
test_ratio = []
test_lx = []
test_ly = []
for image in x_train:
(lx,ly,lz) = image.shape
train_size.append(lx*ly/1024)
train_ratio.append(lx/ly)
train_lx.append(lx)
train_ly.append(ly)
for image in x_test:
(lx,ly,lz) = image.shape
test_size.append(lx*ly/1024)
test_ratio.append(lx/ly)
test_lx.append(lx)
test_ly.append(ly)
```
%% Cell type:markdown id: tags:
### 3.2/ Show statistics
%% Cell type:code id: tags:
``` python
# ------ Global stuff
print("x_train size : ",len(x_train))
print("y_train size : ",len(y_train))
print("x_test size : ",len(x_test))
print("y_test size : ",len(y_test))
# ------ Statistics / sizes
plt.figure(figsize=(16,6))
plt.hist([train_size,test_size], bins=100)
plt.gca().set(title='Sizes in Kpixels - Train=[{:5.2f}, {:5.2f}]'.format(min(train_size),max(train_size)),
ylabel='Population',
xlim=[0,30])
plt.legend(['Train','Test'])
plt.show()
# ------ Statistics / ratio lx/ly
plt.figure(figsize=(16,6))
plt.hist([train_ratio,test_ratio], bins=100)
plt.gca().set(title='Ratio lx/ly - Train=[{:5.2f}, {:5.2f}]'.format(min(train_ratio),max(train_ratio)),
ylabel='Population',
xlim=[0.8,1.2])
plt.legend(['Train','Test'])
plt.show()
# ------ Statistics / lx
plt.figure(figsize=(16,6))
plt.hist([train_lx,test_lx], bins=100)
plt.gca().set(title='Images lx - Train=[{:5.2f}, {:5.2f}]'.format(min(train_lx),max(train_lx)),
ylabel='Population',
xlim=[20,150])
plt.legend(['Train','Test'])
plt.show()
# ------ Statistics / ly
plt.figure(figsize=(16,6))
plt.hist([train_ly,test_ly], bins=100)
plt.gca().set(title='Images ly - Train=[{:5.2f}, {:5.2f}]'.format(min(train_ly),max(train_ly)),
ylabel='Population',
xlim=[20,150])
plt.legend(['Train','Test'])
plt.show()
# ------ Statistics / classId
plt.figure(figsize=(16,6))
plt.hist([y_train,y_test], bins=43)
plt.gca().set(title='ClassesId',
ylabel='Population',
xlim=[0,43])
plt.legend(['Train','Test'])
plt.show()
```
%% Cell type:markdown id: tags:
## 4/ List of classes
What are the 43 classes of our images...
%% Cell type:code id: tags:
``` python
ooo.plot_images(x_meta,y_meta, range(43), columns=8, x_size=2, y_size=2,
colorbar=False, y_pred=None, cm='binary')
```
%% Cell type:markdown id: tags:
## 5/ What does it really look like
%% Cell type:code id: tags:
``` python
# ---- Get and show few images
samples = [ random.randint(0,len(x_train)-1) for i in range(32)]
ooo.plot_images(x_train,y_train, samples, columns=8, x_size=2, y_size=2, colorbar=False, y_pred=None, cm='binary')
```
%% Cell type:markdown id: tags:
## 6/ dataset cooking...
Images must have the **same size** to match the size of the network.
It is possible to work on **rgb** or **monochrome** images and **equalize** the histograms.
The data must be **normalized**.
See : [Exposure with scikit-image](https://scikit-image.org/docs/dev/api/skimage.exposure.html)
See : [Local histogram equalization](https://scikit-image.org/docs/dev/api/skimage.filters.rank.html#skimage.filters.rank.equalize)
See : [Histogram equalization](https://scikit-image.org/docs/dev/api/skimage.exposure.html#skimage.exposure.equalize_hist)
### 6.1/ Enhancement cook
%% Cell type:code id: tags:
``` python
def images_enhancement(images, width=25, height=25, mode='RGB'):
'''
Resize and convert images - doesn't change originals.
input images must be RGBA or RGB.
args:
images : images list
width,height : new images size (25,25)
mode : RGB | RGB-HE | L | L-HE | L-LHE | L-CLAHE
return:
numpy array of enhanced images
'''
modes = { 'RGB':3, 'RGB-HE':3, 'L':1, 'L-HE':1, 'L-LHE':1, 'L-CLAHE':1}
lz=modes[mode]
out=[]
for img in images:
# ---- if RGBA, convert to RGB
if img.shape[2]==4:
img=color.rgba2rgb(img)
# ---- Resize
img = transform.resize(img, (width,height))
# ---- RGB / Histogram Equalization
if mode=='RGB-HE':
hsv = color.rgb2hsv(img.reshape(width,height,3))
hsv[:, :, 2] = exposure.equalize_hist(hsv[:, :, 2])
img = color.hsv2rgb(hsv)
# ---- Grayscale
if mode=='L':
img=color.rgb2gray(img)
# ---- Grayscale / Histogram Equalization
if mode=='L-HE':
img=color.rgb2gray(img)
img=exposure.equalize_hist(img)
# ---- Grayscale / Local Histogram Equalization
if mode=='L-LHE':
img=color.rgb2gray(img)
img=rank.equalize(img, disk(10))/255.
# ---- Grayscale / Contrast Limited Adaptive Histogram Equalization (CLAHE)
if mode=='L-CLAHE':
img=color.rgb2gray(img)
img=exposure.equalize_adapthist(img)
# ---- Add image in list of list
out.append(img)
ooo.update_progress('Enhancement: ',len(out),len(images))
# ---- Reshape images
# (-1, width,height,1) for L
# (-1, width,height,3) for RGB
#
out = np.array(out,dtype='float64')
out = out.reshape(-1,width,height,lz)
return out
```
%% Cell type:markdown id: tags:
### 6.2/ To get an idea of the different recipes
%% Cell type:code id: tags:
``` python
i=random.randint(0,len(x_train)-16)
x_samples = x_train[i:i+16]
y_samples = y_train[i:i+16]
datasets = {}
datasets['RGB'] = images_enhancement( x_samples, width=25, height=25, mode='RGB' )
datasets['RGB-HE'] = images_enhancement( x_samples, width=25, height=25, mode='RGB-HE' )
datasets['L'] = images_enhancement( x_samples, width=25, height=25, mode='L' )
datasets['L-HE'] = images_enhancement( x_samples, width=25, height=25, mode='L-HE' )
datasets['L-LHE'] = images_enhancement( x_samples, width=25, height=25, mode='L-LHE' )
datasets['L-CLAHE'] = images_enhancement( x_samples, width=25, height=25, mode='L-CLAHE' )
print('\nEXPECTED (Meta) :\n')
x_expected=[ x_meta[i] for i in y_samples]
ooo.plot_images(x_expected, y_samples, range(16), columns=16, x_size=1, y_size=1, colorbar=False, y_pred=None, cm='binary')
print('\nORIGINAL IMAGES :\n')
ooo.plot_images(x_samples, y_samples, range(16), columns=16, x_size=1, y_size=1, colorbar=False, y_pred=None, cm='binary')
print('\nENHANCED :\n')
for k,d in datasets.items():
print("dataset : {} min,max=[{:.3f},{:.3f}] shape={}".format(k,d.min(),d.max(), d.shape))
ooo.plot_images(d, y_samples, range(16), columns=16, x_size=1, y_size=1, colorbar=False, y_pred=None, cm='binary')
```
%% Cell type:markdown id: tags:
### 6.3/ Cook and save
A function to save a dataset
%% Cell type:code id: tags:
``` python
def save_h5_dataset(x_train, y_train, x_test, y_test, x_meta,y_meta, h5name):
# ---- Filename
filename='./data/'+h5name
# ---- Create h5 file
with h5py.File(filename, "w") as f:
f.create_dataset("x_train", data=x_train)
f.create_dataset("y_train", data=y_train)
f.create_dataset("x_test", data=x_test)
f.create_dataset("y_test", data=y_test)
f.create_dataset("x_meta", data=x_meta)
f.create_dataset("y_meta", data=y_meta)
# ---- done
size=os.path.getsize(filename)/(1024*1024)
print('Dataset : {:24s} shape : {:22s} size : {:6.1f} Mo (saved)\n'.format(filename, str(x_train.shape),size))
```
%% Cell type:markdown id: tags:
Create enhanced datasets, and save them...
Will take about 7-8'
%% Cell type:code id: tags:
``` python
%%time
for s in [24, 48]:
for m in ['RGB', 'RGB-HE', 'L', 'L-LHE']:
# ---- A nice dataset name
name='set-{}x{}-{}.h5'.format(s,s,m)
print("\nDataset : ",name)
# ---- Enhancement
x_train_new = images_enhancement( x_train, width=s, height=s, mode=m )
x_test_new = images_enhancement( x_test, width=s, height=s, mode=m )
x_meta_new = images_enhancement( x_meta, width=s, height=s, mode='RGB' )
# ---- Save
save_h5_dataset( x_train_new, y_train, x_test_new, y_test, x_meta_new,y_meta, name)
x_train_new,x_test_new=0,0
```
%% Cell type:markdown id: tags:
## 7/ Reload data to be sure ;-)
%% Cell type:code id: tags:
``` python
%%time
dataset='set-48x48-L'
samples=range(24)
with h5py.File('./data/'+dataset+'.h5') as f:
x_tmp = f['x_train'][:]
y_tmp = f['y_train'][:]
print("dataset loaded from h5 file.")
ooo.plot_images(x_tmp,y_tmp, samples, columns=8, x_size=2, y_size=2, colorbar=False, y_pred=None, cm='binary')
x_tmp,y_tmp=0,0
```
%% Cell type:markdown id: tags:
----
That's all folks !
......
GTSRB/fidle/pwk.py
+ 12
− 7
View file @ 69a500aa
......@@ -26,7 +26,7 @@ import matplotlib
import matplotlib.pyplot as plt
import seaborn as sn
VERSION='0.1.5'
VERSION='0.1.7'
# -------------------------------------------------------------
......@@ -119,12 +119,17 @@ def plot_images(x,y, indices, columns=12, x_size=1, y_size=1, colorbar=False, y_
for i in indices:
axs=fig.add_subplot(rows, columns, n)
n+=1
# Shapes must be differents for RGB and L
(lx,ly,lz)=x[i].shape
if lz==1:
img=axs.imshow(x[i].reshape(lx,ly), cmap = cm, interpolation='lanczos')
else:
img=axs.imshow(x[i].reshape(lx,ly,lz),cmap = cm, interpolation='lanczos')
# ---- Shape is (lx,ly)
if len(x[i].shape)==2:
xx=x[i]
# ---- Shape is (lx,ly,n)
if len(x[i].shape)==3:
(lx,ly,lz)=x[i].shape
if lz==1:
xx=x[i].reshape(lx,ly)
else:
xx=x[i]
img=axs.imshow(xx, cmap = cm, interpolation='lanczos')
axs.spines['right'].set_visible(True)
axs.spines['left'].set_visible(True)
axs.spines['top'].set_visible(True)
......
MNIST/01-DNN-MNIST.ipynb 0 → 100644
+ 422
− 0
View file @ 69a500aa
source diff could not be displayed: it is too large. Options to address this: view the blob.
MNIST/fidle/__init__.py 0 → 100644
+ 2
− 0
View file @ 69a500aa
VERSION='0.1a'
\ No newline at end of file
MNIST/fidle/pwk.py 0 → 100644
+ 224
− 0
View file @ 69a500aa
# ==================================================================
# ____ _ _ _ __ __ _
# | _ \ _ __ __ _ ___| |_(_) ___ __ _| | \ \ / /__ _ __| | __
# | |_) | '__/ _` |/ __| __| |/ __/ _` | | \ \ /\ / / _ \| '__| |/ /
# | __/| | | (_| | (__| |_| | (_| (_| | | \ V V / (_) | | | <
# |_| |_| \__,_|\___|\__|_|\___\__,_|_| \_/\_/ \___/|_| |_|\_\
# module pwk
# ==================================================================
# A simple module to host some common functions for practical work
# pjluc 2020
import os
import glob
from datetime import datetime
import itertools
import datetime, time
import math
import numpy as np
import tensorflow as tf
from tensorflow import keras
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sn
VERSION='0.1.7'
# -------------------------------------------------------------
# init_all
# -------------------------------------------------------------
#
def init(mplstyle='fidle/talk.mplstyle'):
global VERSION
# ---- matplotlib
matplotlib.style.use(mplstyle)
# ---- Hello world
# now = datetime.datetime.now()
print('IDLE 2020 - Practical Work Module')
print(' Version :', VERSION)
print(' Run time : {}'.format(time.strftime("%A %-d %B %Y, %H:%M:%S")))
print(' Matplotlib style :', mplstyle)
print(' TensorFlow version :',tf.__version__)
print(' Keras version :',tf.keras.__version__)
# -------------------------------------------------------------
# Folder cooking
# -------------------------------------------------------------
#
def tag_now():
return datetime.datetime.now().strftime("%Y-%m-%d_%Hh%Mm%Ss")
def mkdir(path):
os.makedirs(path, mode=0o750, exist_ok=True)
def get_directory_size(path):
"""
Return the directory size, but only 1 level
args:
path : directory path
return:
size in Mo
"""
size=0
for f in os.listdir(path):
if os.path.isfile(path+'/'+f):
size+=os.path.getsize(path+'/'+f)
return size/(1024*1024)
# -------------------------------------------------------------
# shuffle_dataset
# -------------------------------------------------------------
#
def shuffle_np_dataset(x, y):
assert (len(x) == len(y)), "x and y must have same size"
p = np.random.permutation(len(x))
return x[p], y[p]
def update_progress(what,i,imax):
bar_length = min(40,imax)
if (i%int(imax/bar_length))!=0 and i<imax:
return
progress = float(i/imax)
block = int(round(bar_length * progress))
endofline = '\r' if progress<1 else '\n'
text = "{:16s} [{}] {:>5.1f}% of {}".format( what, "#"*block+"-"*(bar_length-block), progress*100, imax)
print(text, end=endofline)
# -------------------------------------------------------------
# show_images
# -------------------------------------------------------------
#
def plot_images(x,y, indices, columns=12, x_size=1, y_size=1, colorbar=False, y_pred=None, cm='binary'):
"""
Show some images in a grid, with legends
args:
X: images - Shapes must be (-1 lx,ly,1) or (-1 lx,ly,3)
y: real classes
indices: indices of images to show
columns: number of columns (12)
x_size,y_size: figure size
colorbar: show colorbar (False)
y_pred: predicted classes (None)
cm: Matplotlib olor map
returns:
nothing
"""
rows = math.ceil(len(indices)/columns)
fig=plt.figure(figsize=(columns*x_size, rows*(y_size+0.35)))
n=1
errors=0
if np.any(y_pred)==None:
y_pred=y
for i in indices:
axs=fig.add_subplot(rows, columns, n)
n+=1
# ---- Shape is (lx,ly)
if len(x[i].shape)==2:
xx=x[i]
# ---- Shape is (lx,ly,n)
if len(x[i].shape)==3:
(lx,ly,lz)=x[i].shape
if lz==1:
xx=x[i].reshape(lx,ly)
else:
xx=x[i]
img=axs.imshow(xx, cmap = cm, interpolation='lanczos')
axs.spines['right'].set_visible(True)
axs.spines['left'].set_visible(True)
axs.spines['top'].set_visible(True)
axs.spines['bottom'].set_visible(True)
axs.set_yticks([])
axs.set_xticks([])
if y[i]!=y_pred[i]:
axs.set_xlabel('{} ({})'.format(y_pred[i],y[i]))
axs.xaxis.label.set_color('red')
errors+=1
else:
axs.set_xlabel(y[i])
if colorbar:
fig.colorbar(img,orientation="vertical", shrink=0.65)
plt.show()
def plot_image(x,cm='binary', figsize=(4,4)):
(lx,ly,lz)=x.shape
plt.figure(figsize=figsize)
if lz==1:
plt.imshow(x.reshape(lx,ly), cmap = cm, interpolation='lanczos')
else:
plt.imshow(x.reshape(lx,ly,lz),cmap = cm, interpolation='lanczos')
plt.show()
# -------------------------------------------------------------
# show_history
# -------------------------------------------------------------
#
def plot_history(history, figsize=(8,6)):
"""
Show history
args:
history: history
save_as: filename to save or None
"""
# Accuracy
plt.figure(figsize=figsize)
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Model accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
# Loss values
plt.figure(figsize=figsize)
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
# -------------------------------------------------------------
# plot_confusion_matrix
# -------------------------------------------------------------
#
def plot_confusion_matrix(cm,
title='Confusion matrix',
figsize=(12,8),
cmap="gist_heat_r",
vmin=0,
vmax=1,
xticks=5,yticks=5):
"""
given a sklearn confusion matrix (cm), make a nice plot
Args:
cm: confusion matrix from sklearn.metrics.confusion_matrix
title: the text to display at the top of the matrix
figsize: Figure size (12,8)
cmap: color map (gist_heat_r)
vmi,vmax: Min/max 0 and 1
"""
accuracy = np.trace(cm) / float(np.sum(cm))
misclass = 1 - accuracy
plt.figure(figsize=figsize)
sn.heatmap(cm, linewidths=1, linecolor="#ffffff",square=True,
cmap=cmap, xticklabels=xticks, yticklabels=yticks,
vmin=vmin,vmax=vmax)
plt.ylabel('True label')
plt.xlabel('Predicted label\naccuracy={:0.4f}; misclass={:0.4f}'.format(accuracy, misclass))
plt.show()
MNIST/fidle/talk.mplstyle 0 → 100644
+ 33
− 0
View file @ 69a500aa
# See : https://matplotlib.org/users/customizing.html
axes.titlesize : 24
axes.labelsize : 20
axes.edgecolor : dimgrey
axes.labelcolor : dimgrey
axes.linewidth : 2
axes.grid : False
axes.prop_cycle : cycler('color', ['steelblue', 'tomato', '2ca02c', 'd62728', '9467bd', '8c564b', 'e377c2', '7f7f7f', 'bcbd22', '17becf'])
lines.linewidth : 3
lines.markersize : 10
xtick.color : black
xtick.labelsize : 18
ytick.color : black
ytick.labelsize : 18
axes.spines.left : True
axes.spines.bottom : True
axes.spines.top : False
axes.spines.right : False
savefig.dpi : 300 # figure dots per inch or 'figure'
savefig.facecolor : white # figure facecolor when saving
savefig.edgecolor : white # figure edgecolor when saving
savefig.format : svg
savefig.bbox : tight
savefig.pad_inches : 0.1
savefig.transparent : True
savefig.jpeg_quality: 95
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment