Instalación de Anaconda en Ubuntu


Diseñado para los flujos de trabajo de ciencia de los datos y aprendizaje automático, Anaconda es un gestor de paquetes de código abierto, gestor de entornos y distribución de los lenguajes de programación Python y R.

En efecto Conda es un gestor de paquetes y un sistema de gestión de entornos de código abierto,multiplataforma y de lenguaje agnóstico publicado bajo la licencia BSD. Está escrito en el lenguaje de programación Python, pero puede gestionar proyectos que contengan código escrito en otros lenguajes, como R, así como proyecto multilenguaje. Conda puede instalar la versión de Python que se necesite en el entorno de desarrollo, al contrario que otros gestores de paquetes basados en Python, como pip o wheel.

Cuenta con «canales» (channels), que son las ubicaciones de los repositorios en los que Conda busca paquetes. Debido a que los canales se organizan jerárquicamente, al instalar un paquete Conda comprobará qué canal tiene el mayor índice de prioridad; este orden de prioridad se puede cambiar, así como también añadir nuevos canales. Los canales que se establecen por defecto son los repositorios de Continuum. Existen canales más generales, que ofrecen una amplia gama de paquetes, como conda-forge; y otros más específicos, como Bioconda, que proporciona paquetes especializados en bioinformática.

Conda está incluido en todas las versiones de Anaconda, Miniconda ​ y Anaconda Repository.

Obtención de la versión más reciente de Anaconda

Prerrequisitos

  • Una cuenta de usuario con  privilegios de sudo 
  • Acceso a una línea de comando / ventana de terminal (Ctrl-Alt-T)

Actualice el Administrador de paquetes local

Empiece por actualizar el administrador de paquetes local. Abra una ventana de terminal e ingrese lo siguiente:

sudo apt-get update

Si su sistema no tiene curl , instálelo ingresando:

sudo apt-get install curl

Descargue la última versión de Anaconda

En el momento en que se escribió este artículo, la última versión de Anaconda es 2020.02. Consulte la página de descarga del desarrollador para ver la versión más reciente.

https://www.anaconda.com/distribution/

Busque la versión más reciente para Linux y copie la secuencia de comandos bash del instalador.

Anote la URL y utilícela para descargar la versión correcta.

Cambie al directorio / tmp y use curl para descargar el instalador usando su terminal de comando:

cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh

Esta versión está diseñada para Python 3.7. Si está utilizando Python 2.7, utilice la URL adecuada.

Verificar la suma de comprobación de descarga

Checksum es una herramienta de seguridad que se utiliza para verificar la autenticidad e integridad de un script descargado.

Introduzca la siguiente:

sha256sum Anaconda3–2020.02–Linux–x86_64.sh

Su sistema mostrará una serie de letras y números:

69581cf739365ec7fb95608eef694ba959d7d33b36eb961953f2b82cb25bdf5a Anaconda3-2019.07-Linux-x86_64.sh

Compárelos con la suma de comprobación apropiada (o hash ) en la documentación de Anaconda . Si ha elegido una versión diferente, asegúrese de consultar la documentación para ver la suma de comprobación de esa versión.

Ejecución de la secuencia de comandos de Anaconda

Una vez que acepte la licencia, se le pedirá que seleccione la ubicación de la instalación. Puede pulsar ENTER para aceptar la ubicación predeterminada o especificar una ubicación diferente.


bash Anaconda3-2019.03-Linux-x86_64.sh

Recibirá el siguiente resultado para revisar el acuerdo de licencia pulsando ENTER hasta llegar al final.

Output
Welcome to Anaconda3 2019.03

In order to continue the installation process, please review the license
agreement.
Please, press ENTER to continue
>>>
...
Do you approve the license terms? [yes|no]

Cuando llegue al final de la licencia, escriba yes, si acepta la licencia, para completar la instalación.

En este momento, se procederá con la instalación. Tenga en cuenta que el proceso puede tardar un tiempo.

Cuando se complete la instalación, recibirá el siguiente resultado:

