Questo articolo fa parte della serie dedicata ai più rilevanti task di Natural Language Processing. Approfondisci anche gli altri partendo dal primo articolo.

Inoltre per un'introduzione sugli aspetti di base in ambito Machine Learning leggere l'articolo Machine learning e applicazioni per l'industria.

Classificazione Testuale

In questo articolo viene trattato il task della classificazione testuale.

Con classificazione testuale si fa riferimento, appunto, all'utilizzo di approcci di classificazione di tipo supervisionato, con l'obiettivo di associare contenuti testuali a caratteristiche e classi definite a priori.
Esempi di classificazione testuale sono:

• Sentiment Analysis: classificare ad esempio recensioni rispetto al sentiment(negativo e positivo)
• Ticket Classification: associare ticket di supporto alla categoria di riferimento, piuttosto che alla classe di urgenza
• Document Classification e Tagging: classificare contenuti testuali associandoli a una o più classi

Queste sono solo alcune delle possibili applicazioni realizzabili tramite la classificazione testuale. Rientrano di fatto in questo campo tutte le applicazioni che consistono nel classificare e associare contenuti testuali rispetto a un insieme di etichette o classi definito a priori.

In relazione agli esempi elencati possiamo raccogliere i task di classificazione testuale in tre diverse tipologie:

• Classificazione binaria: il numero di classi/etichette a cui vengono associati i contenuti è uguale a due
• Classicazione multiclasse: il numero di classi/etichette a cui vengono associati i contenuti è uguale a n, con n > 2
• Classicazione multiclasse multilabel: classificazione di tipo multiclasse dove ogni contenuto può essere associato a più di una classe, e quindi avere più di un'etichetta

Per affrontare un task di classificazione testuale, a prescindere dalla tipologia di classificazione, è necessario svolgere tendenzialmente questi tre passi:

• etichettare i dati: costruire un training set di contenuti testuali etichettati con caratteristiche rispetto alle quali si vuole svolgere la classificazione
• trasformare e elaborare il testo: i contenuti testuali necessitano sia di una fase di preprocessing, necessaria per porre il contenuto testuale in una forma più adatta al task da svolgere, sia di una fase di trasformazione dei contenuti per renderli leggibili e analizzabili dagli algoritmi di machine learning utilizzati
• addestramento del modello: la fase vera e propria dell'addestramento del modello, tramite un qualche algoritmo di riferimento

Vediamo nelle sezioni successive come realizare tutto ciò.

Etichettatura dei dati

La fase di etichettatura dei dati risulta fondamentale per poter addestrare un modello di Machine Learning per la classificazione testuale. Essendo un approccio di tipo supervisionato, senza dati etichettati non si può realizzare nulla in tal senso.

Può capitare che si voglia realizzare applicazioni per le quali si è già in possesso di dati etichettati. Questo perchè si possiede già uno storico di dati etichettati grazie al lavoro svolto in passato dagli utenti, piuttosto che dagli addetti al task.
Pensiamo al task di Ticket Classification.
Se l'obiettivo è realizzare un modello di Machine Learning in grado di classificare ticket di supporto rispetto alla loro categoria, devo avere a disposizione un dataset di ticket passati, etichettati con le rispettive categorie.
Potrei reperire facilmente questi dati utilizzando tutti i ticket passati che gli addetti hanno già associato alle relative categorie quando hanno svolto questo lavoro "a mano" per indirizzare il ticket al reparto o alla persona di competenza. In un contesto di questo tipo mi basta reperire i dati e porli in una forma leggibile ed utilizzabile per l'addestramento. Tipicamente un file csv.

Qualora non si abbiano a disposizione dati etichettati, e quindi si sia in possesso solo dei contenuti testuali da utilizzare per l'addestramento, allora si può far ricorso ad annotatori testuali per etichettare in maniera agile ed efficiente i dati.
Doccano, ad esemnpio, è un'annotatore ben strutturato e open source.
Un altro annotatore, questo a pagamento, è Prodigy. Si tratta di un annotatore avanzato e potenziato attraverso il concetto di active learning; è sviluppato da Explosion.ai, creatori della libreria opensource di NLP Spacy.

Una volta annotati i dati possono essere facilmente esportati in formato csv per poi essere letti e manipolati attraverso librerie ad hoc come Pandas.

Preprocessing e trasformazione dei dati

1. Preprocessing e pulizia del testo

L'attività di trasformazione e preprocessing dei dati è molto importante in qualsiasi task di Machine Learning, ma nel contesto della classicazione testuale e più in generale dell'elaborazione del linguaggio naturale è molto rilevante.

Un contenuto testuale generalmente contiene molta informazione al suo interno, e non tutta quest'informazione è rilevante ai fini della classificazione da svolgere.
Gran parte del contenuto testuale molto spesso non ha alcuna rilevanza nel risultato prodotto; in alcune occasioni può rappresentare invece rumore che va a distorcere la classificazione prodotta dal modello.
Ad esempio nel contesto della Sentiment Analysis, in una recensione, posso trovare aggettivi come ottimo piuttosto che pessimo che hanno un peso specifico nell'individuazione del sentiment del contenuto. Altri termini invece non dicono nulla in tal senso.

Inoltre nel linguaggio naturale un concetto può essere espresso con termini che hanno stessa radice ma declinazione differente. Quei termini rappresentano lo stesso concetto, ma avendo una declinazione differente il modello di Machine Learning potrebbe fare difficoltà a comprendere che si tratta di un concetto similare a quanto già visto.
E anche la punteggiatura, molto spesso introduce solo rumore nell'analisi del testo.

Per tutti questi motivi è molto importante svolgere delle attività di preprocessing del testo in modo da minimizzare il più possibile tutti gli effetti non desiderati causati da informazione non rilevante presente nel testo.

Queste attività possono essere di diverso tipo e legate profondamente al task che si sta svolgendo. Esistono comunque delle attività di preprocessing che vengono svolte quasi sempre quando si approccia a task di nlp.

Una prima attività molto semplice è quella di tokenizzazione del testo.
A seguire possono essere svolte le seguenti azioni:

• Rimuovere le stopwords: eliminare dal testo tutte quelle parti del discorso che nell'ambito di un linguaggio non rappresentano solitamente informazione rilevante, come gli articoli, le proposizioni, le congiunzioni, ecc... Inoltre quest'attività può essere svolta facendo stopping sulla base di una propria lista di parole da rimuovere, realizzata in base al contesto e al tipo di dominio su cui si sta lavorando.
• Rimuovere la punteggiatura: la punteggiatura quasi mai rappresenta informazione rilevante e quindi è meglio rimuoverla

• Stemming: lo stemming è un processo molto comune nei motori di ricerca che consiste nel ridurre un termine dalla forma flessa alla sua radice, con l'obiettivo di minimizzare l'effetto della presenza di variazioni morfologiche differenti che hanno però lo stesso significato semantico. Esistono due approcci per fare stemming. Un primo basato su dizionario, similmente a quanto avviene per l'attività di rimozione delle stopwords. Un secondo di tipo algoritmico basato su regole, ad esempio lo Stemmer di Porter.
• Lowercasing: trasformare tutto il testo in carattere minuscolo in modo da evitare differenziazioni in base al carattere

Le librarie di NLP come Nltk o Spacy offrono funzionalità già definite per svolgere queste attività.
Vediamo ad esempio come svolgere queste attività attraverso Nltk.

from nltk.corpus import stopwords  
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer 
  
example_sent = """This is a sample sentence, 
                  showing off the stop words filtration."""

# stopwords list 
stop_words = set(stopwords.words('english'))

# stemmer
ps = PorterStemmer() 

# tokenization
word_tokens = word_tokenize(example_sent)  

# stoppping
filtered_sentence = [w for w in word_tokens if not w in stop_words]  

# stemming
stemmed_sentence = [ps.stem(w) for w in filtered_sentence]
  
print(word_tokens)  
print(filtered_sentence)
print(stemmed_sentence)  

2. Trasformazione del testo

Una volta terminate le attività di preprocessing sul testo, segue un passo importante che è quello della trasformazione dei contenuti in una forma tale da poter essere data in input agli algoritmi di Machine Learning.
Gli algoritmi non sono in grado di analizzare direttamente le parole testuali, e quindi va svolta un'attività di trasformazione in una rappresentazione numerica e/o vettoriale.

Esistono diversi metodi per rappresentare i contenuti testuali. Ognuna di queste rappresentazioni utilizza il concetto di vocabolario. Vediamo quali sono e come funzionano.

Bag of Words

Il modello Bag of Words consiste in una rappresentazione vettoriale dove ogni contenuto testuale viene trasformato in un vettore V-dimensionale, con V che rappresenta la cardinalità del vocabolario. In particolare avremo che ogni componente del vettore assumerà valor uguale a zero, qualora il termine non è presente, altrimenti un valore corrispondente al numero di occorrenze di quel termine nel testo.

Tf-idf

Tf-Idf sta per Term Frequency/Inverted Document Frequency. Si tratta di una rappresentazione vettoriale similare a quella del metodo Bag of Words, ma per i termini presenti nel testo, piuttosto che il numero di occorrenze, viene utilizzato questo valore Tf-Idf definito come il rapporto tra la Term Frequency e la Inverse Document Frequency. La Term Frequency è la frequenza del termine all'interno del documento. La Inverse Document Frequency è una misura di quanto il termine occorre all'interno dell'intero corpus(in quanti documenti essenzialmente). Rispetto al modello Bag of Words questa rappresentazione quindi enfatizza i termini "rilevanti" come quelli che:

• appaiono frequentemente in un documento ("common locally")
• appaiono frequentemente nel corpus ("rare globally") Questa rappresentazione, date queste caratteristiche, è quindi sempre preferita a quella Bag of Words, più semplice e quindi meno carica di significato.

Text to sequence of numbers

Un'ultima rappresentazione, utilizzata principalmente nel contesto delle reti neurali, è quella che prevede di trasformare ogni contenuto testuale in una sequenza di interi, dove ogni intero mappa un token specifico all'interno di un apposito vocabolario. Questa rappresentazione è molto spesso utilizzata insieme all'utilizzo di Word Embedding.

La rappresentazione scelta dipende molto spesso dall'algoritmo utlizzato e dal tipo di task che si va ad affrontare. Nella stragrande maggioranza dei casi l'appropccio è quello di utilizzare un modello Tf-Idf con algoritmi "classici", e una rappresentazione Text to Sequence con approcci di Deep Learning. Nella prossima sezione vedremo l'applicazione e l'utilizzo di queste trasformazioni nel contesto del training vero e proprio di modelli per la classificazione testuale.

Training di modelli

Abbiamo visto quali sono le best practice che riguardano l'elaborazione e la trasformazione del testo. Ora vediamo come addestrare i nostri modelli. Sono presenti allo stato dell'arte vari algoritmi che a seconda del contesto dimostrano di essere molto adatti per il task della classificazione testuale. Tra gli approcci classici troviamo Classicatori Bayesiani, Support Vector Machine, Logistic Regression. Tra gli approcci di tipi Deep Learning invece sono molto efficaci le reti di tipo convolutivo, ma in alcuni casi anche le reti di tipo ricorrente.

Seguono due esempi di addestramento di modelli in grado di classificare ticket di supporto rispetto alla propria categoria, utilizzando prima un Classificatore Bayesiano e poi una Rete Neurale Convolutiva.

Il codice integrale per questi esempi e anche per altri esempi con altri tra gli algoritmi citati, sono presenti sul repository Github relativo a questa serie di articoli. Nel repository troverai il codice sorgente degli esempi descritto ed eseguibile in jupyter notebook ben documentati.

1. Classificazione testuale con Classificatore Bayesiano

Nel nostro caso utilizzeremo un Classificatore Bayesiano nella versione cosiddetta "ingenua" (Naïve Bayes Classifier). Si tratta di un Classificatore Bayesiano semplificato con un modello di probabilità sottostante che fa l'ipotesi di indipendenza delle caratteristiche, cioè assume che la presenza o l'assenza di un particolare attributo in un documento testuale non è correlata alla presenza o assenza di altri attributi

Per addestrare il modello utilizzeremo la libreria Scikit-Learn.

