En esta publicación, explico "el truco" detrás de NBC y les daré un ejemplo que podemos usar para resolver un problema de clasificación.

En las próximas secciones, hablaré sobre las matemáticas detrás de NBC. Siéntete libre de omitir esas secciones y pasar a la parte de implementación si no estás interesado en las matemáticas.

En la sección de implementación, te mostraré un algoritmo NBC simple. Luego lo usaremos para resolver un problema de clasificación. La tarea será determinar si cierto pasajero del Titanic sobrevivió al accidente o no.

Probabilidad condicional

Antes de hablar sobre el algoritmo en sí, hablemos de las matemáticas detrás de él. Necesitamos entender qué es la probabilidad condicional y cómo podemos usar el teorema de Bayes para calcularla.

Piense en un dado equilibrado con seis lados. ¿Cuál es la probabilidad de obtener un seis al lanzar el dado? Eso es fácil, es 1/6. Tenemos seis resultados posibles e igualmente probables, pero solo nos interesa uno de ellos. Entonces, 1/6 lo es.

Pero, ¿qué pasa si te digo que ya lancé el dado y el resultado es un número par? ¿Cuál es la probabilidad de que tengamos un seis ahora?

Esta vez, los posibles resultados son solo tres porque solo hay tres números pares en el dado. Todavía estamos interesados en solo uno de esos resultados, por lo que ahora la probabilidad es mayor: 1/3. ¿Cuál es la diferencia entre ambos casos?

En el primer caso, no teníamos información previa sobre el resultado. Por lo tanto, necesitábamos considerar todos los resultados posibles.

En el segundo caso, se nos dijo que el resultado era un número par, por lo que podíamos reducir el espacio de posibles resultados a solo los tres números pares que aparecen en un dado normal de seis caras.

En general, al calcular la probabilidad de un evento A, dada la ocurrencia de otro evento B, decimos que estamos calculando la probabilidad condicional de A dado B, o simplemente la probabilidad de A dado B. Lo denotamos P(A|B).

Por ejemplo, la probabilidad de obtener un seis dado que el número que tenemos es par: P(Seis|Par) = 1/3. Aquí, denotamos con Seis el evento de obtener un seis y con Par el evento de obtener un número par.

Pero, ¿cómo calculamos las probabilidades condicionales? ¿Existe una fórmula?

Cómo calcular probabilidades condicionales y el teorema de Bayes

Ahora, te daré un par de fórmulas para calcular probabilidades condicionales. Prometo que no serán difíciles y son importantes si deseas comprender la ideas detrás de los algoritmos de aprendizaje automático de los que hablaremos más adelante.

La probabilidad de un evento A dada la ocurrencia de otro evento B se puede calcular de la siguiente manera:

P(A|B) = P(A,B)/P(B)

Donde P(A,B) denota la probabilidad de A y B ocurriendo al mismo tiempo, y P(B) denota la probabilidad de B.

Observa que necesitamos P(B) > 0 porque no tiene sentido hablar de la probabilidad de A dado B si la ocurrencia de B no es posible.

También podemos calcular la probabilidad de un evento A, dada la ocurrencia de múltiples eventos B1, B2, ..., Bn:

P(A|B1,B2,...,Bn) = P(A,B1,B2,...,Bn)/P(B1,B2,...,Bn)

Hay otra forma de calcular probabilidades condicionales. Esta forma es el llamado Teorema de Bayes.

P(A|B) = P(B|A)P(A)/P(B)

P(A|B1,B2,...,Bn) = P(B1,B2,...,Bn|A)P(A)/P(B1,B2,...,Bn)

Observa que estamos calculando la probabilidad del evento A dado el evento B, invirtiendo el orden de ocurrencia de los eventos.

Ahora suponemos que ha ocurrido el evento A y queremos calcular la probabilidad del evento B (o eventos B1, B2, ..., Bn en el segundo y más general ejemplo).

Un dato importante que se puede derivar de este Teorema es la fórmula para calcular P(B1,B2,...,Bn,A). Eso se llama la regla de la cadena para las probabilidades.

P(B1,B2,...,Bn,A) = P(B1 | B2, B3, ..., Bn, A)P(B2,B3,...,Bn,A)
= P(B1 | B2, B3, ..., Bn, A)P(B2 | B3, B4, ..., Bn, A)P(B3, B4, ..., Bn, A)
= P(B1 | B2, B3, ..., Bn, A)P(B2 | B3, B4, ..., Bn, A)...P(Bn | A)P(A)

Esa es una fórmula fea, ¿no? Pero bajo algunas condiciones podemos hacer una solución y evitarlo.

Hablemos del último concepto que necesitamos saber para entender los algoritmos.

Independencia

El último concepto del que vamos a hablar es el de independencia. Decimos que los eventos A y B son independientes si

P(A|B) = P(A)

Eso significa que la probabilidad del evento A no se ve afectada por la ocurrencia del evento B. Una consecuencia directa es que P(A,B) = P(A)P(B).

En términos sencillos, esto significa que la probabilidad de la ocurrencia de A y B al mismo tiempo es igual al producto de las probabilidades de los eventos A y B que ocurren por separado.

Si A y B son independientes, también se sostiene que:

P(A,B|C) = P(A|C)P(B|C)

¡Ahora estamos listos para hablar sobre los clasificadores Naive Bayes!

Clasificadores Naive Bayes

Supongamos que tenemos un vector X de n características (features) y queremos determinar la clase de ese vector a partir de un conjunto de k clases y1, y2, ..., yk. Por ejemplo, si queremos determinar si lloverá hoy o no.

Tenemos dos clases posibles (k = 2): lluvia, no lluvia, y la longitud del vector de características podría ser 3 (n = 3).

La primera característica podría ser si está nublado o soleado, la segunda característica podría ser si la humedad es alta o baja, y la tercera característica sería si la temperatura es alta, media o baja.

Entonces, estos podrían ser posibles vectores de características.

<Nublado, H_Alta, T_Baja>
<Soleado, H_Baja, T_Media>
<Nublado, H_Baja, T_Alta>

Nuestra tarea es determinar si lloverá o no, dadas las características meteorológicas.

Después de conocer las probabilidades condicionales, parece natural abordar el problema tratando de calcular la probabilidad de que llueva dadas las características:

R = P(Llueve | Nublado, H_Alta, T_Baja)
NR = P(NoLlueve | Nublado, H_Alta, T_Baja)

Si R > NR respondemos que va a llover, de lo contrario decimos que no.

En general, si tenemos k clases y1, y2, ..., yk, y un vector de n características X = <X1, X2, ..., Xn>, queremos encontrar la clase yi que maximiza

P(yi | X1, X2, ..., Xn) = P(X1, X2,..., Xn, yi)/P(X1, X2, ..., Xn)

Observa que el denominador es constante y no depende de la clase yi. Entonces, podemos ignorarlo y enfocarnos en el numerador.

En una sección anterior, vimos cómo calcular P(X1, X2,..., Xn, yi) descomponiéndolo en un producto de probabilidades condicionales (la fórmula fea):

P(X1, X2,..., Xn, yi) = P(X1 | X2,..., Xn, yi)P(X2 | X3,..., Xn, yi)...P(Xn | yi)P(yi)

Suponiendo que todas las características Xi son independientes y usando el teorema de Bayes, podemos calcular la probabilidad condicional de la siguiente manera:

P(yi | X1, X2,..., Xn) = P(X1, X2,..., Xn | yi)P(yi)/P(X1, X2, ..., Xn)
= P(X1 | yi)P(X2 | yi)...P(Xn | yi)P(yi)/P(X1, X2, ..., Xn)

Y solo tenemos que centrarnos en el numerador.

Al encontrar la clase yi que maximiza la expresión anterior, estamos clasificando el vector de entrada. Pero, ¿cómo podemos obtener todas esas probabilidades?

Cómo calcular las probabilidades

Al resolver este tipo de problemas necesitamos tener un conjunto de ejemplos previamente clasificados.

Por ejemplo, en el problema de adivinar si lloverá o no, necesitamos tener varios ejemplos de vectores de características y sus clasificaciones que se obtendrían de pronósticos meteorológicos anteriores.

Entonces, tendríamos algo como esto:

...
<Nublado, H_Alta, T_Baja> -> Llueve
<Soleado, H_Baja, T_Media> -> No Llueve
<Nublado, H_Baja, T_Alta> -> No Llueve
...

Supongamos que necesitamos clasificar un nuevo vector <Nublado, H_Baja, T_Alta>. Necesitamos calcular:

P(Llueve | Nublado, H_Baja, T_Baja) = P(Nublado | H_Baja, T_Baja, Llueve)P(H_Baja | T_Baja, Llueve)P(T_Baja | Llueve)P(Llueve)/P(Nublado, H_Baja, T_Baja)

Obtenemos la expresión anterior aplicando la definición de probabilidad condicional y la regla de la cadena. Recuerda que solo necesitamos enfocarnos en el numerador por lo que podamos eliminar el denominador.

También necesitamos calcular la probabilidad para NoLlueve, pero podemos hacerlo de una forma similar.

Podemos encontrar P(Llueve) = # Llueve/Total. Eso significa contar las entradas en el conjunto de datos que se clasifican con Llueve y dividir ese número por el tamaño del conjunto de datos.

Para calcular P(Nublado | H_Baja, T_Baja, Llueve) necesitamos contar todas las entradas que tienen las características H_Baja, T_Baja y Nublado. Esas entradas también deben clasificarse como Llueve. Luego, ese número se divide por la cantidad total de datos. Calculamos el resto de factores de la fórmula de forma similar.

Hacer esos cálculos para todas las clases posibles es muy costoso y lento. Por tanto, necesitamos hacer suposiciones sobre el problema que simplifiquen los cálculos.

Los clasificadores Naive Bayes asumen que todas las características son independientes entre sí. Entonces podemos reescribir nuestra fórmula aplicando el teorema de Bayes y asumiendo la independencia entre cada par de características:

P(Llueve | Nublado, H_Baja, T_Baja) = P(Nublado | Llueve)P(H_Baja | Llueve)P(T_Baja | Llueve)P(Llueve)/P(Nublado, H_Baja, T_Baja)

Ahora calculamos P(Nublado | Llueve) contando el número de entradas que están clasificadas como Llueve y estaban Nublado.

El algoritmo se llama Naive (que significa ingenuo en inglés) debido a esta suposición de independencia. Hay dependencias entre las características (features) la mayor parte del tiempo. No podemos decir que en la vida real no existe una dependencia entre la humedad y la temperatura, por ejemplo. Los clasificadores Naive Bayes también se denominan Bayes Indepentientes o Bayes Simples.

La fórmula general sería:

P(yi | X1, X2, ..., Xn) = P(X1 | yi)P(X2 | yi)...P(Xn | yi)P(yi)/P(X1, X2, ..., Xn)

Recuerda que puedes deshacerte del denominador. Solo calculamos el numerador y respondemos la clase que lo maximiza.

Ahora, implementemos nuestro NBC y usémoslo en un problema.

¡Programemos!

Les mostraré una implementación de un NBC simple y luego lo veremos en la práctica.

El problema que vamos a resolver es determinar si un pasajero del Titanic sobrevivió o no, dadas algunas características como su género y su edad.

Aquí puedes ver la implementación de un NBC muy simple:

class NaiveBayesClassifier:
    
    def __init__(self, X, y):
        
        '''
        X e y denotan las características y las etiquetas de destino respectivamente
        '''
        self.X, self.y = X, y 
        
        self.N = len(self.X) # Tamaño del conjunto de entrenamiento

        self.dim = len(self.X[0]) # Dimensión del vector de características

        self.attrs = [[] for _ in range(self.dim)] # Aquí almacenaremos las columnas del conjunto de entrenamiento.

        self.output_dom = {} # Clases de salida con el número de ocurrencias en el conjunto de entrenamiento. En este caso solo tenemos 2 clases

        self.data = [] # To store every row [Xi, yi]
        
        
        for i in range(len(self.X)):
            for j in range(self.dim):
                # si nunca hemos visto este valor para este atributo antes, 
                # luego lo agregamos a la matriz attrs en la posición correspondiente
                if not self.X[i][j] in self.attrs[j]:
                    self.attrs[j].append(self.X[i][j])
                    
            # si nunca hemos visto esta clase de salida antes,
            # luego lo agregamos a output_dom y contamos una ocurrencia por ahora
            if not self.y[i] in self.output_dom.keys():
                self.output_dom[self.y[i]] = 1
            # de lo contrario, incrementamos la ocurrencia de esta salida en el conjunto de entrenamiento en 1
            else:
                self.output_dom[self.y[i]] += 1
            # almacenar la fila
            self.data.append([self.X[i], self.y[i]])
            
            

    def classify(self, entry):

        solve = None # Resultado final
        max_arg = -1 # máximo parcial

        for y in self.output_dom.keys():

            prob = self.output_dom[y]/self.N # P(y)

            for i in range(self.dim):
                cases = [x for x in self.data if x[0][i] == entry[i] and x[1] == y] # all rows with Xi = xi
                n = len(cases)
                prob *= n/self.N # P *= P(Xi = xi)
                
            # si tenemos una probabilidad mayor para esta salida que el máximo parcial ...
            if prob > max_arg:
                max_arg = prob
                solve = y

        return solve