Output...
installation finished.
Do you wish the installer to prepend the Anaconda3 install location
to PATH in your /home/sammy/.bashrc ? [yes|no]
[no] >>> 

Se recomienda que escriba yes para usar el comando conda.

Activación de la instalación

Ahora, puede activar la instalación con el siguiente comando:

source ~/.bashrc

Instalación de prueba

Utilice el comando conda para probar la instalación y la activación:

conda list

Recibirá el resultado de todos los paquetes que tiene disponibles a través de la instalación de Anaconda.

Configuración de los entornos de Anaconda

Puede crear entornos de Anaconda con el comando conda create. Por ejemplo, se puede crear un entorno de Python 3 llamado my_envcon el siguiente comando:

conda create --name my_env python=3

Active el nuevo entorno de esta manera:

conda activate my_env

El prefijo de instrucción de su comando cambiará para reflejar que está en un entorno de Anaconda activo, y que, ahora, está listo para empezar a trabajar en un proyecto.

Visualización de series temporales con Python 3


El análisis de series de tiempo pertenece a una rama de la estadística que implica el estudio de datos ordenados, a menudo temporales. Cuando se aplica de manera relevante, el análisis de series de tiempo puede revelar tendencias inesperadas, extraer estadísticas útiles e incluso pronosticar tendencias en el futuro. Por estas razones, se aplica en muchos campos, incluidos la economía, la previsión meteorológica y la planificación de la capacidad, por nombrar algunos.

En este tutorial, presentaremos algunas técnicas comunes utilizadas en el análisis de series de tiempo y recorreremos los pasos iterativos necesarios para manipular y visualizar datos de series de tiempo.

Para este tutorial, usaremos Jupyter Notebook para trabajar con los datos. Si aún no lo tiene, debe seguir nuestro tutorial para instalar y configurar Jupyter Notebook para Python 3 .

Instalación de paquetes

Aprovecharemos la pandasbiblioteca, que ofrece mucha flexibilidad a la hora de manipular datos, y la statsmodelsbiblioteca, que nos permite realizar cálculos estadísticos en Python. Utilizadas juntas, estas dos bibliotecas amplían Python para ofrecer una mayor funcionalidad y aumentar significativamente nuestro conjunto de herramientas analíticas.

Al igual que con otros paquetes de Python, podemos instalar pandasy statsmodelscon pip. Primero, pasemos a nuestro entorno de programación local o entorno de programación basado en servidor:


 cd environments 

 . my_env/bin/activate 

Desde aquí, creemos un nuevo directorio para nuestro proyecto. Lo llamaremos timeseriesy luego pasaremos al directorio. Si llama al proyecto con un nombre diferente, asegúrese de sustituir su nombre en timeseriestoda la guía.


 mkdir timeseries 
 cd timeseries 

Ahora podemos instalar pandas, statsmodelsy el paquete de trazado de datos matplotlib. También se instalarán sus dependencias:


 pip install pandas statsmodels matplotlib 

En este punto, estamos listos para comenzar a trabajar con pandasy statsmodels.

Carga de datos de series de tiempo

Para comenzar a trabajar con nuestros datos, iniciaremos Jupyter Notebook:


 jupyter notebook 

Para crear un nuevo archivo de cuaderno, seleccione Nuevo > Python 3 en el menú desplegable de la parte superior derecha:

Crea un nuevo cuaderno de Python 3

Esto abrirá un cuaderno que nos permite cargar las bibliotecas requeridas (observe las abreviaturas estándar que se usan para hacer referencia pandas, matplotliby statsmodels). En la parte superior de nuestro cuaderno, debemos escribir lo siguiente:

import pandas as pd
import statsmodels.api as sm
import matplotlib.pyplot as plt

Después de cada bloque de código en este tutorial, debe escribir ALT + ENTERpara ejecutar el código y pasar a un nuevo bloque de código dentro de su computadora portátil.

Convenientemente, statsmodelsviene con conjuntos de datos integrados, por lo que podemos cargar un conjunto de datos de series de tiempo directamente en la memoria.

Trabajaremos con un conjunto de datos llamado “CO2 atmosférico de muestras de aire continuo en el Observatorio Mauna Loa, Hawái, EE. UU.”, Que recolectó muestras de CO2 desde marzo de 1958 hasta diciembre de 2001. Podemos traer estos datos de la siguiente manera:

data = sm.datasets.co2.load_pandas()
co2 = data.data

Veamos cómo se ven las primeras 5 líneas de nuestros datos de series de tiempo:

print(co2.head(5))

       
        Output
                     co2
1958-03-29  316.1
1958-04-05  317.3
1958-04-12  317.6
1958-04-19  317.5
1958-04-26  316.4

Con nuestros paquetes importados y el conjunto de datos de CO2 listo para usar, podemos pasar a indexar nuestros datos.

Indexación con datos de series de tiempo

Es posible que haya notado que las fechas se han establecido como el índice de nuestro pandasDataFrame. Cuando trabajemos con datos de series de tiempo en Python, debemos asegurarnos de que las fechas se usen como índice, así que asegúrese de verificarlo siempre, lo que podemos hacer ejecutando lo siguiente:

co2.index

       
        Output
       DatetimeIndex(['1958-03-29', '1958-04-05', '1958-04-12', '1958-04-19',
               '1958-04-26', '1958-05-03', '1958-05-10', '1958-05-17',
               '1958-05-24', '1958-05-31',
               ...
               '2001-10-27', '2001-11-03', '2001-11-10', '2001-11-17',
               '2001-11-24', '2001-12-01', '2001-12-08', '2001-12-15',
               '2001-12-22', '2001-12-29'],
              dtype='datetime64[ns]', length=2284, freq='W-SAT')

El dtype=datetime[ns]campo confirma que nuestro índice está hecho de objetos de sello de fecha, mientras que length=2284y freq='W-SAT'nos dice que tenemos 2284 sellos de fecha semanales a partir de los sábados.

Puede ser complicado trabajar con datos semanales, así que usemos los promedios mensuales de nuestra serie temporal. Esto se puede obtener utilizando la resamplefunción conveniente , que nos permite agrupar la serie de tiempo en cubos (1 mes), aplicar una función en cada grupo (media) y combinar el resultado (una fila por grupo).

y = co2['co2'].resample('MS').mean()

Aquí, el término MSsignifica que agrupamos los datos en depósitos por meses y asegura que estamos usando el inicio de cada mes como marca de tiempo:

y.head(5)

       
        Output
       1958-03-01    316.100
1958-04-01    317.200
1958-05-01    317.120
1958-06-01    315.800
1958-07-01    315.625
Freq: MS, Name: co2, dtype: float64

Una característica interesante de pandases su capacidad para manejar índices de sello de fecha, lo que nos permite dividir rápidamente nuestros datos. Por ejemplo, podemos dividir nuestro conjunto de datos para recuperar solo los puntos de datos que vienen después del año 1990:

y['1990':]

       
        Output
       1990-01-01    353.650
1990-02-01    354.650
               ...   
2001-11-01    369.375
2001-12-01    371.020
Freq: MS, Name: co2, dtype: float64

O podemos dividir nuestro conjunto de datos para recuperar solo puntos de datos entre octubre 1995y octubre 1996:

y['1995-10-01':'1996-10-01']

       
        Output
       1995-10-01    357.850
1995-11-01    359.475
1995-12-01    360.700
1996-01-01    362.025
1996-02-01    363.175
1996-03-01    364.060
1996-04-01    364.700
1996-05-01    365.325
1996-06-01    364.880
1996-07-01    363.475
1996-08-01    361.320
1996-09-01    359.400
1996-10-01    359.625
Freq: MS, Name: co2, dtype: float64

Con nuestros datos correctamente indexados para trabajar con datos temporales, podemos pasar al manejo de valores que pueden faltar.

Manejo de valores perdidos en datos de series de tiempo

Los datos del mundo real tienden a ser confusos. Como podemos ver en el gráfico, no es raro que los datos de series de tiempo contengan valores perdidos. La forma más sencilla de verificarlos es trazando directamente los datos o usando el comando a continuación que revelará los datos faltantes en la salida:

y.isnull().sum()

       
        Output
       5

Esta salida nos dice que hay 5 meses con valores perdidos en nuestra serie de tiempo.

Generalmente, deberíamos “completar” los valores faltantes si no son demasiado numerosos para que no tengamos lagunas en los datos. Podemos hacer esto pandasusando el fillna()comando . Para simplificar, podemos completar los valores perdidos con el valor no nulo más cercano en nuestra serie de tiempo, aunque es importante tener en cuenta que a veces sería preferible una media móvil.

y = y.fillna(y.bfill())

Con los valores faltantes completados, podemos verificar una vez más si existen valores nulos para asegurarnos de que nuestra operación funcionó:

y.isnull().sum()

       
        Output
       0

Después de realizar estas operaciones, vemos que hemos completado con éxito todos los valores faltantes en nuestra serie de tiempo.

Visualización de datos de series de tiempo

Cuando se trabaja con datos de series de tiempo, se pueden revelar muchas cosas mediante su visualización. Algunas cosas a tener en cuenta son:

  • estacionalidad : ¿los datos muestran un patrón periódico claro?
  • Tendencia : ¿los datos siguen una pendiente constante hacia arriba o hacia abajo?
  • ruido : ¿hay puntos atípicos o valores perdidos que no son consistentes con el resto de los datos?

Podemos usar el pandascontenedor alrededor de la matplotlibAPI para mostrar un gráfico de nuestro conjunto de datos:

y.plot(figsize=(15, 6))
plt.show()
Visualización de series temporales Figura 1

Aparecen algunos patrones distinguibles cuando graficamos los datos. La serie temporal tiene un patrón de estacionalidad obvio, así como una tendencia general creciente. También podemos visualizar nuestros datos usando un método llamado descomposición de series de tiempo. Como sugiere su nombre, la descomposición de series de tiempo nos permite descomponer nuestra serie de tiempo en tres componentes distintos: tendencia, estacionalidad y ruido.

Afortunadamente, statsmodelsproporciona la seasonal_decomposefunción conveniente para realizar la descomposición estacional de forma inmediata. Si está interesado en obtener más información, la referencia para su implementación original se puede encontrar en el siguiente documento, ” STL: Un procedimiento de descomposición de tendencia estacional basado en Loess “.

El siguiente script muestra cómo realizar la descomposición estacional de series de tiempo en Python. De forma predeterminada, seasonal_decomposedevuelve una figura de tamaño relativamente pequeño, por lo que las dos primeras líneas de este fragmento de código aseguran que la figura de salida sea lo suficientemente grande para que podamos visualizarla.

from pylab import rcParams
rcParams['figure.figsize'] = 11, 9

decomposition = sm.tsa.seasonal_decompose(y, model='additive')
fig = decomposition.plot()
plt.show()
Visualización de descomposición de tendencias estacionales de series temporales Figura 2

El uso de la descomposición de series de tiempo facilita la identificación rápida de una media cambiante o una variación en los datos. El gráfico anterior muestra claramente la tendencia al alza de nuestros datos, junto con su estacionalidad anual. Estos se pueden utilizar para comprender la estructura de nuestra serie temporal. La intuición detrás de la descomposición de series de tiempo es importante, ya que muchos métodos de pronóstico se basan en este concepto de descomposición estructurada para producir pronósticos.

Si ha seguido este post, ahora tiene experiencia visualizando y manipulando datos de series de tiempo en Python.

Para mejorar aún más su conjunto de habilidades, puede cargar otro conjunto de datos y repetir todos los pasos vistos, como por ejemplo, es posible que desee leer un archivo CSV con la biblioteca pandaso utilizar el conjunto de datos sunspotsque viene pre-cargado con la statsmodels biblioteca: data = sm.datasets.sunspots.load_pandas().data.

Cómo importar módulos en Python 3


En este post vamos a ver como haciendo uso de módulos nos permite hacer que nuestros programas sean más robustos y poderosos a medida que aprovechamos el código existente. También podemos crear nuestros propios módulos para nosotros y para que otros programadores los utilicen en programas futuros.

El lenguaje de programación Python viene con una variedad de funciones integradas . Entre estas se encuentran varias funciones comunes, que incluyen:

  • print() que imprime expresiones
  • abs() que devuelve el valor absoluto de un número
  • int() que convierte otro tipo de datos en un entero
  • len() que devuelve la longitud de una secuencia o colección

Sin embargo, estas funciones integradas son limitadas y podemos hacer uso de módulos para hacer programas más sofisticados.

Los módulos son archivos con extension .py de Python que constan lógicamente de código Python. Se puede hacer referencia a cualquier archivo de Python como módulo. Un archivo de Python llamado hello.py tiene el nombre de módulo hello que puede importarse a otros archivos de Python o usarse en el intérprete de línea de comandos de Python.

Los módulos pueden definir funciones , clases y variables a las que puede hacer referencia en otros archivos .py de Python o mediante el intérprete de línea de comandos de Python.

En Python, se accede a los módulos mediante la instrucción import . Cuando hacemos esto, ejecutamos el código del módulo, manteniendo los alcances de las definiciones para que tus archivos actuales puedan hacer uso de estos.

Cuando Python importa un módulo llamado, hello por ejemplo, el intérprete primero buscará un módulo incorporado llamado hello. Si no se encuentra un módulo integrado, el intérprete de Python buscará un archivo nombrado hello.py en una lista de directorios que recibe de la variable sys.path.

Vamos a ver la verificación e instalación de módulos, la importación de módulos y los módulos de alias.

Comprobación e instalación de módulos

Hay varios módulos que están integrados en la biblioteca estándar de Python , que contiene muchos módulos que brindan acceso a la funcionalidad del sistema o brindan soluciones estandarizadas. La biblioteca estándar de Python es parte de cada instalación de Python.

Para comprobar que estos módulos de Python están listos para funcionar, ingrese a su entorno de programación Python 3 local o al entorno de programación basado en servidor e inicie el intérprete de Python en su línea de comando así:


 python 

Desde dentro del intérprete, puede ejecutar la declaración import para asegurarse de que el módulo dado esté listo para ser llamado, como en:


 import math 

Dado que math es un módulo integrado, su intérprete debe completar la tarea sin comentarios, volviendo a la indicación. Esto significa que no necesita hacer nada para comenzar a usar el módulo math.

Ejecutemos la declaración import con un módulo que quizás no haya instalado, como la biblioteca de trazado 2D matplotlib:


 import matplotlib 

Si matplotlib no está instalado, recibirá un error como este:

       
        Output
       ImportError: No module named 'matplotlib'

Puede desactivar el intérprete de Python con CTRL + D y luego instalarlo matplotlibcon pip.

A continuación, podemos utilizar pip para instalar el módulo matplotlib:


 pip install matplotlib 

Una vez que esté instalado, puede importar matplotlib en el intérprete de Python usando import matplotlib, y se completará sin errores.

Importación de módulos

Para hacer uso de las funciones de un módulo, deberá importar el módulo con una declaración import

Una declaracion import se compone de la palabra clave import junto con el nombre del módulo.

En un archivo de Python, esto se declarará en la parte superior del código, debajo de las líneas shebang o comentarios generales.

Entonces, en el archivo de programa de Python my_rand_int.py importaríamos el modulo random para generar números aleatorios de esta manera: my_rand_int.py

import random

Cuando importamos un módulo, lo ponemos a nuestra disposición en nuestro programa actual como un espacio de nombres separado. Esto significa que tendremos que referirnos a la función en notación de puntos, como en [module].[function].

En la práctica, con el ejemplo del módulo random, esto puede parecer una función como:

  • random.randint() que llama a la función para devolver un entero aleatorio, o
  • random.randrange() que llama a la función para devolver un elemento aleatorio de un rango especificado.

Creemos un ciclo for para mostrar cómo llamaremos a una función del módulo random dentro de nuestro programa: my_rand_int.py

import random


for i in range(10):
    print(random.randint(1, 25))

Este pequeño programa primero importa el módulo random en la primera línea, luego se mueve a un ciclo for que trabajará con 10 elementos. Dentro del ciclo, el programa imprimirá un número entero aleatorio dentro del rango de 1 a 25 (inclusive). Los enteros 1 y 25se pasan a random.randint()como sus parámetros.

Cuando ejecutamos el programa con python my_rand_int.py, recibiremos 10 enteros aleatorios como salida. Debido a que estos son aleatorios, es probable que obtenga diferentes enteros cada vez que ejecute el programa, pero se verán así:


       
        Output
       6
9
1
14
3
22
10
1
15
9

Los números enteros nunca deben estar por debajo de 1 o por encima de 25.

Si desea utilizar funciones de más de un módulo, puede hacerlo agregando varias declaraciones import a my_rand_int.py

import random
import math

Es posible que vea programas que importan varios módulos con comas que los separan, como en import random, math, pero esto no es coherente con la Guía de estilo de PEP 8 .

Para hacer uso de nuestro módulo adicional, podemos agregar la constante pi de math a nuestro programa y disminuir el número de enteros aleatorios impresos: my_rand_int.py

import random
import math


for i in range(5):
    print(random.randint(1, 25))

print(math.pi)

Ahora, cuando ejecutamos nuestro programa, recibiremos una salida que se ve así, con una aproximación de pi como nuestra última línea de salida:


       
        Output
       18
10
7
13
10
3.141592653589793

La declaración import le permite importar uno o más módulos a su programa Python, permitiéndole hacer uso de las definiciones construidas en esos módulos.

Usando fromimport

Para hacer referencia a elementos de un módulo dentro del espacio de nombres de su programa, puede usar la declaración fromimport. Cuando importa módulos de esta manera, puede hacer referencia a las funciones por su nombre en lugar de mediante la notación de puntos

En esta construcción, puede especificar qué definiciones hacer referencia directamente.

En otros programas, puede ver que la declaración import toma referencias a todo lo definido dentro del módulo mediante el uso de un asterisco ( *) como comodín, pero PEP 8 lo desaconseja. .

Primero veamos la importación de una función específica, randint()desde el módulo random en my_rand_int.py

from random import randint

Aquí, primero llamamos a la palabra clave from, luego al módulo random. A continuación, usamos la palabra clave import y llamamos a la función específica que nos gustaría usar.

Ahora, cuando implementemos esta función dentro de nuestro programa, ya no escribiremos la función en notación de puntos como, random.randint()sino que simplemente escribiremos randint() en my_rand_int.py

from random import randint


for i in range(10):
    print(randint(1, 25))

Cuando ejecute el programa, recibirá un resultado similar al que recibimos anteriormente.

Usando la construcción fromimport nos permite hacer referencia a los elementos definidos de un módulo dentro del espacio de nombres de nuestro programa, lo que nos permite evitar la notación de puntos.

Módulos de aliasing

Es posible modificar los nombres de los módulos y sus funciones dentro de Python usando la palabra clave as.

Es posible que desee cambiar un nombre porque ya ha usado el mismo nombre para otra cosa en su programa, otro módulo que ha importado también usa ese nombre, o puede abreviar un nombre más largo que está usando mucho.

La construcción de esta declaración se ve así:

import [module] as [another_name]

Modificaremos el nombre del módulo math en nuestro archivo de programa my_math.py. Cambiaremos el nombre del módulo de matha m para abreviarlo. Nuestro programa modificado se verá así: my_math.py

import math as m


print(m.pi)
print(m.e)

Dentro del programa, ahora nos referimos a la constante pi como m.pi en lugar de math.pi .

Para algunos módulos, es habitual utilizar alias. La documentación oficial del módulomatplotlib.pyplotr equiere el uso de pltcomo alias:

import matplotlib.pyplot as plt

Esto permite a los programadores agregar la palabra más corta plt a cualquiera de las funciones disponibles dentro del módulo, como en plt.show().

.