Niveles de autonomía en coches


Estamos sin duda todos familiarizados a la conducción autónoma gracias al carismático Elon Musk y sus famosa marca Tesla Motors, pero como vamos a ver en este humilde post no todos los coches autónomos son fabricados por Tesla y además existen hasta seis niveles de automoción, lo cual sin duda nos da esperanza que en un futuro cercano desde este momento podremos adquirir un vehículo con cierto grado de atomía en pro de mejorar entre todos la seguridad en la carretera.

La conducción autónoma ha sido clasificada en seis niveles por la Sociedad de Ingenieros de Automoción (SAE, por sus siglas en inglés). La actualización más reciente es el estándar J3016.

Los tres primeros niveles de la SAE para los vehículos autónomos (0 al 2) incluyen características de asistencia al conductor. Mientras tanto, los tres últimos (3 al 5) incluyen características reales de automatización.

Nivel 0

No hay conducción autónoma, no hay control continuo del vehículo. Aquí englobamos aquellos sistemas que proporcionan un aviso al conductor (por ejemplo, un sistema de detección de objetos en el ángulo muerto o asistente al cambio de carril), un sistema de frenado automático de emergencia… hablamos, por lo tanto, de sistemas de seguridad. Por tanto en este nivel 0 de los vehículos autónomos es aplicable a los coches más comunes en la actualidad, ya que no se automatizan las acciones del conductor.

Características:

  • El conductor realiza todas las tareas y maniobras.
  • El vehículo puede incluir sensores o radares que notifican al conductor de eventos y objetos cercanos.

Limitaciones:

  • Los coches en este nivel no incluyen ningún tipo de control autónomo.

Nivel 1

Los primeros sistemas de asistencia a la conducción que han ayudado al conductor de forma continua se encuentran englobados en este Nivel 1. Son aquellos capaces de controlar el vehículo bien longitudinal o lateralmente, pero nunca las dos cosas a la vez.

La diferencia con las tecnologías consideradas de nivel 0 es que las del nivel 1 el coche realiza cambios por su cuenta. Un ejemplo son los sistemas de frenada de emergencia automática (AEB) que cuando detectan la presencia de un obstáculo moderan la velocidad sin necesidad de que el conductor presione el pedal.

Los vehículos autónomos de nivel 1 pues incluyen sistemas que controlan la dirección, la velocidad y el frenado. Muchos modelos disponibles en la actualidad incluyen funciones de este nivel, entre otras:

  • Piloto automático adaptativo (control de crucero).
  • Sistema de control de carril.
  • Asistencia de estacionamiento.
  • Control de distancia y anticolisión.
  • Sistema automático de frenado de emergencia.

Características:

  • VhAsistencia autónoma en sistemas de dirección o de velocidad.
  • El conductor sigue controlando la mayoría de las funciones del coche.
  • Se mantienen las manos en el volante.

Limitaciones:

  • Solo hay asistencia autónoma en un sistema a la vez. Asistencia en la dirección o en la velocidad, pero no en ambos en simultáneo.

MODELOS

  • El ejemplo más claro, y el primero de estos sistemas en ver la luz (1998) es el ACC – Adaptive Cruise Control. 
  • Ha habido intentos previos que solo controlaban motor (Mitsubishi)
  • Mercedes en 1998 lanzó en el Clase S un sistema capaz de ajustar la velocidad de forma automática al vehículo precedente, usando información de un radar situado en la parte frontal. Controlaba sistema de gestión de motor y sistema de frenado, liberando al conductor de la necesidad de pisar pedal alguno (dentro de unos límites) cuando el ACC se activaba.  Así, solo debía controlar la dirección, haciendo los viajes más relajados y seguros.

En un sistema ACC, como en el resto de sistemas de Nivel 1, el conductor es siempre responsable de la conducción y no puede embarcarse en ninguna actividad paralela. El sistema, simplemente, ayuda a que la conducción sea más confortable. Hoy día sistemas como ACC son legión y se pueden encontrar desde los segmentos más bajos del mercado.

NIVEL 2

Mientras en un Nivel 1 el sistema controla el vehículo longitudinal o lateralmente, en un Nivel 2 el control es longitudinal y transversal, de forma simultánea. Este pequeño matiz, sin embargo, hace que la percepción del conductor en cuanto a autonomía sea mucho may

Los vehículos autónomos nivel 2 son POR TANTO capaces de tomar el control de algunos sistemas, aunque el conductor debe estar alerta por si se necesita su intervención.

Al sistema ACC añaden un control de posición en el carril (centrado). El conductor no ha de tener los pies en los pedales (como en un sistema ACC), pero además existe un par de fuerza inducido en el volante que “guía” al vehículo al centro del carril. En ocasiones, se pueden soltar las manos del volante, y el vehículo seguirá en el centro del carril en vías de curvas amplias. 

Características:

  • Al menos dos funciones están automatizadas al mismo tiempo.
  • El coche autoconducido se mantiene en el carril y a una distancia segura de los otros elementos en la vía.
  • Se permite que el conductor deje de controlar el volante y el acelerador (conducción manos libres).
  • Estos vehículos autónomos detectan los límites del carril y de la carretera. Incluso sin necesidad de líneas o señalización en el pavimento.

Limitaciones:

  • El coche toma el control por períodos cortos de tiempo, solo de algunas funciones y bajo ciertas condiciones .
  • El conductor debe estar alerta para retomar el control si fuera necesario.

MODELOS

  • La lista de modelos que se encuentran ya en el nivel 2 de conducción autónoma es larga: son los llamados coches semiautónomos
  • Aquí hablamos de sistemas relativamente populares y que se pueden encontrar en utilitarios como un Peugeot 208
  • Mercedes en 1998 lanzó en el Clase S un sistema capaz de ajustar la velocidad de forma automática al vehículo precedente, usando información de un radar situado en la parte frontal. Controlaba sistema de gestión de motor y sistema de frenado, liberando al conductor de la necesidad de pisar pedal alguno (dentro de unos límites) cuando el ACC se activaba.  Así, solo debía controlar la dirección, haciendo los viajes más relajados y seguros.
  • Otros ejemplos reales ProPilot de Nissan
  • EL Mercedes-Benz Clase E.
  • El BMW Serie 7
  • Volvo, Mercedes, Audi y BMW son las más avanzadas en este terreno.

NIVEL 2+

Para complicar aún más las cosas, existe algo llamado Nivel 2+. No está registrado per se en la SAE, pero es un estándar de facto en la industria. ¿Y que es un Nivel 2+? Pues un Nivel 2 en el cual no se obliga al conductor a tener las manos en el volante. Sin embargo, el conductor sigue siendo responsable total de la conducción, y como tal no puede hacer ninguna tarea adicional.

Siguen siendo sistemas de asistencia. No son conducción autónoma. El conductor es responsable siempre, y para validar que está prestando atención a la conducción aun estando las manos fuera del volante, se suele usar una cámara que monitoriza al conductor (todos los mencionados arriba salvo Tesla, de momento). Si no hay atención, el sistema le recordará al conductor de hacerlo. En caso de ignorar el aviso, pasaremos al modo “parar en modo seguro”.

Estos sistemas Nivel 2+, por lo general, solo funcionan en zonas determinadas (por ejemplo, autopistas). Serían capaces de hacer más cosas (adelantamientos con o sin confirmación del conductor, etc). Pero seguirán siendo Nivel 2+… por mucho que los llevemos hasta el extremo, como Tesla con su FSD. En principio, con el FSD se podría disponer de un sistema de Nivel 2+ funcionando en aquellas zonas que Tesla haya “desbloqueado” primero, mediante el uso de mapas crowd-sourced. Y están en ello, basándose en la gran cantidad de vehículos grabando datos (vehículos de cliente). Pero seguirá siendo un Nivel 2. Por mucho que haya videos de Tesla gestionando rotondas, cruces e intersecciones en la versión beta de FSD, el conductor sigue siendo el único responsable. Es un nivel 2

MODELOS

  • El pionero fue Cadillac con su SuperCruise en US, que hoy día se encuentra hasta en un Chevrolet Bolt.
  • Después otras muchas le han seguido: BMW, NIO, Nissan (ProPilot II),
  • Próximamente Ford, Jeep, Lexus, Hyundai… y Tesla, claro.

NIVEL 3