Ipotizziamo di avere a disposizione in un file csv i nostri ticket già preprocessati attraverso le tecniche già viste nelle sezioni precedenti. Inoltre per ogni contenuto testuale conosciamo la categoria espressa tramite un'identificativo numerico.

Il primo passo che dobbiamo svolgere è quello di leggere i dati e creare da una parte il training set per l'addestramento, dall'altra il test set per la validazione.

Per fare ciò per prima cosa importiamo il contenuto del csv in un Pandas dataframe. Successivamente estraiamo il testo e le etichette e costruiamo due liste apposite.

import pandas as pd

df_tickets = pd.read_csv('input/all_tickets.csv')


text_list = df_tickets['body'].tolist()
labels_list = df_tickets['category'].tolist()

Ora andiamo a trasformare la lista dei contenuti testuali in una rappresentazione di tipo Tf-Idf. Per fare ciò ci avvaliamo di funzioni definite dalla libreria. Una volta fatto ciò, splittiamo l'intero insieme in training e test set.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(text_list, labels_list, test_size=0.1, random_state=0)

count_vect = CountVectorizer()
vectorized_data = count_vect.fit_transform(X_train)

tfidf = TfidfTransformer()
X_train = tfidf.fit_transform(vectorized_data)

A questo punto passiamo all'addestramento vero e proprio e successivamente alla valutazione delle prestazioni ottenute calcolando attraverso funzioni predefinite l'accuratezza raggiunta e la matrice di confusione relativa al test set.

from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import f1_score, accuracy_score, classification_report

mnb = MultinomialNB()
mnb.fit(X_train, y_train)

pred = mnb.predict(X_test_tfidf)

#print(f1_score(y_test, pred))
print(accuracy_score(y_test, pred))
#print(precision_score(y_test, pred))
confusion_matrix(y_test, pred)

Il modello a questo punto può essere salvato in formato pickle per poi essere utilizzato per i propri scopi. Il modello prende in input una rappresentazione Tf-Idf e non il testo naturale, quindi prima di dare il contenuto testuale in input al modello, bisogna sempre convertirlo nella rappresentazione scelta(in questo caso Tf-Idf).

Scikit-learn mette a disposizione uno strumento che semplifica questi aspetti e permette di fatto di definire un modello end-to-end, cioè un modello che prende direttamente in input il testo e restituisce in output la classificazione desiderata. Questo avviene attraverso la classe sklearn.pipeline.Pipeline, attraverso la quale è possibile definire in un unico oggetto la lista di tutte le trasformazioni e azioni da svolgere. Il codice precedente sarà in parte replicato dal codice che segue.

from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

text_clf = Pipeline([
        ('vect', count_vect),
        ('tfidf', TfidfTransformer()),
        ('clf', MultinomialNB())
    ])

Un'altra funzione molto utile da segnalare, definita dalla classe sklearn.model_selection.GridSearchCV, è la Grid Search per svolgere l'ottimizzazione dei parametri in modo rapido e semplice.

Sia il concetto di Pipeline che di Grid Search sono approfonditi e utilizzati nel codice presente sul repository Github.

2. Classificazione testuale con Reti Neurali convolutive

Un altro algoritmo molto adatto a svolgere task di classificazione testuale è quello delle reti neurali convolutive, in particolare le reti con layer convolutivi a 1 dimensione, che svolgono cioè delle operazioni di convoluzione temporale, mentre i layer convolutivi a 2 dimensioni si adattano maggiormente all'elaborazione e l'analisi delle immagini. Per approfondimenti sulle differenze: https://missinglink.ai/guides/keras/keras-conv1d-working-1d-convolutional-neural-networks-keras/.

Vediamo ora come addestrare un modello per la classificazione dei ticket attraverso algoritmi di questo tipo. Lo facciamo utilizzando come libreria di supporto Tensorflow Keras. Ipotizziamo sempre di avere a disposizione in un file csv i nostri ticket già preprocessati e "puliti".

Comer per l'approccio con il Classificatore Bayesiano, per prima cosa importiamo il contenuto del csv in un Pandas dataframe. Successivamente estraiamo il testo e le etichette e costruiamo due liste apposite.

import pandas as pd

df_tickets = pd.read_csv('input/all_tickets.csv')


text_list = df_tickets['body'].tolist()
labels_list = df_tickets['category'].tolist()

Ora passiamo all'attività di trasformazione dei dati, e in questo caso utilizziamo un trasformazione di tipo text to sequence of numbers. Ogni contenuto testuale viene trasformato in una sequenza di interi, dove ogni intero mappa un termine in un vocabolario apposito. Per fare ciò utilizziamo un utility definita da Keras con la classe tf.keras.preprocessing.text.Tokenizer. Trasformati i dati, viene fatto lo split in train e test set e poi il padding delle sequenze ad una lunghezza massima definita analizzando il dataset a priori. Vengono anche trasformate le etichette attraverso un LabelEncoder, anche se per questo dataset le etichette già sono definite come interi. Questo passo è fondamentale quando le etichette non sono degli interi.

from tensorflow.keras.preprocessing.text import Tokenizer

tokenizer = Tokenizer(split=' ')
tokenizer.fit_on_texts(text_list)
X = tokenizer.texts_to_sequences(text_list)

values = np.array(text_list)
# integer encode
label_encoder = LabelEncoder()
label_encoder.fit(values)
Y = label_encoder.transform(text_list)

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.1, random_state=42)

# padding sequences to maxlen
print('Pad sequences (samples x time)')
X_train = sequence.pad_sequences(X_train, maxlen=maxlen)
X_test = sequence.pad_sequences(X_test, maxlen=maxlen)
print('x_train shape:', X_train.shape)
print('x_test shape:', X_test.shape)

Segue a questo punto la definizione dell'architettura del modello, la definizione degli iperparametri e l'addestramento vero e proprio. L'addestramento è controllato da un'approccio di tipo Early Stopping per prevenire eventuali fenomeni di Overfitting

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation
from tensorflow.keras.layers import Embedding
from tensorflow.keras.layers import GlobalAveragePooling1D, Conv1D, GlobalMaxPooling1D
from tensorflow.keras.callbacks import EarlyStopping

batch_size = 32 # batch size
epochs = 100 # number of epochs
filters = 100
kernel_size = 1
hidden_dims = 100
embedding_dim = 100

print('Build model...')
model = Sequential()

# we start off with an efficient embedding layer which maps
# our vocab indices into embedding_dims dimensions
if use_pretrained_embeddings: 
    model.add(Embedding(max_features+1,
                        embedding_dim,
                        input_length=maxlen
                        , weights = [embedding_matrix], trainable = True))
    print("using pretrained embeddings")
else:
    model.add(Embedding(max_features+1,
                        embedding_dim,
                        input_length=maxlen))
    print("using embeddings from scratch")
model.add(Dropout(0.2))

# we add a Convolution1D, which will learn filters
# word group filters of size filter_length:
model.add(Conv1D(filters,
                 kernel_size,
                 padding='valid',
                 activation='relu',
                 strides=1))

# we use max pooling:
model.add(GlobalMaxPooling1D())

# We add a vanilla hidden layer:
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))

# We project onto a single unit output layer, and squash it with a softmax:
model.add(Dense(n_outputs))
model.add(Activation('softmax'))

model.compile(loss='sparse_categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

callback = EarlyStopping(monitor='val_loss', min_delta=0, patience=5, verbose=0, mode='auto',
    baseline=None, restore_best_weights=False)

history = model.fit(np.array(X_train), np.array(Y_train),
              batch_size=batch_size,
              epochs=epochs,
            validation_split=0.1, callbacks = [callback])

Il modello può essere anche in questo caso salvato e riutilizzato dove necessario. E cosi come con Scikit Learn è possibile realizzare un approccio di tipo end-to-end per evitare di dover ogni volta svolgere trasformazioni sull'input. Una strategia possibile è presente sulla documentazione di Tensorflow Keras.

Per approfondimenti vedi il notebook associato sul repository Github.

3. Valutazioni e confronti

Quale dei due approcci è il migliore? Quale raggiunge il miglior livello di accuratezza?

Sono diverse le metriche e gli approcci di valutazione utilizzabili per fare chiarezza in tal senso. Nel caso della classificazione testuale, e più in generale degli approcci di classificazione, Accuratezza, Precision, Recall, F1-score sono metriche fondamentali da calcolare e analizzare. Un altro strumento sempre molto utile è la matrice di confusione, che permette di visualizzare falsi positivi e negativi.

Vediamo i risultati degli addestramenti attraverso dei report di classificazione prodotti in fase di valutazione. Questi report mostrano valori di precision, recall, accuratezza e altre metriche in un unica tabella, con il focus sia sulle diverse classi che sulle prestazioni globali.

Per questo task i due classificatori hanno delle prestazioni molto simili come possiamo osservare. Performa leggermente meglio il Classificatore Bayesiano. Ma non sempre è cosi.

Le reti neurali convolutive si dimostrano ad esempio molto potenti quando la classificazione dipende da feature molto identificative. Ad esempio immaginiamo di voler classificare documenti aziendali rispetto al cliente. Le informazioni come il nome piuttosto che la partita iva del cliente sono delle informazioni molto utili per capire a che cliente fa riferimento il documento. In casi come queste le reti neurali raggiungo dei risultati di accuratezza molto alti.
I Classificatori Bayesiani invece si dimostrano molto accurati nella stragrande maggioranza dei casi. Anche se non sempre raggiungono i livelli di accuratezza delle reti neurali convolutive, hanno come punto di forza quello di restituire valori di confidenza associati alla classificazioni prodotte molto significativi, e con soglie ben definite. Questo accade poichè a tutti gli effetti il Classificatore Bayesiano è un modello probabilistico.

Le reti neurali, restituiscono anch'esse un valore di confidenza associato alla classificazione, che però non può essere considerato del tutto un valore probabilistico, poichè esso è il risutalto dell'applicazione di una Softmax allo strato di ouput della rete. Quindi di fatto va considerata come una trasposizione nello spazio delle probabilità del risultato prodotto dalla rete. Per questi motivi il valore di confidenza va interpretato in modo differente e non sempre riesce ad esprimere le differenze auspicate.

Conclusioni

Ricapitolando la classificazione testuale ci permette di catalagora i nostri contenuti testuali rispetto a caratteristiche di diverso tipo. La capacità di raggruppare contenuti testuali in modo automatico e intelligente può rappresentare un valore aggiunto non indifferente per un'azienda ad esempio. Pensate ad un software gestionale che permette l'archiviazione in spazi separati di documenti aziendali di vario genere; attraverso uno strumento di classificazione testuale basato su Machine Learning si può catalogare in modo automatico il documento nello spazio corretto in base al cliente piuttosto che la tipologia. Un'altro esempio può essere un sistema di supporto per il CSS. Similmente a quanto fatto negli esempi visti, si possono classificare in modo automatico i ticket in arrivo in base alla categoria o l'urgenza per aiutare nel task di assegnazione dei ticket ai reparti addetti.

Cosa aspetti quindi? Sfrutta le potenzialità offerte dal Machine Learning per classificare e estrarre in modo automatico informazione dal testo in modo da rendere più intelligente la tua applicazione. Divertiti con i notebook presenti sul repository Github a testare gli algoritmi visti negli esempi e anche altri algoritmi come le Support Vector Machine o le reti LSTM.
Successivamente riutilizza questi algoritmi per realizzare i tuoi modelli di classificazione testuale da utilizzare a supporto della tua applicazione.

In questo articolo sono stati citati solo alcuni degli argomenti più rilevanti per quanto concerne la classificazione testuale. Kamran Kowsari ha approfondito attraverso un paper molto completo, tutti gli aspetti legati a questo task, espondendone in modo eccellente vantaggi e svantaggi. Si tratta di una trattazione che tocca moltissimi aspetti che riguardano non solo il task della classificazione testuale, ma in generale tutto il mondo del Natural Language Processing. Se vi occupate di NLP non potete perderlo.

Paper di riferimento: Kowsari, K., Meimandi, K. J., Heidarysafa, M., Mendu, S., Barnes, L. E., & Brown, D. E. (2019). Text Classification Algorithms: A Survey.

Articolo Medium: Text Classification Algorithms: A Survey.