Aquí, asumimos que cada característica tiene un dominio discreto. Eso significa que toman un valor de un conjunto finito de valores posibles.

Lo mismo ocurre con las clases. Ten en cuenta que almacenamos algunos datos en el método __init__ por lo que no es necesario repetir algunas operaciones. La clasificación de una nueva entrada se lleva a cabo en el método classify.

Este es un ejemplo simple de implementación. En las aplicaciones del mundo real, no necesitas (y es mejor si no creas) tu propia implementación. Por ejemplo, la biblioteca sklearn en Python contiene varias buenas implementaciones de NBC.

¡Observa lo fácil que es implementarlo!

Ahora, apliquemos nuestro nuevo clasificador para resolver un problema. Tenemos un conjunto de datos con la descripción de 887 pasajeros en el Titanic. También podemos ver si un pasajero determinado sobrevivió a la tragedia o no.

Entonces, nuestra tarea es determinar si otro pasajero que no está incluido en el conjunto de entrenamiento lo hizo o no.

En este ejemplo, usaré la biblioteca de pandas para leer y procesar los datos. No utilizo ninguna otra herramienta.

Los datos se almacenan en un archivo llamado titanic.csv, por lo que el primer paso es leer los datos y obtener una descripción general.

import pandas as pd

data = pd.read_csv('titanic.csv')

print(data.head())

La salida es:

Survived  Pclass                                               Name  \
0         0       3                             Mr. Owen Harris Braund   
1         1       1  Mrs. John Bradley (Florence Briggs Thayer) Cum...   
2         1       3                              Miss. Laina Heikkinen   
3         1       1        Mrs. Jacques Heath (Lily May Peel) Futrelle   
4         0       3                            Mr. William Henry Allen   

      Sex   Age  Siblings/Spouses Aboard  Parents/Children Aboard     Fare  
0    male  22.0                        1                        0   7.2500  
1  female  38.0                        1                        0  71.2833  
2  female  26.0                        0                        0   7.9250  
3  female  35.0                        1                        0  53.1000  
4    male  35.0                        0                        0   8.0500  

Observa que tenemos el nombre de cada pasajero. No usaremos esa característica para nuestro clasificador porque no es significativa para nuestro problema. También eliminaremos la característica Fare (tarifa en inglés) porque es continua y nuestras funciones deben ser discretas.

Hay clasificadores Naive Bayes que admiten caracterísitcas (features) continuas. Por ejemplo, el clasificador Naive Bayes Gausseano.

y = list(map(lambda v: 'yes' if v == 1 else 'no', data['Survived'].values)) # valores objetivo como cadena

# No usaremos el campo 'Nombre'(Name) ni 'Tarifa' (Fare)

X = data[['Pclass', 'Sex', 'Age', 'Siblings/Spouses Aboard', 'Parents/Children Aboard']].values # valores de características

Luego, necesitamos separar nuestro conjunto de datos en un conjunto de entrenamiento y un conjunto de validación. El último se utiliza para validar qué tan bien está funcionando nuestro algoritmo.

print(len(y)) # >> 887

# Tomaremos 600 ejemplos para entrenar y el resto para el proceso de validación.
y_train = y[:600]
y_val = y[600:]

X_train = X[:600]
X_val = X[600:]

Creamos nuestro NBC con el conjunto de entrenamiento y luego clasificamos cada entrada en el conjunto de validación.

Medimos la precisión de nuestro algoritmo dividiendo el número de entradas que clasificó correctamente por el número total de entradas en el conjunto de validación.

## Crear la instancia de Naive Bayes Classifier con los datos de entrenamiento

nbc = NaiveBayesClassifier(X_train, y_train)


total_cases = len(y_val) # tamaño del conjunto de validación

# Ejemplos bien clasificados y ejemplos mal clasificados
good = 0
bad = 0

for i in range(total_cases):
    predict = nbc.classify(X_val[i])
#     print(y_val[i] + ' --------------- ' + predict)
    if y_val[i] == predict:
        good += 1
    else:
        bad += 1

print('TOTAL EXAMPLES:', total_cases)
print('RIGHT:', good)
print('WRONG:', bad)
print('ACCURACY:', good/total_cases)

La salida:

TOTAL EXAMPLES: 287
RIGHT: 200
WRONG: 87
ACCURACY: 0.6968641114982579

No es genial pero es algo. Podemos obtener una mejora de aproximadamente un 10% en la precisión si eliminamos otras funciones como hermanos / cónyuges a bordo y padres / hijos a bordo.

Puedes ver un cuaderno con el código y el conjunto de datos aquí.

Conclusiones

Hoy en día, tenemos redes neuronales y otros algoritmos de ML complejos y costosos por todas partes.

Los NBC son algoritmos muy sencillos que nos permiten conseguir buenos resultados en algunos problemas de clasificación sin necesidad de muchos recursos. También escalan muy bien, lo que significa que podemos agregar muchas más funciones y el algoritmo seguirá siendo rápido y confiable.

Incluso en el caso de que los NBC no fueran adecuados para el problema que estábamos tratando de resolver, podrían ser muy útiles como referencia.

Primero podríamos intentar resolver el problema usando un NBC con unas pocas líneas de código y poco esfuerzo. Luego podríamos intentar lograr mejores resultados con algoritmos más complejos y costosos.

Este proceso puede ahorrarnos mucho tiempo y nos da una retroalimentación inmediata sobre si los algoritmos complejos realmente valen la pena para nuestra tarea.

En este artículo, leíste sobre las probabilidades condicionales, la independencia y el teorema de Bayes. Esos son los conceptos matemáticos detrás de los clasificadores Naive Bayes.

Después de eso, vimos una implementación simple de un NBC y resolvimos el problema de determinar si un pasajero del Titanic sobrevivió al accidente.

Espero que este artículo te haya resultado útil. Puedes leer sobre temas relacionados con la informática en mi blog personal y siguiéndome en Twitter.

Traducido del artículo de Jose J. Rodríguez - How Naive Bayes Classifiers Work – with Python Code Examples

PNL maneja cosas como respuestas de texto, descifrar el significado de las palabras dentro de un contexto y mantener conversaciones con nosotros. Ayuda a las computadoras a comprender el lenguaje humano para que podamos comunicarnos de diferentes maneras.

Desde los bots de chat hasta las solicitudes de empleo y la clasificación de tu correo electrónico en diferentes carpetas, PNL se utiliza en todas partes a nuestro alrededor.

En esencia, el procesamiento del lenguaje natural es una combinación de informática y lingüística. La lingüística nos brinda las reglas que debemos usar para entrenar nuestros modelos de aprendizaje automático y obtener los resultados que buscamos.

Hay muchas razones por las que el procesamiento del lenguaje natural se ha convertido en una parte importante del aprendizaje automático. Ayuda a las máquinas a detectar el sentimiento de los comentarios de un cliente, puede ayudar a clasificar los tickets de soporte para cualquier proyecto en el que estés trabajando y puede leer y comprender el texto de manera coherente.

Y dado que opera con un conjunto de reglas lingüísticas, no tiene los mismos prejuicios que los humanos.

Dado que PNL es un área de estudio tan grande, hay una serie de herramientas que puedes utilizar para analizar datos para tus propósitos específicos.

Existe el enfoque basado en reglas en el que se configuran muchas declaraciones si-entonces (if-then) para manejar cómo se interpreta el texto. Por lo general, un lingüista será responsable de esta tarea y lo que producen es muy fácil de entender para la gente.

Esto puede ser bueno para empezar, pero se vuelve muy complejo a medida que comienzas a trabajar con grandes conjuntos de datos.

Otro enfoque es utilizar aprendizaje automático donde no es necesario definir reglas. Esto es excelente cuando intentas analizar grandes cantidades de datos de forma rápida y precisa.

Elegir el algoritmo correcto para que el enfoque de aprendizaje automático funcione es importante en términos de eficiencia y precisión. Existen algoritmos comunes como Naïve Bayes y Support Vector Machines. Luego están los algoritmos más específicos como Google BERT

¿Qué es BERT?

BERT es una biblioteca de código abierto creada en 2018 en Google. Es una técnica nueva para PNL y adopta un enfoque de modelos de entrenamiento completamente diferente al de cualquier otra técnica.

BERT es un acrónimo de Representaciones de codificador bidireccional de Transformer. Eso significa que, a diferencia de la mayoría de las técnicas que analizan oraciones de izquierda a derecha o de derecha a izquierda, BERT va en ambas direcciones usando el codificador Transformer. Su objetivo es generar un modelo de lenguaje.

Esto le da una precisión y un rendimiento increíbles en conjuntos de datos más pequeños, lo que resuelve un gran problema en el procesamiento del lenguaje natural.

Si bien hay una gran cantidad de datos basados en texto disponibles, muy pocos de ellos se han etiquetado para usar en el entrenamiento de un modelo de aprendizaje automático. Dado que la mayoría de los enfoques para los problemas de PNL aprovechan el aprendizaje profundo (deep learning), necesita grandes cantidades de datos para entrenar.

Realmente se ven las grandes mejoras en un modelo cuando se ha entrenado con millones de datos. Para ayudar a solucionar este problema de no tener suficientes datos etiquetados, los investigadores encontraron formas de entrenar modelos de representación de lenguaje de propósito general a través del entrenamiento previo usando textos de Internet.

Estos modelos de representación previamente entrenados se pueden ajustar para que funcionen con conjuntos de datos específicos que son más pequeños que los que se usan comúnmente en el aprendizaje profundo. Estos conjuntos de datos más pequeños pueden ser para problemas como el análisis de opiniones o la detección de spam. Esta es la forma en que se abordan la mayoría de los problemas de PNL porque proporciona resultados más precisos que comenzar con un conjunto de datos más pequeño.

Es por eso que BERT es un gran descubrimiento. Proporciona una forma de pre-entrenar con mayor precisión tus modelos con menos datos. El enfoque bidireccional que utiliza significa que obtiene más contexto para una palabra que si solo estuviera entrenando en una dirección. Con este contexto adicional, puede aprovechar otra técnica llamada LM enmascarada.

En qué se diferencia de otros algoritmos de aprendizaje automático

El LM enmascarado enmascara al azar el 15% de las palabras en una oración con un símbolo o token [MASK] y luego trata de predecirlas basándose en las palabras que rodean a la palabra enmascarada. Así es como BERT puede ver las palabras de izquierda a derecha y de derecha a izquierda.

Esto es completamente diferente de cualquier otro modelo de lenguaje existente porque mira las palabras antes y después de una palabra enmascarada, al mismo tiempo. Gran parte de la precisión que tiene BERT se puede atribuir a esto.

Para que BERT funcione con tu conjunto de datos, debes agregar un poco de metadatos. Deberá haber incrustaciones de tokens (token embeddings) para marcar el principio y el final de las oraciones. Deberá tener incrustaciones de segmentos (segment embeddings) para poder distinguir diferentes oraciones. Por último, necesitará incrustaciones posicionales (positional embeddings) para indicar la posición de las palabras en una oración.

Se verá similar a esto.

[CLS] the [MASK] has blue spots [SEP] it rolls [MASK] the parking lot [SEP]

Con los metadatos agregados a tus puntos de datos (data points), LM enmascarado está listo para funcionar.

Una vez que ha terminado de predecir palabras, BERT aprovecha la predicción de la siguiente oración. Esto analiza la relación entre dos oraciones. Hace esto para comprender mejor el contexto de todo el conjunto de datos al tomar un par de oraciones y predecir si la segunda oración es la siguiente en función del texto original.

Para que la predicción de la siguiente oración funcione en la técnica BERT, la segunda oración se envía a través del modelo basado en Transformer.

Hay cuatro versiones diferentes de BERT previamente entrenadas según la escala de datos con la que estés trabajando. Puedes aprender más sobre ellos aquí: https://github.com/google-research/bert#bert

El inconveniente de este enfoque es que la función de pérdida solo considera las predicciones de palabras enmascaradas y no las predicciones de las demás. Eso significa que la técnica BERT converge más lentamente que las otras técnicas de derecha a izquierda o de izquierda a derecha.

BERT se puede aplicar a cualquier problema de PNL que se te ocurra, incluida la predicción de intenciones, las aplicaciones de respuesta a preguntas y la clasificación de texto.

