Tutorial: Creación y ejecución de un cuaderno de Jupyter con PythonTutorial: create and run a Jupyter notebook with Python

Este tutorial le guiará en el proceso de uso de Azure Notebooks para crear un cuaderno de Jupyter completo que muestra la regresión lineal simple.This tutorial walks you through the process of using Azure Notebooks to create a complete Jupyter notebook that demonstrates simple linear regression. En el transcurso de este tutorial, se familiarizará con la interfaz de usuario de Jupyter Notebook, que incluye la creación de distintas celdas, la ejecución de celdas y la visualización del cuaderno como una presentación.In the course of this tutorial, you familiarize yourself with the Jupyter notebook UI, which includes creating different cells, running cells, and presenting the notebook as a slide show.

Encontrará el cuaderno completo en GitHub: Ejemplos de Azure Notebooks.The completed notebook can be found on GitHub - Azure Notebooks Samples. Sin embargo, este tutorial empieza con un proyecto nuevo y un cuaderno vacío para que pueda experimentar su creación paso a paso.This tutorial, however, begins with a new project and an empty notebook so you can experience creating it step by step.

Creación del proyectoCreate the project

  1. Vaya a Azure Notebooks e inicie sesión.Go to Azure Notebooks and sign in. (Para más información, consulte Quickstart - Sign in to Azure Notebooks [Inicio rápido: Inicio de sesión en Azure Notebooks]).(For details, see Quickstart - Sign in to Azure Notebooks).

  2. En la página del perfil público, seleccione My Projects (Mis proyectos) en la parte superior de la página:From your public profile page, select My Projects at the top of the page:

    Vínculo Mis proyectos en la parte superior de la ventana del explorador

  3. En la página My Projects (Mis proyectos), seleccione +New Project (+Nuevo proyecto) [método abreviado de teclado: n]; el botón puede aparecer solo como + si la ventana del explorador es estrecha:On the My Projects page, select + New Project (keyboard shortcut: n); the button may appear only as + if the browser window is narrow:

    Comando New Project (Nuevo proyecto) en la página My Projects (Mis proyectos)

  4. En la ventana emergente Create New Project (Crear nuevo proyecto) que aparece, escriba o establezca estos detalles y, luego, seleccione Create (Crear):In the Create New Project popup that appears, enter or set the following details, then select Create:

    • Project name (Nombre del proyecto): Linear Regression Example - Cricket ChirpsProject name: Linear Regression Example - Cricket Chirps
    • Project ID (Id. del proyecto): linear-regression-exampleProject ID: linear-regression-example
    • Public project (Proyecto público): desactivadaPublic project: (cleared)
    • Create a README.md (Crear un Léame.md): desactivadaCreate a README.md: (cleared)
  5. Después de unos instantes, Azure Notebooks lo lleva al proyecto nuevo.After a few moments, Azure Notebooks navigates you to the new project.

Creación del archivo de datosCreate the data file

El modelo de regresión lineal que se crea en el cuaderno extrae datos de un archivo del proyecto llamado cricket_chirps.csv.The linear regression model you create in the notebook draws data from a file in your project called cricket_chirps.csv. Para crear este archivo, cópielo de GitHub - Azure Notebooks Samples o escriba los datos directamente.You can create this file either by copying it from GitHub - Azure Notebooks Samples, or by entering the data directly. Estas dos opciones se describen en las secciones siguientes.The following sections describe both approaches.

Carga del archivo de datosUpload the data file

  1. En el panel del proyecto en Azure Notebooks, seleccione Upload > From URL (Cargar > Desde URL).On your project dashboard in Azure Notebooks, select Upload > From URL

  2. En la ventana emergente, escriba la siguiente dirección URL en File URL (URL de archivo) y cricket_chirps.csv en File Name (Nombre de archivo); después, seleccione Done (Listo).In the popup, enter the following URL in File URL and cricket_chirps.csv in File Name, then select Done.

    https://raw.githubusercontent.com/Microsoft/AzureNotebooks/master/Samples/Linear%20Regression%20-%20Cricket%20Chirps/cricket_chirps.csv
    
  3. El archivo cricket_chirps.csv aparecerá en la lista de archivos del proyecto:The cricket_chirps.csv file should now appear in your project's file list:

    Archivo CSV recién creado que se muestra en la lista de archivos de proyecto

