<jupyter_start><jupyter_text>Visualizar o DataFrame com as colunas: 'Descrições dos Itens' (DESCR_ITEM); o vetor que representa estas descrições (com Zeros e Uns e Dois ou mais, se houver repetição de palavras na descrição); e a classificação da Natureza da Base de Cálculo das Contribuições de PIS/COFINS em 'NAT_BC_CRED'<jupyter_code>dados = []
textos2 = textos.tolist()
classificacao2 = classificacao.tolist()

# textos.loc[idx]
# textos2[idx]

for idx, lista in enumerate(vetores_de_texto):
    nova_lista = [textos2[idx], *lista, classificacao2[idx]]
    dados.append(nova_lista)

# Exemplo de Descrição de Item (coluna DESCR_ITEM) e 
# sua representação vetorial (conjunto de palavras na sequência) e
# a classificação da Natureza da BC dos Créditos (coluna NAT_BC_CRED).
# Create the pandas DataFrame
coluna_nome = ['DESCR_ITEM', *list(palavras), 'NAT_BC_CRED']
df3 = pd.DataFrame(dados, columns = coluna_nome)
df3.head()
# Transformação Inversa. Dado um vetor, encontrar o texto correspondente
def textualizar_vetor(vetor, tradutor):
    lista_de_palavras = []
    for index, value in enumerate(vetor):
        #print(index, value)
        if value == 1:
            for palavra, numero in tradutor.items():
                if numero == index:
                    lista_de_palavras.append(palavra)
    texto = ' '.join(lista_de_palavras)
    return texto

textualizar_vetor(vetores_de_texto[0],tradutor)<jupyter_output><empty_output><jupyter_text>Separar as variáveis de treino e teste:<jupyter_code>x = vetores_de_texto
y = classificacao

# Criar os conjuntos de dados de treino e teste (para evitar vício):
x_treino, x_teste, y_treino, y_teste = train_test_split(x, y, test_size = 0.30)<jupyter_output><empty_output><jupyter_text>Machine Learning algoritmo n° 1: DummyClassifierDummyClassifier is a classifier that makes predictions using simple rules.This classifier is useful as a simple baseline to compare with other (real) classifiers. Do not use it for real problems.<jupyter_code># Train a dummy classifier to make predictions based on the most_frequent class value
modeloDMC = DummyClassifier(strategy="most_frequent")
modeloDMC.fit(x_treino, y_treino)

# Returns the mean accuracy on the given test data and labels.
acuraciaDMC = modeloDMC.score(x_teste, y_teste)

# Imprimir os resultados:
print(f"Acurácia (DummyClassifier): {acuraciaDMC*100:.2f}%")
# Ao invés de usar dummy_clf.score, poderíamos ter usados as duas funções dummy_clf.predict e accuracy_score:
y_previsoes = modeloDMC.predict(x_teste)
ac = accuracy_score(y_previsoes, y_teste)

# Imprimir os resultados:
print(f"Acurácia (DummyClassifier): {ac*100:.2f}%")
# Usar o modelo com as variáveis x_teste como entradas e comparar as variáveis de previsoes_para_y e y_teste:
previsoes_para_y = modeloDMC.predict(x_teste[:50]).tolist()

for teste, prev in zip(y_teste[:50] , previsoes_para_y):
    print(f'{teste = } ; {prev = }')<jupyter_output>teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; p[...]<jupyter_text>Machine Learning algoritmo n° 2: MultinomialNBNaive Bayes classifier for multinomial modelsThe multinomial Naive Bayes classifier is suitable for classification with discrete features (e.g., word counts for text classification). The multinomial distribution normally requires integer feature counts. However, in practice, fractional counts such as tf-idf may also work.<jupyter_code>modeloNB = MultinomialNB()
modeloNB.fit(x_treino, y_treino)

# Return the mean accuracy on the given test data and labels.
acuraciaNB = modeloNB.score(x_teste, y_teste)

# Imprimir os resultados:
print(f"Acurácia (MultinomialNB): {acuraciaNB*100:.2f}%")
# Usar o modelo com as variáveis x_teste como entradas e comparar as variáveis de previsoes_para_y e y_teste:
previsoes_para_y = modeloNB.predict(x_teste[:50]).tolist()

for teste, prev in zip(y_teste[:50] , previsoes_para_y):
    print(f'{teste = } ; {prev = }')<jupyter_output>teste = '00 - Operações sem direito a crédito' ; prev = '02 - Aquisição de bens utilizados como insumo'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '02 - Aquisição de bens utilizados como insumo'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem dire[...]<jupyter_text>Machine Learning algoritmo n° 3: Linear Support Vector Classification.<jupyter_code># Train a dummy classifier to make predictions based on the most_frequent class value
modeloSVC = LinearSVC()
modeloSVC.fit(x_treino, y_treino)

# Return the mean accuracy on the given test data and labels.
acuraciaSVC = modeloSVC.score(x_teste, y_teste)

# Imprimir os resultados:
print(f"Acurácia (LinearSVC): {acuraciaSVC*100:.2f}%")
# Usar o modelo com as variáveis x_teste como entradas e comparar as variáveis de previsoes_para_y e y_teste:
previsoes_para_y = modeloSVC.predict(x_teste[:50]).tolist()

for teste, prev in zip(y_teste[:50] , previsoes_para_y):
    print(f'{teste = } ; {prev = }')<jupyter_output>teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; prev = '00 - Operações sem direito a crédito'
teste = '00 - Operações sem direito a crédito' ; p[...]<jupyter_text>Machine Learning algoritmo n° 4: DecisionTreesClassifierDecisionTreeClassifier is a class capable of performing multi-class classification on a dataset.<jupyter_code># Criação do modelo:
modeloDTC = DecisionTreeClassifier()
modeloDTC.fit(x_treino, y_treino)

acuraciaDTC = modeloDTC.score(x_teste, y_teste)

# Imprimir os resultados:
print(f"Acurácia (DecisionTreeClassifier): {acuraciaDTC*100:.2f}%")
# Usar o modelo com as variáveis x_teste como entradas e comparar as variáveis de previsoes_para_y e y_teste:
previsoes_para_y = modeloDTC.predict(x_teste[:50]).tolist()

for teste, prev in zip(y_teste[:50] , previsoes_para_y):
    print(f'{teste = } ; {prev = }')
# Podemos plotar a árvore, após o treino:
# https://scikit-learn.org/stable/modules/tree.html
# https://towardsdatascience.com/understanding-decision-trees-for-classification-python-9663d683c952
modeloDTC_amostra = DecisionTreeClassifier()
modeloDTC_amostra.fit(x[:20], y[:20])
for index, texto in enumerate(x[:20]):
    print(textualizar_vetor(texto,tradutor))
class_names = modeloDTC_amostra.classes_
class_names
dot_data = tree.export_graphviz(
    modeloDTC_amostra, 
    out_file=None,
    class_names=planilha['NAT_BC_CRED'].unique(),
    feature_names=list(palavras),
    filled=True, rounded=True,
    special_characters=True,
    #proportion=False,
)
graph = graphviz.Source(dot_data)
graph.render('DecisionTreeClassifier',format='png')
graph<jupyter_output><empty_output><jupyter_text>Problema:A partir de Itens com descrições quaisquer encontrar a classificação da Natureza da Base de Cálculo.Utilizar o algoritmo de maior acurácia.<jupyter_code>modelos = {
    modeloDMC: acuraciaDMC,
    modeloNB : acuraciaNB,
    modeloSVC: acuraciaSVC,
    modeloDTC: acuraciaDTC
}

# creating a Dataframe object from a list 
# of tuples of key, value pair
df_modelos = pd.DataFrame(list(modelos.items()), columns = ['Modelos', 'Acurácia'])
df_modelos
melhor_modelo = None
valor_max = 0