Ejemplo de Código

Preparándote

Ahora veremos un ejemplo de BERT en acción. Lo primero que deberás hacer es clonar el repositorio de Bert.

git clone https://github.com/google-research/bert.git

Ahora necesita descargar los archivos de modelo BERT previamente entrenados desde la página BERT en GitHub. A lo largo del resto de este tutorial, me referiré al directorio de este repositorio como directorio raíz.

Estos archivos te brindan los hiperparámetros, pesos y otras cosas que necesitas con la información que Bert aprendió durante el entrenamiento previo. Usaré el modelo BERT-Base, Uncased, pero encontrarás varias otras opciones en diferentes idiomas en la página de GitHub.

Algunas de las razones por las que elegirías el modelo BERT-Base, Uncased es si no tienes acceso a una TPU de Google, en cuyo caso normalmente elegirías un modelo Base.

Si cree que el texto que estás tratando de analizar distingue entre mayúsculas y minúsculas (esa distinción le da un significado contextual real), entonces optarías por un modelo de tipo Cased.

Si la distinción entre mayúsculas y minúsculas no es importante o aún no está muy seguro, entonces un modelo de tipo Uncased sería una opción válida.

Trabajaremos con algunas reseñas de Yelp como nuestro conjunto de datos. Recuerda, BERT espera los datos en un formato determinado utilizando esas incrustaciones de tokens y otros. Necesitaremos agregarlos a un archivo .tsv. Este archivo será similar a un .csv, pero tendrá cuatro columnas y ninguna fila de encabezado.

Así es como se verán las cuatro columnas.

• Columna 0: ID de la fila
• Columna 1: Etiqueta de la fila (debe ser un número entero)
• Columna 2: Una columna de la misma letra para todas las filas (no se usa para nada, pero BERT lo espera)
• Columna 3: El texto que queremos clasificar

Deberás crear una carpeta llamada datos en el directorio donde clonaste BERT y agregar tres archivos allí: train.tsv, dev.tsv, test.tsv.

En los archivos train.tsv y dev.tsv, tendremos las cuatro columnas de las que hablamos anteriormente. En el archivo test.tsv, solo tendremos el ID de fila y el texto que queremos clasificar como columnas. Estos serán los archivos de datos que usaremos para entrenar y probar nuestro modelo.

Preparando los datos

Primero necesitamos obtener los datos con los que trabajaremos. Puedes descargar las reseñas de Yelp aquí: https://course.fast.ai/datasets#nlp Estará en la sección NLP y querrás la versión Polarity.

La razón por la que trabajaremos con esta versión es porque los datos ya tienen una polaridad, lo que significa que ya tienen un sentimiento asociado. Guarda este archivo en el directorio de datos.

Ahora estamos listos para comenzar a escribir código. Crea un nuevo archivo en el directorio raíz llamado pre_processing.py y agrega el siguiente código.

import pandas as pd
# esto es para extraer los datos de ese archivo .tgz
import tarfile
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split

# obtener todos los datos de ese .tgz
yelp_reviews = tarfile.open('data/yelp_review_polarity_csv.tgz')
yelp_reviews.extractall('data')
yelp_reviews.close()

# comprueba cómo se ven los datos antes de empezar
# mira el conjunto de datos de entrenamiento
train_df = pd.read_csv('data/yelp_review_polarity_csv/train.csv', header=None)
print(train_df.head())

# mira el conjunto de datos de prueba
test_df = pd.read_csv('data/yelp_review_polarity_csv/test.csv', header=None)
print(test_df.head())

En este código, hemos importado algunos paquetes de Python y descomprimimos los datos para ver cómo se ven. Notarás que los valores asociados con las reseñas son 1 y 2, siendo 1 una mala reseña y 2 una buena reseña. Necesitamos convertir estos valores a etiquetas más estándar, es decir 0 y 1. Puedes hacerlo con el siguiente código.

train_df[0] = (train_df[0] == 2).astype(int)
test_df[0] = (test_df[0] == 2).astype(int)

Siempre que realizes cambios a tus datos, es importante comprobar si todo salió bien. Entonces lo haremos con los siguientes comandos.

print(train_df.head())
print(test_df.head())

Cuando veas que tus valores de polaridad han cambiado para ser lo que esperabas. Ahora los datos deberían tener unos y ceros.

Dado que hemos limpiado los datos iniciales, es hora de preparar las cosas para BERT. Tendremos que hacer que nuestros datos se ajusten a los formatos de columna de los que hablamos anteriormente. Comencemos con los datos de entrenamiento.

Los datos de entrenamiento tendrán las cuatro columnas: ID de fila, etiqueta de fila, letra única, texto que queremos clasificar.

BERT espera dos archivos para entrenamiento llamados train y dev. Crearemos esos archivos dividiendo el archivo de entrenamiento inicial en dos archivos después de formatear nuestros datos con los siguientes comandos.

bert_df = pd.DataFrame({
    'id': range(len(train_df)),
    'label': train_df[0],
    'alpha': ['q']*train_df.shape[0],
    'text': train_df[1].replace(r'\n', ' ', regex=True)
})

train_bert_df, dev_bert_df = train_test_split(bert_df, test_size=0.01)

Con la variable bert_df, hemos formateado los datos para que sean los que espera BERT. Puedes elegir cualquier otra letra para el valor alpha si lo deseas. El método train_test_split que importamos al principio se encarga de dividir los datos de entrenamiento en los dos archivos que necesitamos.

Observa cómo se formatearon los datos con este comando.

print(train_bert_df.head())

Ahora necesitamos formatear los datos de prueba. Esto se verá diferente de cómo manejamos los datos de entrenamiento. BERT solo espera dos columnas para los datos de prueba: ID de fila, texto que queremos clasificar. No necesitamos hacer nada más con los datos de prueba una vez que los tengamos en este formato y lo haremos con el siguiente comando.

test_bert_df = pd.DataFrame({
    'id': range(len(test_df)),
    'text': test_df[1].replace(r'\n', ' ', regex=True)
})

Es similar a lo que hicimos con los datos de entrenamiento, solo que sin dos de las columnas. Echa un vistazo a los datos de prueba recién formateados.

test_bert_df.head()

Si todo se ve bien, puede guardar estas variables como los archivos .tsv con los que trabajará BERT.

train_bert_df.to_csv('data/train.tsv', sep='\t', index=False, header=False)
dev_bert_df.to_csv('data/dev.tsv', sep='\t', index=False, header=False)
test_bert_df.to_csv('data/test.tsv', sep='\t', index=False, header=False)

Entrenando el modelo

Una nota rápida antes de comenzar a entrenar el modelo: BERT puede consumir muchos recursos en las computadoras portátiles. Puede causar errores de memoria porque no hay suficiente RAM o algún otro hardware no es lo suficientemente potente. Podrías intentar hacer que training_batch_size sea más pequeño, pero eso hará que el entrenamiento del modelo sea realmente lento.

Agrega una carpeta al directorio raíz llamada model_output. Ahí es donde se guardará nuestro modelo una vez finalizado el entrenamiento. Ahora abre una terminal y ve al directorio raíz de este proyecto. Una vez que estés en el directorio correcto, ejecuta el siguiente comando y comenzará a entrenar tu modelo.

python run_classifier.py --task_name=cola --do_train=true --do_eval=true --data_dir=./data/ --vocab_file=./uncased_L-12_H-768_A-12/vocab.txt --bert_config_file=./uncased_L-12_H-768_A-12/bert_config.json --init_checkpoint=./uncased_L-12_H768_A-12/bert_model.ckpt.index --max_seq_length=128 --train_batch_size=32 --learning_rate=2e-5 --num_train_epochs=3.0 --output_dir=./model_output --do_lower_case=False

Deberías ver algunos resultados desplazándose a través de tu terminal. Una vez que esto termine de ejecutarse, tendrás un modelo entrenado que está listo para hacer predicciones.

Haciendo una predicción

Si echas un vistazo al directorio model_output, notarás que hay un montón de archivos model.ckpt. Estos archivos tienen los pesos del modelo entrenado en diferentes puntos durante el entrenamiento, por lo que deseas encontrar el que tenga el número más alto. Ese será el modelo entrenado final que querrás usar.

Ahora ejecutaremos run_classifier.py nuevamente con opciones ligeramente diferentes. En particular, cambiaremos el valor init_checkpoint al punto de control del modelo más alto y estableceremos un nuevo valor --do_predict en verdadero. Aquí está el comando que necesitas ejecutar en tu terminal.

python run_classifier.py --task_name=cola --do_predict=true --data_dir=./data --vocab_file=./uncased_L-12_H-768-A-12/bert_config.json --init_checkpoint=./model_output/model.ckpt-<highest checkpoint number> --max_seq_length=128 --output_dir=./model_output

Una vez que el comando termine de ejecutarse, debería ver un nuevo archivo llamado test_results.tsv. ¡Esto tendrá tus resultados predichos basados en el modelo que entrenaste!

Acabas de utilizar BERT para analizar algunos datos reales y, con suerte, todo esto tiene sentido.

Otros pensamientos

Sentí que era necesario pasar por el proceso de limpieza de datos aquí en caso de que alguien no lo haya pasado antes. A veces, el aprendizaje automático parece mágico, pero realmente se trata de tomarse el tiempo para que tus datos estén en las condiciones adecuadas para entrenar con un algoritmo.

BERT todavía es relativamente nuevo desde que se lanzó en 2018, pero hasta ahora ha demostrado ser más preciso que los modelos existentes, incluso si es más lento.

Traducido del artículo de Milecia McGregor - Google BERT NLP Machine Learning Tutorial

Los algoritmos basados en árboles tienden a usar la media para características (features) continuas o el modo para características categóricas cuando hacen predicciones sobre muestras de entrenamiento en las regiones a las que pertenecen. También producen predicciones con alta precisión, estabilidad y facilidad de interpretación.

Ejemplos de algoritmos basados en árboles

Hay diferentes algoritmos basados en árboles que puedes usar, como por ejemplo

• Árboles de Decisiones (Decision Trees)
• Bosques Aleatorios (Random Forest)
• Aumento de Gradiente (Gradient Boosting)
• Bagging (Agregación Bootstrap  "Bootstrap Aggregation")

Por lo tanto, todo científico de datos debería aprender estos algoritmos y usarlos en sus proyectos de aprendizaje automático.

En este artículo, aprenderás sobre el algoritmo de bosques aleatorios (random forest). Después de completar este artículo, podrás dominar el uso del algoritmo de bosque aleatorio para resolver y crear modelos predictivos para problemas de clasificación con scikit-learn.

¿Qué es el algoritmo de bosques aleatorios?

Bosque aleatorio es uno de los algoritmos de aprendizaje supervisado basados en árboles más populares. También es el más flexible y fácil de usar.

El algoritmo se puede utilizar para resolver problemas de clasificación y regresión. El bosque aleatorio tiende a combinar cientos de árboles de decisión y luego entrena cada árbol de decisión en una muestra diferente de las observaciones.

Las predicciones finales del bosque aleatorio se realizan promediando las predicciones de cada árbol individual.

Los beneficios son numerosos. Los árboles de decisión individuales tienden a sobre ajustarse (overfit) a los datos de entrenamiento, pero el bosque aleatorio puede mitigar ese problema al promediar los resultados de predicción de diferentes árboles. Esto le da al algoritmo de bosques aleatorios una mayor precisión predictiva que un solo árbol de decisión.

El algoritmo de bosque aleatorio también puede ayudarte a encontrar características que son importantes en tu conjunto de datos. Esto se debe al algoritmo de Boruta, que selecciona características importantes en un conjunto de datos.

El bosque aleatorio se ha utilizado en una variedad de aplicaciones, por ejemplo, para proporcionar recomendaciones de diferentes productos a los clientes en el comercio electrónico.

En medicina, el algoritmo puede ser utilizado para identificar la enfermedad del paciente a través del análisis de su historial médico.

También en el sector bancario, puede ser utilizado para determinar fácilmente si el cliente es fraudulento o legítimo.

¿Cómo funciona el algoritmo de bosques aleatorios?

El algoritmo funciona completando los siguientes pasos:

Paso 1: El algoritmo selecciona muestras en forma aleatoria de la base de datos proporcionada.

Paso 2: El algoritmo creará un árbol de decisión para cada muestra seleccionada. Luego obtendrá un resultado de predicción de cada árbol creado.

Paso 3: A continuación, se realizará la votación para cada resultado previsto. Para un problema de clasificación, usará la moda, y para un problema de regresión, usará la media.

Paso 4: Y finalmente, el algoritmo seleccionará el resultado de predicción más votado como predicción final.

Algoritmo de bosques aleatorios en la práctica

Ahora que conoces el funcionamiento del algoritmo de bosque aleatorio, creemos un clasificador.

Construiremos un clasificador utilizando el conjunto de datos de diabetes de los indios Pima. El conjunto de datos de diabetes de los indios Pima implica predecir la aparición de la diabetes en un plazo de 5 años según los detalles médicos proporcionados. Este es un problema de clasificación binaria.

Nuestro objetivo es analizar y crear un modelo sobre aquel conjunto de datos para predecir si un paciente en particular tiene riesgo de desarrollar diabetes, dados otros factores independientes.

Comenzaremos importando paquetes importantes que usaremos para cargar el conjunto de datos y crear un clasificador de bosque aleatorio. Usaremos la biblioteca scikit-learn para cargar y usar el algoritmo de bosque aleatorio.

# importar paquetes importantes
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler, MinMaxScaler
import pandas_profiling

from matplotlib import rcParams
import warnings

warnings.filterwarnings("ignore")

# tamaño de la figura en pulgadas
rcParams["figure.figsize"] = 10, 6
np.random.seed(42)

Conjunto de datos

Luego, carga el conjunto de datos desde el directorio de datos:

# Cargar conjunto de datos
data = pd.read_csv("../data/pima_indians_diabetes.csv")

Ahora podemos observar la muestra del conjunto de datos.

# mostrar muestra del conjunto de datos
data.sample(5)

Como puedes ver, en nuestro conjunto de datos tenemos deferentes características con valores numéricos.

Entendamos la lista de características que tenemos en este conjunto de datos.

# mostrar columnas
data.columns

En este conjunto de datos, hay 8 características  de entrada y 1 característica de salida / destino. Se cree que los valores que faltan están codificados con valor cero. El significado de los nombres de las características es el siguiente (desde la primera hasta la última):

• Número de embarazos.
• Concentración de glucosa en plasma a 2 horas en una prueba oral de tolerancia a la glucosa.
• Presión arterial diastólica (mm Hg).
• Espesor del pliegue cutáneo del tríceps (mm).
• Insulina sérica de 2 horas (mu U / ml).
• Índice de masa corporal (peso en kg / (altura en m) ^ 2).
• Función del pedigrí de la diabetes.
• Edad (años).
• Variable de clase (0 o 1).

Luego, dividimos el conjunto de datos en características independientes y característica  de destino. Nuestra característica de destino para este conjunto de datos se llama class.

# dividir los datos en características de entrada y de destino

X = data.drop("class", axis=1)
y = data["class"]

Preprocesamiento del Conjunto de Datos

Antes de crear un modelo, necesitamos estandarizar nuestras características independientes usando el método standardScaler de scikit-learn.

# estandarizar el conjunto de datos
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Dividiendo el conjunto de datos en datos de entrenamiento y prueba

Ahora dividimos nuestro conjunto de datos procesados en datos de prueba y entrenamiento. Los datos de prueba serán el 10% de todo el conjunto de datos procesados.

# dividir en conjunto de entrenamiento (train) y 
#conjunto de prueba (test)
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, stratify=y, test_size=0.10, random_state=42
)

Construyendo el Clasificador de bosque aleatorio

Ahora es el momento de crear nuestro clasificador de bosque aleatorio y luego entrenarlo en el conjunto de entrenamiento. También pasaremos el número de árboles (100) del bosque que queremos usar mediante el parámetro llamado n_estimators.

# crear el clasificador
classifier = RandomForestClassifier(n_estimators=100)

# Entrenar el modelo usando el conjunto de entranamiento
classifier.fit(X_train, y_train)

El resultado anterior muestra diferentes valores de parámetros del clasificador de bosque aleatorio utilizado durante el proceso de entrenamiento en los datos de entrenamiento.

Después del entrenamiento, podemos realizar predicciones sobre los datos de la prueba.

# predicción en el conjunto de prueba
y_pred = classifier.predict(X_test)

Luego, verificamos la precisión utilizando los valores reales y los predichos de los datos de prueba.

# Calcular la precisión del modelo
print("Precisión:", accuracy_score(y_test, y_pred))

Precisión: 0.8051948051948052

Nuestra precisión es de alrededor del 80,5%, lo cual es bueno. Pero siempre podemos hacerlo mejor.

Identificar características importantes

Como dije antes, también podemos verificar las características importantes usando la variable feature_importances_ del algoritmo de bosque aleatorio en scikit-learn.

# verificar características importantes
feature_importances_df = pd.DataFrame(
    {"feature": list(X.columns), "importance": classifier.feature_importances_}
).sort_values("importance", ascending=False)

# Mostrar
feature_importances_df

La figura anterior muestra la importancia relativa de las características y su contribución al modelo. También podemos visualizar estas características y sus puntuaciones utilizando las bibliotecas seaborn y matplotlib.

# visualizarcaracterísticas importantes

# Crear un diagrama de barras
sns.barplot(x=feature_importances_df.feature, y=feature_importances_df.importance)
# agregar estiquestas

plt.xlabel("Feature Importance Score")
plt.ylabel("Features")
plt.title("Visualizing Important Features")
plt.xticks(
    rotation=45, horizontalalignment="right", fontweight="light", fontsize="x-large"
)
plt.show()

En la figura anterior, puedes ver que la variable triceps_skinfold_thickness tiene poca importancia y no contribuye mucho a la predicción.

Esto significa que podemos eliminar esta variable y entrenar nuestro clasificador  nuevamente y luego ver si puede mejorar su rendimiento en los datos de prueba.

# cargar datos con características seleccionadas
X = data.drop(["class", "triceps_skinfold_thickness"], axis=1)
y = data["class"]

# estandarizar el conjunto de datos
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# dividir en conjunto de entrenamiento y de prueba
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, stratify=y, test_size=0.10, random_state=42
)

Entrenaremos el algoritmo con las características procesadas seleccionadas de nuestro conjunto de datos, realizaremos predicciones y luego calcularemos la precisión del modelo.

# crear clasificador
clf = RandomForestClassifier(n_estimators=100)

# Entrenar el modelo usando el conjunto de entrenamiento
clf.fit(X_train, y_train)

# predicción en el conjunto de prueba
y_pred = clf.predict(X_test)

# Calcular la precisión del modelo,
print("Precisión:", accuracy_score(y_test, y_pred))

Precisión: 0.8181818181818182

Ahora, la precisión del modelo ha aumentado del 80,5% al 81,8% después de que eliminamos la característica menos importante llamada triceps_skinfold_thickness.

Esto sugiere que es muy importante verificar las características importantes y ver si puedes eliminar las menos importantes para aumentar el rendimiento de su modelo.

En resumen

Los algoritmos basados en árboles son realmente importantes para que los aprenda todo científico de datos. En este artículo, has aprendido los conceptos básicos de los algoritmos basados en árboles y cómo crear un modelo de clasificación utilizando el algoritmo de bosque aleatorio.

¡Felicitaciones, has llegado al final de este artículo!

Si aprendiste algo nuevo o disfrutaste leyendo este artículo, compártelo para que otros puedan verlo. Hasta entonces, ¡nos vemos en el próximo post! También me pueden contactar en Twitter @Davis_McDavid

Traducido del artículo de Davis David - Random Forest Classifier Tutorial: How to Use Tree-Based Algorithms for Machine Learning

El paquete es conocido por una estructura de datos muy útil llamado arreglo de NumPy. NumPy también permite a los desarrolladores de Python realizar en forma rápida una amplia variedad de cálculo numéricos.

Este tutorial te enseñará los fundamentos de NumPy que puedes usar para crear aplicaciones numéricas en Python hoy.

Tabla de Contenidos

Puedes saltear una sección específica de este tutorial de NumPy utilizando esta tabla de contenidios:

• Introducción a NumPy
• Arreglos de NumPy
• Métodos y Operaciones de NumPy
• Indexaciones y Asignaciones en NumPy
• Pensamientos finales y oferta especial

Introducción a NumPy

En esta sección, introduciremos la librería de NumPy en Python.

¿Qué es NumPy?

NumPy es una librería de Python para computación científica. NumPy significa  Python numérico. Aquí está la descripción oficial de la librería indicada en su página web:

"NumPy es el paquete fundamental para la computación científica con Python. Contiene entre otras cosas:

• un poderoso objeto de arreglo N-dimensional
• funciones (radiodifusión) sofisticadas
• herramientas para integrar código en C/C++ y Fortran
• útiles capacidades de álgebra lineal, transformación de Fourier y números aleatorios

Además de sus obvios usos científicos, NumPy puede ser utilizado como un eficiente contenedor multidimensional de datos genéricos. Tipos de datos arbitrarios puede ser definidos. Esto permite que NumPy se integre sin problemas y con rapidez con una amplia variedad de bases de datos.

NumPy está licenciado bajo el formato BSD, lo que permite la reutilización con pocas restricciones".

NumPy es una librería de Python tan importante que hay otras librerías (incluyendo pandas) que están construidas enteramente sobre NumPy.

El principal beneficio de NumPy

El principal beneficio de NumPy es que permite una generación y manejo de datos extremadamente rápido. NumPy tiene su propia estructura de datos incorporada llamado arreglo que es similar a la lista normal de Python, pero puede almacenar y operar con datos de manera mucho más eficiente.

Que aprenderemos sobre NumPy

Los practicantes avanzados de Python pasarán mucho más tiempo trabajando con pandas que trabajando con NumPy. AUn así, dado que pandas se basa en NumPy, es importante comprender los aspectos más importantes de la biblioteca NumPy.

En las siguientes secciones, cubriremos la siguiente información sobre la librería de NumPy:

• Arreglos de NumPy
• Indexación y asignación de NumPy
• Métodos y operaciones de NumPy

Continuemos

Pasemos a aprender sobre los arreglos de NumPy, la estructura de datos central con la que todo profesional de NumPy debe estar familiarizado.

Arreglos de NumPy

En esta sección, aprenderemos sobre los arreglos de NumPy.

¿Qué son los Arreglos de NumPy?

Los arreglos NumPy son la forma principal de almacenar datos utilizando la biblioteca NumPy. Son similares a las listas normales en Python, pero tienen la ventaja de ser más rápidas y tener más métodos integrados.

Los arreglos de NumPy son creados llamando al método array() de la librería de NumPy. Dentro del método, deberías pasar una lista.

A continuación, se muestra un ejemplo de un arreglo de NumPy básico. Ten en cuenta que mientras ejecuto la instrucción import numpy as np al comienzo de este bloque de código, se excluirá de los otros bloques de código en esta sección por razones de brevedad.

import numpy as np

sample_list = [1, 2, 3]

np.array(sample_list)

La última línea de ese bloque de código dará como resultado una salida que se ve así.

array([1,2,3])

El contenedor array() indica que esta ya no es una lista normal de Python. En cambio, es un arreglo de NumPy.

Los dos tipos diferentes de arreglos de NumPy

Hay dos tipos diferentes de arreglos de NumPy: vectores y matrices.

Los vectores son arreglos de NumPy uni-dimensionales y se ve así:

my_vector = np.array(['este', 'es', 'un', 'vector'])

Las matrices son arreglo bi-dimensionales y son creadas pasando una lista de lista dentro del método np.array(). Un ejemplo es el siguiente.

my_matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]

np.array(my_matrix)

También puedes expandir los arreglos de NumPy para trabajar con matrices de tres, cuatro, cinco, seis o más dimensiones, pero son raras y están en gran parte fuera del alcance de este curso (después de todo, este es un curso sobre programación Python, no álgebra lineal).

Arreglos de NumPy: Métodos Incorporados

Los arreglos de NumPy vienen con un número de métodos incorporados útiles. Dedicaremos el resto de esta sección analizando estos métodos en detalle.

Cómo obtener un rango de números en Python utilizando Numpy

NumPy tiene un método útil llamado arange que toma dos números y devuelve un arreglo de números enteros que son mayores o iguales a (>=) el primer número y menores que (<) el segundo número.

Un ejemplo del método arange es el siguiente.

np.arange(0,5)

#Devuevle array([0, 1, 2, 3, 4])

También puedes incluir una tercera variable en el método arange que proporciona un tamaño de paso para que la función regrese. Pasar 2 como tercera variable devolverá cada segundo número en el rango, pasar 5 como tercera variable devolverá cada quinto número en el rango, y así sucesivamente.

Un ejemplo de uso de la tercera variable en el método arange se encuentra a continuación.

np.arange(1,11,2)

#Returns array([1, 3, 5, 7, 9])

Cómo generar Unos y Ceros en Python usando NumPy

Mientras programas, de vez en cuando necesitará crear arreglos de unos o ceros. NumPy tiene métodos incorporados que te permiten hacer ambas cosas.

Podemos crear arreglos de ceros utilizando el método zeros de NumPy. Le pasas el número de enteros que quisieras crear como el argumento de la función. Un ejemplo es el siguiente.

np.zeros(4)

#Devuelve array([0, 0, 0, 0])

También puedes hacer algo similar utilizando matrices tridimensionales. Por ejemplo, np.zeros(5, 5) crea un arreglo de 5x5 que contiene todos ceros.

Podemos crear arreglos de unos usando un método similar llamado ones. Un ejemplo es el que sigue.

np.ones(5)

#Returns array([1, 1, 1, 1, 1])

Cómo dividir uniformemente un rango de números en Python usando NumPy

Hay muchas situaciones en las que tienes un rango de números y te gustaría dividir por igual ese rango de números en intervalos. El método linspace de NumPy está diseñado para resolver este problema. linspace tiene tres argumentos:

1. El inicio del intervalo
2. El fin del intervalo
3. El número de subintervalos en los que deseas que se divida el intervalo

Un ejemplo del método linspace es el siguiente.

np.linspace(0, 1, 10)

#Devuelve array([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])

Cómo crear un arreglo Identidad en Python usando NumPy

Cualquiera que haya estudiado álgebra lineal estará familiarizado con el concepto de un "arregloidentidad", que es un arreglo cuadrada cuyos valores diagonales son todos 1. NumPy tiene una función incorporada que incluye un argumento para construir matrices de identidad. La función es eye.

Algunos ejemplos:

np.eye(1)

#Devuelve un arreglo identidad de 1x1

np.eye(2) 

#Devuelve un arreglo identidad de 2x2

np.eye(50)

#Devuelve un arreglo identidad de 50x50

Cómo crear números aleatorios en Python usando NumPy

NumPy tiene varios métodos integrados que te permiten crear matrices de números aleatorios. Cada uno de estos métodos comienza con random. A continuación se muestran algunos ejemplos:

np.random.rand(sample_size)

#Devuelve una muestra de números aleatorios entre 0 y 1.

#El tamaño de la muestra puede ser un número entero (para un arreglo unidimensional) o dos enteros separados por comas (para un arreglo bidimensional).

np.random.randn(sample_size)

#Devuelve una muestra de números aleatorios entre 0 y 1, siguiendo la distribución normal

#El tamaño de la muestra puede ser un número entero (para un arreglo unidimensional) o dos enteros separados por comas (para un arreglo bidimensional).

np.random.randint(low, high, sample_size)

#Devuelve una muestra de números enteros que son mayores o iguales que 'low' y menores que 'high' 

Cómo remodelar arreglos de NumPy

Es muy común tomar un arreglo con ciertas dimensiones y transformar ese arreglo en una forma diferente. Por ejemplo, es posible que tengas un arreglo unidimensional con 10 elementos y desee cambiarla a un arreglo bidimensional de 2x5.

A continuación se muestra un ejemplo:

arr = np.array([0,1,2,3,4,5])

arr.reshape(2,3)

La salida de esta operación es:

array([[0, 1, 2],

       [3, 4, 5]])

Ten en cuenta que para usar el método reshape, el arreglo original debe tener la misma cantidad de elementos que el arreglo en el que estás tratando de remodelarlo.

Si tienes curiosidad sobre la forma actual de un arreglo NumPy, puede determinar su forma utilizando el atributo shape de NumPy. Usando nuestra estructura de la variable arr anterior, a continuación se muestra un ejemplo de cómo llamar al atributo shape:

arr = np.array([0,1,2,3,4,5])

arr.shape

#Devuelve (6,)- ten en cuenta que no hay un segundo elemento ya que es un arreglo unidimensional

arr = arr.reshape(2,3)

arr.shape

#Devuelve (2,3)

También puede combinar el método  reshape con el atributo  shape en una línea como esta:

arr.reshape(2,3).shape

#Devuelve (2,3)

Cómo encontrar el valor máximo y mínimo de un arreglo NumPy

Para concluir esta sección, aprendamos cuatro métodos útiles para identificar los valores máximo y mínimo dentro de un arreglo NumPy. Trabajaremos con este arreglo:

simple_array = [1, 2, 3, 4]

Podemos usar el método max para encontrar el máximo valor de un arreglo de NumPy. A continuación se muestra un ejemplo.

simple_array.max()

#Devuelve 4

Podemos usar también el método argmax para encontrar el índice del máximo valor dentro de un arreglo. Esto es útil cuando deseas encontrar la ubicación del valor máximo pero no necesariametne te interesa su valor en si.

Un ejemplo se observa a continuación.

simple_array.argmax()

#Devuelve 3

En forma similar, podemos usar los métodos min y argmin para encontrar el valor e índice del mínimo valor dentro de un arreglo de NumPy.

simple_array.min()

#Devuelve 1

simple_array.argmin()

#Devuelve 0

Continuemos

En esta sección, analizaremos varios atributos y métodos de los arreglos de NumPy.

Seguiremos trabajando en algunos problemas de práctica de arreglos NumPy en la siguiente sección.

Métodos y Operaciones de NumP

En esta sección, trabajaremos a través de varias operaciones incluidas en la biblioteca NumPy.

A lo largo de esta sección, asumiremos que el comando import numpy as np ya ha sido ejecutada.

El arreglo usado en esta sección

Para esta sección, trabajaré con un arreglo de longitud 4 creada usando np.arange en todos los ejemplos.

Si deseas comparar mi arreglo con las salidas utilizadas en esta sección, así es como creé e imprimí el arreglo:

arr = np.arange(4)

arr

Los valores del arreglo están debajo.

array([0, 1, 2, 3])

Cómo realizar operaciones aritméticas en Python usando NumPy

NumPy facilita realizar operaciones aritméticas con arreglos. Puedes realizarlas usando el arreglo y un sólo número, o puedes realizarlas entre dos arreglos NumPy.

Exploramos cada una de las principales operaciones matemáticas a continuación.

Suma

Al sumar un sólo número a un arreglo de NumPy, ese número se suma a cada elemento en el arreglo. A continuación se ve un ejemplo:

2 + arr

#Devuelve array([2, 3, 4, 5])

Puedes sumar dos arreglos NumPy usando el operador +. Los arreglos se suman elemento por elemento (lo que significa que los primeros elementos se suman entre si, los segundos elementos se suman se suman entre se, y así sucesivamente).

A continuación se ve un ejemplo.

arr + arr

#Devuelve array([0, 2, 4, 6])

Resta

Como la suma, la resta se realiza elemento por elemento para arreglos de NumPy. Puedes encontrar un ejemplo para el caso de un solo número y para el de otro arreglo NumPy a continuación

arr - 10

#Devuelve array([-10,  -9,  -8,  -7])

arr - arr

#Devuelve array([0, 0, 0, 0])

Multiplicación

La multiplicación también se realiza elemento por elemento tanto para casos de un sólo número como para casos de opraciones entre arreglos de NumPy.

A continuación se ven dos ejemplo.

6 * arr

#Devuelve array([ 0,  6, 12, 18])

arr * arr

#Devuelve array([0, 1, 4, 9])

División

En este punto, probablemente no te sorprende saber que la división en arreglos NumPy se realiza elemento por elemento. Un ejemplo de división de arr por un sólo número se ve a continuación:

arr / 2

#Devuelve array([0. , 0.5, 1. , 1.5])

La división tiene una excepción notable en comparación con las otras operaciones matemáticas que hemos visto en esta sección. Dado que no podemos dividir por cero, al hacerlo, el campo correspondiente se completará con un valor nan, que es la abreviatura de Python para "No es un número" (“Not A Number”). Jupyter Notebook también imprimirá una advertencia similar a esta:

RuntimeWarning: invalid value encountered in true_divide

Un ejemplo de dividir por cero es con un arreglo NumPy que se muestra a continuación.

arr / arr

#Devuelve array([nan,  1.,  1.,  1.])

Aprenderemos cómo tratar los valores nan con más detalle más adelante en este curso.

Operaciones complejas en arreglos de NumPy

Muchas operaciones no se pueden realizar simplemente aplicando la sintaxis normal a un arreglo NumPy. En esta sección, exploraremos varias operaciones matemáticas que tienen métodos incorporados en la biblioteca NumPy.

Cómo calcular raíz cuadrada usando NumPy

Puedes calcular la raíz cuadrada de cada elemento en un arreglo usando el método np.sqrt:

np.sqrt(arr)

#Devuelve array([0., 1., 1.41421356, 1.73205081])

A continuación se muestran muchos otros ejemplos (ten en cuenta que no te serán evaluados, pero aún así es útil ver las capacidades de NumPy):

np.exp(arr)

#Devuelve e ^ elemento para cada elemento del arreglo

np.sin(arr)

#Calcula el seno trigonométrico de cada valor en el arreglo

np.cos(arr)

#Calcula el coseno trigonométrico de cada valor en el arreglo

np.log(arr)

#Calcula el logaritmo en base diez de cada valor en el arreglo

Continuemos

En esta sección, exploramos los diversos métodos y operaciones disponibles en la biblioteca NumPy Python. Evaluaremos tu conocimiento de estos conceptos en los problemas de práctica que se presentan a continuación.

Indexación y Asignación en NumPy

En esta sección, exploraremos la indexación y la asignación en arreglos NumPy.

El arreglo que usaré en esta sección

Como antes, usaré un arreglo específico a través de esta sección. Esta vez se generará utilizando el método np.random.rand. Así es como generé el arreglo:

arr = np.random.rand(5)

Aquí está el arreglo real:

array([0.69292946, 0.9365295 , 0.65682359, 0.72770856, 0.83268616])

Para que este arreglo sea más fácil de ver, redondearé cada elemento a 2 decimales usando el método round de NumPy:

arr = np.round(arr, 2)

Aquí está el nuevo arreglo:

array([0.69, 0.94, 0.66, 0.73, 0.83])

Cómo retornar un elemento específico de un arreglo de NumPy

Podemos seleccionar (y retornar) un elemento específico desde un arreglo NumPy de la misma forma que realiza con una lista normal de Python: usando los corchetes.

Un ejemplo se ve a continuación:

arr[0]

#Devuelve 0.69

También podemos referenciar múltiples elementos de un arreglo NumPy usando los dos puntos. Por ejemplo, el índice [2:] selecciona cada elemento desde el índice 2 en adelante. El índice [:3] selecciona cada elemento hasta el índice 3 excluido. El índice [2:4] retorna cada elemento desde el índice 2 al índice 4, excluyendo este último. El criterio de valoración más alto siempre se excluye.

A continuación se muestran algunos ejemplos de indexación mediante el operador de dos puntos.

arr[:]

#Retorna el arreglo completo: array([0.69, 0.94, 0.66, 0.73, 0.83])

arr[1:]

#Devuelve array([0.94, 0.66, 0.73, 0.83])

arr[1:4] 

#Devuelve array([0.94, 0.66, 0.73])

Asignación de elementos en arreglos de NumPy

Podemos asignar nuevos valores a un elemento de un arreglo NumPy usando el operador =, al igual que las listas de Python normales. A continuación se muestran algunos ejemplos (ten en cuenta que todo esto es un bloque de código, lo que significa que las asignaciones de elementos se llevan adelante de paso a paso)

array([0.12, 0.94, 0.66, 0.73, 0.83])

arr

#Devuelve array([0.12, 0.94, 0.66, 0.73, 0.83])

arr[:] = 0

arr

#Devuelve array([0., 0., 0., 0., 0.])

arr[2:5] = 0.5

arr

#Devuelve array([0. , 0. , 0.5, 0.5, 0.5])

Referenciación de arreglos en NumPy

NumPy hace uso de un concepto llamado "Referencia de arreglos" (array referencing) que es una fuente común de confusiones para las personas que son nuevas en la librería.

Para entender la referencia de arreglo, primero veamos un ejemplo:

new_array = np.array([6, 7, 8, 9])

second_new_array = new_array[0:2]

second_new_array

#Devuelve array([6, 7])

second_new_array[1] = 4

second_new_array 

#Devuelve array([6, 4]), como se esperaba

new_array 

#Devuelve array([6, 4, 8, 9]) 

#que es DIFERENTE de su valor original de array([6, 7, 8, 9])

#¿Que ha pasado?

Como puedes ver, la modificación de second_new_array cambió también el valor de new_array.

¿Por qué es esto?

Por defecto, NumPy no crea una copia de un arreglo cuando hace referencia a la variable del arreglo original usando el operador de asignación =. En cambio, simplemente apunta la nueva variable a la anterior, lo que permite que la segunda variable realice modificaciones en la variable original, incluso si esta no es tu intención.

Esto puede parecer extraño, pero tiene una explicación lógica. El propósito de la referencia de arreglos es conservar poder computacional. Al trabajar con grandes conjuntos de datos, rápidamente te quedarías sin RAM si crearas un nuevo arreglo cada vez que quisieras trabajar con una porción de él.

Afortunadamente, existe una solución para la referencia de arreglos. Puede utilizar el método copy para copiar explícitamente un arreglo NumPy.

A continuación se muestra un ejemplo de esto.

array_to_copy = np.array([1, 2, 3])

copied_array = array_to_copy.copy()

array_to_copy

#Returns array([1, 2, 3])

copied_array

#Returns array([1, 2, 3])

Como puede ver a continuación, realizar modificaciones al arreglo copiado no altera el original.

copied_array[0] = 9

copied_array

#Devuelve array([9, 2, 3])

array_to_copy

#Devuelve array([1, 2, 3])

Hasta ahora en la sección, solo hemos explorado cómo hacer referencia a arreglos NumPy unidimensionales. Ahora exploraremos la indexación de matrices bidimensionales.

Indexando arreglos NumPy de dos dimensiones

Para comenzar, creemos un arreglo NumPy de dos dimensiones llamado mat:

mat = np.array([[5, 10, 15],[20, 25, 30],[35, 40, 45]])

mat

"""

Devuelve:

array([[ 5, 10, 15],

       [20, 25, 30],

       [35, 40, 45]])

"""

Hay dos formas de indexar un arreglo NumPy de dos dimensiones:

• mat[fila, columna]
• mat[fila][colulma]

Personalmente, prefiero indexar usando la nomenclatura mat[fila][colulma] porque es más fácil de visualizar paso a paso. Por ejemplo:

#Primero, vamos a conseguir la primera fila:

mat[0]

#Luego, obtengamos el último elemento de la primera fila:

mat[0][-1]

También puede generar submatrices a partir de un arreglo NumPy bidimensional utilizando esta notación:

mat[1:][:2]

"""

Devuelve:

array([[20, 25, 30],

       [35, 40, 45]])

"""

La referencia de arreglos también se aplica a arreglos bidimensionales en NumPy, así que asegúrate de utilizar el método copy si deseas evitar modificar inadvertidamente un arreglo original después de guardar una porción de él en un nuevo nombre de variable.

Selección condicional mediante arreglos de NumPy

Los arreglos NumPy admiten una función llamada conditional selection, que le permite generar un nuevo arreglo de valores booleanos que indican si cada elemento dentro del arreglo satisface una declaración if particular.

Un ejemplo de esto está abajo (también recreé nuestra variable arr original ya que ha pasado un tiempo desde que la vimos):

arr = np.array([0.69, 0.94, 0.66, 0.73, 0.83])

arr > 0.7

#Devuelve array([False,  True, False,  True,  True])

También puedes generar un nuevo arreglo de valores que satisfagan esta condición pasando la condición entre corchetes (como lo hacemos para indexar).

Un ejemplo de esto está abajo:

arr[arr > 0.7]

#Devuelve array([0.94, 0.73, 0.83])

La selección condicional puede volverse significativamente más compleja que esto. Exploraremos más ejemplos en los problemas de práctica asociados a esta sección.

Continuemos

En esta sección, exploramos la indexación y la asignación de matrices NumPy en detalle. Fortaleceremos aún más su conocimiento de estos conceptos trabajando en una serie de problemas de práctica en la siguiente sección.

Pensamientos finales y oferta especial

Gracias por leer este artículo sobre NumPy, que es uno de mis paquetes favoritos de Python y una biblioteca imprescindible para todos los desarrolladores de Python.

Traducido del artículo de Nick McCullum - The Ultimate Guide to the NumPy Package for Scientific Computing in Python

Antes de realizar la extracción de datos de una página web, debes asegurarte de que el proveedor lo permita en sus términos de servicio. Además, deberías verificar si no puedes usar una API en su lugar.

Una extracción masiva de datos puede poner al servidor bajo un enorme esfuerzo, lo cual puede resultar en una denegación de servicio. Y no quieres eso.

¿Quién debería leer esto?

Este artículo es para lectores avanzados. Se asume que ya estás familiarizado con el lenguaje de programación de Python.

Como mínimo, debes entender la comprensión de listas, el administrador de contexto y las funciones. También debes saber cómo configurar un entorno virtual.

Ejecutaremos el código en tu máquina local para explorar algunos sitios web.

Qué aprenderás en este artículo

Al final de este artículo, sabrás cómo descargar una página web, analizarla en busca de información interesante y darle un formato utilizable para su posterior procesamiento. Esto también se conoce como ETL.

Este artículo también explicará qué hacer si ese sitio web usa JavaScript para representar (render) contenido (como React.js o Angular).

Pre-requisitos

Antes de comenzar, deseo asegurarme de que estemos listo para dar inicio. Por favor, establece un entorno virtual e instálale los siguientes paquetes:

• beautifulsoup4 (versión 4.9.0 al momento de estar escribiendo el artículo)
• requests (versión 2.23.0 al momento de estar escribiendo el artículo)
• wordcloud (versión 1.17.0 al momento de estar escribiendo el artículo, opcional)
• selenium (versión 3.141.0 al momento de estar escribiendo el artículo, opcional)

Puedes encontrar el código de este proyecto en este repositorio git en GitHub

Para este ejemplo, realizaremos una extracción (scrape) de la Ley Básica para la República Federal de Alemania. (No te preocupes, ya verifiqué los Términos de Servicios. Ofrecen una versión XML para procesamiento de máquina, pero esta página sirve como un ejemplo de procesamiento de HTML. Entonces debería estar bien.)

Paso 1: Descargar la fuente

Primero lo primero: creé un archivo urls.txt que contiene todos los URLs que deseo descargar:

https://www.gesetze-im-internet.de/gg/art_1.html
https://www.gesetze-im-internet.de/gg/art_2.html
https://www.gesetze-im-internet.de/gg/art_3.html
https://www.gesetze-im-internet.de/gg/art_4.html
https://www.gesetze-im-internet.de/gg/art_5.html
https://www.gesetze-im-internet.de/gg/art_6.html
https://www.gesetze-im-internet.de/gg/art_7.html
https://www.gesetze-im-internet.de/gg/art_8.html
https://www.gesetze-im-internet.de/gg/art_9.html
https://www.gesetze-im-internet.de/gg/art_10.html
https://www.gesetze-im-internet.de/gg/art_11.html
https://www.gesetze-im-internet.de/gg/art_12.html
https://www.gesetze-im-internet.de/gg/art_12a.html
https://www.gesetze-im-internet.de/gg/art_13.html
https://www.gesetze-im-internet.de/gg/art_14.html
https://www.gesetze-im-internet.de/gg/art_15.html
https://www.gesetze-im-internet.de/gg/art_16.html
https://www.gesetze-im-internet.de/gg/art_16a.html
https://www.gesetze-im-internet.de/gg/art_17.html
https://www.gesetze-im-internet.de/gg/art_17a.html
https://www.gesetze-im-internet.de/gg/art_18.html
https://www.gesetze-im-internet.de/gg/art_19.html

Luego, escribí un poco de código en Python en un archivo llamado scraper.py para descargar el HTML de estos archivos.

En un escenario real, esto sería demasiado costoso y, en su lugar, utilizarías una base de datos. Para simplificar las cosas, descargaré archivos en el mismo directorio y usaré su nombre como nombre de archivo.

from os import path
from pathlib import PurePath

import requests

with open('urls.txt', 'r') as fh:
    urls = fh.readlines()
urls = [url.strip() for url in urls]  # strip `\n`

for url in urls:
    file_name = PurePath(url).name
    file_path = path.join('.', file_name)
    text = ''

    try:
        response = requests.get(url)
        if response.ok:
            text = response.text
    except requests.exceptions.ConnectionError as exc:
        print(exc)
    
    with open(file_path, 'w') as fh:
        fh.write(text)

    print('Written to', file_path)

Al descargar los archivos, los puedo procesar localmente tanto como lo desee sin depender de unos servidos. Trata de ser un buen ciudadano web, ¿si?

Paso 2: Analizar la fuente

Ahora que he descargado los archivos, es tiempo de extraer información interesante. Por lo tanto me dirijo a alguna de las páginas que descargué, la abro en un navegador web, y aprieto Crtl-U para ver su código fuente. Al inspeccionarlo me mostrará su estructura HTML.

En mi caso, quería el texto de la ley sin ningún marcado. El elemento que lo envuelve tiene un id de container. Usando BeautifulSoup puedo ver que una combinación de find y get_text hará lo que quiero.

Como tengo un segundo paso ahora, voy a refactorizar un poco el código poniéndolo en funciones y agregando una CLI mínima.

from os import path
from pathlib import PurePath
import sys

from bs4 import BeautifulSoup
import requests


def download_urls(urls, dir):
    paths = []

    for url in urls:
        file_name = PurePath(url).name
        file_path = path.join(dir, file_name)
        text = ''

        try:
            response = requests.get(url)
            if response.ok:
                text = response.text
            else:
                print('Mala respuesta para', url, response.status_code)
        except requests.exceptions.ConnectionError as exc:
            print(exc)
    
        with open(file_path, 'w') as fh:
            fh.write(text)

        paths.append(file_path)

    return paths

def parse_html(path):
    with open(path, 'r') as fh:
        content = fh.read()

    return BeautifulSoup(content, 'html.parser')

def download(urls):
    return download_urls(urls, '.')

def extract(path):
    return parse_html(path)

def transform(soup):
    container = soup.find(id='container')
    if container is not None:
        return container.get_text()

def load(key, value):
    d = {}
    d[key] = value
    return d

def run_single(path):
    soup = extract(path)
    content = transform(soup)
    unserialised = load(path, content.strip() if content is not None else '')
    return unserialised

def run_everything():
    l = []

    with open('urls.txt', 'r') as fh:
        urls = fh.readlines()
    urls = [url.strip() for url in urls]

    paths = download(urls)
    for path in paths:
        print('Written to', path)
        l.append(run_single(path))

    print(l)

if __name__ == "__main__":
    args = sys.argv

    if len(args) is 1:
      run_everything()
    else:
        if args[1] == 'download':
            download([args[2]])
            print('Done')
        if args[1] == 'parse':
            path = args[2]
            result = run_single(path)
            print(result)

Ahora puedo ejecutar el código de tres maneras:

1. Sin ningún argumento para ejecutar todo (es decir, descargar todas las URL y extraerlas, luego guardarlas en el disco) a través de: python scraper.py
2. Con un argumento de download y una url para descargar: python scraper.py download https://www.gesetze-im-internet.de/gg/art_1.html. Esto no procesará el archivo.
3. Con un argumento de parse y una ruta de archivo para analizar: python scraper.py art_1.html. Esto omitirá el paso de descarga.

Con esto, solo falta una última cosa.

Paso 3: Dar formato a la fuente para su posterior procesamiento

Digamos que quiero generar una nube de palabras para cada artículo. Esta puede ser una forma rápida de tener una idea de lo que trata un texto. Para ello, instala el paquete wordcloud y actualiza el archivo así:

from os import path
from pathlib import Path, PurePath
import sys

from bs4 import BeautifulSoup
import requests
from wordcloud import WordCloud

STOPWORDS_ADDENDUM = [
    'Das',
    'Der',
    'Die',
    'Diese',
    'Eine',
    'In',
    'InhaltsverzeichnisGrundgesetz',
    'im',
    'Jede',
    'Jeder',
    'Kein',
    'Sie',
    'Soweit',
    'Über'
]
STOPWORDS_FILE_PATH = 'stopwords.txt'
STOPWORDS_URL = 'https://raw.githubusercontent.com/stopwords-iso/stopwords-de/master/stopwords-de.txt'


def download_urls(urls, dir):
    paths = []

    for url in urls:
        file_name = PurePath(url).name
        file_path = path.join(dir, file_name)
        text = ''

        try:
            response = requests.get(url)
            if response.ok:
                text = response.text
            else:
                print('Mala respuesta para', url, response.status_code)
        except requests.exceptions.ConnectionError as exc:
            print(exc)
    
        with open(file_path, 'w') as fh:
            fh.write(text)

        paths.append(file_path)

    return paths

def parse_html(path):
    with open(path, 'r') as fh:
        content = fh.read()

    return BeautifulSoup(content, 'html.parser')

def download_stopwords():
    stopwords = ''

    try:
        response = requests.get(STOPWORDS_URL)
        if response.ok:
            stopwords = response.text
        else:
            print('Mala respuesta para', url, response.status_code)
    except requests.exceptions.ConnectionError as exc:
        print(exc)

    with open(STOPWORDS_FILE_PATH, 'w') as fh:
        fh.write(stopwords)

    return stopwords

def download(urls):
    return download_urls(urls, '.')

def extract(path):
    return parse_html(path)

def transform(soup):
    container = soup.find(id='container')
    if container is not None:
        return container.get_text()

def load(filename, text):
    if Path(STOPWORDS_FILE_PATH).exists():
        with open(STOPWORDS_FILE_PATH, 'r') as fh:
            stopwords = fh.readlines()
    else:
        stopwords = download_stopwords()

    # Tira de espacios en blanco alrededor
    stopwords = [stopword.strip() for stopword in stopwords]
    # Extienda las stopwords con las propias, que se determinaron después de 	  la primera ejecución stopwords = stopwords + STOPWORDS_ADDENDUM

    try:
        cloud = WordCloud(stopwords=stopwords).generate(text)
        cloud.to_file(filename.replace('.html', '.png'))
    except ValueError:
        print('No se pudo generar la nube de palabras para', key)

def run_single(path):
    soup = extract(path)
    content = transform(soup)
    load(path, content.strip() if content is not None else '')

def run_everything():
    with open('urls.txt', 'r') as fh:
        urls = fh.readlines()
    urls = [url.strip() for url in urls]

    paths = download(urls)
    for path in paths:
        print('Written to', path)
        run_single(path)
    print('Done')

if __name__ == "__main__":
    args = sys.argv

    if len(args) is 1:
      run_everything()
    else:
        if args[1] == 'download':
            download([args[2]])
            print('Done')
        if args[1] == 'parse':
            path = args[2]
            run_single(path)
            print('Done')

¿Qué cambió? Por un lado, descargué una lista de palabras vacías (stopwords) alemanas de GitHub. De esta manera, puedo eliminar las palabras más comunes del texto de la ley descargado.

Luego, creé una instancia de WordCloud con la lista de palabras vacías que descargué y el texto de la ley. Se convertirá en una imagen con el mismo nombre de base.

Después de la primera ejecución, descubrí que la lista de palabras vacías está incompleta. Así que agregué palabras adicionales que quiero excluir de la imagen resultante.

Con esto, la parte principal de la extracción web está completa.

Bonus: ¿Y los SPA?

Los SPA, o aplicaciones de página única, son aplicaciones web donde toda la experiencia está controlada por JavaScript, que se ejecuta en el navegador. Como tal, descargar el archivo HTML no nos lleva muy lejos. ¿Qué deberíamos hacer en su lugar?

Usaremos el navegador. Con Selenium. Asegúrate de instalar también un controlador. Descarga el archivo .tar.gz y descomprímelo en la carpeta bin de tu entorno virtual para que Selenium lo encuentre. Ese es el directorio donde puedes encontrar el script de activación (en sistemas GNU / Linux).

Como ejemplo, estoy usando el sitio web de Angular aquí. Angular es un SPA-Framework popular escrito en JavaScript y se garantiza que será controlado por él por el momento.

Dado que el código será más lento, creé un nuevo archivo llamado crawler.py para él. El contenido tiene este aspecto:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from wordcloud import WordCloud

def extract(url):
    elem = None
    driver = webdriver.Firefox()
    driver.get(url)

    try:
        found = WebDriverWait(driver, 10).until(
            EC.visibility_of(
                driver.find_element(By.TAG_NAME, "article")
            )
        )
        # Haz una copia de los datos relevantes, porque Selenium arrojará si
        # intenta acceder a las propiedades después de que el controlador se 			cierre
        elem = {
          "text": found.text
        }
    finally:
        driver.close()

    return elem

def transform(elem):
    return elem["text"]
        
def load(text, filepath):
    cloud = WordCloud().generate(text)
    cloud.to_file(filepath)

if __name__ == "__main__":
    url = "https://angular.io/"
    filepath = "angular.png"

    elem = extract(url)
    if elem is not None:
        text = transform(elem)
        load(text, filepath)
    else:
        print("Lo siento, no se pudieron extraer datos")

Aquí, Python abre una instancia de Firefox, navega por el sitio web y busca un elemento <article>. Está copiando su texto en un diccionario, que se lee en el paso transform y se convierte en WordCloud durante load.

Cuando se trata de sitios con mucho JavaScript, a menudo es útil usar Waits y tal vez incluso ejecutar execute_script para diferir a JavaScript si es necesario.

Resumen

¡Gracias por leer hasta aquí! Resumamos lo que hemos aprendido ahora:

1. Cómo hacer una extracción (scrape) un sitio web con el paquete requests de Python.
2. Cómo traducirla en una estructura con sentido usando beautifulsoup.
3. Cómo procesar aún más esa estructura en algo con lo que puedas trabajar.
4. Qué hacer si la página de destino se basa en JavaScript.

Otras lecturas

Si quieres saber más sobre mí, puedes seguirme en Twitter o visitar mi sitio web.

No soy el primero que escribió sobre Web Scraping aquí en freeCodeCamp. Yasoob Khalid y Dave Gray también lo hicieron en el pasado:

An Intro to Web Scraping with lxml and Python

by Timber.io An Intro to Web Scraping with lxml and PythonPhoto by Fabian Grohs[https://unsplash.com/photos/dC6Pb2JdAqs?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText] on Unsplash[https://unsplash.com/search/photos/web?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText…

freeCodeCamp.orgfreeCodeCamp.org

Better web scraping in Python with Selenium, Beautiful Soup, and pandas

by Dave Gray Web ScrapingUsing the Python programming language, it is possible to “scrape” data from theweb in a quick and efficient manner. Web scraping is defined as: &gt; a tool for turning the unstructured data on the web into machine readable,structured data which is ready for analysis. (sou…

freeCodeCamp.orgfreeCodeCamp.org

Traducido del artículo de André Jaenisch - How Scrape Websites with Python 3

Cuando nos gusta el repositorio de alguien y nos gustaría tenerlo en nuestra cuenta de GitHub, hacemos un fork o bifurcación para poder trabajar con él en forma separada.

Cuando hacemos un fork de un repositorio, obtenemos una instancia de todo el repositorio con todo su historial. Luego, podemos hacer lo que queramos sin afectar la versión original.

¿Qué es un pull request?

Los pull requests son la forma de contribuir a un proyecto grupal o de código abierto.

Por ejemplo, un usuario llamado Harry realiza un fork de un repositorio de ThanoshanMV y le efectúa algunos cambios. Ahora Harry puede hacer un pull request a ThanoshanMV, pero dependerá de ThanoshanMV aceptar o declinarlo. Es como decir: "ThanoshanMV, ¿podrías por favor extraer (pull) mis cambios?"

¿Que significa contribuir?

No solo podemos contribuir a un proyecto de código abierto con código, sino que podemos hacerlo de muchas otras maneras. Algunas de ellas están descritas abajo.

Como indica la guía de hacktitude para iniciados de la firma IT 99xtechnology, podemos contribuir a un proyecto de código abierto de las siguientes maneras:

1. Diseñando: Puedes construir los diseños de un proyecto para mejorar su usabilidad, mejorar la navegación y el menú del proyecto en función de lo indicado por investigaciones acerca de las preferencias del usuario, crear arte para logotipos o camisetas y proporcionar guías de estilo para el proyecto.
2. Escribiendo: Puedes escribir y mejorar la documentación del proyecto o traducirla, iniciar un boletín o escribir tutoriales para el proyecto y tomar nota de los aspectos más destacados de la lista de correo, u organizar una carpeta de ejemplos mostrando cómo se utilizan los proyectos.
3. Organizando: Puedes vincular problemas duplicados, sugerir nuevas etiquetas de problemas, sugerir cerrar viejos problemas aún abiertos y hacer preguntas sobre problemas abiertos recientemente para hacer avanzar la discusión.
4. Ayuda a otros: Responde preguntas de problemas aún en discusión, revisa el código enviado por otras personas y ofrécete a ser mentor de otro colaborador.
5. Elaborando código: Ayuda a resolver problemas aún en discusión, consulta si puedes proveer nuevas funciones y mejorar las herramientas y las pruebas.

¡Realicemos nuestro primer pull request!

1. Realicemos un fork del repositorio

Realiza un fork del repositorio haciendo un clic en el botón fork de la parte superior de la página. Esto creará una instancia del repositorio completo en tu cuenta.

2. Clona el repositorio

Una vez que el repositorio esté en tu cuenta, clónalo a tu computador para trabajarlo localmente.

Para clonarlo, has clic en el botón "Code" y copia el link.

Abre la terminal y ejecuta el siguiente comando. Esto clonará el repositorio localmente.

$ git clone [DIRECCIÓN HTTPS]

Ahora hemos configurado una copia de la rama maestra desde el repositorio principal del proyecto en línea.

Debemos ir al repositorio clonado ejecutando el siguiente comando:

$ cd [NOMBRE DEL REPOSITORIO]

3. Crea una rama

Es una buena práctica crear una rama (branch) nueva cuando trabajas con repositorios, ya sea que se trate de un proyecto pequeño o estés contribuyendo en un equipo de trabajo.

El nombre de la rama debe ser breve y debe reflejar el trabajo que estamos haciendo.

Ahora crea una rama usando el comando git checkout:

$ git checkout -b [Nombre de la Rama]

4. Realiza cambios y confírmalos

Has cambios esenciales al proyecto y guárdalos.

Luego ejecuta git status , y verás los cambios.

Agrega esos cambios a la rama recién creada usando el comando git add:

$ git add .

Ahora confirma esos cambios utilizando el comando git commit:

$ git commit -m "Adding an article to week 02 of articles of the week"

5. Envía los cambios a GitHub

Para enviar los cambios a GitHub, debemos identificar el nombre del repositorio remoto.

$ git remote

Para este repositorio el nombre es "origin".

Luego de identificar el nombre podemos enviar en forma segura los cambios a GitHub.

git push origin [Nombre de la Rama]

6. Crea un pull request

Ve a tu repositorio en GitHub y verás un botón llamado "Pull request", has clic en él.

Por favor, provee todos los detalles necesarios de lo que has hecho (puedes referenciar problemas utilizando "#"). Ahora, envía el pull request.

¡Felicitaciones! Has hecho tu primer pull request.

Si tu pull request es aceptado recibirás un mail.

7. Sincroniza tu rama maestra con la del repositorio original

Antes de enviar cualquier pull request al repositorio original debes sincronizar tu repositorio con aquel.

Incluso si no vas a enviar un pull request al repositorio original, es mejor efectuar la sincronización, ya que pueden haberse agregado algunas prestaciones o funciones adicionales y haberse corregido algunos errores desde la vez que realizaste un fork de aquel repositorio.

Sigue estos pasos para actualizar/sincronizar aquellos cambios con tu rama maestra:

1. Primero, revisa en que rama estás ubicado.

$ git branch

Esto enumerará todas las ramas y indicará en verde la rama actual o activa.

2. Cambia a la rama maestra.

$ git checkout master

3. Agrega el repositorio original como un repositorio upstream.

Para poder extraer los cambios desde el repositorio original a tu versión local, necesitas agregar el repositorio Git original como un repositorio upstream.

$ git remote add upstream [HTTPS]

Aquí, [HTTPS] es el URL que debes copiar del repositorio del propietario.

4. Busca (fetch) el repositorio.

Busca todos los cambios  del repositorio original. Las confirmaciones (commits) del repositorio original serán almacenadas en una rama local llamada upstream/master.

$ git fetch upstream

5. Fusionala.

Fusiona los cambios de la rama upstream/master a tu rama maestra local. Esto hará que tu rama maestra se sincronice con el repositorio upstream sin perder tus cambios locales.

$ git merge upstream/master

6. Envía (push) los cambios a GitHub

En este punto tu rama local está sincronizada con la rama maestra del repositorio original. Si deseas actualizar el repositorio de GitHub, necesitas enviar tus cambios.

$ git push origin master

NOTA: Luego de sincronizar tu rama maestra puedes eliminar el repositorio upstream, si lo desea. Pero lo necesitará para actualizar/sincronizar tu repositorio en el futuro, por lo que es una buena práctica conservarlo.

$ git remote rm [Nombre del Repositorio Remoto]

8. Elimina ramas innecesarias

Las ramas son creadas para propósitos especiales. Una vez que ese propósito se cumple, aquellas ramas ya no son necesarias, por lo que puedes eliminarlas.

$ git branch -d [Nombre de la Rama]

También, puedes eliminar su versión en GitHub.

git push origin --delete [Nombre de la Rama]

Conclusión

GitHub es una poderosa herramienta para controlar el historial de versiones. Todos pueden contribuir a proyectos de código abierto mediante pull requests. Las contribuciones no siempre son un código; también hay otras formas de contribuir.

Finalmente, debo decirte que no debes preocuparte si tus pull requests son rechazadas. Los encargados de los proyectos dedican mucho tiempo a mejorarlos y saben mucho más sobre sus proyectos que nosotros. Así que no te preocupes si tu solicitud no es tenida en cuenta.

Mantente fuerte, positivo y nunca te rindas.
― Roy T. Bennett, The Light in the Heart

Este artículo fue originalmente publicado en Medium.

Puedes contactarme y conectar conmigo en Twitter.

¡Sigue contribuyendo al mundo del código abierto!

Traducido del arículo de Thanoshan MV - How to make your first pull request on GitHu

Hola! Soy Sanjula, y en esta guía espero poder enseñarte un poco acerca de Git incluyendo:

• Qué es Git
• Porqué aprender Git
• Establecer variables de configuración
• Introducción al comando help en Git
• Cómo convertir un proyecto existente en un repositorio de Git local
• Cosas que hacer antes del primer commit
• Cómo agregar archivos al área de preparación (staging area)
• Cómo eliminar archivos del área de preparación
• Realizar tu primer commit
• Cómo clonar un repositorio remoto
• Ver información sobre el respositorio remoto
• Cómo enviar (push) tus cambios al repositorio remoto
• Como crear una rama (branch) para una prestación o problema específico
• Enviar la rama al repositorio remoto luego de ejecutar el comando commit
• Cómo fusionar (merge) una rama
• Cómo eliminar una rama

¡Empecemos!

¿Qué es Git?

En términos sencillos, Git es un sistema de control de versiones distribuido de código abierto.

Los sistemas de control de versiones ayudan a cualquier equipo de software a gestionar cambios en el código fuente de un producto o servicio a lo largo del tiempo. Realiza un seguimiento de todas las modificaciones al código fuente en una base de datos. Si se ha cometido un error crítico en el código fuente, los desarrolladores de un equipo de software pueden retrotraer el código fuente a una versión antes de que se realizara el cambio erróneo. Como resultado, los sistemas de control de versiones protegen el código fuente de desastres, errores humanos y consecuencias no deseadas (cuando una corrección de errores rompe otra parte de la aplicación, por ejemplo).

Entonces, ¿Porqué aprender Git?

Git es el sistema de control de versiones más utilizado en el mundo actualmente. Es un proyecto de código abierto maduro y mantenido activamente, desarrollado originalmente por Linus Torvalds.

Una cantidad asombrosa de proyectos de software dependen de Git para el control de versiones, incluidos proyectos comerciales y de código abierto, especialmente utilizando el servicio de alojamiento de repositorios de git, GitHub, que ahora es propiedad de Microsoft. De ahí la importancia de aprender Git.

Prerrequisitos para esta guía

Descarga e instala git desde aquí

Verifica la versión de git

git --version

Si el número de versión es devuelto, entonces significa que git ha sido instalado exitosamente en tu computador.

Estableciendo los valores de configuración

Ahora debemos establecer las variables de configuración global, que son muy importantes, especialmente si estás trabajando con otros desarrolladores. La principal ventaja de esto es que es más fácil averiguar quién ha hecho un commit de determinado bloque de código, por ejemplo.

git config --global user.name “Sanjula Madurapperuma”

git config --global user.email “sanjula@mail.com”

git config --list

Comando help

Como puedes notar, config es un verbo que se ha usado con frecuencia hasta ahora en este manual y los verbos también se pueden usar como prefijo o sufijo con el comando help. Podemos usar el mismo ejemplo (el verbo config) de arriba para explicar estos comandos.

git help config

git config --help

Los dos comandos indicados realizan la misma acción. Muestran la página de manual del verbo especificado. Esto será útil para identificar capacidades más avanzadas de git.

Cómo inicializar un repositorio a partir de código existente

Si tienes un repositorio local que deseas convertir en un proyecto git para comenzar a rastrearlo, entonces podemos comenzar ejecutando el comando de abajo dentro del directorio del proyecto.

git init

¡Listo! Así, has convertido tu proyecto en un repositorio local de git. Si abres la carpeta del proyecto, verás que se ha creado un nuevo directorio llamado .git.

Que hacer antes del primer commit

Ingresa el siguiente comando para ver los archivos sin seguimiento (untracked files):

git status

Si hay archivos que no deseas que otras personas vean en el repositorio, como archivos que contienen preferencias personales o las del IDE, has lo siguiente:

touch .gitignore

Para especificar qué archivos no se agregarán al repositorio de git, abre en un editor de texto el archivo .gitignore, que se puede editar como un archivo de texto normal. Ahora podemos ingresar lo siguiente en el archivo, por ejemplo:

.project

*.java

También se pueden utilizar caracteres comodín. En este caso, se ha utilizado para especificar que no se agreguen todos los archivos que terminan con la extensión .java al repositorio.

Ahora ejecuta nuevamente git status

Ahora puedes ver que los archivos que indicamos en el archivo .gitignore ya no se muestran en la lista de archivos sin seguimiento. El archivo .gitignore debe confirmarse (usando el comando commit) en el repositorio para mantener las mismas exclusiones en todos los demás lugares.

Agregando archivos al área de preparación (staging area)

Todo este tiempo estuvimos en el directorio de trabajo. El área de preparación es donde organizamos todos los archivos que se rastrean y deben confirmarse antes de enviarlos al repositorio de git. Es un archivo que almacena lo que se debe incluir en la próxima confirmación.

Si deseas agregar todos los archivos que actualmente  están sin seguimiento y has cambiado al área de preparación, usa el siguiente comando:

git add -A

Si deseas agregar archivos individualmente, podemos indicar el nombre del archivo después de git add. Por ejemplo,

git add .gitignore

Ahora, si escribes git status, verás que el archivo .gitignore está en el área de preparación.

Eliminando archivos del área de preparación

Para eliminar archivos del área de preparación de manera individual, escribe lo siguiente (por ejemplo):

git reset simple.py

Esto eliminará el archivo simple.py del área de preparación. Para ver este cambio, escribe nuevamente el comando git status.

Si deseas eliminar todos los archivos del área de preparación, entonces ejecuta lo siguiente:

git reset

Ahora, si escribes git status, veremos que todos los archivos han cambiado a archivos sin seguimiento.

Ejecutando el primer commit

Ahora ejecuta lo siguiente para agregar todos los archivos al área de preparación para ser confirmados.

git add -A

Si lo deseas, puedes ejecutar git status para ver todos los archivos que serán confirmados.

Para realizar un commit, escribe lo siguiente.

git commit -m “Initial Commit”

“-m” especifica un mensaje que se debe pasar describiendo la confirmación. Dado que este es nuestro primer commit, escribiremos Initial Commit.

Como puedes ver, el commit se ha ejecutado correctamente.

Si ahora ejecutas git status, verás que se indica que el directorio de trabajo está limpio ya que se han confirmado todos los archivos y no se ha modificado ninguno desde entonces.

Si ejecutamos el siguiente comando:

git log

luego podemos ver el commit que habiamos ejcutado, incluyendo el número hash del commit.

¡Ahora estamos rastreando exitosamente el proyecto local con git!

Clonando un repositorio remoto

Si queremos rastrear un proyecto remoto existente con git, entonces tenemos que escribir un comando en el siguiente formato:

git clone <url> <directorio donde clonar>

A modo de ejemplo, usaré el repositorio de git en este enlace.

Primero me ubicaré en el directorio donde quiero clonar el proyecto, aunque puedes especificar esto tal como se muestra arriba.

Ve al enlace del repositorio indicado antes y has clic en "Code", luego copia el url que figura.

Luego escribe:

git clone https://github.com/sanjulamadurapperuma/GitDemoMedium.git

De esta forma hemos clonado el repositorio exitosamente.

Si ingresamos el siguiente comando, veremos todos los archivos que ahora están en el directorio local.

ls -la

Viendo información sobre el repositorio remoto

Si escribes el siguiente comando:

git remote -v

Este comando enumerará las ubicaciones de donde el repositorio local obtendrá los cambios realizados externamente y a dónde serán enviadas tus confirmaciones o cambios que realices al repositorio remoto.

Si escribes el comando:

git branch -a

Esto enumerará todas las ramas que se encuentran en el repositorio, tanto local como remotamente.

Para demostrar la actualización del repositorio remoto, haremos algunos cambios en los archivos del repositorio que clonamos.

Ahora que hemos realizado un cambio en nuestro código, la siguiente acción que debemos realizar es enviar estos cambios al repositorio remoto.

Enviando los cambios al repositorio remoto

El siguiente comando mostrará todos los cambios que se han hecho a los archivos.

git diff

Si ingresamos git status de nuevo, veremos que se han rastreado cambios y que simple.py ha sido modificado.

Ahora agrégalos al área de preparación

git add -A

Ejecuta git status nuevamente

Ahora vemos que simple.py esta listo para ser confirmado.

Luego escribe el comando commit con un mensaje

git commit -m “Updated hello function”

Ahora debemos enviar los cambios confirmados al repositorio remoto para que otras personas tengan acceso a ellos.

Dado que lo común es que hay varios desarrolladores trabajando en un solo proyecto, primero tenemos que extraer cualquier cambio que se haya realizado en el repositorio remoto antes de enviar nuestros cambios para evitar conflictos.

Ejecuta el siguiente comando:

git pull origin master

Como ya estamos actualizados, ahora podemos enviar nuestros cambios al repositorio remoto.

Ahora ejecuta lo siguiente:

git push origin master

¡Hemos enviado con éxito nuestros cambios a la rama principal del repositorio remoto!

Creando una rama para una prestación o problema especifico

Hasta ahora hemos estado trabajando en nuestra rama maestra o principal, pero no es así como deberías trabajar en git como desarrollador porque la rama maestra debe ser una versión estable del proyecto en el que estás trabajando. Entonces, para cada prestación o problema, generalmente es la norma crear tu propia rama y luego trabajar sobre esa rama.

El comando para crear una nueva rama llamada simple-greeting es el siguiente:

git branch simple-greeting

Ahora si ejecutas

git branch

luego verás todas las ramas del repositorio, y la rama en la que tu estás ubicado se encuentra resaltada con un asterisco del lado izquierdo

Si deseas cambiarte a la rama recientemente creada por ti, escribe lo siguiente:

git checkout simple-greeting

Ahora, si escribes git branch verás que ahora te encuentras en la rama simple-greeting.

Ahora debemos realizar los cambios en el proyecto. Nos dirigimos al archivo y definimos la función greeting.

Ahora repetimos el proceso para confirmar estos cambios:

git status

git add -A

git commit -m “Greeting Function”

Este commit solo cambiará los archivos en la rama simple-greeting local, no habiendo alterado aún la rama master local ni el repositorio remoto.

Enviando la rama al repositorio remoto luego de efectuar una confirmación

Ingresa el siguiente comando:

git push -u origin simple-greeting

donde origin es el nombre del respositorio y simple-greeting es la rama que le queremos enviar.

Ahora hemos enviado la rama simple-greeting al repositorio remoto. Si escribes:

git branch -a

Ahora vemos que en nuestro repositorio remoto tenemos la rama simple-greeting. ¿Porqué debemos enviar la rama al repositorio remoto? Porque en algunas empresas es allí donde ejecutan sus pruebas unitarias y en otras para asegurarse de que el código se ejecute bien antes de fusionarse con la rama maestra.

Dado que todas la prueban ha sido exitosas (no entraremos en detalles de eso aquí), ahora podemos fusionar la rama simple-greeting con la rama principal.

Fusionando una rama

Primero, debemos ubicarnos (checkout) en la rama maestra local

git checkout master

Extraemos todos los cambios de la rama maestra remota:

git pull origin master

Ahora veremos todas las ramas que hemos fusionado hasta ahora:

git branch —-merged

la rama simple-greeting no figurará ya que aún no la hemos fusionado.

Para fusionar simple-greeting con la principal, ingresa:

git merge simple-greeting

(Ten en cuenta que ahora estamos en la rama maestra)

Ahora que ha sido fusionada, podemos enviar los cambios a la rama maestra del repositorio remoto.

git push origin master

Ahora los cambios han sido enviados a la rama maestra del repositorio remoto.

Eliminando una rama

Dado que la función o la nueva prestación ya se ha implementado, podemos eliminar la rama simple-greeting. Para verificar la fusión realizada en la sección anterior, podemos ejecutar:

git branch --merged

Si simple-greeting se muestra aquí, eso significa que hemos fusionado todos los cambios y que la rama ya puede ser descartada.

git branch -d simple-greeting

Ahora la rama ha sido eliminada localmente.

Pero como la hemos enviado al repositorio remoto, aún continua ahí. Esto puede ser visto ejecutando:

git branch -a

Para eliminar la rama del repositorio remoto, escribe:

git push origin --delete simple-greeting

Si volvemos a ejecutar

git branch -a

Podemos ver que la rama ahora a sido eliminada también del repositorio remoto.

¡¡Felicitaciones!! ¡Ahora eres un maestro en los comandos básicos pero críticos de Git!

Para referencia o uso de este tutorial, aquí está el enlace del repositorio público de GitHub

Traducido del artículo de Sanjula Madurapperuma - The Essential Git Handbook