diff --git a/swh/langdetect/cnn_w.py b/swh/langdetect/cnn_w.py
index 34167c8..7dce467 100644
--- a/swh/langdetect/cnn_w.py
+++ b/swh/langdetect/cnn_w.py
@@ -1,301 +1,300 @@
 import os
 import sys
 import subprocess
 import time
 import random
 import csv
 import numpy as np
 import warnings
 with warnings.catch_warnings():
     warnings.simplefilter("ignore")
     import tensorflow as tf
 import json
 import argparse
 
 from ast import literal_eval
 from pickle import dump
 from pickle import load
 from numpy import array
 from .utils.common import Tokenizer
-from .utils.common import file_to_string
 from keras.preprocessing.sequence import pad_sequences
 from keras.callbacks import EarlyStopping
 from keras.models import Model
 from keras.models import Sequential
 from keras.models import load_model
 from keras.layers import Input
 from keras.layers import Dense
 from keras.layers import Flatten
 from keras.layers import Merge
 from keras.layers import Dropout
 from keras.layers import ThresholdedReLU
 from keras.layers import Activation
 from keras.layers import Lambda
 from keras.layers import Embedding
 from keras.layers.convolutional import Convolution1D
 from keras.layers.convolutional import MaxPooling1D
 from keras.layers.normalization import BatchNormalization
 from keras.layers import Concatenate
 from keras.utils import np_utils
 from keras.optimizers import SGD
 from collections import Counter
 
 csv.field_size_limit(sys.maxsize)
 
 from keras import backend as K
 K.set_session(K.tf.Session(config=K.tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)))
 
 def main():
     parser = argparse.ArgumentParser(description='Training and test tool of charactor-level ConvNet text categorisation.')
 
     subparsers = parser.add_subparsers(dest='sub_command')
 
     parser_train = subparsers.add_parser('train', help='Training on the dataset, dataset must be a *.csv file. A model will be created in the same directory.')
     parser_train.add_argument('train_path', metavar='PATH', type=str, help='Path of the training dataset.')
     parser_train.add_argument('-ms', '--maxsize',  metavar='SIZE', dest='train_maxsize', type=int, help='Set maximum input size of ConvNet, default 1024.')
     parser_train.add_argument('-e', '--epochs', metavar='N', dest='train_epochs', type=int, help='Number of training epochs (iterations), default 50.')
     parser_test = subparsers.add_parser('test', help='Test on the dataset, dataset must be a directory with *.csv dataset named by corresponding language.')
     parser_test.add_argument('test_root', metavar='ROOT', type=str, help='Root of the test dataset.')
     
     if len(sys.argv[1:]) == 0:
         parser.print_help()
         parser.exit()
     args = parser.parse_args()
 
     if args.sub_command == "train":
         if args.train_maxsize:
             if args.train_epochs:
                 n = CNNword(args.train_path, maxsize=args.train_maxsize, epochs=args.train_epochs)
                 n.train()
             else:
                 n = CNNword(args.train_path, maxsize=args.train_maxsize)
                 n.train()
         else:
             if args.train_epochs:
                 n = CNNword(args.train_path, epochs=args.train_epochs)
                 n.train()
             else:
                 n = CNNword(args.train_path)
                 n.train()
     elif args.sub_command == "test":
         n = CNNword(args.test_root)
         print(args.test_root)
         n.test()
     else:
         parser.parse_args('-h')
 
 class CNNword:
 
-    def __init__(self, path, maxsize=768, epochs=30):
+    def __init__(self, path, maxsize=1024, epochs=30):
         
         self._path = path
 
         # Root of model folder
         self._root_model = os.path.join(os.path.dirname(path), 'model_cnn_word')
         try:
             os.mkdir(self._root_model)
         except:
             pass
 
         # Path of result
         self._path_result = os.path.join(os.path.dirname(path), 'result_cnn_word')
         
         dir_path = os.path.dirname(os.path.abspath(__file__))
         with open(os.path.join(dir_path, 'static_data', 'languages.json'), 'r') as f:
             self._languages = json.load(f)
 
         self._path_test_csv = path
         self._path_vocab = os.path.join(self._root_model, 'vocab')
 
         self._input_size = maxsize
