<jupyter_start><jupyter_text>PROCESSAMENTO DE LINGUAGEM NATURAL (NLP)(*NATURAL LANGUAGE PROCESSING*) ![](https://www.encora.com/hs-fs/hubfs/Blog-EncoraML.png?width=800&name=Blog-EncoraML.png)Processamento de linguagem natural (NLP) é um subcampo da linguística, ciência da computação e inteligência artificial preocupado com as interações entre computadores e linguagem humana, em particular como programar computadores para processar e analisar grandes quantidades de dados de linguagem natural. O resultado é um computador capaz de "compreender" o conteúdo dos documentos, incluindo as nuances contextuais da linguagem dentro deles. A tecnologia pode então extrair com precisão as informações e percepções contidas nos documentos, bem como categorizar e organizar os próprios documentos. Os desafios no processamento de linguagem natural frequentemente envolvem reconhecimento de fala, compreensão de linguagem natural e geração de linguagem natural.O processamento de linguagem natural (ou Linguística computacional está se tornando o estado da arte no mundo de hoje. Evoluiu muitos anos atrás na década de 1960. A tarefa da NLP é entender as expressões humanas naturais em termos de fala ou texto, tomando como entrada e fornecendo A mineração de texto, também chamada de *Text Analytics*, usa o processamento de linguagem natural para transformar corpus não estruturados em documentos ou bancos de dados padronizados e normalizados para análise posterior, aplicando técnicas de inteligência artificial e algoritmos de aprendizado de máquina.**APLICAÇÕES DE NLP**A seguir está uma lista de algumas das aplicações mais frequentes do processamento de linguagem natural. Algumas dessas tarefas têm aplicativos diretos do mundo real, enquanto outras normalmente servem como subtarefas que são usadas para ajudar na resolução de tarefas maiores.Embora as tarefas de processamento de linguagem natural estejam intimamente interligadas, elas podem ser subdivididas em categorias por conveniência, como descrito abaixo:* **Processamento de texto e fala*** Análise morfológica* Análise sintática* Semântica lexical* Semântica relacional (semântica de frases individuais)* Discurso (semântica além das frases individuais)* Aplicativos de NLP de nível superior 1.MANIPULAÇÃO DE *STRINGS****String***: Em programação de computador, uma *string* é tradicionalmente uma sequência de caracteres, seja como uma constante literal ou como algum tipo de variável. Este último pode permitir que seus elementos sejam mutados e o comprimento alterado, ou pode ser corrigido (após a criação). Uma *string* é geralmente considerada como um tipo de dados e frequentemente implementada como uma estrutura de dados de matriz de bytes (ou palavras) que armazena uma sequência de elementos, normalmente caracteres, usando alguma codificação de caracteres.([Leia](https://realpython.com/python-input-output/))Ex: `"olá"` ,`"olá mundo"` ,`"olá mundo, essa frase é uma string"`A seguir veremos alguns métodos e propiedades úteis para manipulação de *strings*.  1.1. Método: *print** print() - Retorna valores no terminal>sintaxe : `print("olá mundo")`<jupyter_code>frase="olá mundo"
print(frase)<jupyter_output>olá mundo<jupyter_text>1.2. Método *format** format()- Insere variáveis dentro de uma string>sintaxe : `"olá mundo, meu nome é {}".format("Seu nome")`<jupyter_code>nome='Felipe'
frase="olá mundo, meu nome é {}".format(nome)
print(frase)
frase=f"olá mundo, meu nome é {nome}"
print(frase)<jupyter_output>olá mundo, meu nome é Felipe<jupyter_text>1.3. Métodos: *capitalize* , *title*, *upper* e *lower** upper () - Converte uma string em maiúsculas>sintaxe : ` "olá mundo".upper() = "OLÁ MUNDO`* lower () - Converte uma string em minúsculas>sintaxe : ` "olá mundo".lower() = olá mundo`* capitalize () - Converte o primeiro caractere em maiúsculas>sintaxe : ` "olá mundo".capitalize() = "Olá mundo"`* title () - Converte o primeiro caractere de cada palavra em maiúsculas>sintaxe : ` "olá mundo".title() = "Olá Mundo"`<jupyter_code>#Frase original
nome='Felipe'
frase="olá mundo, meu nome é {}".format(nome)
#Upper
print(frase.upper())
#Lower
print(frase.lower())
#Capitalize
print(frase)
#Title
print(frase)<jupyter_output>olá mundo, meu nome é Felipe<jupyter_text>1.4. Propriedade : *list** Para o python toda string pode ser interpretada como uma lista, dessa forma a maioria dos métodos do objeto *list()* são aplicavéis a strings.Abaixo veremos alguns exemplos:<jupyter_code>#Tamanho
len(frase)
#Index
frase[2]
# Intevarlo
frase[0:3]
#Inversão
frase[::-1]
#Máximo
max(frase)
#Mínimo
min(frase)
# Valores únicos
set(frase)<jupyter_output><empty_output><jupyter_text>1.5. Método *count*, *replace* e *split** count () - Retorna o número de vezes que um valor especificado ocorre em uma string>sintaxe : ` "olá mundo".count("olá") = 1`* replace () - Retorna uma string onde um valor especificado é substituído por um valor especificado>sintaxe : ` "olá mundo".count("olá","oi") = "oi mundo"`* split () - Divide a string no separador especificado e retorna uma lista >sintaxe : ` "olá mundo".split() = ["olá","mundo"]`<jupyter_code>#Count
frase.count('mundo')
#Replace
frase.replace("olá","oi")
#Split
frase.split()
#Total de palvras na frase
len(frase.split())<jupyter_output><empty_output><jupyter_text>1.6. Teste da seçãoCrie uma função que conte o número de palavras na frase : **"Um livro é a prova de que os homens são capazes de fazer magia"**Resultado esperado:`um:1, livro:1, é:1, a:7, prova:1 , de:2 , que:1 , os:1 , homens:1 ,são:1 ,capazes:1, fazer:1, magia:1`<jupyter_code># Definir frase
frase_teste="Um livro é a prova de que os homens são capazes de fazer magia"

# Definir função
def ContaPalvras(frase):
     [print( f"{palavra}:{str(frase.count(palavra))}") for palavra in set(frase.split())]

#Aplicação
ContaPalvras(frase_teste)<jupyter_output>prova:1
homens:1
livro:1
de:2
magia:1
a:7
são:1
que:1
Um:1
fazer:1
capazes:1
é:1
os:1<jupyter_text>2.OLÁ MUNDO DO NLP E A MINERAÇÃO DE TEXTOSMineração de texto, conhecida também como mineração de dados textuais e semelhante à análise textual, refere-se ao processo de obtenção de informações importantes de um texto. Informações importantes são obtidas normalmente pela elaboração de padrões e tendências através de meios como o padrão estatístico de aprendizagem. Geralmente a mineração de texto envolve o processo de estruturação do texto de entrada (frequentemente análise, junto com a adição de algumas características linguísticas derivadas e com a retirada de outras, e com a subsequente inserção em um banco de dados), de derivação de padrões dentro da estrutura de dados e, por fim, de avaliação e interpretação do resultado. ([Wipedia](https://pt.wikipedia.org/wiki/Minera%C3%A7%C3%A3o_de_texto))<jupyter_code># Ler um arquivo de texto
rap_lord=open('Rap Lord.txt','r',encoding="utf8").read()
print(rap_lord)<jupyter_output>Lutei pra entrar e não vou sair
Os que não pertencem eu devolvi
Ácido no metal causa efeito letal
Teto baixo te espreme, respira
Quem pira tá na mira da minha firma
Então me espera recupera o fôlego
Se comigo não morre nunca cai
Não tento a sorte, Woodstock num flow metódico
Toma é pra quem quer dou é pra quem pode
E nosso destino é uma caixa de surpresa
Leopardo ou zebra me diz
'Cê quer ser predador ou presa (é assim ô)
Percorri pela beira da terra
Até a sorte me dizer, menino você tem uma aval
No tempo essência eu elevo no peito
O excesso essencial
É muito bom não se acomodar
Satisfação se o verso ecoar
Vendo em polpa não vou me poupar
Então demorou meu mano, let's go
Quero que se foda o que disser
'Tô de pé, vou mantendo a fé até
Meu mano vou correndo igual ralé
Adivinha o que tu quer, vagabundo quer
Mas e quem não quer, né?
Quero ver dinheiro na responsa
Ser amigo da onça, jacaré que banca vira bolsa
Mano, então me mostre a cara
Convivência com malandro que já foi da costa
Fala pra[...]<jupyter_text>2.1.ColeçõesColeções em Python são contêineres usados para armazenar coleções de dados, por exemplo, list, dict, set, tuple etc. Essas são coleções integradas. Vários módulos foram desenvolvidos para fornecer estruturas de dados adicionais para armazenar coleções de dados. Um desses módulos é o *collections* , nativo do próprio Python.<jupyter_code># Importar a biblioteca
from collections import Counter
#Contar letras mais frequentes
Counter(rap_lord).most_common(10)
#Contar palavras mais frequentes
Counter(rap_lord.split()).most_common(10)<jupyter_output><empty_output><jupyter_text>2.2. Teste da seçãoa. Crie uma função que conte a participação percentual das 10 letras mais frequentes na música Rap Lord  > Resultado esperado: ` " " : 16.69% , "a" : 10.32% , "e" : 9.26% ...`b. Crie uma função que conte a participação percentual das 10 palavras mais frequentes na música Rap Lord  > Resultado esperado: `"não" : 3.89%, "que" : 3.78% , "o" : 2.48% ,"de" : 2.05% ...`<jupyter_code>#Definir função
def frequencias(texto,top):
  #Totais
  total_letras = sum(Counter(texto).values())
  #Mais frequentes
  letras_frequentes = Counter(texto).most_common(top)
  #Exibir
  for letter in letras_frequentes:
      print (f"{letter[0]} : {round((letter[1]/total_letras)*100,2)}%")
frequencias(rap_lord,10)<jupyter_output>: 16.69%
a : 10.32%
e : 9.26%
o : 8.29%
n : 4.45%
r : 4.43%
i : 4.24%
u : 3.99%
m : 3.8%
s : 3.69%
{'fraction_non_alphanumeric': 0.08770799785292539, 'fraction_numerical': 0.01406333870101986, 'mean_word_length': 5.593064401981599, 'pattern_counts': {'":': 0, '<': 31, '<?xml version=': 0, '>': 42, 'https://': 3, 'lorem ipsum': 0, 'www.': 1, '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': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '490397', 'license': 'MIT', 'n_tokens_mistral': 3425, 'n_tokens_neox': 3340, 'n_words': 1180, 'path': 'Python/Machine Learning With Python/Natural Language Processing/Introductory Class - (UFPA)/NLP PARTE I.ipynb', 'repo_name': 'FelipeRamosOliveira/Portfolio', 'size': '9315'}