Categorías
Python

Unicode y carácter codificaciones en Python: una guía sin dolor

 

Tabla de Contenidos

  • ¿Cuáles son PNL y SPACY?
  • InstallationHow instalar spaCyHow para descargar modelos y datos
  • Cómo instalar SPACY
  • Cómo descargar modelos y datos
  • Usando spaCyHow leer un StringHow para leer un archivo de texto
  • Cómo leer una cadena
  • Cómo leer un archivo de texto
  • Sentencia Detección
  • Tokenization en sPACY
  • palabras vacías
  • lematización
  • Word Frequency
  • parte del discurso de etiquetado
  • Visualización: Uso de la coincidencia de funciones displaCy
  • preprocesamiento basado en normas
  • Usando sPACY
  • Dependencia analizar Usando sPACY
  • Navegación por el árbol y el subárbol
  • superficial ParsingNoun Frase DetectionVerb Frase Detección
  • frase nominal Detección
  • frase verbal Detección
  • Nombrado Entidad Reconocimiento
  • Conclusión
  • Cómo instalar sPACY
  • Cómo descargar modelos y datos
  • TG_01 9

    • Cómo leer una cadena
    • Cómo leer un archivo de texto
    • frase nominal Detección
    • frase verbal Detección

    SPACY es una biblioteca libre y de código abierto para Natural Language Processing ( PNL) en Python con una gran cantidad de capacidades incorporado. Se está convirtiendo cada vez más popular para el procesamiento y análisis de datos en la PNL. Pruebas de datos no estructurados se produce a gran escala, y es importante para el proceso y las ideas se derivan de los datos no estructurados. Para ello, es necesario representar los datos en un formato que pueda ser entendido por los ordenadores. PNL puede ayudarle a hacer eso.

    En este tutorial, aprenderá:

    • Lo que los términos y conceptos fundamentales de la PNL son
    • Cómo implementar esos conceptos en SPACY
    • Cómo personalizar y ampliar incorporado funcionalidades en SPACY
    • Cómo para realizar análisis estadísticos básicos sobre un texto
    • Cómo crear un gasoducto para procesar texto no estructurado
    • Cómo analizar una frase y extraer conocimiento con sentido de ella Bono

    gratuito: Haga clic aquí para obtener acceso a un capítulo de Python trucos: El libro que te muestra las mejores prácticas de Python con ejemplos sencillos puede aplicar instantáneamente a escribir código más bonito + Pythonic.

    ¿Cuáles son PNL y SPACY?

    PNL es un subcampo de la inteligencia artificial y se ocupa de las interacciones entre los ordenadores y los lenguajes humanos. PNL es el proceso de analizar, comprender y derivar significado del lenguaje humano para ordenadores.

    PNL ayuda a extraer ideas de texto no estructurado y tiene varios casos de uso, tales como:

    • resumen automático
    • entidad denominada reconocimiento
    • Respuesta automática a preguntas análisis de sentimientos

    SPACY es una biblioteca libre de código abierto de PNL en Python. Está escrito en Cython y está diseñado para sistemas de comprensión del lenguaje natural o extracción de información de construcción. Está construido para uso en producción y proporciona una API concisa y fácil de usar. Instalación

    En esta sección, vamos a instalar SPACY y luego descargar los datos y modelos para el idioma Inglés.

    Cómo instalar SPACY

    SPACY puede instalarse utilizando pip , un gestor de paquetes de Python. Puede utilizar un entorno virtual a no depender de los paquetes de todo el sistema. Para obtener más información sobre entorno virtual s y pip , echa un vistazo a ¿Qué es la pipa? Una guía para Nueva Pythonistas y Python entornos virtuales: Una cartilla.

    Crear un nuevo entorno virtual:

    $ python3 -m venv env

    Activar este entorno virtual e instalar SPACY:

    $ source ./env/bin/activate
    $ pip install spacy

    de cómo descargar los modelos y los datos

    SPACY tiene diferentes tipos de modelos. El modelo por defecto para el idioma Inglés es en_core_web_sm.

    Activar el entorno virtual creado en los anteriores modelos de paso y de descarga y los datos para el idioma Inglés:

    $ python -m spacy download en_core_web_sm

    Verificar si la descarga se ha realizado correctamente o no cargándolo:

    >>> import spacy
    >>> nlp = spacy.load('en_core_web_sm')

    Si se crea el objeto PNL, entonces significa que sPACY se instaló y que los modelos y los datos se ha descargado correctamente.

    Usando SPACY

    En esta sección, vamos a usar espaciosa para una cadena de entrada y un archivo de texto. Cargar la instancia modelo de lenguaje en SPACY:

    >>> import spacy
    >>> nlp = spacy.load('en_core_web_sm')

    Aquí, el objeto es una instancia de la PNL modelo de lenguaje. Se puede suponer que, a lo largo de este tutorial, la PNL se refiere al modelo de lenguaje cargado por en_core_web_sm. Ahora puede utilizar SPACY para leer una cadena o un archivo de texto.

    Cómo leer una cadena

    Usted puede utilizar SPACY para crear un objeto Doc procesado, que es un contenedor para acceder a las anotaciones lingüísticas, para una cadena de entrada:

    >>> introduction_text = ('This tutorial is about Natural'
    ... ' Language Processing in Spacy.')
    >>> introduction_doc = nlp(introduction_text)
    >>> # Extract tokens for the given doc
    >>> print ([token.text for token in introduction_doc])
    ['This', 'tutorial', 'is', 'about', 'Natural', 'Language',
    'Processing', 'in', 'Spacy', '.']

    En el ejemplo anterior, el aviso cómo el texto se convierte en un objeto que se entiende por sPACY. Puede utilizar este método para convertir cualquier texto en un objeto Doc procesados ​​y atributos deducir que será cubierto en las próximas secciones.

    Cómo leer un archivo de texto

    En esta sección, creará un objeto Doc procesada por un archivo de texto:

    >>> file_name = 'introduction.txt'
    >>> introduction_file_text = open(file_name).read()
    >>> introduction_file_doc = nlp(introduction_file_text)
    >>> # Extract tokens for the given doc
    >>> print ([token.text for token in introduction_file_doc])
    ['This', 'tutorial', 'is', 'about', 'Natural', 'Language',
    'Processing', 'in', 'Spacy', '.', '\n']

    Así es como se puede convertir un archivo de texto en un objeto Doc procesado.

    Nota:

    se puede asumir que:

    • Los nombres de variables que termina con el sufijo _TEXT son objetos de cadena Unicode.
    • Nombre de la variable que termina con el sufijo _doc son los objetos del modelo de lenguaje SPACY.

    Sentence Detección

    Sentence Detección es el proceso de localizar el inicio y el final de las oraciones en un texto dado. Esto le permite divide un texto en unidades lingüísticamente significativas. Vamos a usar estas unidades cuando se está procesando el texto para realizar tareas tales como etiquetado gramatical y extracción de entidades .

    En SPACY, la propiedad senta se utiliza para extraer frases. Así es como se extraería el número total de frases y las frases de un texto de entrada dado:

    >>> about_text = ('Gus Proto is a Python developer currently'
    ... ' working for a London-based Fintech'
    ... ' company. He is interested in learning'
    ... ' Natural Language Processing.')
    >>> about_doc = nlp(about_text)
    >>> sentences = list(about_doc.sents)
    >>> len(sentences)
    2
    >>> for sentence in sentences:
    ... print (sentence)
    ...
    'Gus Proto is a Python developer currently working for a
    London-based Fintech company.'
    'He is interested in learning Natural Language Processing.'

    En el ejemplo anterior, SPACY es correcta capaz de identificar frases en el idioma Inglés, con un punto como delimitador frase (.) . También puede personalizar la detección frase para detectar frases en delimitadores personalizados.

    He aquí un ejemplo, cuando se utiliza una elipsis (…) como delimitador:

    >>> def set_custom_boundaries(doc):
    ... # Adds support to use `...` as the delimiter for sentence detection
    ... for token in doc[:-1]:
    ... if token.text == '...':
    ... doc[token.i+1].is_sent_start = True
    ... return doc
    ...
    >>> ellipsis_text = ('Gus, can you, ... never mind, I forgot'
    ... ' what I was saying. So, do you think'
    ... ' we should ...')
    >>> # Load a new model instance
    >>> custom_nlp = spacy.load('en_core_web_sm')
    >>> custom_nlp.add_pipe(set_custom_boundaries, before='parser')
    >>> custom_ellipsis_doc = custom_nlp(ellipsis_text)
    >>> custom_ellipsis_sentences = list(custom_ellipsis_doc.sents)
    >>> for sentence in custom_ellipsis_sentences:
    ... print(sentence)
    ...
    Gus, can you, ...
    never mind, I forgot what I was saying.
    So, do you think we should ...
    >>> # Sentence Detection with no customization
    >>> ellipsis_doc = nlp(ellipsis_text)
    >>> ellipsis_sentences = list(ellipsis_doc.sents)
    >>> for sentence in ellipsis_sentences:
    ... print(sentence)
    ...
    Gus, can you, ... never mind, I forgot what I was saying.
    So, do you think we should ...

    Tenga en cuenta que custom_ellipsis_sentences contienen tres frases, mientras que ellipsis_sentences contiene dos frases. Estas frases todavía se obtienen a través del atributo senta, como se vio antes.

    Tokenization en SPACY

    Tokenization es el siguiente paso después de la detección frase. Se le permite identificar las unidades básicas en su texto. Estas unidades básicas se llaman fichas . Tokenization es útil porque rompe un texto en unidades significativas. Estas unidades se utilizan para el análisis adicional, como etiquetado gramatical.

    En SPACY, puede imprimir fichas iterando el objeto Doc:

    >>> for token in about_doc:
    ... print (token, token.idx)
    ...
    Gus 0
    Proto 4
    is 10
    a 13
    Python 15
    developer 22
    currently 32
    working 42
    for 50
    a 54
    London 56
    - 62
    based 63
    Fintech 69
    company 77
    . 84
    He 86
    is 89
    interested 92
    in 103
    learning 106
    Natural 115
    Language 123
    Processing 132
    . 142

    Nota cómo SPACY conserva la índice a partir de las fichas. Es útil para la sustitución de palabras en su lugar. SPACY proporciona varios atributos para la clase Token:

    >>> for token in about_doc:
    ... print (token, token.idx, token.text_with_ws,
    ... token.is_alpha, token.is_punct, token.is_space,
    ... token.shape_, token.is_stop)
    ...
    Gus 0 Gus True False False Xxx False
    Proto 4 Proto True False False Xxxxx False
    is 10 is True False False xx True
    a 13 a True False False x True
    Python 15 Python True False False Xxxxx False
    developer 22 developer True False False xxxx False
    currently 32 currently True False False xxxx False
    working 42 working True False False xxxx False
    for 50 for True False False xxx True
    a 54 a True False False x True
    London 56 London True False False Xxxxx False
    - 62 - False True False - False
    based 63 based True False False xxxx False
    Fintech 69 Fintech True False False Xxxxx False
    company 77 company True False False xxxx False
    . 84 . False True False . False
    He 86 He True False False Xx True
    is 89 is True False False xx True
    interested 92 interested True False False xxxx False
    in 103 in True False False xx True
    learning 106 learning True False False xxxx False
    Natural 115 Natural True False False Xxxxx False
    Language 123 Language True False False Xxxxx False
    Processing 132 Processing True False False Xxxxx False
    . 142 . False True False . False

    En este ejemplo, algunos de los atributos comúnmente requeridas se accede:

    • text_with_ws grabados texto contador de arrastre espacio (si está presente).
    • is_alpha detecta si el elemento está formada por caracteres alfabéticos o no.
    • detecta is_punct si el elemento es un símbolo de puntuacion o no.
    • is_space detecta si el token es un espacio o no.
    • shape_ imprime la forma de la palabra.
    • is_stop detecta si el elemento está parada una palabra o no.

    Nota: Vas a aprender más acerca de las palabras vacías en la siguiente sección.

    También puede personalizar el proceso de tokenización para detectar señales de caracteres personalizados. Esto a menudo se utiliza para las palabras con guiones, que son palabras unidas con un guión. Por ejemplo, “londinense” es una palabra con guión.

    SPACY le permite personalizar la tokenización mediante la actualización de la propiedad tokenizer en el objeto de la PNL:

    >>> import re
    >>> import spacy
    >>> from spacy.tokenizer import Tokenizer
    >>> custom_nlp = spacy.load('en_core_web_sm')
    >>> prefix_re = spacy.util.compile_prefix_regex(custom_nlp.Defaults.prefixes)
    >>> suffix_re = spacy.util.compile_suffix_regex(custom_nlp.Defaults.suffixes)
    >>> infix_re = re.compile(r'''[-~]''')
    >>> def customize_tokenizer(nlp):
    ... # Adds support to use `-` as the delimiter for tokenization
    ... return Tokenizer(nlp.vocab, prefix_search=prefix_re.search,
    ... suffix_search=suffix_re.search,
    ... infix_finditer=infix_re.finditer,
    ... token_match=None
    ... )
    ...

    >>> custom_nlp.tokenizer = customize_tokenizer(custom_nlp)
    >>> custom_tokenizer_about_doc = custom_nlp(about_text)
    >>> print([token.text for token in custom_tokenizer_about_doc])
    ['Gus', 'Proto', 'is', 'a', 'Python', 'developer', 'currently',
    'working', 'for', 'a', 'London', '-', 'based', 'Fintech',
    'company', '.', 'He', 'is', 'interested', 'in', 'learning',
    'Natural', 'Language', 'Processing', '.']

    Con el fin de personalizar, se puede pasar varios parámetros a la clase Tokenizer:

    • nlp.vocab es un recipiente de almacenamiento para especial casos y se utiliza para manejar casos como contracciones y emoticonos.
    • prefix_search es la función que se utiliza para manejar anterior puntuacion, como paréntesis de apertura.
    • infix_finditer es la función que se utiliza para manejar separadores no está en blanco, como guiones.
    • suffix_search es la función que se utiliza para manejar éxito puntuacion, como paréntesis de cierre.
    • token_match es una función booleana opcional que se utiliza para que coincida con cuerdas que nunca debe ser dividida. Se anula las reglas anteriores y es útil para entidades como URLs o números.

    Nota: SPACY ya se detecta palabras con guiones como fichas individuales. El código anterior es sólo un ejemplo para mostrar cómo se puede personalizar tokenización. Se puede utilizar para cualquier otro carácter. Palabras

    parada

    Detener palabras son las palabras más comunes en un idioma. En el idioma Inglés, algunos ejemplos de palabras de parada son los, son, sino, y ellos. La mayoría de las oraciones deben contener palabras vacías con el fin de ser frases completas que tengan sentido.

    En general, las palabras vacías se eliminan porque no son significativos y distorsionan el análisis de frecuencia de palabras. SPACY tiene una lista de palabras de parada para el idioma Inglés:

    >>> import spacy
    >>> spacy_stopwords = spacy.lang.en.stop_words.STOP_WORDS
    >>> len(spacy_stopwords)
    326
    >>> for stop_word in list(spacy_stopwords)[:10]:
    ... print(stop_word)
    ...
    using
    becomes
    had
    itself
    once
    often
    is
    herein
    who
    too

    Puede eliminar las palabras vacías a partir del texto de entrada:

    >>> for token in about_doc:
    ... if not token.is_stop:
    ... print (token)
    ...
    Gus
    Proto
    Python
    developer
    currently
    working
    London
    -
    based
    Fintech
    company
    .
    interested
    learning
    Natural
    Language
    Processing
    .

    Detener palabras como es, una, por, el, y en el que no se imprimen en la salida anterior. También puede crear una lista de testigos que no contengan palabras vacías:

    >>> about_no_stopword_doc = [token for token in about_doc if not token.is_stop]
    >>> print (about_no_stopword_doc)
    [Gus, Proto, Python, developer, currently, working, London,
    -, based, Fintech, company, ., interested, learning, Natural,
    Language, Processing, .]

    about_no_stopword_doc se puede unir con espacios para formar una oración sin palabras vacías.

    Lematización

    Lematización es el proceso de reducir las formas declinadas de una palabra sin dejar de asegurar que la forma reducida pertenece al lenguaje. Esta forma o raíz de la palabra reducida se denomina lema .

    Por ejemplo, organizan s , organizar d y organizar son todas las formas de organizan . Aquí, organizar es el lema. La inflexión de una palabra le permite expresar diferentes categorías gramaticales como tensa ( organizar d vs organizar ), número ( tren s vs tren ), y pronto. Lematización es necesario, ya que ayuda a reducir las formas declinadas de una palabra para que puedan ser analizados como un único elemento. También puede ayudar a normalizar el texto.

    SPACY tiene la lemma_ atributo en la clase de emergencia. Este atributo tiene la forma de un token lematizadas:

    >>> conference_help_text = ('Gus is helping organize a developer'
    ... 'conference on Applications of Natural Language'
    ... ' Processing. He keeps organizing local Python meetups'
    ... ' and several internal talks at his workplace.')
    >>> conference_help_doc = nlp(conference_help_text)
    >>> for token in conference_help_doc:
    ... print (token, token.lemma_)
    ...
    Gus Gus
    is be
    helping help
    organize organize
    a a
    developer developer
    conference conference
    on on
    Applications Applications
    of of
    Natural Natural
    Language Language
    Processing Processing
    . .
    He -PRON-
    keeps keep
    organizing organize
    local local
    Python Python
    meetups meetup
    and and
    several several
    internal internal
    talks talk
    at at
    his -PRON-
    workplace workplace
    . .

    En este ejemplo, la organización se reduce a su forma de organizar lema. Si no lemmatize el texto, a continuación, organizar y organizador será contado como diferentes fichas, a pesar de que ambos tienen un significado similar. Lematización le ayuda a evitar palabras duplicadas que tienen significados similares.

    Word Frequency

    Ahora puede convertir un texto dado en tokens y realizar análisis estadísticos sobre ella. Este análisis le puede dar diferentes puntos de vista sobre patrones de palabras, tales como palabras comunes o las palabras únicas en el texto:

    >>> from collections import Counter
    >>> complete_text = ('Gus Proto is a Python developer currently'
    ... 'working for a London-based Fintech company. He is'
    ... ' interested in learning Natural Language Processing.'
    ... ' There is a developer conference happening on 21 July'
    ... ' 2019 in London. It is titled "Applications of Natural'
    ... ' Language Processing". There is a helpline number '
    ... ' available at +1-1234567891. Gus is helping organize it.'
    ... ' He keeps organizing local Python meetups and several'
    ... ' internal talks at his workplace. Gus is also presenting'
    ... ' a talk. The talk will introduce the reader about "Use'
    ... ' cases of Natural Language Processing in Fintech".'
    ... ' Apart from his work, he is very passionate about music.'
    ... ' Gus is learning to play the Piano. He has enrolled '
    ... ' himself in the weekend batch of Great Piano Academy.'
    ... ' Great Piano Academy is situated in Mayfair or the City'
    ... ' of London and has world-class piano instructors.')
    ...
    >>> complete_doc = nlp(complete_text)
    >>> # Remove stop words and punctuation symbols
    >>> words = [token.text for token in complete_doc
    ... if not token.is_stop and not token.is_punct]
    >>> word_freq = Counter(words)
    >>> # 5 commonly occurring words with their frequencies
    >>> common_words = word_freq.most_common(5)
    >>> print (common_words)
    [('Gus', 4), ('London', 3), ('Natural', 3), ('Language', 3), ('Processing', 3)]
    >>> # Unique words
    >>> unique_words = [word for (word, freq) in word_freq.items() if freq == 1]
    >>> print (unique_words)
    ['Proto', 'currently', 'working', 'based', 'company',
    'interested', 'conference', 'happening', '21', 'July',
    '2019', 'titled', 'Applications', 'helpline', 'number',
    'available', '+1', '1234567891', 'helping', 'organize',
    'keeps', 'organizing', 'local', 'meetups', 'internal',
    'talks', 'workplace', 'presenting', 'introduce', 'reader',
    'Use', 'cases', 'Apart', 'work', 'passionate', 'music', 'play',
    'enrolled', 'weekend', 'batch', 'situated', 'Mayfair', 'City',
    'world', 'class', 'piano', 'instructors']

    Al observar las palabras comunes, se puede ver que el texto en su conjunto es probablemente alrededor de Gus, Londres o natural Procesamiento del lenguaje. De esta manera, se puede tomar cualquier texto estructurado y realizar análisis estadísticos para saber de qué se trata.

    Aquí hay otro ejemplo del mismo texto con las palabras vacías:

    >>> words_all = [token.text for token in complete_doc if not token.is_punct]
    >>> word_freq_all = Counter(words_all)
    >>> # 5 commonly occurring words with their frequencies
    >>> common_words_all = word_freq_all.most_common(5)
    >>> print (common_words_all)
    [('is', 10), ('a', 5), ('in', 5), ('Gus', 4), ('of', 4)]

    Cuatro de cada cinco de las palabras más comunes son palabras vacías, que no te dicen mucho sobre el texto. Si se tiene en cuenta las palabras de parada mientras se hace el análisis de frecuencia de palabras, entonces usted no será capaz de obtener conocimiento con sentido del texto de entrada. Esta es la razón por la eliminación de palabras vacías es tan importante.

    Parte del discurso Tagging

    Parte de la oración o POS es una función gramatical que explica cómo se usa una palabra en particular en una oración. Hay ocho partes del discurso:

    Parte de la oración etiquetado es el proceso de asignar una etiqueta POS a cada ficha, dependiendo de su uso en la frase. POS etiqueta s son útiles para la asignación de una categoría sintáctica como sustantivo, verbo o a cada palabra.

    En SPACY, etiquetas POS están disponibles como un atributo en el objeto simbólico:

    >>> for token in about_doc:
    ... print (token, token.tag_, token.pos_, spacy.explain(token.tag_))
    ...
    Gus NNP PROPN noun, proper singular
    Proto NNP PROPN noun, proper singular
    is VBZ VERB verb, 3rd person singular present
    a DT DET determiner
    Python NNP PROPN noun, proper singular
    developer NN NOUN noun, singular or mass
    currently RB ADV adverb
    working VBG VERB verb, gerund or present participle
    for IN ADP conjunction, subordinating or preposition
    a DT DET determiner
    London NNP PROPN noun, proper singular
    - HYPH PUNCT punctuation mark, hyphen
    based VBN VERB verb, past participle
    Fintech NNP PROPN noun, proper singular
    company NN NOUN noun, singular or mass
    . . PUNCT punctuation mark, sentence closer
    He PRP PRON pronoun, personal
    is VBZ VERB verb, 3rd person singular present
    interested JJ ADJ adjective
    in IN ADP conjunction, subordinating or preposition
    learning VBG VERB verb, gerund or present participle
    Natural NNP PROPN noun, proper singular
    Language NNP PROPN noun, proper singular
    Processing NNP PROPN noun, proper singular
    . . PUNCT punctuation mark, sentence closer

    Aquí, se accede a dos atributos de la clase de emergencia:

    spacy.explain da detalles descriptivos de un punto de venta etiqueta en particular. SPACY proporciona una lista de etiquetas completa junto con una explicación para cada etiqueta.

    El uso de identificadores de punto de venta, se puede extraer una categoría particular de las palabras:

    >>> nouns = []
    >>> adjectives = []
    >>> for token in about_doc:
    ... if token.pos_ == 'NOUN':
    ... nouns.append(token)
    ... if token.pos_ == 'ADJ':
    ... adjectives.append(token)
    ...
    >>> nouns
    [developer, company]
    >>> adjectives
    [interested]

    Usted puede usar esto para penetraciones Derivar, quitar los nombres más comunes, o ver qué adjetivos se utilizan para un sustantivo particular.

    Visualización: Usando displaCy

    SPACY viene con un built-in visualizador llamada displaCy . Se puede utilizar para visualizar una dependencia de análisis o entidades nombradas en un navegador o un cuaderno Jupyter.

    Puede utilizar displaCy para encontrar etiquetas de punto de venta para los tokens:

    >>> from spacy import displacy
    >>> about_interest_text = ('He is interested in learning'
    ... ' Natural Language Processing.')
    >>> about_interest_doc = nlp(about_interest_text)
    >>> displacy.serve(about_interest_doc, style='dep')

    El código anterior hará girar un simple servidor web. Se puede ver la visualización mediante la apertura de http://127.0.0.1:5000 en su navegador:

    En la imagen de arriba, cada símbolo se le asigna una etiqueta escrita POS justo debajo de la ficha.

    Nota: Así es como se puede utilizar displaCy en un cuaderno Jupyter: Funciones

    >>> displacy.render(about_interest_doc, style='dep', jupyter=True)

    preprocesamiento

    Puede crear una función preprocesamiento que toma el texto como entrada y aplica las siguientes operaciones:

    • minúsculas del texto
    • Lemmatizes cada ficha
    • Elimina los símbolos de puntuación palabras vacías
    • Elimina

    un convertidos función pre-procesamiento de texto a un formato analizable. Es necesario para la mayoría de las tareas de PNL. He aquí un ejemplo:

    >>> def is_token_allowed(token):
    ... '''
    ... Only allow valid tokens which are not stop words
    ... and punctuation symbols.
    ... '''
    ... if (not token or not token.string.strip() or
    ... token.is_stop or token.is_punct):
    ... return False
    ... return True
    ...
    >>> def preprocess_token(token):
    ... # Reduce token to its lowercase lemma form
    ... return token.lemma_.strip().lower()
    ...
    >>> complete_filtered_tokens = [preprocess_token(token)
    ... for token in complete_doc if is_token_allowed(token)]
    >>> complete_filtered_tokens
    ['gus', 'proto', 'python', 'developer', 'currently', 'work',
    'london', 'base', 'fintech', 'company', 'interested', 'learn',
    'natural', 'language', 'processing', 'developer', 'conference',
    'happen', '21', 'july', '2019', 'london', 'title',
    'applications', 'natural', 'language', 'processing', 'helpline',
    'number', 'available', '+1', '1234567891', 'gus', 'help',
    'organize', 'keep', 'organize', 'local', 'python', 'meetup',
    'internal', 'talk', 'workplace', 'gus', 'present', 'talk', 'talk',
    'introduce', 'reader', 'use', 'case', 'natural', 'language',
    'processing', 'fintech', 'apart', 'work', 'passionate', 'music',
    'gus', 'learn', 'play', 'piano', 'enrol', 'weekend', 'batch',
    'great', 'piano', 'academy', 'great', 'piano', 'academy',
    'situate', 'mayfair', 'city', 'london', 'world', 'class',
    'piano', 'instructor']

    Tenga en cuenta que los complete_filtered_tokens no contiene ninguna palabra de parada o signos de puntuación y consta de fichas minúsculas lematizadas. Matching

    basada en reglas Uso de concordancia basada en la Regla SPACY

    es uno de los pasos de extracción de información de texto no estructurado. Se utiliza para identificar y extracto de tokens y frases de acuerdo con los patrones (como en minúsculas) y funciones gramaticales (como parte de la oración). juego basado en reglas

    puede utilizar expresiones regulares para extraer entidades (tales como números de teléfono) de un texto no estructurado. Es diferente de la extracción de texto usando expresiones regulares sólo en el sentido de que las expresiones regulares no tienen en cuenta los atributos léxicos y gramaticales del texto. juego basado en reglas

    Con, puede extraer un nombre y un apellido, que son siempre nombres propios :

    >>> from spacy.matcher import Matcher
    >>> matcher = Matcher(nlp.vocab)
    >>> def extract_full_name(nlp_doc):
    ... pattern = [{'POS': 'PROPN'}, {'POS': 'PROPN'}]
    ... matcher.add('FULL_NAME', None, pattern)
    ... matches = matcher(nlp_doc)
    ... for match_id, start, end in matches:
    ... span = nlp_doc[start:end]
    ... return span.text
    ...
    >>> extract_full_name(about_doc)
    'Gus Proto'

    En este ejemplo, el patrón es una lista de objetos que define la combinación de fichas para ser igualada. Ambas etiquetas de punto de venta en que son PROPN (nombre propio). Así, el patrón se compone de dos objetos en los que las etiquetas de punto de venta para ambas fichas deben ser PROPN. A continuación se añade este patrón para Matcher usando FULL_NAME y el la match_id. Por último, los partidos se obtienen con sus índices de inicio y fin.

    También puede utilizar la concordancia basada en reglas a los números de teléfono de extracto:

    >>> from spacy.matcher import Matcher
    >>> matcher = Matcher(nlp.vocab)
    >>> conference_org_text = ('There is a developer conference'
    ... 'happening on 21 July 2019 in London. It is titled'
    ... ' "Applications of Natural Language Processing".'
    ... ' There is a helpline number available'
    ... ' at (123) 456-789')
    ...
    >>> def extract_phone_number(nlp_doc):
    ... pattern = [{'ORTH': '('}, {'SHAPE': 'ddd'},
    ... {'ORTH': ')'}, {'SHAPE': 'ddd'},
    ... {'ORTH': '-', 'OP': '?'},
    ... {'SHAPE': 'ddd'}]
    ... matcher.add('PHONE_NUMBER', None, pattern)
    ... matches = matcher(nlp_doc)
    ... for match_id, start, end in matches:
    ... span = nlp_doc[start:end]
    ... return span.text
    ...
    >>> conference_org_doc = nlp(conference_org_text)
    >>> extract_phone_number(conference_org_doc)
    '(123) 456-789'

    En este ejemplo, sólo el patrón se actualiza con el fin de igualar los números de teléfono del ejemplo anterior. Aquí, también se utilizan algunos de los atributos de la ficha:

    • ORTE da el texto exacto de la ficha.
    • FORMA transforma la cadena de contadores a mostrar características ortográficas.
    • OP define operadores. Utilizando ? como un medio de valor que el patrón es opcional, lo que significa que puede coincidir con 0 o 1 veces.

    Nota: Por simplicidad, los números de teléfono se supone que son de un formato en particular: (123) 456-789. Puede cambiar esto dependiendo de su caso de uso. juego basado en reglas

    ayuda a identificar y fichas y frases extracto según patrones léxicos (como en minúsculas) y las características gramaticales (como parte de la oración).

    Dependencia de análisis de uso de SPACY

    Dependencia de análisis es el proceso de extracción de la dependencia de análisis sintáctico de una oración para representar su estructura gramatical. Se define la relación de dependencia entre palabras claves y su los dependientes . El jefe de una sentencia no tiene ninguna dependencia y se llama la raíz de la sentencia . El verbo suele ser la cabeza de la frase. Todas las demás palabras están vinculados a la palabra principal.

    Las dependencias se pueden asignar en una representación en gráfico dirigido: Palabras

    • son los nodos.
    • Las relaciones gramaticales son los bordes.

    Dependencia de análisis ayuda a saber qué papel juega una palabra en el texto y lo diferente que las palabras se relacionan entre sí. También se usa en análisis sintáctico superficial y nombrada entidad reconocimiento.

    Así es como se puede utilizar análisis de dependencias para ver las relaciones entre las palabras:

    >>> piano_text = 'Gus is learning piano'
    >>> piano_doc = nlp(piano_text)
    >>> for token in piano_doc:
    ... print (token.text, token.tag_, token.head.text, token.dep_)
    ...
    Gus NNP learning nsubj
    is VBZ learning aux
    learning VBG learning ROOT
    piano NN learning dobj

    En este ejemplo, la frase contiene tres tipos de relaciones:

    Hay una lista detallada de las relaciones con las descripciones. Puede utilizar displaCy para visualizar el árbol de dependencias: Código

    >>> displacy.serve(piano_doc, style='dep')

    Esto producirá una visualización que se puede acceder mediante la apertura de http://127.0.0.1:5000 en su navegador:

    Esta imagen muestra que que el tema de la frase es el nombre propio Gus y que tiene una relación con aprender piano.

    Navegación por el árbol y el subárbol

    El árbol de dependencias de análisis tiene todas las propiedades de un árbol. Este árbol contiene información acerca de la estructura de oraciones y la gramática, y se puede recorrer en diferentes maneras de extraer las relaciones.

    SPACY proporciona atributos como los niños, izquierdas, derechos y sub-árbol para navegar por el árbol de análisis sintáctico:

    >>> one_line_about_text = ('Gus Proto is a Python developer'
    ... ' currently working for a London-based Fintech company')
    >>> one_line_about_doc = nlp(one_line_about_text)
    >>> # Extract children of `developer`
    >>> print([token.text for token in one_line_about_doc[5].children])
    ['a', 'Python', 'working']
    >>> # Extract previous neighboring node of `developer`
    >>> print (one_line_about_doc[5].nbor(-1))
    Python
    >>> # Extract next neighboring node of `developer`
    >>> print (one_line_about_doc[5].nbor())
    currently
    >>> # Extract all tokens on the left of `developer`
    >>> print([token.text for token in one_line_about_doc[5].lefts])
    ['a', 'Python']
    >>> # Extract tokens on the right of `developer`
    >>> print([token.text for token in one_line_about_doc[5].rights])
    ['working']
    >>> # Print subtree of `developer`
    >>> print (list(one_line_about_doc[5].subtree))
    [a, Python, developer, currently, working, for, a, London, -,
    based, Fintech, company]

    Es posible construir una función que toma un subárbol como argumento y devuelve una cadena mediante la fusión de las palabras en él:

    >>> def flatten_tree(tree):
    ... return ''.join([token.text_with_ws for token in list(tree)]).strip()
    ...
    >>> # Print flattened subtree of `developer`
    >>> print (flatten_tree(one_line_about_doc[5].subtree))
    a Python developer currently working for a London-based Fintech company

    Puede utilizar esta función para imprimir todas las fichas en un subárbol.

    superficial de análisis

    superficial análisis o fragmentación , es el proceso de extracción de frases de texto no estructurado. Fragmentar grupos fichas adyacentes en frases sobre la base de sus etiquetas POS. Hay algunos trozos convencionales bien conocidas frases tales como sustantivo, verbo frases y frases preposicionales.

    Noun Frase Detección

    Un sustantivo frase es una frase que tiene un sustantivo como su cabeza. También podría incluir otras clases de palabras, tales como adjetivos, determinantes, ordinales. frases nominales son útiles para explicar el contexto de la frase. Ellos le ayudan a inferir lo se está hablando en la frase.

    SPACY tiene las noun_chunks de propiedad en el objeto Doc. Se puede utilizar para extraer frases nominales:

    >>> conference_text = ('There is a developer conference'
    ... ' happening on 21 July 2019 in London.')
    >>> conference_doc = nlp(conference_text)
    >>> # Extract Noun Phrases
    >>> for chunk in conference_doc.noun_chunks:
    ... print (chunk)
    ...
    a developer conference
    21 July
    London

    Al observar las frases nominales, se puede obtener información acerca de su texto. Por ejemplo, una conferencia de desarrolladores indica que el texto menciona una conferencia, mientras que la Fecha 21 de julio de le permite saber que la conferencia está programada para el 21 de julio. Puede averiguar si la conferencia está en el pasado o en el futuro. Londres le dice que la conferencia está en Londres.

    frase verbal Detección

    A verbo frase es una unidad sintáctica compuesto de al menos un verbo. Este verbo puede ser seguido por otros trozos, como frases nominales. Verbo frases son útiles para la comprensión de las acciones que los sustantivos están involucrados en

    SPACY no se ha incorporado en la funcionalidad de extracto de verbo frases, por lo que tendrá una biblioteca llamada textacy:.

    Nota:

    Usted puede utilizar PIP instalar textacy:

    $ pip install textacy

    Ahora que ha instalado textacy, que se puede utilizar para extraer verbo frases sobre la base de reglas gramaticales:

    >>> import textacy
    >>> about_talk_text = ('The talk will introduce reader about Use'
    ... ' cases of Natural Language Processing in'
    ... ' Fintech')
    >>> pattern = r'(?*+)'
    >>> about_talk_doc = textacy.make_spacy_doc(about_talk_text,
    ... lang='en_core_web_sm')
    >>> verb_phrases = textacy.extract.pos_regex_matches(about_talk_doc, pattern)
    >>> # Print all Verb Phrase
    >>> for chunk in verb_phrases:
    ... print(chunk.text)
    ...
    will introduce
    >>> # Extract Noun Phrase to explain what nouns are involved
    >>> for chunk in about_talk_doc.noun_chunks:
    ... print (chunk)
    ...
    The talk
    reader
    Use cases
    Natural Language Processing
    Fintech

    en este ejemplo, la frase verbal introducir indica que algo va a ser introducido. Al observar las frases nominales, se puede ver que hay una charla que va a introducir al lector en los casos de uso del procesamiento del lenguaje natural o Fintech.

    El código anterior extrae todas las frases verbales utilizando un patrón de expresión regular de etiquetas POS. Se pueden ajustar el patrón de frases verbales, dependiendo de su caso de uso.

    Nota: En el ejemplo anterior, podría también haber hecho la dependencia de análisis para ver cuáles eran las relaciones entre las palabras.

    Nombrado Entidad Reconocimiento

    Nombrado Entidad Reconocimiento (NER) es el proceso de localización de entidades nombrados en texto estructurado y luego clasificándolos en categorías predefinidas, tales como nombres de personas, organizaciones, lugares, valores monetarios, porcentajes , expresiones de tiempo, y así sucesivamente.

    Puede utilizar NER saber más sobre el significado de su texto. Por ejemplo, se podría utilizar para rellenar las etiquetas de un conjunto de documentos con el fin de mejorar la búsqueda por palabra clave. También se podría utilizar para clasificar los tickets de soporte al cliente en categorías relevantes.

    SPACY tiene las entos de propiedad sobre los objetos Doc. Se puede utilizar para extraer entidades nombradas:

    >>> piano_class_text = ('Great Piano Academy is situated'
    ... ' in Mayfair or the City of London and has'
    ... ' world-class piano instructors.')
    >>> piano_class_doc = nlp(piano_class_text)
    >>> for ent in piano_class_doc.ents:
    ... print(ent.text, ent.start_char, ent.end_char,
    ... ent.label_, spacy.explain(ent.label_))
    ...
    Great Piano Academy 0 19 ORG Companies, agencies, institutions, etc.
    Mayfair 35 42 GPE Countries, cities, states
    the City of London 46 64 GPE Countries, cities, states

    En el ejemplo anterior, ent es un objeto Span con varios atributos: Texto

    • da la representación de texto Unicode de la entidad.
    • start_char denota el carácter de compensación para el inicio de la entidad.
    • end_char denota el carácter de compensación para el final de la entidad.
    • LABEL_ da la etiqueta de la entidad.

    da spacy.explain detalles descriptivos de una etiqueta de entidad. El modelo SPACY tiene una lista de pre-formados de las clases de entidad. Puede utilizar displaCy para visualizar estas entidades:

    >>> displacy.serve(piano_class_doc, style='ent')

    Si abre http://127.0.0.1:5000 en su navegador, a continuación se puede ver la visualización:

    puede utilizar NER nombres de las personas a redactar a partir de un texto. Por ejemplo, es posible que desee hacer esto con el fin de ocultar la información personal recopilada en una encuesta. Puede utilizar SPACY de hacer eso:

    >>> survey_text = ('Out of 5 people surveyed, James Robert,'
    ... ' Julie Fuller and Benjamin Brooks like'
    ... ' apples. Kelly Cox and Matthew Evans'
    ... ' like oranges.')
    ...
    >>> def replace_person_names(token):
    ... if token.ent_iob != 0 and token.ent_type_ == 'PERSON':
    ... return '[REDACTED] '
    ... return token.string
    ...
    >>> def redact_names(nlp_doc):
    ... for ent in nlp_doc.ents:
    ... ent.merge()
    ... tokens = map(replace_person_names, nlp_doc)
    ... return ''.join(tokens)
    ...
    >>> survey_doc = nlp(survey_text)
    >>> redact_names(survey_doc)
    'Out of 5 people surveyed, [REDACTED] , [REDACTED] and'
    ' [REDACTED] like apples. [REDACTED] and [REDACTED]'
    ' like oranges.'

    En este ejemplo, replace_person_names () utiliza ent_iob. Se da el código IOB de la etiqueta de entidad con nombre mediante el etiquetado dentro-fuera-de comenzar (IOB). En este caso, puede tener un valor distinto de cero, debido a cero significa que no hay etiqueta de entidad está establecida.

    Conclusión

    SPACY es una biblioteca potente y avanzado que está ganando gran popularidad para aplicaciones de PNL debido a su velocidad, facilidad de uso, precisión y extensibilidad. ¡Felicidades! Ahora ya sabe:

    • Lo que los términos y conceptos fundamentales de la PNL son
    • Cómo poner en práctica esos conceptos en SPACY
    • Cómo personalizar y ampliar incorporado funcionalidades en SPACY
    • cómo llevar a cabo el análisis estadístico básico en un texto
    • Cómo crear un gasoducto para procesar texto no estructurado
    • Cómo analizar una frase y extraer conocimiento con sentido de ella

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *