Préparation des données pour la formation

Question

J'essaie de préparer le fichier de données en créant un encodage à chaud du texte de caractères à l'aide duquel je peux ensuite former mon modèle pour la classification. J'ai un fichier de données d'apprentissage qui se compose de lignes de caractères et je fais d'abord le codage entier d'entre eux, puis l'un codage à chaud.

par exemple. voici comment le fichier de données ressemble:

1. afafalkjfalkfalfjalfjalfjafajfaflajflajflajfajflajflajfjaljfafj
2. fgtfafadargggagagagagagavcacacacarewrtgwgjfjqiufqfjfqnmfhbqvcqvfqfqafaf
3. fqiuhqqhfqfqfihhhhqeqrqtqpocckfmafaflkkljlfabadakdpodqpqrqjdmcoqeijfqfjqfjoqfjoqgtggsgsgqr

Voilà comment je me rapproche de ce:

import pandas as pd 
from sklearn import preprocessing 

categorical_data = pd.read_csv('abc.txt', sep="\n", header=None) 
labelEncoder = preprocessing.LabelEncoder() 
X = categorical_data.apply(labelEncoder.fit_transform) 
print("Afer label encoder") 
print(X.head()) 

oneHotEncoder = preprocessing.OneHotEncoder() 
oneHotEncoder.fit(X) 

onehotlabels = oneHotEncoder.transform(X).toarray() 
print("Shape after one hot encoding:", onehotlabels.shape) 

print(onehotlabels) 

J'obtiens le codage entier pour chaque ligne (0,1,2 dans mon cas) et ensuite le vecteur codé chaud suivant.

Ma question est que comment puis-je le faire pour chaque caractère dans une ligne individuelle comme pour la prédiction, le modèle devrait apprendre à partir des caractères dans une ligne (qui correspond à une certaine étiquette). Quelqu'un peut-il me donner un aperçu sur la façon de procéder à partir de là?

Answer 1

Compte tenu de votre exemple je me retrouve avec une trame de données comme ceci:

0 
0 0 
1 1 
2 2 

D'après votre description, il semble que vous voulez que chaque ligne d'avoir son propre indépendant d'un encodage à chaud. permet donc d'abord regarder à la ligne 1.

afafalkjfalkfalfjalfjalfjafajfaflajflajflajfajflajflajfjaljfafj 

La raison pour laquelle vous obtenez le dataframe j'inclus ci-dessus est que cette ligne est de se lire dans la trame de données, puis transmis à la labelEncoder et oneHotEncoder comme une valeur unique, pas tableau de 63 valeurs (la longueur de la chaîne).

Qu'est-ce que vous voulez vraiment faire est de passer le labelEncoder un tableau de taille 63.

data = np.array([let for let in categorical_data[0][0]]) 
X = labelEncoder.fit_transform(data) 
oneHotEncoder.fit(X.reshape(-1,1)) 
row_1_labels = oneHotEncoder.transform(X.reshape(-1,1)).toarray() 
row_1_labels 

array([[ 1., 0., 0., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 0., 0., 0., 1., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 0., 0., 0., 1., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1.], 
     [ 0., 0., 1., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 1., 0., 0., 0.], 
     [ 0., 0., 1., 0., 0.]]) 

Vous pouvez répéter cette opération pour chaque ligne pour obtenir l'indépendant encodages chaud. Comme si:

one_hot_encodings = categorical_data.apply(lambda x: [oneHotEncoder.fit_transform(labelEncoder.fit_transform(np.array([let for let in x[0]])).reshape(-1,1)).toarray()], axis=1) 
one_hot_encodings 

                0 
0 [[1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.... 
1 [[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,... 
2 [[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,... 

Si vous vouliez les lignes à un encodée chaud sur la base des valeurs trouvées dans toutes les lignes que vous tout d'abord adapter la labelEncoder à toutes les lettres uniques et faire les transformations pour chaque ligne. Comme si:

unique_letters = np.unique(np.array([let for row in categorical_data.values for let in row[0]])) 
labelEncoder.fit(unique_letters) 
unique_nums = labelEncoder.transform(unique_letters) 
oneHotEncoder.fit(unique_nums.reshape(-1,1)) 
cat_dat = categorical_data.apply(lambda x: [np.array([let for let in x[0]])], axis=1) 
one_hot_encoded = cat_dat.apply(lambda x: [oneHotEncoder.transform(labelEncoder.transform(x[0]).reshape(-1,1)).toarray()], axis=1) 
one_hot_encoded 

                0 
0 [[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,... 
1 [[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,... 
2 [[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,... 

Cela vous renvoie une trame de données à chaque rangée contenant une série de lettres codées à chaud sur la base des lettres de toutes les lignes.