-        self._vocab_size = 20001
+        self._vocab_size = 15001
         self._num_of_classes = len(self._languages)
         self._batch_size = 64
         self._epochs = epochs
 
         if not os.path.isfile(self._path_vocab):
             self._learn_vocab(self._input_size, self._num_of_classes)
         with open(self._path_vocab, 'rb') as f:
             c = load(f)
-        l = c.most_common(20000)
+        l = c.most_common(15000)
         print(l)
         self._indexer = dict((v[0], i + 1) for i, v in enumerate(l))
         self._oov_index = len(self._indexer) + 1
 
     def file_len(self, fname):
         with open(fname) as f:
             count = 0
             for l in f:
                 count += 1
             return count
 
     def train(self):
         model = self._get_model()
 
-        earlystop = EarlyStopping(monitor='loss', min_delta=0, patience=2, verbose=0, mode='auto')
+        earlystop = EarlyStopping(monitor='loss', min_delta=0, patience=3, verbose=0, mode='auto')
         callbacks = [earlystop]
         model.fit_generator(
             self._generator(self._input_size, self._num_of_classes, self._batch_size),
             steps_per_epoch=self.file_len(self._path) / self._batch_size, epochs=self._epochs, callbacks=callbacks)
         model.save(os.path.join(self._root_model, 'model.h5'))
 
     def _learn_vocab(self, length, total_class):
         c = Counter()
         with open(self._path, newline='') as csvfile:
             r = csv.reader(csvfile, delimiter=' ', quotechar='|')
             for pair in r:
                 label, string = pair
                 label = int(label)
                 print(label, end='\r')
                 string = literal_eval(string)
                 tokens = Tokenizer.tokenize(string, 'word')
                 c.update(tokens)
 
         with open(self._path_vocab, 'wb') as f:
             dump(c, f)
         
     def _generator(self, length, total_class, batch_size=64):
         counter = 0
         while True:
             with open(self._path, newline='') as csvfile:
                 r = csv.reader(csvfile, delimiter=' ', quotechar='|')
                 for pair in r:
                     if counter == 0:
                         X = np.empty((0, length))
                         Y = np.empty((0, total_class))
                     label, string = pair
                     label = int(label)
                     string = literal_eval(string)
                     tokens = [self._indexer.get(x, self._oov_index) for x in Tokenizer.tokenize(string, 'word')]
                     X = np.append(X, pad_sequences([tokens], maxlen=length), axis=0)
                     label = array(np_utils.to_categorical([label], total_class))
                     Y = np.append(Y, label, axis=0)
                     
                     counter += 1
                     if counter == batch_size:
                         counter = 0
                         yield(X,Y)
         
                         
     def _get_model(self):
 
         input_size = self._input_size
         vocab_size = self._vocab_size
         embedding_size = 128
         optimizer = 'adam'
         loss = 'categorical_crossentropy'
         num_of_classes = self._num_of_classes
 
         embedding_layer = Embedding(vocab_size + 1,
                                     embedding_size,
                                     input_length=input_size,
         )
 
         # applying a more complex convolutional approach
         convs = []
         filter_sizes = [3,4,5]
         
         sequence_input = Input(shape=(input_size,), dtype='int64')
         embedded_sequences = embedding_layer(sequence_input)
         
         for fsz in filter_sizes:
             l_conv = Convolution1D(filters=10, kernel_size=fsz, activation='relu')(embedded_sequences)
-            l_pool = MaxPooling1D(5)(l_conv)
+            l_pool = MaxPooling1D(3)(l_conv)
             convs.append(l_pool)
     
         l_merge = Concatenate(axis=1)(convs)
-        l_conv1= Convolution1D(128, 5, activation='relu')(l_merge)
+        l_conv1= Convolution1D(128, 3, activation='relu')(l_merge)
         l_pool1 = MaxPooling1D(5)(l_conv1)
-        l_conv2 = Convolution1D(128, 5, activation='relu')(l_pool1)
+        l_conv2 = Convolution1D(128, 3, activation='relu')(l_pool1)
         l_pool2 = MaxPooling1D(5)(l_conv2)
         l_flat = Flatten()(l_pool2)
         l_dense = Dense(512, activation='relu')(l_flat)
         preds = Dense(num_of_classes, activation='softmax')(l_dense)
 
         model = Model(sequence_input, preds)
         model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])
         
         print(model.summary())
         
         return model
 
     def _max_len(self, texts):
         return max([len(text) for text in texts])
 
     def test(self):
         csv.field_size_limit(sys.maxsize)
         try:
             r = open(self._path_result, 'rb')
             test_result = load(r)
             r.close()
         except FileNotFoundError:
             test_result = {}
             
         model = self._load_model()
         
         for language in [x for x in self._languages if x not in test_result.keys()]:
             test_result[language] = self.test_class(model, language)
             with open(self._path_result, 'wb') as f:
                 dump(test_result, f)
             
     def _load_model(self):
         model = load_model(os.path.join(self._root_model, 'model.h5'))
 
         return model
     
     def _count_size(self, files):
         size = 0
         for f in files:
             size += os.path.getsize(f)
         return size
     
     def test_class(self, model, language):
         ok = 0
         results = []
         count = 0
         total_test = self.file_len(os.path.join(self._path_test_csv, language + '.csv'))
                           
         with open(os.path.join(self._path_test_csv, language + '.csv'), newline='') as csvfile:
             r = csv.reader(csvfile, delimiter=' ', quotechar='|')
             for pair in r:
                 label, string = pair
                 label = int(label)
                 string = literal_eval(string)
                 tokens = [self._indexer.get(x, self._oov_index) for x in Tokenizer.tokenize(string, 'word')]
                 result = self._guess_file_language(model, tokens)
                 count += 1
                 print('[{0:4d}/{1:4d}] {2}:{3}       '.format(count, total_test, result[0][1], result[0][0]),end='\r')
                 results.append(result[0])
                 if result[0][1] == language:
                     ok += 1
 
         accuracy = ok / total_test
         print('Tests for {}                   '.format(language))
         print('Total test files           : {}'.format(total_test))
         print('Correctly classified files : {}'.format(ok))
         print('Accuracy                   : {}%'.format(accuracy * 100))
         return (ok, total_test, accuracy, results)
 
     def speed_benchmark(self):
         language = self._languages[10]
         model = self._load_model()
 
         test_set = self._get_test_set(language)
         total_size = self._count_size(test_set)
         print('{} kB in total'.format(total_size / 1024))
         
         t_start = time.perf_counter()
         self.test_class(model, language)
         t_end = time.perf_counter()
         
         print('{} seconds.'.format(t_end - t_start))
         print('{} seconds per KiB'.format(((t_end - t_start) / total_size) * 1024))
 
     def _guess_file_language(self, model, tokens):
         X = pad_sequences([tokens], maxlen=self._input_size)
         result = list(model.predict(X))[0]
         result = [(s, self._languages[i]) for i, s in enumerate(result)]
         return sorted(result, reverse=True)
 
 if __name__ == '__main__':
     main()
diff --git a/swh/langdetect/utils/common.py b/swh/langdetect/utils/common.py
index 0817cfd..652009e 100644
--- a/swh/langdetect/utils/common.py
+++ b/swh/langdetect/utils/common.py
@@ -1,175 +1,175 @@
 """
 Here regroup basic preprocessing methods
 used in learning stage for different 
 approaches.
 
 """
 
 import re, os, time
 
 _not_start_with_point = lambda x: not x.startswith('.')
 
 class Tokenizer():
 
     separator = re.compile(
-        b'([\x20-\x2f\x3a-\x40\x5b-\x5e\x60\x7b-\x7e\t\n]|\d+\.\d+|\d+|\d+\.\d+[eE][+-]?\d+)')
+        b'([\x20-\x2f\x3a-\x40\x5b-\x5e\x60\x7b-\x7e\s]|\d+\.\d+|\d+|\d+\.\d+[eE][+-]?\d+)')
 
     def is_number(n):
         try:
             float(n)
         except ValueError:
             return False
         return True
 
     def tokenize(text, re_name):
         ''' Splits text into tokens '''
         if re_name == 'letter':
             return list(text)
         elif re_name == 'word':