for modelo, acuracia in modelos.items():
    if acuracia > valor_max:
        melhor_modelo = modelo
        valor_max = acuracia
melhor_modelo
itens_teste = [
    'ARMAZENAGEM DE PRODUTO',
    'ARMAZENAGEM DE Soja',
    'LOCACAO Imovel',
    'Acetona',
    'VinhoDoce',
    'MONOManoGlicoVerde',
    '<NAME>', 'jabuticaba'
]
itens = pd.Series(itens_teste).str.lower()
itens.replace(dicionario, regex=True, inplace=True)
itens = itens.str.split()
itens
itens_vetorizado = [vetorizar_textos(item, tradutor) for item in itens]
# how to combine two flat lists into a 2D array? [duplicate]
lista_2d = list(zip(itens_teste, melhor_modelo.predict(itens_vetorizado)))

# creating df object with columns specified    
df2 = pd.DataFrame(lista_2d, columns =['DESCR_ITEM teste', 'NAT_BC_CRED (previsto)']) 
df2

# Adicionar modelos ou algoritmos
models = []

models.append(('DMC', DummyClassifier(strategy="most_frequent")))
models.append(('DTC', DecisionTreeClassifier()))
models.append(('KNC', KNeighborsClassifier()))
models.append(('LDA', LinearDiscriminantAnalysis()))
models.append(('LSVC', LinearSVC(max_iter=10000)))
models.append(('MNB', MultinomialNB()))
models.append(('GNB', GaussianNB()))
models.append(('BNB', BernoulliNB()))

models.append(('LGR', LogisticRegression(solver='lbfgs', max_iter=1000)))
# prepare configuration for cross validation test harness
seed = 10
# How to count the number of rows in a Pandas DataFrame in Python
N = len(df3.index)

# Selecionar apenas uma amostra
#N = 100

# To get N random rows
df4 = df3.sample(n = N)

# Selecionar amostras aleatórias com N elementos
amostra_x = df4.drop('DESCR_ITEM', axis = 1).drop('NAT_BC_CRED', axis = 1)
amostra_y = df4['NAT_BC_CRED']

# evaluate each model in turn
results = []
names = []
scoring = 'accuracy'
for name, model in models:
    # K-Folds cross-validator
    # Provides train/test indices to split data in train/test sets. 
    # Split dataset into k consecutive folds (without shuffling by default).
    kfold = model_selection.KFold(n_splits=10, shuffle=True, random_state=seed)
    
    # Evaluate a score by cross-validation
    # cv: int, cross-validation generator or an iterable, default=None
    # Determines the cross-validation splitting strategy. Possible inputs for cv are:
    #    None, to use the default 5-fold cross validation,
    #    int, to specify the number of folds in a (Stratified)KFold,
    #    CV splitter, 
    #    An iterable yielding (train, test) splits as arrays of indices.
    cv_results = model_selection.cross_val_score(model, amostra_x, amostra_y, cv=kfold, scoring=scoring)
    
    results.append(cv_results)
    names.append(name)
    print(f'algoritmo {name:>4}: media {cv_results.mean():.5f} ; desvio padrão {cv_results.std():.5f}')
# boxplot algorithm comparison
fig = plt.figure()
fig.suptitle('Comparação de 9 Algoritmos na Classificação de Texto')
ax = fig.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names)
plt.savefig('algorithm_comparison.png', bbox_inches='tight', dpi=300)
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10203758027432015, 'fraction_numerical': 0.018552287322603663, 'mean_word_length': 4.877912395153775, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 29, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '400083', 'license': 'MIT', 'n_tokens_mistral': 4737, 'n_tokens_neox': 4509, 'n_words': 1322, 'path': 'DadosML/classificar_insumos_em_funcao_da_natureza_da_base_de_calculo.ipynb', 'repo_name': 'claudiofsr/python-sped', 'size': '12619'}