El sistema controla el vehículo longitudinal y lateralmente, como en un nivel 2. Pero la diferencia estriba en que aquí el sistema es el que conduce el coche mientras se encuentre activado. Es decir – y aquí está la gran ventaja de un nivel 3 – el conductor podría dedicarse a realizar alguna actividad secundaria mientras esté en el coche. Pero (porque tiene que haber un pero), esta actividad secundaria no puede ser de una naturaleza tal que no le permita volver a retomar el control del vehículo en unos segundos si el sistema se lo pide

En este nivel 3, los vehículos autónomos comienzan a analizar su entorno y son capaces de tomar decisiones. Utilizan sensores LIDAR para registrar lo que ocurre alrededor. Estos sensores combinan visión computarizada, cámaras, radar y localización.

Características:

  • Los coches son capaces de controlar funciones críticas de conducción circular en una autopista, adelantar un coche o tomar una salida.
  • El vehículo activa automáticamente ajustes de seguridad al detectar determinadas situaciones de tráfico, en la vía o ambientales.
  • El conductor puede dejar de supervisar al coche en períodos extendidos de tiempo.

Limitaciones:

  • Se permite al conductor soltar el volante, pero solo en tramos con tráfico lento, inferior a 60 km/h.
  • Se requiere que el conductor esté detrás del volante de estos vehículos autónomos si se conduce en carreteras públicas.
  • En muchos países, todavía no se ha definido o actualizado el marco legal, limitando su uso.
  • En España se trabaja en la modificación del marco legislativo que afecta a los vehículos autónomos.

MODELOS:

  • Los vehículos autónomos en este nivel son: el clásico Tesla Model S, con el sistema piloto automático,
  • Honda como Mercedes comercializarán Nivel 3 este 2021, tras el intento frustrado de Audi con su actual A8.
  • Otros vendrán – véanse las plataformas de BMW (iX), Lexus o NIO.
  • Otro ejemplo de conducción autónoma de nivel 3 es el Audi A8.

Dado que ahora el sistema es el responsable de la conducción, es necesario un salto tecnológico importante para ofrecer Nivel 3. En primer lugar, es necesaria una redundancia de sistemas (sensores, plataformas de control, actuadores, redes de datos, fuentes de alimentación…), para garantizar que no existen fuentes únicas de error. Después, a nivel de sensórica, es preciso tener información mucho más robusta del entorno (también de forma redundante). Y aquí es donde, casi toda la industria parece estar de acuerdo que el lidar es una solución adecuada para solucionar alguno de los problemas de detección de objetos en nuestro carril en circunstancias donde cámaras o radar tendrían más dificultades. Los mapas de alta resolución también juegan un papel muy importante.

Esto tiene un precio. Los sistemas de Nivel 3 no van a ser baratos, ni para el fabricante ni para el público. Un lidar, por ejemplo, tendrá un precio de entre $700-$1000. Para comparar, un radar de los que se vienen usando en múltiples aplicaciones a día de hoy se puede conseguir por poco más de $30 en grandes volúmenes.

Y finalmente, la polémica. Hay fabricantes que dicen que el Nivel 3 es una trampa mortal.

NIVEL 4 Alta Automatización

En un nivel 4, el conductor no es responsable de la conducción, pero es que tampoco se le reclamara para que tome el control si es necesario. El vehículo funcionará de forma totalmente autónoma dentro de un ODD específico, y antes de llegar al final de ese ODD – con bastante antelación, si es que el destino final cae fuera de ese ODD – podrá informar de que será necesaria intervención humana para llegar al final del trayecto. Si no se consigue que el conductor retome el control, se estacionara de forma segura.

Los vehículos autónomos en este nivel 4 se conducen sin necesidad de intervención de un conductor. Utilizan algoritmos de IA para entrenarse en las distintas condiciones y escenarios de manejo. Hay conexión mediante sistema WiFi en el coche.

Características:

  • El coche puede controlar todas las funciones críticas de conducción.
  • Los vehículos autónomos nivel 4 modifican su respuesta en función de condiciones externas.
  • Si las condiciones son adversas, busca un lugar apropiado y se detiene.
  • Ya no hay conductor, solo pasajeros, los cuales pueden viajar dormidos.

Limitaciones:

  • Se espera estén disponibles entre 2021 y 2030.
  • Inicialmente estarán operativos bajo supervisión (no conducción) y en determinados escenarios.

MODELOS

  • Tesla tiene una variante del Model S,
  • Google el Proyecto Waymo 
  • Audi el Elaine Concept.
  • Mientras tanto, Ford y Volvo anuncian modelos nivel 4 para 2021.

NIVEL 5: Automatización Completa

En este nivel , los vehículos robotizados no requieren ningún tipo de control de conducción (ni volante ni pedales). Ya no hay conductor y las instrucciones se dan por comando de voz o mediante aplicaciones móviles.

Los coches en los niveles 4 y 5 funcionan intercambiando información con su entorno. Aprovechan de compartir y utilizar los datos generados por las telecomunicaciones de las ciudades inteligentes y el IOT. El Audi Aicon es un ejemplo de coche conceptual nivel 5 que solo es posible con tecnología 5G. El Parlamento Europeo espera que estos vehículos autónomos estén disponibles hacia el año 2030.

Características:

  • No requieren interacción humana alguna.
  • Varios prototipos adelantados son coches eléctricos.
  • Utilizan reconocimiento de 360°, en un rango mayor que los humanos.

Limitaciones:

  • Se requiere definir una estructura legal para su uso.
  • Hay que realizar inversiones para la adaptación tecnológica de la infraestructura vial.

EXTRACTO DE LOS NIVELES DE AUTOMTIZACION

  • Hoy estamos entre el nivel 2 y un ‘poquito’ del 3
  • El conductor es SIEMPRE el responsable hasta Nivel 2. A partir de Nivel 3 el sistema es responsable.
  • Hay nivel 2 y nivel 2+. Este último representa un sistema más avanzado que permite circular con las manos fuera del volante. Incluso dentro del nivel 2+ hay diferencias – Tesla por ejemplo, con su FSD, lo lleva al extremo y permitiría conducir “manos libres” pero con responsabilidad del conductor en entornos urbanos.
  • La conducción autónoma comienza en Nivel 3. Hasta nivel 2 es asistida.
  • Nivel 3 se confía en que llegue PRONTO, pero en todo el mundo. Japón y Alemania serán los primeros.
  • Nivel 4, para uso privado, no se espera hasta bien entrada la década.
  • Nivel 5 ni está ni se le espera en el medio plazo. Si alguien dice que es capaz de solucionar el nivel 5 de conducción autónoma, o viene de un futuro muy lejano o miente.

Primeros pasos con Jupyter Notebook


¿Qué es Jupyter Notebook?

Jupyter Notebook es una herramienta increíblemente poderosa para desarrollar y presentar proyectos de ciencia de datos de forma interactiva. Este post intentara guiarle de cómo usar Jupyter Notebooks para proyectos de ciencia de datos y cómo configurarlo en su máquina local.

jupyter-notebook las mejores herramientas gratuitas de ciencia de datos

Pero primero: ¿qué es un “cuaderno”?

Un cuaderno integra código y su salida en un solo documento que combina visualizaciones, texto narrativo, ecuaciones matemáticas y otros medios enriquecidos. En otras palabras: es un documento único en el que puede ejecutar código, mostrar el resultado y también agregar explicaciones, fórmulas, gráficos y hacer que su trabajo sea más transparente, comprensible, repetible y compartible. 

El uso de Notebooks es ahora una parte importante del flujo de trabajo de la ciencia de datos en empresas de todo el mundo. Si su objetivo es trabajar con datos, el uso de una computadora portátil acelerará su flujo de trabajo y facilitará la comunicación y el intercambio de resultados. 

Lo mejor de todo es que, como parte del proyecto de código abierto  Jupyter , los cuadernos de Jupyter son completamente gratuitos. Puede descargar el software  solo o como parte del kit de herramientas de ciencia de datos de Anaconda .

Aunque es posible utilizar muchos lenguajes de programación diferentes en Jupyter Notebooks, este artículo se centrará en Python, ya que es el caso de uso más común. (Entre los usuarios de R, R Studio  tiende a ser una opción más popular).Jupyter Notebooks también puede actuar como una plataforma flexible para familiarizarse con los pandas e incluso con Python, como se verá en este tutorial.

Algunas cosas que se veran en este post:

  • Cubrir los conceptos básicos de la instalación de Jupyter y la creación de su primer cuaderno
  • Profundizar y aprender toda la terminología importante
  • Explorear la facilidad con la que se pueden compartir y publicar en línea los blocs de notas.

Ejemplo de análisis de datos en un cuaderno Jupyter

Primero, recorreremos la configuración y un análisis de muestra para responder una pregunta de la vida real. Esto demostrará cómo el flujo de una computadora portátil hace que las tareas de ciencia de datos sean más intuitivas para nosotros mientras trabajamos y para otros una vez que llega el momento de compartir nuestro trabajo.

Entonces, digamos que es analista de datos y se le ha encomendado la tarea de averiguar cómo cambiaron históricamente las ganancias de las empresas más grandes de los EE. UU. Encontrará un conjunto de datos de compañías Fortune 500 que abarcan más de 50 años desde la primera publicación de la lista en 1955, reunidos a partir del archivo público de  Fortune . Seguimos adelante y creamos un CSV de los datos que puede usar  aquí .

Como demostraremos, los cuadernos de Jupyter son perfectamente adecuados para esta investigación. Primero, sigamos e instalemos Jupyter.

Instalación

La forma más fácil para que un principiante comience con Jupyter Notebooks es instalando  Anaconda .

Anaconda es la distribución de Python más utilizada para la ciencia de datos y viene precargada con todas las bibliotecas y herramientas más populares. 

Algunas de las bibliotecas de Python más grandes incluidas en Anaconda incluyen NumPy ,  pandas y  Matplotlib , aunque la  lista completa de más de 1000 es exhaustiva.

Por lo tanto, Anaconda nos permite comenzar con un taller de ciencia de datos completamente equipado sin la molestia de administrar innumerables instalaciones o preocuparse por las dependencias y los problemas de instalación específicos del sistema operativo (léase: específicos de Windows).

Para obtener Anaconda, simplemente:

  1. Descargue la última versión de Anaconda para Python 3.8.
  2. Instale Anaconda siguiendo las instrucciones en la página de descarga y / o en el ejecutable.

Si es un usuario más avanzado con Python ya instalado y prefiere administrar sus paquetes manualmente, puede usar pip :

pip3 install jupyter

Creación de su primer cuaderno

En esta sección, aprenderemos a ejecutar y guardar blocs de notas, a familiarizarnos con su estructura y a comprender la interfaz. Nos familiarizaremos con alguna terminología básica que lo guiará hacia una comprensión práctica de cómo usar Jupyter Notebooks por su cuenta y nos preparará para la siguiente sección, que recorre un ejemplo de análisis de datos y da vida a todo lo que aprendemos aquí.

Ejecutando Jupyter

En Windows, puede ejecutar Jupyter a través del acceso directo que Anaconda agrega a su menú de inicio, que abrirá una nueva pestaña en su navegador web predeterminado que debería parecerse a la siguiente captura de pantalla.

Panel de control de Jupyter

Este no es un cuaderno por el momento, ¡pero que no cunda el pánico! No hay mucho que hacer. Este es el panel de control del portátil, diseñado específicamente para administrar sus portátiles Jupyter. Piense en ello como la plataforma de lanzamiento para explorar, editar y crear sus cuadernos.

Tenga en cuenta que el panel le dará acceso solo a los archivos y subcarpetas que se encuentran dentro del directorio de inicio de Jupyter (es decir, donde está instalado Jupyter o Anaconda). Sin embargo, el directorio de inicio se puede cambiar .

También es posible iniciar el tablero en cualquier sistema a través del símbolo del sistema (o terminal en sistemas Unix) ingresando el comando jupyter notebook; en este caso, el directorio de trabajo actual será el directorio de inicio.

Con Jupyter Notebook abierto en su navegador, es posible que haya notado que la URL del panel de control es algo así como https://localhost:8888/tree. Localhost no es un sitio web, pero indica que el contenido se sirve desde su   máquina local : su propia computadora.

Los cuadernos y el tablero de Jupyter son aplicaciones web, y Jupyter inicia un servidor Python local para servir estas aplicaciones en su navegador web, lo que lo hace esencialmente independiente de la plataforma y abre la puerta para compartir más fácilmente en la web.

(Si aún no comprende esto, no se preocupe; el punto importante es que, aunque Jupyter Notebooks se abre en su navegador, está alojado y se ejecuta en su máquina local. Sus blocs de notas no están realmente en la web hasta que decide compartirlos.)

La interfaz del tablero se explica por sí misma, aunque volveremos a ella brevemente más adelante. entonces que estamos esperando ‘ Busque la carpeta en la que le gustaría crear su primer cuaderno, haga clic en el botón desplegable “Nuevo” en la parte superior derecha y seleccione “Python 3”:

Nuevo menú de cuaderno

¡Oye presto, aquí estamos! Su primer cuaderno de Jupyter se abrirá en una nueva pestaña; cada cuaderno usa su propia pestaña porque puede abrir varios cuadernos simultáneamente.

Si regresa al tablero, verá el nuevo archivo Untitled.ipynb y debería ver un texto verde que le indica que su computadora portátil se está ejecutando.

¿Qué es un archivo ipynb?

La respuesta corta: cada  archivo .ipynb es un cuaderno, por lo que cada vez que cree un nuevo cuaderno, se creará un nuevo   archivo .ipynb.  

La respuesta más larga: cada .ipynb archivo es un archivo de texto que describe el contenido de su cuaderno en un formato llamado  JSON . Cada celda y su contenido, incluidos los archivos adjuntos de imágenes que se han convertido en cadenas de texto, se enumeran allí junto con algunos  metadatos .

Puede editarlo usted mismo, ¡si sabe lo que está haciendo! – seleccionando “Editar> Editar metadatos del cuaderno” en la barra de menú del cuaderno. También puede ver el contenido de los archivos de su cuaderno seleccionando “Editar” en los controles del panel.

Sin embargo, la palabra clave puede. En la mayoría de los casos, no hay ninguna razón por la que deba editar manualmente los metadatos de su cuaderno.

La interfaz del portátil

Ahora que tiene un cuaderno abierto frente a usted, es de esperar que su interfaz no se vea del todo extraña. Después de todo, Jupyter es esencialmente un procesador de texto avanzado.

¿Por qué no echar un vistazo? Consulte los menús para familiarizarse con ellos, especialmente tómese unos minutos para desplazarse hacia abajo en la lista de comandos en la paleta de comandos, que es el botón pequeño con el ícono del teclado (o Ctrl + Shift + P).

Nuevo cuaderno de Jupyter

Hay dos términos bastante prominentes que debe notar, que probablemente sean nuevos para usted: las  células  y los  núcleos  son clave tanto para comprender Jupyter como para lo que lo convierte en algo más que un procesador de texto. Afortunadamente, estos conceptos no son difíciles de entender.

  • Un kernel es un “motor computacional” que ejecuta el código contenido en un documento de cuaderno.
  • Una celda es un contenedor para el texto que se mostrará en el cuaderno o el código que ejecutará el kernel del cuaderno.

Celdas

Regresaremos a los núcleos un poco más tarde, pero primero hablemos de las celdas. Las células forman el cuerpo de un cuaderno. En la captura de pantalla de un nuevo cuaderno en la sección anterior, ese cuadro con el contorno verde es una celda vacía. Hay dos tipos de células principales que cubriremos:

  • Una  celda de código contiene código que se ejecutará en el kernel. Cuando se ejecuta el código, el portátil muestra el resultado debajo de la celda de código que lo generó.
  • Una  celda de Markdown contiene texto formateado con Markdown y muestra su salida en el lugar cuando se ejecuta la celda de Markdown.

La primera celda de un cuaderno nuevo es siempre una celda de código.

Probémoslo con un ejemplo clásico de Hello World: escriba print('Hello World!') en la celda y haga clic en el botón Ejecutar  Botón de ejecución del cuaderno en la barra de herramientas de arriba o presione  Ctrl + Enter.

El resultado debería verse así:

print('Hello World!')
Hello World!

Cuando ejecutamos la celda, su salida se muestra a continuación y la etiqueta a su izquierda habrá cambiado de In [ ] a  In [1].

La salida de una celda de código también forma parte del documento, por lo que puede verla en este artículo. Siempre puede notar la diferencia entre el código y las celdas de Markdown porque las celdas de código tienen esa etiqueta a la izquierda y las celdas de Markdown no.

La parte “En” de la etiqueta es simplemente la abreviatura de “Entrada”, mientras que el número de etiqueta indica cuándo se ejecutó la celda en el kernel; en este caso, la celda se ejecutó primero.

Ejecute la celda nuevamente y la etiqueta cambiará a In [2] porque ahora la celda fue la segunda en ejecutarse en el kernel. Será más claro por qué esto es tan útil más adelante cuando echemos un vistazo más de cerca a los núcleos.

En la barra de menú, haga clic en  Insertar  y seleccione  Insertar celda debajo  para crear una nueva celda de código debajo de la primera y pruebe el siguiente código para ver qué sucede. ¿Notas algo diferente?

import time
time.sleep(3)

Esta celda no produce ningún resultado, pero tarda tres segundos en ejecutarse. Observe cómo Jupyter significa cuando la celda se está ejecutando actualmente cambiando su etiqueta a In [*]

En general, la salida de una celda proviene de cualquier dato de texto impreso específicamente durante la ejecución de la celda, así como del valor de la última línea de la celda, ya sea una variable solitaria, una llamada de función u otra cosa. Por ejemplo:

def say_hello(recipient):
    return 'Hello, {}!'.format(recipient)

say_hello('Tim')
'Hello, Tim!'

Te encontrarás usando esto casi constantemente en tus propios proyectos, y veremos más de eso más adelante.

Atajos de teclado

Una última cosa que puede haber observado al ejecutar sus celdas es que su borde se vuelve azul, mientras que era verde mientras estaba editando. En un Jupyter Notebook, siempre hay una celda “activa” resaltada con un borde cuyo color denota su modo actual:

  • Contorno verde : la celda está en “modo de edición”
  • Contorno azul : la celda está en “modo de comando”

Entonces, ¿qué podemos hacer con una celda cuando está en modo comando? Hasta ahora, hemos visto cómo ejecutar una celda  Ctrl + Enter, pero hay muchos otros comandos que podemos usar. La mejor manera de usarlos es con atajos de teclado.

Los atajos de teclado son un aspecto muy popular del entorno de Jupyter porque facilitan un flujo de trabajo rápido basado en celdas. Muchas de estas son acciones que puede realizar en la celda activa cuando está en modo de comando.

A continuación, encontrará una lista de algunos de los atajos de teclado de Jupyter. No es necesario que los memorice todos de inmediato, pero esta lista debería darle una buena idea de lo que es posible.

  • Alternar entre los modos de edición y comando con  Esc y  Enter, respectivamente.
  • Una vez en el modo de comando:
    • Desplácese hacia arriba y hacia abajo en sus celdas con las   teclas Up y  Down.
    • Presione  A o  B para insertar una nueva celda encima o debajo de la celda activa.
    • M transformará la celda activa en una celda de Markdown.
    • Y establecerá la celda activa en una celda de código.
    • D + D ( D dos veces) eliminará la celda activa.
    • Z deshará la eliminación de la celda.
    • Mantenga  Shift presionado y presione  Up o  Downpara seleccionar varias celdas a la vez. Con varias celdas seleccionadas, Shift + M fusionará su selección.
  • Ctrl + Shift + -, en el modo de edición, dividirá la celda activa en el cursor.
  • También puede hacer clic Shift + Click en y  en el margen a la izquierda de sus celdas para seleccionarlas.

Continúe y pruébelos en su propio cuaderno. Una vez que esté listo, cree una nueva celda de Markdown y aprenderemos a formatear el texto en nuestros cuadernos.

Reducción

Markdown es un lenguaje de marcado ligero y fácil de aprender para formatear texto sin formato. Su sintaxis tiene una correspondencia uno a uno con las etiquetas HTML, por lo que algunos conocimientos previos aquí serían útiles, pero definitivamente no son un requisito previo.

Recuerda que este artículo fue escrito en un cuaderno de Jupyter, por lo que todo el texto narrativo y las imágenes que has visto hasta ahora se lograron escribiendo en Markdown. Cubramos los conceptos básicos con un ejemplo rápido:

# This is a level 1 heading

## This is a level 2 heading

This is some plain text that forms a paragraph. Add emphasis via **bold** and __bold__, or *italic* and _italic_. 

Paragraphs must be separated by an empty line. 

* Sometimes we want to include lists. 
* Which can be bulleted using asterisks. 

1. Lists can also be numbered. 
2. If we want an ordered list.

[It is possible to include hyperlinks](https://www.example.com)

Inline code uses single backticks: `foo()`, and code blocks use triple backticks: 
```
bar()
``` 
Or can be indented by 4 spaces: 

    foo()
    
And finally, adding images is easy: ![Alt text](https://www.example.com/image.jpg)

Así es como se vería Markdown una vez que ejecute la celda para renderizarlo:

(Tenga en cuenta que el texto alternativo de la imagen se muestra aquí porque en realidad no usamos una URL de imagen válida en nuestro ejemplo)

Al adjuntar imágenes, tiene tres opciones:

  • Utilice una URL para una imagen en la web.
  • Use una URL local para una imagen que mantendrá junto a su cuaderno, como en el mismo repositorio de git.
  • Agregue un archivo adjunto a través de “Editar> Insertar imagen”; esto convertirá la imagen en una cadena y la almacenará dentro de su .ipynbarchivo de cuaderno  . ¡Tenga en cuenta que esto hará que su .ipynb archivo sea mucho más grande!

Hay mucho más en Markdown, especialmente en torno a los hipervínculos, y también es posible incluir simplemente HTML simple. Una vez que se encuentre superando los límites de los conceptos básicos anteriores, puede consultar la guía oficial  del creador de Markdown, John Gruber, en su sitio web.

Granos

Detrás de cada portátil hay un kernel. Cuando ejecuta una celda de código, ese código se ejecuta dentro del kernel. Cualquier salida se devuelve a la celda para que se muestre. El estado del kernel persiste a lo largo del tiempo y entre celdas; pertenece al documento como un todo y no a celdas individuales.

Por ejemplo, si importa bibliotecas o declara variables en una celda, estarán disponibles en otra. Probemos esto para sentirlo. Primero, importaremos un paquete de Python y definiremos una función:

import numpy as np
def square(x):
    return x * x

Una vez que hayamos ejecutado la celda de arriba, podemos hacer referencia a np y  squareen cualquier otra celda. 

x = np.random.randint(1, 10)
y = square(x)
print('%d squared is %d' % (x, y))
1 squared is 1

Esto funcionará independientemente del orden de las celdas de su cuaderno. Siempre que se haya ejecutado una celda, las variables que declaró o las bibliotecas que importó estarán disponibles en otras celdas.

Puede probarlo usted mismo, imprimamos nuestras variables nuevamente.

print('Is %d squared %d?' % (x, y))
Is 1 squared 1?

¡No hay sorpresas aquí! Pero, ¿qué pasa si cambiamos el valor de  y?

y = 10
print('Is %d squared is %d?' % (x, y))

Si ejecutamos la celda de arriba, ¿qué crees que pasaría?

Obtendremos una salida como:  Is 4 squared 10?. Esto se debe a que una vez que hemos ejecutado la  y = 10celda de código, yya no es igual al cuadrado de x en el kernel. 

La mayoría de las veces, cuando crea un cuaderno, el flujo será de arriba hacia abajo. Pero es común volver atrás para realizar cambios. Cuando necesitamos realizar cambios en una celda anterior, el orden de ejecución que podemos ver a la izquierda de cada celda, por ejemplo In [6], puede ayudarnos a diagnosticar problemas al ver en qué orden se han ejecutado las celdas. 

Y si alguna vez deseamos restablecer las cosas, hay varias opciones increíblemente útiles en el menú Kernel:

  • Reiniciar: reinicia el kernel, borrando así todas las variables, etc.que fueron definidas.
  • Reiniciar y borrar la salida: igual que el anterior, pero también borrará la salida que se muestra debajo de las celdas de código.
  • Reiniciar y ejecutar todo: igual que el anterior, pero también ejecutará todas sus celdas en orden de la primera a la última.

Si su kernel se atasca alguna vez en un cálculo y desea detenerlo, puede elegir la opción Interrumpir.

Elegir un kernel

Es posible que haya notado que Jupyter le brinda la opción de cambiar el kernel y, de hecho, hay muchas opciones diferentes para elegir. Cuando creó un nuevo cuaderno desde el panel de control seleccionando una versión de Python, en realidad estaba eligiendo qué kernel usar.

Hay kernels para diferentes versiones de Python, y también para más de 100 lenguajes,  incluidos Java, C e incluso Fortran. Los científicos de datos pueden estar particularmente interesados ​​en los núcleos para  R  y  Julia , así como en  imatlab  y  Calysto MATLAB Kernel  para Matlab.

El kernel de SoS  proporciona compatibilidad con varios idiomas en un solo portátil.

Cada kernel tiene sus propias instrucciones de instalación, pero probablemente requiera que ejecute algunos comandos en su computadora.

¿Aprendiendo Python para la ciencia de datos?

¡Prueba una de nuestras más de 60 misiones gratuitas hoy!Empiece >>

Análisis de ejemplo

Ahora que hemos visto  qué es  un Jupyter Notebook, es hora de ver  cómo se utilizan en la práctica, lo que debería darnos una comprensión más clara de por  qué son tan populares.

Finalmente es hora de comenzar con ese conjunto de datos de Fortune 500 mencionado anteriormente. Recuerde, nuestro objetivo es averiguar cómo han cambiado históricamente las ganancias de las empresas más grandes de EE . UU .

Vale la pena señalar que todos desarrollarán sus propias preferencias y estilo, pero los principios generales aún se aplican. Si lo desea, puede seguir esta sección en su propio cuaderno o utilizarla como guía para crear su propio enfoque.

Nombrar sus cuadernos

Antes de comenzar a escribir su proyecto, probablemente querrá darle un nombre significativo. nombre de archivo Untitleden la parte superior izquierda de la pantalla para ingresar un nuevo nombre de archivo, y presione el icono Guardar (que parece un disquete) debajo de él para guardar.

Tenga en cuenta que cerrar la pestaña del cuaderno en su navegador no “cerrará” su cuaderno de la forma en que lo haría cerrar un documento en una aplicación tradicional. El kernel del portátil seguirá ejecutándose en segundo plano y debe cerrarse antes de que se “cierre” realmente, aunque esto es muy útil si cierra accidentalmente la pestaña o el navegador.

Si el kernel se apaga, puede cerrar la pestaña sin preocuparse de si todavía se está ejecutando o no. 

La forma más sencilla de hacerlo es seleccionar “Archivo> Cerrar y detener” en el menú de la libreta. Sin embargo, también puede apagar el kernel yendo a “Kernel> Shutdown” desde la aplicación de la computadora portátil o seleccionando la computadora portátil en el panel de control y haciendo clic en “Apagar” (vea la imagen a continuación).

Un cuaderno para correr

Configuración

Es común comenzar con una celda de código específicamente para las importaciones y la configuración, de modo que si elige agregar o cambiar algo, simplemente puede editar y volver a ejecutar la celda sin causar efectos secundarios.

%matplotlib inline
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns sns.set(style="darkgrid")

Importaremos pandas  para trabajar con nuestros datos,  Matplotlib  para trazar gráficos y  Seaborn  para hacer que nuestros gráficos sean más bonitos. También es común importar  NumPy, pero en este caso, pandas lo importa por nosotros.

Esa primera línea no es un comando de Python, pero usa algo llamado magia de línea para indicarle a Jupyter que capture los diagramas de Matplotlib y los represente en la salida de la celda. Hablaremos un poco más sobre la magia de líneas más adelante, y también se tratan en nuestro tutorial avanzado de Jupyter Notebooks .

Por ahora, sigamos adelante y carguemos nuestros datos.

df = pd.read_csv('fortune500.csv')

Es sensato hacer esto también en una sola celda, en caso de que necesitemos recargarlo en algún momento.

Guardar y comprobar

Ahora que hemos comenzado, lo mejor es ahorrar con regularidad. Al presionar  Ctrl + Sguardará nuestro cuaderno llamando al comando “Guardar y punto de control”, pero ¿qué es este punto de control?

Cada vez que creamos un nuevo cuaderno, se crea un archivo de punto de control junto con el archivo del cuaderno. Se encuentra dentro de un subdirectorio oculto de su ubicación de guardado llamado .ipynb_checkpoints y también es un  .ipynb archivo.

De forma predeterminada, Jupyter guardará automáticamente su cuaderno cada 120 segundos en este archivo de punto de control sin alterar el archivo de su cuaderno principal. Cuando “Guardar y punto de control”, se actualizan tanto el cuaderno como los archivos del punto de control. Por lo tanto, el punto de control le permite recuperar su trabajo no guardado en caso de un problema inesperado.

Puede volver al punto de control desde el menú a través de “Archivo> Volver al punto de control”.

Investigando nuestro conjunto de datos

¡Ahora estamos realmente rodando! Nuestro cuaderno se guarda de forma segura y hemos cargado nuestro conjunto de datos  df en la estructura de datos de pandas más utilizada, que se llama  DataFrame ay básicamente se parece a una tabla. ¿Qué aspecto tiene el nuestro?

df.head()
AñoRangoEmpresaIngresos (en millones)Beneficio (en millones)
019551Motores generales9823.5806
119552Exxon Mobil5661.4584,8
219553Acero de EE. UU.3250,4195,4
319554Energia General2959,1212,6
419555Esmark2510,819,1
df.tail()
AñoRangoEmpresaIngresos (en millones)Beneficio (en millones)
254952005496Wm. Wrigley Jr.3648,6493
254962005497Energía Peabody3631,6175,4
254972005498Wendy’s internacional3630,457,8
254982005499Kindred Healthcare3616,670,6
254992005500Cincinnati Financial3614.0584

Luciendo bien. Tenemos las columnas que necesitamos y cada fila corresponde a una sola empresa en un solo año.

Cambiemos el nombre de esas columnas para poder consultarlas más adelante.

df.columns = ['year', 'rank', 'company', 'revenue', 'profit']

A continuación, necesitamos explorar nuestro conjunto de datos. Esta completo? ¿Lo leyeron los pandas como se esperaba? ¿Falta algún valor?

len(df)
25500

De acuerdo, eso se ve bien, son 500 filas por cada año desde 1955 hasta 2005, inclusive.

Comprobemos si nuestro conjunto de datos se ha importado como era de esperar. Una simple verificación es ver si los tipos de datos (o dtypes) se han interpretado correctamente.

df.dtypes
year int64 rank int64 company object revenue float64 profit object dtype: object

UH oh. Parece que hay algún problema con la columna de ganancias; esperaríamos que fuera  float64 similar a la columna de ingresos. Esto indica que probablemente contiene algunos valores que no son enteros, así que echemos un vistazo.

non_numberic_profits = df.profit.str.contains('[^0-9.-]')
df.loc[non_numberic_profits].head()
añorangoempresaingresoslucro
2281955229Norton135,0N / A
2901955291Elaboración de cerveza Schlitz100,0N / A
2941955295Aceite vegetal del Pacífico97,9N / A
2961955297Cervecerías Liebmann96,0N / A
3521955353Minneapolis-Moline77,4N / A

¡Tal como sospechábamos! Algunos de los valores son cadenas, que se han utilizado para indicar datos faltantes. ¿Hay otros valores que se hayan infiltrado?

set(df.profit[non_numberic_profits])
{'N.A.'}

Eso hace que sea fácil de interpretar, pero ¿qué debemos hacer? Bueno, eso depende de cuántos valores falten.

len(df.profit[non_numberic_profits])
369

Es una pequeña fracción de nuestro conjunto de datos, aunque no del todo intrascendente, ya que todavía está en torno al 1,5%.

Si las filas que contienen N.A. están distribuidas de manera aproximada y uniforme a lo largo de los años, la solución más sencilla sería eliminarlas. Así que echemos un vistazo rápido a la distribución.

bin_sizes, _, _ = plt.hist(df.year[non_numberic_profits], bins=range(1955, 2006))
Falta distribución de valor

De un vistazo, podemos ver que los valores más inválidos en un solo año son menos de 25, y como hay 500 puntos de datos por año, eliminar estos valores representaría menos del 4% de los datos de los peores años. De hecho, aparte de un aumento en torno a los 90, la mayoría de los años tienen menos de la mitad de los valores faltantes del pico.

Para nuestros propósitos, digamos que esto es aceptable y continúe y elimine estas filas.

df = df.loc[~non_numberic_profits]
df.profit = df.profit.apply(pd.to_numeric)

Deberíamos comprobar que funcionó.

len(df)
25131
df.dtypes
year int64 rank int64 company object revenue float64 profit float64 dtype: object

¡Estupendo! Hemos terminado la configuración de nuestro conjunto de datos.

Si tuviéramos que presentar su cuaderno como un informe, podríamos deshacernos de las celdas de investigación que creamos, que se incluyen aquí como una demostración del flujo de trabajo con los cuadernos, y fusionar las celdas relevantes (consulte la sección Funcionalidad avanzada a continuación para más sobre esto) para crear una celda de configuración de un solo conjunto de datos.

Esto significaría que si alguna vez estropeamos nuestro conjunto de datos en otro lugar, podemos simplemente volver a ejecutar la celda de configuración para restaurarlo.

Trazando con matplotlib

A continuación, podemos llegar a abordar la cuestión en cuestión trazando el beneficio promedio por año. También podríamos trazar los ingresos, así que primero podemos definir algunas variables y un método para reducir nuestro código.

group_by_year = df.loc[:, ['year', 'revenue', 'profit']].groupby('year')
avgs = group_by_year.mean()
x = avgs.index
y1 = avgs.profit
def plot(x, y, ax, title, y_label):
    ax.set_title(title)
    ax.set_ylabel(y_label)
    ax.plot(x, y)
    ax.margins(x=0, y=0)

¡Ahora tramemos!

fig, ax = plt.subplots()
plot(x, y1, ax, 'Increase in mean Fortune 500 company profits from 1955 to 2005', 'Profit (millions)')
Aumento de las ganancias medias de las empresas incluidas en la lista Fortune 500 de 1955 a 2005

Vaya, eso parece exponencial, pero tiene algunas caídas enormes. Deben corresponder a la recesión de principios de la  década de 1990  y a la  burbuja de las puntocom . Es bastante interesante ver eso en los datos. Pero, ¿cómo es que las ganancias se recuperaron a niveles aún más altos después de cada recesión?

Quizás los ingresos puedan decirnos más.

y2 = avgs.revenue
fig, ax = plt.subplots()
plot(x, y2, ax, 'Increase in mean Fortune 500 company revenues from 1955 to 2005', 'Revenue (millions)')
Aumento de los ingresos medios de las empresas incluidas en la lista Fortune 500 de 1955 a 2005

Eso agrega otro lado a la historia. Los ingresos no se vieron tan afectados; ese es un gran trabajo contable de los departamentos de finanzas.

Con un poco de ayuda  de Stack Overflow , podemos superponer estos gráficos con +/- sus desviaciones estándar.

def plot_with_std(x, y, stds, ax, title, y_label):
    ax.fill_between(x, y - stds, y + stds, alpha=0.2)
    plot(x, y, ax, title, y_label)
fig, (ax1, ax2) = plt.subplots(ncols=2)
title = 'Increase in mean and std Fortune 500 company %s from 1955 to 2005'
stds1 = group_by_year.std().profit.values
stds2 = group_by_year.std().revenue.values
plot_with_std(x, y1.values, stds1, ax1, title % 'profits', 'Profit (millions)')
plot_with_std(x, y2.values, stds2, ax2, title % 'revenues', 'Revenue (millions)')
fig.set_size_inches(14, 4)
fig.tight_layout()
jupyter-notebook-tutorial_48_0

Eso es asombroso, ¡las desviaciones estándar son enormes! Algunas empresas de Fortune 500 ganan miles de millones mientras que otras pierden miles de millones, y el riesgo ha aumentado junto con el aumento de las ganancias a lo largo de los años.

Quizás algunas empresas se desempeñen mejor que otras; ¿Son las ganancias del 10% superior más o menos volátiles que las del 10% inferior?

Hay muchas preguntas que podríamos analizar a continuación, y es fácil ver cómo el flujo de trabajo en un cuaderno puede coincidir con el propio proceso de pensamiento. Para los propósitos de este tutorial, detendremos nuestro análisis aquí, ¡pero siéntase libre de continuar investigando los datos por su cuenta!

Este flujo nos ayudó a investigar fácilmente nuestro conjunto de datos en un solo lugar sin cambiar de contexto entre aplicaciones, y nuestro trabajo se puede compartir y reproducir de inmediato. Si quisiéramos crear un informe más conciso para una audiencia en particular, podríamos refactorizar rápidamente nuestro trabajo fusionando celdas y eliminando el código intermediario.

Compartir sus cuadernos

Cuando la gente habla de compartir sus cuadernos, generalmente hay dos paradigmas que pueden estar considerando.

La mayoría de las veces, las personas comparten el resultado final de su trabajo, al igual que este artículo, lo que significa compartir versiones no interactivas y pre-renderizadas de sus cuadernos. Sin embargo, también es posible colaborar en portátiles con la ayuda de sistemas de control de versiones como Git o plataformas online como Google Colab .

Antes de compartir

Un cuaderno compartido aparecerá exactamente en el estado en el que se encontraba cuando lo exporta o lo guarda, incluida la salida de las celdas de código. Por lo tanto, para asegurarse de que su computadora portátil esté lista para compartir, por así decirlo, hay algunos pasos que debe seguir antes de compartir:

  1. Haga clic en “Celda> Todos los resultados> Borrar”.
  2. Haga clic en “Kernel> Reiniciar y ejecutar todo”.
  3. Espere a que las celdas de su código terminen de ejecutarse y verifique que se haya ejecutado como se esperaba

Esto asegurará que sus cuadernos no contengan salida intermedia, tengan un estado obsoleto y se ejecuten en orden en el momento de compartir.

Exportación de sus cuadernos

Jupyter tiene soporte integrado para exportar a HTML y PDF, así como a varios otros formatos, que puede encontrar en el menú en “Archivo> Descargar como”.

Si desea compartir sus cuadernos con un pequeño grupo privado, esta funcionalidad puede ser todo lo que necesite. De hecho, como a muchos investigadores de instituciones académicas se les proporciona un espacio web público o interno, y debido a que puede exportar un cuaderno a un archivo HTML, Jupyter Notebooks puede ser una forma especialmente conveniente para que los investigadores compartan sus resultados con sus pares.

Pero si compartir archivos exportados no es suficiente para usted, también existen algunos métodos inmensamente populares para compartir  .ipynb archivos más directamente en la web.

GitHub

Con la  cantidad de cuadernos públicos en GitHub que  excedieron los 1.8 millones a principios de 2018, seguramente es la plataforma independiente más popular para compartir proyectos de Jupyter con el mundo. GitHub tiene soporte integrado para renderizar  .ipynb archivos directamente tanto en repositorios como en esencias en su sitio web. Si aún no lo sabe,  GitHub  es una plataforma de alojamiento de código para el control de versiones y la colaboración para repositorios creados con  Git. . Necesitará una cuenta para utilizar sus servicios, pero las cuentas estándar son gratuitas.

Una vez que tenga una cuenta de GitHub, la forma más fácil de compartir un cuaderno en GitHub no requiere Git en absoluto. Desde 2008, GitHub ha proporcionado su servicio Gist para alojar y compartir fragmentos de código, cada uno de los cuales tiene su propio repositorio. Para compartir un cuaderno usando Gists:

  1. Inicie sesión y navegue hasta gist.github.com .
  2. Abra su  .ipynb archivo en un editor de texto, seleccione todo y copie el JSON dentro.
  3. Pegue el JSON del cuaderno en la esencia.
  4. Dale a tu Gist un nombre de archivo, recordando agregarlo  .iypnb o esto no funcionará.
  5. Haga clic en “Crear esencia secreta” o “Crear esencia pública”.

Esto debería tener un aspecto similar al siguiente:

Creando una esencia

Si creó un Gist público, ahora podrá compartir su URL con cualquier persona, y otros podrán  bifurcar y clonar  su trabajo.

Crear tu propio repositorio de Git y compartirlo en GitHub está más allá del alcance de este tutorial, pero  GitHub proporciona muchas guías  para que comiences por tu cuenta.

Un consejo adicional para aquellos que usan git es  agregar una excepción  a su  .gitignore para los .ipynb_checkpoints directorios ocultos que  crea Jupyter, para no enviar archivos de puntos de control innecesariamente a su repositorio.

Nbviewer

Después de haber crecido hasta renderizar  cientos de miles  de cuadernos cada semana en 2015, NBViewer es el renderizador de cuadernos más popular en la web. Si ya tiene un lugar para alojar sus cuadernos de Jupyter en línea, ya sea en GitHub o en otro lugar, NBViewer renderizará su cuaderno y proporcionará una URL para compartir junto con él. Se proporciona como un servicio gratuito como parte del Proyecto Jupyter y está disponible en  nbviewer.jupyter.org .

Desarrollado inicialmente antes de la integración de Jupyter Notebook de GitHub, NBViewer permite que cualquier persona ingrese una URL, ID de Gist o nombre de usuario / repositorio / archivo de GitHub y mostrará el cuaderno como una página web. La ID de un Gist es el número único al final de su URL; por ejemplo, la cadena de caracteres después de la última barra invertida  https://gist.github.com/username/50896401c23e0bf417e89cd57e89e1de. Si ingresa un nombre de usuario o nombre de usuario / repositorio de GitHub, verá un explorador de archivos mínimo que le permite explorar los repositorios de un usuario y su contenido.

La URL que se muestra en NBViewer cuando se muestra un cuaderno es una constante basada en la URL del cuaderno que se está procesando, por lo que puede compartirla con cualquier persona y funcionará siempre que los archivos originales permanezcan en línea; NBViewer no almacena en caché los archivos durante mucho tiempo. largo.

Si no le gusta Nbviewer, existen otras opciones similares: aquí hay un hilo con algunos para considerar de nuestra comunidad.

Extras: Extensiones de Jupyter Notebook

Ya hemos cubierto todo lo que necesita para empezar a trabajar en Jupyter Notebooks.

¿Qué son las extensiones?

Las extensiones son precisamente lo que parecen: características adicionales que amplían la funcionalidad de Jupyter Notebooks. Si bien un Jupyter Notebook básico puede hacer mucho, las extensiones ofrecen algunas características adicionales que pueden ayudar con flujos de trabajo específicos o que simplemente mejoran la experiencia del usuario.

Por ejemplo, una extensión llamada “Tabla de contenido” genera una tabla de contenido para su cuaderno, para que los cuadernos grandes sean más fáciles de visualizar y navegar. 

Otro, llamado Inspector de variables, le mostrará el valor, el tipo, el tamaño y la forma de cada variable en su cuaderno para una fácil referencia rápida y depuración. 

Otro, llamado ExecuteTime, le permite saber cuándo y durante cuánto tiempo se ejecutó cada celda; esto puede ser particularmente conveniente si está tratando de acelerar un fragmento de su código.

Estos son solo la punta del iceberg; hay muchas extensiones disponibles.

¿Dónde puede obtener extensiones?

Para obtener las extensiones, debe instalar Nbextensions. Puede hacer esto usando pip y la línea de comando. Si tiene Anaconda, puede ser mejor hacerlo a través de Anaconda Prompt en lugar de la línea de comandos normal.

Cerrar Jupyter cuadernos, abierta Anaconda Prompt y ejecute el siguiente comando: pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install.

Una vez que haya hecho eso, inicie un cuaderno y debería ver una pestaña Nbextensions. Al hacer clic en esta pestaña, se le mostrará una lista de extensiones disponibles. Simplemente marque las casillas de las extensiones que desea habilitar y ¡listo para las carreras!

Instalación de extensiones

Una vez que se ha instalado Nbextensions, no es necesario realizar una instalación adicional de cada extensión. Sin embargo, si ya instaló Nbextensons pero no ve la pestaña, no está solo. Este hilo en Github detalla algunos problemas y soluciones comunes.

Extras: Line Magics en Jupyter

Anteriormente mencionamos los comandos mágicos cuando solíamos %matplotlib inlinehacer que los gráficos de Matplotlib se renderizaran directamente en nuestro cuaderno. También hay muchas otras magias que podemos usar.

Cómo usar magia en Jupyter

Un buen primer paso es abrir un Jupyter Notebook, escribir %lsmagicen una celda y ejecutar la celda. Esto generará una lista de las magias de línea y de celda disponibles, y también te dirá si “automagic” está activado. 

  • Las magias de línea operan en una sola línea de una celda de código
  • La magia celular opera en toda la celda de código en la que se llaman

Si automagic está activado, puede ejecutar una magia simplemente escribiéndola en su propia línea en una celda de código y ejecutando la celda. Si está desactivado, deberá poner   %antes de las magias de línea y   %%  antes de las magias de células para usarlas.

Muchas magias requieren información adicional (al igual que una función requiere un argumento) para decirles cómo operar. Veremos un ejemplo en la siguiente sección, pero puede ver la documentación de cualquier magia ejecutándola con un signo de interrogación, así:

%matplotlib?

Cuando ejecute la celda anterior en un cuaderno, aparecerá una larga cadena de documentos en la pantalla con detalles sobre cómo puede usar la magia.

Algunos comandos mágicos útiles

Cubrimos más en el tutorial avanzado de Jupyter , pero aquí hay algunos para comenzar:

Mando mágicoQue hace
%correrEjecuta un archivo de secuencia de comandos externo como parte de la celda que se está ejecutando.
Por ejemplo, si aparece % run myscript.py en una celda de código, el kernel ejecutará myscript.py como parte de esa celda.
%cronométraloCuenta bucles, mide e informa cuánto tiempo tarda en ejecutarse una celda de código.
% archivo de escrituraGuarde el contenido de una celda en un archivo.
Por ejemplo,  % savefile myscript.py guardaría la celda de código como un archivo externo llamado myscript.py.
%TiendaGuarde una variable para usarla en un cuaderno diferente.
% pwdImprima la ruta del directorio en el que está trabajando actualmente.
%% javascriptEjecuta la celda como código JavaScript.

Hay mucho más de donde vino eso. Ingrese a Jupyter Notebooks y comience a explorar usando%lsmagic !

Pensamientos finales

Comenzando desde cero, nos hemos familiarizado con el flujo de trabajo natural de Jupyter Notebooks, profundizamos en las funciones más avanzadas de IPython y finalmente aprendimos cómo compartir nuestro trabajo con amigos, colegas y el mundo. ¡Y logramos todo esto desde un propio cuaderno!

Debe quedar claro cómo los cuadernos promueven una experiencia de trabajo productiva al reducir el cambio de contexto y emular un desarrollo natural de pensamientos durante un proyecto. El poder de usar Jupyter Notebooks también debería ser evidente, y cubrimos muchos clientes potenciales para que comience a explorar más funciones avanzadas en sus propios proyectos.

Si desea obtener más inspiración para sus propios cuadernos, Jupyter ha creado  una galería de cuadernos de Jupyter interesantes  que pueden resultarle útiles y la  página de inicio de Nbviewer.  enlaces a algunos ejemplos realmente elegantes de cuadernos de calidad.

Fáciles medidas de c.a. con Arduino


Medir la tensión de ca de la red de suministro con Arduino puede ser una labor compleja dado el rango de tensiones que manejamos ,pero gracias a los transformadores de tensión vamos a ver cómo medir voltaje CA hasta 250 V, tanto en 50 Hz como en 60 Hz, usando el ZMPT101B, (ese es el nombre del transformador solamente, pero lo encontrará con este nombre o “sensor de voltaje CA”).

Este módulo basado en un transformador de precisión para medidas (el zMPT101B) y un circuito operacional (el LM358) con la electronica asociada

Hemos de dicir que ,usado el código correcto, es mucho mejor esta electronica para las medidas, que los otros métodos que usan transformador + rectificador + divisor de voltaje….que no siempre dan los valores correctos. Puede que otros sistemas muestren la señal cuadrada o triangular,lo cual afecta seriamente el RMS, pues el RMS es lo que queremos medir, y para ello debemos mantener la misma forma de la señal asi que al adaptarlo para el Arduino,y aquí es cuando el módulo es útil.

Debemos advertir nuevamente que este tipo de circuitos pueden ser peligrosas si no se extrema las medidas pues en los bornes atornillados debemos conectar la carga de ca de 220V

Sineses.png

El módulo toma la señal que queremos medir, aquí una potencia doméstica de 220V, tiene alrededor de 311V como pico.

El transformador del módulo lo devuelve al pico de 2.5V

Luego agrega un desplazamiento de 2.5V para adaptarlo al Arduino.

       

  Y aquí preste atención, algunos códigos se usan con este módulo, solo hacen una muestra de la señal y miden los picos, luego una pequeña multiplicación, y puede mostrarle el “RMS” de esta señal, pero esos códigos funcionan solo para señal de onda sinusoidal perfecta, si está midiendo otra forma de la señal sería falsa.

Y, por ejemplo, aquí utilizamos un atenuador de luz(dimmer), que se basa en un Triac y ya conoces la forma “extraña” de la señal que hace un Triac.

artículo-2014julio-ics-responde-el-desafío-de-fig1

Aquí puede ver que para medir el RMS no solo debe medir los picos y hacer los mismos cálculos para la señal de onda sinusoidal.

Pero debe hacerlo de la manera correcta y es muy difícil de codificar, por eso usaremos una biblioteca simple que como siempre hará el trabajo por nosotros. 

Visualización de la información

Para mostrar las medidas se puede usar por ejemplo una pantalla OLED en lugar de las tipicas basadas en LCD con el controlador de Toshiba HD44780,

LCD es el acrónimo de Liquid Crystal Display (en español Pantalla de Cristal Líquido). No podemos considerar que se trate de una tecnología novedosa. El LCD lleva con nosotros mucho tiempo, solo tenemos que echar la mirada hacia atrás y recordar esos relojes Casio o las calculadoras que llevamos a clase de matemáticas.

Estamos acostumbrados a que la materia pueda estar en estado sólido, líquido o gaseoso, los llamados estados de la materia. Pero ya en el siglo XIX se descubrió que había más estados en los que podía encontrarse la materia. El cristal líquido se encuentra en algún lugar entre el sólido y líquido.No es el objetivo de este post la física involucrada detrás de los LCD, solo decir que utiliza las propiedades de la luz polarizada para mostrarnos la información en una pantalla. A partir de una serie de filtros, se consigue mostrar la información gracias a la iluminación de fondo.

Hay una amplia gama de pantallas LCDs que podemos utilizar con Arduino. Aparte de las funcionalidades extra que nos puedan dar cada una de ellas, las podemos diferenciar por el número de filas y columnas, su tamaño.

Por ejemplo, una pantalla LCD de 16×1 tendrá una fila de 16 caracteres es decir, solo podremos mostrar 16 caracteres simultáneamente, al igual que un LCD de 20×4 tendrá 4 filas de 20 caracteres cada una.

LCD

En este artículo vamos a trabajar con un LCD típico, de 16×2. Esto significa que vamos a poder mostrar 16 caracteres en la primera fila y los mismos en la segunda fila.

La mayoría de las pantallas LCD que se están haciendo ahora, vienen con una fila de dieciséis pines. Los primeros catorce pines se utilizan para controlar la visualización. Los dos últimos son para la iluminación de fondo.

Aunque el dato se puede enviar en 8 bits , lo normal es usarlo partido en “trozos” de 4 bits, labor que será transparente al usuario gracias a las librería LiquidCrystal.h y que como es obvio se emplea para ahorrarnos 4 lineas de datos del GPIO de modo que necesitaríamos 4 para datos + 3 de control =7 pines de datos lógicamente mas 2 mas para la alimentación de 5v DC

PINFUNCIÓN
1GND (Tierra)
25 Voltios
3Control de contraste pantalla
4RS – Selector entre comandos y datos
5RW – Escritura y lectura de comandos y datos
6Sincronización de lectura de datos
7-14Pines de datos de 8-bit
15Alimentación luz de fondo (5V)
16GND (Tierra) luz de fondo (0V)

En la siguiente imagen vemos la correspondencia con los pines físicos del LCD.

Pines LCD 16x2

Esta imagen muestra la parte de abajo del LCD. Cuando lo conectes a la protoboard los pines estarán invertidos horizontalmente.

Otra alternativa es usar una pantalla OLED i2c de 128 * 32 , cuyo coste es irrisorio. Este tipo de pantallas esde reducidasa dimensiones y , puede usarlas en algunos proyectos pequeños de bricolaje y también les brinda muchas posibilidades para hacer (diferentes fuentes y tamaños de textos, diferentes formas, desplazamiento, imágenes bmp …) Tenga en cuenta que este tipo de pantalla no es una pantalla a color, las “nornales ” solo imprimen en azul (Izquierda) pero las hay en blanco, y algunos pueden tener amarillo + uno de los colores anteriores .

Este es un ejemplo cableado con una pantalla OLED .Este cableado depende de su versión de pantalla ,( el que vemos usa 4 pines : dos para la alimentacion con 3,3V DC y los dos de datos no cableando el pin RST).

circuito

Conexiones finales

Wiring.png

Este es todo el cableado y, como se mencionó, estamos usando una pantalla OLED de 128 × 32, puede usarla o no, el módulo está alimentado por 5v y entrega una señal analógica.

Configuración:

Lo primero que debe hacer es calibrar el módulo con su potenciómetro, cablear el módulo, enchufar el Arduino y cargar este simple código, y no olvide colocar las sondas de medición en la toma de corriente (¡¡¡CUIDADO !!! ) y ya conoce el voltaje.

El código para probar esto es realmente simple , usando eso si, el Serial Plotter de Arduino IDE:

void setup() {
Serial.begin(9600);
}

void loop() 
{
Serial.println(analogRead(A0));
}

Abra el trazador de serie del IDE de Arduino:

parcela1
plot2

Verá algo como esto en su trazador de serie, significa que no adquiere toda la señal, ajuste el potenciómetro hasta que tenga algo que parezca una onda sinusoidal. Sé que esa no es la señal de onda sinusoidal de CA.

plot3

Cuando tenga algo como esto, puede agregar un retraso para ver una buena onda sinusoidal, aquí es porque estoy midiendo justo después de mi atenuador de luz, verá un pequeño pico antes del pico de señal si mide el enchufe directamente, no lo hará

sinewaveee.png

Ahora que su módulo está calibrado, las calibraciones del código se basarán en él, así que trate de no cambiarlo.

Código:

La biblioteca que usamos es Filters.h, reduce la cantidad de trabajo para usted, descargue aquí o desde Github . 

Bibliotecas de pantallas OLED de Adafruit

 /* This code works with ZMPT101B AC voltage sensor module and 128x32 OLED display
 * It permits you to measure any AC voltage up to 250V, BE CAREFUL !!!
 * The functions from Filters library permits you to calculate the True RMS of a signal
 * Refer to www.surtrTech.com or SurtrTech YouTube channel for more details
 */

#include <Filters.h> //Easy library to do the calculations
#include <SPI.h>     //Libraries for the OLED display
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
#define OLED_RESET    -1 //

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); //Declaring the display name (display)

float testFrequency = 50;                     // test signal frequency (Hz)
float windowLength = 40.0/testFrequency;     // how long to average the signal, for statistist

int Sensor = 0; //Sensor analog input, here it's A0

float intercept = -0.04; // to be adjusted based on calibration testing
float slope = 0.0405; // to be adjusted based on calibration testing
float current_Volts; // Voltage

unsigned long printPeriod = 1000; //Refresh rate
unsigned long previousMillis = 0;


void setup() {
  Serial.begin( 9600 );    // start the serial port
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start the OLED display 
  display.clearDisplay();
  display.setTextSize(2);                   
  display.setTextColor(WHITE);              
  display.setCursor(1,1);               
  display.print("SurtrTech");
  display.setCursor(1,20);
  display.setTextSize(1);
  display.print("AC Voltmeter");
  display.display();
  delay(5000);

}

void loop() {
  
  RunningStatistics inputStats;                //Easy life lines, actual calculation of the RMS requires a load of coding
  inputStats.setWindowSecs( windowLength );
   
  while( true ) {   
    Sensor = analogRead(A0);  // read the analog in value:
    inputStats.input(Sensor);  // log to Stats function
        
    if((unsigned long)(millis() - previousMillis) >= printPeriod) {
      previousMillis = millis();   // update time every second
            
      Serial.print( "\n" );
      
      current_Volts = intercept + slope * inputStats.sigma(); //Calibartions for offset and amplitude
      current_Volts= current_Volts*(40.3231);                //Further calibrations for the amplitude
      
      Serial.print( "\tVoltage: " );
      Serial.print( current_Volts ); //Calculation and Value display is done the rest is if you're using an OLED display
      
      
      display.clearDisplay();
      display.setTextSize(3);       //size of the text that will follow              
      display.setTextColor(WHITE);  //its color            
      display.setCursor(1,1);      //position from where you want to start writing           
      display.print(current_Volts,1);
      display.setCursor(115,00);
      display.setTextSize(2);
      display.print("V");
      display.setCursor(115,15);
      display.setTextSize(1);
      display.print("AC");
      display.display();
    }
  }

}

Pruebas:

Los valores seguramente no son perfectos y 100% precisos, pero como ve, necesita calibraciones muy precisas para hacerlo perfecto, y no olvide que está usando un módulo de 10 $ o menos, y allí se compara con un multímetro que usa TRMS. , Verdadero valor eficaz.

     Un multímetro que no sea TRMS también le dará una lectura falsa para una señal que no sea de onda sinusoidal,

Fuente: https://surtrtech.com/