-            pretokens = [x for x in Tokenizer.separator.split(text.lower()) if x and x.strip(b'\n')]
+            pretokens = [x for x in Tokenizer.separator.split(text) if x and x.strip(b'\n')]
             tokens = []
             for x in pretokens :
                 if Tokenizer.is_number(x):
                     tokens.append(b'<number>')
                 elif x.isspace():
                     tokens.append(b' ')
                 else:
                     tokens.append(x)
             return tokens
                     
 
 def file_to_string(filename):
     """ Read a file to a string. """
     with open(filename, 'rb') as f:
         data = f.read()
     return data
 
 def count_files(root_language):    
     all_folders = natural_sort(filter
                                (_not_start_with_point,
                                 os.listdir(root_language)))
     files = natural_sort(filter
                          (_not_start_with_point,
                           os.listdir(root_language + '/' + all_folders[-1])))
     (max,_) = os.path.splitext(files[-1])
     return int(max)
 
 def find_file(root_language, n):
     '''Find the n-th file in language folder'''
     if n > count_files(root_language):
         return ''
     else:
         start = (n - 1) // 1000 * 1000 + 1
         end = start + 999
         root_count = root_language + '/' + str(start) + '-' + str(end)
         files = natural_sort(filter
                              (_not_start_with_point,
                               os.listdir(root_count)))
         return root_count + '/' + files[n - start]
 
 '''def replace_string_and_number(text):
     """ Replace strings and numbers in a file by special tokens 
     """
     str_replaced = _re_string.sub(b'"__str__"', text)
     str_num_replaced = _re_number.sub(b'__num__', str_replaced)
     #str_num_replaced = text
     return str_num_replaced
 '''
 
 def natural_sort(l): 
     convert = lambda text: int(text) if text.isdigit() else text.lower() 
     alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ] 
     return sorted(l, key = alphanum_key)
 
 def remove_comment(binary_text, language):
     splited_text = binary_text.splitlines()
     text = b'\n'.join(splited_text)
     regexp = get_regexp(language)
     if not regexp:
         return binary_text
     return regexp.sub(b'\n', text)
 
 def get_regexp(language):
     re_inline = get_inline(language)
     re_block = get_block(language)
     rs = []
     if re_inline:
         rs.append(re_inline)
     if re_block:
         rs.append(re_block)
     if rs == []:
         return None
     return re.compile(b'|'.join(rs), re.DOTALL)
         
     
 def get_inline(language):
     r_base = b'[^\\n]*(?:\\n|$)'
     if language in ['Ada',
                     'Eiffel',
                     'VHDL',
                     'AppleScript',
                     'Haskell',
                     'Lua',
                     'PLSQL']:
         r = b'(--)' + r_base
     elif language in ['C',
                       'C++',
                       'C#',
                       'D',
                       'JavaScript',
                       'ActionScript',
                       'Java',
                       'Rust']:
         r = b'(//)' + r_base
     elif language == 'Xojo':
         r = b'(' + b'|'.join([b'//', b"\'"]) + b')' + r_base
     elif language in ['R',
                       'Tcl',
                       'Awk',
                       'Perl',
                       'Perl 6',
                       'Ruby',
                       'Python']:
         r = b'(#)' + r_base
     elif language in ['COBOL']:
         r = b'(\\*>)' + r_base
     elif language in ['Matlab']:
         r = b'(%)' + r_base
     else:
         return None
     return b'(' + r + b')'
 
 def get_block(language):
     r_base = b'.*?'
     if language in ['C',
                     'C++',
                     'C#',
                     'JavaScript',
                     'ActionScript',
                     'PLSQL',
                     'PHP',
                     'Rust']:
         r = b'(/\\*)' + r_base + b'(\\*/)'
     elif language in ['OCaml',
                       'Pascal',
                       'Modula-2',
                       'Smarty']:
         r = b'(\\(\\*)' + r_base + b'(\\*\\))'
     elif language == 'Python':
         r = b'(\'\'\')' + r_base + b'(\'\'\')'
     else:
         return None
     return b'(' + r + b')'
     
     
 def purify(text, lang):
     # TODO: for some language like HTML, remove code other than principal language
     pass