Creación de un archivo desde ceroCreate a file from scratch

  1. En el panel del proyecto en Azure Notebooks, seleccione + New > Blank File (+Nuevo > Archivo en blanco).On your project dashboard in Azure Notebooks, select + New > Blank File

  2. Aparece un campo en la lista de archivos del proyecto.A field appears in the project's file list. Escriba cricket_chirps.csv y pulse Entrar.Enter cricket_chirps.csv and press Enter.

  3. Haga clic con el botón derecho en cricket_chirps.csv y seleccione Edit File (Editar archivo).Right-click cricket_chirps.csv and select Edit File.

  4. En el editor que aparece, escriba la siguiente información:In the editor that appears, enter the following data:

    Chirps/Minute,Temperature
    20,88.6
    16,71.6
    19.8,93.3
    18.4,84.3
    17.1,80.6
    15.5,75.2
    14.7,69.7
    17.1,82
    15.4,69.4
    16.2,83.3
    15,79.6
    17.2,82.6
    16,80.6
    17,83.5
    14.4,76.3
    
  5. Seleccione Save File (Guardar archivo) para guardar el archivo y volver al panel del proyecto.Select Save File to save the file and return to the project dashboard.

Instalación de los paquetes de nivel de proyectoInstall project level packages

Dentro de un cuaderno, siempre puede usar comandos como !pip install en una celda de código para instalar los paquetes necesarios.Within a notebook, you can always use commands like !pip install in a code cell to install required packages. Sin embargo, estos comandos se ejecutan cada vez que ejecute las celdas de código del cuaderno, lo que puede llevar un tiempo considerable.However, such commands are run every time you run the notebook's code cells, and can take considerable time. Por eso, en su lugar, puede instalar paquetes en el nivel proyecto con un archivo requirements.txt.For this reason, you can instead install packages at the project level using a requirements.txt file.

  1. Use el proceso descrito en Creación de un archivo desde cero para crear un archivo llamado requirements.txt con el siguiente contenido:Use the process described in Create a file from scratch to create a file named requirements.txt with the following contents:

    matplotlib==3.0.0
    numpy==1.15.0
    pandas==0.23.4
    scikit-learn==0.20.0
    

    También puede cargar un archivo requirements.txt desde el equipo local si lo prefiere, tal y como se describe en Carga del archivo de datos.You can also upload a requirements.txt file from your local computer if you prefer, as described on Upload the data file.

  2. En el panel del proyecto, seleccione Project Settings (Configuración del proyecto).On the project dashboard, select Project Settings.

  3. En la ventana emergente que aparece, seleccione la pestaña Environment (Entorno) y, después, +Add (+Agregar).In the popup that appears, select the Environment tab, then select +Add.

  4. En el primer control de lista desplegable (la operación), en Environment Setup Steps (Pasos de configuración del entorno), elija Requirements.txt.In the first drop-down control (the operation) under Environment Setup Steps, choose Requirements.txt.

  5. En el segundo control de lista desplegable (el nombre de archivo), elija requirements.txt (el archivo que creó).In the second drop-down control (the file name), choose requirements.txt (the file you created).

  6. En el tercer control de lista desplegable (la versión de Python), elija Python Version 3.6.In the third drop-down control (the Python version), choose Python Version 3.6.

  7. Seleccione Guardar.Select Save.

Pestaña Project Settings Environment (Entorno de configuración del proyecto) con el archivo requirements.txt especificado

Una vez realizado este paso de configuración, cualquier cuaderno que se ejecute en el proyecto se ejecutará en un entorno donde estén instalados esos paquetes.With this setup step in place, any notebook you run in the project will run in an environment where those packages are installed.

Creación y ejecución de un cuadernoCreate and run a notebook

Con el archivo de datos listo y el entorno del proyecto establecido, ya puede crear y abrir el cuaderno.With the data file ready and the project environment set, you can now create and open the notebook.

  1. En el panel del proyecto, seleccione +New > Notebook (+Nuevo > Cuaderno).On the project dashboard, select + New > Notebook.

  2. En la ventana emergente, escriba Linear Regression Example - Cricket Chirps.ipynb en Item Name (Nombre del elemento), elija Python 3.6 como lenguaje y, después, seleccione New (Nuevo).In the popup, enter Linear Regression Example - Cricket Chirps.ipynb for Item Name, choose Python 3.6 for the language, then select New.

  3. Cuando el nuevo cuaderno aparezca en la lista de archivos, selecciónelo para iniciarlo.After the new notebook appears on the file list, select it to start the notebook. Se abre una nueva pestaña del explorador automáticamente.A new browser tab opens automatically.

  4. Como tiene un archivo requirements.txt en la configuración del entorno, verá el mensaje "Waiting for your container to finish being prepared" (Esperando que finalice la preparación del contenedor).Because you have a requirements.txt file in the environment settings, you see the message, "Waiting for your container to finish being prepared." Puede seleccionar OK (Aceptar) para cerrar el mensaje y continuar trabajando en el cuaderno; sin embargo; las celdas de código no se pueden ejecutar hasta que el entorno esté totalmente configurado.You can select OK to close the message and continue working in the notebook; you can't run code cells, however, until the environment is set up fully.

  5. Abre el cuaderno en la interfaz de Jupyter con una celda única de código vacío como el valor predeterminado.The notebook opens in the Jupyter interface with a single empty code cell as the default.

    Vista inicial de un cuaderno nuevo en Azure NotebooksInitial view of a new notebook in Azure Notebooks

Paseo por la interfaz del cuadernoTour the notebook interface

Con el cuaderno en ejecución, puede agregar código y celdas de Markdown, ejecutar esas celdas y administrar el funcionamiento del cuaderno.With the notebook running, you can add code and Markdown cells, run those cells, and manage the operation of the notebook. Sin embargo, merece la pena dedicar unos minutos primero a familiarizarse con la interfaz.First, however, it's worth taking a few minutes to familiarize yourself with the interface. Para obtener la documentación completa, seleccione el comando de menú Help > Notebook Help (Ayuda > Ayuda del cuaderno).For full documentation, select the Help > Notebook Help menu command.

En la parte superior de la ventana verá los siguientes elementos:Along the top of the window you see the following items:

(A) El nombre del cuaderno; puede hacer clic en él para editarlo.(A) The name of your notebook, which you can edit by clicking. (B) Los botones para navegar al proyecto contenedor y el panel de proyectos, que abre nuevas pestañas en el explorador.(B) Buttons to navigate to the containing project and your projects dashboard, which open new tabs in your browser. (C) Un menú con comandos para trabajar con el cuaderno.(C) A menu with commands for working with the notebook. (D) Una barra de herramientas con los métodos abreviados para las operaciones comunes.(D) a toolbar with shortcuts for common operations. (E) El lienzo de edición que contiene las celdas.(E) the editing canvas containing cells. (F) Un indicador de si el cuaderno es de confianza; el valor predeterminado es Not Trusted (No es de confianza).(F) indicator of whether the notebook is trusted (default is Not Trusted). (G) El kernel usado para ejecutar el cuaderno, junto con un indicador de actividad.(G) the kernel used to run the notebook along with an activity indicator.

Áreas principales de la interfaz de usuario de JupyterPrimary UI areas of the Jupyter interface

Jupyter incorpora un paseo por los principales elementos de la interfaz de usuario.Jupyter provides a built-in tour of the primary UI elements. Para iniciar la visita, seleccione el comando Help > User Interface Tour (Ayuda > Paseo por la interfaz de usuario) y haga clic en los menús emergentes.Start the tour by selecting the Help > User Interface Tour command and clicking through the popups.

Los grupos de comandos de menú son los siguientes:The groups of menu commands are as follows:

MenúMenu DESCRIPCIÓNDescription
ArchivoFile Comandos para administrar el archivo de cuaderno, incluidos los comandos para crear y copiar cuadernos, mostrar una vista previa de impresión y descargar el cuaderno en diversos formatos.Commands to manage the notebook file, including commands to create and copy notebooks, show a print preview, and download the notebook in a variety of formats.
EditEdit Comandos típicos para cortar, copiar y pegar celdas, buscar y reemplazar valores, administrar datos adjuntos de celda e insertar imágenes.Typical commands to cut, copy, and paste cells, find and replace values, manage cell attachments, and insert images.
VerView Comandos para controlar la visibilidad de las distintas partes de la UI de Jupyter.Commands to control visibility of different parts of the Jupyter UI.
InsertarInsert Comandos para insertar una nueva celda por encima o debajo de la celda actual.Commands to insert a new cell above or below the current cell. Estos comandos se utilizan con frecuencia para crear un cuaderno.You use these commands frequently when creating a notebook.
CellCell Los distintos comandos Run (Ejecutar) ejecutan una o varias celdas en diferentes combinaciones.The various Run commands run one or more cells in different combinations. Los comandos Cell Type (Tipo de celda) cambia el tipo de celda entre Code (Código), Markdown y Raw NBConvert (texto sin formato).The Cell Type commands change the type of a cell between Code, Markdown, and Raw NBConvert (plain text). Los comandos Current Outputs (Salidas actuales) y All Outputs (Todas las salidas) controlan cómo se muestra el resultado de la ejecución del código, e incluyen un comando para borrar todas las salidas.The Current Outputs and All Outputs commands control how output from run code is shown, and include a command to clear all output.
KernelKernel Comandos para administrar cómo se ejecuta el código en el kernel, más Change kernel (Cambiar kernel) para cambiar el lenguaje o la versión de Python que se usa para ejecutar el cuaderno.Commands to manage how code is being run in the kernel, along with Change kernel to change the language or Python version used to run the notebook.
DatosData Comandos para cargar y descargar archivos desde el proyecto o la sesión.Commands to upload and download files from the project or session. Consulte Trabajo con archivos de datos de proyecto.See Work with project data files
WidgetsWidgets Comandos para administrar Jupyter Widgets (Widgets de Jupyter), que proporcionan funcionalidades adicionales para la visualización, la asignación y el trazado.Commands to manage Jupyter Widgets, which provide additional capabilities for visualization, mapping, and plotting.
AyudaHelp Comandos que ofrecen ayuda y documentación sobre la interfaz de Jupyter.Commands that provide help and documentation for the Jupyter interface.

La mayoría de los comandos de la barra de herramientas tiene comandos de menú equivalentes.Most of the commands on the toolbar have equivalent menu commands. Una excepción es Enter/Edit RISE Slideshow (Especificar/editar presentación de RISE), que se describe en Uso compartido y presentación de cuadernos.One exception is Enter/Edit RISE Slideshow, which is discussed on Share and present notebooks.

Use estos comandos mientras rellena el cuaderno en las secciones siguientes.You use a number of these commands as you populate the notebook in the sections that follow.

Creación de una celda de MarkdownCreate a Markdown cell

  1. Haga clic en la primera celda vacía que se muestra en el lienzo del cuaderno.Click into the first empty cell shown on the notebook canvas. De forma predeterminada, una celda es del tipo Code, lo que significa que se ha diseñado para contener código ejecutable para el kernel seleccionado (Python, R o F#).By default, a cell is a Code type, which means it's designed to contain runnable code for the selected kernel (Python, R, or F#). El tipo actual se muestra en la lista desplegable de tipos, en la barra de herramientas:The current type is shown in the type drop-down on the toolbar:

    Lista desplegable de tipo de celda en la lista desplegable

  2. Cambie el tipo de celda a Markdown utilizando la lista desplegable de la barra de herramientas; también puede usar los comandos de menú Cell > Cell Type > Markdown (Celda > Tipo de celda > Markdown):Change the cell type to Markdown using the toolbar drop-down; alternately, use the Cell > Cell Type > Markdown menu command:

    Comando de menú de tipo de celda

  3. Haga clic en la celda para comenzar a editarla y, luego, escriba el siguiente código Markdown:Click into the cell to start editing, then enter the following Markdown:

    # Example Linear Regression
    
    This notebook contains a walkthrough of a simple linear regression. The data, obtained from [college.cengage.com](https://college.cengage.com/mathematics/brase/understandable_statistics/7e/students/datasets/slr/frames/frame.html), relates the rate of cricket chirps to temperature from *The Song of Insects*, by Dr. G. W. Pierce, Harvard College Press.
    
    In this example we're using the count of chirps per minute as the independent varible to then predict the dependent variable, temperature. In short, we're using a little data science to make ourselves a cricket thermometer. (You could also reverse the data and use temperature to predict the number of chirps, but it's more fun to use crickets as the thermometer itself!)
    
    The methods shown in this example follow what's presented in the Udemy course, [Machine Learning A to Z](https://www.udemy.com/machinelearning/learn/v4/).
    
    A lovely aspect of Notebooks is that you can use Markdown cells to explain what the code is doing rather than code comments. There are several benefits to doing so:
    
    - Markdown allows for richer text formatting, like *italics*, **bold**, `inline code`, hyperlinks, and headers.
    - Markdown cells automatically word wrap whereas code cells do not. Code comments typically use explicit line breaks for formatting, but that's not necessary in Markdown.
    - Using Markdown cells makes it easier to run the Notebook as a slide show.
    - Markdown cells help you remove lengthy comments from the code, making the code easier to scan.
    
    When you run a code cell, Jupyter executes the code; when you run a Markdown cell, Jupyter renders all the formatting into text that's suitable for presentation.
    
  4. Para representar el código Markdown como HTML para el explorador, seleccione el comando Run (Ejecutar) en la barra de herramientas, o use el comando Cell > Run Cells (Celda > Ejecutar celdas).To render the Markdown into HTML for the browser, select the Run command on the toolbar, or use the Cell > Run Cells command. Ahora, el código Markdown del formato y los vínculos aparece según lo esperado en un explorador.The Markdown code for formatting and links now appear as you expect them to in a browser.

  5. Cuando se ejecuta la última celda del cuaderno, Jupyter crea automáticamente una nueva celda debajo de la que se ha ejecutado.When you run the last cell in the notebook, Jupyter automatically creates a new cell below the one you ran. Repita los pasos descritos en esta sección para agregar el siguiente código Markdown a esta celda:Put more Markdown into this cell by repeating the steps in this section with the following Markdown:

    ## Install packages using pip or conda
    
    Because the code in your notebook likely uses some Python packages, you need to make sure the Notebook environment contains those packages. You can do this directly within the notebook in a code block that contains the appropriate pip or conda commands prefixed by `!`:
    
    \```
    !pip install <pkg name>
    
    !conda install <pkg name> -y
    \```
    
  6. Para volver a editar el código Markdown, haga doble clic en la celda representada.To edit the Markdown again, double-click in the rendered cell. Para volver a representar HTML después de realizar cambios, ejecute la celda.To render HTML again after making changes, run the cell.

Creación de una celda de código con comandosCreate a code cell with commands

Tal y como se explicó para la celda Markdown anterior, puede incluir comandos directamente en el cuaderno.As the previous Markdown cell explained, you can include commands directly in the notebook. Puede usar comandos para instalar paquetes, ejecutar curl o wget para recuperar datos, u otras acciones.You can use commands to install packages, run curl or wget to retrieve data, or anything else. Los cuadernos de Jupyter se ejecutan bien en una máquina virtual Linux, lo que permite trabajar con el conjunto completo de comandos Linux.Jupyter notebooks effectively run within a Linux virtual machine, so you have the full Linux command set to work with.

  1. Escriba los siguientes comandos en la celda de código que apareció después de usar Run (Ejecutar) en la celda Markdown anterior.Enter the commands below in the code cell that appeared after you used Run on the previous Markdown cell. Si no ve una nueva celda, cree una con Insert > Insert Cell Below (Insertar > Insertar celda debajo) o use el botón + de la barra de herramientas.If you don't see a new cell, create one with Insert > Insert Cell Below or use the + button on the toolbar.

    !pip install numpy
    !pip install matplotlib
    !pip install pandas
    !pip install sklearn
    
  2. Antes de ejecutar la celda, cree una nueva celda con el botón + de la barra de herramientas, cambie el tipo a Markdown y escriba la explicación siguiente:Before running the cell, create a new cell with the + button on the toolbar, set it to Markdown, and enter the following explanation:

    Note that when you run a code block that contains install commands, and also those with `import` statements, it make take the notebooks a little time to complete the task. To the left of the code block you see `In [*]` to indicate that execution is happening. The Notebook's kernel on the upper right also shows a filled-in circle to indicate "busy."
    
  3. Seleccione el comando Cell > Run All (Celda > Ejecutar todo) para ejecutar todas las celdas del cuaderno.Select the Cell > Run All command to run all the cells in the notebook. Observe que las celdas Markdown se representan como HTML y el comando se ejecuta en el kernel, y observe el indicador de kernel tal y como se describe en el propio código Markdown:Notice that the Markdown cells render as HTML, and the command run in the kernel, and observe the kernel indicator as described in the Markdown itself:

    Indicador de ocupado del kernel del cuaderno

  4. Todos los comandos pip install se ejecutan rápidamente y, como estos paquetes ya están instalados en el entorno del proyecto (y también están incluidos en Azure Notebooks de forma predeterminada), verá muchos mensajes del tipo "Requirement already satisfied" (Requisito ya cumplido).It also takes a little time for all of the pip install commands to run, and because you already installed these packages in the project environment (and because they're also included in Azure Notebooks by default), you see many messages that read, "Requirement already satisfied." Como todas esas salidas pueden resultar una distracción a la vista, seleccione esa celda (con un clic) y use Cell > Cell Outputs > Toggle (Celda > Salidas de celda > Alternar).All of that output can be visually distracting, so select that sell (using a single click), then use the Cell > Cell Outputs > Toggle to hide the output. También puede usar el comando Clear (Borrar) en ese mismo submenú para quitar todas las salidas.You can also use the Clear command on that same submenu to remove the output entirely.

    El comando Toggle (Alternar) oculta solo la salida más reciente de la celda; si vuelve a ejecutar la celda, la salida vuelve a aparecer.The Toggle command hides only the most recent output from the cell; if you run the cell again, the output reappears.

  5. Como los paquetes están instalados en el entorno del proyecto, marque como comentario los comandos ! pip install mediante #; de esta forma, pueden permanecer en el cuaderno como material informativo, pero no ocuparán tiempo de ejecución y no producirán salidas innecesarias.Because the packages are installed in the project environment, comment out the ! pip install commands using #; this way they can remain in the notebook as instructional material but won't take any time to run and won't produce unnecessary output. En este caso, mantener los comandos como comentarios en el cuaderno también informa sobre las dependencias del cuaderno.In this case, keeping the commented commands in the notebook also indicates the notebook's dependencies.

    # !pip install numpy
    # !pip install matplotlib
    # !pip install pandas
    # !pip install sklearn
    

Creación de las celdas restantesCreate the remaining cells

Para rellenar el resto del cuaderno, cree una serie de celdas del tipo Markdown y Code.To populate the rest of the notebook, you next create a series of Markdown and code cells. Para cada una de las siguientes celdas, primero cree la nueva celda y, luego, establezca el tipo y pegue el contenido.For each cell listed below, first create the new cell, then set the type, then paste in the content.

Aunque puede esperar para ejecutar el cuaderno después de crear cada celda, es interesante ejecutar cada celda al crearla.Although you can wait to run the notebook after you've created each cell, it's interesting to run each cell as you create it. No todas las celdas muestran una salida; si no ve ningún error, puede dar por hecho que la celda se ha ejecutado con normalidad.Not all cells show output; if you don't see any errors, assume the cell ran normally.

Cada celda de código depende del código que se han ejecutado en las celdas anteriores y, si no se ejecuta una de las celdas, las celdas siguientes pueden producir errores.Each code cell depends on the code that's been run in previous cells, and if you neglect to run one of the cells, later cells may produce errors. Si se da cuenta de que ha olvidado ejecutar una celda, pruebe a usar Cell > Run All Above (Celda > Ejecutar todas las anteriores) antes de ejecutar la celda actual.If you find that you've forgotten to run a cell, try using the Cell > Run All Above before running the current cell.

Si ve resultados inesperados (y probablemente los verá), compruebe que todas las celdas son del tipo "Code" o "Markdown" según sea necesario.If you see unexpected results (which you probably will!), check that each cell is set to "Code" or "Markdown" as necessary. Por ejemplo, un error "Invalid syntax" (Sintaxis no válida) normalmente se produce cuando se ha especificado Markdown en una celda de código.For example, an "Invalid syntax" error typically occurs when you've entered Markdown into Code cell.

  1. Celda Markdown:Markdown cell:

    ## Import packages and prepare the dataset
    
    In this example we're using numpy, pandas, and matplotlib. Data is in the file cricket_chirps.csv. Because this file is in the same project as this present Notebook, we can just load it using a relative pathname.
    
  2. Celda de código; cuando se ejecuta, muestra el contenido de la tabla como salida.Code cell; when run, shows the table contents as output. Puede suprimir la salida marcando como comentario la instrucción print.You can suppress the output by commenting out the print statement.

    import numpy as np
    import pandas as pd
    
    dataset = pd.read_csv('cricket_chirps.csv')
    print(dataset)
    X = dataset.iloc[:, :-1].values  # Matrix of independent variables -- remove the last column in this data set
    y = dataset.iloc[:, 1].values    # Matrix of dependent variables -- just the last column (1 == 2nd column)
    

    Nota

    Quizás vea advertencias de este código como "numpy.dtype size changed"; estas advertencias pueden omitirse.You may see warnings from this code about "numpy.dtype size changed"; the warnings can be safely ignored.

  3. Celda Markdown:Markdown cell:

    Next, split the dataset into a Training set (2/3rds) and Test set (1/3rd). We don't need to do any feature scaling because there is only one column of independent variables, and packages typically do scaling for you.
    
  4. Celda de código; cuando se ejecuta, esta celda no produce una salida.Code cell; when run, this cell has no output.

    from sklearn.model_selection import train_test_split
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 1/3, random_state = 0)
    
  5. Celda Markdown:Markdown cell:

    ## Fit the data to the training set
    
    "Fitting" the data to a training set means making the line that describes the relationship between the independent and the dependent variables. With a simple data set like we're using here, you can visualize the line on a simple x-y plot: the x-axis is the independent variable (chirp count in this example), and the y-axis is the independent variable (temperature). Fitting the data means plotting all the points in the training set, then drawing the best-fit line through that data.
    
    With two independent variables you can imagine a three-dimensional plot with a line fitted to the data. At three or more independent variables, however, it's no longer easy to visualize the fit, but you get the idea. In the end, it's all just mathematics, which a computer can handle easily without having to form a mental picture!
    
    The regressor's `fit` method here creates the line, which algebraically is of the form `y = x*b1 + b0`, where b1 is the coefficient or slope of the line (which you can get to through `regressor.coef_`), and b0 is the intercept of the line at x=0 (which you can get to through `regressor.intercept_`).
    
  6. Celda de código; cuando se ejecuta, esta celda produce la salida LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None,normalize=False).Code cell; when run, this cell shows the output, LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None,normalize=False).

    from sklearn.linear_model import LinearRegression
    
    regressor = LinearRegression()    # This object is the regressor, that does the regression
    regressor.fit(X_train, y_train)   # Provide training data so the machine can learn to predict using a learned model.
    
  7. Celda Markdown:Markdown cell:

    ## Predict the results
    
    With the regressor in hand, we can predict the test set results using its `predict` method. That method takes a vector of independent variables for which you want predictions.
    
    Because the regressor is fit to the data by virtue of `coef_` and `intercept_`, a prediction is the result of `coef_ * x + intercept_`. (Indeed, `predict(0)` returns `intercept_` and `predict(1)` returns `intercept_ + coef_`.)
    
    In the code, the `y_test` matrix (from when we split the set) contains the real observations. `y_pred` assigned here contains the predictions for the same `X_test` inputs. It's not expected that the test or training points exactly fit the regression; the regression is trying to find the model that we can use to make predictions with new observations of the independent variables.
    
  8. Celda de código; cuando se ejecuta, esta celda muestera resultados como [79.49588055 75.98873911 77.87719989 80.03544077 75.17939878].Code cell; when run, this cell shows results like [79.49588055 75.98873911 77.87719989 80.03544077 75.17939878].

    y_pred = regressor.predict(X_test)
    print(y_pred)
    
  9. Celda Markdown:Markdown cell:

    It's interesting to think that all the "predictions" we use in daily life, like weather forecasts, are just regression models of some sort working with various data sets. Those models are much more complicated than what's shown here, but the idea is the same.
    
    Knowing how predictions work help us understand that the actual observations we would collect in the moment will always be somewhat off from the predictions: the predictions fit exactly to the model, whereas the observations typically won't.
    
    Of course, such systems feed new observations back into the dataset to continually improve the model, meaning that predictions should get more accurate over time.
    
    The challenge is determining what data to actually use. For example, with weather, how far back in time do you go? How have weather patterns been changing decade by decade? In any case, something like weather predictions will be doing things hour by hour, day by day, for things like temperature, precipitation, winds, cloud cover, etc. Radar and other observations are of course fed into the model and the predictions are reduced to mathematics.
    
  10. Celda Markdown:Markdown cell:

    ## Visualize the results
    
    The following code generates a plot: green dots are training data, red dots are test data, blue dots are predictions. Gray line is the regression itself. You see that all the blue dots are exactly on the line, as they should be, because the predictions exactly fit the model (the line).
    
  11. Celda de código; cuando se ejecuta, esta celda produce un trazado gráfico.Code cell; when run, this cell produces a graphical plot. Si no ve el trazado la primera vez (y en su lugar ve "Figure size 640x480 with 1 Axes"), vuelva a ejecuta la celda.If you don't see the plot the first time (and instead see "Figure size 640x480 with 1 Axes"), run the cell again.

    import matplotlib.pyplot as plt
    
    plt.scatter(X_train, y_train, color = 'green')
    plt.scatter(X_test, y_test, color = 'red')   
    plt.scatter(X_test, y_pred, color = 'blue')  # The predicted temperatures of the same X_test input.
    plt.plot(X_train, regressor.predict(X_train), color = 'gray')
    plt.title('Temperature based on chirp count')
    plt.xlabel('Chirps/minute')
    plt.ylabel('Temperature')
    plt.show()
    

    Salida de trazado del código de matplotlib

  12. Celda Markdown:Markdown cell:

    ## Closing comments
    
    At the end of the day, when you create a model, you use training data. Then you start feeding test data (real observations) to see how well the model actually works. You may find that the model is a little inaccurate over time, in which case you retrain the model with some new data. Retraining the model means you're creating a new fit line that's used for predictions.
    
    This regression can be used to examine the variability of the relationship between temperature and chirp count. Of course, if the model proves too inaccurate (that is, the predictions aren't very good), then it suggests that we might need to introduce more independent variables like humidity, time of year, latitude, amount of moonlight, and so on. If you have such data, you can do separate lines regressions for each independent variable, and then do multiple regressions with combinations of independent variables. 
    
    Again, once you are working with more than one or two independent variables, it's much easier to use machine learning to crunch the numbers than to try to visualize it graphically.
    

Borrado de las salidas y nueva ejecución de todas las celdasClear outputs and rerun all cells

Después de seguir los pasos descritos en la sección anterior para rellenar todo el cuaderno, ha creado un fragmento de código en ejecución en el contexto de un tutorial completo sobre la regresión lineal.After following the steps in the previous section to populate the entire notebook, you've created both a piece of running code in the context of a full tutorial on linear regression. Esta combinación directa de código y texto es una de las grandes ventajas de los cuadernos.This direct combination of code and text is one of the great advantages of notebooks!

Ahora, vuelva a ejecutar el cuaderno completo:Try rerunning the whole notebook now:

  1. Borre todos los datos de la sesión del kernel y todas las salidas de las celdas; para ello, seleccione Kernel > Restart & Clear Output (Kernel > Reiniciar y borrar salida).Clear all the kernel's session data and all cell output by selecting Kernel > Restart & Clear Output. Siempre es conveniente ejecutar este comando cuando se ha completado un cuaderno, simplemente para asegurarse de que no se han creado dependencias extrañas entre las celdas de código.This command is always a good one to run when you've completed a notebook, just to make sure that you haven't created any strange dependencies between code cells.

  2. Vuelva a ejecutar el cuaderno con Cell > Run All (Celda > Ejecutar todo).Rerun the notebook using Cell > Run All. Tenga en cuenta que el indicador de kernel se rellena mientras se ejecuta el código.Notice the kernel indicator is filled in while code is running.

    Si tiene un código que se ejecuta durante demasiado tiempo o se queda bloqueado, puede detener el kernel con el comando Kernel > Interrupt (Kernel > Interrumpir).If you have any code that runs for too long or otherwise gets stuck, you can stop the kernel by using the Kernel > Interrupt command.

  3. Desplácese por el cuaderno para examinar los resultados.Scroll through the notebook to examine the results. (De nuevo, si el trazado no aparece, vuelva a ejecutar esa celda).(If again the plot doesn't appear, rerun that cell.)

Guardado, detención y cierre del cuadernoSave, halt, and close the notebook

Durante el tiempo que está editando un cuaderno, puede guardar el estado actual con el comando File > Save and Checkpoint (Archivo > Guardar y punto de comprobación) o con el botón de guardado de la barra de herramientas.During the time you're editing a notebook, you can save its current state with the File > Save and Checkpoint command or the save button on the toolbar. Un "punto de comprobación" crea una instantánea que puede revertir en cualquier momento durante la sesión.A "checkpoint" creates a snapshot that you can revert to at any time during the session. Los puntos de comprobación le permiten realizar una serie de cambios experimentales y, si esos cambios no funcionan, puede volver a un punto de comprobación con el comando File > Revert to Checkpoint (Archivo > Revertir al punto de comprobación).Checkpoints allow you to make a series of experimental changes, and if those changes don't work, you can just revert to a checkpoint using the File > Revert to Checkpoint command. Otro método es crear celdas adicionales y marcar como comentario todo el código que no desea ejecutar; funciona de las dos maneras.An alternate approach is to create extra cells and comment out any code that you don't want to run; either way works.

También puede usar el comando File > Make a Copy (Archivo > Crear una copia) en cualquier momento para realizar una copia del estado actual del cuaderno en un nuevo archivo del proyecto.You can also use the File > Make a Copy command at any time to make a copy of the current state of the notebook into a new file in your project. Esa copia se abre automáticamente en una nueva pestaña del explorador.That copy opens in a new browser tab automatically.

Cuando haya terminado con un cuaderno, use el comando la File > Close and halt (Archivo > Cerrar y detener) para cerrar el cuaderno y apagar el kernel que lo ejecutaba.When you're done with a notebook, use the File > Close and halt command, which closes the notebook and shuts down the kernel that's been running it. Después, Azure Notebooks cierra la pestaña del explorador automáticamente.Azure Notebooks then closes the browser tab automatically.

Depuración de cuadernos con Visual Studio CodeDebug notebooks using Visual Studio Code

Si las celdas de código del cuaderno no se comportan de la manera esperada, quizás haya errores de código u otros defectos.If the code cells in your notebook don't behave in the way you expect, you may have code bugs or other defects. Sin embargo, aparte de usar instrucciones print para mostrar el valor de las variables, un entorno típico de Jupyter no ofrece funcionalidades de depuración.However, other than using print statements to show the value of variables, a typical Jupyter environment doesn't offer any debugging facilities.

Afortunadamente, puede descargar el archivo .ipynb del cuaderno y, después, abrirlo en Visual Studio Code con la extensión de Python.Fortunately, you can download the notebook's .ipynb file, then open it in Visual Studio Code using the Python extension. La extensión importa directamente un cuaderno como un solo archivo de código, conservando las celdas de Markdown en los comentarios.The extension directly imports a notebook as a single code file, preserving your Markdown cells in comments. Una vez importado el cuaderno, puede usar el depurador de Visual Studio Code para recorrer el código, establecer puntos de interrupción, examinar el estado, etc.Once you've imported the notebook, you can use the Visual Studio Code debugger to step through your code, set breakpoints, examine state, and so forth. Después de realizar correcciones en el código, exporte el archivo .ipynb de Visual Studio Code y cárguelo en Azure Notebooks.After making corrections to your code, you then export the .ipynb file from Visual Studio Code and upload it back into Azure Notebooks.

Para más información, consulte el artículo Debug a Jupyter notebook (Depurar un cuaderno de Jupyter) en la documentación de Visual Studio Code.For more information, see Debug a Jupyter notebook in the Visual Studio Code documentation.

Consulte también Visual Studio Code - Jupyter support (Visual Studio Code: compatibilidad con Jupyter) para conocer las características adicionales de Visual Studio Code para cuadernos de Jupyter.Also see Visual Studio Code - Jupyter support for additional features of Visual Studio Code for Jupyter notebooks.

Pasos siguientesNext steps

Artículos de procedimientos:How-to articles: