Apuntes Azure Data Scientist

Exploring Data with Python
A significant part of a a data scientist's role is to explore, analyze, and visualize data.
There are many tools and programming languages that they can use to do this. One
of the most popular approaches is to use Jupyter notebooks (like this one) and
Python.
Python is a flexible programming language that is used in a wide range of

scenarios—from web applications to device programming. It's extremely popular in
the data science and machine learning community because of the many packages it
supports for data analysis and visualization.
In this notebook, we'll explore some of these packages and apply basic techniques
to analyze data. This is not intended to be a comprehensive Python programming
exercise or even a deep dive into data analysis. Rather, it's intended as a crash
course in some of the common ways in which data scientists can use Python to
work with data.
Note: If you've never used the Jupyter Notebooks environment before, there are a few
things you should be aware of:
● Notebooks are made up of cells. Some cells (like this one) contain
markdown text, while others (like the one beneath this one) contain
code.
● You can run each code cell by using the ► Run button. The ► Run
button will show up when you hover over the cell.
● The output from each code cell will be displayed immediately below the
cell.
● Even though the code cells can be run individually, some variables used
in the code are global to the notebook. That means that you should run
all of the code cells in order. There may be dependencies between code
cells, so if you skip a cell, subsequent cells might not run correctly.
Exploring data arrays with NumPy

Let's start by looking at some simple data.
Suppose a college professor takes a sample of student grades from a class to

analyze.
Run the code in the cell below by clicking the ► Run button to see the data.
data =
[50,50,47,97,49,3,53,42,26,74,82,62,37,15,70,27,36,35,48,52,63,64]
print(data)
The data has been loaded into a Python list structure, which is a good data type for
general data manipulation, but it's not optimized for numeric analysis. For that, we're
going to use the NumPy package, which includes specific data types and functions
for working with Numbers in Python.
Run the cell below to load the data into a NumPy array.
import numpy as np
grades = np.array(data)
print(grades)
Just in case you're wondering about the differences between a list and a NumPy
array, let's compare how these data types behave when we use them in an
expression that multiplies them by 2.
print (type(data),'x 2:', data * 2)
print('---')
print (type(grades),'x 2:', grades * 2)
Note that multiplying a list by 2 creates a new list of twice the length with the original
sequence of list elements repeated. Multiplying a NumPy array on the other hand
performs an element-wise calculation in which the array behaves like a vector, so we
end up with an array of the same size in which each element has been multiplied by
2.
The key takeaway from this is that NumPy arrays are specifically designed to support
mathematical operations on numeric data—which makes them more useful for data
analysis than a generic list.
You might have spotted that the class type for the NumPy array above is a
numpy.ndarray. The nd indicates that this is a structure that can consist of multiple
dimensions. (It can have n dimensions.) Our specific instance has a single dimension
of student grades.
Run the cell below to view the shape of the array.

grades.shape
The shape confirms that this array has only one dimension, which contains 22
elements. (There are 22 grades in the original list.) You can access the individual
elements in the array by their zero-based ordinal position. Let's get the first element
(the one in position 0).
grades[0]
Now that you know your way around a NumPy array, it's time to perform some
analysis of the grades data.
You can apply aggregations across the elements in the array, so let's find the simple
average grade (in other words, the mean grade value).
grades.mean()
So the mean grade is just around 50—more or less in the middle of the possible
range from 0 to 100.
Let's add a second set of data for the same students. This time, we'll record the
typical number of hours per week they devoted to studying.
# Define an array of study hours
study_hours = [10.0,11.5,9.0,16.0,9.25,1.0,11.5,9.0,8.5,14.5,15.5,
13.75,9.0,8.0,15.5,8.0,9.0,6.0,10.0,12.0,12.5,12.0]
# Create a 2D array (an array of arrays)
student_data = np.array([study_hours, grades])
# display the array
student_data
Now the data consists of a 2-dimensional array—an array of arrays. Let's look at its
shape.
# Show shape of 2D array
student_data.shape
The student_data array contains two elements, each of which is an array containing
22 elements.
To navigate this structure, you need to specify the position of each element in the
hierarchy. So to find the first value in the first array (which contains the study hours
data), you can use the following code.
# Show the first element of the first element
student_data[0][0]
Now you have a multidimensional array containing both the student's study time and
grade information, which you can use to compare study time to a student's grade.
# Get the mean value of each sub-array
avg_study = student_data[0].mean()
avg_grade = student_data[1].mean()
print('Average study hours: {:.2f}\nAverage grade:
{:.2f}'.format(avg_study, avg_grade))
Exploring tabular data with Pandas

NumPy provides a lot of the functionality and tools you need to work with numbers,
such as arrays of numeric values. However, when you start to deal with
two-dimensional tables of data, the Pandas package offers a more convenient
structure to work with: the DataFrame.
Run the following cell to import the Pandas library and create a DataFrame with three
columns. The first column is a list of student names, and the second and third
columns are the NumPy arrays containing the study time and grade data.
import pandas as pd
df_students = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie',
'Ethan', 'Vicky', 'Frederic', 'Jimmie',
'Rhonda', 'Giovanni', 'Francesca',
'Rajab', 'Naiyana', 'Kian', 'Jenny',
'Jakeem','Helena','Ismat','Anila','Skye','Daniel','Aisha'],
'StudyHours':student_data[0],
'Grade':student_data[1]})
df_students
Note that in addition to the columns you specified, the DataFrame includes an index
to uniquely identify each row. We could have specified the index explicitly and
assigned any kind of appropriate value (for example, an email address). However,
because we didn't specify an index, one has been created with a unique integer value
for each row.
Finding and filtering data in a DataFrame

You can use the DataFrame's loc method to retrieve data for a specific index value,
like this.
# Get the data for index value 5
df_students.loc[5]
You can also get the data at a range of index values, like this:
# Get the rows with index values from 0 to 5
df_students.loc[0:5]
In addition to being able to use the loc method to find rows based on the index, you
can use the iloc method to find rows based on their ordinal position in the DataFrame
(regardless of the index):
# Get data in the first five rows
df_students.iloc[0:5]
Look carefully at the iloc[0:5] results, and compare them to the loc[0:5]
results you obtained previously. Can you spot the difference?
The loc method returned rows with index label in the list of values from 0 to 5, which
includes 0, 1, 2, 3, 4, and 5 (six rows). However, the iloc method returns the rows in
the positions included in the range 0 to 5. Since integer ranges don't include the
upper-bound value, this includes positions 0, 1, 2, 3, and 4 (five rows).
iloc identifies data values in a DataFrame by position, which extends beyond rows to
columns. So, for example, you can use it to find the values for the columns in
positions 1 and 2 in row 0, like this:
df_students.iloc[0,[1,2]]
Let's return to the loc method, and see how it works with columns. Remember that
loc is used to locate data items based on index values rather than positions. In the
absence of an explicit index column, the rows in our DataFrame are indexed as
integer values, but the columns are identified by name:
df_students.loc[0,'Grade']
Here's another useful trick. You can use the loc method to find indexed rows based
on a filtering expression that references named columns other than the index, like
this:
df_students.loc[df_students['Name']=='Aisha']
Actually, you don't need to explicitly use the loc method to do this. You can simply
apply a DataFrame filtering expression, like this:
df_students[df_students['Name']=='Aisha']
And for good measure, you can achieve the same results by using the DataFrame's
query method, like this:
df_students.query('Name=="Aisha"')
The three previous examples underline a confusing truth about working with Pandas.
Often, there are multiple ways to achieve the same results. Another example of this
is the way you refer to a DataFrame column name. You can specify the column name
as a named index value (as in the df_students['Name'] examples we've seen so
far), or you can use the column as a property of the DataFrame, like this:
df_students[df_students.Name == 'Aisha']
Loading a DataFrame from a file

We constructed the DataFrame from some existing arrays. However, in many
real-world scenarios, data is loaded from sources such as files. Let's replace the
student grades DataFrame with the contents of a text file.
!wget
https://raw.githubusercontent.com/MicrosoftDocs/mslearn-introduction-to
-machine-learning/main/Data/ml-basics/grades.csv
df_students = pd.read_csv('grades.csv',delimiter=',',header='infer')
df_students.head()
The DataFrame's read_csv method is used to load data from text files. As you can
see in the example code, you can specify options such as the column delimiter and
which row (if any) contains column headers. (In this case, the delimiter is a comma
and the first row contains the column names. These are the default settings, so the
parameters could have been omitted.)
Handling missing values

One of the most common issues data scientists need to deal with is incomplete or
missing data. So how would we know that the DataFrame contains missing values?
You can use the isnull method to identify which individual values are null, like this:
df_students.isnull()
Of course, with a larger DataFrame, it would be inefficient to review all of the rows
and columns individually, so we can get the sum of missing values for each column
like this:
df_students.isnull().sum()
So now we know that there's one missing StudyHours value and two missing Grade
values.
To see them in context, we can filter the DataFrame to include only rows where any
of the columns (axis 1 of the DataFrame) are null.
df_students[df_students.isnull().any(axis=1)]
When the DataFrame is retrieved, the missing numeric values show up as NaN (not a
number).
So now that we've found the null values, what can we do about them?
One common approach is to impute replacement values. For example, if the number
of study hours is missing, we could just assume that the student studied for an
average amount of time and replace the missing value with the mean study hours. To
do this, we can use the fillna method like this:
df_students.StudyHours =
df_students.StudyHours.fillna(df_students.StudyHours.mean())
df_students
Alternatively, it might be important to ensure that you only use data you know to be
absolutely correct. In this case, you can drop rows or columns that contain null
values by using the dropna method. For example, we'll remove rows (axis 0 of the
DataFrame) where any of the columns contain null values:
df_students = df_students.dropna(axis=0, how='any')
df_students
Explore data in the DataFrame
Now that we've cleaned up the missing values, we're ready to explore the data in the
DataFrame. Let's start by comparing the mean study hours and grades.
# Get the mean study hours using to column name as an index
mean_study = df_students['StudyHours'].mean()
# Get the mean grade using the column name as a property (just to make
the point!)
mean_grade = df_students.Grade.mean()
# Print the mean study hours and mean grade
print('Average weekly study hours: {:.2f}\nAverage grade:
{:.2f}'.format(mean_study, mean_grade))
OK, let's filter the DataFrame to find only the students who studied for more than the
average amount of time.
# Get students who studied for the mean or more hours
df_students[df_students.StudyHours > mean_study]
Note that the filtered result is itself a DataFrame, so you can work with its columns
just like any other DataFrame.
For example, let's find the average grade for students who undertook more than the
average amount of study time.
# What was their mean grade?
df_students[df_students.StudyHours > mean_study].Grade.mean()
Let's assume that the passing grade for the course is 60.
We can use that information to add a new column to the DataFrame that indicates
whether or not each student passed.
First, we'll create a Pandas Series containing the pass/fail indicator (True or False),
and then we'll concatenate that series as a new column (axis 1) in the DataFrame.
passes = pd.Series(df_students['Grade'] >= 60)
df_students = pd.concat([df_students, passes.rename("Pass")], axis=1)
df_students
DataFrames are designed for tabular data, and you can use them to perform many of
the same kinds of data analytics operations you can do in a relational database, such
as grouping and aggregating tables of data.
For example, you can use the groupby method to group the student data into groups
based on the Pass column you added previously and to count the number of names
in each group. In other words, you can determine how many students passed and
failed.
print(df_students.groupby(df_students.Pass).Name.count())
You can aggregate multiple fields in a group using any available aggregation
function. For example, you can find the mean study time and grade for the groups of
students who passed and failed the course.
print(df_students.groupby(df_students.Pass)['StudyHours',
'Grade'].mean())
DataFrames are amazingly versatile and make it easy to manipulate data. Many
DataFrame operations return a new copy of the DataFrame. So if you want to modify
a DataFrame but keep the existing variable, you need to assign the result of the
operation to the existing variable. For example, the following code sorts the student
data into descending order by Grade and assigns the resulting sorted DataFrame to
the original df_students variable.
# Create a DataFrame with the data sorted by Grade (descending)
df_students = df_students.sort_values('Grade', ascending=False)
# Show the DataFrame
df_students
Summary
NumPy and DataFrames are the workhorses of data science in Python. They provide
us ways to load, explore, and analyze tabular data. As we will see in subsequent
modules, even advanced analysis methods typically rely on NumPy and Pandas for
these important roles.
In our next workbook, we'll take a look at how create graphs and explore your data in
more interesting ways.
Exploring data with Python -
visualize data
In this notebook, we'll apply a few techniques to analyze data with basic statistics
and visualize it using graphs.
Loading our data

Before we begin, let's load the same data about study hours that we analyzed in the
previous notebook. We'll also recalculate who passed the class in the same way as
last time.
Run the code in the cell below by clicking the ► Run button to see the data.
import pandas as pd
# Load data from a text file
!wget
# Remove any rows with missing data
# Calculate who passed, assuming '60' is the grade needed to pass
# Save who passed to the Pandas dataframe
# Print the result out into this notebook
df_students
Visualizing data with Matplotlib

DataFrames provide a great way to explore and analyze tabular data, but sometimes
a picture is worth a thousand rows and columns. The Matplotlib library provides the
foundation for plotting data visualizations that can greatly enhance your ability to
analyze the data.
Let's start with a simple bar chart that shows the grade of each student.
Note: This first graph may take 1 to 2 minutes to render. Subsequent graphs will
render more quickly.
# Ensure plots are displayed inline in the notebook
%matplotlib inline
from matplotlib import pyplot as plt
# Create a bar plot of name vs grade
plt.bar(x=df_students.Name, height=df_students.Grade)
# Display the plot
plt.show()
Well, that worked, but the chart could use some improvements to make it clearer
what we're looking at.
Note that you used the pyplot class from Matplotlib to plot the chart. This class
provides many ways to improve the visual elements of the plot. For example, the
following code:
● Specifies the color of the bar chart.

● Adds a title to the chart (so we know what it represents)
● Adds labels to the X and Y axes (so we know which axis shows which data)
● Adds a grid (to make it easier to determine the values for the bars)
● Rotates the X markers (so we can read them)
plt.bar(x=df_students.Name, height=df_students.Grade, color='orange')
# Customize the chart
plt.title('Student Grades')
plt.xlabel('Student')
plt.ylabel('Grade')
plt.grid(color='#95a5a6', linestyle='--', linewidth=2, axis='y',
alpha=0.7)
plt.xticks(rotation=90)
# Display the plot
plt.show()
Resultado:
A plot is technically contained within a Figure. In the previous examples, the figure
was created implicitly for you, but you can create it explicitly. For example, the
following code creates a figure with a specific size.
# Create a Figure
fig = plt.figure(figsize=(8,3))
plt.bar(x=df_students.Name, height=df_students.Grade, color='orange')
# Customize the chart
plt.title('Student Grades')
plt.xlabel('Student')
plt.ylabel('Grade')
plt.grid(color='#95a5a6', linestyle='--', linewidth=2, axis='y',
alpha=0.7)
plt.xticks(rotation=90)
# Show the figure
plt.show()
Resultado: La vetana toma el tamaño definido configurado en el código
A figure can contain multiple subplots, each on its own axis.
For example, the following code creates a figure with two subplots: one is a bar chart
showing student grades, and the other is a pie chart comparing the number of
passing grades to non-passing grades.
# Create a figure for 2 subplots (1 row, 2 columns)
fig, ax = plt.subplots(1, 2, figsize = (10,4))
# Create a bar plot of name vs grade on the first axis
ax[0].bar(x=df_students.Name, height=df_students.Grade, color='orange')
ax[0].set_title('Grades')
ax[0].set_xticklabels(df_students.Name, rotation=90)
# Create a pie chart of pass counts on the second axis
pass_counts = df_students['Pass'].value_counts()
ax[1].pie(pass_counts, labels=pass_counts)
ax[1].set_title('Passing Grades')
ax[1].legend(pass_counts.keys().tolist())
# Add a title to the Figure
fig.suptitle('Student Data')
# Show the figure
fig.show()
Resultado:
Until now, you've used methods of the Matplotlib.pyplot object to plot charts.
However, Matplotlib is so foundational to graphics in Python that many packages,
including Pandas, provide methods that abstract the underlying Matplotlib functions
and simplify plotting. For example, the DataFrame provides its own methods for
plotting data as shown in the following example, which plots a bar chart of study
hours.
df_students.plot.bar(x='Name', y='StudyHours', color='teal',
figsize=(6,4))
Getting started with statistical analysis

Now that you know how to use Python to manipulate and visualize data, you can
start analyzing it.
A lot of data science is rooted in statistics, so we'll explore some basic statistical
techniques.
Note: This section is not intended to teach you statistics—that's much too big a topic
for this notebook. It will however introduce you to some statistical concepts and
techniques that data scientists use as they explore data in preparation for machine
learning modeling.
Descriptive statistics and data distribution

When examining a variable (for example, a sample of student grades), data scientists
are particularly interested in its distribution (in other words, how are all the different
grade values spread across the sample). The starting point for this exploration is
often to visualize the data as a histogram and see how frequently each value for the
variable occurs.
# Get the variable to examine
var_data = df_students['Grade']
# Create a Figure
# Plot a histogram
plt.hist(var_data)
# Add titles and labels
plt.title('Data Distribution')
plt.xlabel('Value')
plt.ylabel('Frequency')
# Show the figure
fig.show()
Resultado
The histogram for grades is a symmetric shape, where the most frequently occurring
grades tend to be in the middle of the range (around 50), with fewer grades at the
extreme ends of the scale.
Measures of central tendency

To understand the distribution better, we can examine so-called measures of central
tendency, which is a fancy way of describing statistics that represent the "middle" of
the data. The goal of this analysis is to try to find a "typical" value. Common ways to
define the middle of the data include:
● The mean: A simple average based on adding together all of the values in the
sample set and then dividing the total by the number of samples.
● The median: The value in the middle of the range of all of the sample values.
● The mode: The most commonly occurring value in the sample set*.
Let's calculate these values, along with the minimum and maximum values for
comparison, and show them on the histogram.
*Of course, in some sample sets, there may be a tie for the most common value. In
those cases, the dataset is described as bimodal or even multimodal.
var = df_students['Grade']
# Get statistics
min_val = var.min()
max_val = var.max()
mean_val = var.mean()
med_val = var.median()
mod_val = var.mode()[0]
print('Minimum:{:.2f}\nMean:{:.2f}\nMedian:{:.2f}\nMode:{:.2f}\nMaximum
:{:.2f}\n'.format(min_val,
mean_val,
med_val,
mod_val,
max_val))
# Create a Figure
# Plot a histogram
plt.hist(var)
# Add lines for the statistics
plt.axvline(x=min_val, color = 'gray', linestyle='dashed', linewidth =
2)
plt.axvline(x=mean_val, color = 'cyan', linestyle='dashed', linewidth =
2)
plt.axvline(x=med_val, color = 'red', linestyle='dashed', linewidth =
2)
plt.axvline(x=mod_val, color = 'yellow', linestyle='dashed', linewidth
= 2)
plt.axvline(x=max_val, color = 'gray', linestyle='dashed', linewidth =
2)
plt.xlabel('Value')
plt.ylabel('Frequency')
# Show the figure
fig.show()
Resultado:
For the grade data, the mean, median, and mode all seem to be more or less in the
middle of the minimum and maximum, at around 50.
Another way to visualize the distribution of a variable is to use a box plot (sometimes
called a box-and-whiskers plot). Let's create one for the grade data.
var = df_students['Grade']
# Create a Figure
# Plot a histogram
plt.boxplot(var)
# Show the figure
fig.show()
Resultado:
The box plot shows the distribution of the grade values in a format different from the
histogram. The box part of the plot shows where the inner two quartiles of the data
reside. In this case, half of the grades are between approximately 36 and 63. The
whiskers extending from the box show the outer two quartiles, so the other half of
the grades in this case are between 0 and 36 or 63 and 100. The line in the box
indicates the median value.
For learning, it can be useful to combine histograms and box plots, with the box
plot's orientation changed to align it with the histogram. (In some ways, it can be
helpful to think of the histogram as a "front elevation" view of the distribution, and the
box plot as a "plan" view of the distribution from above.)
# Create a function that we can re-use
def show_distribution(var_data):
# Get statistics
min_val = var_data.min()
max_val = var_data.max()
mean_val = var_data.mean()
med_val = var_data.median()
mod_val = var_data.mode()[0]
print('Minimum:{:.2f}\nMean:{:.2f}\nMedian:{:.2f}\nMode:{:.2f}\nMaximum
:{:.2f}\n'.format(min_val,
mean_val,
med_val,
mod_val,
max_val))
# Create a figure for 2 subplots (2 rows, 1 column)
# Plot the histogram
ax[0].hist(var_data)
ax[0].set_ylabel('Frequency')
# Add lines for the mean, median, and mode
ax[0].axvline(x=min_val, color = 'gray', linestyle='dashed',
linewidth = 2)
ax[0].axvline(x=mean_val, color = 'cyan', linestyle='dashed',
linewidth = 2)
ax[0].axvline(x=med_val, color = 'red', linestyle='dashed',
linewidth = 2)
ax[0].axvline(x=mod_val, color = 'yellow', linestyle='dashed',
linewidth = 2)
ax[0].axvline(x=max_val, color = 'gray', linestyle='dashed',
linewidth = 2)
# Plot the boxplot
ax[1].boxplot(var_data, vert=False)
ax[1].set_xlabel('Value')
fig.suptitle('Data Distribution')
# Show the figure
fig.show()
col = df_students['Grade']
# Call the function
show_distribution(col)
Resultado:
All of the measurements of central tendency are right in the middle of the data
distribution, which is symmetric with values becoming progressively lower in both
directions from the middle.
To explore this distribution in more detail, you need to understand that statistics is
fundamentally about taking samples of data and using probability functions to
extrapolate information about the full population of data.
What does this mean? Samples refer to the data we have on hand, such as
information about these 22 students' study habits and grades. The population refers
to all possible data we could collect, such as every student's grades and study habits
across every educational institution throughout the history of time. Usually we're
interested in the population, but it's simply not practical to collect all of that data.
Instead, we need to try estimate what the population is like from the small amount of
data (samples) that we have.
If we have enough samples, we can calculate something called a probability density

function, which estimates the distribution of grades for the full population.
The pyplot class from Matplotlib provides a helpful plot function to show this
density.
def show_density(var_data):
# Plot density
var_data.plot.density()
plt.title('Data Density')
# Show the mean, median, and mode
plt.axvline(x=var_data.mean(), color = 'cyan', linestyle='dashed',
linewidth = 2)
plt.axvline(x=var_data.median(), color = 'red', linestyle='dashed',
linewidth = 2)
plt.axvline(x=var_data.mode()[0], color = 'yellow',
linestyle='dashed', linewidth = 2)
# Show the figure
plt.show()
# Get the density of Grade
show_density(col)
As expected from the histogram of the sample, the density shows the characteristic
"bell curve" of what statisticians call a normal distribution with the mean and mode
at the center and symmetric tails.
Summary
Well done! There were a number of new concepts in here, so let's summarize.
Here we have:
1. Made graphs with Matplotlib.

2. Seen how to customize these graphs.
3. Calculated basic statistics, such as medians.
4. Looked at the spread of data using box plots and histograms.
5. Learned about samples versus populations.
6. Estimated what the population of grades might look like from a sample of
grades.
In our next notebook, we'll look at spotting unusual data and finding relationships
between data.
Exploring data with Python - real
world data
In the last notebook, we looked at grades for our student data and investigated the
data visually with histograms and box plots. Now we'll look into more complex cases,
describe the data more fully, and discuss how to make basic comparisons between
data.
Real world data distributions

Previously, we looked at grades for our student data and estimated from this sample
what the full population of grades might look like. Let's refresh our memory and take
a look at this data again.
Run the code below to print out the data and make a histogram + box plot that shows
the grades for our sample of students.
import pandas as pd
# Load data from a text file
!wget
# Remove any rows with missing data
# Calculate who passed, assuming '60' is the grade needed to pass
# Save who passed to the Pandas dataframe
# Print the result out into this notebook
print(df_students)
#·‌
Create·‌
a·‌
function·‌
that·‌we·‌can·‌re-use
def·‌
show_distribution(var_data):
·‌·‌·‌·'
‌ ''
·‌·‌·‌·T
‌ his·‌
function·‌
will·‌
make·‌a·‌
distribution·‌(graph)·‌and·‌
display·‌it
·‌·‌·‌·'
‌ ''
·‌·‌·‌·#
‌ ·‌Get·‌
statistics
·‌·‌·‌·m
‌ in_val·‌=·‌
var_data.min()
·‌·‌·‌·m
‌ ax_val·‌=·‌
var_data.max()
·‌·‌·‌·m
‌ ean_val·‌=·‌
var_data.mean()
·‌·‌·‌·m
‌ ed_val·‌=·‌
var_data.median()
·‌·‌·‌·m
‌ od_val·‌=·‌
var_data.mode()[0]
·‌·‌·‌·p
‌ rint('Minimum:{:.2f}\nMean:{:.2f}\nMedian:{:.2f}\nMode:{:.2f}\nMax
imum:{:.2f}\n'.format(min_val,
·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌
·‌·‌·‌·‌·‌·‌·m‌ ean_val,
·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌
·‌·‌·‌·‌·‌·‌·m‌ ed_val,
·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌
·‌·‌·‌·‌·‌·‌·m‌ od_val,
·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌·‌
·‌·‌·‌·‌·‌·‌·m‌ ax_val))
·‌·‌·‌·#
‌ ·‌Create·‌
a·‌
figure·‌for·‌2·‌subplots·‌
(2·‌rows,·‌1·‌
column)
·‌·‌·‌·f
‌ ig,·‌ax·‌=·‌
plt.subplots(2,·‌
1,·‌figsize·‌=·‌(10,4))
·‌·‌·‌·#
‌ ·‌Plot·‌the·‌
histogram·‌·‌·‌
·‌·‌·‌·a
‌ x[0].hist(var_data)
·‌·‌·‌·a
‌ x[0].set_ylabel('Frequency')
·‌·‌·‌·#
‌ ·‌Add·‌
lines·‌
for·‌
the·‌mean,·‌
median,·‌and·‌mode
·‌·‌·‌·a
‌ x[0].axvline(x=min_val,·‌color·‌=·‌
'gray',·‌
linestyle='dashed',·‌linewi
dth·‌=·‌ 2)
·‌·‌·‌·a
‌ x[0].axvline(x=mean_val,·‌
color·‌=·‌
'cyan',·‌linestyle='dashed',·‌
linew
idth·‌=·‌ 2)
·‌·‌·‌·a
‌ x[0].axvline(x=med_val,·‌color·‌=·‌
'red',·‌
linestyle='dashed',·‌linewid
th·‌=·‌2)
·‌·‌·‌·a
‌ x[0].axvline(x=mod_val,·‌color·‌=·‌
'yellow',·‌linestyle='dashed',·‌
line
width·‌=·‌2)
·‌·‌·‌·a
‌ x[0].axvline(x=max_val,·‌color·‌=·‌
'gray',·‌
linestyle='dashed',·‌linewi
dth·‌=·‌ 2)
·‌·‌·‌·#
‌ ·‌Plot·‌the·‌
boxplot·‌·‌·‌
·‌·‌·‌·a
‌ x[1].boxplot(var_data,·‌
vert=False)
·‌·‌·‌·a
‌ x[1].set_xlabel('Value')
·‌·‌·‌·#
‌ ·‌Add·‌
a·‌
title·‌
to·‌the·‌Figure
·‌·‌·‌·f
‌ ig.suptitle('Data·‌
Distribution')
·‌·‌·‌·#
‌ ·‌Show·‌the·‌
figure
·‌·‌·‌·f
‌ ig.show()
show_distribution(df_students['Grade'])
As you might recall, our data had the mean and mode at the center, with data spread
symmetrically from there.
Now let's take a look at the distribution of the study hours data.
#·‌
Get·‌
the·‌
variable·‌to·‌examine
col·‌=·‌
df_students['StudyHours']
#·‌
Call·‌
the·‌
function
Resultado:
The distribution of the study time data is significantly different from that of the
grades.
Note that the whiskers of the box plot only begin at around 6.0, indicating that the
vast majority of the first quarter of the data is above this value. The minimum is
marked with an o, indicating that it is statistically an outlier—a value that lies
significantly outside the range of the rest of the distribution.
Outliers can occur for many reasons. Maybe a student meant to record "10" hours of
study time, but entered "1" and missed the "0". Or maybe the student was abnormally
lazy when it comes to studying! Either way, it's a statistical anomaly that doesn't
represent a typical student. Let's see what the distribution looks like without it.
# We will only get students who have studied more than one hour
col = df_students[df_students.StudyHours>1]['StudyHours']
# Call the function
Resultado:
For learning purposes, we have just treated the value 1 as a true outlier here and
excluded it. In the real world, it would be unusual to exclude data at the extremes
without more justification when our sample size is so small. This is because the
smaller our sample size, the more likely it is that our sampling is a bad
representation of the whole population. (Here, the population means grades for all
students, not just our 22.) For example, if we sampled study time for another 1,000
students, we might find that it's actually quite common to not study much!
When we have more data available, our sample becomes more reliable. This makes it
easier to consider outliers as being values that fall below or above percentiles within
which most of the data lie. For example, the following code uses the Pandas quantile
function to exclude observations below the 0.01th percentile (the value above which
99% of the data reside).
# calculate the 0.01th percentile
q01 = df_students.StudyHours.quantile(0.01)
col = df_students[df_students.StudyHours>q01]['StudyHours']
# Call the function
Resultado:
Tip: You can also eliminate outliers at the upper end of the distribution by defining a
threshold at a high percentile value. For example, you could use the quantile function
to find the 0.99 percentile below which 99% of the data reside.
With the outliers removed, the box plot shows all data within the four quartiles. Note
that the distribution is not symmetric like it is for the grade data. There are some
students with very high study times of around 16 hours, but the bulk of the data is
between 7 and 13 hours. The few extremely high values pull the mean towards the
higher end of the scale.
Let's look at the density for this distribution.

def show_density(var_data):
# Plot density
var_data.plot.density()
plt.title('Data Density')
# Show the mean, median, and mode
plt.axvline(x=var_data.mean(), color = 'cyan', linestyle='dashed',
linewidth = 2)
plt.axvline(x=var_data.median(), color = 'red', linestyle='dashed',
linewidth = 2)
plt.axvline(x=var_data.mode()[0], color = 'yellow',
linestyle='dashed', linewidth = 2)
# Show the figure
plt.show()
# Get the density of StudyHours
show_density(col)
Resultado:
This kind of distribution is called right skewed. The mass of the data is on the left
side of the distribution, creating a long tail to the right because of the values at the
extreme high end, which pull the mean to the right.
Measures of variance
So now we have a good idea where the middle of the grade and study hours data
distributions are. However, there's another aspect of the distributions we should
examine: how much variability is there in the data?
Typical statistics that measure variability in the data include:
● Range: The difference between the maximum and minimum. There's no

built-in function for this, but it's easy to calculate using the min and max
functions.
● Variance: The average of the squared difference from the mean. You can use
the built-in var function to find this.
● Standard Deviation: The square root of the variance. You can use the built-in
std function to find this.
for col_name in ['Grade','StudyHours']:
col = df_students[col_name]
rng = col.max() - col.min()
var = col.var()
std = col.std()
print('\n{}:\n - Range: {:.2f}\n - Variance: {:.2f}\n - Std.Dev:
{:.2f}'.format(col_name, rng, var, std))
Of these statistics, the standard deviation is generally the most useful. It provides a
measure of variance in the data on the same scale as the data itself (so grade points
for the Grade distribution and hours for the StudyHours distribution). The higher the
standard deviation, the more variance there is when comparing values in the
distribution to the distribution mean—in other words, the data is more spread out.
When working with a normal distribution, the standard deviation works with the
particular characteristics of a normal distribution to provide even greater insight. Run
the cell below to see the relationship between standard deviations and the data in
the normal distribution.
import scipy.stats as stats
# Get the Grade column
# get the density
density = stats.gaussian_kde(col)
# Plot the density
col.plot.density()
# Get the mean and standard deviation
s = col.std()
m = col.mean()
# Annotate 1 stdev
x1 = [m-s, m+s]
y1 = density(x1)
plt.plot(x1,y1, color='magenta')
plt.annotate('1 std (68.26%)', (x1[1],y1[1]))
# Annotate 2 stdevs
x2 = [m-(s*2), m+(s*2)]
y2 = density(x2)
plt.plot(x2,y2, color='green')
# Annotate 3 stdevs
x3 = [m-(s*3), m+(s*3)]
y3 = density(x3)
plt.plot(x3,y3, color='orange')
# Show the location of the mean
plt.axvline(col.mean(), color='cyan', linestyle='dashed', linewidth=1)
plt.axis('off')
plt.show()
Resultado:
The horizontal lines show the percentage of data within 1, 2, and 3 standard
deviations of the mean (plus or minus).
In any normal distribution:
● Approximately 68.26% of values fall within one standard deviation from the
mean.
● Approximately 95.45% of values fall within two standard deviations from the
mean.
● Approximately 99.73% of values fall within three standard deviations from the
mean.
So, since we know that the mean grade is 49.18, the standard deviation is 21.74, and
distribution of grades is approximately normal, we can calculate that 68.26% of
students should achieve a grade between 27.44 and 70.92.
The descriptive statistics we've used to understand the distribution of the student
data variables are the basis of statistical analysis. Because they're such an
important part of exploring your data, there's a built-in describe method of the
DataFrame object that returns the main descriptive statistics for all numeric
columns.
df_students.describe()
Comparing data
Now that you know something about the statistical distribution of the data in your
dataset, you're ready to examine your data to identify any apparent relationships
between variables.
First of all, let's get rid of any rows that contain outliers so that we have a sample
that is representative of a typical class of students. We identified that the
StudyHours column contains some outliers with extremely low values, so we'll
remove those rows.
df_sample = df_students[df_students['StudyHours']>1]
df_sample
Comparing numeric and categorical variables

The data includes two numeric variables (StudyHours and Grade) and two
categorical variables (Name and Pass). Let's start by comparing the numeric
StudyHours column to the categorical Pass column to see if there's an apparent
relationship between the number of hours studied and a passing grade.
To make this comparison, let's create box plots showing the distribution of
StudyHours for each possible Pass value (true and false).
df_sample.boxplot(column='StudyHours', by='Pass', figsize=(8,5))
Comparing the StudyHours distributions, it's immediately apparent (if not particularly
surprising) that students who passed the course tended to study for more hours than
students who didn't. So if you wanted to predict whether or not a student is likely to
pass the course, the amount of time they spend studying may be a good predictive
indicator.
Comparing numeric variables

Now let's compare two numeric variables. We'll start by creating a bar chart that
shows both grade and study hours.
# Create a bar plot of name vs grade and study hours
df_sample.plot(x='Name', y=['Grade','StudyHours'], kind='bar',
figsize=(8,5))
Resultado:
The chart shows bars for both grade and study hours for each student, but it's not
easy to compare because the values are on different scales. A grade is measured in
grade points (and ranges from 3 to 97), and study time is measured in hours (and
ranges from 1 to 16).
A common technique when dealing with numeric data in different scales is to

normalize the data so that the values retain their proportional distribution but are
measured on the same scale. To accomplish this, we'll use a technique called
MinMax scaling that distributes the values proportionally on a scale of 0 to 1. You
could write the code to apply this transformation, but the Scikit-Learn library provides
a scaler to do it for you.
from sklearn.preprocessing import MinMaxScaler
# Get a scaler object
scaler = MinMaxScaler()
# Create a new dataframe for the scaled values
df_normalized = df_sample[['Name', 'Grade', 'StudyHours']].copy()
# Normalize the numeric columns
df_normalized[['Grade','StudyHours']] =
scaler.fit_transform(df_normalized[['Grade','StudyHours']])
# Plot the normalized values
df_normalized.plot(x='Name', y=['Grade','StudyHours'], kind='bar',
figsize=(8,5))
Resultado
With the data normalized, it's easier to see an apparent relationship between grade
and study time. It's not an exact match, but it definitely seems like students with
higher grades tend to have studied more.
So there seems to be a correlation between study time and grade. In fact, there's a
statistical correlation measurement we can use to quantify the relationship between
these columns.
df_normalized.Grade.corr(df_normalized.StudyHours)
The correlation statistic is a value between -1 and 1 that indicates the strength of a
relationship. Values above 0 indicate a positive correlation (high values of one
variable tend to coincide with high values of the other), while values below 0 indicate
a negative correlation (high values of one variable tend to coincide with low values of
the other). In this case, the correlation value is close to 1, showing a strongly positive
correlation between study time and grade.
Note: Data scientists often quote the maxim "correlation is not causation". In other
words, as tempting as it might be, you shouldn't interpret the statistical correlation as
explaining why one of the values is high. In the case of the student data, the
statistics demonstrate that students with high grades tend to also have high
amounts of study time, but this is not the same as proving that they achieved high
grades because they studied a lot. The statistic could equally be used as evidence to
support the nonsensical conclusion that the students studied a lot because their
grades were going to be high.
Another way to visualize the apparent correlation between two numeric columns is
to use a scatter plot.
# Create a scatter plot
df_sample.plot.scatter(title='Study Time vs Grade', x='StudyHours',
y='Grade')
Again, it looks like there's a discernible pattern in which the students who studied the
most hours are also the students who got the highest grades.
We can see this more clearly by adding a regression line (or a line of best fit) to the
plot that shows the general trend in the data. To do this, we'll use a statistical
technique called least squares regression.
Remember when you were learning how to solve linear equations in school, and
recall that the slope-intercept form of a linear equation looks like this:
�=��+�
In this equation, y and x are the coordinate variables, m is the slope of the line, and b
is the y-intercept (where the line goes through the Y-axis).
In the case of our scatter plot for our student data, we already have our values for x
(StudyHours) and y (Grade), so we just need to calculate the intercept and slope of
the straight line that lies closest to those points. Then we can form a linear equation
that calculates a new y value on that line for each of our x (StudyHours) values. To
avoid confusion, we'll call this new y value f(x) (because it's the output from a linear
equation function based on x). The difference between the original y (Grade) value
and the f(x) value is the error between our regression line and the actual Grade
achieved by the student. Our goal is to calculate the slope and intercept for a line
with the lowest overall error.
Specifically, we define the overall error by taking the error for each point, squaring it,
and adding all the squared errors together. The line of best fit is the line that gives us
the lowest value for the sum of the squared errors—hence the name least squares
regression.
Fortunately, you don't need to code the regression calculation yourself. The SciPy
package includes a stats class that provides a linregress method to do the hard work
for you. This returns (among other things) the coefficients you need for the slope
equation: slope (m) and intercept (b) based on a given pair of variable samples you
want to compare.
from scipy import stats
#
df_regression = df_sample[['Grade', 'StudyHours']].copy()
# Get the regression slope and intercept
m, b, r, p, se = stats.linregress(df_regression['StudyHours'],
df_regression['Grade'])
print('slope: {:.4f}\ny-intercept: {:.4f}'.format(m,b))
print('so...\n f(x) = {:.4f}x + {:.4f}'.format(m,b))
# Use the function (mx + b) to calculate f(x) for each x (StudyHours)
value
df_regression['fx'] = (m * df_regression['StudyHours']) + b
# Calculate the error between f(x) and the actual y (Grade) value
df_regression['error'] = df_regression['fx'] - df_regression['Grade']
# Create a scatter plot of Grade vs StudyHours
df_regression.plot.scatter(x='StudyHours', y='Grade')
# Plot the regression line
plt.plot(df_regression['StudyHours'],df_regression['fx'], color='cyan')
# Display the plot
plt.show()
Resultado
Note that this time, the code plotted two distinct things—the scatter plot of the
sample study hours and grades is plotted as before, and then a line of best fit based
on the least squares regression coefficients is plotted.
The slope and intercept coefficients calculated for the regression line are shown
above the plot.
The line is based on the f(x) values calculated for each StudyHours value. Run the
following cell to see a table that includes the following values:
● The StudyHours for each student.

● The Grade achieved by each student.
● The f(x) value calculated using the regression line coefficients.
● The error between the calculated f(x) value and the actual Grade value.
Some of the errors, particularly at the extreme ends, and quite large (up to over 17.5
grade points). But, in general, the line is pretty close to the actual grades.
# Show the original x,y values, the f(x) value, and the error
df_regression[['StudyHours', 'Grade', 'fx', 'error']]
Using the regression coefficients for prediction

Now that you have the regression coefficients for the study time and grade
relationship, you can use them in a function to estimate the expected grade for a
given amount of study.
# Define a function based on our regression coefficients
def f(x):
m = 6.3134
b = -17.9164
return m*x + b
study_time = 14
# Get f(x) for study time
prediction = f(study_time)
# Grade can't be less than 0 or more than 100
expected_grade = max(0,min(100,prediction))
#Print the estimated grade
print ('Studying for {} hours per week may result in a grade of
{:.0f}'.format(study_time, expected_grade))
So by applying statistics to sample data, you've determined a relationship between
study time and grade and encapsulated that relationship in a general function that
can be used to predict a grade for a given amount of study time.
This technique is in fact the basic premise of machine learning. You can take a set of
sample data that includes one or more features (in this case, the number of hours
studied) and a known label value (in this case, the grade achieved) and use the
sample data to derive a function that calculates predicted label values for any given
set of features.
Summary
Here we've looked at:
1. What an outlier is and how to remove them

2. How data can be skewed
3. How to look at the spread of data
4. Basic ways to compare variables, such as grades and study time
Entrenamiento y evaluación de
modelos de regresión
Introducción
Completado
100 XP
2 minutos
Los modelos usan la regresión para predecir un número.
En el aprendizaje automático, el objetivo de la regresión es crear un modelo que

pueda predecir un valor numérico y cuantificable, por ejemplo, un precio, una
cantidad, un tamaño u otro número escalar.
La regresión es una técnica estadística de importancia fundamental para la ciencia

debido a su facilidad de interpretación, solidez y velocidad en el cálculo. Los
modelos de regresión proporcionan una base excelente para comprender cómo
funcionan las técnicas de aprendizaje automático más complejas.
En situaciones reales, especialmente cuando hay pocos datos disponibles, los

modelos de regresión son muy útiles para realizar predicciones. Por ejemplo, si una
empresa que alquila bicicletas quiere predecir el número esperado de alquileres en
un día determinado en el futuro, un modelo de regresión puede predecir este
número. Se podría crear un modelo con datos existentes, como el número de
bicicletas alquiladas en determinados días y en los que también se registró la
estación, el día de la semana, y así sucesivamente.
Requisitos previos
● Conocimientos de matemáticas básicas
● Experiencia previa con la programación en Python
Objetivos de aprendizaje
Objetivos de este módulo:
● Cuándo usar modelos de regresión.

● Cómo entrenar y evaluar los modelos de regresión con el marco de
Scikit-learn.
Siguiente unidad: ¿Qué es la regresión?
¿Qué es la regresión?
Completado
100 XP
8 minutos
La regresión consiste en establecer una relación entre las variables de los datos que
representan propiedades (conocidas como características) de lo que se está
observando y la variable que se está intentando predecir (conocida como etiqueta).
Recuerde nuestra empresa que alquila bicicletas y quiere predecir el número
esperado de alquileres en un día determinado. En este caso, las características
incluyen cosas como el día de la semana, el mes, etc., y la etiqueta es el número de
alquileres de bicicletas.
Para entrenar el modelo, comenzamos con una muestra de datos que contiene las
características, así como los valores conocidos de la etiqueta, por lo que, en este
caso, necesitamos datos históricos que incluyan fechas, condiciones meteorológicas
y el número de alquileres de bicicletas.
A continuación, esta muestra de datos se divide en dos subconjuntos:
● Un conjunto de datos de entrenamiento al que aplicaremos un algoritmo

que determina una función que encapsula la relación entre los valores
de las características y los valores de etiqueta conocidos.
● Un conjunto de datos de validación o de prueba que se puede usar para
evaluar el modelo mediante su uso para generar predicciones para la
etiqueta y su comparación con los valores de etiqueta conocidos reales.
El uso de datos históricos con valores de etiqueta conocidos para entrenar un

modelo hace que la regresión sea un ejemplo de aprendizaje automático
supervisado.
Un ejemplo sencillo
Observemos un ejemplo sencillo para ver cómo funciona el proceso de

entrenamiento y evaluación en principio. Simplifiquemos el escenario para que se
use una sola característica, la temperatura media diaria, para predecir la etiqueta de
alquileres de bicicletas.
Comenzamos con algunos datos que incluyen valores conocidos para la

característica de temperatura media diaria y la etiqueta de alquileres de bicicletas.
Temperatura Alquileres
56 115
61 126
67 137
72 140
76 152
82 156
54 114
62 129
Ahora seleccionaremos aleatoriamente cinco de estas observaciones y las

usaremos para entrenar un modelo de regresión. Cuando hablamos de "entrenar un
modelo", lo que queremos decir es encontrar una función (una ecuación
matemática; vamos a llamarla f) que puede usar la característica de temperatura (a
la que llamaremos x) para calcular el número de alquileres (que llamaremos y). En
otras palabras, tenemos que definir la función siguiente: f(x) = y.
Nuestro conjunto de datos de entrenamiento tiene el siguiente aspecto:
x y
56 115
61 126
67 137
72 140
76 152
Comencemos por trazar los valores de entrenamiento de x e y en un gráfico:
Ahora es necesario ajustar estos valores a una función, permitiendo una cierta
variación aleatoria. Probablemente pueda ver que los puntos trazados forman casi
una línea recta diagonal; es decir, existe una supuesta relación lineal entre x e y, por
lo que tenemos que encontrar una función lineal que se ajuste de la mejor manera a
la muestra de datos. Hay varios algoritmos que se pueden usar para establecer esta
función que, en definitiva, buscará una línea recta con la varianza total mínima de
los puntos trazados, de este modo:
La línea representa una función lineal que se puede usar con cualquier valor de x
para aplicar la pendiente de la línea y su intersección (donde la línea cruza el eje y
cuando x es 0) para calcular y. En este caso, si extendiésemos la línea a la
izquierda, veríamos que cuando x es 0, y es aproximadamente 20, y la pendiente de
la línea es tal que para cada unidad de x que avanza hacia la derecha, y aumenta
aproximadamente 1,7. Por lo tanto, la función f se puede calcular como 20 + 1,7x.
Ahora que hemos definido la función de predicción, podemos usarla para predecir
las etiquetas para los datos de validación que retuvimos y comparar los valores de
predicción (lo que normalmente se indica con el símbolo ŷ, o "y con acento
circunflejo") con los valores de y conocidos reales.
x y ŷ
82 156 159,4
54 114 111,8
62 129 125,4
Veamos la comparación de los valores de y e ŷ en un trazado:

Los puntos trazados que se encuentran en la línea de función son los valores de ŷ
predichos calculados por la función, y los otros puntos trazados son los valores de y
reales.
Hay varias maneras de medir la varianza entre los valores predichos y los reales, y
podemos usar estas métricas para evaluar el grado de predicción del modelo.
Nota
El aprendizaje automático se basa en estadísticas y matemáticas, y es importante

tener en cuenta los términos específicos que usan los estadísticos y matemáticos (y,
por lo tanto, los científicos de datos). Puede considerar la diferencia entre un valor
de etiqueta predicho y el valor real de la etiqueta como una medida del error. Sin
embargo, en la práctica, los valores "reales" se basan en observaciones de ejemplo
(que a su vez pueden estar sujetas a una varianza aleatoria). Para que quede claro
que estamos comparando un valor predicho (ŷ) con un valor observado (y), nos
referimos a la diferencia entre ellos como residuales. Podemos resumir los
residuales de todas las predicciones de datos de validación para calcular la pérdida
general del modelo como medida de su rendimiento predictivo.
Una de las formas más comunes de medir la pérdida es elevar al cuadrado los
residuales individuales, sumar los cuadrados y calcular la media. Elevar el valor
residual al cuadrado tiene el efecto de basar el cálculo en valores absolutos (sin
hacer caso a si la diferencia es negativa o positiva) y dar mayor ponderación a las
diferencias más grandes. Esta métrica se denomina error cuadrático medio.
En el caso de los datos de validación, el cálculo tiene el siguiente aspecto:

s ŷ y - ŷ (y - ŷ)2
156 159,4 -3,4 11,56
114 111,8 2.2 4.84
129 125,4 3.6 12,96
Sum ∑ 29,36
Media x̄ 9,79
Por lo tanto, la pérdida del modelo basada en la métrica del ECM es de 9,79.
¿Es bueno eso? Es difícil de saber porque el valor del ECM no se expresa en una
unidad de medida significativa. Sabemos que cuanto menor sea el valor, menos
pérdida tendrá el modelo; y, por tanto, mejor será la predicción. Esto lo convierte en
una métrica útil para comparar dos modelos y encontrar el que tenga mejor
rendimiento.
A veces, resulta más útil expresar la pérdida en la misma unidad de medida que el
propio valor de etiqueta predicho, en este caso, el número de alquileres. Es posible
hacer esto si se calcula la raíz cuadrada del ECM, lo que genera una métrica
conocida, evidentemente, como raíz del error cuadrático medio (RECM).
√9,79 = 3,13
Por lo tanto, la RECM del modelo indica que la pérdida está apenas por encima de
3, lo que se puede interpretar de forma flexible como que, en promedio, las
predicciones incorrectas se equivocan en unos 3 alquileres.
Hay muchas otras métricas que se pueden usar para medir la pérdida en una
regresión. Por ejemplo, R2 (R al cuadrado) (a veces conocido como coeficiente de
determinación) es la correlación entre x e y al cuadrado. Esto genera un valor entre
0 y 1 que mide la cantidad de varianza que se puede explicar por el modelo. En
general, cuanto más se acerque a 1 este valor, mejor será la predicción del modelo.
Siguiente unidad: Ejercicio: Entrenamiento y
evaluación de un modelo de regresión
Ejercicio: Entrenamiento y evaluación de

un modelo de regresión
Regression
Supervised machine learning techniques involve training a model to operate on a set
of features and predict a label using a dataset that includes some already-known
label values. The training process fits the features to the known labels to define a
general function that can be applied to new features for which the labels are
unknown, and predict them. You can think of this function like this, in which y
represents the label we want to predict and x represents the features the model uses
to predict it.
In most cases, x is actually a vector that consists of multiple feature values, so to be

a little more precise, the function could be expressed like this:
The goal of training the model is to find a function that performs some kind of
calculation to the x values that produces the result y. We do this by applying a
machine learning algorithm that tries to fit the x values to a calculation that produces
y reasonably accurately for all of the cases in the training dataset.
There are lots of machine learning algorithms for supervised learning, and they can
be broadly divided into two types:
● Regression algorithms: Algorithms that predict a y value that is a numeric

value, such as the price of a house or the number of sales transactions.
● Classification algorithms: Algorithms that predict to which category, or class,
an observation belongs. The y value in a classification model is a vector of
probability values between 0 and 1, one for each class, indicating the
probability of the observation belonging to each class.
In this notebook, we'll focus on regression, using an example based on a real study in
which data for a bicycle sharing scheme was collected and used to predict the
number of rentals based on seasonality and weather conditions. We'll use a
simplified version of the dataset from that study.
Citation: The data used in this exercise is derived from Capital Bikeshare and is used
in accordance with the published license agreement.
Explore the Data

The first step in any machine learning project is to explore the data that you will use
to train a model. The goal of this exploration is to try to understand the relationships
between its attributes; in particular, any apparent correlation between the features
and the label your model will try to predict. This may require some work to detect and
fix issues in the data (such as dealing with missing values, errors, or outlier values),
deriving new feature columns by transforming or combining existing features (a
process known as feature engineering), normalizing numeric features (values you can
measure or count) so they're on a similar scale, and encoding categorical features
(values that represent discrete categories) as numeric indicators.
Let's start by loading the bicycle sharing data as a Pandas DataFrame and viewing
the first few rows.
import pandas as pd
# load the training dataset
!wget
-machine-learning/main/Data/ml-basics/daily-bike-share.csv
bike_data = pd.read_csv('daily-bike-share.csv')
bike_data.head()
The data consists of the following columns:
● instant: A unique row identifier

● dteday: The date on which the data was observed - in this case, the data was
collected daily; so there's one row per date.
● season: A numerically encoded value indicating the season (1:winter, 2:spring,
3:summer, 4:fall)
● yr: The year of the study in which the observation was made (the study took
place over two years - year 0 represents 2011, and year 1 represents 2012)
● mnth: The calendar month in which the observation was made (1:January ...
12:December)
● holiday: A binary value indicating whether or not the observation was made on
a public holiday)
● weekday: The day of the week on which the observation was made (0:Sunday
... 6:Saturday)
● workingday: A binary value indicating whether or not the day is a working day
(not a weekend or holiday)
● weathersit: A categorical value indicating the weather situation (1:clear,
2:mist/cloud, 3:light rain/snow, 4:heavy rain/hail/snow/fog)
● temp: The temperature in celsius (normalized)
● atemp: The apparent ("feels-like") temperature in celsius (normalized)
● hum: The humidity level (normalized)
● windspeed: The windspeed (normalized)
● rentals: The number of bicycle rentals recorded.
In this dataset, rentals represents the label (the y value) our model must be trained to
predict. The other columns are potential features (x values).
As mentioned previously, you can perform some feature engineering to combine or

derive new features. For example, let's add a new column named day to the
dataframe by extracting the day component from the existing dteday column. The
new column represents the day of the month from 1 to 31.
bike_data['day'] = pd.DatetimeIndex(bike_data['dteday']).day
bike_data.head(32)
OK, let's start our analysis of the data by examining a few key descriptive statistics.
We can use the dataframe's describe method to generate these for the numeric
features as well as the rentals label column.
numeric_features = ['temp', 'atemp', 'hum', 'windspeed']
bike_data[numeric_features + ['rentals']].describe()
The statistics reveal some information about the distribution of the data in each of
the numeric fields, including the number of observations (there are 731 records), the
mean, standard deviation, minimum and maximum values, and the quartile values
(the threshold values for 25%, 50% - which is also the median, and 75% of the data).
From this, we can see that the mean number of daily rentals is around 848; but
there's a comparatively large standard deviation, indicating a lot of variance in the
number of rentals per day.
We might get a clearer idea of the distribution of rentals values by visualizing the
data. Common plot types for visualizing numeric data distributions are histograms
and box plots, so let's use Python's matplotlib library to create one of each of these
for the rentals column.
import pandas as pd
import matplotlib.pyplot as plt
# This ensures plots are displayed inline in the Jupyter notebook
%matplotlib inline
# Get the label column
label = bike_data['rentals']
# Create a figure for 2 subplots (2 rows, 1 column)
# Plot the histogram
ax[0].hist(label, bins=100)
ax[0].set_ylabel('Frequency')
# Add lines for the mean, median, and mode
ax[0].axvline(label.mean(), color='magenta', linestyle='dashed',
linewidth=2)
ax[0].axvline(label.median(), color='cyan', linestyle='dashed',
linewidth=2)
# Plot the boxplot
ax[1].boxplot(label, vert=False)
ax[1].set_xlabel('Rentals')
fig.suptitle('Rental Distribution')
# Show the figure
fig.show()
Resultado
The plots show that the number of daily rentals ranges from 0 to just over 3,400.
However, the mean (and median) number of daily rentals is closer to the low end of
that range, with most of the data between 0 and around 2,200 rentals. The few
values above this are shown in the box plot as small circles, indicating that they are
outliers - in other words, unusually high or low values beyond the typical range of
most of the data.
We can do the same kind of visual exploration of the numeric features. Let's create a
histogram for each of these.
# Plot a histogram for each numeric feature
for col in numeric_features:
fig = plt.figure(figsize=(9, 6))
ax = fig.gca()
feature = bike_data[col]
feature.hist(bins=100, ax = ax)
ax.axvline(feature.mean(), color='magenta', linestyle='dashed',
linewidth=2)
ax.axvline(feature.median(), color='cyan', linestyle='dashed',
linewidth=2)
ax.set_title(col)
plt.show()
Resultado:
The numeric features seem to be more normally distributed, with the mean and
median nearer the middle of the range of values, coinciding with where the most
commonly occurring values are.
Note: The distributions are not truly normal in the statistical sense, which would
result in a smooth, symmetric "bell-curve" histogram with the mean and mode (the
most common value) in the center; but they do generally indicate that most of the
observations have a value somewhere near the middle.
We've explored the distribution of the numeric values in the dataset, but what about
the categorical features? These aren't continuous numbers on a scale, so we can't
use histograms; but we can plot a bar chart showing the count of each discrete value
for each category.
import numpy as np
# plot a bar plot for each categorical feature count
categorical_features =
['season','mnth','holiday','weekday','workingday','weathersit', 'day']
for col in categorical_features:
counts = bike_data[col].value_counts().sort_index()
ax = fig.gca()
counts.plot.bar(ax = ax, color='steelblue')
ax.set_title(col + ' counts')
ax.set_xlabel(col)
ax.set_ylabel("Frequency")
plt.show()
Resultado
Many of the categorical features show a more or less uniform distribution (meaning
there's roughly the same number of rows for each category). Exceptions to this
include:
● holiday: There are many fewer days that are holidays than days that aren't.
● workingday: There are more working days than non-working days.
● weathersit: Most days are category 1 (clear), with category 2 (mist and cloud)
the next most common. There are comparatively few category 3 (light rain or
snow) days, and no category 4 (heavy rain, hail, or fog) days at all.
Now that we know something about the distribution of the data in our columns, we
can start to look for relationships between the features and the rentals label we want
to be able to predict.
For the numeric features, we can create scatter plots that show the intersection of
feature and label values. We can also calculate the correlation statistic to quantify
the apparent relationship..
for col in numeric_features:
ax = fig.gca()
feature = bike_data[col]
label = bike_data['rentals']
correlation = feature.corr(label)
plt.scatter(x=feature, y=label)
plt.xlabel(col)
plt.ylabel('Bike Rentals')
ax.set_title('rentals vs ' + col + '- correlation: ' +
str(correlation))
plt.show()
Resultado:
The results aren't conclusive, but if you look closely at the scatter plots for temp and
atemp, you can see a vague diagonal trend showing that higher rental counts tend to
coincide with higher temperatures; and a correlation value of just over 0.5 for both of
these features supports this observation. Conversely, the plots for hum and
windspeed show a slightly negative correlation, indicating that there are fewer
rentals on days with high humidity or windspeed.
Now let's compare the categorical features to the label. We'll do this by creating box
plots that show the distribution of rental counts for each category.
# plot a boxplot for the label by each categorical feature
for col in categorical_features:
ax = fig.gca()
bike_data.boxplot(column = 'rentals', by = col, ax = ax)
ax.set_title('Label by ' + col)
ax.set_ylabel("Bike Rentals")
plt.show()
Resultado:
The plots show some variance in the relationship between some category values and
rentals. For example, there's a clear difference in the distribution of rentals on
weekends (weekday 0 or 6) and those during the working week (weekday 1 to 5).
Similarly, there are notable differences for holiday and workingday categories.
There's a noticeable trend that shows different rental distributions in spring and
summer months compared to winter and fall months. The weathersit category also
seems to make a difference in rental distribution. The day feature we created for the
day of the month shows little variation, indicating that it's probably not predictive of
the number of rentals.
Train a Regression Model

Now that we've explored the data, it's time to use it to train a regression model that
uses the features we've identified as potentially predictive to predict the rentals label.
The first thing we need to do is to separate the features we want to use to train the
model from the label we want it to predict.
# Separate features and labels
X, y = bike_data[['season','mnth',
'holiday','weekday','workingday','weathersit','temp', 'atemp', 'hum',
'windspeed']].values, bike_data['rentals'].values
print('Features:',X[:10], '\nLabels:', y[:10], sep='\n')
After separating the dataset, we now have numpy arrays named X containing the
features, and y containing the labels.
We could train a model using all of the data; but it's common practice in supervised
learning to split the data into two subsets; a (typically larger) set with which to train
the model, and a smaller "hold-back" set with which to validate the trained model.
This enables us to evaluate how well the model performs when used with the
validation dataset by comparing the predicted labels to the known labels. It's
important to split the data randomly (rather than say, taking the first 70% of the data
for training and keeping the rest for validation). This helps ensure that the two
subsets of data are statistically comparable (so we validate the model with data that
has a similar statistical distribution to the data on which it was trained).
To randomly split the data, we'll use the train_test_split function in the scikit-learn
library. This library is one of the most widely used machine learning packages for
Python.
from sklearn.model_selection import train_test_split
# Split data 70%-30% into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.30, random_state=0)
print ('Training Set: %d rows\nTest Set: %d rows' % (X_train.shape[0],
X_test.shape[0]))
Now we have the following four datasets:
● X_train: The feature values we'll use to train the model

● y_train: The corresponding labels we'll use to train the model
● X_test: The feature values we'll use to validate the model
● y_test: The corresponding labels we'll use to validate the model
Now we're ready to train a model by fitting a suitable regression algorithm to the
training data. We'll use a linear regression algorithm, a common starting point for
regression that works by trying to find a linear relationship between the X values and
the y label. The resulting model is a function that conceptually defines a line where
every possible X and y value combination intersect.
In Scikit-Learn, training algorithms are encapsulated in estimators, and in this case

we'll use the LinearRegression estimator to train a linear regression model.
# Train the model
from sklearn.linear_model import LinearRegression
# Fit a linear regression model on the training set
model = LinearRegression().fit(X_train, y_train)
print (model)
Evaluate the Trained Model

Now that we've trained the model, we can use it to predict rental counts for the
features we held back in our validation dataset. Then we can compare these
predictions to the actual label values to evaluate how well (or not!) the model is
working.
import numpy as np
predictions = model.predict(X_test)
np.set_printoptions(suppress=True)
print('Predicted labels: ', np.round(predictions)[:10])
print('Actual labels : ' ,y_test[:10])
Comparing each prediction with its corresponding "ground truth" actual value isn't a
very efficient way to determine how well the model is predicting. Let's see if we can
get a better indication by visualizing a scatter plot that compares the predictions to
the actual labels. We'll also overlay a trend line to get a general sense for how well
the predicted labels align with the true labels.
%matplotlib inline
plt.scatter(y_test, predictions)
plt.xlabel('Actual Labels')
plt.ylabel('Predicted Labels')
plt.title('Daily Bike Share Predictions')
# overlay the regression line
z = np.polyfit(y_test, predictions, 1)
p = np.poly1d(z)
plt.plot(y_test,p(y_test), color='magenta')
plt.show()
There's a definite diagonal trend, and the intersections of the predicted and actual
values are generally following the path of the trend line; but there's a fair amount of
difference between the ideal function represented by the line and the results. This
variance represents the residuals of the model - in other words, the difference
between the label predicted when the model applies the coefficients it learned during
training to the validation data, and the actual value of the validation label. These
residuals when evaluated from the validation data indicate the expected level of error
when the model is used with new data for which the label is unknown.
You can quantify the residuals by calculating a number of commonly used evaluation
metrics. We'll focus on the following three:
● Mean Square Error (MSE): The mean of the squared differences between
predicted and actual values. This yields a relative metric in which the smaller
the value, the better the fit of the model
● Root Mean Square Error (RMSE): The square root of the MSE. This yields an
absolute metric in the same unit as the label (in this case, numbers of
rentals). The smaller the value, the better the model (in a simplistic sense, it
represents the average number of rentals by which the predictions are wrong!)
● Coefficient of Determination (usually known as R-squared or R2): A relative
metric in which the higher the value, the better the fit of the model. In essence,
this metric represents how much of the variance between predicted and
actual label values the model is able to explain.
Note: You can find out more about these and other metrics for evaluating regression
models in the Scikit-Learn documentation
Let's use Scikit-Learn to calculate these metrics for our model, based on the
predictions it generated for the validation data.
from sklearn.metrics import mean_squared_error, r2_score
mse = mean_squared_error(y_test, predictions)
print("MSE:", mse)
rmse = np.sqrt(mse)
print("RMSE:", rmse)
r2 = r2_score(y_test, predictions)
print("R2:", r2)
So now we've quantified the ability of our model to predict the number of rentals. It
definitely has some predictive power, but we can probably do better!
Summary
Here we've explored our data and fit a basic regression model. In the next notebook,
we will try a number of other regression algorithms to improve performance
Descubrimiento de nuevos modelos de
regresión
Completado
100 XP
5 minutos
En la unidad 2, hemos visto cómo ajustar una línea recta a los puntos de datos. Sin
embargo, la regresión puede ajustarse a muchos tipos de relaciones, incluidas
aquellas con varios factores y aquellas en las que la importancia de un factor
depende de otro.
Experimentación con modelos

A menudo se eligen los modelos de regresión porque funcionan con muestras de
datos pequeñas, son sólidos, fáciles de interpretar y existe una gran variedad.
La regresión lineal es la forma más simple de regresión, sin límite en cuanto al

número de características usadas. La regresión lineal se presenta de diversas
formas y, a menudo, se las denomina en función del número de características
usadas y la forma de la curva que mejor se ajusta.
Los árboles de decisión adoptan un enfoque paso a paso para predecir una variable.
Si pensamos en el ejemplo de las bicicletas, el árbol de decisión puede dividir
primero los ejemplos entre los que son durante primavera y verano y otoño e
invierno, para hacer una predicción basada en el día de la semana. El lunes de
primavera y verano puede tener una tasa de alquiler de bicicletas de 100 al día,
mientras que el lunes de otoño e invierno puede tener una tasa de alquiler de 20 al
día.
Los algoritmos de conjunto construyen no solo un árbol de decisión, sino un gran

número de árboles, lo que permite realizar mejores predicciones sobre datos más
complejos. Los algoritmos de conjunto, como bosque aleatorio, se usan
ampliamente en el aprendizaje automático y en la ciencia debido a sus sólidas
capacidades de predicción.
Los científicos de datos suelen experimentar con el uso de modelos diferentes. En el

ejercicio siguiente, experimentaremos con diferentes tipos de modelos para
comparar su rendimiento con los mismos datos.
Regression - Experimenting with
additional models
In the previous notebook, we used simple regression models to look at the
relationship between features of a bike rentals dataset. In this notebook, we'll
experiment with more complex models to improve our regression performance.
the first few rows. We'll also split our data into training and test datasets.
# Import modules we'll need for this notebook
import pandas as pd
import numpy as np
%matplotlib inline
!wget
print(bike_data.head())
# After separating the dataset, we now have numpy arrays named **X**
containing the features, and **y** containing the labels.
X_test.shape[0]))
Resultado:

Now we're ready to train a model by fitting a suitable regression algorithm to the
training data.
Experiment with Algorithms

The linear regression algorithm we used last time to train the model has some
predictive capability, but there are many kinds of regression algorithm we could try,
including:
● Linear algorithms: Not just the Linear Regression algorithm we used above
(which is technically an Ordinary Least Squares algorithm), but other variants
such as Lasso and Ridge.
● Tree-based algorithms: Algorithms that build a decision tree to reach a
prediction.
● Ensemble algorithms: Algorithms that combine the outputs of multiple base
algorithms to improve generalizability.
Note: For a full list of Scikit-Learn estimators that encapsulate algorithms for
supervised machine learning, see the Scikit-Learn documentation. There are many
algorithms to choose from, but for most real-world scenarios, the Scikit-Learn
estimator cheat sheet can help you find a suitable starting point.
Try Another Linear Algorithm
Let's try training our regression model by using a Lasso algorithm. We can do this by
just changing the estimator in the training code.
from sklearn.linear_model import Lasso
# Fit a lasso model on the training set
model = Lasso().fit(X_train, y_train)
print (model, "\n")
# Evaluate the model using the test data
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
# Plot predicted vs actual
p = np.poly1d(z)
plt.show()
Resultado:
Try a Decision Tree Algorithm
As an alternative to a linear model, there's a category of algorithms for machine
learning that uses a tree-based approach in which the features in the dataset are
examined in a series of evaluations, each of which results in a branch in a decision
tree based on the feature value. At the end of each series of branches are leaf-nodes
with the predicted label value based on the feature values.
It's easiest to see how this works with an example. Let's train a Decision Tree
regression model using the bike rental data. After training the model, the code below
will print the model definition and a text representation of the tree it uses to predict
label values.
from sklearn.tree import DecisionTreeRegressor
from sklearn.tree import export_text
# Train the model
model = DecisionTreeRegressor().fit(X_train, y_train)
print (model, "\n")
# Visualize the model tree
tree = export_text(model)
print(tree)
Resultado
So now we have a tree-based model; but is it any good? Let's evaluate it with the test
data.
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
p = np.poly1d(z)
plt.show()
Resultado:
The tree-based model doesn't seem to have improved over the linear model, so what
else could we try?
Try an Ensemble Algorithm

Ensemble algorithms work by combining multiple base estimators to produce an
optimal model, either by applying an aggregate function to a collection of base
models (sometimes referred to a bagging) or by building a sequence of models that
build on one another to improve predictive performance (referred to as boosting).
For example, let's try a Random Forest model, which applies an averaging function to
multiple Decision Tree models for a better overall model.
from sklearn.ensemble import RandomForestRegressor
# Train the model
model = RandomForestRegressor().fit(X_train, y_train)
print (model, "\n")
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
p = np.poly1d(z)
plt.show()
Resultado:
For good measure, let's also try a boosting ensemble algorithm. We'll use a Gradient
Boosting estimator, which like a Random Forest algorithm builds multiple trees, but
instead of building them all independently and taking the average result, each tree is
built on the outputs of the previous one in an attempt to incrementally reduce the
loss (error) in the model.
# Train the model
from sklearn.ensemble import GradientBoostingRegressor
model = GradientBoostingRegressor().fit(X_train, y_train)
print (model, "\n")
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
p = np.poly1d(z)
plt.show()
Resultado:
Summary
Here we've tried a number of new regression algorithms to improve performance. In
our notebook we'll look at 'tuning' these algorithms to improve performance.
Mejora de los modelos con
hiperparámetros
Completado
100 XP
5 minutos
A menudo, los modelos simples con conjuntos de datos pequeños se pueden ajustar
en un solo paso, mientras que los conjuntos de datos más grandes y los modelos
más complejos deben ajustarse mediante el uso repetido del modelo con datos de
entrenamiento y la comparación de la salida con la etiqueta esperada. Si la
predicción es lo suficientemente precisa, consideramos que el modelo está
entrenado. Si no es así, se ajusta ligeramente el modelo y se vuelve a repetir.
Los hiperparámetros son valores que cambian la forma en que el modelo se ajusta
durante estos bucles. La velocidad de aprendizaje, por ejemplo, es un
hiperparámetro que establece cuánto se ajusta un modelo durante cada ciclo de
entrenamiento. Una alta velocidad de aprendizaje significa que un modelo se puede
entrenar más rápido, pero si es demasiado alta, los ajustes pueden ser tan grandes
que el modelo nunca termine de ajustarse y no sea óptimo.
Preprocesamiento de datos
El preprocesamiento hace referencia a los cambios realizados en los datos antes de
pasarse al modelo. Ya hemos leído que el preprocesamiento puede implicar la
limpieza del conjunto de datos. Aunque esto es importante, el preprocesamiento
también puede incluir el cambio del formato de los datos para que el modelo los
pueda usar más fácilmente. Por ejemplo, los datos descritos como "rojo", "naranja",
"amarillo", "lima" y "verde", pueden funcionar mejor si se convierten en un formato
más nativo para los equipos, como números que indican la cantidad de rojo y la
cantidad de verde.
Características de escalado
El paso de preprocesamiento más común consiste en escalar las características

para se encuentren entre cero y uno. Por ejemplo, el peso de una bicicleta y la
distancia que una persona recorre en una bicicleta pueden ser dos números muy
diferentes, pero al escalar ambos números a entre cero y uno, los modelos pueden
aprender de los datos con mayor eficacia.
Uso de categorías como características
En el aprendizaje automático, también se pueden usar características de categorías

como "bicicleta", "monopatín" o "automóvil". Estas características se representan
mediante valores de 0 o 1 en vectores one-hot, vectores que tienen 0 o 1 para cada
valor posible. Por ejemplo, la bicicleta, el monopatín y el automóvil podrían ser
respectivamente (1,0,0), (0,1,0) y (0,0,1).
Regression - Optimize and save

models
In the previous notebook, we used complex regression models to look at the
relationship between features of a bike rentals dataset. In this notebook, we'll see if
we can improve the performance of these models even further.
the first few rows. As usual, we'll also split our data into training and test datasets.
# Import modules we'll need for this notebook
import pandas as pd
import numpy as np
%matplotlib inline
!wget
print(bike_data.head())
# After separating the dataset, we now have numpy arrays named **X**
containing the features, and **y** containing the labels.
X_test.shape[0]))
Resultado:

Now we're ready to train a model by fitting a boosting ensemble algorithm, as in our
last notebook. Recall that a Gradient Boosting estimator, is like a Random Forest
algorithm, but instead of building them all trees independently and taking the
average result, each tree is built on the outputs of the previous one in an attempt to
incrementally reduce the loss (error) in the model.
# Train the model
from sklearn.ensemble import GradientBoostingRegressor,
RandomForestRegressor
model = GradientBoostingRegressor().fit(X_train, y_train)
print (model, "\n")
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
p = np.poly1d(z)
plt.show()
Resultado:
Optimize Hyperparameters
Take a look at the GradientBoostingRegressor estimator definition in the output
above, and note that it, like the other estimators we tried previously, includes a large
number of parameters that control the way the model is trained. In machine learning,
the term parameters refers to values that can be determined from data; values that
you specify to affect the behavior of a training algorithm are more correctly referred
to as hyperparameters.
The specific hyperparameters for an estimator vary based on the algorithm that the
estimator encapsulates. In the case of the GradientBoostingRegressor estimator, the
algorithm is an ensemble that combines multiple decision trees to create an overall
predictive model. You can learn about the hyperparameters for this estimator in the
Scikit-Learn documentation.
We won't go into the details of each hyperparameter here, but they work together to
affect the way the algorithm trains a model. In many cases, the default values
provided by Scikit-Learn will work well; but there may be some advantage in
modifying hyperparameters to get better predictive performance or reduce training
time.
So how do you know what hyperparameter values you should use? Well, in the
absence of a deep understanding of how the underlying algorithm works, you'll need
to experiment. Fortunately, SciKit-Learn provides a way to tune hyperparameters by
trying multiple combinations and finding the best result for a given performance
metric.
Let's try using a grid search approach to try combinations from a grid of possible
values for the learning_rate and n_estimators hyperparameters of the
GradientBoostingRegressor estimator.
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import make_scorer, r2_score
# Use a Gradient Boosting algorithm
alg = GradientBoostingRegressor()
# Try these hyperparameter values
params = {
'learning_rate': [0.1, 0.5, 1.0],
'n_estimators' : [50, 100, 150]
}
# Find the best hyperparameter combination to optimize the R2 metric
score = make_scorer(r2_score)
gridsearch = GridSearchCV(alg, params, scoring=score, cv=3,
return_train_score=True)
gridsearch.fit(X_train, y_train)
print("Best parameter combination:", gridsearch.best_params_, "\n")
# Get the best model
model=gridsearch.best_estimator_
print(model, "\n")
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
p = np.poly1d(z)
plt.show()
Resultado:
Note: The use of random values in the Gradient Boosting algorithm results in slightly
different metrics each time. In this case, the best model produced by hyperparameter
tuning is unlikely to be significantly better than one trained with the default
hyperparameter values; but it's still useful to know about the hyperparameter tuning
technique!
Preprocess the Data

We trained a model with data that was loaded straight from a source file, with only
moderately successful results.
In practice, it's common to perform some preprocessing of the data to make it easier
for the algorithm to fit a model to it. There's a huge range of preprocessing
transformations you can perform to get your data ready for modeling, but we'll limit
ourselves to a few common techniques:
Scaling numeric features
Normalizing numeric features so they're on the same scale prevents features with
large values from producing coefficients that disproportionately affect the
predictions. For example, suppose your data includes the following numeric features:
A B C
3 480 65
Normalizing these features to the same scale may result in the following values
(assuming A contains values from 0 to 10, B contains values from 0 to 1000, and C
contains values from 0 to 100):
A B C
0. 0.4 0.6
3 8 5
There are multiple ways you can scale numeric data, such as calculating the
minimum and maximum values for each column and assigning a proportional value
between 0 and 1, or by using the mean and standard deviation of a normally
distributed variable to maintain the same spread of values on a different scale.
Encoding categorical variables

Machine learning models work best with numeric features rather than text values, so
you generally need to convert categorical features into numeric representations. For
example, suppose your data includes the following categorical feature.
Size
L
You can apply ordinal encoding to substitute a unique integer value for each
category, like this:
Size
Another common technique is to use one hot encoding to create individual binary (0
or 1) features for each possible category value. For example, you could use one-hot
encoding to translate the possible categories into binary columns like this:
Size_ Size_M Size_

S L
1 0 0
0 1 0
0 0 1
To apply these preprocessing transformations to the bike rental, we'll make use of a
Scikit-Learn feature named pipelines. These enable us to define a set of
preprocessing steps that end with an algorithm. You can then fit the entire pipeline to
the data, so that the model encapsulates all of the preprocessing steps as well as
the regression algorithm. This is useful, because when we want to use the model to
predict values from new data, we need to apply the same transformations (based on
the same statistical distributions and category encodings used with the training
data).
Note: The term pipeline is used extensively in machine learning, often to mean very
different things! In this context, we're using it to refer to pipeline objects in
Scikit-Learn, but you may see it used elsewhere to mean something else.
# Train the model
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
import numpy as np
# Define preprocessing for numeric columns (scale them)
numeric_features = [6,7,8,9]
numeric_transformer = Pipeline(steps=[
('scaler', StandardScaler())])
# Define preprocessing for categorical features (encode them)
categorical_features = [0,1,2,3,4,5]
categorical_transformer = Pipeline(steps=[
('onehot', OneHotEncoder(handle_unknown='ignore'))])
# Combine preprocessing steps
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)])
# Create preprocessing and training pipeline
pipeline = Pipeline(steps=[('preprocessor', preprocessor),
('regressor', GradientBoostingRegressor())])
# fit the pipeline to train a linear regression model on the training
set
model = pipeline.fit(X_train, (y_train))
print (model)
Resultado:
OK, the model is trained, including the preprocessing steps. Let's see how it performs
with the validation data.
# Get predictions
# Display metrics
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
p = np.poly1d(z)
plt.show()
Resultado:
The pipeline is composed of the transformations and the algorithm used to train the
model. To try an alternative algorithm you can just change that step to a different
kind of estimator.
# Use a different estimator in the pipeline
('regressor', RandomForestRegressor())])
# fit the pipeline to train a linear regression model on the training
set
print (model, "\n")
# Get predictions
# Display metrics
print("MSE:", mse)
rmse = np.sqrt(mse)
print("R2:", r2)
plt.title('Daily Bike Share Predictions - Preprocessed')
p = np.poly1d(z)
plt.show()
Resultado:
We've now seen a number of common techniques used to train predictive models for
regression. In a real project, you'd likely try a few more algorithms, hyperparameters,
and preprocessing transformations; but by now you should have got the general
idea. Let's explore how you can use the trained model with new data.
Use the Trained Model

First, let's save the model.
import joblib
# Save the model as a pickle file
filename = './bike-share.pkl'
joblib.dump(model, filename)
Now, we can load it whenever we need it, and use it to predict labels for new data.
This is often called scoring or inferencing.
# Load the model from the file
loaded_model = joblib.load(filename)
# Create a numpy array containing a new observation (for example
tomorrow's seasonal and weather forecast information)
X_new =
np.array([[1,1,0,3,1,1,0.226957,0.22927,0.436957,0.1869]]).astype('floa
t64')
print ('New sample: {}'.format(list(X_new[0])))
# Use the model to predict tomorrow's rentals
result = loaded_model.predict(X_new)
print('Prediction: {:.0f} rentals'.format(np.round(result[0])))
The model's predict method accepts an array of observations, so you can use it to
generate multiple predictions as a batch. For example, suppose you have a weather
forecast for the next five days; you could use the model to predict bike rentals for
each day based on the expected weather conditions.
# An array of features based on five-day weather forecast
X_new = np.array([[0,1,1,0,0,1,0.344167,0.363625,0.805833,0.160446],
[0,1,0,1,0,1,0.363478,0.353739,0.696087,0.248539],
[0,1,0,2,0,1,0.196364,0.189405,0.437273,0.248309],
[0,1,0,3,0,1,0.2,0.212122,0.590435,0.160296],
[0,1,0,4,0,1,0.226957,0.22927,0.436957,0.1869]])
# Use the model to predict rentals
results = loaded_model.predict(X_new)
print('5-day rental predictions:')
for prediction in results:
print(np.round(prediction))
Summary
That concludes the notebooks for this module on regression. In this notebook we ran
a complex regression, tuned it, saved the model, and used it to predict outcomes for
the future.
Identificación de escenarios de
aprendizaje automático de regresión
Completado
100 XP
3 minutos
La regresión es una forma de aprendizaje automático que se usa para comprender

las relaciones entre variables para predecir un resultado deseado. La regresión
predice una etiqueta numérica o un resultado en función de variables o
características. Por ejemplo, una empresa de venta de automóviles podría usar las
características de un coche (como el tamaño del motor, el número de asientos, el
kilometraje, etc.) para predecir su precio de venta probable. En este caso, las
características del coche son las características y el precio de venta es la etiqueta.
La regresión es un ejemplo de técnica de aprendizaje automático supervisado en la

que se entrena un modelo con datos que incluyen tanto las características como los
valores conocidos para la etiqueta, de modo que el modelo aprenda a ajustar las
combinaciones de características para la etiqueta. Después de completar el
entrenamiento, puede usar el modelo entrenado para predecir etiquetas de nuevos
elementos para los que la etiqueta se desconoce.
Escenarios de modelos de aprendizaje automático de

regresión
Los modelos de aprendizaje automático de regresión se usan en muchos sectores.
Algunos escenarios son los siguientes:
● Uso de características de las casas, como las superficies cuadradas y el

número de habitaciones, para predecir los precios de las casas.
● Uso de características de las condiciones de una granja, como el clima
y la calidad del suelo, para predecir el rendimiento de los cultivos.
● Uso de características de una campaña pasada, como los registros de
publicidad, para predecir futuros clics de anuncios.
¿Qué es Azure Machine Learning?
Completado
100 XP
5 minutos
Entrenar e implementar un modelo de Machine Learning eficaz implica una gran

cantidad de trabajo, siendo buena parte de este intensivo en tiempo y en recursos.
Azure Machine Learning es un servicio basado en la nube que permite simplificar
algunas de las tareas para preparar los datos, entrenar un modelo e implementar un
servicio predictivo. Los modelos de aprendizaje automático de regresión se pueden
crear mediante Azure Machine Learning.
Lo más importante es que Azure Machine Learning ayuda a los científicos de datos
a aumentar su eficiencia mediante la automatización de muchas de las tareas que
consumen mucho tiempo asociadas a los modelos de entrenamiento. Les permite
usar recursos de proceso basados en la nube que se escalan de manera eficaz para
manejar grandes volúmenes de datos, incurriendo en costes solo cuando realmente
se usan.
Área de trabajo de Azure Machine Learning

Para usar Azure Machine Learning, debe crear un área de trabajo en la suscripción
de Azure. Después, puede usar esta área de trabajo para administrar datos,
recursos de proceso, código, modelos y otros artefactos relacionados con las cargas
de trabajo de aprendizaje automático.
Después de crear un área de trabajo de Azure Machine Learning, puede desarrollar

soluciones con el servicio Azure Machine Learning, ya sea con herramientas de
desarrollo o con el portal web de Estudio de Azure Machine Learning.
Azure Machine Learning Studio

Estudio de Azure Machine Learning es un portal web de soluciones de aprendizaje
automático en Azure. Incluye una amplia gama de características y funcionalidades
que ayudan a los científicos de datos a preparar datos, entrenar modelos, publicar
servicios predictivos y supervisar su uso. Para empezar a usar el portal web, debe
asignar el área de trabajo que creó en Azure Portal a Estudio de Azure Machine
Learning.
Proceso de Azure Machine Learning
En esencia, Azure Machine Learning es un servicio para entrenar y administrar
modelos de aprendizaje automático, para los que se necesita recursos de proceso
en los que ejecutar el proceso de entrenamiento. Los destinos de proceso son
recursos basados en la nube en los que se pueden ejecutar procesos de
entrenamiento de modelos y exploración de datos.
En Estudio de Azure Machine Learning, puede administrar los destinos de proceso

para las actividades de ciencia de datos. Puede crear cuatro tipos de recursos de
proceso:
● Instancias de proceso: estaciones de trabajo de desarrollo que los

científicos de datos pueden usar para trabajar con datos y modelos.
● Clústeres de proceso: clústeres escalables de máquinas virtuales para
el procesamiento a petición de código de experimento.
● Clústeres de inferencia: destinos de implementación para servicios
predictivos que usan los modelos entrenados.
● Proceso asociado: vínculos a recursos de proceso de Azure existentes,
como clústeres de Azure Virtual Machines o Azure Databricks.
¿Qué es el diseñador de Azure Machine
Learning?
Completado
100 XP
4 minutos
En Estudio de Azure Machine Learning, hay varias maneras de crear modelos de

aprendizaje automático de regresión. Una de ellas consiste en usar una interfaz
visual denominada diseñador, que puede usar para entrenar, probar e implementar
modelos de aprendizaje automático. La interfaz de arrastrar y colocar usa entradas y
salidas claramente definidas que se pueden compartir, reutilizar y controlar la
versión.
Cada proyecto de diseñador, conocido como canalización, tiene un panel izquierdo

para la navegación y un lienzo en el lado derecho. Para usar el diseñador,
identifique los bloques de creación o los componentes necesarios para el modelo,
colóquelos y conéctelos en el lienzo y ejecute un trabajo de aprendizaje automático.
Pipelines
Las canalizaciones permiten organizar, administrar y reutilizar flujos de trabajo de
aprendizaje automático complejos entre proyectos y usuarios. Una canalización se
inicia con el conjunto de datos desde el que quiere entrenar el modelo. Cada vez
que se ejecuta una canalización, la configuración de esta y sus resultados se
almacenan en el área de trabajo como un trabajo de canalización.
Componentes
Un componente de Azure Machine Learning encapsula un paso en una canalización
de aprendizaje automático. Puede considerar un componente como una función de
programación y como un bloque de creación para las canalizaciones de Azure
Machine Learning. En un proyecto de canalización, puede acceder a los
componentes y recursos de datos desde la pestaña Biblioteca de recursos del panel
izquierdo.
Conjuntos de datos
Puede crear recursos de datos en la página Datos a partir de archivos locales, un
almacén de datos, archivos web y Open Datasets. Estos recursos de datos
aparecerán junto con los conjuntos de datos de ejemplo estándar en la biblioteca de
recursos del diseñador.
Trabajos de Azure Machine Learning

Un trabajo de Azure Machine Learning (ML) ejecuta una tarea en un destino de
proceso especificado. Los trabajos permiten el seguimiento sistemático de los flujos
de trabajo y la experimentación de aprendizaje automático. Una vez creado un
trabajo, Azure ML mantiene un registro de ejecución del mismo. Todos los registros
de ejecución de los trabajos se pueden ver en Azure ML Studio.
En el proyecto del diseñador, puede acceder al estado de un trabajo de canalización

mediante la pestaña Trabajos enviados del panel izquierdo.
Puede encontrar todos los trabajos que ha ejecutado en un área de trabajo en la
página Trabajos.
Comprensión de los pasos para la

regresión
Completado
100 XP
6 minutos
Puede pensar en los pasos para entrenar y evaluar un modelo de aprendizaje

automático de regresión como los siguientes:
1. Preparar datos: identifique las características y la etiqueta de un

conjunto de datos. Procese previamente o limpie y transforme los datos
según sea necesario.
2. Entrenar el modelo: divida los datos en dos grupos, un conjunto de
entrenamiento y uno de validación. Entrene un modelo de Machine
Learning con el conjunto de datos de entrenamiento. Pruebe el modelo
de Machine Learning en cuanto al rendimiento con el conjunto de datos
de validación.
3. Evaluar el rendimiento: compare la proximidad de las predicciones del
modelo con las etiquetas conocidas.
4. Implementar un servicio predictivo: después de entrenar un modelo de
Machine Learning, debe convertir la canalización de entrenamiento en
una canalización de inferencia en tiempo real. A continuación, puede
implementar el modelo como una aplicación en un servidor o dispositivo
para que otros usuarios puedan usarlo.
Sigamos estos cuatro pasos a medida que aparecen en el diseñador de Azure.
Preparación de los datos

El diseñador de Azure Machine Learning tiene varios componentes integrados que
se pueden usar para preparar los datos para el entrenamiento. Estos componentes
permiten limpiar datos, normalizar características, combinar tablas, etc.
Entrenamiento de un modelo
Para entrenar un modelo de regresión, necesita un conjunto de datos que incluya
características históricas, características de la entidad para la que quiere realizar
una predicción y valores de etiqueta conocidos. La etiqueta es la cantidad que
quiere para entrenar un modelo que va a predecir.
Es habitual entrenar el modelo con un subconjunto de los datos, a la vez que se

retienen algunos con los que probar el modelo entrenado. Esto le permite comparar
las etiquetas que predice el modelo con las etiquetas conocidas reales del conjunto
de datos original.
Usará el componente Puntuar modelo del diseñador para generar el valor de

etiqueta de clase predicho. Una vez que conecte todos los componentes, querrá
ejecutar un experimento, que usará el recurso de datos en el lienzo para entrenar y
puntuar un modelo.
Evaluación del rendimiento

Después de entrenar un modelo, es importante evaluar su rendimiento. Hay muchas
métricas de rendimiento y metodologías para evaluar el rendimiento de las
predicciones de un modelo. Para revisar las métricas de evaluación en la página del
trabajo completado, haga clic con el botón derecho en el componente Evaluar
modelo.
● Error medio absoluto (EAM): la diferencia media entre los valores
pronosticados y los reales. Este valor se basa en las mismas unidades
que la etiqueta, en este caso, dólares. Cuanto menor sea este valor,
mejor será la predicción del modelo.
● Raíz del error cuadrático medio (RECM): raíz cuadrada de la diferencia
cuadrática media entre valores predichos y verdaderos. El resultado es
una métrica basada en la misma unidad que la etiqueta (dólares). En
comparación con el valor EAM (anterior), una diferencia mayor indica
una mayor desviación en los errores individuales (por ejemplo, algunos
errores son muy pequeños, mientras que otros son grandes).
● Error cuadrático relativo (ESR): una métrica relativa entre 0 y 1 en
función del cuadrado de las diferencias entre los valores pronosticados
y los reales. Cuanto más cercano a 0 sea el valor de esta métrica, mejor
funciona el modelo. Como esta métrica es relativa, se puede usar para
comparar modelos en los que las etiquetas se encuentran en unidades
distintas.
● Error absoluto relativo (EAR): una métrica relativa entre 0 y 1 en función
de las diferencias absolutas entre los valores pronosticados y los reales.
Cuanto más cercano a 0 sea el valor de esta métrica, mejor funciona el
modelo. Al igual que ESR, esta métrica se puede usar para comparar
modelos en los que las etiquetas se encuentran en unidades distintas.
● Coeficiente de determinación (R2): esta métrica se suele denominar R
cuadrado y resume la cantidad de la varianza entre los valores reales y
los previstos que se explica en el modelo. Cuanto más cercano a 1 sea
esta valor, mejor funciona el modelo.
Implementación de un servicio predictivo

Tiene la capacidad de implementar un servicio que se puede usar en tiempo real.
Para automatizar el modelo en un servicio que realice predicciones continuas, debe
crear e implementar una canalización de inferencia.
Canalización de inferencia
Para implementar la canalización, antes debe convertir la canalización de

entrenamiento en una canalización de inferencia en tiempo real. Este proceso quita
los componentes de entrenamiento y agrega entradas y salidas de servicios web
para administrar las solicitudes.
La canalización de inferencia realiza las mismas transformaciones de datos que la

primera canalización para los datos nuevos. Después, usa el modelo entrenado para
deducir o predecir valores de etiqueta en función de sus características. Este
modelo formará la base de un servicio predictivo que puede publicar para que lo
usen las aplicaciones.
Para crear una canalización de inferencia, seleccione el menú situado encima de un

trabajo completado.
Implementación
Después de crear la canalización de inferencia, puede implementarla como un punto

de conexión. En la página Puntos de conexión, puede ver los detalles de
implementación, probar el servicio de canalización con datos de ejemplo y buscar
credenciales para conectar el servicio de canalización a una aplicación cliente.
El punto de conexión tardará un tiempo en implementarse. El estado de
implementación de la pestaña Detalles indicará Correcto cuando la implementación
se realice correctamente.
En la pestaña Prueba, puede probar el servicio implementado con datos de ejemplo

en formato JSON. La pestaña Prueba es una herramienta que puede usar para
comprobar rápidamente si el modelo se comporta según lo previsto. Normalmente,
resulta útil probar el servicio antes de conectarlo a una aplicación.
Puede encontrar las credenciales para el servicio en la pestaña Consumir. Estas
credenciales se usan para conectar el modelo de Machine Learning entrenado como
un servicio a una aplicación cliente.
Ejercicio: Exploración de la regresión
con el diseñador de Azure Machine
Learning
Completado
100 XP
55 minutos
En este módulo, entrenará un modelo de regresión que predice el precio de un

automóvil en función de sus características.
Nota
Para completar este laboratorio, necesitará una suscripción de Azure en la que

tenga acceso administrativo.
Inicie el ejercicio y siga las instrucciones.
https://microsoftlearning.github.io/AI-900-AIFundamentals/instructions/02a-create-regression
-model.html
modelos de clasificación
47 min.
Módulo
9 Unidades
4.8 (1870)
Califíquelo
IntermedioCientífico de datosAzure
La clasificación es un tipo de aprendizaje automático que se usa para categorizar

elementos en clases.
En este módulo, aprenderá lo siguiente:
● Cuándo usar la clasificación

● Cómo entrenar y evaluar un modelo de clasificación mediante el marco
Scikit-learn
InicioSumar
Requisitos previos
● Conceptos matemáticos básicos
● Programación con Python
Introducción
Completado
100 XP
2 minutos
La clasificación es una forma de aprendizaje automático por la cual entrena un

modelo para predecir a qué categoría pertenece un elemento. Por ejemplo, un
consultorio médico podría usar datos de diagnóstico, como la altura, el peso, la
tensión arterial o el nivel de glucosa en sangre de un paciente para predecir si este
es diabético o no.
Los datos categóricos tienen distintas "clases", en lugar de valores numéricos.
Algunos tipos de datos pueden ser numéricos o categóricos: el tiempo de una
carrera puede ser un tiempo en segundos, o podemos dividir los tiempos en clases
de "rápido", "medio" y "lento, lo cual sería categórico. Mientras que otros tipos de
datos solo pueden ser categóricos, como un tipo de forma: "círculo", "triángulo" o
"cuadrado".
Requisitos previos
● Conocimientos de matemáticas básicas
● Experiencia previa con la programación en Python
En este módulo, aprenderá a:
● Cuándo usar la clasificación

● Cómo entrenar y evaluar un modelo de clasificación mediante el marco
Scikit-learn
¿Qué es la clasificación?
Completado
100 XP
5 minutos
La clasificación binaria es la clasificación con dos categorías. Por ejemplo,

podríamos etiquetar a los pacientes como no diabéticos o diabéticos.
Para predecir la clase, se calcula la probabilidad de cada clase posible como un

valor entre 0 (imposible) y 1 (cierto). La probabilidad total para todas las clases es 1,
ya que el paciente es definitivamente diabético o no diabético. Así, si la probabilidad
prevista de que un paciente sea diabético es de 0,3, existe una probabilidad
correspondiente de 0,7 de que el paciente no sea diabético.
Se usa un valor de umbral, normalmente 0,5, para determinar la clase predicha, por
lo que si la clase positiva (en este caso, diabético) tiene una probabilidad predicha
mayor que el umbral, se predice una clasificación de diabético.
Entrenamiento y evaluación de un modelo de

clasificación
La clasificación es un ejemplo de una técnica de aprendizaje automático
supervisada; es decir, se basa en datos que incluyen valores de características
conocidos (por ejemplo, medidas de diagnóstico para los pacientes), así como en
valores de etiqueta conocidos (por ejemplo, una clasificación de diabético o no
diabético). Se usa un algoritmo de clasificación para ajustar un subconjunto de los
datos a una función que pueda calcular la probabilidad de cada etiqueta de clase a
partir de los valores de las características. Los datos restantes se usan para evaluar
el modelo al comparar las predicciones que genera a partir de las características
con las etiquetas de clase conocidas.
Un ejemplo sencillo
Vamos a explorar un ejemplo sencillo para ayudar a explicar los principios clave.
Supongamos que tenemos los siguientes datos sobre los pacientes, que constan de
una característica única (nivel de glucosa en sangre) y una etiqueta de clase (0 para
no diabético, 1 para diabético).
Glucosa en sangre Diabético
82 0
92 0
112 1
102 0
115 1
107 1
87 0
120 1
83 0
119 1
104 1
105 0
86 0
109 1
Usaremos las ocho primeras observaciones para entrenar un modelo de

clasificación, y comenzaremos por trazar la característica de glucosa en sangre (a la
que llamaremos x) y la etiqueta de diabético predicha (a la que llamaremos y).
Lo que se necesita es una función que calcule un valor de probabilidad para y según
x (en otras palabras, se necesita la función f(x) = y). Del gráfico se puede ver que los
pacientes con un bajo nivel de glucosa en sangre son todos no diabéticos, mientras
que los pacientes con un nivel mayor de glucosa en sangre son diabéticos. Al
parecer, cuanto mayor sea el nivel de glucosa en sangre, más probable es que el
paciente sea diabético, donde el punto de la inflexión se encuentra en algún lugar
entre 100 y 110. Es necesario encontrar una función que calcule un valor de y entre
0 y 1 para dichos valores.
Una de ellas es una función logística, que forma una curva sigmoidea (con forma de
S), similar a la siguiente:
Ahora podemos usar la función para calcular un valor de probabilidad donde y sea
positivo (es decir, el paciente es diabético) a partir de cualquier valor de x buscando
el punto en la línea de función para x. Podemos establecer un valor de umbral de
0,5 como punto de corte para la predicción de la etiqueta de clase.
Vamos a probarlo con los valores de datos que hemos conservado:
Los puntos trazados debajo de la línea de umbral producirán una clase predicha de
0 (no diabéticos), y los puntos por encima de la línea se predecirán como 1
(diabético).
Ahora podemos comparar las predicciones de etiqueta basándonos en la función

logística encapsulada en el modelo (a la que llamaremos ŷ o "y acento circunflejo")
con las etiquetas de clase reales (y).
x y ŷ
83 0 0
119 1 1
104 1 0
105 0 1
86 0 0
109 1 1

evaluación de un modelo de clasificación
Classification
Supervised machine learning techniques involve training a model to operate on a set
of features and predict a label using a dataset that includes some already-known
label values. You can think of this function like this, in which y represents the label
we want to predict and X represents the vector of features the model uses to predict
it.
Classification is a form of supervised machine learning in which you train a model to

use the features (the x values in our function) to predict a label (y) that calculates the
probability of the observed case belonging to each of a number of possible classes,
and predicting an appropriate label. The simplest form of classification is binary
classification, in which the label is 0 or 1, representing one of two classes; for
example, "True" or "False"; "Internal" or "External"; "Profitable" or "Non-Profitable"; and
so on.
Binary Classification
In this notebook, we will focus on an example of binary classification, where the
model must predict a label that belongs to one of two classes. In this exercise, we'll
train a binary classifier to predict whether or not a patient should be tested for
diabetes based on some medical data.
Explore the data

Run the following cell to load a CSV file of patent data into a Pandas dataframe:
Citation: The diabetes dataset used in this exercise is based on data originally
collected by the National Institute of Diabetes and Digestive and Kidney Diseases.
Celda Markdown vacía. Haga doble clic o presione Entrar para agregar contenido.
import pandas as pd
!wget
-machine-learning/main/Data/ml-basics/diabetes.csv
diabetes = pd.read_csv('diabetes.csv')
diabetes.head()
This data consists of diagnostic information about some patients who have been
tested for diabetes. Scroll to the right if necessary, and note that the final column in
the dataset (Diabetic) contains the value 0 for patients who tested negative for
diabetes, and 1 for patients who tested positive. This is the label that we will train our
model to predict; most of the other columns
(Pregnancies,PlasmaGlucose,DiastolicBloodPressure, and so on) are the features we
will use to predict the Diabetic label.
Let's separate the features from the labels - we'll call the features X and the label y:
features =
['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickne
ss','SerumInsulin','BMI','DiabetesPedigree','Age']
label = 'Diabetic'
X, y = diabetes[features].values, diabetes[label].values
for n in range(0,4):
print("Patient", str(n+1), "\n Features:",list(X[n]), "\n
Label:", y[n])
Resultado:
Now let's compare the feature distributions for each label value.
%matplotlib inline
features =
for col in features:
diabetes.boxplot(column=col, by='Diabetic', figsize=(6,6))
plt.title(col)
plt.show()
For some of the features, there's a noticeable difference in the distribution for each
label value. In particular, Pregnancies and Age show markedly different distributions
for diabetic patients than for non-diabetic patients. These features may help predict
whether or not a patient is diabetic.
Split the data
Our dataset includes known values for the label, so we can use this to train a
classifier so that it finds a statistical relationship between the features and the label
value; but how will we know if our model is any good? How do we know it will predict
correctly when we use it with new data that it wasn't trained with? Well, we can take
advantage of the fact we have a large dataset with known label values, use only
some of it to train the model, and hold back some to test the trained model - enabling
us to compare the predicted labels with the already known labels in the test set.
In Python, the scikit-learn package contains a large number of functions we can use
to build a machine learning model - including a train_test_split function that ensures
we get a statistically random split of training and test data. We'll use that to split the
data into 70% for training and hold back 30% for testing.
print ('Training cases: %d\nTest cases: %d' % (X_train.shape[0],
X_test.shape[0]))
Resultado:
Train and Evaluate a Binary Classification Model

OK, now we're ready to train our model by fitting the training features (X_train) to the
training labels (y_train). There are various algorithms we can use to train the model.
In this example, we'll use Logistic Regression, which (despite its name) is a
well-established algorithm for classification. In addition to the training features and
labels, we'll need to set a regularization parameter. This is used to counteract any
bias in the sample, and help the model generalize well by avoiding overfitting the
model to the training data.
Note: Parameters for machine learning algorithms are generally referred to as

hyperparameters (to a data scientist, parameters are values in the data itself -
hyperparameters are defined externally from the data!)
# Train the model
from sklearn.linear_model import LogisticRegression
# Set regularization rate
reg = 0.01
# train a logistic regression model on the training set
model = LogisticRegression(C=1/reg, solver="liblinear").fit(X_train,
y_train)
print (model)
Resultado:
# Train the model

reg = 0.01

y_train)
print (model)
Now we've trained the model using the training data, we can use the test data we
held back to evaluate how well it predicts. Again, scikit-learn can help us do this.
Let's start by using the model to predict labels for our test set, and compare the
predicted labels to the known labels:
print('Predicted labels: ', predictions)
print('Actual labels: ' ,y_test)
Resultado:
The arrays of labels are too long to be displayed in the notebook output, so we can
only compare a few values. Even if we printed out all of the predicted and actual
labels, there are too many of them to make this a sensible way to evaluate the
model. Fortunately, scikit-learn has a few more tricks up its sleeve, and it provides
some metrics that we can use to evaluate the model.
The most obvious thing you might want to do is to check the accuracy of the
predictions - in simple terms, what proportion of the labels did the model predict
correctly?
from sklearn.metrics import accuracy_score
print('Accuracy: ', accuracy_score(y_test, predictions))
Resultado:
The accuracy is returned as a decimal value - a value of 1.0 would mean that the
model got 100% of the predictions right; while an accuracy of 0.0 is, well, pretty
useless!
Summary
Here we prepared our data by splitting it into test and train datasets, and applied
logistic regression - a way of applying binary labels to our data. Our model was able
to predict whether patients had diabetes with what appears like reasonable
accuracy. But is this good enough? In the next notebook we will look at alternatives
to accuracy that can be much more useful in machine learning.
Evaluación de modelos de clasificación

Completado
100 XP
4 minutos
La precisión del entrenamiento de un modelo de clasificación es mucho menos

importante que lo bien que funcionará ese modelo cuando se le den nuevos datos
no vistos. Después de todo, entrenamos modelos para que se puedan usar en los
nuevos datos que se encuentran en el mundo real. Por lo tanto, después de
entrenar un modelo de clasificación, debemos evaluar cómo funciona con un
conjunto de datos nuevos no vistos.
En las unidades anteriores, creamos un modelo que predecía si un paciente tenía

diabetes o no en función de su nivel de glucosa en sangre. Ahora, cuando se aplica
a algunos datos que no formaban parte del conjunto de entrenamiento, obtenemos
las siguientes predicciones:
x y ŷ
83 0 0
119 1 1
104 1 0
105 0 1
86 0 0
109 1 1
Recordemos que x se refiere al nivel de glucosa en sangre, y se refiere a si son

realmente diabéticos, e ŷ se refiere a la predicción del modelo sobre si son
diabéticos o no.
El simple cálculo de cuántas predicciones fueron correctas es a veces engañoso o

demasiado simplista para que comprendamos el tipo de errores que cometerá en el
mundo real. Para obtener información más detallada, podemos tabular los
resultados en una estructura denominada matriz de confusión, como la siguiente:
La matriz de confusión muestra el número total de casos en los que:

● El modelo predijo 0 y la etiqueta real es 0 (verdaderos negativos; arriba
a la izquierda)
● El modelo predijo 1 y la etiqueta real es 1 (verdaderos positivos, abajo a
la derecha)
● El modelo predijo 0 y la etiqueta real es 1 (falsos negativos, abajo a la
izquierda)
● El modelo predijo 1 y la etiqueta real es 0 (falsos positivos, arriba a la
derecha)
Las celdas de la matriz de confusión se suelen sombrear para que los valores más
altos tengan un sombreado más profundo. De este modo, resulta más fácil ver una
tendencia diagonal fuerte de la parte superior izquierda a la inferior derecha,
resaltando las celdas en las que el valor predicho y el valor real son los mismos.
A partir de estos valores principales, puede calcular un rango de otras métricas que
pueden ayudarle a evaluar el rendimiento del modelo. Por ejemplo:
● Exactitud: (VP+VN)/(VP+VN+FP+FN): de todas las predicciones,

¿cuántas son correctas?
● Coincidencia: VP/(VP+FN): de todos los casos que son positivos,
¿cuántos detectó el modelo?
● Precisión: VP/(VP+FP): de todos los casos en los que el modelo predijo
ser positivo, ¿cuántos realmente son positivos?
Siguiente unidad: Ejercicio: Realización de la

clasificación con métricas alternativas
Classification Metrics
In the last notebook we fit binary classifier to predict whether patients were diabetic or not.
We used accuracy as a measure of how well the model performed, but accuracy isn't
everything. In this notebook, we will look at alternatives to accuracy that can be much more
useful in machine learning.
Alternative metrics for binary classifiers

Accuracy seems like a sensible metric to evaluate (and to a certain extent it is), but you need
to be careful about drawing too many conclusions from the accuracy of a classifier.
Remember that it's simply a measure of how many cases were predicted correctly. Suppose
only 3% of the population is diabetic. You could create a classifier that always just predicts 0,
and it would be 97% accurate - but not terribly helpful in identifying patients with diabetes!
Fortunately, there are some other metrics that reveal a little more about how our model is
performing. Scikit-Learn includes the ability to create a classification report that provides
more insight than raw accuracy alone.
To get started, run the next cell to load our data and train our model like last time.
Celda Markdown vacía. Haga doble clic o presione Entrar para agregar contenido.
import pandas as pd
%matplotlib inline
from sklearn.metrics import accuracy_score
!wget
-machine-learning/main/Data/ml-basics/diabetes.csv
diabetes = pd.read_csv('diabetes.csv')
features =
label = 'Diabetic'
X, y = diabetes[features].values, diabetes[label].values
print ('Training cases: %d\nTest cases: %d' % (X_train.shape[0],
X_test.shape[0]))
# Train the model
reg = 0.01
y_train)
print('Predicted labels: ', predictions)
print('Actual labels: ' ,y_test)
print('Accuracy: ', accuracy_score(y_test, predictions))
Reslutado:
One of the simplest places to start is a classification report. Run the next cell to see a range
of alternatives ways to assess our model
from sklearn. metrics import classification_report
print(classification_report(y_test, predictions))
Resultado:
The classification report includes the following metrics for each class (0 and 1)
note that the header row may not line up with the values!
● Precision: Of the predictions the model made for this class, what proportion were
correct?
● Recall: Out of all of the instances of this class in the test dataset, how many did the
model identify?
● F1-Score: An average metric that takes both precision and recall into account.
● Support: How many instances of this class are there in the test dataset?
The classification report also includes averages for these metrics, including a weighted
average that allows for the imbalance in the number of cases of each class.
Because this is a binary classification problem, the 1 class is considered positive and its
precision and recall are particularly interesting - these in effect answer the questions:
● Of all the patients the model predicted are diabetic, how many are actually diabetic?
● Of all the patients that are actually diabetic, how many did the model identify?
You can retrieve these values on their own by using the precision_score and recall_score
metrics in scikit-learn (which by default assume a binary classification model).
from sklearn.metrics import precision_score, recall_score
print("Overall Precision:",precision_score(y_test, predictions))
print("Overall Recall:",recall_score(y_test, predictions))
Resultado:
The precision and recall metrics are derived from four possible prediction outcomes:
● True Positives: The predicted label and the actual label are both 1.
● False Positives: The predicted label is 1, but the actual label is 0.
● False Negatives: The predicted label is 0, but the actual label is 1.
● True Negatives: The predicted label and the actual label are both 0.
These metrics are generally tabulated for the test set and shown together as a confusion
matrix, which takes the following form:
TN FP
FN TP
Note that the correct (true) predictions form a diagonal line from top left to bottom right -
these figures should be significantly higher than the false predictions if the model is any
good.
In Python, you can use the sklearn.metrics.confusion_matrix function to find these values for
a trained classifier:
from sklearn.metrics import confusion_matrix
# Print the confusion matrix
cm = confusion_matrix(y_test, predictions)
print (cm)
Resultado:
Until now, we've considered the predictions from the model as being either 1 or 0 class
labels. Actually, things are a little more complex than that. Statistical machine learning
algorithms, like logistic regression, are based on probability; so what actually gets predicted
by a binary classifier is the probability that the label is true (P(y)) and the probability that the
label is false (1 - P(y)). A threshold value of 0.5 is used to decide whether the predicted label
is a 1 (P(y) > 0.5) or a 0 (P(y) <= 0.5). You can use the predict_proba method to see the
probability pairs for each case:
y_scores = model.predict_proba(X_test)
print(y_scores)
Resultado:
The decision to score a prediction as a 1 or a 0 depends on the threshold to which the
predicted probabilities are compared. If we were to change the threshold, it would affect the
predictions; and therefore change the metrics in the confusion matrix. A common way to
evaluate a classifier is to examine the true positive rate (which is another name for recall)
and the false positive rate for a range of possible thresholds. These rates are then plotted
against all possible thresholds to form a chart known as a received operator characteristic
(ROC) chart, like this:
from sklearn.metrics import roc_curve
import matplotlib
%matplotlib inline
# calculate ROC curve
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
# plot ROC curve
# Plot the diagonal 50% line
plt.plot([0, 1], [0, 1], 'k--')
# Plot the FPR and TPR achieved by our model
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()
The ROC chart shows the curve of the true and false positive rates for different threshold
values between 0 and 1. A perfect classifier would have a curve that goes straight up the left
side and straight across the top. The diagonal line across the chart represents the probability
of predicting correctly with a 50/50 random prediction; so you obviously want the curve to be
higher than that (or your model is no better than simply guessing!).
The area under the curve (AUC) is a value between 0 and 1 that quantifies the overall
performance of the model. The closer to 1 this value is, the better the model. Once again,
scikit-Learn includes a function to calculate this metric.
from sklearn.metrics import roc_auc_score
auc = roc_auc_score(y_test,y_scores[:,1])
print('AUC: ' + str(auc))
Resultado:
Perform preprocessing in a pipeline

In this case, the ROC curve and its AUC indicate that the model performs better than a
random guess which is not bad considering we performed very little preprocessing of the
data.
In practice, it's common to perform some preprocessing of the data to make it easier for the
algorithm to fit a model to it. There's a huge range of preprocessing transformations you can
perform to get your data ready for modeling, but we'll limit ourselves to a few common
techniques:
● Scaling numeric features so they're on the same scale. This prevents features with
large values from producing coefficients that disproportionately affect the predictions.
● Encoding categorical variables. For example, by using a one hot encoding technique
you can create individual binary (true/false) features for each possible category
value.
To apply these preprocessing transformations, we'll make use of a Scikit-Learn feature

named pipelines. These enable us to define a set of preprocessing steps that end with an
algorithm. You can then fit the entire pipeline to the data, so that the model encapsulates all
of the preprocessing steps as well as the regression algorithm. This is useful, because when
we want to use the model to predict values from new data, we need to apply the same
transformations (based on the same statistical distributions and category encodings used
with the training data).
Note: The term pipeline is used extensively in machine learning, often to mean very different
things! In this context, we're using it to refer to pipeline objects in Scikit-Learn, but you may
see it used elsewhere to mean something else.
# Train the model
from sklearn.preprocessing import StandardScaler, OneHotEncoder
import numpy as np
# Define preprocessing for numeric columns (normalize them so they're
on the same scale)
numeric_features = [0,1,2,3,4,5,6]
numeric_transformer = Pipeline(steps=[
('scaler', StandardScaler())])
# Define preprocessing for categorical features (encode the Age column)
categorical_features = [7]
categorical_transformer = Pipeline(steps=[
('onehot', OneHotEncoder(handle_unknown='ignore'))])
# Combine preprocessing steps
transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)])
('logregressor', LogisticRegression(C=1/reg,
solver="liblinear"))])
# fit the pipeline to train a logistic regression model on the training
set
print (model)
Resultado:
The pipeline encapsulates the preprocessing steps as well as model training.
Let's use the model trained by this pipeline to predict labels for our test set, and compare the
performance metrics with the basic model we created previously.
# Get predictions from test data
# Get evaluation metrics
print ('Confusion Matrix:\n',cm, '\n')
print('Accuracy:', accuracy_score(y_test, predictions))
print('AUC: ' + str(auc))
# plot ROC curve
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.show()
Resultado:
The results look a little better, so clearly preprocessing the data has made a difference.
Try a different algorithm

Now let's try a different algorithm. Previously we used a logistic regression algorithm, which
is a linear algorithm. There are many kinds of classification algorithm we could try, including:
● Support Vector Machine algorithms: Algorithms that define a hyperplane that

separates classes.
● Tree-based algorithms: Algorithms that build a decision tree to reach a prediction
● Ensemble algorithms: Algorithms that combine the outputs of multiple base
algorithms to improve generalizability.
This time, We'll use the same preprocessing steps as before, but we'll train the model using
an ensemble algorithm named Random Forest that combines the outputs of multiple random
decision trees (for more details, see the Scikit-Learn documentation).
from sklearn.ensemble import RandomForestClassifier
('logregressor',
RandomForestClassifier(n_estimators=100))])
# fit the pipeline to train a random forest model on the training set
print (model)
Let's look at the performance metrics for the new model.
print ('Confusion Matrix:\n',cm, '\n')
print('Accuracy:', accuracy_score(y_test, predictions))
print('\nAUC: ' + str(auc))
# plot ROC curve
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.show()
Resultado:
That looks better!
Use the Model for Inferencing

Now that we have a reasonably useful trained model, we can save it for use later to predict
labels for new data:
import joblib
filename = './diabetes_model.pkl'
joblib.dump(model, filename)
When we have some new observations for which the label is unknown, we can load the
model and use it to predict values for the unknown label:
model = joblib.load(filename)
# predict on a new sample
# The model accepts an array of feature arrays (so you can predict the
classes of multiple patients in a single call)
# We'll create an array with a single array of features, representing
one patient
X_new = np.array([[2,180,74,24,21,23.9091702,1.488172308,22]])
print ('New sample: {}'.format(list(X_new[0])))
# Get a prediction
pred = model.predict(X_new)
# The model returns an array of predictions - one for each set of
features submitted
# In our case, we only submitted one patient, so our prediction is the
first one in the resulting array.
print('Predicted class is {}'.format(pred[0]))
Summary
In this notebook, we looked at a range of metrics for binary classification and tried a few
algorithms beyond logistic regression. We will move onto more complex classification
problems in the following notebook.
Creación de modelos de clasificación
multiclase
Completado
100 XP
4 minutos
También es posible crear modelos de clasificación multiclase, en los que hay más de
dos clases posibles. Por ejemplo, el consultorio médico podría ampliar el modelo de
diabetes para clasificar a los pacientes como:
● No diabéticos
● Diabéticos de tipo 1
● Diabéticos de tipo 2
Los valores de probabilidad de las clases individuales aún sumarían un total de 1 (el
paciente definitivamente está en una de las tres clases), y el modelo prediría la
clase más probable.
Uso de modelos de clasificación multiclase

La clasificación multiclase puede considerarse una combinación de varios
clasificadores binarios. Hay dos maneras de abordar el problema:
● Una frente al resto (OVR), en el que se crea un clasificador para cada

valor de clase posible, con un resultado positivo para los casos en los
que la predicción es esta clase y predicciones negativas para los casos
en los que la predicción es cualquier otra clase. Por ejemplo, un
problema de clasificación con cuatro clases de formas posibles
(cuadrado, círculo, triángulo, hexágono) requeriría cuatro clasificadores
que predigan:
○ cuadrado o no
○ círculo o no
○ triángulo o no
○ hexágono o no
● Uno frente a uno (OVO), en el que se crea un clasificador para cada par
de clases posible. El problema de clasificación con cuatro clases de
formas requeriría los siguientes clasificadores binarios:
○ cuadrado o círculo
○ cuadrado o triángulo
○ cuadrado o hexágono
○ círculo o triángulo
○ círculo o hexágono
○ triángulo o hexágono
En los dos enfoques, el modelo general debe tener en cuenta todas estas
predicciones para determinar a qué categoría única pertenece el elemento.
Afortunadamente, en la mayoría de los marcos de aprendizaje automático, incluido

Scikit-learn, la implementación de un modelo de clasificación multiclase no es
significativamente más compleja que la clasificación binaria y, en la mayoría de los
casos, los estimadores utilizados para la clasificación binaria admiten implícitamente
la clasificación multiclase abstrayendo un algoritmo OVR o un algoritmo OVO, o
permitiendo la elección de cualquiera de ellos.

evaluación de modelos de clasificación multiclase
modelos de clasificación multiclase
Multiclass Classification
In the last notebook, we looked at binary classification. This works well when the data
observations belong to one of two classes or categories, such as "True" or "False". When
the data can be categorized into more than two classes, you must use a multiclass
classification algorithm.
Multiclass classification can be thought of as a combination of multiple binary classifiers.

There are two ways in which you approach the problem:
● One vs Rest (OVR), in which a classifier is created for each possible class value,
with a positive outcome for cases where the prediction is this class, and negative
predictions for cases where the prediction is any other class. A classification problem
with four possible shape classes (square, circle, triangle, hexagon) would require four
classifiers that predict:
○ square or not
○ circle or not
○ triangle or not
○ hexagon or not
● One vs One (OVO), in which a classifier for each possible pair of classes is created.
The classification problem with four shape classes would require the following binary
classifiers:
○ square or circle
○ square or triangle
○ square or hexagon
○ circle or triangle
○ circle or hexagon
○ triangle or hexagon
In both approaches, the overall model that combines the classifiers generates a vector of
predictions in which the probabilities generated from the individual binary classifiers are used
to determine which class to predict.
Fortunately, in most machine learning frameworks, including scikit-learn, implementing a

multiclass classification model is not significantly more complex than binary classification -
and in most cases, the estimators used for binary classification implicitly support multiclass
classification by abstracting an OVR algorithm, an OVO algorithm, or by allowing a choice of
either.
More Information: To learn more about estimator support for multiclass classification in
Scikit-Learn, see the Scikit-Learn documentation.
Explore the data

Let's start by examining a dataset that contains observations of multiple classes. We'll use a
dataset that contains observations of three different species of penguin.
Citation: The penguins dataset used in the this exercise is a subset of data collected and
made available by Dr. Kristen Gorman and the Palmer Station, Antarctica LTER, a member
of the Long Term Ecological Research Network.
import pandas as pd
!wget
https://raw.githubusercontent.com/MicrosoftDocs/mslearn-introduction-to-machine-learning/
main/Data/ml-basics/penguins.csv
penguins = pd.read_csv('penguins.csv')
# Display a random sample of 10 observations
sample = penguins.sample(10)
sample
The dataset contains the following columns:
● CulmenLength: The length in mm of the penguin's culmen (bill).

● CulmenDepth: The depth in mm of the penguin's culmen.
● FlipperLength: The length in mm of the penguin's flipper.
● BodyMass: The body mass of the penguin in grams.
● Species: An integer value that represents the species of the penguin.
The Species column is the label we want to train a model to predict. The dataset includes
three possible species, which are encoded as 0, 1, and 2. The actual species names are
revealed by the code below:
penguin_classes = ['Adelie', 'Gentoo', 'Chinstrap']
print(sample.columns[0:5].values, 'SpeciesName')
for index, row in penguins.sample(10).iterrows():
print('[',row[0], row[1], row[2], row[3], int(row[4]),']',penguin_classes[int(row[4])])
Now that we know what the features and labels in the data represent, let's explore the
dataset. First, let's see if there are any missing (null) values.
# Count the number of null values for each column
penguins.isnull().sum()
It looks like there are some missing feature values, but no missing labels. Let's dig a little
deeper and see the rows that contain nulls.
# Show rows containing nulls
penguins[penguins.isnull().any(axis=1)]
There are two rows that contain no feature values at all (NaN stands for "not a number"), so
these won't be useful in training a model. Let's discard them from the dataset.
# Drop rows containing NaN values
penguins=penguins.dropna()
#Confirm there are now no nulls
penguins.isnull().sum()
Now that we've dealt with the missing values, let's explore how the features relate to the
label by creating some box charts.
%matplotlib inline
penguin_features = ['CulmenLength','CulmenDepth','FlipperLength','BodyMass']
penguin_label = 'Species'
for col in penguin_features:
penguins.boxplot(column=col, by=penguin_label, figsize=(6,6))
plt.title(col)
plt.show()
From the box plots, it looks like species 0 and 2 (Adelie and Chinstrap) have similar data
profiles for culmen depth, flipper length, and body mass, but Chinstraps tend to have longer
culmens. Species 1 (Gentoo) tends to have fairly clearly differentiated features from the
others; which should help us train a good classification model.
Prepare the data

Just as for binary classification, before training the model, we need to separate the features
and label, and then split the data into subsets for training and validation. We'll also apply a
stratification technique when splitting the data to maintain the proportion of each label value
in the training and validation datasets.
penguins_X, penguins_y = penguins[penguin_features].values,
penguins[penguin_label].values
x_penguin_train, x_penguin_test, y_penguin_train, y_penguin_test =
train_test_split(penguins_X, penguins_y,
test_size=0.30,
random_state=0,
stratify=penguins_y)
print ('Training Set: %d, Test Set: %d \n' % (x_penguin_train.shape[0],
x_penguin_test.shape[0]))
Train and evaluate a multiclass classifier

Now that we have a set of training features and corresponding training labels, we can fit a
multiclass classification algorithm to the data to create a model. Most scikit-learn
classification algorithms inherently support multiclass classification. We'll try a logistic
regression algorithm.
reg = 0.1
multi_model = LogisticRegression(C=1/reg, solver='lbfgs', multi_class='auto',
max_iter=10000).fit(x_penguin_train, y_penguin_train)
print (multi_model)
Now we can use the trained model to predict the labels for the test features, and compare
the predicted labels to the actual labels:
penguin_predictions = multi_model.predict(x_penguin_test)
print('Predicted labels: ', penguin_predictions[:15])
print('Actual labels : ' ,y_penguin_test[:15])
Let's look at a classification report.
from sklearn. metrics import classification_report
print(classification_report(y_penguin_test, penguin_predictions))
As with binary classification, the report includes precision and recall metrics for each class.
However, while with binary classification we could focus on the scores for the positive class;
in this case, there are multiple classes so we need to look at an overall metric (either the
macro or weighted average) to get a sense of how well the model performs across all three
classes.
You can get the overall metrics separately from the report using the scikit-learn metrics score
classes, but with multiclass results you must specify which average metric you want to use
for precision and recall.
from sklearn.metrics import accuracy_score, precision_score, recall_score
print("Overall Accuracy:",accuracy_score(y_penguin_test, penguin_predictions))
print("Overall Precision:",precision_score(y_penguin_test, penguin_predictions,
average='macro'))
print("Overall Recall:",recall_score(y_penguin_test, penguin_predictions, average='macro'))
Now let's look at the confusion matrix for our model:
# Print the confusion matrix
mcm = confusion_matrix(y_penguin_test, penguin_predictions)
print(mcm)
The confusion matrix shows the intersection of predicted and actual label values for each
class - in simple terms, the diagonal intersections from top-left to bottom-right indicate the
number of correct predictions.
When dealing with multiple classes, it's generally more intuitive to visualize this as a heat
map, like this:
import numpy as np
%matplotlib inline
plt.imshow(mcm, interpolation="nearest", cmap=plt.cm.Blues)
plt.colorbar()
tick_marks = np.arange(len(penguin_classes))
plt.xticks(tick_marks, penguin_classes, rotation=45)
plt.yticks(tick_marks, penguin_classes)
plt.xlabel("Predicted Species")
plt.ylabel("Actual Species")
plt.show()
The darker squares in the confusion matrix plot indicate high numbers of cases, and you can
hopefully see a diagonal line of darker squares indicating cases where the predicted and
actual label are the same.
In the case of a multiclass classification model, a single ROC curve showing true positive
rate vs false positive rate is not possible. However, you can use the rates for each class in a
One vs Rest (OVR) comparison to create a ROC chart for each class.
from sklearn.metrics import roc_curve
from sklearn.metrics import roc_auc_score
# Get class probability scores
penguin_prob = multi_model.predict_proba(x_penguin_test)
# Get ROC metrics for each class
fpr = {}
tpr = {}
thresh ={}
for i in range(len(penguin_classes)):
fpr[i], tpr[i], thresh[i] = roc_curve(y_penguin_test, penguin_prob[:,i], pos_label=i)
# Plot the ROC chart

plt.plot(fpr[0], tpr[0], linestyle='--',color='orange', label=penguin_classes[0] + ' vs Rest')
plt.plot(fpr[1], tpr[1], linestyle='--',color='green', label=penguin_classes[1] + ' vs Rest')
plt.plot(fpr[2], tpr[2], linestyle='--',color='blue', label=penguin_classes[2] + ' vs Rest')
plt.title('Multiclass ROC curve')
plt.ylabel('True Positive rate')
plt.legend(loc='best')
plt.show()
To quantify the ROC performance, you can calculate an aggregate area under the curve
score that is averaged across all of the OVR curves.
auc = roc_auc_score(y_penguin_test,penguin_prob, multi_class='ovr')
print('Average AUC:', auc)
Preprocess data in a pipeline

Again, just like with binary classification, you can use a pipeline to apply preprocessing steps
to the data before fitting it to an algorithm to train a model. Let's see if we can improve the
penguin predictor by scaling the numeric features in a transformation steps before training.
We'll also try a different algorithm (a support vector machine), just to show that we can!
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
# Define preprocessing for numeric columns (scale them)
feature_columns = [0,1,2,3]
feature_transformer = Pipeline(steps=[
('scaler', StandardScaler())
])
# Create preprocessing steps
transformers=[
('preprocess', feature_transformer, feature_columns)])
# Create training pipeline
('regressor', SVC(probability=True))])
# fit the pipeline to train a linear regression model on the training set
multi_model = pipeline.fit(x_penguin_train, y_penguin_train)
print (multi_model)
Now we can evaluate the new model.
# Get predictions from test data
penguin_predictions = multi_model.predict(x_penguin_test)
penguin_prob = multi_model.predict_proba(x_penguin_test)
# Overall metrics
print("Overall Accuracy:",accuracy_score(y_penguin_test, penguin_predictions))
print("Overall Precision:",precision_score(y_penguin_test, penguin_predictions,
average='macro'))
print("Overall Recall:",recall_score(y_penguin_test, penguin_predictions, average='macro'))
print('Average AUC:', roc_auc_score(y_penguin_test,penguin_prob, multi_class='ovr'))
# Confusion matrix
plt.imshow(mcm, interpolation="nearest", cmap=plt.cm.Blues)
plt.colorbar()
tick_marks = np.arange(len(penguin_classes))
plt.xticks(tick_marks, penguin_classes, rotation=45)
plt.yticks(tick_marks, penguin_classes)
plt.xlabel("Predicted Species")
plt.ylabel("Actual Species")
plt.show()
Use the model with new data observations

Now let's save our trained model so we can use it again later.
import joblib
filename = './penguin_model.pkl'
joblib.dump(multi_model, filename)
OK, so now we have a trained model. Let's use it to predict the class of a new penguin
observation:
multi_model = joblib.load(filename)
# The model accepts an array of feature arrays (so you can predict the classes of multiple
penguin observations in a single call)
# We'll create an array with a single array of features, representing one penguin
x_new = np.array([[50.4,15.3,224,5550]])
print ('New sample: {}'.format(x_new[0]))
# The model returns an array of predictions - one for each set of features submitted
# In our case, we only submitted one penguin, so our prediction is the first one in the
resulting array.
penguin_pred = multi_model.predict(x_new)[0]
print('Predicted class is', penguin_classes[penguin_pred])
You can also submit a batch of penguin observations to the model, and get back a prediction
for each one.
# This time our input is an array of two feature arrays
x_new = np.array([[49.5,18.4,195, 3600],
[38.2,20.1,190,3900]])
print ('New samples:\n{}'.format(x_new))
# Call the web service, passing the input data
predictions = multi_model.predict(x_new)
# Get the predicted classes.
for prediction in predictions:
print(prediction, '(' + penguin_classes[prediction] +')')
Summary
Classification is one of the most common forms of machine learning, and by following the
basic principles we've discussed in this notebook you should be able to train and evaluate
classification models with scikit-learn. It's worth spending some time investigating
classification algorithms in more depth, and a good starting point is the Scikit-Learn
documentation.
Resumen
En este módulo, ha aprendido cómo se puede usar la clasificación para crear un modelo de
aprendizaje automático que predice categorías o clases. Después, ha usado el marco de
Scikit-learn en Python para entrenar y evaluar un modelo de clasificación.
Aunque Scikit-learn es un marco popular para escribir código con el fin de entrenar modelos
de clasificación, también puede crear soluciones de aprendizaje automático para
clasificación con las herramientas gráficas de Microsoft Azure Machine Learning. Para
obtener más información sobre el desarrollo sin código de modelos de clasificación
mediante Azure Machine Learning, consulte el módulo Creación de un modelo de
clasificación con el diseñador de Azure Machine Learning.
Desafío: Clasificación de vinos

¿Le parece difícil entrenar un modelo de clasificación? Pruebe el desafío en el cuaderno
/challenges/03 - Wine Classification Challenge.ipynb para ver si puede clasificar los vinos en
sus variedades de uva.
modelos de agrupación en clústeres
38 min.
Módulo
7 Unidades
4.8 (1610)
Califíquelo
IntermedioCientífico de datosAzure
La agrupación en clústeres es un tipo de aprendizaje automático que se usa para

agrupar elementos similares en clústeres.
● Cuándo usar la agrupación en clústeres

● Cómo entrenar y evaluar un modelo de agrupación en clústeres mediante el
marco scikit-learn
Introducción
Completado
100 XP
2 minutos
La agrupación en clústeres es el proceso de agrupar objetos con objetos similares.

Por ejemplo, en la imagen siguiente tenemos una colección de coordenadas 2D que
se han agrupado en tres categorías: superior izquierda (amarillo), inferior (rojo) y
superior derecha (azul).
Una diferencia importante entre los modelos de agrupación en clústeres y
clasificación es que la agrupación en clústeres es un método "no supervisado",
donde el "entrenamiento" se realiza sin etiquetas. En su lugar, los modelos
identifican ejemplos que tienen una colección similar de características. En la
imagen anterior, los ejemplos que se encuentran en una ubicación similar se
agrupan.
La agrupación en clústeres es común y útil para explorar nuevos datos en los que
aún no se conocen patrones entre puntos de datos, como categorías de alto nivel.
Se usa en muchos campos que necesitan etiquetar automáticamente datos
complejos, incluido el análisis de redes sociales, la conectividad cerebral o el filtrado
de correo no deseado, entre otros.
¿Qué es la agrupación en clústeres?

Completado
100 XP
5 minutos
La agrupación en clústeres es un tipo de aprendizaje automático sin supervisión en

el que las observaciones se agrupan en clústeres en función de las similitudes en
sus valores de datos o características. Este tipo de aprendizaje automático se
considera no supervisado porque no usa valores de etiqueta conocidos previamente
para entrenar un modelo. En un modelo de agrupación en clústeres, la etiqueta es el
clúster al que se asigna la observación, únicamente en función en sus
características.
Por ejemplo, supongamos que un botánico observa una muestra de flores y registra
el número de pétalos y hojas en cada flor.
Puede ser útil agrupar estas flores en clústeres en función de las similitudes entre
sus características.
Hay muchas maneras de hacerlo. Por ejemplo, si la mayoría de las flores tienen el
mismo número de hojas, podrían agruparse en aquellas con muchos o pocos
pétalos. Por otra parte, si el número de pétalos y hojas varía considerablemente,
puede haber un patrón que detectar, como que las que tienen muchas hojas
también tienen muchos pétalos. El objetivo del algoritmo de agrupación en clústeres
es encontrar la manera óptima de dividir el conjunto de datos en grupos. El
significado de "óptima" depende del algoritmo utilizado y del conjunto de datos que
se proporciona.
Aunque este ejemplo de la flor puede ser sencillo para un humano con solo unas
pocas muestras, a medida que el conjunto de datos crece a miles de muestras o a
más de dos características, los algoritmos de agrupación en clústeres se vuelven
muy útiles para diseccionar rápidamente un conjunto de datos en grupos.

evaluación de un modelo de agrupación en
clústeres
un modelo de agrupación en clústeres
Clustering - Introduction
In contrast to supervised machine learning, unsupervised learning is used when there is no
"ground truth" from which to train and validate label predictions. The most common form of
unsupervised learning is clustering, which is simllar conceptually to classification, except that
the the training data does not include known values for the class label to be predicted.
Clustering works by separating the training cases based on similarities that can be
determined from their feature values. Think of it this way; the numeric features of a given
entity can be thought of as vector coordinates that define the entity's position in
n-dimensional space. What a clustering model seeks to do is to identify groups, or clusters,
of entities that are close to one another while being separated from other clusters.
For example, let's take a look at a dataset that contains measurements of different species
of wheat seed.
Citation: The seeds dataset used in the this exercise was originally published by the Institute
of Agrophysics of the Polish Academy of Sciences in Lublin, and can be downloaded from
the UCI dataset repository (Dua, D. and Graff, C. (2019). UCI Machine Learning Repository
http://archive.ics.uci.edu/ml. Irvine, CA: University of California, School of Information and
Computer Science).
import pandas as pd
!wget
main/Data/ml-basics/seeds.csv
data = pd.read_csv('seeds.csv')
# Display a random sample of 10 observations (just the features)
features = data[data.columns[0:6]]
features.sample(10)
As you can see, the dataset contains six data points (or features) for each instance
(observation) of a seed. So you could interpret these as coordinates that describe each
instance's location in six-dimensional space.
Now, of course six-dimensional space is difficult to visualise in a three-dimensional world, or

on a two-dimensional plot; so we'll take advantage of a mathematical technique called
Principal Component Analysis (PCA) to analyze the relationships between the features and
summarize each observation as coordinates for two principal components - in other words,
we'll translate the six-dimensional feature values into two-dimensional coordinates.
from sklearn.decomposition import PCA
# Normalize the numeric features so they're on the same scale
scaled_features = MinMaxScaler().fit_transform(features[data.columns[0:6]])
# Get two principal components
pca = PCA(n_components=2).fit(scaled_features)
features_2d = pca.transform(scaled_features)
features_2d[0:10]
Now that we have the data points translated to two dimensions, we can visualize them in a
plot:
%matplotlib inline
plt.scatter(features_2d[:,0],features_2d[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data')
plt.show()
Hopefully you can see at least two, arguably three, reasonably distinct groups of data points;
but here lies one of the fundamental problems with clustering - without known class labels,
how do you know how many clusters to separate your data into?
One way we can try to find out is to use a data sample to create a series of clustering
models with an incrementing number of clusters, and measure how tightly the data points
are grouped within each cluster. A metric often used to measure this tightness is the within
cluster sum of squares (WCSS), with lower values meaning that the data points are closer.
You can then plot the WCSS for each model.
#importing the libraries
import numpy as np
from sklearn.cluster import KMeans
%matplotlib inline
# Create 10 models with 1 to 10 clusters
wcss = []
for i in range(1, 11):
kmeans = KMeans(n_clusters = i)
# Fit the data points
kmeans.fit(features.values)
# Get the WCSS (inertia) value
wcss.append(kmeans.inertia_)
#Plot the WCSS values onto a line graph

plt.plot(range(1, 11), wcss)
plt.title('WCSS by Clusters')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()
The plot shows a large reduction in WCSS (so greater tightness) as the number of clusters
increases from one to two, and a further noticable reduction from two to three clusters. After
that, the reduction is less pronounced, resulting in an "elbow" in the chart at around three
clusters. This is a good indication that there are two to three reasonably well separated
clusters of data points.
Summary
Here we looked at what clustering means, and how to determine whether clustering might be
appropriate for your data. In the next notebook, we will look at two ways of labelling the data
automatically.
Evaluación de diferentes tipos de

agrupación en clústeres
Entrenamiento de un modelo de agrupación en

clústeres
Hay varios algoritmos que puede usar para la agrupación en clústeres. Uno de los
algoritmos más usados es la agrupación en clústeres k-means que, en su forma más
sencilla, comprende los pasos siguientes:
1. Los valores de las características se vectorizan para definir coordenadas de n

dimensiones (donde n es el número de características). En el ejemplo de las
flores, tenemos dos características (el número de pétalos y el número de
hojas), por lo que el vector de características tiene dos coordenadas que se
pueden usar para trazar conceptualmente los puntos de datos en un espacio
de dos dimensiones.
2. Decida cuántos clústeres quiere usar para agrupar las flores y llame a
este valor k. Por ejemplo, para crear tres clústeres, usaría un valor k de 3.
Después, se representan los puntos k en coordenadas aleatorias. En
última instancia, estos puntos serán los puntos centrales de cada clúster,
por lo que se hace referencia a ellos como centroides.
3. Cada punto de datos (en este caso, cada flor) se asigna a su centroide más
cercano.
4. Cada centroide se mueve al centro de los puntos de datos asignados en
función de la distancia media entre los puntos.
5. Después de mover el centroide, los puntos de datos pueden pasar a estar más
cerca de otro centroide, por lo que se reasignan a los clústeres en función del
nuevo centroide más cercano.
6. Los pasos de movimiento de centroides y reasignación de clústeres se repiten
hasta que los clústeres se estabilizan o se alcanza un número máximo
predeterminado de iteraciones.
En la siguiente animación se ilustra este proceso:
Agrupación en clústeres jerárquica

La agrupación en clústeres jerárquica es otro tipo de algoritmo de agrupación en clústeres
en el que los propios clústeres pertenecen a un grupo más grande, que pertenecen a
grupos incluso más grandes, y así sucesivamente. El resultado es que los puntos de datos
pueden agruparse con diferentes grados de precisión: con un gran número de grupos muy
pequeños y precisos, o con un pequeño número de grupos más grandes.
Por ejemplo, si aplicamos la agrupación a los significados de las palabras, podemos obtener
un grupo que contenga adjetivos específicos de las emociones ("enfadado", "feliz", etc.),
que a su vez pertenezca a un grupo que contenga todos los adjetivos relacionados con el
ser humano ("feliz", "guapo", "joven"), y este a su vez pertenezca a un grupo aún mayor que
contenga todos los adjetivos ("feliz", "verde", "guapo", "duro", etc.).
La agrupación en clústeres jerárquicas es útil no solo para dividir los datos en grupos, sino
también para comprender las relaciones entre estos grupos. Una ventaja importante de la
agrupación en clústeres jerárquica es que no requiere que el número de clústeres se defina
de antemano y, a veces, puede proporcionar resultados más interpretables que los
enfoques no jerárquicos. El principal inconveniente es que estos enfoques pueden tardar
mucho más tiempo en calcularse que los enfoques más sencillos y, a veces, no son
adecuados para grandes conjuntos de datos.

evaluación de modelos de agrupación en clústeres
avanzados
modelos de agrupación en clústeres
avanzados
Clustering - K-Means and
Hierachial
In the last notebook, we learned that data can be broken into clusters and learned how to
see whether data may be compatible with such an analysis. In this notebook, we will perform
this clustering automatically.
To get started, run the cell below to load our data
Citation: The seeds dataset used in the this exercise was originally published by the Institute
of Agrophysics of the Polish Academy of Sciences in Lublin, and can be downloaded from
the UCI dataset repository (Dua, D. and Graff, C. (2019). UCI Machine Learning Repository
http://archive.ics.uci.edu/ml. Irvine, CA: University of California, School of Information and
Computer Science).
import pandas as pd
!wget
main/Data/ml-basics/seeds.csv
data = pd.read_csv('seeds.csv')
# Display a random sample of 10 observations (just the features)
features = data[data.columns[0:6]]
features.sample(10)
from sklearn.decomposition import PCA
# Normalize the numeric features so they're on the same scale
scaled_features = MinMaxScaler().fit_transform(features[data.columns[0:6]])
# Get two principal components
pca = PCA(n_components=2).fit(scaled_features)
features_2d = pca.transform(scaled_features)
features_2d[0:10]
K-Means Clustering
The algorithm we used to create our test clusters is K-Means. This is a commonly used
clustering algorithm that separates a dataset into K clusters of equal variance. The number
of clusters, K, is user defined. The basic algorithm has the following steps:
1. A set of K centroids are randomly chosen.

2. Clusters are formed by assigning the data points to their closest centroid.
3. The means of each cluster is computed and the centroid is moved to the mean.
4. Steps 2 and 3 are repeated until a stopping criteria is met. Typically, the algorithm
terminates when each new iteration results in negligable movement of centroids and
the clusters become static.
5. When the clusters stop changing, the algorithm has converged, defining the locations
of the clusters - note that the random starting point for the centroids means that
re-running the algorithm could result in slightly different clusters, so training usually
involves multiple iterations, reinitializing the centroids each time, and the model with
the best WCSS is selected.
Let's try using K-Means on our seeds data with a K value of 3.

from sklearn.cluster import KMeans
# Create a model based on 3 centroids
model = KMeans(n_clusters=3, init='k-means++', n_init=100, max_iter=1000)
# Fit to the data and predict the cluster assignments for each data point
km_clusters = model.fit_predict(features.values)
# View the cluster assignments
km_clusters
Let's see those cluster assignments with the two-dimensional data points.
%matplotlib inline
def plot_clusters(samples, clusters):
col_dic = {0:'blue',1:'green',2:'orange'}
mrk_dic = {0:'*',1:'x',2:'+'}
colors = [col_dic[x] for x in clusters]
markers = [mrk_dic[x] for x in clusters]
for sample in range(len(clusters)):
plt.scatter(samples[sample][0], samples[sample][1], color = colors[sample],
marker=markers[sample], s=100)
plt.title('Assignments')
plt.show()
plot_clusters(features_2d, km_clusters)
Hopefully, the the data has been separated into three distinct clusters.
So what's the practical use of clustering? In some cases, you may have data that you need
to group into distict clusters without knowing how many clusters there are or what they
indicate. For example a marketing organization might want to separate customers into
distinct segments, and then investigate how those segments exhibit different purchasing
behaviors.
Sometimes, clustering is used as an initial step towards creating a classification model. You
start by identifying distinct groups of data points, and then assign class labels to those
clusters. You can then use this labelled data to train a classification model.
In the case of the seeds data, the different species of seed are already known and encoded
as 0 (Kama), 1 (Rosa), or 2 (Canadian), so we can use these identifiers to compare the
species classifications to the clusters identified by our unsupervised algorithm
seed_species = data[data.columns[7]]
plot_clusters(features_2d, seed_species.values)
There may be some differences between the cluster assignments and class labels, but the
K-Means model should have done a reasonable job of clustering the observations so that
seeds of the same species are generally in the same cluster.
Hierarchical Clustering
Hierarchical clustering methods make fewer distributional assumptions when compared to
K-means methods. However, K-means methods are generally more scalable, sometimes
very much so.
Hierarchical clustering creates clusters by either a divisive method or agglomerative method.

The divisive method is a "top down" approach starting with the entire dataset and then
finding partitions in a stepwise manner. Agglomerative clustering is a "bottom up** approach.
In this lab you will work with agglomerative clustering which roughly works as follows:
1. The linkage distances between each of the data points is computed.

2. Points are clustered pairwise with their nearest neighbor.
3. Linkage distances between the clusters are computed.
4. Clusters are combined pairwise into larger clusters.
5. Steps 3 and 4 are repeated until all data points are in a single cluster.
The linkage function can be computed in a number of ways:
● Ward linkage measures the increase in variance for the clusters being linked,
● Average linkage uses the mean pairwise distance between the members of the two
clusters,
● Complete or Maximal linkage uses the maximum distance between the members of
the two clusters.
Several different distance metrics are used to compute linkage functions:

● Euclidian or l2 distance is the most widely used. This metric is only choice for the
Ward linkage method.
● Manhattan or l1 distance is robust to outliers and has other interesting properties.
● Cosine similarity, is the dot product between the location vectors divided by the
magnitudes of the vectors. Notice that this metric is a measure of similarity, whereas
the other two metrics are measures of difference. Similarity can be quite useful when
working with data such as images or text documents.
Agglomerative Clustering
Let's see an example of clustering the seeds data using an agglomerative clustering
algorithm.
from sklearn.cluster import AgglomerativeClustering
agg_model = AgglomerativeClustering(n_clusters=3)
agg_clusters = agg_model.fit_predict(features.values)
agg_clusters
So what do the agglomerative cluster assignments look like?
%matplotlib inline
def plot_clusters(samples, clusters):
col_dic = {0:'blue',1:'green',2:'orange'}
mrk_dic = {0:'*',1:'x',2:'+'}
colors = [col_dic[x] for x in clusters]
markers = [mrk_dic[x] for x in clusters]
for sample in range(len(clusters)):
plt.scatter(samples[sample][0], samples[sample][1], color = colors[sample],
marker=markers[sample], s=100)
plt.title('Assignments')
plt.show()
plot_clusters(features_2d, agg_clusters)
Summary
Here we practiced using K-means and heirachial clustering. This unsupervised learning has
the ability to take unlabelled data and identify which of these data are similar to one another.
Resumen
En este módulo, ha aprendido a usar la agrupación en clústeres para crear modelos de
aprendizaje automático no supervisados que agrupan observaciones de datos en clústeres.
Después, ha usado el marco scikit-learn en Python para entrenar un modelo de agrupación
en clústeres.
Aunque scikit-learn es un marco popular para escribir código con el fin de entrenar modelos
de agrupación en clústeres, también puede crear soluciones de aprendizaje automático para
la agrupación en clústeres con las herramientas gráficas de Microsoft Azure Machine
Learning. Para obtener más información sobre el desarrollo sin código de modelos de
agrupación en clústeres mediante Azure Machine Learning, consulte el módulo Creación de
un modelo de agrupación en clústeres con el diseñador de Azure Machine Learning.
Desafío: Agrupación de datos sin etiquetar

Ahora que ha visto cómo crear un modelo de agrupación en clústeres, ¿por qué no prueba
con uno? Encontrará un desafío de agrupación en clústeres en el cuaderno 04 - Clustering
Challenge.ipynb.
Entrenamiento y evaluación de modelos
de aprendizaje profundo
El aprendizaje profundo es una forma avanzada de aprendizaje automático que
emula el modo en que el cerebro humano aprende a través de redes de neuronas
conectadas.
● Principios básicos del aprendizaje profundo.

● Cómo entrenar una red neuronal profunda (DNN) con PyTorch o Tensorflow
● Cómo entrenar una red neuronal convolucional (CNN) mediante PyTorch o
Tensorflow
● Cómo usar el aprendizaje por transferencia para entrenar una red neuronal
convolucional (CNN) con PyTorch o Tensorflow.
Introducción
El aprendizaje profundo es una forma avanzada de aprendizaje automático que
intenta emular el modo en que el cerebro humano aprende.
El cerebro tiene células nerviosas, las neuronas, que están conectadas entre sí por
extensiones nerviosas que transmiten señales electroquímicas a través de la red.
Cuando se estimula la primera neurona de la red, se procesa la señal de entrada y,
si supera un umbral determinado, el neurona se activa y transmite la señal a las
neuronas con las que está conectada. A su vez, estas neuronas se pueden activar y
transmitir la señal a través del resto de la red. Con el tiempo, las conexiones entre
los neuronas se refuerzan por el uso frecuente a medida que aprende a responder
de forma eficaz. Por ejemplo, si alguien le lanza un balón, sus conexiones
neuronales le permiten procesar la información visual y coordinar los movimientos
para atraparlo. Si realiza esta acción varias veces, la red de neuronas que le permite
atrapar un balón será más fuerte y, por lo tanto, mejorará a la hora de atrapar un
balón.
El aprendizaje profundo emula este proceso biológico mediante redes neuronal

artificiales que procesan entradas numéricas en lugar de estímulos electroquímicos.
Las conexiones nerviosas entrantes se reemplazan por entradas numéricas que se

suelen identificar como x. Cuando hay más de un valor de entrada, x se considera
vector con elementos denominados x1, x2, y así sucesivamente.
Asociado con cada valor x hay un valor ponderación (w), que se usa para fortalecer
o debilitar el efecto del valor x para simular el aprendizaje. Además, se agrega una
entrada sesgo (b) para permitir el control específico sobre la red. Durante el proceso
de entrenamiento, se ajustarán los valores w y b para optimizar la red de modo que
"aprenda" a generar los resultados correctos.
La neurona misma encapsula una función que calcula una suma ponderada de x, w
y b. A su vez, esta función se encuentra en una función de activación que restringe
el resultado (por lo general, a un valor entre 0 y 1) a fin de determinar si la neurona
transmite o no un resultado a la capa siguiente de neuronas de la red.
Conceptos de red neuronal profunda

Antes de explorar cómo entrenar un modelo de Machine Learning de red neuronal
profunda(DNN), consideremos lo que se intenta lograr. El aprendizaje automático
está relacionado con la predicción de una etiqueta en función de algunas
características de una observación determinada. En términos simples, un modelo de
Machine Learning es una función que calcula y (la etiqueta) a partir de x (las
características): f(x)=y.
Un ejemplo de clasificación simple

Por ejemplo, supongamos que la observación consta de algunas medidas de un
pingüino.
Específicamente, las medidas son las siguientes:
● El largo del pico del pingüino.

● La profundidad del pico del pingüino.
● El largo de la aleta del pingüino.
● El peso del pingüino.
En este caso, las características (x) son un vector de cuatro valores, o bien,
matemáticamente expresado, x=[x1,x2,x3,x4].
Imagine que la etiqueta que intenta predecir (y) es la especie del pingüino y que hay
tres posibilidades de especie:
1. Adelia
2. Papúa
3. Barbijo
Este es un ejemplo de un problema de clasificación, en el que el modelo de Machine

Learning debe predecir la clase más probable a la que pertenece la observación. Un
modelo de clasificación logra esto mediante la predicción de una etiqueta que
consta de la probabilidad de cada clase. Es decir, y es un vector de valores de tres
probabilidades, una para cada una de las posibles clases: y=[P(0),P(1),P(2)].
Puede entrenar el modelo de Machine Learning con las observaciones para las que
ya conoce la etiqueta verdadera. Por ejemplo, puede tener las medidas de
características siguientes para un pingüino de Adelia:
x=[37.3, 16.8, 19.2, 30.0]
Ya sabe que se trata de un ejemplo de un pingüino de Adelia (clase 0), por lo que
una función de clasificación perfecta debe dar como resultado una etiqueta que
indique una probabilidad del 100 % para la clase 0 y una probabilidad del 0 % para
las clases 1 y 2:
y=[1, 0, 0]
Un modelo de red neuronal profunda

Por tanto, ¿cómo podríamos usar el aprendizaje profundo para crear un modelo de
clasificación para el modelo de clasificación de los pingüinos? Veamos un ejemplo:
El modelo de red neuronal profunda para el clasificador consta de varias capas de
neuronas artificiales. En este caso, hay cuatro capas:
● Una capa de entrada con una neurona para cada valor de entrada
esperado (x).
● Dos capas denominadas ocultas, cada una con cinco neuronas.
● Una capa de salida con tres neuronas, una para cada valor de
probabilidad de clase (y) que el modelo va a predecir.
Debido a la arquitectura en capas de la red, este tipo de modelo se conoce a veces

como perceptrón de varias capas. Además, tenga en cuenta que todas las neuronas
de las capas de entrada y ocultas están conectadas a todas los neuronas de las
capas subsiguientes. Este es un ejemplo de una red totalmente conectada.
Al crear un modelo como este, debe definir un capa de entrada que admita la
cantidad de características que va a procesar el modelo y una capa de salida que
refleje la cantidad de salidas que espera que genere. Puede decidir la cantidad de
capas ocultas que quiere incluir y cuántas neuronas en cada una de ellas, pero no
tiene ningún control sobre los valores de entrada y salida de estas capas, ya que se
determinan mediante el proceso de entrenamiento del modelo.
Entrenamiento de una red neuronal profunda

El proceso de entrenamiento de una red neuronal profunda se compone de varias
iteraciones, llamadas épocas. Para la primera época, empiece por asignar valores
de inicialización aleatorios para los valores de ponderación (w) y sesgo b. Luego, el
proceso es tal como se muestra a continuación:
1. Las características de las observaciones de datos con valores de

etiqueta conocidos se envían a la capa de entrada. Por lo general, estas
observaciones se agrupan en lotes (que se suelen denominar como
mini lotes).
2. Luego, las neuronas aplican su función y, si está activada, pasan el
resultado a la capa siguiente hasta que la capa de salida genera una
predicción.
3. La predicción se compara con el valor conocido real y se calcula el
monto de la varianza entre los valores previstos y los verdaderos (lo que
se conoce como la pérdida).
4. En función de los resultados, se calculan los valores revisados de los
valores de ponderación y sesgo a fin de reducir la pérdida y estos
ajustes se retropropagan a la neuronas de las capas de la red.
5. En la época siguiente, el entrenamiento por lotes se repite con
propagación hacia adelante con los valores de ponderación y sesgo
corregidos, a fin de mejorar la precisión del modelo (mediante la
reducción de la pérdida).
Nota
El procesamiento de las características de entrenamiento como un lote mejora la

eficacia del proceso de entrenamiento mediante el procesamiento de varias
observaciones de manera simultánea como una matriz de características con
vectores de ponderaciones y sesgos. Las funciones algebraicas lineales que
trabajan con matrices y vectores también se usan en el procesamiento de gráficos
3D. Como resultado, los equipos con unidades de procesamiento gráfico (GPU)
ofrecen un rendimiento significativamente mejor para entrenar modelos de
aprendizaje profundo que los equipos que solo tienen CPU (unidad de
procesamiento central).
Una visión más detallada de las funciones de pérdida y

la retropropagación
En la descripción anterior del proceso de entrenamiento de aprendizaje profundo se
mencionó que la pérdida del modelo se calcula y utiliza para ajustar los valores de
ponderación y sesgo. ¿Cómo funciona esto exactamente?
Cálculo de la pérdida
Supongamos que uno de los ejemplos transmitidos a través del proceso de

entrenamiento contiene las características de un pingüino de Adelia (clase 0). La
salida correcta de la red sería [1, 0, 0]. Ahora, supongamos que la red genera la
salida [0.4, 0.3, 0.3]. Si las comparamos, podemos calcular una varianza absoluta
para cada elemento (es decir, la distancia entre cada valor previsto y el valor que
debería ser) como [0.6, 0.3, 0.3].
Dado que en la práctica se procesan varias observaciones, generalmente se agrega

la varianza, por ejemplo, elevando cada valor de varianza a la potencia de 2 y luego
calculando la media para terminar con un solo valor de pérdida promedio, como
0,18.
Optimizadores
Ahora viene la parte inteligente. La pérdida se calcula con una función que opera en
los resultados de la capa final de la red, que también es una función. La capa de red
final funciona en las salidas de las capas anteriores, que también son funciones. Por
tanto, todo el modelo, desde la capa de entrada hasta el cálculo de la pérdida, no es
más que una gran función anidada. Las funciones tienen algunas características
muy útiles, entre las que se incluyen las siguientes:
● Puede conceptualizar una función como una línea trazada si compara

su salida con cada una de sus variables.
● Puede usar un cálculo diferencial para calcular la derivada de la función
en cualquier punto con respecto a sus variables.
Tomemos la primera de estas funcionalidades. Podemos trazar la línea de la función

para mostrar cómo se compara un valor de ponderación individual con la pérdida y
marcar en esa línea el punto en el que el valor de ponderación actual coincide con el
valor de pérdida actual.
Ahora aplicaremos la segunda característica de una función. La derivada de una
función para un punto determinado indica si la pendiente (o gradiente) de la salida
de la función (en este caso, la pérdida) aumenta o disminuye con respecto a una
variable de función (en este caso, el valor de ponderación). Una derivada positiva
indica que la función está aumentando, mientras que una negativo indica que
disminuye. En este caso, en el punto trazado del valor de ponderación actual, la
función tiene una gradiente descendente. En otras palabras, el aumento de la
ponderación disminuirá la pérdida.
Usamos un optimizador para aplicar este mismo truco a todas las variables de
ponderación y sesgo del modelo y determinar en qué dirección se deben ajustar
(hacia arriba o hacia abajo) para disminuir la cantidad total de pérdidas en el
modelo. Hay varios algoritmos de optimización de uso común, que incluyen el
descenso por gradiente estocástico (SGD), la tasa de aprendizaje adaptativo
(ADADELTA) y la estimación de impulso adaptativo (Adam), entre otros; todos
diseñados para determinar cómo ajustar las ponderaciones y los sesgos para
reducir las pérdidas.
Velocidad de aprendizaje
Ahora, la siguiente pregunta obvia es: ¿cuánto debería ajustar el optimizador los
valores de ponderaciones y sesgos? Si observa el trazado del valor de ponderación,
puede ver que con un ligero aumento de la ponderación, la línea funcional cae
(disminución de la pérdida). Sin embargo, si el valor aumenta demasiado, la línea de
función comenzará a aumentar nuevamente y la pérdida puede incluso aumentar.
Puede ser que después de la época siguiente resulte necesario disminuir la
ponderación.
El tamaño del ajuste se controla mediante un parámetro que se establece para el

entrenamiento, denominado velocidad de aprendizaje. Una velocidad de aprendizaje
baja genera ajustes pequeños (por lo que puede tardar más épocas en minimizar la
pérdida), mientras que una velocidad de aprendizaje alta genera ajustes grandes
(de modo que es posible que no se alcance el mínimo).
Ejercicio: Entrenamiento de una red

neuronal profunda
Hasta ahora, aprendió mucho sobre la teoría y los principios del aprendizaje
profundo con redes neuronales. La mejor manera de aprender a aplicar esta teoría
es compilar un modelo de aprendizaje profundo. Eso es precisamente lo que hará
en este ejercicio.
Hay muchos marcos de trabajo disponibles para el entrenamiento de redes neuronal

profundas y, en este ejercicio, puede optar por explorar dos de los marcos de
aprendizaje profundo más populares para Python: PyTorch y TensorFlow.
Antes de comenzar
Para completar el ejercicio, necesitará lo siguiente:
● Una suscripción a Microsoft Azure. Si aún no tiene una, puede solicitar

una prueba gratuita en https://azure.microsoft.com/free.
● Un área de trabajo de Azure Machine Learning con una instancia de
proceso y el repositorio ml-basics clonado.
Nota
En este módulo se usa un área de trabajo de Azure Machine Learning. Si va a

completar este módulo como preparación para la certificación Azure Data Scientist,
considere la posibilidad de crear el área de trabajo una vez y reutilizarla en otros
módulos. Después de completar el ejercicio, asegúrese de seguir las instrucciones
de limpieza para detener los recursos de procesos y conservar el área de trabajo si
planea reutilizarla.
Creación de un área de trabajo de Azure Machine Learning
Si aún no tiene un área de trabajo de Azure Machine Learning en su suscripción a

Azure, siga estos pasos para crear una:
1. Inicie sesión en Azure Portal con la cuenta de Microsoft asociada a su

suscripción de Azure.
2. En la página Inicio de Azure, en Servicios de Azure, seleccione Crear
un recurso. Aparecerá el panel Crear un recurso.
3. En el cuadro de búsqueda Buscar servicios y marketplace, busque y
seleccione Machine Learning. Se abrirá el panel Machine Learning.
4. Seleccione Crear. Se abrirá el panel Machine Learning.
5. En la pestaña Aspectos básicos, escriba los valores siguientes para cada
opción.
Configuración Valor
Detalles del
proyecto
Suscripción Seleccione la suscripción de Azure que quiera usar para este

ejercicio.
Resource group Seleccione el vínculo Crear nuevo, asigne un nombre único

al nuevo grupo de recursos y seleccione Aceptar.
Detalles del área

de trabajo
Nombre del área Escriba un nombre único para la aplicación. Por ejemplo,
de trabajo podría usar <su_nombre>;machinelearn.
Region En la lista desplegable, seleccione cualquier ubicación

disponible.
6.
Acepte el resto de los valores predeterminados y seleccione Revisar y
crear.
7. Una vez pasada la validación, seleccione Crear.
Espere a que se cree el recurso de área de trabajo, ya que puede tardar
unos minutos.
8. Una vez finalizada la implementación, seleccione Ir al recurso. Se abrirá
el panel Machine Learning.
9. Seleccione Iniciar Studio, o bien vaya a https://ml.azure.com e inicie
sesión con la cuenta Microsoft. Se abrirá la página Microsoft Azure
Machine Learning Studio.
10. En Estudio de Azure Machine Learning, alterne el icono ☰ de la parte
superior izquierda para desplegar o contraer su panel de menús. Puede
usar estas opciones para administrar los recursos en el área de trabajo.
Creación de una instancia de proceso
Para ejecutar el cuaderno que usará en este ejercicio, necesitará una instancia de
proceso en el área de trabajo de Azure Machine Learning.
1. En el panel de menús de la izquierda, en Administrar, seleccione

Proceso. Aparece el panel Proceso.
2. En la pestaña Instancias de proceso, si ya tiene una instancia de
proceso, iníciela; de lo contrario, seleccione Nuevo para crear una.
Aparecerá el panel Crear instancia de proceso.
3. Escriba los valores siguientes para cada opción:
● Nombre del proceso: escriba un nombre único.
● Tipo de máquina virtual: CPU
● Tamaño de la máquina virtual:: seleccione entre las
opciones recomendadas: Standard_DS11_v2
4. Seleccione Crear. Se vuelve a abrir el panel Proceso, en el que se
muestra la instancia de proceso.
5. Espere a que se inicie la instancia de proceso, lo que puede tardar un
par de minutos. En la columna Estado la instancia de proceso cambiará
a En ejecución.
Clonación del repositorio ml-basics
Los archivos que se usan en este módulo (y en otros módulos relacionados) están
publicados en el repositorio MicrosoftDocs/ml-basics de GitHub. Si aún no lo ha
hecho, siga estos pasos para clonar el repositorio en su área de trabajo de Azure
Machine Learning:
1. Seleccione Áreas de trabajo en el menú izquierdo de Estudio de Azure

Machine Learning y, después, seleccione el área de trabajo que creó en
la lista.
2. En la columna Autor de la izquierda, seleccione el vínculo Cuadernos
para abrir Cuadernos de Jupyter Notebook. Aparece el panel
Cuadernos.
3. Seleccione el botón Terminal situado a la derecha. Aparece un shell de
terminal.
4. Ejecute los comandos siguientes para cambiar el directorio actual al
directorio Users y clone el repositorio ml-basics, que contiene el
cuaderno y los archivos que usará en este ejercicio.
5. Bash
6. Copiar
cd Users
git clone https://github.com/microsoftdocs/ml-basics
7.
8. Una vez completado el comando y finalizada la restauración de los
archivos, cierre la pestaña de terminal y vaya a la página principal del
explorador de archivos de Jupyter Notebook.
9. Abra la carpeta Users, que debe contener una carpeta ml-basics con los
archivos que usará en este módulo.
Nota
Le recomendamos usar Jupyter en un área de trabajo de Azure Machine Learning
para este ejercicio. Esta configuración garantiza la instalación de la versión correcta
de Python y de los distintos paquetes que necesitará. Además, después de crear el
área de trabajo una vez, puede volver a usarla en otros módulos. Si prefiere
completar el ejercicio en un entorno de Python en su propio equipo, puede hacerlo.
Encontrará información detallada de la configuración de un entorno de desarrollo
local que usa Visual Studio Code en la página de GitHub sobre la ejecución de
laboratorios en su propio equipo. Tenga en cuenta que, si decide hacer esto, es
posible que las instrucciones del ejercicio no coincidan con la interfaz de usuario de
sus cuadernos.
Entrenamiento de un modelo de red neuronal profunda

Después de crear un entorno de Jupyter y de clonar el repositorio ml-basics, ya está
listo para explorar el aprendizaje profundo.
1. En Jupyter, en la carpeta ml-basics, abra o el cuaderno Deep Neural

Networks (PyTorch).ipynb o Deep Neural Networks (Tensorflow).ipynb,
según las preferencias del marco, y siga las instrucciones que contiene.
2. Cuando haya terminado, cierre y detenga todos los cuadernos.
Cuando haya terminado de trabajar en el cuaderno, vuelva a este módulo y vaya a

la unidad siguiente para seguir aprendiendo.
Redes neuronal convolucionales

Completado
100 XP
10 minutos
Si bien puede usar modelos de aprendizaje profundo para cualquier tipo de

aprendizaje automático, resultan especialmente útiles para trabajar con datos que
constan de grandes matrices de valores numéricos, como imágenes. Los modelos
de aprendizaje automático que funcionan con imágenes son la base de una
inteligencia artificial de área denominada Computer Vision. Además, las técnicas de
aprendizaje profundo han impulsado avances asombrosos en esta área durante los
últimos años.
El motivo del éxito del aprendizaje profundo en esta área es un tipo de modelo
denominado red neuronal convolucional, CNN. Por lo general, una CNN funciona
extrayendo características de las imágenes y enviándolas a una red neuronal
completamente conectada para generar una predicción. Las capas de extracción de
características de la red reducen la cantidad de características en la matriz
potencialmente enorme de valores de píxeles individuales a un conjunto más
pequeño de características que ayuda a la predicción de etiquetas.
Capas de una CNN

Las CNN constan de varias capas, cada una de las cuales realiza una tarea
específica en la extracción de características o la predicción de etiquetas.
Capas convolucionales
Uno de los tipos principales de capas es la capa convolucional, que extrae

características importantes de las imágenes. Una capa convolucional funciona
aplicando un filtro a las imágenes. El filtro está definido por un kernel que consta de
una matriz de valores de ponderación.
Por ejemplo, un filtro de 3x3 podría definirse de la manera siguiente:
Copiar
1 -1 1
-1 0 -1
1 -1 1
Una imagen también es simplemente una matriz de valores de píxeles. Para aplicar
el filtro, debe "superponerlo" en una imagen y calcular una suma ponderada de los
valores de píxeles de la imagen correspondientes bajo el kernel del filtro. Luego, el
resultado se asigna a la celda central de una sección correspondiente de 3×3 en
una matriz de valores nueva que tiene el mismo tamaño que la imagen. Por ejemplo,
supongamos que una imagen de 6x6 tiene los valores de píxeles siguientes:
Copiar
255 255 255 255 255 255

255 255 100 255 255 255
255 100 100 100 255 255
100 100 100 100 100 255
255 255 255 255 255 255
255 255 255 255 255 255
Aplicar el filtro a la sección de 3x3 superior izquierda de la imagen funcionaría de la

manera siguiente:
Copiar
255 255 255 1 -1 1 (255 x 1)+(255 x -1)+(255 x 1) +
255 255 100 x -1 0 -1 = (255 x -1)+(255 x 0)+(100 x -1) +

= 155
255 100 100 1 -1 1 (255 x1 )+(100 x -1)+(100 x 1)
El resultado se asigna al valor de píxel correspondiente en la matriz nueva como se

indica a continuación:
Copiar
? ? ? ? ? ?
? 155 ? ? ? ?
? ? ? ? ? ?
? ? ? ? ? ?
? ? ? ? ? ?
? ? ? ? ? ?
Ahora el filtro se mueve (se convoluciona). Por lo general, se utiliza un tamaño de

paso de 1 (es decir, se desplaza un píxel a la derecha) y se calcula el valor para el
píxel siguiente.
Copiar
255 255 255 1 -1 1 (255 x 1)+(255 x -1)+(255 x 1) +
255 100 255 x -1 0 -1 = (255 x -1)+(100 x 0)+(255 x -1) +

= -155
100 100 100 1 -1 1 (100 x1 )+(100 x -1)+(100 x 1)
Ahora podemos rellenar este valor de la matriz nueva.
Copiar
? ? ? ? ? ?
? 155 -155 ? ? ?
? ? ? ? ? ?
? ? ? ? ? ?
? ? ? ? ? ?
? ? ? ? ? ?
El proceso se repite hasta que se aplica el filtro en todas las secciones de 3x3 de la
imagen a fin de generar una matriz de valores nueva como la siguiente:
Copiar
? ? ? ? ? ?
? 155 -155 155 -155 ?
? -155 310 -155 155 ?
? 310 155 310 0 ?
? -155 -155 -155 0 ?
? ? ? ? ? ?
Debido al tamaño del kernel de filtro, no se pueden calcular los valores de los
píxeles del borde; por tanto, solo se suele aplicar un valor de relleno (a menudo, 0):
Copiar
0 0 0 0 0 0
0 155 -155 155 -155 0
0 -155 310 -155 155 0
0 310 155 310 0 0
0 -155 -155 -155 0 0
0 0 0 0 0 0
La salida de la convolución generalmente se pasa a una función de activación. A

menudo, esta es una función de Unidad lineal rectificada (ReLU) que garantiza que
los valores negativos se establezcan en 0:
Copiar
0 0 0 0 0 0
0 155 0 155 0 0
0 0 310 0 155 0
0 310 155 310 0 0
0 0 0 0 0 0
0 0 0 0 0 0
La matriz resultante es una asignación de características de valores de

características que se puede usar para entrenar un modelo de Machine Learning.
Nota: Los valores en la asignación de características pueden ser mayores que el

valor máximo de un píxel (255). Por lo tanto, si desea visualizar la asignación de
características, debería normalizar los valores de característica entre 0 y 255.
En la animación siguiente, se muestra el proceso de convolución.
1. Se pasa una imagen a la capa convolucional. En este caso, la imagen

es una forma geométrica simple.
2. La imagen consta de una matriz de píxeles con valores entre 0 y 255
(para imágenes de color, habitualmente es una matriz tridimensional
con valores para los canales rojo, verde y azul).
3. En general, un kernel de filtro se inicializa con ponderaciones aleatorias.
En este ejemplo, se eligieron valores que resaltan los posibles efectos
de un filtro en los valores de los píxeles. Sin embargo, en una CNN real,
las ponderaciones iniciales normalmente se generarían en función de
una distribución gaussiana aleatoria. Este filtro se usará para extraer
una asignación de características de los datos de la imagen.
4. El filtro se convoluciona en la imagen, calculando los valores de las
características al aplicar una suma de las ponderaciones multiplicada
por sus valores correspondientes de píxeles en cada posición. Se aplica
una función de activación ReLU para asegurarse de que los valores
negativos estén establecidos en 0.
5. Después de la convolución, la asignación de características contiene los
valores extraídos de las características, los que a menudo enfatizan los
atributos visuales clave de la imagen. En este caso, la asignación de
características resalta los bordes y las esquinas del triángulo de la
imagen.
Por lo general, una capa convolucional aplica varios kernels de filtro. Cada filtro
genera una asignación de características diferente y todas estas asignaciones se
pasan a la capa siguiente de la red.
Agrupación de capas
Después de extraer los valores de las características de las imágenes, se usan

capas de agrupación (o submuestreo) para disminuir la cantidad de valores de
características a la vez que se conservan las características diferenciales clave que
se han extraído.
Uno de los tipos de agrupación más comunes es la agrupación máxima en la que se

aplica un filtro a la imagen y solo se conserva el valor de píxel máximo dentro del
área de filtro. Por ejemplo, si se aplica un kernel de agrupación de 2x2 a sección
siguiente de una imagen, se generaría el resultado 155.
Copiar
0 0
0 155
Tenga en cuenta que el efecto del filtro de agrupación de 2x2 es reducir el número
de valores de 4 a 1.
Al igual que con las capas convolucionales, las capas de agrupación funcionan
aplicando el filtro a toda la asignación de características. En la animación siguiente
se muestra un ejemplo de la agrupación máxima de una asignación de imágenes.
1. La asignación de características extraída por un filtro en una capa
convolucional contiene una matriz de valores de características.
2. Se usa un kernel de agrupación para reducir la cantidad de valores de
características. En este caso, el tamaño del kernel es 2x2, por lo que
generará una matriz con un cuarto de la cantidad de valores de
características.
3. El kernel de agrupación se convoluciona en la asignación de
características, conservando solo el valor de píxel más alto en cada
posición.
Capas de anulación
Uno de los mayores desafíos en una CNN es evitar el sobreajuste. Aquí, el modelo
resultante funciona bien con los datos de entrenamiento, pero no se puede
generalizar bien a los datos nuevos con los que no se entrenó. Una técnica que
puede usar para mitigar el sobreajuste es incluir capas en las que el proceso de
entrenamiento elimina (o "anula") asignaciones de características de forma
aleatoria. Esto puede parecer un poco contradictorio, pero es una manera eficaz de
asegurarse de que el modelo no aprenda a depender demasiado de las imágenes
de entrenamiento.
Otras técnicas que puede usar para mitigar el sobreajuste incluyen el volteo
aleatorio, la creación de reflejo o la distorsión de las imágenes de entrenamiento a
fin de generar datos que varíen entre las épocas de entrenamiento.
Capas de acoplamiento
Después de usar capas convolucionales y de agrupación para extraer las

características destacadas de las imágenes, las asignaciones de características
resultantes son matrices multidimensionales de valores de píxeles. Una capa de
acoplamiento se usa para acoplar las asignaciones de características a un vector de
valores que se puede usar como entrada para una capa totalmente conectada.
Capas totalmente conectadas
Por lo general, una CNN termina con una red completamente conectada en la que
los valores de las características se transmiten a una capa de entrada, a través de
una o más capas ocultas, y generan valores previstos en una capa de salida.
Una arquitectura básica de la CNN podría tener un aspecto similar al siguiente:
1. Las imágenes se introducen en una capa convolucional. En este caso,

hay dos filtros, por lo que cada imagen genera dos asignaciones de
características.
2. Las asignaciones de características se pasan a una capa de
agrupación, en la que un kernel de agrupación de 2x2 disminuye el
tamaño de las asignaciones de características.
3. Una capa de anulación anula algunas de las asignaciones de
características de manera aleatoria para ayudar a evitar el sobreajuste.
4. Una capa de acoplamiento toma las matrices de asignaciones de
características restantes y las acopla a un vector.
5. Los elementos del vector se introducen en una red totalmente
conectada, lo que genera las predicciones. En este caso, la red es un
modelo de clasificación que predice las probabilidades de tres clases de
imágenes posibles (triángulo, cuadrado y círculo).
Entrenamiento de un modelo de CNN

Al igual que lo que ocurre con cualquier red neuronal profunda, se entrena una CNN
mediante la transferencia de lotes de datos de entrenamiento a través de varias
épocas, ajustando los valores de ponderaciones y sesgos en función de la pérdida
calculada para cada época. En el caso de una CNN, la retropropagación de
ponderaciones ajustadas incluye ponderaciones de kernel de filtro que se usan en
capas convolucionales, así como las ponderaciones que se utilizan en capas
totalmente conectadas.
Ejercicio: Entrenamiento de una red

neuronal convolucional
Completado
100 XP
45 minutos
PyTorch y TensorFlow ofrecen compatibilidad completa para crear redes neuronal

convolucionales como modelos de clasificación para las imágenes.
En este ejercicio, usará su marco preferido para crear un clasificador de imágenes

simple basado en CNN para imágenes de formas geométricas simples. Se pueden
aplicar los mismos principios a las imágenes de cualquier tipo.
Para completar el ejercicio, siga estos pasos:
1. En Jupyter, en la carpeta ml-basics, abra el cuaderno Convolutional

Neural Networks (PyTorch).ipynb o Convolutional Neural Networks
(Tensorflow).ipynb, según las preferencias del marco, y siga las
instrucciones que contiene.
Cuando haya terminado de trabajar en el cuaderno, vuelva a este módulo y vaya a
la unidad siguiente para seguir aprendiendo.
Transferencia de aprendizaje
Completado
100 XP
5 minutos
En la vida, a menudo resulta más fácil aprender una aptitud nueva si ya tiene
experiencia en una aptitud similar transmisible. Por ejemplo, probablemente sea
más fácil enseñar a alguien cómo conducir un autobús si ya sabe conducir un
automóvil. El conductor puede usar los conocimientos que ya tiene sobre cómo
conducir un automóvil y aplicarlos para aprender a conducir un autobús.
Se puede aplicar el mismo principio para entrenar modelos de aprendizaje profundo

mediante una técnica denominada aprendizaje por transferencia.
Funcionamiento del aprendizaje por transferencia

Por lo general, una red neuronal convolucional (CNN) para la clasificación de
imágenes consta de varias capas que extraen características y, a continuación, usan
una capa totalmente conectada final para clasificar las imágenes en función de
estas características.
Conceptualmente, esta red neuronal consta de dos conjuntos de capas distintos:
1. Un conjunto de capas del modelo base que realizan la extracción de

características.
2. Una capa totalmente conectada que toma las características extraídas y
las usa para la predicción de clases.
Las capas de extracción de características aplican agrupaciones y filtros

convolucionales para enfatizar los bordes, las esquinas y otros patrones de las
imágenes que se pueden usar para diferenciarlas y, en teoría, deberían funcionar
para cualquier conjunto de imágenes con las mismas dimensiones que la capa de
entrada de la red. La capa de predicción asigna las características a un conjunto de
resultados que representan probabilidades para cada etiqueta de clase que quiera
usar para clasificar las imágenes.
Al dividir la red en estos tipos de capas, es posible tomar las capas de extracción de
características de un modelo ya entrenado y adjuntar una o más capas que usen las
características extraídas para predecir las etiquetas de clase correctas para sus
imágenes. Este enfoque le permite mantener las ponderaciones entrenadas
previamente para las capas de extracción de características, lo que significa que
solo necesita entrenar las capas de predicción que agrega.
Hay muchas arquitecturas establecidas para redes neuronales convolucionales para

la clasificación de imágenes que puede utilizar como modelo base para el
aprendizaje por transferencia, de modo que pueda basarse en el trabajo de otros y
desarrollar fácilmente un modelo eficaz de clasificación de imágenes.
Ejercicio: Uso del aprendizaje por
transferencia
Completado
100 XP
30 minutos
PyTorch y TensorFlow admiten una biblioteca de modelos existentes que se pueden

usar como base para el aprendizaje por transferencia.
En este ejercicio, usará su marco preferido para entrenar un modelo de red neuronal
convolucional mediante el aprendizaje por transferencia.
Para completar el ejercicio, siga estos pasos:
1. En Jupyter, en la carpeta ml-basics, abra o el cuaderno Transfer

Learning (PyTorch).ipynb o Transfer Learning (Tensorflow).ipynb, según
las preferencias del marco, y siga las instrucciones que contiene.
Limpieza
Si ha usado una instancia de proceso en un área de trabajo de Azure Machine
Learning para completar los ejercicios, siga estos pasos para la limpieza.
1. Cierre todos los cuadernos de Jupyter y la página principal de Jupyter.

2. En Azure Machine Learning Studio, en la página Proceso, seleccione la
instancia de proceso y, en la barra de menús superior, seleccione
Detener.
Si no tiene previsto completar otros módulos que requieran el área de trabajo de

Azure Machine Learning, puede eliminar el grupo de recursos que ha creado para el
área de trabajo en su suscripción a Azure.
Resumen
En este módulo aprendió los principios fundamentales del aprendizaje profundo y
cómo crear modelos de red neuronal profunda con PyTorch o Tensorflow. También
exploró el uso de redes neuronales convolucionales para crear modelos de
clasificación de imágenes.
Las técnicas de aprendizaje profundo están a la vanguardia del aprendizaje

automático y la inteligencia artificial, y se usan para implementar soluciones
empresariales. Si este módulo lo inspiró para compilar soluciones de aprendizaje
automático, debería considerar la posibilidad de descubrir cómo Azure Machine
Learning puede ayudarlo a entrenar, implementar y administrar modelos a gran
escala. Aprenda a usar Azure Machine Learning para administrar las operaciones de
aprendizaje automático en la ruta de aprendizaje Compilación de soluciones de IA
con Azure Machine Learning Service.
Uso de aprendizaje automático
automatizado en Azure Machine
Learning
Entrenar un modelo de Machine Learning es un proceso iterativo que requiere
tiempo y recursos de proceso. El ML automatizado puede ayudar a que sea más
sencillo.
Más información sobre cómo usar la interfaz de usuario de aprendizaje automático
automatizado en Azure Machine Learning
Introducción
El aprendizaje automático es la base de la mayoría de las soluciones de inteligencia
artificial. La creación de una solución inteligente empieza a veces con el uso del
aprendizaje automático para entrenar un modelo predictivo con datos históricos que
se hayan recopilado.
Azure Machine Learning es un servicio en la nube que se puede usar para entrenar
y administrar modelos de Machine Learning.
En este módulo, aprenderá a:
● Identifique el proceso de aprendizaje automático.

● Comprenda las funcionalidades de Azure Machine Learning.
● Use el aprendizaje automático automatizado de Estudio de Azure
Machine Learning para entrenar un modelo predictivo e implementarlo.
Para completar este módulo, necesitará una suscripción de Microsoft Azure. Si aún
no tiene una, puede solicitar una prueba gratuita en https://azure.microsoft.com.
¿Qué es el aprendizaje automático?

El aprendizaje automático es una técnica que utiliza matemáticas y estadísticas para
crear un modelo que puede predecir valores desconocidos.
Por ejemplo, supongamos que Adventure Works Cycles es un negocio que alquila
bicicletas en una ciudad. El negocio podría utilizar datos históricos para entrenar un
modelo que prediga la demanda diaria de alquileres con el fin de asegurarse de que
haya suficientes bicicletas y personal disponibles.
Para ello, Adventure Works podría crear un modelo de Machine Learning que tome
información sobre un día específico (el día de la semana, las condiciones climáticas
previstas, etc.) como entrada y prediga el número previsto de alquileres como
salida.
De forma matemática, puede considerar el aprendizaje automático como una forma

de definir una función (por ejemplo, f) que opera con una o más características de
algo (que se denominará x) para calcular una etiqueta prevista (y), como esta:
f(x) = y
En el ejemplo del alquiler de bicicletas, los detalles sobre un día determinado (día de
la semana, clima, etc.) son las características (x), el número de alquileres para ese
día es la etiqueta (y) y la función (f) que calcula el número de alquileres según la
información sobre el día está encapsulada en el modelo de Machine Learning.
La operación específica que realiza la función f en x para calcular y depende de una

serie de factores, incluidos el tipo de modelo que se intenta crear y el algoritmo
específico usado para entrenarlo. Además, en la mayoría de casos, los datos
usados para entrenar el modelo de Machine Learning requieren algún
preprocesamiento antes de que se pueda realizar el entrenamiento del modelo.
Tipos de aprendizaje automático

Hay dos enfoques generales para el aprendizaje automático: supervisado y no
supervisado. En ambos enfoques, hay que entrenar un modelo que realice
predicciones.
El enfoque de aprendizaje automático supervisado requiere comenzar con un

conjunto de datos con valores de etiqueta conocidos. Entre los tipos de tareas de
aprendizaje automático supervisadas están la regresión y la clasificación.
● Regresión: se usa para predecir un valor continuo, como un precio, un

total de ventas o alguna otra medida.
● Clasificación: se usa para determinar una etiqueta de clase: un ejemplo
de una etiqueta de clase binaria es si un paciente tiene diabetes o no;
un ejemplo de etiquetas de varias clases es clasificar el texto como
positivo, negativo o neutro.
El enfoque de aprendizaje automático no supervisado comienza con un conjunto de

datos sin valores de etiqueta conocidos. Un tipo de tarea de aprendizaje automático
no supervisado es la agrupación en clústeres.
● Agrupación en clústeres: se usa para determinar las etiquetas

agrupando información similar en grupos de etiquetas, como agrupar
medidas de aves en especies.
En el vídeo siguiente se describen los distintos tipos de modelos de Machine

Learning que se pueden crear y el proceso que se suele seguir para entrenarlos y
usarlos.
Siguiente unidad: ¿Qué es Azure Machine Learning

Studio?
¿Qué es Azure Machine Learning
Studio?
Completado
100 XP
5 minutos

servicio predictivo.
Y lo más importante, Azure Machine Learning ayuda a los científicos de datos a

aumentar su eficiencia al automatizar muchas tareas que requieren bastante tiempo
y que están asociadas a los modelos de entrenamiento. Además, les permite usar
recursos de procesos basados en la nube que se escalan de manera eficaz para
manejar grandes volúmenes de datos, incurriendo en costos solo cuando realmente
se usan.



asignar el área de trabajo que creó en el Azure Portal a Azure Machine Learning
Studio.
modelos de Machine Learning, para los que se necesita proceso sobre el que
ejecutar el proceso de entrenamiento.
Los destinos de proceso son recursos basados en la nube en los que se pueden
ejecutar procesos de entrenamiento de modelos y exploración de datos.

proceso:

Siguiente unidad: Descripción del aprendizaje
automático automatizado de Azure
Descripción del aprendizaje automático
automatizado de Azure
Completado
100 XP
3 minutos
Azure Machine Learning incluye una capacidad de aprendizaje automático

automatizado que prueba automáticamente varias técnicas de procesamiento previo
y algoritmos de entrenamiento de modelos en paralelo. Estas capacidades
automatizadas usan la potencia del proceso en la nube para encontrar el modelo de
Machine Learning supervisado con el mejor rendimiento para los datos.
El aprendizaje automático automatizado le permite entrenar modelos sin un amplio

conocimiento de programación ni de ciencia de datos. En el caso de las personas
con conocimientos de programación y de ciencia de datos, proporciona una manera
de ahorrar tiempo y recursos mediante la automatización de la selección de
algoritmos y la optimización de los hiperparámetros.
Puede crear un trabajo de aprendizaje automático automatizado en Azure Machine

Learning Studio.
En Azure Machine Learning, las operaciones que se ejecutan se denominan

trabajos. Puede configurar varias opciones para el trabajo antes de iniciar una
ejecución de aprendizaje automático automatizado. La configuración de ejecución
proporciona la información necesaria para especificar el script de entrenamiento, el
destino de proceso y el entorno de Azure ML en la configuración de ejecución y
ejecutar un trabajo de entrenamiento.
Siguiente unidad: Comprender el proceso de

AutoML
Ejercicio: Exploración del aprendizaje
automático automatizado en Azure ML
Completado
100 XP
50 minutos
En este ejercicio, usará un conjunto de datos de información histórica de alquiler de

bicicletas para entrenar un modelo que prediga el número de alquileres de bicicletas
que se espera un día determinado, en función de las características estacionales y
meteorológicas.
Nota


https://microsoftlearning.github.io/AI-900-AIFundamentals/instructions/02-module-02.
html
Creación de un modelo de clasificación
Learning
La clasificación es una técnica de aprendizaje automático supervisado que se usa
para predecir categorías o clases. Obtenga información sobre cómo crear modelos
de clasificación con el diseñador de Azure Machine Learning.
ntroducción
Completado
100 XP
2 minutos
La clasificación es un ejemplo de técnica de aprendizaje automático supervisado en

la que se entrena un modelo mediante datos que incluyen tanto las características
como los valores conocidos para la etiqueta, de modo que el modelo aprenda a
ajustar las combinaciones de características para la etiqueta. Después de completar
el entrenamiento, puede usar el modelo entrenado para predecir etiquetas de
nuevos elementos para los que la etiqueta se desconoce.
Puede usar el diseñador de Microsoft Azure Machine Learning para crear modelos
de clasificación mediante una interfaz visual de arrastrar y colocar, sin necesidad de
escribir código.
En este módulo aprenderá a:
● Identificación de escenarios de aprendizaje automático de clasificación.

● Usar el diseñador de Azure Machine Learning para entrenar un modelo
de clasificación.
● Usar un modelo de clasificación para la inferencia.
● Implemente y pruebe un modelo de clasificación.
Para completar este módulo, necesitará una suscripción de Microsoft Azure. Si aún
aprendizaje automático de clasificación
Completado
100 XP
3 minutos
La clasificación es una forma de aprendizaje automático que se usa para predecir a

qué categoría o clase pertenece un objeto. Esta técnica de aprendizaje automático
se puede aplicar a escenarios binarios y de varias clases. Por ejemplo, una clínica
podría usar las características de un paciente (como edad, peso, presión arterial,
entre otras) para predecir si el paciente tiene riesgo de padecer diabetes. En este
caso, las características del paciente son las funciones y la etiqueta es una
clasificación de 0 o 1 que representa si es diabético o no.
Al igual que la regresión, la clasificación es un ejemplo de técnica de aprendizaje

automático supervisado en la que se entrena un modelo mediante datos que
incluyen tanto las características como los valores conocidos para la etiqueta, de
modo que el modelo aprenda a ajustar las combinaciones de características para la
etiqueta. Después de completar el entrenamiento, puede usar el modelo entrenado
para predecir etiquetas de nuevos elementos para los que la etiqueta se desconoce.
Escenarios para los modelos de aprendizaje

automático de clasificación
Los modelos de aprendizaje automático de clasificación se usan en muchos
sectores. Algunos escenarios son:
● Uso de datos clínicos para predecir si un paciente se enfermará o no.

● El uso de datos históricos para predecir si la opinión de texto es
positiva, negativa o neutra.
● Uso de características de pequeñas empresas para predecir si una
nueva empresa tendrá éxito.
Completado
100 XP
4 minutos

servicio predictivo. Los modelos de aprendizaje automático de clasificación se
pueden crear mediante Azure Machine Learning.
se usan.



asignar el área de trabajo que creó en Azure Portal a Estudio de Azure Machine
Learning.

proceso:

●
¿Qué es el diseñador de Azure Machine
Learning?
Completado
100 XP
6 minutos
En Azure Machine Learning Studio, hay varias maneras de crear modelos de

aprendizaje automático de clasificación. Una de ellas consiste en usar una interfaz
visual denominada diseñador, que puede usar para entrenar, probar e implementar
modelos de aprendizaje automático. La interfaz de arrastrar y colocar usa entradas y
salidas claramente definidas que se pueden compartir, reutilizar y controlar la
versión.
Cada proyecto de diseñador, conocido como canalización, tiene un panel izquierdo

para la navegación y un lienzo en el lado derecho. Para usar el diseñador,
identifique los bloques de creación o los componentes necesarios para el modelo,
colóquelos y conéctelos en el lienzo y ejecute un trabajo de aprendizaje automático.
Pipelines
Las canalizaciones permiten organizar, administrar y reutilizar flujos de trabajo de
aprendizaje automático complejos entre proyectos y usuarios. Una canalización se
inicia con el conjunto de datos desde el que quiere entrenar el modelo. Cada vez
que se ejecuta una canalización, la configuración de esta y sus resultados se
almacenan en el área de trabajo como un trabajo de canalización.
Componentes
Un componente de Azure Machine Learning encapsula un paso en una canalización
de aprendizaje automático. Puede considerar un componente como una función de
programación y como un bloque de creación para las canalizaciones de Azure
Machine Learning. En un proyecto de canalización, puede acceder a los
componentes y recursos de datos desde la pestaña Biblioteca de recursos del panel
izquierdo.
Conjuntos de datos
Puede crear recursos de datos en la página Datos a partir de archivos locales, un
almacén de datos, archivos web y Open Datasets. Estos recursos de datos
aparecerán junto con los conjuntos de datos de ejemplo estándar en la biblioteca de
recursos del diseñador.
Trabajos de Azure Machine Learning

Un trabajo de Azure Machine Learning (ML) ejecuta una tarea en un destino de
proceso especificado. Los trabajos permiten el seguimiento sistemático de los flujos
de trabajo y la experimentación de aprendizaje automático. Una vez creado un
trabajo, Azure ML mantiene un registro de ejecución del mismo. Todos los registros
de ejecución de los trabajos se pueden ver en Azure ML Studio.
En el proyecto del diseñador, puede acceder al estado de un trabajo de canalización

mediante la pestaña Trabajos enviados del panel izquierdo.
Puede encontrar todos los trabajos que ha ejecutado en un área de trabajo en la
página Trabajos.
Descripción de los pasos para la

clasificación
Completado
100 XP
8 minutos
Puede pensar en los pasos para entrenar y evaluar un modelo de Machine Learning
de clasificación como los siguientes:
1. Preparar los datos: identifique las características y la etiqueta de un

conjunto de datos. Procese previamente o limpie y transforme los datos
según sea necesario.
2. Entrenar el modelo: divida los datos en dos grupos, un conjunto de
entrenamiento y uno de validación. Entrene un modelo de Machine
Learning con el conjunto de datos de entrenamiento. Pruebe el modelo
de Machine Learning en cuanto al rendimiento con el conjunto de datos
de validación.
3. Evaluar el rendimiento: compare la proximidad de las predicciones del
modelo con las etiquetas conocidas.
4. Implementar un servicio predictivo: después de entrenar un modelo de
Machine Learning, debe convertir la canalización de entrenamiento en
una canalización de inferencia en tiempo real. A continuación, puede
implementar el modelo como una aplicación en un servidor o un
dispositivo para que otros usuarios puedan usarlo.
Vamos a seguir estos cuatro pasos a medida que aparecen en el diseñador de

Azure.
Preparación de los datos

El diseñador de Azure Machine Learning tiene varios componentes creados
previamente que se pueden usar para preparar los datos para el entrenamiento.
Estos componentes permiten limpiar datos, normalizar características, combinar
tablas, etc.
Entrenamiento de un modelo
Para entrenar un modelo de clasificación, necesita un conjunto de datos que incluya
características históricas, características de la entidad para la que quiere realizar
una predicción y valores de etiqueta conocidos. La etiqueta es el indicador de clase
que quiere para entrenar un modelo para predecir.
Es habitual entrenar el modelo con un subconjunto de los datos, a la vez que se
retienen algunos con los que probar el modelo entrenado. Esto le permite comparar
las etiquetas que predice el modelo con las etiquetas conocidas reales del conjunto
de datos original.
Usará el componente Puntuar modelo del diseñador para generar el valor de

etiqueta de clase predicho. Una vez que conecte todos los componentes, querrá
ejecutar un experimento, que usará el recurso de datos del lienzo para entrenar y
puntuar un modelo.
Evaluación del rendimiento

Después de entrenar un modelo, es importante evaluar su rendimiento. Hay muchas
métricas de rendimiento y metodologías para evaluar el rendimiento de las
predicciones de un modelo. Para revisar las métricas de evaluación en la página del
trabajo completado, haga clic con el botón derecho en el componente Evaluar
modelo.
Matriz de confusión
La matriz de confusión es una herramienta que se usa para evaluar la calidad de las
predicciones de un modelo de clasificación. Compara las etiquetas predichas con
las etiquetas reales.
En un modelo de clasificación binaria en el que se predice uno de dos valores

posibles, la matriz de confusión es una cuadrícula de 2x2 en la que se muestran los
recuentos de los valores previstos y reales de las clases 1 y 0. Clasifica los
resultados del modelo en cuatro tipos de resultados. Con nuestro ejemplo de
diabetes, estos resultados pueden ser similares a los siguientes:
● Verdadero positivo: el modelo predice que el paciente tiene diabetes y el

paciente realmente la tiene.
● Falso positivo: el modelo predice que el paciente tiene diabetes, pero el
paciente realmente no la tiene.
● Falso negativo: el modelo predice que el paciente no tiene diabetes,
pero el paciente realmente la tiene.
● Verdadero negativo: el modelo predice que el paciente no tiene diabetes
y el paciente realmente no la tiene.
Supongamos que tiene datos para 100 pacientes. Crea un modelo que predice que
un paciente no tiene diabetes el 15 % del tiempo, por lo que predice que 15
personas tienen diabetes y predice que 85 personas no tienen diabetes. En realidad,
supongamos que 25 personas realmente la tienen y 75 personas realmente no la
tienen. Esta información se puede presentar en una matriz de confusión como la
siguiente:
En un modelo de clasificación de varias clases (donde hay más de dos clases
posibles), se usa el mismo enfoque para mostrar en formato de tabla cada
combinación posible de recuentos de valores reales y previstos; por tanto, un
modelo con tres clases posibles daría como resultado una matriz de 3x3 con una
línea diagonal de celdas en las que las etiquetas previstas y reales coincidan.
Entre las métricas que se pueden derivar de la matriz de confusión, se encuentran

las siguientes:
● Exactitud: el número de predicciones correctas (verdaderos positivos y

verdaderos negativos) dividido por el número total de predicciones.
● Precisión: el número de casos clasificados como positivos que lo son
realmente (el número de verdaderos positivos dividido por el de
verdaderos positivos más los falsos positivos).
● Coincidencia: la fracción de casos positivos identificados correctamente
(el número de verdaderos positivos dividido por el de verdaderos
positivos más los falsos negativos).
● Puntuación F1: métrica general que básicamente combina la precisión y
la coincidencia.
De estas métricas, la exactitud puede ser la más intuitiva. Sin embargo, debe tener
cuidado al usar la precisión como medida del funcionamiento correcto de un modelo.
Con el modelo que predice que el 15 % de los pacientes tienen diabetes cuando en
realidad el 25 % de los pacientes la tienen podemos calcular las métricas siguientes:
La exactitud del modelo es la siguiente: (10+70)/ 100 = 80 %.
La precisión del modelo es la siguiente: 10/(10+5) = 67 %.
La coincidencia del modelo es 10/(10+15) = 40 %
Selección de un umbral
Un modelo de clasificación predice la probabilidad de cada clase posible. En otras

palabras, el modelo calcula una probabilidad para cada etiqueta predicha. En el
caso de un modelo de clasificación binaria, la probabilidad de una predicción es un
valor comprendido entre 0 y 1. De manera predeterminada, una probabilidad de
predicción igual o superior a 0,5 da como resultado una predicción de clase de 1,
mientras que una predicción por debajo de este umbral significa que hay una mayor
probabilidad de una predicción negativa (recuerde que las probabilidades de todas
las clases suman 1), por lo que la clase pronosticada sería 0.
El diseñador tiene un control deslizante para el umbral que resulta útil para revisar
cómo cambiaría el rendimiento del modelo en función del umbral establecido.
Curva ROC y métrica AUC
Otro término para la coincidencia es la tasa de verdaderos positivos, que tiene una
métrica correspondiente denominada tasa de falsos positivos, que mide el número
de casos negativos que se han identificado incorrectamente como positivos en
comparación con el número de casos negativos reales. Trazar estas métricas entre
sí para cada valor del umbral posible entre 0 y 1 da como resultado una curva,
conocida como curva ROC (ROC significa característica operativa del receptor, pero
la mayoría de los científicos de datos simplemente la llaman curva ROC). En un
modelo ideal, la curva ascendería por el lado izquierdo y discurriría por la parte
superior, para cubrir todo el área del gráfico. Cuanto mayor sea el área bajo la curva
de la métrica AUC (que puede ser cualquier valor comprendido entre 0 y 1), mejor
será el rendimiento del modelo. Puede revisar la curva ROC en Resultados de la
evaluación.
Implementación de un servicio predictivo

Tiene la capacidad de implementar un servicio que se puede usar en tiempo real.
Para automatizar el modelo en un servicio que realice predicciones continuas, debe
crear e implementar una canalización de inferencia.
Canalización de inferencia
Para implementar la canalización, antes debe convertir la canalización de

entrenamiento en una canalización de inferencia en tiempo real. Este proceso quita
los componentes de entrenamiento y agrega entradas y salidas de servicios web
para administrar las solicitudes.
La canalización de inferencia realiza las mismas transformaciones de datos que la

primera canalización para los datos nuevos. Después, usa el modelo entrenado para
deducir o predecir valores de etiqueta en función de sus características. Este
modelo formará la base de un servicio predictivo que puede publicar para que lo
usen las aplicaciones.
Para crear una canalización de inferencia, seleccione el menú situado encima de un

trabajo completado.
Implementación
Después de crear la canalización de inferencia, puede implementarla como un punto

de conexión. En la página Puntos de conexión, puede ver los detalles de
implementación, probar el servicio de canalización con datos de ejemplo y buscar
credenciales para conectar el servicio de canalización a una aplicación cliente.
El punto de conexión tardará un tiempo en implementarse. El estado de

implementación de la pestaña Detalles indicará Correcto cuando la implementación
se realice correctamente.
En la pestaña Prueba, puede probar el servicio implementado con datos de ejemplo
en formato JSON. La pestaña Prueba es una herramienta que puede usar para
comprobar rápidamente si el modelo se comporta según lo previsto. Normalmente,
resulta útil probar el servicio antes de conectarlo a una aplicación.
Puede encontrar las credenciales para el servicio en la pestaña Consumir. Estas
credenciales se usan para conectar el modelo de Machine Learning entrenado como
un servicio a una aplicación cliente.
Siguiente unidad: Ejercicio: Exploración de la
clasificación con el diseñador de Azure Machine
Learning
Ejercicio: Exploración de la clasificación

Learning
Completado
100 XP
60 minutos
En este ejercicio, creará un modelo de clasificación que predice si es probable que

un paciente contraiga diabetes en función de factores como su índica de masa
corporal, edad, niveles de glucosa y otros indicadores.
Nota


https://microsoftlearning.github.io/AI-900-AIFundamentals/instructions/02b-create-classificati
on-model.html
Creación de un modelo de agrupación
en clústeres con el diseñador de Azure
Machine Learning
La agrupación en clústeres es una técnica de aprendizaje automático no
supervisada que se utiliza para agrupar entidades similares en función de sus
características. Obtenga información sobre cómo crear modelos de agrupación en
clústeres con el diseñador de Azure Machine Learning.
Entrenamiento y publicación de un modelo de agrupación en clústeres con el diseñador de
Azure Machine Learning
Introducción
Puede usar el diseñador de Microsoft Azure Machine Learning para crear modelos
de agrupación en clústeres mediante una interfaz visual de arrastrar y colocar, sin
necesidad de escribir código.
● Identificación de escenarios comunes de aprendizaje automático de

agrupación en clústeres.
● Usar el diseñador de Azure Machine Learning para entrenar un modelo
de agrupación en clústeres.
● Usar un modelo de agrupación en clústeres para hacer inferencias.
● Implementar un modelo de agrupación en clústeres como servicio.
Para completar este módulo, necesitará una suscripción a Microsoft Azure. Si aún
aprendizaje automático de agrupación
en clústeres
Completado
100 XP
2 minutos
La agrupación en clústeres es una forma de aprendizaje automático que se utiliza
para agrupar elementos similares en grupos según sus características. Por ejemplo,
un investigador podría tomar medidas de pingüinos y agruparlas en función de las
similitudes en sus proporciones.
La agrupación es un ejemplo de Machine Learning no supervisado en el que se

entrena un modelo para separar elementos en grupos a partir únicamente de sus
características o funciones. No existe ningún valor de clúster conocido previamente
(o etiqueta) para entrenar el modelo.
Escenarios para los modelos de aprendizaje

automático de agrupación en clústeres
Los modelos de aprendizaje automático de agrupación en clústeres se usan en
muchos sectores. Algunos escenarios son:
● Agrupación de datos de atributos de cliente en segmentos para el

análisis de marketing.
● Agrupación de coordenadas geográficas en regiones de tráfico elevado
en una ciudad para una aplicación de uso compartido de vehículos.
● Agrupación de comentarios escritos en temas para priorizar los cambios
de servicio al cliente.
●

Completado
100 XP
3 minutos

servicio predictivo. Los modelos de aprendizaje automático de agrupación en
clústeres se pueden crear mediante Azure Machine Learning.
se usan.



asignar el área de trabajo que creó en el Azure Portal a Azure Machine Learning
Studio.

proceso:

Introducción al SDK de Azure Machine
Learning
Azure Machine Learning proporciona una plataforma basada en la nube para
entrenar, implementar y administrar modelos de aprendizaje automático.
En este módulo, aprenderá a lo siguiente:
● Aprovisionar un área de trabajo de Azure Machine Learning.

● Usar herramientas e interfaces para trabajar con Azure Machine
Learning.
● Ejecutar experimentos basados en código en un área de trabajo de
Azure Machine Learning.
Introducción
Azure Machine Learning es una plataforma para cargas de trabajo de aprendizaje
automático operativas en la nube.
Basado en la plataforma en la nube Microsoft Azure, Azure Machine Learning le

permite administrar lo siguiente:
● Proceso a petición escalable para cargas de trabajo de aprendizaje

automático.
● Almacenamiento de datos y conectividad para ingerir datos de una gran
variedad de orígenes.
● Orquestación de flujos de trabajo de aprendizaje automático para
automatizar los procesos de entrenamiento, implementación y
administración de modelos.
● Registro y administración de modelos, para poder realizar el
seguimiento de varias versiones de los modelos y los datos con los que
se han entrenado.
● Métricas y supervisión para el entrenamiento de experimentos,
conjuntos de valores y servicios publicados.
● Implementación de modelos para inferencias por lotes y en tiempo real.

● Usar herramientas e interfaces para trabajar con Azure Machine
Learning.
● Ejecutar experimentos basados en código en un área de trabajo de
Áreas de trabajo de Azure Machine

Learning
Completado
100 XP
5 minutos
Un área de trabajo es un contexto para los experimentos, los datos, los destinos de
proceso y otros recursos asociados a una carga de trabajo de aprendizaje
automático.
Áreas de trabajo para recursos de Machine Learning

Un área de trabajo define el límite para un conjunto de recursos de aprendizaje
automático relacionados. Puede usar áreas de trabajo para agrupar los recursos de
aprendizaje automático en función del proyecto, el entorno de implementación (por
ejemplo, prueba y producción), el equipo u otro principio de organización. Los
recursos de un área de trabajo incluyen lo siguiente:
● Destinos de proceso para desarrollo, entrenamiento e implementación.
● Datos para la experimentación y el entrenamiento del modelo.
● Cuadernos que contienen código compartido y documentación.
● Experimentos, incluido el historial de ejecución con métricas y salidas
registradas.
● Canalizaciones que definen procesos de varios pasos organizados.
● Modelos que ha entrenado.
Áreas de trabajo como recursos de Azure

Las áreas de trabajo son recursos de Azure y, como tales, se definen dentro de un
grupo de recursos en una suscripción de Azure, junto con otros recursos de Azure
relacionados necesarios para admitir el área de trabajo.
Entre los recursos de Azure que se crean junto a un área de trabajo se incluyen los
siguientes:
● Una cuenta de almacenamiento, que se usa para almacenar los

archivos que usa el área de trabajo, así como los datos para los
experimentos y el entrenamiento del modelo.
● Una instancia de Application Insights, que se usa para supervisar los
servicios predictivos en el área de trabajo.
● Una instancia de Azure Key Vault, que se usa para administrar secretos
como las claves de autenticación y las credenciales que se usan e el
área de trabajo.
● Un registro de contenedor, creado a medida para administrar
contenedores para los modelos implementados.
Control de acceso basado en roles
Puede asignar directivas de autorización basadas en roles a un área de trabajo, lo

que le permite administrar los permisos que restringen las acciones que pueden
realizar entidades de seguridad de Azure Active Directory (AAD) específicas. Por
ejemplo, podría crear una directiva que permita que solo los usuarios del grupo
Operaciones de TI creen destinos de proceso y almacenes de datos, al tiempo que
permite a los usuarios del grupo Científicos de datos crear y ejecutar experimentos y
registrar modelos.
Creación de un área de trabajo

Puede crear un área de trabajo de cualquiera de las maneras siguientes:
● En Microsoft Azure Portal, cree un recurso de Machine Learning

mediante la especificación de la suscripción, el grupo de recursos y el
nombre del área de trabajo.
● Use el SDK de Python de Azure Machine Learning para ejecutar código
que crea un área de trabajo. Por ejemplo, con el código siguiente se
crea un área de trabajo llamada aml-workspace (teniendo en cuenta
que el SDK de Azure ML para Python esté instalado y se haya
especificado un id. de suscripción válido):
Python
Copiar
from azureml.core import Workspace
ws = Workspace.create(name='aml-workspace',
subscription_id='123456-abc-123...',
resource_group='aml-resources',
create_resource_group=True,
location='eastus'
)
● Use la interfaz de la línea de comandos (CLI) de Azure con la extensión
de la CLI para Azure Machine Learning. Por ejemplo, podría usar el
comando siguiente (que supone que ya se ha creado un grupo de
recursos denominado aml-resources):
Bash
Copiar
az ml workspace create -w 'aml-workspace' -g 'aml-resources'
● Cree una plantilla de Azure Resource Manager. Para más información

sobre el formato de plantilla de un área de trabajo de Azure Machine
Learning, vea la documentación de Azure Machine Learning.
Ejercicio: creación de un área de trabajo

Completado
100 XP
20 minutos
Ahora puede crear un área de trabajo para empezar a usar Azure Machine Learning.
En este ejercicio, aprenderá a:

● Crear de una instancia de proceso.
● Sirve para ejecutar un cuaderno.
Instrucciones
Siga estas instrucciones para completar el ejercicio.
1. Si todavía no tiene una suscripción de Azure, suscríbase para disfrutar

de una prueba gratuita en https://azure.microsoft.com.
2. Vea el repositorio de ejercicios en https://aka.ms/mslearn-dp100.
3. Complete el ejercicio Creación de un área de trabajo de Azure Machine
Learning.
Herramientas e interfaces de Azure

Machine Learning
Completado
100 XP
5 minutos
Azure Machine Learning proporciona un servicio basado en la nube que ofrece

flexibilidad en la forma de usarlo. Existen interfaces de usuario diseñadas de
manera específica para Azure Machine Learning, o bien puede usar una interfaz de
programación para administrar los recursos del área de trabajo y ejecutar
operaciones de aprendizaje automático.

Puede administrar los recursos del área de trabajo de Azure Machine Learning en
Azure Portal, pero como esta es una interfaz general para administrar todos los tipos
de recursos de Azure, es posible que los científicos de datos y otros usuarios
implicados en las operaciones de aprendizaje automático prefieran usar una interfaz
más concreta y dedicada.
Azure Machine Learning Studio es una herramienta basada en web para administrar
un área de trabajo de Azure Machine Learning. Permite crear, administrar y ver
todos los recursos del área de trabajo y proporciona las siguientes herramientas
gráficas:
● Diseñador: una interfaz de arrastrar y colocar para el desarrollo de

modelos de aprendizaje automático "sin código".
● Aprendizaje automático automatizado: una interfaz de asistente que
permite entrenar un modelo mediante una combinación de algoritmos y
técnicas de preprocesamiento de datos para determinar el modelo
óptimo para los datos.
Nota
Una herramienta publicada anteriormente denominada Azure Machine Learning

Studio proporcionaba un servicio gratuito para arrastrar y colocar el desarrollo del
modelo de aprendizaje automático. La interfaz de estudio para el servicio Azure
Machine Learning incluye esta funcionalidad en la herramienta de diseñador, así
como otras funciones de administración de recursos del área de trabajo.
Para usar Azure Machine Learning Studio, utilice un explorador web para ir a
https://ml.azure.com e inicie sesión con las credenciales asociadas a la suscripción
de Azure. Después, puede seleccionar la suscripción y el área de trabajo que quiere
administrar.
El SDK de Azure Machine Learning
Aunque las interfaces gráficas como Azure Machine Learning Studio facilitan la
creación y administración de los recursos de aprendizaje automático, a menudo es
conveniente usar un enfoque basado en código para administrarlos. Mediante la
escritura de scripts para crear y administrar recursos, puede hacer lo siguiente:
● Ejecutar operaciones de aprendizaje automático desde el entorno de

desarrollo que prefiera.
● Automatizar la creación y configuración de recursos para que sea
repetible.
● Garantizar la coherencia de los recursos que se deben replicar en
varios entornos (por ejemplo, desarrollo, prueba y producción)
● Incorporar la configuración de recursos de aprendizaje automático en
flujos de trabajo de operaciones de desarrollador (DevOps), como las
canalizaciones de integración continua e implementación continua
(CI/CD).
Azure Machine Learning proporciona kits de desarrollo de software (SDK) para

Python y R, que puede usar para crear, administrar y usar recursos en un área de
trabajo de Azure Machine Learning.
Nota
Este curso se centra en el SDK de Python porque tiene funcionalidades más

amplias que el SDK de R, que se encuentra en versión preliminar en el momento de
redactar este artículo.
Instalación del SDK de Python de Azure Machine Learning
Puede instalar el SDK de Python de Azure Machine Learning mediante la utilidad de

administración de paquetes pip, como se muestra en el ejemplo de código siguiente:
Bash
Copiar
pip install azureml-sdk
El SDK se instala mediante la utilidad PIP de Python y consta del paquete

azureml-sdk principal, así como otros muchos paquetes auxiliares que contienen
una funcionalidad especializada. Por ejemplo, el paquete azureml-widgets
proporciona compatibilidad con widgets interactivos en un entorno de Jupyter
Notebook. Para instalar paquetes adicionales, inclúyalos en el comando pip
install:
Bash
Copiar
pip install azureml-sdk azureml-widgets
Más información: Para más información sobre la instalación del SDK de Python de
Azure Machine Learning, vea la documentación del SDK. Además, debe tener en
cuenta que el SDK se actualiza de forma periódica, y revisar las notas de la versión
de la versión más reciente.
Conexión a un área de trabajo
Después de instalar el paquete del SDK en el entorno de Python, puede escribir

código para conectarse al área de trabajo y realizar operaciones de aprendizaje
automático. La manera más sencilla de conectarse a un área de trabajo es usar un
archivo de configuración del área de trabajo, que incluye la suscripción de Azure, el
grupo de recursos y los detalles del área de trabajo, como se muestra aquí:
JSON
Copiar
"subscription_id": "1234567-abcde-890-fgh...",
"resource_group": "aml-resources",
"workspace_name": "aml-workspace"
Sugerencia
Puede descargar un archivo de configuración para un área de trabajo en la página

Información general de su hoja en Azure Portal o desde Estudio de Azure Machine
Learning.
Para conectarse al área de trabajo mediante el archivo de configuración, puede usar

el método from_config de la clase Workspace del SDK, como se muestra aquí:
Python
Copiar
ws = Workspace.from_config()
De forma predeterminada, el método from_config busca un archivo denominado

config.json en la carpeta que contiene el archivo de código Python, pero puede
especificar otra ruta de acceso si es necesario.
Como alternativa al uso de un archivo de configuración, puede usar el método get

de la clase Workspace con detalles especificados de forma explícita sobre la
suscripción, el grupo de recursos y el área de trabajo, como se muestra aquí,
aunque se suele preferir la técnica del archivo de configuración debido a su mayor
flexibilidad cuando se usan varios scripts:
Python
Copiar
ws = Workspace.get(name='aml-workspace',
subscription_id='1234567-abcde-890-fgh...',
resource_group='aml-resources')
Sea cual sea la técnica que use, si no hay ninguna sesión activa actual con la
suscripción de Azure, se le pedirá que se autentique.
Uso de la clase Workspace
La clase Workspace es el punto de partida para la mayoría de las operaciones de

código. Por ejemplo, puede usar su atributo compute_targets para recuperar un
objeto de diccionario que contiene los destinos de proceso definidos en el área de
trabajo, como se indica a continuación:
Python
Copiar
for compute_name in ws.compute_targets:
compute = ws.compute_targets[compute_name]
print(compute.name, ":", compute.type)
El SDK contiene una completa biblioteca de clases que puede usar para crear,
administrar y usar muchos tipos de recursos en un área de trabajo de Azure
Machine Learning.
Más información: Para más información sobre el SDK de Azure Machine Learning,
vea la documentación del SDK.
La extensión de la CLI para Azure Machine Learning

La interfaz de la línea de comandos (CLI) de Azure es una herramienta de línea de
comandos multiplataforma para administrar los recursos de Azure. La extensión de
la CLI para Azure Machine Learning es un paquete adicional que proporciona
comandos para trabajar con Azure Machine Learning.
Para instalar la extensión de la CLI para Azure Machine Learning, primero debe
instalar la CLI de Azure. Vea las instrucciones de instalación completas para todas
las plataformas compatibles para más información.
Después de instalar la CLI de Azure, puede agregar la extensión de la CLI para

Azure Machine Learning si ejecuta el comando siguiente:
Bash
Copiar
az extension add -n azure-cli-ml
Para usar la extensión de la CLI para Azure Machine Learning, ejecute el comando
az ml con los parámetros adecuados para la acción que quiera realizar. Por ejemplo,
para enumerar los destinos de proceso de un área de trabajo, ejecute el comando
siguiente:
Bash
Copiar
az ml computetarget list -g 'aml-resources' -w 'aml-workspace'
Nota
En el ejemplo de código anterior, el parámetro -g especifica el nombre del grupo de

recursos en el que se define el área de trabajo de Azure Machine Learning
especificada en el parámetro -w. Estos parámetros son alias abreviados para
--resource-group y --workspace-name.
Más información: Para más información sobre la extensión de la CLI para Azure
Machine Learning, vea la documentación del SDK.
Compute Instances (Instancias de proceso)

Azure Machine Learning incluye la capacidad de crear instancias de proceso en un
área de trabajo para proporcionar un entorno de desarrollo que se administre con
todos los demás recursos del área de trabajo.
Las instancias de proceso incluyen instalaciones de Jupyter Notebook y JupyterLab

que puede usar para escribir y ejecutar código que usa el SDK de Azure Machine
Learning para trabajar con recursos en el área de trabajo.
Puede elegir una imagen de instancia de proceso que proporcione la especificación

de proceso que necesita, desde máquinas virtuales pequeñas solo con CPU hasta
grandes estaciones de trabajo habilitadas para GPU. Como las instancias de
proceso se hospedan en Azure, solo pagará por los recursos de proceso cuando se
ejecuten; por tanto, puede crear una instancia de proceso que se adapte a sus
necesidades y detenerla cuando se haya completado la carga de trabajo para
minimizar los costos.
Puede almacenar cuadernos de forma independiente en el almacenamiento del área

de trabajo y abrirlos en cualquier instancia de proceso.
Visual Studio Code

Visual Studio Code es un entorno de edición de código ligero para Microsoft
Windows, Apple macOS y Linux. Proporciona una interfaz visual para muchos tipos
de código, incluido Microsoft C#, JavaScript, Python y otros, además de IntelliSense
y formato de sintaxis para formatos de datos comunes, como JSON y XML.
La flexibilidad de Visual Studio Code se basa en la capacidad de instalar

extensiones modulares que agregan comprobación de sintaxis, depuración e
interfaces de administración visuales para cargas de trabajo específicas. Por
ejemplo, la extensión Microsoft Python para Visual Studio Code agrega
compatibilidad para escribir y ejecutar código de Python en scripts o cuadernos
dentro de la interfaz de Visual Studio Code.
La extensión Azure Machine Learning para Visual Studio Code proporciona una
interfaz gráfica para trabajar con recursos en un área de trabajo de Azure Machine
Learning. Puede combinar las funciones de las extensiones de Azure Machine
Learning y Python para administrar una carga de trabajo completa de aprendizaje
automático de un extremo a otro en Azure Machine Learning desde el entorno de
Visual Studio Code.
Experimentos de Azure Machine

Learning
Completado
100 XP
5 minutos
Al igual que cualquier disciplina científica, la ciencia de datos implica la ejecución de

experimentos, normalmente para explorar datos, o bien para compilar y evaluar
modelos predictivos. En Azure Machine Learning, un experimento es un proceso
con nombre, normalmente la ejecución de un script o una canalización, que puede
generar métricas y salidas, y del que se puede realizar el seguimiento en el área de
trabajo de Azure Machine Learning.
Un experimento se puede ejecutar varias veces, con datos, código o configuración

diferentes, y Azure Machine Learning realiza el seguimiento de cada ejecución, lo
que le permite ver el historial de ejecuciones y comparar los resultados de cada una.
Contexto de ejecución del experimento

Cuando se envía un experimento, se usa su contexto de ejecución para inicializar y
finalizar la ejecución del experimento de la que se realiza el seguimiento en Azure
Machine Learning, como se muestra en el ejemplo de código siguiente:
Python
Copiar
from azureml.core import Experiment
# create an experiment variable
experiment = Experiment(workspace = ws, name = "my-experiment")
# start the experiment
run = experiment.start_logging()
# experiment code goes here
# end the experiment
run.complete()
Una vez finalizada la ejecución del experimento, puede ver los detalles en la
pestaña Experimentos de Azure Machine Learning Studio.
Registro de métricas y creación de salidas

Los experimentos son más útiles cuando generan métricas y salidas de las que se
puede realizar el seguimiento entre ejecuciones.
Registro de métricas
Cada experimento genera archivos de registro que incluyen los mensajes que se
escribirán en el terminal durante la ejecución interactiva. Esto le permite usar
instrucciones print sencillas para escribir mensajes en el registro. Pero si quiere
registrar métricas con nombre para la comparación entre ejecuciones, puede
hacerlo mediante el objeto Run, que proporciona un intervalo de funciones de
registro específicamente para este fin. Entre ellas se incluyen las siguientes:
● log: se registra un solo valor con nombre.

● log_list: se registra una lista de valores con nombre.
● log_row: se registra una fila con varias columnas.
● log_table: se registra un diccionario como una tabla.
● log_image: se registra un archivo de imagen o un trazado.
Más información: Para más información sobre el registro de métricas durante las
ejecuciones de experimentos, vea Supervisión de ejecuciones y métricas de
experimentos de Azure ML en la documentación de Azure Machine Learning.
Por ejemplo, el código siguiente registra el número de observaciones (registros) en

un archivo CSV:
Python
Copiar
import pandas as pd
# Create an Azure ML experiment in your workspace
experiment = Experiment(workspace = ws, name = 'my-experiment')
# Start logging data from the experiment
run = experiment.start_logging()
# load the dataset and count the rows
data = pd.read_csv('data.csv')
row_count = (len(data))
# Log the row count

run.log('observations', row_count)
# Complete the experiment
run.complete()
Recuperación y visualización de las métricas registradas
Puede ver las métricas registradas por un experimento ejecutado en Estudio de

Azure Machine Learning o mediante el widget RunDetails en un cuaderno, como se
muestra a continuación:
Python
Copiar
from azureml.widgets import RunDetails
RunDetails(run).show()
También puede recuperar las métricas con el método get_metrics del objeto Run,
que devuelve una representación JSON de las métricas, como se muestra aquí:
Python
Copiar
import json
# Get logged metrics
metrics = run.get_metrics()
print(json.dumps(metrics, indent=2))
El código anterior puede generar una salida similar a la siguiente:
JSON
Copiar
"observations": 15000
Archivos de salida del experimento
Además de registrar métricas, un experimento puede generar archivos de salida. A

menudo, se trata de modelos de aprendizaje automático entrenados, pero puede
guardar cualquier tipo de archivo y hacer que esté disponible como salida de la
ejecución del experimento. Los archivos de salida de un experimento se guardan en
su carpeta outputs.
La técnica que se usa para agregar archivos a las salidas de un experimento

depende de cómo se ejecuta el experimento. Los ejemplos mostrados hasta el
momento controlan el ciclo de vida del experimento insertado en el código y, al
adoptar este enfoque, se pueden cargar archivos locales en la carpeta outputs de la
ejecución mediante el método upload_file del objeto Run en el código del
experimento, como se muestra aquí:
Python
Copiar
run.upload_file(name='outputs/sample.csv',
path_or_stream='./sample.csv')
Cuando se ejecuta un experimento en un contexto de cálculo remoto (que se

describirá más adelante en este curso), los archivos escritos en la carpeta outputs
del contexto de proceso se cargan automáticamente en la carpeta outputs de la
ejecución cuando se completa esta.
Sea cual sea el enfoque que use para ejecutar el experimento, puede recuperar una
lista de archivos de salida desde el objeto Run de esta forma:
Python
Copiar
import json
files = run.get_file_names()
print(json.dumps(files, indent=2))
El código anterior debería generar una salida similar a la siguiente:
JSON
Copiar
"outputs/sample.csv"
Ejecución de un script como un experimento

Puede ejecutar un experimento en línea mediante el método start_logging del objeto
Experiment, pero es más habitual encapsular la lógica del experimento en un script
y ejecutarlo como un experimento. El script se puede ejecutar en cualquier contexto
de proceso válido, lo que hace que esta solución sea más flexible para ejecutar
experimentos como escala.
Un script de experimento es simplemente un archivo de código de Python que

contiene el código que se quiere ejecutar en el experimento. Para acceder al
contexto de ejecución del experimento (que es necesario para registrar las
métricas), el script debe importar la clase azureml.core.Run y llamar a su método
get_context. Después, el script puede usar el contexto de ejecución para registrar
métricas, cargar archivos y completar el experimento, como se muestra en el
ejemplo siguiente:
Python
Copiar
from azureml.core import Run
import pandas as pd

import os
# Get the experiment run context
run = Run.get_context()
# load the diabetes dataset
data = pd.read_csv('data.csv')
# Count the rows and log the result
row_count = (len(data))
run.log('observations', row_count)
# Save a sample of the data
os.makedirs('outputs', exist_ok=True)
data.sample(100).to_csv("outputs/sample.csv", index=False,
header=True)
# Complete the run
run.complete()
Para ejecutar un script como un experimento, debe definir una configuración de

script que establezca el script que se va a ejecutar y el entorno de Python en el que
se ejecutará. Esto se implementa mediante el uso de un objeto ScriptRunConfig.
Por ejemplo, el código siguiente se podría usar para ejecutar un experimento en

función de un script de la carpeta experiment_files (que también debe contener
todos los archivos que use script, como el archivo data.csv en el ejemplo de código
del script anterior):
Python
Copiar
from azureml.core import Experiment, ScriptRunConfig
# Create a script config
script_config =
ScriptRunConfig(source_directory=experiment_folder,
script='experiment.py')
# submit the experiment
experiment = Experiment(workspace = ws, name = 'my-experiment')
run = experiment.submit(config=script_config)
run.wait_for_completion(show_output=True)
Nota
El objeto RunConfiguration, creado implícitamente, define el entorno de Python para

el experimento, incluidos los paquetes disponibles para el script. Si el script depende
de paquetes que no están incluidos en el entorno predeterminado, debe asociar
ScriptRunConfig con un objeto Environment que use un objeto CondaDependencies
para especificar los paquetes de Python necesarios. Más adelante, en este mismo
curso, se habla en más profundidad de los entornos de ejecución.
Ejercicio: ejecución de experimentos

Completado
100 XP
20 minutos
Ahora es la oportunidad de probar Azure Machine Learning personalmente.
● Ejecutar un experimento de Azure Machine Learning.

● Ejecutar un script como un experimento.
● Usar MLflow para realizar un seguimiento de las métricas de los
experimentos.
Instrucciones

3. Si todavía no lo ha hecho, complete el ejercicio Creación de un área de
trabajo de Azure Machine Learning para aprovisionar un área de trabajo
de Azure Machine Learning, crear una instancia de proceso y clonar los
archivos necesarios.
4. Complete el ejercicio Ejecución de experimentos.
Entrenamiento de un modelo de
Machine Learning con Azure Machine
Learning
Obtenga información sobre cómo usar Azure Machine Learning para entrenar un
modelo y registrarlo en un área de trabajo.
● Usar ScriptRunConfig para ejecutar un script de entrenamiento de

modelos a modo de experimento de Azure Machine Learning.
● Crear scripts de entrenamiento reutilizables y con parámetros.
● Registrar modelos entrenados.
Introducción
El entrenamiento de un modelo de aprendizaje automático puede ser tan sencillo
como cargar datos y ejecutar una línea de código mediante paquetes como
scikit-learn. Pero en un escenario de aprendizaje automático de producción, debe
tener en cuenta lo siguiente:
● La creación de scripts de entrenamiento reutilizables para varios

entornos de proceso.
● El registro de métricas de rendimiento del modelo durante los procesos
de entrenamiento y evaluación.
● El seguimiento de versiones del modelo.
● Usar ScriptRunConfig para ejecutar un script de entrenamiento de

modelos a modo de experimento de Azure Machine Learning.
● Crear scripts de entrenamiento reutilizables y con parámetros.
● Registrar modelos entrenados.
Ejecución de un script de entrenamiento

Puede usar ScriptRunConfig para ejecutar un experimento basado en script que
entrena un modelo de aprendizaje automático.
Escritura de un script para entrenar un modelo

Cuando se usa un experimento para entrenar un modelo, el script debe guardar el
modelo entrenado en la carpeta outputs. Por ejemplo, mediante el script siguiente se
entrena un modelo con Scikit-Learn y se guarda en la carpeta outputs con el
paquete joblib:
Nota
Este código de ejemplo es un extracto incompleto que muestra el concepto de

entrenamiento de un modelo mediante Scikit-Learn.
Python
Copiar
import pandas as pd
import numpy as np
import joblib

# Prepare the dataset

diabetes = pd.read_csv('data.csv')
X, y = diabetes[['Feature1','Feature2','Feature3']].values,
diabetes['Label'].values
test_size=0.30)
# Train a logistic regression model

reg = 0.1
model = LogisticRegression(C=1/reg,
solver="liblinear").fit(X_train, y_train)
# calculate accuracy
y_hat = model.predict(X_test)
acc = np.average(y_hat == y_test)
run.log('Accuracy', np.float(acc))
# Save the trained model

joblib.dump(value=model, filename='outputs/model.pkl')
run.complete()
Para preparar un experimento donde se entrena un modelo, se crea un script como

este y se guarda en una carpeta. Por ejemplo, puede guardar este script como
training_script. py en una carpeta llamada training_folder. Puesto que el script
incluye código para cargar los datos de entrenamiento de data.csv, este archivo
también se debe guardar en la carpeta.
Ejecución de un script a modo de experimento

Para ejecutar el script, cree una clase ScriptRunConfig que haga referencia a la
carpeta y al archivo de script. En general, también debe definir un entorno de Python
(Conda) que incluya los paquetes que requiera el script. En este ejemplo, el script
usa Scikit-Learn, por lo que debe crear un entorno que lo incluya. El script también
usa Azure Machine Learning para registrar las métricas, por lo que debe recordar
incluir el paquete azureml-defaults en el entorno.
Python
Copiar
from azureml.core import Experiment, ScriptRunConfig, Environment
from azureml.core.conda_dependencies import CondaDependencies
# Create a Python environment for the experiment

sklearn_env = Environment("sklearn-env")
# Ensure the required packages are installed

packages =
CondaDependencies.create(conda_packages=['scikit-learn','pip'],
pip_packages=['azureml-defaults'])
sklearn_env.python.conda_dependencies = packages

script_config =
ScriptRunConfig(source_directory='training_folder',
script='training.py',
environment=sklearn_env)
# Submit the experiment

experiment = Experiment(workspace=ws, name='training-experiment')
run = experiment.submit(config=script_config)
run.wait_for_completion()
Siguiente unidad: Uso de parámetros de script
Uso de parámetros de script

Completado
100 XP
5 minutos
Puede aumentar la flexibilidad de los experimentos basados en scripts mediante el

uso de argumentos para establecer variables en el script.
Uso de argumentos de script

Para usar parámetros en un script, debe utilizar una biblioteca como argparse para
leer los argumentos que se pasan al script y asignarlos a variables. Por ejemplo, en
el script siguiente se lee un argumento denominado --reg-rate, que se utiliza para
establecer el hiperparámetro de tasa de regularización del algoritmo de regresión
logística que se usa para entrenar un modelo.
Python
Copiar
import argparse
import pandas as pd
import numpy as np
import joblib
import os

# Set regularization hyperparameter

parser = argparse.ArgumentParser()
parser.add_argument('--reg-rate', type=float, dest='reg_rate',
default=0.01)
args = parser.parse_args()
reg = args.reg_rate
# Prepare the dataset

diabetes = pd.read_csv('data.csv')
X, y = data[['Feature1','Feature2','Feature3']].values,
data['Label'].values
test_size=0.30)
# Train a logistic regression model

# calculate accuracy

run.complete()
Paso de argumentos a un script de experimento

Para pasar valores de parámetro a un script que se ejecuta en un experimento,
debe proporcionar un valor arguments que contenga una lista de argumentos
separados por comas y sus valores a ScriptRunConfig, como se indica a
continuación:
Python
Copiar
script_config =
ScriptRunConfig(source_directory='training_folder',
script='training.py',
arguments = ['--reg-rate', 0.1],
environment=sklearn_env)
Siguiente unidad: Registro de modelos

Registro de modelos
Completado
100 XP
5 minutos
Después de ejecutar un experimento que entrena un modelo, puede usar una

referencia al objeto Run para recuperar sus salidas, incluido el modelo entrenado.
Recuperación de archivos de modelo

Una vez finalizada la ejecución de un experimento, puede usar el método
get_file_names para enumerar los archivos generados. El procedimiento habitual
para los scripts que entrenan modelos consiste en guardarlos en la carpeta outputs
de la ejecución.
También puede usar los métodos download_file y download_files del objeto de

ejecución para descargar los archivos de salida en el sistema de archivos local.
Python
Copiar
# "run" is a reference to a completed experiment run
# List the files generated by the experiment

for file in run.get_file_names():
print(file)
# Download a named file

run.download_file(name='outputs/model.pkl',
output_file_path='model.pkl')
Registro de un modelo
El registro de modelos permite realizar el seguimiento de varias versiones de un
modelo y recuperar modelos para la inferencia (la predicción de valores de etiqueta
a partir de datos nuevos). Al registrar un modelo, puede especificar un nombre, una
descripción, etiquetas, un marco de trabajo (como Scikit-Learn o PyTorch), una
versión del marco, propiedades personalizadas y otros metadatos útiles. Al registrar
un modelo con el mismo nombre que otro existente, se crea automáticamente una
versión del modelo, que comienza en 1 y aumenta en unidades de 1.
Para registrar un modelo desde un archivo local, puede usar el método register del
objeto Model tal y como se muestra aquí:
Python
Copiar
from azureml.core import Model
model = Model.register(workspace=ws,
model_name='classification_model',
model_path='model.pkl', # local path
description='A classification model',
tags={'data-format': 'CSV'},
model_framework=Model.Framework.SCIKITLEARN,
model_framework_version='0.20.3')
Como alternativa, si tiene una referencia al elemento Run usado para entrenar el
modelo, puede usar su método register_model, tal y como se muestra aquí:
Python
Copiar
run.register_model( model_name='classification_model',
model_path='outputs/model.pkl', # run outputs
path
description='A classification model',
tags={'data-format': 'CSV'},
model_framework=Model.Framework.SCIKITLEARN,
model_framework_version='0.20.3')
Visualización de modelos registrados
Puede ver los modelos registrados en Azure Machine Learning Studio. También
puede usar el objeto Model para recuperar los detalles de los modelos registrados
de esta forma:
Python
Copiar
for model in Model.list(ws):

# Get model name and auto-generated version
print(model.name, 'version:', model.version)

registro de un modelo
Ejercicio: Entrenamiento y registro de un

modelo
Completado
100 XP
20 minutos
Ahora tiene la oportunidad de usar Azure Machine Learning para entrenar un

modelo de aprendizaje automático.
● Usar un script para entrenar un modelo.

● Usar un script con parámetros para entrenar un modelo.
● Registrar un modelo.
Instrucciones

4. Realice el ejercicio Entrenamiento de modelos.
Uso de datos en Azure Machine Learning

Los datos son la base del aprendizaje automático. En este módulo, aprenderá a
trabajar con almacenes y conjuntos de datos en Azure Machine Learning, lo que le
permitirá crear soluciones de entrenamiento de modelos escalables basadas en la
nube.
● Crear y usar almacenes de datos en un área de trabajo de Azure
Machine Learning.
● Crear y usar conjuntos de datos en un área de trabajo de Azure
Machine Learning.
Introducción
Completado
100 XP
2 minutos
Los datos son un elemento fundamental en cualquier carga de trabajo de

aprendizaje automático. Por ello, en este módulo aprenderá a crear y administrar
almacenes de datos y conjuntos de datos en un área de trabajo de Azure Machine
Learning y a usarlos en experimentos de entrenamiento de modelos.
● Crear y utilizar almacenes de datos.

● Crear y utilizar conjuntos de datos.
Introducción a los conjuntos de datos
Completado
100 XP
5 minutos
En Azure Machine Learning, los almacenes de datos son abstracciones de los

orígenes de datos en la nube. Encapsulan la información necesaria para conectarse
a los orígenes de datos. Puede acceder a los almacenes de datos directamente
desde el código, usando el SDK de Azure Machine Learning para cargar o
descargar datos.
Tipos de almacenes de datos

Azure Machine Learning admite la creación de almacenes de datos para varios tipos
de orígenes de datos de Azure, entre los que se incluyen:
● Azure Storage (contenedores de blobs y archivos)

● Almacenes de lagos de datos de Azure
● Azure SQL Database
● Sistema de archivos de Azure Databricks (DBFS)
Nota: para consultar una lista completa de los almacenes de datos admitidos,
consulte la documentación de Azure Machine Learning.
Almacenes de datos integrados

Cada área de trabajo tiene dos almacenes de datos integrados (un contenedor de
blobs de Azure Storage y un contenedor de archivos de Azure Storage), que Azure
Machine Learning usa como almacenamiento del sistema. También hay un tercer
almacén de datos que se agrega al área de trabajo si se usan los conjuntos de
datos abiertos proporcionados como muestra (por ejemplo, mediante la creación de
una canalización de diseñador basada en un conjunto de datos de ejemplo).
En la mayoría de los proyectos de aprendizaje automático, es probable que tenga

que trabajar con orígenes de datos propios, ya sea porque necesita almacenar
volúmenes de datos más grandes de los que admiten los almacenes de datos
integrados o porque tiene que integrar su solución de aprendizaje automático con
datos de aplicaciones existentes.
Uso de almacenes de datos

Completado
100 XP
5 minutos
Para agregar un almacén de datos a su área de trabajo, puede registrarlo con la

interfaz gráfica en el Estudio de Azure Machine Learning o bien utilizar el SDK de
Azure Machine Learning. Por ejemplo, el código siguiente registra un contenedor de
blobs de Azure Storage como un almacén de datos denominado blob_data.
Python
Copiar
from azureml.core import Workspace, Datastore
# Register a new datastore

blob_ds = Datastore.register_azure_blob_container(workspace=ws,
datastore_name='blob_data',
container_name='data_container',
account_name='az_store_acct',
account_key='123456abcde789…')
Administración de almacenes de datos

Puede ver y administrar almacenes de datos en el Estudio de Azure Machine
Learning o puede usar el SDK de Azure Machine Learning. Por ejemplo, en el
código siguiente se enumeran los nombres de cada almacén de datos del área de
trabajo.
Python
Copiar
for ds_name in ws.datastores:
print(ds_name)
Puede obtener una referencia a cualquier almacén de datos usando el método

Datastore.get(), como se muestra aquí:
Python
Copiar
blob_store = Datastore.get(ws, datastore_name='blob_data')
El área de trabajo siempre incluye un almacén de datospredeterminado

(inicialmente, es el almacén de datos workspaceblobstore integrado), que se puede
recuperar mediante el método get_default_datastore() de un objeto de área de
trabajo como este:
Python
Copiar
default_store = ws.get_default_datastore()
Consideraciones sobre los almacenes de datos

A la hora de planear un almacén de datos, tenga en cuenta las siguientes
directrices:
● Al usar Azure Blob Storage, el almacenamiento de nivel prémium puede

proporcionar un mejor un rendimiento de E/S para grandes conjuntos de
datos, pero esta opción aumentará el costo y puede limitar las opciones
de replicación para la redundancia de datos.
● Al trabajar con archivos de datos, aunque el formato CSV es muy
común, el formato Parquet suele dar lugar a un mejor rendimiento.
● Puede acceder a cualquier almacén de datos por nombre, pero quizás
le interesa cambiar el almacén de datos predeterminado (que
inicialmente es el almacén de datos workspaceblobstore integrado).
Para cambiar el almacén de datos predeterminado, utilice el método

set_default_datastore():
Python
Copiar
ws.set_default_datastore('blob_data')
Siguiente unidad: Introducción a los conjuntos de

datos
Uso de conjuntos de datos
Completado
100 XP
5 minutos
Los conjuntos de datos son la principal forma de pasar datos a experimentos que entrenan
modelos.
Trabajo con conjuntos de datos tabulares

Puede leer datos directamente desde un conjunto de datos tabulares convirtiéndolo en un
DataFrame de Pandas o Spark:
Copiar
df = tab_ds.to_pandas_dataframe()
# code to work with dataframe goes here, for example:
print(df.head())
Paso de un conjunto de datos tabular a un script de experimento
Cuando tenga que acceder a un conjunto de datos de un script de experimento, debe pasar
el conjunto de datos al script. Puede hacerlo de dos formas.
Uso de un argumento de script para un conjunto de datos tabulares
Puede pasar un conjunto de datos tabulares como un argumento de script. Al tomar este
enfoque, el argumento recibido por el script es el identificador único para el conjunto de
datos de su área de trabajo. En el script, puede ver el área de trabajo desde el contexto de
ejecución y utilizarlo para recuperar el conjunto de datos por su identificador.
ScriptRunConfig:
Copiar
env = Environment('my_env')
packages = CondaDependencies.create(conda_packages=['pip'],
pip_packages=['azureml-defaults',
'azureml-dataprep[pandas]'])
env.python.conda_dependencies = packages
script_config = ScriptRunConfig(source_directory='my_dir',
script='script.py',
arguments=['--ds', tab_ds],
environment=env)
Script:
Copiar
from azureml.core import Run, Dataset
parser.add_argument('--ds', type=str, dest='dataset_id')

ws = run.experiment.workspace
dataset = Dataset.get_by_id(ws, id=args.dataset_id)
data = dataset.to_pandas_dataframe()
Uso de una entrada con nombre para un conjunto de datos tabulares
También puede pasar un conjunto de datos tabulares como entrada con nombre. Si toma
ese enfoque, usará el método as_named_input del conjunto de datos para especificar un
nombre para el conjunto de datos. Después, en el script, puede recuperar el conjunto de
datos por nombre desde la colección input_datasets del contexto de ejecución sin
necesidad de recuperarlo del área de trabajo. Tenga en cuenta que, si usa este enfoque,
todavía tendrá que incluir un argumento de script para el conjunto de datos, aunque
realmente no lo use para recuperar el conjunto de datos.
ScriptRunConfig:
Copiar
script='script.py',
arguments=['--ds', tab_ds.as_named_input('my_dataset')],
environment=env)
Script:
Copiar
parser.add_argument('--ds', type=str, dest='ds_id')

dataset = run.input_datasets['my_dataset']
data = dataset.to_pandas_dataframe()
Trabajo con conjuntos de datos de archivos

Al trabajar con un conjunto de datos de archivos, puede utilizar el método to_path() para
devolver una lista de las rutas de acceso a los archivos encapsuladas por el conjunto de
datos:
Copiar
for file_path in file_ds.to_path():
print(file_path)
Paso de un conjunto de datos de archivo a un script de experimento
Igual que con un conjunto de datos tabulares, hay dos formas de pasar un conjunto de
datos de archivo a un script. Pero hay algunas diferencias importantes en la forma en que
se pasa el conjunto de datos.
Uso de un argumento de script para un conjunto de datos de archivo
Puede pasar un conjunto de datos de archivo como un argumento de script. A diferencia de

un conjunto de datos tabulares, debe especificar un modo para el argumento del conjunto
de datos de archivo, que puede ser as_download o as_mount. Esto proporciona un punto de
acceso que el script puede usar para leer los archivos del conjunto de datos. En la mayoría
de los casos, debe usar as_download, que copia los archivos en una ubicación temporal del
proceso en el que se ejecuta el script. Pero, si está trabajando con una gran cantidad de
datos para los que es posible que no haya suficiente espacio de almacenamiento en el
proceso del experimento, use as_mount para transmitir los archivos directamente desde su
origen.
ScriptRunConfig:
Copiar
script='script.py',
arguments=['--ds', file_ds.as_download()],
environment=env)
Script:
Copiar
import glob
parser.add_argument('--ds', type=str, dest='ds_ref')

imgs = glob.glob(args.ds_ref + "/*.jpg")
Uso de una entrada con nombre para un conjunto de datos de archivo
También puede pasar un conjunto de datos de archivo como una entrada con nombre. En
este enfoque, se usa el método as_named_input del conjunto de datos para especificar un
nombre antes de especificar el modo de acceso. Después, en el script, puede recuperar el
conjunto de datos por nombre de la colección input_datasets del contexto de ejecución y
leer los archivos desde allí. Igual que con los conjuntos de datos tabulares, si usa este
enfoque, todavía tendrá que incluir un argumento de script para el conjunto de datos,
aunque realmente no lo use para recuperar el conjunto de datos.
ScriptRunConfig:
Copiar
script='script.py',
arguments=['--ds', file_ds.as_named_input('my_ds').as_download()],
environment=env)
Script:
Copiar
import glob
parser.add_argument('--ds', type=str, dest='ds_ref')

dataset = run.input_datasets['my_ds']
imgs= glob.glob(dataset + "/*.jpg")
Introducción a los conjuntos de datos

Los conjuntos de datos son objetos de datos empaquetados con versiones que se
pueden consumir fácilmente en experimentos y canalizaciones. Los conjuntos de
datos son la forma recomendada de trabajar con datos y el mecanismo principal
para funciones avanzadas de Azure Machine Learning, como el etiquetado de datos
y la supervisión de desfase de datos.
Tipos de conjuntos de datos

Los conjuntos de datos normalmente se basan en archivos de un almacén de datos,
aunque también se pueden basar en direcciones URL y otros orígenes. Puede crear
los siguientes tipos de conjuntos de datos:
● Tabular: los datos se leen desde el conjunto de datos como una tabla.
Debe usar este tipo de conjunto de datos cuando los datos están
estructurados de forma coherente y quiere trabajar con ellos en
estructuras de datos tabulares comunes, como DataFrames de Pandas.
● Archivo: el conjunto de datos presenta una lista de rutas de acceso a
archivos que se pueden leer como si fueran del sistema de archivos.
Utilice este tipo de conjunto de datos cuando los datos no estén
estructurados o cuando necesite procesar los datos en el nivel de
archivo (por ejemplo, para entrenar una red neuronal de circunvolución
desde un conjunto de archivos de imagen).
Creación y registro de conjuntos de datos

Puede usar la interfaz visual en el Estudio de Azure Machine Learning o el SDK de
Azure Machine Learning para crear conjuntos de datos a partir de archivos
individuales o varias rutas de acceso a archivos. Las rutas de acceso pueden incluir
caracteres comodín (por ejemplo, /files/*.csv), que permiten encapsular datos de un
gran número de archivos en un único conjunto de datos.
Después de crear un conjunto de datos, puede registrarlo en el área de trabajo para

que esté disponible para su uso en experimentos y canalizaciones de
procesamiento de datos más adelante.
Creación y registro de conjuntos de datos tabulares
Para crear un conjunto de datos tabulares con el SDK, use el método

from_delimited_files de la clase DataSet.Tabular de la siguiente manera:
Python
Copiar
from azureml.core import Dataset
blob_ds = ws.get_default_datastore()
csv_paths = [(blob_ds, 'data/files/current_data.csv'),
(blob_ds, 'data/files/archive/*.csv')]
tab_ds = Dataset.Tabular.from_delimited_files(path=csv_paths)
tab_ds = tab_ds.register(workspace=ws, name='csv_table')
En este ejemplo, el conjunto de datos incluye datos de dos rutas de acceso a

archivos dentro del almacén de datos predeterminado:
● El archivo current_data.csv en la carpeta data/files.

● Todos los archivos .csv de la carpeta data/files/archive/.
Después de crear el conjunto de datos, el código lo registra en el área de trabajo

con el nombre csv_table.
Creación y registro de conjuntos de datos

Para crear un conjunto de datos de archivos con el SDK, use el método from_files
de la clase DataSet.File de la siguiente manera:
Python
Copiar
from azureml.core import Dataset
blob_ds = ws.get_default_datastore()
file_ds = Dataset.File.from_files(path=(blob_ds,
'data/files/images/*.jpg'))
file_ds = file_ds.register(workspace=ws, name='img_files')
El conjunto de datos de este ejemplo incluye todos los archivos .jpg de la ruta de
acceso data/files/images dentro del almacén de datos predeterminado.
Después de crear el conjunto de datos, el código lo registra en el área de trabajo

con el nombre img_files.
Recuperación de un conjunto de datos registrado

Después de registrar un conjunto de datos, puede recuperarlo mediante cualquiera
de las técnicas siguientes:
● Atributo del diccionario datasets de un objeto de Workspace.

● El métodoget_by_name o get_by_id de la clase Dataset.
Estas dos técnicas se muestran en el código siguiente:
Python
Copiar
import azureml.core
from azureml.core import Workspace, Dataset
# Load the workspace from the saved config file

# Get a dataset from the workspace datasets collection

ds1 = ws.datasets['csv_table']
# Get a dataset by name from the datasets class

ds2 = Dataset.get_by_name(ws, 'img_files')
Control de versiones del conjunto de datos
Los conjuntos de datos se pueden versionar, lo que le permite realizar un
seguimiento del historial de versiones de los conjuntos de datos que se usaron en
los experimentos y reproducir esos experimentos con datos en el mismo estado.
Puede crear una nueva versión de un conjunto de datos registrándola con el mismo
nombre que un conjunto de datos previamente registrado y especificando la
propiedad create_new_version:
Python
Copiar
img_paths = [(blob_ds, 'data/files/images/*.jpg'),
(blob_ds, 'data/files/images/*.png')]
file_ds = Dataset.File.from_files(path=img_paths)
file_ds = file_ds.register(workspace=ws, name='img_files',
create_new_version=True)
En este ejemplo, los archivos .png de la carpeta images se han agregado a la

definición del ejemplo de conjunto de datos img_paths utilizado en el tema anterior.
Recuperación de una versión específica del conjunto

de datos
Puede recuperar una versión específica de un conjunto de datos especificando el
parámetro version en el método get_by_name de la clase DataSet.
Python
Copiar
img_ds = Dataset.get_by_name(workspace=ws, name='img_files',
version=2)
Ejercicio: Trabajar con datos

Completado
100 XP
20 minutos
Ahora tiene la oportunidad de trabajar con datos en Azure Machine Learning.

● Cargar datos a un almacén de datos.
● Creación de conjuntos de datos
● Usar conjuntos de datos para entrenar un modelo.
Instrucciones

4. Realice el ejercicio Trabajar con datos.
Uso de Compute en Azure Machine
Learning
Una de las principales ventajas de la nube es la posibilidad de usar recursos de
proceso escalables y a petición para el procesamiento rentable de datos de gran
tamaño. En este módulo, aprenderá a usar el proceso en la nube en Azure Machine
Learning para ejecutar experimentos de entrenamiento a gran escala.
Introducción
Completado
100 XP
2 minutos
En Azure Machine Learning, los científicos de datos pueden ejecutar experimentos

basados en scripts que procesan datos, entrenar modelos de aprendizaje
automático y realizar otras tareas de ciencia de datos. El contexto en tiempo de
ejecución para cada ejecución del experimento consta de dos elementos:
● El entorno del script, que incluye todos los paquetes de los que
depende el script.
● El destino de proceso en el que se implementará el entorno y la
ejecución del script.
● Crear y usar entornos.

● Crear destinos de proceso.
Introducción a los entornos
Completado
100 XP
5 minutos
El código de Python se ejecuta en el contexto de un entorno virtual que define la

versión del tiempo de ejecución de Python que se va a usar, así como los paquetes
instalados disponibles para el código. En la mayoría de las instalaciones de Python,
los paquetes se instalan y administran en entornos con Conda o PIP.
Para mejorar la portabilidad, normalmente se crean entornos en contenedores de

Docker que, a su vez, se hospedan en destinos de proceso, como el equipo de
desarrollo, máquinas virtuales o clústeres en la nube.
Entornos en Azure Machine Learning

En general, Azure Machine Learning controla la creación de entornos y la instalación
de paquetes, normalmente a través de la creación de contenedores de Docker.
Puede especificar los paquetes Conda o PIP que necesita y hacer que Azure
Machine Learning cree un entorno para el experimento.
En una solución de aprendizaje automático de la empresa, donde los experimentos

se pueden ejecutar en diversos contextos de cálculo, puede ser importante tener en
cuenta los entornos en los que se ejecuta el código del experimento. Los entornos
están encapsulados por la clase Entorno, que puede usar para crear entornos y
especificar la configuración de tiempo de ejecución para un experimento.
Puede hacer que Azure Machine Learning administre la creación de un entorno y la

instalación de paquetes para definir un entorno y, a continuación, registrarlo para
reutilizarlo. Como alternativa, puede administrar sus propios entornos y registrarlos.
Esto permite definir contextos en tiempo de ejecución coherentes y reutilizables para
los experimentos, independientemente de dónde se ejecute el script de
experimento.
Creación de entornos
Hay varias maneras de crear entornos en Azure Machine Learning.
Crear un entorno a partir de un archivo de especificación
Puede usar un archivo de especificación Conda o PIP para definir los paquetes
necesarios en un entorno de Python y usarlo para crear un objeto de entorno.
Por ejemplo, puede guardar las siguientes opciones de configuración de Conda en

un archivo denominado conda.yml:
Bash
Copiar
name: py_env
dependencies:
- numpy
- pandas
- scikit-learn
- pip:
- azureml-defaults
Después, puede usar el código siguiente para crear un entorno de Azure Machine
Learning a partir del archivo de especificación guardado:
Python
Copiar
from azureml.core import Environment
env =
Environment.from_conda_specification(name='training_environment',
file_path='./conda.yml')
Creación de un entorno a partir de un entorno de Conda existente
Si tiene un entorno Conda existente definido en la estación de trabajo, puede usarlo

para definir un entorno de Azure Machine Learning:
Python
Copiar
env =
Environment.from_existing_conda_environment(name='training_environ
ment',
conda_environment_name='py_env')
Creación de un entorno mediante la especificación de paquetes
Puede definir un entorno especificando los paquetes Conda y PIP que necesita en
un objeto CondaDependencies, como se indica a continuación:
Python
Copiar
from azureml.core.conda_dependencies import CondaDependencies
env = Environment('training_environment')
deps =
CondaDependencies.create(conda_packages=['scikit-learn','pandas','
numpy'],
pip_packages=['azureml-defaults'])
env.python.conda_dependencies = deps
Configuración de contenedores de entorno
Normalmente, los entornos para el script de experimento se crean en contenedores.
El código siguiente configura un experimento basado en script para hospedar el
entorno env creado anteriormente en un contenedor (este es el valor
predeterminado a menos que use DockerConfiguration con un atributo use_docker
de False, en cuyo caso el entorno se crea directamente en el destino de proceso).
Python
Copiar
from azureml.core import Experiment, ScriptRunConfig
from azureml.core.runconfig import DockerConfiguration
docker_config = DockerConfiguration(use_docker=True)
script_config = ScriptRunConfig(source_directory='my_folder',
script='my_script.py',
environment=env,
docker_runtime_config=docker_config)
Azure Machine Learning usa una biblioteca de imágenes base para los
contenedores y elige la base adecuada para el destino de proceso que especifique
(por ejemplo, incluida la compatibilidad con Cuda para el proceso basado en GPU).
Si ha creado imágenes de contenedor personalizadas y las ha registrado en un
registro de contenedor, puede invalidar las imágenes base predeterminadas y usar
las suyas propias modificando los atributos de la propiedad docker del entorno.
Python
Copiar
env.docker.base_image='my-base-image'
env.docker.base_image_registry='myregistry.azurecr.io/myimage'
Como alternativa, puede hacer que una imagen se cree a petición en función de la
imagen base y la configuración adicional en un Dockerfile.
Python
Copiar
env.docker.base_image = None
env.docker.base_dockerfile = './Dockerfile'
De manera predeterminada, Azure Machine Learning administra las rutas de acceso
y las dependencias de paquetes de Python. Si la imagen ya incluye una instalación
de Python con las dependencias que necesita, puede invalidar este comportamiento
estableciendo python.user_managed_dependencies en True y estableciendo una
ruta de acceso de Python explícita para la instalación.
Python
Copiar
env.python.user_managed_dependencies=True
env.python.interpreter_path = '/opt/miniconda/bin/python'
Registro y reutilización de entornos

Después de crear un entorno, puede registrarlo en el área de trabajo y volver a
usarlo para experimentos futuros que tengan las mismas dependencias de Python.
Registro de un entorno
Use el método Register de un objeto de entorno para registrar un entorno:
Python
Copiar
env.register(workspace=ws)
Puede ver los entornos registrados en el área de trabajo de la siguiente manera:
Python
Copiar
env_names = Environment.list(workspace=ws)
for env_name in env_names:
print('Name:',env_name)
Recuperación y uso de un entorno
Puede recuperar un entorno registrado mediante el método Get de la clase de

entorno y, a continuación, asignarlo a un ScriptRunConfig.
Por ejemplo, en el siguiente ejemplo de código se recupera el entorno registrado
training_environment y se asigna a una configuración de ejecución de script:
Python
Copiar
from azureml.core import Environment, ScriptRunConfig
training_env = Environment.get(workspace=ws,
name='training_environment')
script_config = ScriptRunConfig(source_directory='my_folder',
script='my_script.py',
environment=training_env)
Cuando se ejecuta un experimento basado en el estimador, Azure Machine Learning

busca un entorno existente que coincida con la definición y, si no se encuentra
ninguno, se creará un nuevo entorno basado en la especificación del entorno
registrado.
Introducción a los destinos de proceso

Completado
100 XP
5 minutos
En Azure Machine Learning, los destinos de proceso son equipos físicos o virtuales
en los que se ejecutan los experimentos.
Tipos de proceso
Azure Machine Learning admite varios tipos de proceso para la experimentación y el
entrenamiento. Esto le permite seleccionar el tipo más adecuado de destino de
proceso para sus necesidades concretas.
● Proceso local: puede especificar un destino de proceso local para la

mayoría de las tareas de procesamiento en Azure Machine Learning.
Esto ejecuta el experimento en el mismo destino de proceso que el
código que se usa para iniciar el experimento, que puede ser la estación
de trabajo física o una máquina virtual, como una instancia de proceso
de Azure Machine Learning en la que se ejecuta un cuaderno.
Normalmente, el proceso local es una excelente opción durante el
desarrollo y las pruebas con volúmenes de datos bajos a moderados.
● Clústeres de proceso: en el caso de cargas de trabajo de experimentos
con requisitos de escalabilidad elevados, puede usar clústeres de
proceso de Azure Machine Learning, que son clústeres de varios nodos
de Virtual Machines que se escalan o reducen verticalmente de forma
automática para satisfacer la demanda. Esta es una manera rentable de
ejecutar experimentos que necesiten administrar grandes volúmenes de
datos o usar el procesamiento en paralelo para distribuir la carga de
trabajo y reducir el tiempo que se tarda en ejecutarse.
● Proceso adjunto: si ya usa un entorno de proceso basado en Azure para
la ciencia de datos, como una máquina virtual o un clúster de Azure
Databricks, puede adjuntarlo al área de trabajo de Azure Machine
Learning y usarlo como destino de proceso para determinados tipos de
carga de trabajo.
Nota
En Estudio de Azure Machine Learning, puede crear otro tipo de proceso

denominado clústeres de inferencia. Este tipo de proceso representa un clúster de
Azure Kubernetes Service y solo se puede usar para implementar modelos
entrenados como servicios de inferencia. Exploraremos la implementación más
adelante, pero por ahora nos centraremos en los experimentos y el entrenamiento
del modelo.
La capacidad de asignar ejecuciones de experimentos a destinos de proceso

específicos ayuda a implementar un ecosistema flexible de ciencia de datos de las
maneras siguientes:
● El código se puede desarrollar y probar en un proceso local o de bajo

costo y, luego, moverse a un proceso más escalable para cargas de
trabajo de producción.
● Puede ejecutar los procesos individuales en el destino de proceso que
mejor se adapten a sus necesidades. Por ejemplo, mediante el uso de
un proceso basado en GPU para entrenar modelos de aprendizaje
profundo y el cambio a un proceso de solo CPU de menor costo para
probar y registrar el modelo entrenado.
Una de las principales ventajas de la informática en la nube es la capacidad de

administrar los costos pagando solo por lo que usa. En Azure Machine Learning,
puede aprovechar este principio mediante la definición de destinos de proceso que:
● Se inician a petición y se detienen automáticamente cuando ya no se

necesitan.
● Se escalan automáticamente según las necesidades de procesamiento
de la carga de trabajo.
Creación de destinos de proceso
Completado
100 XP
5 minutos
Las formas más comunes de crear o adjuntar un destino de proceso son usar la
página Proceso en Estudio de Azure Machine Learning Studio o usar el SDK de
Azure Machine Learning para aprovisionar destinos de proceso en el código.
Creación de un destino de proceso administrado con el

SDK
Un destino de proceso administrado es aquel administrado por Azure Machine
Learning, como un clúster de proceso de Azure Machine Learning.
Para crear un clúster de proceso de Azure Machine Learning, utilice la clase

azureml.core.compute.ComputeTarget y la clase AmlCompute de la siguiente
manera:
Python
Copiar
from azureml.core.compute import ComputeTarget, AmlCompute

# Specify a name for the compute (unique within the workspace)

compute_name = 'aml-cluster'
# Define compute configuration

compute_config =
AmlCompute.provisioning_configuration(vm_size='STANDARD_DS11_V2',
min_nodes=0, max_nodes=4,
vm_priority='dedicated')
# Create the compute

aml_cluster = ComputeTarget.create(ws, compute_name,
compute_config)
aml_cluster.wait_for_completion(show_output=True)
En este ejemplo, se creará un clúster con un máximo de cuatro nodos que se basa
en la imagen de máquina virtual STANDARD_DS12_v2. La prioridad de las
máquinas virtuales (VM) se establece en dedicado, lo que significa que están
reservadas para su uso en este clúster (la alternativa es especificar lowpriority, que
tiene un costo más bajo, pero significa que las máquinas virtuales se pueden
reemplazar si una carga de trabajo de mayor prioridad requiere el proceso).
Nota
Para obtener una lista completa de las opciones de configuración de AmlCompute,

consulte la documentación del SDK de la clase AmlCompute.
Conexión de un destino de proceso no administrado

con el SDK
Un destino de proceso no administrado es aquel que se define y administra fuera del
área de trabajo Azure Machine Learning; por ejemplo, una máquina virtual de Azure
o un clúster de Azure Databricks.
El código para adjuntar un destino de proceso no administrado existente es similar

al código que se usa para crear un destino de proceso administrado, salvo que se
debe usar el método ComputeTarget.attach() para adjuntar el proceso existente
basándose en sus valores de configuración específicos del destino.
Por ejemplo, el código siguiente puede usarse para asociar un clúster de Azure
Databricks existente:
Python
Copiar
from azureml.core.compute import ComputeTarget, DatabricksCompute

# Specify a name for the compute (unique within the workspace)

compute_name = 'db_cluster'
# Define configuration for existing Azure Databricks cluster

db_workspace_name = 'db_workspace'
db_resource_group = 'db_resource_group'
db_access_token = '1234-abc-5678-defg-90...'
db_config =
DatabricksCompute.attach_configuration(resource_group=db_resource_
group,
workspace_name=db_workspace_name,
access_token=db_access_token)
# Create the compute

databricks_compute = ComputeTarget.attach(ws, compute_name,
db_config)
databricks_compute.wait_for_completion(True)
Comprobación de un destino de proceso existente

En muchos casos, querrá comprobar la existencia de un destino de proceso y crear
solo uno nuevo si no hay ninguno con el nombre especificado. Para ello, puede
detectar la excepción ComputeTargetException de la siguiente manera:
Python
Copiar
from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException
compute_name = "aml-cluster"
# Check if the compute target exists

try:
aml_cluster = ComputeTarget(workspace=ws, name=compute_name)
print('Found existing cluster.')
except ComputeTargetException:
# If not, create it
compute_config =
AmlCompute.provisioning_configuration(vm_size='STANDARD_DS11_V2',
max_nodes=4)
aml_cluster = ComputeTarget.create(ws, compute_name,
compute_config)
aml_cluster.wait_for_completion(show_output=True)
Más información: para obtener más información sobre la creación de destinos de

proceso, consulte Configuración y uso de destinos de proceso para el entrenamiento
de modelos en la documentación de Azure Machine Learning.
Uso de destinos de proceso
Completado
100 XP
5 minutos
Después de crear o adjuntar destinos de proceso en el área de trabajo, puede

usarlos para ejecutar cargas de trabajo específicas, como experimentos.
Para usar un destino de proceso determinado, puede especificarlo en el parámetro

adecuado para una configuración de ejecución de experimento o un estimador. Por
ejemplo, el código siguiente configura un estimador para usar el destino de proceso
denominado aml-cluster:
Python
Copiar
compute_name = 'aml-cluster'
script='script.py',
environment=training_env,
compute_target=compute_name)
Cuando se envía un experimento, la ejecución se pone en cola mientras se inicia el

destino de proceso aml-cluster y se crea el entorno especificado en él y, a
continuación, la ejecución se procesa en el entorno de proceso.
En lugar de especificar el nombre del destino de proceso, puede especificar un

objeto ComputeTarget, como se indica a continuación:
Python
Copiar
from azureml.core.compute import ComputeTarget
compute_name = "aml-cluster"
training_cluster = ComputeTarget(workspace=ws, name=compute_name)

script='script.py',
environment=training_env,
compute_target=training_cluster)
Ejercicio: uso de contextos de proceso

Completado
100 XP
20 minutos
Ahora es su oportunidad de trabajar con entornos y destinos de proceso en Azure

Machine Learning.
● Crear y utilizar un entorno.

● Crear y usar un destino de proceso.
Instrucciones

4. Complete el ejercicio Uso de procesos.
Orquestación del aprendizaje automático
con canalizaciones
La orquestación del entrenamiento del aprendizaje automático con canalizaciones
es un elemento clave de DevOps para el aprendizaje automático. En este módulo,
aprenderá a crear, publicar y ejecutar canalizaciones para entrenar modelos en
● Creación de los pasos de una canalización
● Paso de datos entre los pasos
● Publicación y ejecución de una canalización
● Programación de una canalización
Introducción
Completado
100 XP
2 minutos
En Azure Machine Learning, las cargas de trabajo se ejecutan como experimentos

que aprovechan los activos de datos y los recursos de proceso. En un proceso de
ciencia de datos empresarial, generalmente querrá separar el proceso general en
tareas individuales y orquestarlas como canalizaciones de pasos conectados. Las
canalizaciones son fundamentales para implementar una solución efectiva de
operaciones de Machine Learning (ML Ops) en Azure, por lo que explorará cómo
definirlas y ejecutarlas en este módulo.
Nota
El término canalización se usa ampliamente en aprendizaje automático, a menudo

con diferentes significados. Por ejemplo, en Scikit-Learn, puede definir
canalizaciones que combinen transformaciones de preprocesamiento de datos con
un algoritmo de entrenamiento; y en Azure DevOps, puede definir una canalización
de compilación o de versión para realizar las tareas de compilación y configuración
necesarias para ofrecer el software. Este módulo se centra en las canalizaciones de
Azure Machine Learning, que encapsulan pasos que pueden ejecutarse como un
experimento. Sin embargo, tenga en cuenta que es absolutamente factible tener una
canalización de Azure DevOps con una tarea que inicia una canalización de Azure
Machine Learning, que a su vez incluye un paso que entrena un modelo basado en
una canalización de Scikit-Learn.
● Crear una canalización de Azure Machine Learning.

● Publicar una canalización de Azure Machine Learning.
● Programar una canalización de Azure Machine Learning.
Introducción a las canalizaciones

Completado
100 XP
5 minutos
En Azure Machine Learning, una canalización es un flujo de trabajo de tareas de

aprendizaje automático en las que cada tarea se implementa como un paso.
Los pasos se pueden organizar de forma secuencial o en paralelo, lo que permite

crear una sofisticada lógica de flujo para orquestar las operaciones de aprendizaje
automático. Cada paso puede ejecutarse en un destino de proceso específico;
gracias a ello, es posible combinar diferentes tipos de procesamiento según sea
necesario para lograr un objetivo general.
Una canalización se puede ejecutar como un proceso mediante la ejecución de la

canalización como un experimento. Cada paso de la canalización se ejecuta en su
destino de proceso asignado como parte de la ejecución general del experimento.
Puede publicar una canalización como un punto de conexión de REST, lo que

permite a las aplicaciones cliente iniciar una ejecución de canalización. También
puede definir una programación para una canalización y hacer que se ejecute
automáticamente a intervalos periódicos.
Pasos de la canalización
Una canalización Azure Machine Learning se compone de uno o varios pasos que
realizan tareas. Hay muchos tipos de pasos admitidos por las canalizaciones de
Azure Machine Learning, cada uno con sus propias opciones de configuración y
propósito especializadas.
Entre los tipos comunes de paso de una canalización de Azure Machine Learning
figuran los siguientes:
● PythonScriptStep: ejecuta un script de Python especificado.

● DataTransferStep: usa Azure Data Factory para copiar datos entre
almacenes de datos.
● DatabricksStep: ejecuta un cuaderno, un script o un archivo JAR
compilado en un clúster de Databricks.
● AdlaStep: ejecuta un trabajo de U-SQL en Azure Data Lake Analytics.
● ParallelRunStep : ejecuta un script de Python como una tarea
distribuida en varios nodos de proceso.
Nota: Para obtener una lista completa de los tipos de pasos admitidos, consulte la
documentación del paquete azure.pipeline.steps.
Para crear una canalización, primero debe definir cada paso y, después, crear una
canalización que incluya los pasos. La configuración específica de cada paso
depende del tipo de paso. Por ejemplo, el código siguiente define dos pasos
PythonScriptStep para preparar los datos y, a continuación, entrenar un modelo.
Python
Copiar
from azureml.pipeline.steps import PythonScriptStep
# Step to run a Python script

step1 = PythonScriptStep(name = 'prepare data',
source_directory = 'scripts',
script_name = 'data_prep.py',
compute_target = 'aml-cluster')
# Step to train a model

step2 = PythonScriptStep(name = 'train model',
script_name = 'train_model.py',
compute_target = 'aml-cluster')
Después de definir los pasos, puede asignarlos a una canalización y ejecutarlos

como un experimento:
Python
Copiar
from azureml.pipeline.core import Pipeline
# Construct the pipeline

train_pipeline = Pipeline(workspace = ws, steps = [step1,step2])
# Create an experiment and run the pipeline

experiment = Experiment(workspace = ws, name =
'training-pipeline')
pipeline_run = experiment.submit(train_pipeline)
Paso de datos entre los pasos de la

canalización
Completado
100 XP
5 minutos
A menudo, una línea de canalización incluye al menos un paso que depende de la

salida del paso anterior. Por ejemplo, puede usar un paso que ejecute un script de
Python para preprocesar algunos datos, que se deben usar luego en un paso
posterior para entrenar un modelo.
El objeto OutputFileDatasetConfig
El objeto OutputFileDatasetConfig es un tipo especial de conjunto de datos que:
● Hace referencia a una ubicación en un almacén de datos para el

almacenamiento provisional de datos.
● Crea una dependencia de datos entre los pasos de la canalización.
Puede ver un objeto OutputFileDatasetConfig como un almacén intermediario para

los datos que se deben pasar de un paso a un paso posterior.
Entradas y salidas del paso OutputFileDatasetConfig
Para usar un objeto OutputFileDatasetConfig para pasar datos entre pasos, debe
hacer lo siguiente:
1. Defina un objeto llamado OutputFileDatasetConfig que haga referencia

a una ubicación de un almacén de datos. Si no se especifica ningún
almacén de datos explícito, se usará el almacén de datos
predeterminado.
2. Pase el objeto OutputFileDatasetConfig como un argumento de script
en los pasos que ejecutan scripts.
3. Incluya código en esos scripts para escribir en el argumento
OutputFileDatasetConfig como un salida o para leerlo como entrada.
Por ejemplo, el código siguiente define un objeto OutputFileDatasetConfig para los

datos preprocesados que deben pasarse entre los pasos.
Python
Copiar
from azureml.data import OutputFileDatasetConfig
from azureml.pipeline.steps import PythonScriptStep, EstimatorStep
# Get a dataset for the initial data

raw_ds = Dataset.get_by_name(ws, 'raw_dataset')
# Define a PipelineData object to pass data between steps

data_store = ws.get_default_datastore()
prepped_data = OutputFileDatasetConfig('prepped')
# Step to run a Python script
compute_target = 'aml-cluster',
# Script arguments include PipelineData
arguments = ['--raw-ds',
raw_ds.as_named_input('raw_data'),
'--out_folder',
prepped_data])
# Step to run an estimator

# Pass as script argument
arguments=['--training-data',
prepped_data.as_input()])
En los propios scripts, puede obtener una referencia al objeto

OutputFileDatasetConfig desde el argumento de script y usarlo como una carpeta
local.
Python
Copiar
# code in data_prep.py
import argparse
import os

# Get arguments
parser.add_argument('--raw-ds', type=str, dest='raw_dataset_id')
parser.add_argument('--out_folder', type=str, dest='folder')
output_folder = args.folder
# Get input dataset as dataframe

raw_df = run.input_datasets['raw_data'].to_pandas_dataframe()
# code to prep data (in this case, just select specific columns)
prepped_df = raw_df[['col1', 'col2', 'col3']]
# Save prepped data to the PipelineData location

os.makedirs(output_folder, exist_ok=True)
output_path = os.path.join(output_folder, 'prepped_data.csv')
prepped_df.to_csv(output_path)
Reutilización de los pasos de una

canalización
Completado
100 XP
5 minutos
Las canalizaciones con varios pasos de ejecución prolongada pueden tardar mucho
tiempo en completarse. Azure Machine Learning incluye algunas características de
almacenamiento en caché y reutilización para reducir este tiempo.
Administración de la reutilización de la salida del paso

De forma predeterminada, la salida del paso de una ejecución de canalización
anterior se reutiliza sin volver a ejecutar el paso, siempre que el script, el directorio
de origen y otros parámetros del paso no hayan cambiado. La reutilización de pasos
puede reducir el tiempo de ejecución de una canalización, pero puede dar lugar a
resultados obsoletos si no se tienen en cuenta los cambios en los orígenes de datos
posteriores.
Para controlar la reutilización de un paso individual, puede establecer el parámetro

allow_reuse en la configuración del paso, de la siguiente manera:
Python
Copiar
runconfig = run_config,
inputs=[raw_ds.as_named_input('raw_data')],
outputs=[prepped_data],
arguments = ['--folder', prepped_data]),
# Disable step reuse
allow_reuse = False)
Forzado de la ejecución de todos los pasos

Si tiene varios pasos, puede forzar que todos ellos se ejecuten independientemente
de la configuración de reutilización individual estableciendo el parámetro
regenerate_outputs al enviar el experimento de canalización:
Python
Copiar
pipeline_run = experiment.submit(train_pipeline,
regenerate_outputs=True)
Publicación de canalizaciones
Completado
100 XP
5 minutos
Después de crear una canalización, puede publicarla para crear un punto de

conexión de REST mediante el cual la canalización se puede ejecutar a petición.
Publicación de una canalización

Para publicar una canalización, puede llamar a su método de publicación, como se
muestra aquí:
Python
Copiar
published_pipeline = pipeline.publish(name='training_pipeline',
description='Model
training pipeline',
version='1.0')
Como alternativa, puede llamar al método de publicación en una ejecución correcta

de la canalización:
Python
Copiar
# Get the most recent run of the pipeline
pipeline_experiment = ws.experiments.get('training-pipeline')
run = list(pipeline_experiment.get_runs())[0]
# Publish the pipeline from the run

published_pipeline =
run.publish_pipeline(name='training_pipeline',
description='Model
training pipeline',
version='1.0')
Una vez publicada la canalización, puede verla en Estudio de Azure Machine

Learning. También puede determinar el URI de su punto de conexión de la siguiente
manera:
Python
Copiar
rest_endpoint = published_pipeline.endpoint
print(rest_endpoint)
Uso de una canalización publicada

Para iniciar un punto de conexión publicado, realice una solicitud HTTP a su punto
de conexión de REST, pasando un encabezado de autorización con un token para
una entidad de servicio con permiso para ejecutar la canalización y una carga JSON
que especifique el nombre del experimento. La canalización se ejecuta de forma
asincrónica, por lo que la respuesta de una llamada de REST correcta incluye el
identificador de ejecución. Puede usar el identificador de ejecución para realizar el
seguimiento de la ejecución en Estudio de Azure Machine Learning.
Por ejemplo, el siguiente código de Python realiza una solicitud REST para ejecutar
una canalización y muestra el identificador de ejecución devuelto.
Python
Copiar
import requests
response = requests.post(rest_endpoint,
headers=auth_header,
json={"ExperimentName":
"run_training_pipeline"})
run_id = response.json()["Id"]
print(run_id)
Uso de parámetros de canalización
Completado
100 XP
5 minutos
Puede aumentar la flexibilidad de una canalización mediante la definición de

parámetros.
Definición de parámetros para una canalización

Para definir los parámetros de una canalización, cree un objeto PipelineParameter
para cada parámetro y especifique cada parámetro en al menos un paso.
Por ejemplo, podría usar el código siguiente para incluir un parámetro para una tasa
de regularización en el script utilizado por un estimador:
Python
Copiar
from azureml.pipeline.core.graph import PipelineParameter
reg_param = PipelineParameter(name='reg_rate', default_value=0.01)
...

# Pass parameter as script argument
arguments=['--in_folder', prepped_data,
'--reg', reg_param],
inputs=[prepped_data])
Nota
Debe definir los parámetros de una canalización antes de publicarla.
Ejecución de una canalización con un parámetro

Después de publicar una canalización parametrizada, puede pasar los valores de
los parámetros en la carga de JSON para la interfaz de REST:
Python
Copiar
"run_training_pipeline",
"ParameterAssignments":
{"reg_rate": 0.1}})
Programar canalizaciones
Completado
100 XP
5 minutos
Después de haber publicado una canalización, puede iniciarla a petición mediante

su punto de conexión de REST, o bien puede hacer que la canalización se ejecute
automáticamente según una programación periódica o en respuesta a
actualizaciones de datos.
Programación de una canalización para intervalos

periódicos
Para programar una canalización para que se ejecute a intervalos periódicos, debe
definir un objeto ScheduleRecurrence que determine la frecuencia de ejecución y
utilizarlo para crear una programación.
Por ejemplo, el código siguiente programa una ejecución diaria de una canalización
publicada.
Python
Copiar
from azureml.pipeline.core import ScheduleRecurrence, Schedule
daily = ScheduleRecurrence(frequency='Day', interval=1)

pipeline_schedule = Schedule.create(ws, name='Daily Training',
description='trains model
every day',
pipeline_id=published_pipeline.id,
experiment_name='Training_Pipeline',
recurrence=daily)
Desencadenamiento de una ejecución de canalización
con cambios de datos
Para programar la ejecución de una canalización cada vez que cambien los datos,
debe crear una programación que supervise una ruta de acceso especificada en un
almacén de datos, de la siguiente manera:
Python
Copiar
from azureml.core import Datastore
from azureml.pipeline.core import Schedule
training_datastore = Datastore(workspace=ws, name='blob_data')

pipeline_schedule = Schedule.create(ws, name='Reactive Training',
description='trains model on
data change',
experiment_name='Training_Pipeline',
datastore=training_datastore,
path_on_datastore='data/training')
Ejercicio: Creación de una canalización

Completado
100 XP
20 minutos
Ahora tiene la oportunidad de crear y ejecutar una canalización de Azure Machine

Learning.
● Crear una canalización de Azure Machine Learning.

● Publicar una canalización como un servicio de REST.
● Programar una canalización.
Instrucciones
trabajo de Azure Machine Learning para crear un área de trabajo de
Azure Machine Learning, crear una instancia de proceso y clonar los
4. Complete el ejercicio Creación de una canalización.
Implementación de servicios de
aprendizaje automático en tiempo real
con Azure Machine Learning
● Implementar un modelo como servicio de inferencia en tiempo real.

● Consumir un servicio de inferencia en tiempo real.
● Solución de problemas de implementación de servicios
Introducción
Completado
100 XP
2 minutos
En aprendizaje automático, inferencia se refiere al uso de un modelo entrenado para

predecir etiquetas para nuevos datos en los que el modelo no se ha entrenado. A
menudo, el modelo se implementa como parte de un servicio que permite a las
aplicaciones solicitar predicciones inmediatas o, en tiempo real, para observaciones
de datos individuales o en pequeña cantidad.
En Azure Machine Learning, puede crear soluciones de inferencia en tiempo real
implementando un modelo como servicio, hospedado en una plataforma en
contenedor como Azure Kubernetes Services (AKS).
● Implementar un modelo como servicio de inferencia en tiempo real.

● Consumir un servicio de inferencia en tiempo real.
● Solución de problemas de implementación de servicios
Implementación de un modelo como

servicio en tiempo real
Completado
100 XP
5 minutos
Puede implementar un modelo como servicio web en tiempo real en varios tipos de
destino de proceso, incluido el proceso local, una instancia de proceso de Azure
Machine Learning, un servicio de Azure Container Instance (ACI), un clúster de
Azure Kubernetes Service (AKS), una función de Azure o un módulo de Internet de
las cosas (IoT). Azure Machine Learning usa contenedores como mecanismo de
implementación, que empaqueta el modelo y el código para usarlo como una
imagen que se puede implementar en un contenedor del destino de proceso elegido.
Nota
La implementación en un servicio local, una instancia de proceso o un servicio ACI

es una buena elección para las pruebas y el desarrollo. En el caso de producción,
se debe implementar en un destino que cumpla las necesidades específicas de
rendimiento, escalabilidad y seguridad de la arquitectura de la aplicación.
Para implementar un modelo como servicio de inferencia en tiempo real, debe

realizar las siguientes tareas:
1. Registro de un modelo entrenado

Después de entrenar correctamente un modelo, debe registrarlo en el área de
trabajo de Azure Machine Learning. El servicio en tiempo real podrá cargar el
modelo cuando sea necesario.
objeto Model tal y como se muestra aquí:
Python
Copiar
classification_model = Model.register(workspace=ws,
model_path='model.pkl', # local path
description='A classification model')
modelo, puede usar su método register_model, tal y como se muestra aquí:
Python
Copiar

path
2. Definición de una configuración de inferencia

El modelo se implementará como un servicio que consta de:
● Un script para cargar el modelo y devolver predicciones para los datos

enviados.
● Un entorno en el que se ejecutará el script.
Por lo tanto, debe definir el script y el entorno para el servicio.
Creación de un script de entrada
Cree el script de entrada (a veces llamado script de puntuación) para el servicio

como un archivo de Python (.py). Debe incluir dos funciones:
● init(): se llama cuando se inicializa el servicio.

● run(raw_data): se llama cuando se envían nuevos datos al servicio.
Normalmente, se usa la función init para cargar el modelo desde el registro de

modelos y la función run para generar predicciones a partir de los datos de entrada.
En el script de ejemplo siguiente se muestra este patrón:
Python
Copiar
import json
import joblib
import numpy as np
import os
# Called when the service is loaded
def init():
global model
# Get the path to the registered model file and load it
model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'),
'model.pkl')
model = joblib.load(model_path)
# Called when a request is received
def run(raw_data):
# Get the input data as a numpy array
data = np.array(json.loads(raw_data)['data'])
# Get a prediction from the model
predictions = model.predict(data)
# Return the predictions as any JSON serializable format
return predictions.tolist()
Guarde el script en una carpeta para que pueda identificarlo fácilmente en el futuro.
Por ejemplo, puede guardar el script anterior como score.py en una carpeta
denominada service_files.
Creación de un entorno
El servicio requiere un entorno de Python en el que ejecutar el script de entrada, que

puede definir mediante la creación de un entorno que contenga los paquetes
necesarios:
Python
Copiar

service_env = Environment(name='service-env')
python_packages = ['scikit-learn', 'numpy'] # whatever packages

your entry script uses
for package in python_packages:
service_env.python.conda_dependencies.add_pip_package(package)
Combinación del script y el entorno en un InferenceConfig
Después de crear el script de entrada y el entorno, puede combinarlos en un

elemento InferenceConfig para el servicio de la siguiente manera:
Python
Copiar
from azureml.core.model import InferenceConfig
classifier_inference_config = InferenceConfig(source_directory =
'service_files',
entry_script="score.py",
environment=service_env)
3. Definición de una configuración de implementación

Ahora que tiene el script de entrada y el entorno, debe configurar el proceso en el
que se implementará el servicio. Si va a implementar en un clúster de AKS, debe
crear el clúster y un destino de proceso para él antes de la implementación:
Python
Copiar
from azureml.core.compute import ComputeTarget, AksCompute

cluster_name = 'aks-cluster'
compute_config =
AksCompute.provisioning_configuration(location='eastus')
production_cluster = ComputeTarget.create(ws, cluster_name,

compute_config)
production_cluster.wait_for_completion(show_output=True)
Con el destino de proceso creado, ahora puede definir la configuración de

implementación, que establece la especificación de proceso específica del destino
para la implementación en contenedor:
Python
Copiar
from azureml.core.webservice import AksWebservice
classifier_deploy_config =
AksWebservice.deploy_configuration(cpu_cores = 1,
memory_gb = 1)
El código para configurar una implementación de ACI es similar, salvo que no hay
que crear explícitamente un destino de proceso ACI y se debe usar la clase
deploy_configuration del espacio de nombres
azureml.core.webservice.AciWebservice. Del mismo modo, puede usar el espacio
de nombres azureml.core.webservice.LocalWebservice para configurar un servicio
basado en Docker local.
Nota
Para implementar un modelo en una función de Azure, no es necesario crear una

configuración de implementación. En su lugar, debe empaquetar el modelo en
función del tipo de desencadenador de función que quiera usar. Esta funcionalidad
está en versión preliminar en el momento de la redacción de este documento. Para
obtener más información, consulte la sección sobre implementación de un modelo
de aprendizaje automático en Azure Functions en la documentación de Azure
Machine Learning.
4. Implementación del modelo
Una vez preparada la configuración, puede implementar el modelo. La forma más
fácil de hacerlo es llamar al método deploy de la clase Model de la siguiente
manera:
Python
Copiar
from azureml.core.model import Model
model = ws.models['classification_model']
service = Model.deploy(workspace=ws,
name = 'classifier-service',
models = [model],
inference_config =
classifier_inference_config,
deployment_config =
classifier_deploy_config,
deployment_target = production_cluster)
service.wait_for_deployment(show_output = True)
En los servicios locales o de ACI, puede omitir el parámetro deployment_target (o

establecerlo en Ninguno).
Para obtener más información sobre la implementación de modelos con Azure

Machine Learning, consulte Implementación de modelos de Machine Learning en
Azure en la documentación.
Consumo de un servicio de inferencia en

tiempo real
Completado
100 XP
5 minutos
Después de implementar un servicio en tiempo real, puede consumirlo desde las

aplicaciones cliente para predecir las etiquetas para los nuevos casos de datos.
Uso del SDK de Azure Machine Learning

Para las pruebas, puede usar el SDK de Azure Machine Learning para llamar a un
servicio web a través del método run de un objeto WebService que haga referencia
al servicio implementado. Normalmente, los datos se envían al método run en
formato JSON con la siguiente estructura:
JSON
Copiar
"data":[
[0.1,2.3,4.1,2.0], // 1st case
[0.2,1.8,3.9,2.1], // 2nd case,
...
La respuesta del método run es una colección JSON con una predicción para cada
caso que se envió en los datos. En el ejemplo de código siguiente se llama a un
servicio y se muestra la respuesta:
Python
Copiar
import json
# An array of new data cases
x_new = [[0.1,2.3,4.1,2.0],
[0.2,1.8,3.9,2.1]]
# Convert the array to a serializable list in a JSON document
json_data = json.dumps({"data": x_new})
# Call the web service, passing the input data
response = service.run(input_data = json_data)
# Get the predictions
predictions = json.loads(response)
# Print the predicted class for each case.
for i in range(len(x_new)):
print (x_new[i], predictions[i])
Uso de un punto de conexión de REST

En producción, la mayoría de las aplicaciones cliente no incluirán el SDK de Azure
Machine Learning y consumirán el servicio a través de la interfaz de REST. Puede
determinar el punto de conexión de un servicio implementado en Azure Machine
Learning Studio o mediante la recuperación de la propiedad scoring_uri del objeto
WebService en el SDK de la siguiente manera:
Python
Copiar
endpoint = service.scoring_uri
print(endpoint)
Con el punto de conexión conocido, puede usar una solicitud HTTP POST con datos
JSON para llamar al servicio. En el ejemplo siguiente se muestra cómo hacerlo con
Python:
Python
Copiar
import requests
import json
x_new = [[0.1,2.3,4.1,2.0],
[0.2,1.8,3.9,2.1]]
# Set the content type in the request headers
request_headers = { 'Content-Type':'application/json' }
# Call the service
response = requests.post(url = endpoint,
data = json_data,
headers = request_headers)
# Get the predictions from the JSON response
predictions = json.loads(response.json())

print (x_new[i]), predictions[i] )
Authentication
En producción, es probable que quiera restringir el acceso a los servicios aplicando

autenticación. Hay dos tipos de autenticación que puede usar:
● Clave: las solicitudes se autentican especificando la clave asociada con

el servicio.
● Token: las solicitudes se autentican proporcionando un JSON Web
Token (JWT).
De forma predeterminada, la autenticación está deshabilitada para los servicios de

ACI y está establecida en autenticación basada en claves para servicios de AKS
(para la que se generan automáticamente claves principales y secundarias).
Opcionalmente, puede configurar un servicio de AKS para que use la autenticación
basada en token (que no se admite para los servicios de ACI).
Si se tiene una sesión autenticada establecida con el área de trabajo, pueden

recuperarse las claves de un servicio mediante el método get_keys del objeto
WebService asociado al servicio:
Python
Copiar
primary_key, secondary_key = service.get_keys()
En el caso de la autenticación basada en token, la aplicación cliente debe usar la

autenticación de la entidad de seguridad para comprobar su identidad a través de
Azure Active Directory (Azure AD) y llamar al método get_token del servicio para
recuperar un token de tiempo limitado.
Para realizar una llamada autenticada al punto de conexión de REST del servicio,
debe incluir la clave o el token en el encabezado de solicitud de la siguiente manera:
Python
Copiar
import requests
import json
x_new = [[0.1,2.3,4.1,2.0],
[0.2,1.8,3.9,2.1]]
# Set the content type in the request headers
request_headers = { "Content-Type":"application/json",
"Authorization":"Bearer " + key_or_token }
# Call the service
response = requests.post(url = endpoint,
data = json_data,
headers = request_headers)
# Get the predictions from the JSON response
predictions = json.loads(response.json())
print (x_new[i]), predictions[i] )

Solución de problemas de
implementación de servicios
Completado
100 XP
5 minutos
Hay gran cantidad de elementos en una implementación del servicio en tiempo real,
como el modelo entrenado, la configuración del entorno en tiempo de ejecución, el
script de puntuación, la imagen de contenedor y el host del contenedor. La solución
de problemas de una implementación con errores o de un error al consumir un
servicio implementado puede resultar compleja.
Comprobación del estado del servicio

Como paso inicial de la solución de problemas, puede comprobar el estado de un
servicio examinando su estado:
Python
Copiar
from azureml.core.webservice import AksWebservice
# Get the deployed service
service = AksWebservice(name='classifier-service', workspace=ws)
# Check its state
print(service.state)
Nota
Para ver el estado de un servicio, debe usar el tipo de servicio específico del
proceso (por ejemplo AksWebservice) y no un objeto WebService genérico.
En el caso de un servicio operativo, el estado debe ser Correcto.

Revisión de registros de servicios
Si un servicio no funciona correctamente o se experimentan errores al usarlo, puede
revisar sus registros:
Python
Copiar
print(service.get_logs())
Los registros incluyen información detallada sobre el aprovisionamiento del servicio

y las solicitudes que ha procesado. A menudo pueden ofrecer información de la
causa de errores inesperados.
Implementación en un contenedor local

Los errores de implementación y en tiempo de ejecución pueden ser más fáciles de
diagnosticar implementando el servicio como contenedor en una instancia local de
Docker, de la siguiente manera:
Python
Copiar
from azureml.core.webservice import LocalWebservice
deployment_config =
LocalWebservice.deploy_configuration(port=8890)
service = Model.deploy(ws, 'test-svc', [model], inference_config,

deployment_config)
Luego puede probar el servicio implementado localmente mediante el SDK:
Python
Copiar
print(service.run(input_data = json_data))
Después puede solucionar problemas en tiempo de ejecución realizando cambios
en el archivo de puntuación al que se hace referencia en la configuración de
inferencia y volviendo a cargar el servicio sin tener que volver a implementarlo (algo
que solo se puede hacer con un servicio local):
Python
Copiar
service.reload()
print(service.run(input_data = json_data))
Ejercicio: Implementación de un modelo

como servicio en tiempo real
Ahora es su oportunidad de usar Azure Machine Learning para implementar un
modelo de aprendizaje automático como servicio en tiempo real.
● Entrene y registre un modelo.

● Implementará el modelo como servicio en tiempo real.
● Consumirá el servicio implementado.
Instrucciones
Siga estas instrucciones para completar el ejercicio:

4. Complete el ejercicio Creación de un servicio de inferencia en tiempo
real.
Implementación de canalizaciones de
inferencia por lotes con Azure Machine
Learning
Los modelos de Machine Learning se suelen usar para generar predicciones a partir
de un gran número de observaciones en un proceso por lotes. Para ello, puede usar
Azure Machine Learning para publicar una canalización de inferencia por lotes.
Aprenda a crear, publicar y usar canalizaciones de inferencia por lotes con Azure
Machine Learning.
Introducción
En muchos escenarios de producción, las tareas de ejecución prolongada que
operan en grandes volúmenes de datos se realizan como operaciones por lotes. En
el aprendizaje automático, la inferencia por lotes se usa para aplicar un modelo
predictivo a varios casos de forma asincrónica; normalmente escribiendo los
resultados en un archivo o base de datos.
En Azure Machine Learning, puede implementar soluciones de inferencia por lotes
mediante la creación de una canalización que incluya un paso para leer los datos de
entrada, cargar un modelo registrado, predecir etiquetas y escribir los resultados
como salida.
● Publicar la canalización de inferencia por lotes para un modelo

entrenado.
● Usar una canalización de inferencia por lotes para generar predicciones.
Creación de una canalización de

inferencias por lotes
Para crear una canalización de inferencia por lotes, realice las siguientes tareas:
1. Registrar un modelo
Para usar un modelo entrenado en una canalización de inferencia por lotes, debe
registrarlo en el área de trabajo de Azure Machine Learning.
objeto Model tal y como se muestra en el siguiente código de ejemplo:
Python
Copiar
classification_model = Model.register(workspace=your_workspace,
model_path='model.pkl', #
local path
description='A
classification model')
modelo, puede usar su método register_model, tal y como se muestra en el
siguiente código de ejemplo:
Python
Copiar

path
2. Crear un script de puntuación
El servicio de inferencia por lotes requiere un script de puntuación para cargar el

modelo y usarlo para predecir nuevos valores. Debe incluir dos funciones:
● init(): se llama cuando se inicializa la canalización.

● run(mini_batch): se llama para cada lote de datos que se va a procesar.
Normalmente, se usa la función init para cargar el modelo desde el registro de

modelos y la función run para generar predicciones a partir de cada lote de datos y
devolver los resultados. En el script de ejemplo siguiente se muestra este patrón:
Python
Copiar
import os
import numpy as np
import joblib
def init():
# Runs when the pipeline step is initialized
global model
# load the model
model_path = Model.get_model_path('classification_model')
model = joblib.load(model_path)
def run(mini_batch):
# This runs for each batch
resultList = []
# process each file in the batch
for f in mini_batch:
# Read comma-delimited data into an array
data = np.genfromtxt(f, delimiter=',')
# Reshape into a 2-dimensional array for model input
prediction = model.predict(data.reshape(1, -1))
# Append prediction to results
resultList.append("{}: {}".format(os.path.basename(f),
prediction[0]))
return resultList
3. Crear una canalización con una clase

ParallelRunStep
Azure Machine Learning proporciona un tipo de paso de canalización
específicamente para realizar la inferencia por lotes en paralelo. Al usar la clase
ParallelRunStep, puede leer lotes de archivos de un conjunto de datos File y escribir
la salida de procesamiento en OutputFileDatasetConfig. Además, puede establecer
el valor de output_action para el paso en "append_row", lo que garantizará que
todas las instancias del paso que ejecutadas en paralelo intercalarán sus resultados
en un único archivo de salida denominado parallel_run_step.txt:
Python
Copiar
from azureml.pipeline.steps import ParallelRunConfig,

ParallelRunStep
from azureml.data import OutputFileDatasetConfig
from azureml.pipeline.core import Pipeline
# Get the batch dataset for input
batch_data_set = ws.datasets['batch-data']
# Set the output location
output_dir = OutputFileDatasetConfig(name='inferences')
# Define the parallel run step step configuration
parallel_run_config = ParallelRunConfig(
source_directory='batch_scripts',
entry_script="batch_scoring_script.py",
mini_batch_size="5",
error_threshold=10,
output_action="append_row",
environment=batch_env,
compute_target=aml_cluster,
node_count=4)
# Create the parallel run step
parallelrun_step = ParallelRunStep(
name='batch-score',
parallel_run_config=parallel_run_config,
inputs=[batch_data_set.as_named_input('batch_data')],
output=output_dir,
arguments=[],
allow_reuse=True
# Create the pipeline
pipeline = Pipeline(workspace=ws, steps=[parallelrun_step])
4. Ejecutar la canalización y recuperar el resultado del

paso
Una vez definida la canalización, puede ejecutarla y esperar a que se complete. A

continuación, puede recuperar el archivo parallel_run_step.txt de la salida del paso
para ver los resultados, como se muestra en el ejemplo de código siguiente:
Python
Copiar
# Run the pipeline as an experiment

pipeline_run = Experiment(ws,
'batch_prediction_pipeline').submit(pipeline)
pipeline_run.wait_for_completion(show_output=True)
# Get the outputs from the first (and only) step
prediction_run = next(pipeline_run.get_children())
prediction_output = prediction_run.get_output_data('inferences')
prediction_output.download(local_path='results')
# Find the parallel_run_step.txt file
for root, dirs, files in os.walk('results'):
for file in files:
if file.endswith('parallel_run_step.txt'):
result_file = os.path.join(root,file)
# Load and display the results
df = pd.read_csv(result_file, delimiter=":", header=None)
df.columns = ["File", "Prediction"]
print(df)
Publicación de una canalización de

Puede publicar una canalización de inferencia por lotes como un servicio REST, tal
como se muestra en el código de ejemplo siguiente:
Python
Copiar
published_pipeline =
pipeline_run.publish_pipeline(name='Batch_Prediction_Pipeline',
description='Batch pipeline',
version='1.0')
rest_endpoint = published_pipeline.endpoint
Una vez publicada, puede usar el punto de conexión de servicio para iniciar un
trabajo de inferencia por lotes, como se muestra en el código de ejemplo siguiente:
Python
Copiar
import requests
"Batch_Prediction"})
run_id = response.json()["Id"]
También puede programar la canalización publicada para que se ejecute

automáticamente, como se muestra en el código de ejemplo siguiente:
Python
Copiar
from azureml.pipeline.core import ScheduleRecurrence, Schedule
weekly = ScheduleRecurrence(frequency='Week', interval=1)
pipeline_schedule = Schedule.create(ws, name='Weekly Predictions',
description='batch
inferencing',
experiment_name='Batch_Prediction',
recurrence=weekly)
Ejercicio: Crear una canalización de

Ahora tiene la oportunidad de crear y ejecutar una canalización de inferencia por lotes.
● Crear una canalización de inferencia por lotes.

● Publicar la canalización como un servicio REST.
● Ejecutar la canalización a través de su punto de conexión REST.
Instrucciones
1. Si todavía no tiene una suscripción de Azure, suscríbase para disfrutar de una

prueba gratuita en https://azure.microsoft.com.
3. Si todavía no lo ha hecho, complete el ejercicio Creación de un área de trabajo
de Azure Machine Learning para aprovisionar un área de trabajo de Azure
Machine Learning, crear una instancia de proceso y clonar los archivos
necesarios.
4. Realice el ejercicio Crear un servicio de inferencia por lotes.
Resumen
En este módulo ha aprendido a:
● Publicar la canalización de inferencia por lotes para un modelo

entrenado.
● Usar una canalización de inferencia por lotes para generar predicciones.
Ajuste de hiperparámetros con Azure
Machine Learning
Elegir valores óptimos de hiperparámetros para el entrenamiento del modelo puede
ser una tarea difícil y suele implicar una gran cantidad de pruebas y errores. Con
Azure Machine Learning, puede aprovechar los experimentos de escala en la nube
para ajustar los hiperparámetros.
Aprenda a usar los experimentos para ajustar los hiperparámetros de Azure Machine
Learning a fin de optimizar el rendimiento del modelo.
Introducción
En el aprendizaje automático, los modelos se entrenan para predecir etiquetas
desconocidas para los datos nuevos en función de las correlaciones entre las
etiquetas conocidas y las características que se encuentran en los datos de
entrenamiento. Según el algoritmo usado, es posible que tengan que especificar
hiperparámetros para configurar cómo se entrena el modelo. Por ejemplo, el
algoritmo de regresión logística utiliza un hiperparámetro de tasa de regularización
para contrarrestar el sobreajuste. Además, las técnicas de aprendizaje profundo de
las redes neuronal convolucionales (CNN) usan hiperparámetros como la velocidad
de aprendizaje a fin de controlar cómo se ajustan las ponderaciones durante el
entrenamiento y el tamaño del lote para determinar el número de elementos de
datos que se incluyen en cada lote de entrenamiento.
Nota
El aprendizaje profundo es un campo académico con su terminología determinada

propia. Los científicos de datos hacen referencia a los valores que se determinan a
partir de las características de entrenamiento como parámetros, por lo que se
necesita otro término para los valores que se usan para configurar el
comportamiento del entrenamiento y que no se derivan de los datos de
entrenamiento. De ahí nace el término hiperparámetro.
La elección de los valores de hiperparámetro puede afectar de forma significativa al

modelo resultante, lo que hace que sea importante seleccionar los mejores valores
posibles para sus datos concretos y los objetivos de rendimiento predictivo.
Ajuste de hiperparámetros
El ajuste de los hiperparámetros se logra mediante el entrenamiento de varios
modelos, con el mismo algoritmo y los mismos datos de entrenamiento, pero con
distintos valores de hiperparámetros. A continuación, el modelo que resulta de cada
ejecución de entrenamiento se evalúa para determinar la métrica de rendimiento
para la que desea realizar la optimización (por ejemplo, precisión) y se selecciona el
modelo de mejor rendimiento.
En Azure Machine Learning, esto se logra a través de un experimento que consta de

una ejecución de Hyperdrive, que inicia una ejecución secundaria para cada
combinación de hiperparámetro que se va a probar. Cada ejecución secundaria usa
un script de entrenamiento con valores de hiperparámetro parametrizados con el fin
de entrenar un modelo y registra la métrica de rendimiento de destino que logra el
modelo entrenado.
● Definición de un espacio de búsqueda de hiperparámetros.

● Configuración de muestreo de hiperparámetros.
● Selección de una directiva de terminación anticipada.
● Ejecutar un experimento de ajuste de hiperparámetros.
Definición de un espacio de búsqueda
El conjunto de valores de hiperparámetro probado durante el ajuste de los

hiperparámetros se conoce como espacio de búsqueda. La definición del rango de
valores posibles que se pueden elegir depende del tipo de hiperparámetro.
Hiperparámetros discretos
Algunos hiperparámetros requieren valores discretos; en otras palabras, debe
seleccionar el valor de un conjunto determinado de posibilidades. Puede definir un
espacio de búsqueda de un parámetro discreto mediante una opción de una lista de
valores explícitos, que puede definir como una lista de Python (), un rango () o un
conjunto arbitrario de valores separados por comas ().
También puede seleccionar valores discretos de cualquiera de las distribuciones

discretas siguientes:
● qnormal
● quniform
● qlognormal
● qloguniform
Hiperparámetros continuos
Algunos hiperparámetros son continuos; en otras palabras, puede usar cualquier
valor a lo largo de una escala. Si desea definir un espacio de búsqueda para estos
tipos de valor, puede usar cualquiera de los tipos de distribución siguientes:
● normal
● uniforme
● lognormal
● loguniform
Definición de un espacio de búsqueda

Si desea definir un espacio de búsqueda para el ajuste de hiperparámetros, cree un
diccionario con la expresión de parámetro adecuada para cada hiperparámetro con
nombre. Por ejemplo, el espacio de búsqueda siguiente indica que el
hiperparámetro batch_size puede tener el valor 16, 32 o 64, y el hiperparámetro
learning_rate puede tener cualquier valor de una distribución normal con una media
de 10 y una desviación estándar de 3.
Python
Copiar
from azureml.train.hyperdrive import choice, normal
param_space = {
'--batch_size': choice(16, 32, 64),
'--learning_rate': normal(10, 3)
Configuración del muestreo

Los valores específicos que se usan en una ejecución de ajuste de hiperparámetros
dependen del tipo de muestreo que se usa.
Muestreo de cuadrícula
El muestreo de cuadrícula solo se puede utilizar cuando todos los hiperparámetros
son discretos y se usa para probar cada combinación posible de parámetros en el
espacio de búsqueda.
Por ejemplo, en el ejemplo de código siguiente, se usa el muestreo de cuadrícula

para probar todas las combinaciones posibles de los valores discretos batch_size y
learning_rate:
Python
Copiar
from azureml.train.hyperdrive import GridParameterSampling, choice
param_space = {
'--learning_rate': choice(0.01, 0.1, 1.0)

}
param_sampling = GridParameterSampling(param_space)
Muestreo aleatorio
El muestreo aleatorio se usa para seleccionar aleatoriamente un valor para cada
hiperparámetro, que puede ser una combinación de valores discretos y continuos,
tal como se muestra en el ejemplo de código siguiente:
Python
Copiar
from azureml.train.hyperdrive import RandomParameterSampling,

choice, normal
param_space = {
'--learning_rate': normal(10, 3)
param_sampling = RandomParameterSampling(param_space)
Muestreo bayesiano
El muestreo bayesiano elige los valores de hiperparámetro basados en el algoritmo
de optimización bayesiano, que intenta seleccionar combinaciones de parámetros
que mejorarán el rendimiento con respecto a la selección anterior. En el ejemplo de
código siguiente se muestra cómo configurar el muestreo bayesiano:
Python
Copiar
from azureml.train.hyperdrive import BayesianParameterSampling,
choice, uniform
param_space = {
'--learning_rate': uniform(0.05, 0.1)
param_sampling = BayesianParameterSampling(param_space)
Solo puede utilizar el muestreo bayesiano con las expresiones de parámetro choice,
uniformy quniform, y no puede combinarla con una directiva de terminación
anticipada.
Configuración de terminación anticipada

Con un espacio de búsqueda de hiperparámetros suficientemente grande, podría
necesitar muchas iteraciones (ejecuciones secundarias) para probar todas las
combinaciones posibles. Por lo general, se establece un número máximo de
iteraciones, pero esto de todos modos genera un gran número de ejecuciones que
no dan como resultado un modelo mejor que una combinación que ya se intentó.
Para evitar pérdidas de tiempo, puede establecer una directiva de terminación

anticipada que abandone las ejecuciones que probablemente no vayan a generar un
mejor resultado que ejecuciones que se completaron anteriormente. La directiva se
evalúa según el parámetro evaluation_interval que especifique, en función de las
veces que se registra la métrica de rendimiento de destino. También puede
establecer un parámetro delay_evaluation para evitar la evaluación de la directiva
hasta que se haya completado un número mínimo de iteraciones.
Nota
La terminación anticipada resulta especialmente útil en escenarios de aprendizaje

profundo en los que una red neuronal profunda (DNN) se entrena de manera
iterativa durante una serie de épocas. El script de entrenamiento puede informar la
métrica de destino después de cada época y, si la ejecución tiene un rendimiento
considerablemente inferior con respecto a ejecuciones anteriores después del
mismo número de intervalos, se puede abandonar.
Directiva de bandidos
Puede usar una directiva de bandidos para detener una ejecución si la métrica de
rendimiento de destino realiza la mejor ejecución hasta ahora según un margen
especificado.
Python
Copiar
from azureml.train.hyperdrive import BanditPolicy
early_termination_policy = BanditPolicy(slack_amount = 0.2,
evaluation_interval=1,
delay_evaluation=5)
Este ejemplo aplica la directiva para cada iteración después de las cinco primeras y
abandona las ejecuciones en las que la métrica de destino informada es 0,2 o es
peor que la ejecución de mejor rendimiento después del mismo número de
intervalos.
También puede aplicar una directiva de ladrón mediante un factor de margen de

demora, que compara la métrica de rendimiento como una proporción en lugar de
un valor absoluto.
Directiva de mediana de detención

Los abandonos de la directiva de detención de la mediana se ejecutan cuando la
métrica de rendimiento de destino es inferior a la mediana del promedio de
ejecuciones para todas las ejecuciones.
Python
Copiar
from azureml.train.hyperdrive import MedianStoppingPolicy

early_termination_policy =
MedianStoppingPolicy(evaluation_interval=1,
delay_evaluation=5)
Directiva de selección de truncamiento

Una directiva de selección de truncamiento cancela el x % de ejecuciones con
menor rendimiento en cada intervalo de evaluación en función del valor de
truncation_percentage que especificó para X.
Python
Copiar
from azureml.train.hyperdrive import TruncationSelectionPolicy
early_termination_policy =
TruncationSelectionPolicy(truncation_percentage=10,
evaluation_interval=1,
delay_evaluation=5)
Ejecución de un experimento de ajuste

de hiperparámetros
En Azure Machine Learning, puede ejecutar un experimento de Hyperdrive para
ajustar los hiperparámetros.
Creación de un script de entrenamiento para el ajuste

de hiperparámetros
Para ejecutar un experimento de Hyperdrive, debe crear un script de entrenamiento
como lo haría con cualquier otro experimento de entrenamiento, salvo que el script
debe hacer lo siguiente:
● Incluir un argumento para cada hiperparámetro que quiere modificar.

● Registrar la métrica de rendimiento de destino. Esto permite que la
ejecución de Hyperdrive evalúe el rendimiento de las ejecuciones
secundarias que inicia, e identifica la que genera el modelo de mejor
rendimiento.
Por ejemplo, el script de ejemplo siguiente entrena un modelo de regresión logística

con un argumento --regularization para establecer el hiperparámetro de tasa de
regularización y registra la métrica de precisión con el nombre Precisión:
Python
Copiar
import argparse
import joblib
import pandas as pd
import numpy as np
# Get regularization hyperparameter

parser.add_argument('--regularization', type=float,
dest='reg_rate', default=0.01)
reg = args.reg_rate


data = run.input_datasets['training_data'].to_pandas_dataframe()
# Separate features and labels, and split for training/validatiom

X = data[['feature1','feature2','feature3','feature4']].values
y = data['label'].values
test_size=0.30)
# Train a logistic regression model with the reg hyperparameter

# calculate and log accuracy


run.complete()
Nota
Observe que en la clase LogisticRegression de Scikit-Learn, C es el inverso de la

tasa de regularización, por lo que C=1/reg.
Configuración y ejecución de un experimento de

Hyperdrive
Para preparar el experimento de Hyperdrive, debe usar un objeto HyperDriveConfig
para configurar la ejecución del experimento, tal como se muestra en el código de
ejemplo siguiente:
Python
Copiar
from azureml.train.hyperdrive import HyperDriveConfig,
PrimaryMetricGoal
# Assumes ws, script_config and param_sampling are already defined
hyperdrive = HyperDriveConfig(run_config=script_config,
hyperparameter_sampling=param_sampling,
policy=None,
primary_metric_name='Accuracy',
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
max_total_runs=6,
max_concurrent_runs=4)
experiment = Experiment(workspace = ws, name =

'hyperdrive_training')
hyperdrive_run = experiment.submit(config=hyperdrive)
Supervisión y revisión de ejecuciones de Hyperdrive

Puede supervisar los experimentos de Hyperdrive en Estudio de Azure Machine
Learning o mediante el widget RunDetails de instancias de Jupyter Notebook.
El experimento iniciará una ejecución secundaria de cada combinación de

hiperparámetro que se va a probar, y puede recuperar las métricas registradas que
se ejecutan mediante el código siguiente:
Python
Copiar
for child_run in run.get_children():
print(child_run.id, child_run.get_metrics())
También puede enumerar todas las ejecuciones en orden descendente de

rendimiento, como se muestra a continuación:
Python
Copiar
for child_run in
hyperdrive_run.get_children_sorted_by_primary_metric():
print(child_run)
Para recuperar la ejecución de mejor rendimiento, puede usar el código siguiente:

Python
Copiar
best_run = hyperdrive_run.get_best_run_by_primary_metric()
Ejercicio: Ajustar hiperparámetros

Ahora es su oportunidad de ejecutar un experimento de ajuste de hiperparámetros.
● Ejecutar un experimento de ajuste de hiperparámetros.

● Revisar los resultados del experimento.
Instrucciones

4. Complete el ejercicio Ajustar hiperparámetros.
Automatización de la selección de
modelos de Machine Learning con Azure
Machine Learning
Aprenda a usar ML automatizado en Azure Machine Learning para encontrar el
mejor modelo para los datos.
● Use las funciones de ML automatizado de Azure Machine Learning para

determinar el algoritmo de mejor rendimiento para los datos.
● Use ML automatizado para el preprocesamiento de datos durante el
entrenamiento.
● Ejecución de un experimento de aprendizaje automático automatizado.
Introducción
ML automatizado le permite probar varios algoritmos y transformaciones de
preprocesamiento con sus datos. Esto, combinado con un proceso escalable
basado en la nube, permite encontrar el mejor modelo de rendimiento para los datos
sin la enorme cantidad de tiempo de ensayo y error manual que de otro modo sería
necesario.
Azure Machine Learning incluye compatibilidad con el aprendizaje automático

automatizado a través de una interfaz visual de Azure Machine Learning Studio.
Puede usar el SDK de Azure Machine Learning para ejecutar experimentos de
aprendizaje automático automatizado.
● Use las funciones de ML automatizado de Azure Machine Learning para

determinar el algoritmo de mejor rendimiento para los datos.
● Use ML automatizado para el preprocesamiento de datos durante el
entrenamiento.
●
Tareas y algoritmos de ML automatizado

Puede usar aprendizaje automático automatizado en Azure Machine Learning para
entrenar modelos para los siguientes tipos de tareas de aprendizaje automático:
● clasificación
● Regresión
● Previsión de series temporales
Algoritmos específicos de tareas

Azure Machine Learning incluye compatibilidad con numerosos algoritmos usados
comúnmente para realizar estas tareas, entre los que se incluyen:
Algoritmos de clasificación
● Regresión logística
● Máquina de potenciación del gradiente ligera (GBM)
● Árbol de decisión
● Bosque aleatorio
● Bayes naive
● Máquina de vectores de soporte lineal (SVM)
● XGBoost
● Clasificador de redes neuronales profundas (DNN)
● Otras...
Algoritmos de regresión
● Regresión lineal
● Red elástica
● Lazo LARS
● XGBoost
● Otras...
Algoritmos de previsión
● Regresión lineal
● Red elástica
● Lazo LARS
● XGBoost
● Otras...
Más información: puede encontrar una lista completa de los algoritmos admitidos en
Definición de una tarea de aprendizaje automático.
Restricción de la selección de algoritmos

De forma predeterminada, ML automatizado seleccionará aleatoriamente entre toda
la gama de algoritmos para la tarea especificada. Puede optar por bloquear la
selección de algoritmos individuales; esto puede ser útil si sabe que los datos no
son adecuados para un tipo de algoritmo determinado o tiene que cumplir una
directiva que restringe el tipo de algoritmos de aprendizaje automático que puede
usar en su organización.
Preprocesamiento y caracterización
Además de probar una selección de algoritmos, ML automatizado puede aplicar
transformaciones de preprocesamiento a los datos; lo que mejora el rendimiento del
modelo.
Escalado y normalización
ML automatizado aplica escalado y normalización automáticamente a los datos
numéricos, lo que ayuda a evitar que las características a gran escala dominen el
entrenamiento. Durante un experimento de ML automatizado, se aplicarán varias
técnicas de escalado o normalización.
Caracterización opcional
Puede elegir que el aprendizaje automático automatizado aplique el procesamiento
previo de transformaciones, como:
● No se encuentra una imputación de valores para eliminar valores NULL

del conjunto de datos de entrenamiento.
● Codificación de categorías para convertir características de categorías
en indicadores numéricos.
● Colocación de características de cardinalidad alta, como los
identificadores de registro.
● Ingeniería de características (por ejemplo, la derivación de partes de
fecha individuales de características DateTime)
● Otras...
Más información: para más información sobre la compatibilidad con el
procesamiento previo en el aprendizaje automático automatizado,
consulte ¿Qué es el aprendizaje automático automatizado?
Ejecución de experimentos de ML
automatizado
Para ejecutar un experimento de ML automatizado, puede usar la interfaz de usuario
de Azure Machine Learning Studio o enviar un experimento mediante el SDK.
Configuración de un experimento de aprendizaje

automático automatizado
La interfaz de usuario proporciona una manera intuitiva de seleccionar opciones
para el experimento de ML automatizado. Al usar el SDK, tiene mayor flexibilidad y
puede establecer las opciones de los experimentos mediante la clase
AutoMLConfig, tal y como se muestra en el ejemplo siguiente.
Python
Copiar
from azureml.train.automl import AutoMLConfig
automl_run_config = RunConfiguration(framework='python')
automl_config = AutoMLConfig(name='Automated ML Experiment',
task='classification',
primary_metric = 'AUC_weighted',
compute_target=aml_compute,
training_data = train_dataset,
validation_data = test_dataset,
label_column_name='Label',
featurization='auto',
iterations=12,
max_concurrent_iterations=4)
Especificación de los datos de entrenamiento
ML automatizado está diseñado para permitirle simplemente traer sus datos y que
Azure Machine Learning averigüe la mejor manera de entrenar un modelo a partir de
ellos.
Al usar la interfaz de usuario de ML automatizado de Azure Machine Learning

Studio, puede crear o seleccionar un conjunto de datos de Azure Machine Learning
que se usará como entrada para el experimento de ML automatizado.
Al usar el SDK para ejecutar un experimento de ML automatizado, puede enviar los

datos de las siguientes maneras:
● Especifique un conjunto de datos o dataframe de datos de

entrenamiento que incluya las características y la etiqueta que se va a
predecir.
● Opcionalmente, especifique un segundo conjunto de datos o dataframe
de datos de validación que se usará para validar el modelo entrenado.
Si no se proporciona, Azure Machine Learning aplicará la validación
cruzada utilizando los datos de entrenamiento.
O bien:
● Especifique un conjunto de datos, dataframe o matriz numpy de valores

X que contenga las características de entrenamiento, con la
correspondiente matriz y de valores de etiqueta.
● Opcionalmente, especifique un recurso de datos X_valid y y_valid,
dataframes o matrices numpy de los valores X_valid que se van a usar
para la validación.
Especificación de la métrica principal
Una de las opciones más importantes que debe especificar es primary_metric. Se

trata de la métrica de rendimiento de destino para la que se determinará el modelo
óptimo. Azure Machine Learning admite un conjunto de métricas con nombre para
cada tipo de tarea. Para recuperar la lista de métricas disponibles para un tipo de
tarea determinado, puede usar la función get_primary_metrics tal y como se
muestra aquí:
Python
Copiar
from azureml.train.automl.utilities import get_primary_metrics
get_primary_metrics('classification')
Más información: puede encontrar una lista completa de las métricas principales y
sus definiciones en Descripción de los resultados de aprendizaje automático
automatizado.
Envío de un experimento de aprendizaje automático

automatizado
Puede enviar un experimento de aprendizaje automático automatizado como
cualquier otro experimento basado en el SDK.
Python
Copiar
from azureml.core.experiment import Experiment
automl_experiment = Experiment(ws, 'automl_experiment')
automl_run = automl_experiment.submit(automl_config)
Puede supervisar las ejecuciones de experimentos de ML automatizado en Azure
Machine Learning Studio o en el widget RunDetails de instancias de Jupyter
Notebook.
Recuperación de la mejor ejecución y su modelo

Puede identificar fácilmente la mejor ejecución en Azure Machine Learning Studio y
descargar o implementar el modelo que ha generado. Para lograr esto mediante
programación con el SDK, puede usar código como el ejemplo siguiente:
Python
Copiar
best_run, fitted_model = automl_run.get_output()
best_run_metrics = best_run.get_metrics()
for metric_name in best_run_metrics:
metric = best_run_metrics[metric_name]
print(metric_name, metric)
Exploración de los pasos de procesamiento previo

ML automatizado usa canalizaciones de Scikit-learn para encapsular pasos de
preprocesamiento con el modelo. Puede ver los pasos del modelo ajustado que
obtuvo de la mejor ejecución con el código anterior de la siguiente manera:
Python
Copiar
for step_ in fitted_model.named_steps:
print(step_)
Ejercicio: Uso del ML automatizado

Ahora es su oportunidad de usar las funcionalidades de ML automatizado de Azure
Machine Learning para entrenar un modelo de aprendizaje automático.

● Revise el modelo de mejor rendimiento.
Instrucciones

4. Realice el ejercicio Uso del aprendizaje automático automatizado del
SDK.
Nota
También hay un ejercicio denominado Uso del aprendizaje automático

automatizado, en el que puede usar la interfaz visual para el aprendizaje automático
automatizado. También puede hacerlo si quiere explorar el enfoque "sin código".
Análisis de la privacidad diferencial

Los científicos de datos tienen una responsabilidad ética y, a veces, también legal,
de proteger la información confidencial. La privacidad diferencial es un enfoque de
vanguardia que permite realizar análisis útiles, a la vez que protege los valores de
los datos de identificación individual.
Después de completar este módulo, podrá:
● Describir el problema de la privacidad de los datos

● Describir cómo funciona la privacidad diferencial
● Configurar los parámetros de la privacidad diferencial
● Realizar análisis de los datos privados de forma diferencial
InicioSumar
Introducción
Los proyectos de ciencia de datos, incluidos los proyectos de aprendizaje
automático, implican análisis de datos, y dicha información suele incluir datos
personales confidenciales que deben mantenerse privados. En la práctica, la
mayoría de los informes que se publican a partir de los datos incluyen agregaciones
de los datos, lo que puede pensar que proporcionaría cierta privacidad: después de
todo, los resultados agregados no revelan los valores de los datos personales.
Pero considere un caso en el que varios análisis de los datos dan como resultado
agregaciones declaradas que, al combinarse, podrían usarse para trabajar con
información sobre los usuarios del conjunto de datos de origen. Suponga que 10
participantes comparten datos sobre su ubicación y salario, y que se crean dos
informes a partir de dichos datos:
● Un informe del salario agregado que nos indica la media de salarios en

Nueva York, San Francisco y Seattle.
● Un informe de la ubicación del trabajo que nos indica que el 10 % de los
participantes del estudio (es decir, una sola persona) reside en Seattle.
En estos dos informes, podemos determinar fácilmente el salario específico del
participante que reside en Seattle. Cualquier persona que revise ambos estudios y
que resulte conocer a una persona de Seattle que ha participado ahora ya sabe el
salario de dicha persona.
En este módulo, analizará la privacidad diferencial, una técnica que puede ayudar a
proteger los datos personales contra este tipo de exposición.
● Describir el problema de la privacidad de los datos

● Describir cómo funciona la privacidad diferencial
● Configurar los parámetros de la privacidad diferencial
● Realizar análisis de los datos privados de forma diferencial
●
Descripción de la privacidad diferencial

La privacidad diferencial busca proteger los valores de los datos personales
mediante la incorporación de "ruido" estadístico al proceso de análisis. Los cálculos
necesarios para formar ruido son complejos, pero el principio es bastante intuitivo: el
ruido garantiza que las agregaciones de datos permanezcan estadísticamente
coherentes con los valores de datos reales, lo que permite una variación aleatoria,
pero dificulta trabajar con los valores individuales de los datos agregados. Además,
el ruido es diferente para cada análisis, por lo que los resultados son no
deterministas; en otras palabras, dos análisis que realizan la misma agregación
pueden generar resultados ligeramente diferentes.
Configuración de los parámetros de
privacidad de los datos
Una manera de que una persona pueda proteger sus datos personales consiste
simplemente en no participar en un estudio; es decir, lo que se conoce como
"rechazar" la participación. Sin embargo, hay algunas consideraciones para esto
como solución:
● Incluso si decide rechazar su participación en un estudio, es posible que

se produzcan resultados que le afecten. Por ejemplo, puede rechazar
su participación en un estudio en el que se comparen los diagnósticos
de enfermedades cardíacas en un grupo de personas, partiendo de la
base de que, si participa, se pueda revelar un diagnóstico de
enfermedad cardíaca que provoque la subida de las primas de su
seguro de salud. Si el estudio encuentra una correlación entre las
personas que beben café y un riesgo más alto de padecer una
enfermedad cardíaca, y su compañía de seguros se entera de que toma
café, su tarifa puede aumentar aunque no haya participado
personalmente en el estudio.
● Las ventajas de la participación en el estudio pueden superar cualquier
impacto negativo. Por ejemplo, si le pagan 100 USD por participar en un
estudio que provoca una subida de 10 USD al año en la tarifa de su
seguro de salud, deberán transcurrir más de 10 años para tener una
pérdida neta. Puede tratarse de una compensación rentable, sobre
todo, ante la posibilidad de que su tarifa suba a raíz del estudio aunque
no participe.
● La única forma de que la opción de rechazar la participación funcione
para todos es que nadie participe, en cuyo caso, el estudio en general
no tiene sentido.
La cantidad de variación causada por agregar ruido se puede configurar a través de

un parámetro denominado épsilon. Este valor determina el riesgo adicional de que
se puedan identificar sus datos personales al rechazar la participación en un estudio
y al participar en él. Lo principal es que aplica este principio de privacidad para
todos los que participan en el estudio. Un valor de épsilon inferior proporciona la
máxima privacidad, a costa de menos precisión al agregar los datos. Un valor de
épsilon más alto produce agregaciones que son más fieles a la distribución de datos
real, aunque la contribución individual de una única persona al valor agregado
queda menos disimulada por el ruido.
Ejercicio: uso de la privacidad

diferencial
Ahora tiene la oportunidad de explorar la privacidad diferencial por sí mismo
mediante el paquete SmartNoise.
● Use SmartNoise para generar análisis privados de forma diferencial.

● Use SmartNoise para enviar consultas privadas de forma diferencial.
Instrucciones

4. Complete el ejercicio Análisis de la privacidad diferencial.
Definición de los modelos de Machine

Learning con Azure Machine Learning
Muchas de las decisiones que toman hoy en día las organizaciones y los sistemas
automatizados se basan en predicciones realizadas por modelos de Machine
Learning. Cada vez es más importante comprender los factores que influyen en los
modelos de predicción.
Descubra cómo explicar los modelos calculando e interpretando la importancia de
las características.
Introducción
A medida que el aprendizaje automático se hace cada vez más importante para las
decisiones que afectan a la salud, la seguridad, el bienestar económico y otros
aspectos de la vida de las personas, es importante comprender cómo realizan las
predicciones los modelos y poder explicar la lógica de las decisiones basadas en el
aprendizaje automático.
Explicar los modelos es difícil, debido al intervalo de tipos de algoritmos de

aprendizaje automático y la naturaleza del funcionamiento de ese aprendizaje, pero
la interpretación de los modelos se ha convertido en un elemento clave para ayudar
a explicar las predicciones con modelos.
● Interpretar la importancia de las características globales y locales.

● Utilizar un explicador para interpretar un modelo.
● Crear explicaciones de modelos en un experimento de entrenamiento.
● Visualizar las explicaciones del modelo.
Importancia de característica
Los explicadores de los modelos usan técnicas estadísticas para calcular la
importancia de las características. Esto le permite cuantificar la influencia relativa
que tiene cada característica del conjunto de datos de entrenamiento en la
predicción de la etiqueta. Los explicadores evalúan un conjunto de datos de prueba
de casos de características y las etiquetas que el modelo les predice.
Importancia de las características globales
La importancia de las características globales cuantifica la importancia relativa de

cada característica como un todo en el conjunto de datos de prueba. Proporciona
una comparación general del abasto en que cada característica del conjunto de
dados influye en la predicción.
Por ejemplo, un modelo de clasificación binaria para predecir el riesgo de crédito

podría entrenarse con características como el importe del préstamo, los ingresos, el
estado civil y la edad para predecir una etiqueta de 1 para los préstamos que es
probable que se paguen y 0 para los préstamos que tienen un riesgo significativo de
no pagarse (y, por lo tanto, no se deberían aprobar). Un explicador podría usar un
conjunto de datos de prueba suficientemente representativo para generar los
siguientes valores de importancia de las características globales:
ingresos: 0,98
importe del préstamo: 0,67
edad: 0,54
estado civil 0,32
Gráfico de la importancia de las características globales

A partir de estos valores, queda claro que en lo que respecta a las predicciones
generales generadas por el modelo para el conjunto de datos de prueba, los
ingresos son la característica más importante para predecir si un prestatario
devolverá el préstamo o no, seguidos por el importe del préstamo, la edad y, por
último, el estado civil.
Importancia de las características locales
La importancia de las características locales mide la influencia del valor de cada

característica para una predicción individual específica.
Por ejemplo, supongamos que Sam pide un préstamo, que el modelo de Machine
Learning aprueba (prediciendo que Sam va a amortizarlo). Puede usar un explicador
a fin de calcular la importancia de la característica local para que la aplicación de
Sam determine qué factores han influido en la predicción. Puede ser que obtenga un
resultado como este:
Característica A favor de 0 A favor de 1
importe del préstamo -0,9 0.9
ingresos -0,6 0.6
age 0,2 -0,2
estado civil -0,1 0,1
Como se trata de un modelo de clasificación, cada característica adquiere un valor

de importancia local para cada clase posible, lo que indica la cantidad de respaldo a
esa clase en función del valor de la característica. Como se trata de un modelo de
clasificación binario, solo hay dos clases posibles (0 y 1). El respaldo de cada
característica a los resultados de una clase produce un nivel de respaldo
correlativamente negativo para la otra.
Gráfico de la importancia de las características locales
En el caso de Sam, el respaldo total a la clase 0 es -1,4, mientras que el respaldo

para la clase 1 es, en consecuencia, 1,4. Como el respaldo a la clase 1 es mayor
que para la clase 0, el préstamo se aprueba. La característica más importante para
una predicción de clase 1 es el importe del préstamo, seguido de los ingresos. Es el
orden contrario a los valores de importancia de las características globales (que
indican que los ingresos son el factor más importante para la muestra de datos en
su conjunto). Puede haber varios motivos que expliquen por qué la importancia local
de una predicción individual varía con relación a la importancia global de un
conjunto de datos global. Por ejemplo, Sam podría tener menores ingresos que la
media, pero el importe del préstamo en ese caso podría ser inusualmente pequeño.
En un modelo de clasificación de varias clases, se calculan los valores de

importancia local en cada clase posible para cada característica, siempre que el
total de todas las clases siempre sea 0. Por ejemplo, un modelo puede predecir la
especie de un pingüino basándose en características como la longitud y la anchura
del pico, la longitud de las aletas y el peso. Supongamos que hay tres especies de
pingüino, por lo que el modelo predice una de las tres etiquetas de clase (0, 1 o 2).
En el caso de una predicción individual, la característica de la longitud del pico
podría tener valores de importancia local de 0,5 para la clase 0, de 0,3 para la clase
1 y de -0,8 para la clase 2, lo que indicaría que la longitud del pico respalda
moderadamente una predicción de la clase 0, en menor medida una predicción de
clase 1 y en gran medida la predicción que ese pingüino en cuestión no es de clase
2.
Para un modelo de regresión, no hay ninguna clase, por lo que los valores de
importancia local simplemente indican el nivel de influencia que cada característica
tiene en la etiqueta escalar de predicción.
Uso de explicadores
Puede usar el SDK de Azure Machine Learning para crear explicadores de modelos,
aunque no se hayan entrenado con un experimento de Azure Machine Learning.
Creación de un explicador
Para interpretar un modelo local, debe instalar el paquete azureml-interpret y usarlo
para crear un explicador. Hay muchos tipos de explicador, entre ellos:
● MimicExplainer: un explicador que crea un modelo de suplente global

que se aproxima al modelo entrenado y se puede usar para generar
explicaciones. Este modelo explicable debe tener el mismo tipo de
arquitectura que el modelo entrenado (por ejemplo, lineal o basada en
árbol).
● TabularExplainer: un explicador que actúa como un contenedor en torno
a los distintos algoritmos del explicador de SHA, eligiendo
automáticamente el que sea más adecuado para la arquitectura del
modelo.
● PFIExplainer: un explicador de la importancia de la característica de
permutación que analiza la importancia de las características
mezclando los valores de las características y midiendo el impacto en el
rendimiento de la predicción.
En el ejemplo de código siguiente se muestra cómo crear una instancia de cada uno
de estos tipos de explicador para un modelo hipotético denominado
modelo_préstamo:
Python
Copiar
# MimicExplainer
from interpret.ext.blackbox import MimicExplainer
from interpret.ext.glassbox import DecisionTreeExplainableModel
mim_explainer = MimicExplainer(model=loan_model,
initialization_examples=X_test,
explainable_model =
DecisionTreeExplainableModel,
features=['loan_amount','income','age','marital_status'],
classes=['reject', 'approve'])
# TabularExplainer
from interpret.ext.blackbox import TabularExplainer

tab_explainer = TabularExplainer(model=loan_model,
initialization_examples=X_test,
# PFIExplainer
from interpret.ext.blackbox import PFIExplainer
pfi_explainer = PFIExplainer(model = loan_model,
Explicación de la importancia de las características

globales
Para recuperar los valores de importancia global de las características del modelo,
llame al método explain_global() del explicador para obtener una explicación global
y, después, use el método get_feature_importance_dict() para obtener un
diccionario de los valores de importancia de las características. En el ejemplo de
código siguiente, se muestra cómo recuperar la importancia de la característica
global:
Python
Copiar
# MimicExplainer
global_mim_explanation = mim_explainer.explain_global(X_train)
global_mim_feature_importance =
global_mim_explanation.get_feature_importance_dict()
# TabularExplainer
global_tab_explanation = tab_explainer.explain_global(X_train)
global_tab_feature_importance =
global_tab_explanation.get_feature_importance_dict()
# PFIExplainer
global_pfi_explanation = pfi_explainer.explain_global(X_train,
y_train)
global_pfi_feature_importance =
global_pfi_explanation.get_feature_importance_dict()
Nota
El código es el mismo para MimicExplainer y TabularExplainer. PFIExplainer

requiere las etiquetas reales que corresponden a las características de prueba.
Explicación de la importancia de las características

locales
Para recuperar la importancia de la característica local desde MimicExplainer o
TabularExplainer, debe llamar al método explain_local() de su explicador,
especificando el subconjunto de casos que quiere explicar. Después, puede usar los
métodos get_ranked_local_names() y get_ranked_local_values() para recuperar los
diccionarios de los nombres de las características y los valores de importancia,
clasificados por importancia. En el ejemplo de código siguiente, se muestra cómo
recuperar la importancia de la característica local:
Python
Copiar
# MimicExplainer
local_mim_explanation = mim_explainer.explain_local(X_test[0:5])
local_mim_features =
local_mim_explanation.get_ranked_local_names()
local_mim_importance =
local_mim_explanation.get_ranked_local_values()
# TabularExplainer
local_tab_explanation = tab_explainer.explain_local(X_test[0:5])
local_tab_features =
local_tab_explanation.get_ranked_local_names()
local_tab_importance =
local_tab_explanation.get_ranked_local_values()
Nota
El código es el mismo para MimicExplainer y TabularExplainer. PFIExplainer no es

compatible con las explicaciones de importancia de las características locales.
Creación de explicaciones
Cuando se usa un estimador o un script para entrenar un modelo en un experimento
de Azure Machine Learning, puede crear un explicador y cargar la explicación que
genera en la ejecución para su posterior análisis.
Creación de una explicación en el script del

experimento
Para crear una explicación en el script del experimento, deberá asegurarse de que
los paquetes azureml-interpret y azureml-entrib-interpret estén instalados en el
entorno de ejecución. Después, puede usarlas para crear una explicación a partir
del modelo entrenado y cargarlo en las salidas de ejecución. En el ejemplo de
código siguiente se muestra de qué forma puede incorporarse el código en un script
de experimento para generar y cargar una explicación del modelo.
Python
Copiar
# Import Azure ML run library
from azureml.core.run import Run
from azureml.contrib.interpret.explanation.explanation_client
import ExplanationClient
from interpret.ext.blackbox import TabularExplainer
# other imports as required
# code to train model goes here
# Get explanation
explainer = TabularExplainer(model, X_train, features=features,

classes=labels)
explanation = explainer.explain_global(X_test)
# Get an Explanation Client and upload the explanation
explain_client = ExplanationClient.from_run(run)
explain_client.upload_model_explanation(explanation,
comment='Tabular Explanation')
# Complete the run
run.complete()
Visualización de la explicación
Puede ver la explicación que ha creado para el modelo en la pestaña Explicaciones
para la ejecución en Azure Machine Learning Studio.
También puede usar el objeto ExplanationClient para descargar la explicación en

Python.
Python
Copiar
from azureml.contrib.interpret.explanation.explanation_client
import ExplanationClient
client = ExplanationClient.from_run_id(workspace=ws,
experiment_name=experiment.experiment_name,
run_id=run.id)
explanation = client.download_model_explanation()
feature_importances = explanation.get_feature_importance_dict()
Visualización de explicaciones
Las explicaciones del modelo en el Estudio de Azure Machine Learning incluyen
varias visualizaciones que puede usar para explorar la importancia de las
características.
Nota
Las visualizaciones solo están disponibles para las ejecuciones de experimentos

configurados para generar y cargar explicaciones. Al usar el aprendizaje automático
automatizado, solo se generarán explicaciones de manera predeterminada para la
ejecución que produzca el mejor modelo.
Visualización de la importancia de las características

globales
La primera visualización de la pestaña Explicaciones para una ejecución muestra la
importancia de la característica global.
Puede usar el control deslizante para mostrar solo las N principales características.
Visualización de la importancia del resumen

Al cambiar a la visualización de la importancia del resumen, se muestra la
distribución de valores de importancia individuales para cada característica en el
conjunto de datos de prueba.
Puede ver las características como un diagrama de enjambre (como se muestra

arriba), un diagrama de caja o un diagrama de violín.
Visualización de la importancia de las características

locales
Al seleccionar un punto de datos individual, se muestra la importancia de la
característica local del caso al que pertenece el punto de datos.
Ejercicio: Interpretar modelos
Ahora tiene la oportunidad de interpretar los modelos.
● Generar importancia de la característica de un modelo.

● Generar explicaciones como parte de un experimento de entrenamiento
del modelo.
Instrucciones

4. Realice el ejercicio Interpretar modelos.
Detección y mitigación de la parcialidad
en los modelos con Azure Machine
Learning
A menudo, los modelos de Machine Learning pueden encapsular un sesgo
involuntario que tiene como resultado la parcialidad. Con Fairlearn y Azure Machine
Learning, puede detectar y mitigar la parcialidad de los modelos.
● Cómo evaluar la imparcialidad de los modelos de Machine Learning.

● Cómo mitigar la disparidad predictiva en un modelo de Machine
Learning.
Introducción
Los modelos de Machine Learning se utilizan cada vez más para fundamentar
decisiones que afectan a la vida de las personas. Por ejemplo, una predicción
realizada por un modelo de Machine Learning podría influir en lo siguiente:
● Aprobación de préstamos, seguros u otros servicios financieros.

● Aceptación en un centro educativo o universitario.
● Idoneidad para una prueba médica o un tratamiento experimental.
● Inclusión en una promoción de marketing.
● Selección para un empleo o un ascenso.
Con estas decisiones tan importantes en el aire, se debe confiar en que los modelos
de Machine Learning predigan y no discriminen subconjuntos de la población por
factores étnicos, de género, de edad, etc.
● Evaluar la imparcialidad de los modelos de Machine Learning.

● Mitigar la disparidad predictiva en un modelo de Machine Learning.
La imparcialidad en los modelos

Cuando se considera el concepto de imparcialidad en lo que respecta a las
predicciones realizadas por los modelos de Machine Learning, resulta útil aclarar lo
que se entiende por "equitativo".
Por ejemplo, imagine un modelo de clasificación que se usa para predecir la

probabilidad de devolver un préstamo y, por tanto, influye en si el préstamo se
concede o no. Es probable que el modelo se entrene con características que reflejen
las características del solicitante, como por ejemplo:
● Age
● Situación laboral
● Income
● Cuenta de ahorro
● Deuda actual
Estas características se utilizan para entrenar un modelo de clasificación binaria que

predice si un solicitante va a devolver un préstamo.
Imagine que el modelo predice que aproximadamente el 45 % de los solicitantes
amortizarán correctamente los préstamos. Pero al revisar los registros de
aprobación de los préstamos, comienza a sospechar que se aprueban menos
préstamos para solicitantes de 25 años o menos que para los mayores de 25.
¿Cómo puede estar seguro de que el modelo es equitativo para los candidatos de
ambos grupos de edad?
Medición de la disparidad en las predicciones

Una manera de empezar a evaluar la imparcialidad de un modelo consiste en
comparar las predicciones para cada grupo con una característica confidencial. En
el modelo de aprobación de préstamos, la edad es una característica confidencial
que interesa, por lo que los datos se podrían dividir en subconjuntos para cada
grupo de edad y comparar la probabilidad de selección (la proporción de
predicciones positivas) de cada grupo.
Imagine que descubre que el modelo predice que el 36 % de los solicitantes de 25
años o menos devolverá un préstamo, pero que se predicen devoluciones correctas
para el 54 % de los solicitantes de más de 25 años. Hay una disparidad del 18 % en
las predicciones.
A primera vista, esta comparación parece confirmar que hay un sesgo en el modelo
que discrimina a los solicitantes más jóvenes. Pero si se considera la población en
su conjunto, es posible que las personas más jóvenes generalmente dispongan de
menos ingresos que otras con profesiones más establecidas, que tengan niveles
inferiores de ahorro y recursos, y una mayor proporción de incumplimiento de las
condiciones del préstamo.
El aspecto importante que se debe tener en cuenta es que, como el objetivo es

asegurar la imparcialidad en lo que respecta a la edad, no implica necesariamente
que esa edad no sea un factor relacionado con la probabilidad de devolver el
préstamo. Es posible que, en general, las personas más jóvenes tengan menos
probabilidades de devolver un préstamo que las de mayor edad. Para ver el cuadro
completo, es necesario profundizar más en el rendimiento predictivo del modelo
para cada subconjunto de la población.
Medición de la disparidad en el rendimiento de la

predicción
Cuando se entrena un modelo de Machine Learning mediante una técnica
supervisada, como las de regresión o clasificación, se usan métricas logradas con
datos de validación de retención para evaluar el rendimiento predictivo global del
modelo. Por ejemplo, podría evaluar un modelo de clasificación en función de la
precisión o la coincidencia.
Para evaluar la imparcialidad de un modelo, puede aplicar la misma métrica de

rendimiento predictivo a subconjuntos de los datos, en función de las características
confidenciales por las que se agrupe la población, y medir la disparidad de esas
métricas entre los subgrupos.
Por ejemplo, imagine que el modelo de aprobación de préstamos exhibe una

métrica de coincidencia general de 0,67, es decir, identifica correctamente el 67 %
de los casos en los que el solicitante ha devuelto el préstamo. La duda es si el
modelo ofrece o no una proporción similar de predicciones correctas para otros
grupos de edad.
Para averiguarlo, los datos se agrupan en función de la característica confidencial

(Edad) y se mide la métrica de rendimiento predictivo (coincidencia) de esos grupos.
Después, se pueden comparar las puntuaciones de la métrica para determinar la
disparidad entre ellas.
Imagine que la coincidencia de los casos de validación en los que el solicitante tiene
25 años o menos es 0,50 y 0,83 para los casos en los que el solicitante es mayor de
25 años. Es decir, el modelo ha identificado correctamente el 50 % de las personas
del grupo de edad de 25 años o menos que han devuelto un préstamo (y, por tanto,
ha clasificado incorrectamente al otro 50 % como impagos del préstamo), pero ha
detectado al 83 % de los que han pagado en el grupo de mayor edad (solo se
clasifica de forma incorrecta el 17 %). La disparidad en el rendimiento de la
predicción entre los grupos es del 33 %; el modelo predice significativamente más
falsos negativos para el grupo de edad más joven.
Posibles causas de la disparidad
Cuando encuentre una disparidad en las proporciones de predicción o las métricas
de rendimiento de predicción en grupos de características confidenciales, merece la
pena evaluar las causas posibles. Entre ellas se incluyen:
● Desequilibrio de datos. Es posible que algunos grupos tengan un

exceso de representación en los datos de entrenamiento, o que los
datos estén sesgados de forma que los casos de un grupo concreto no
representen la población total.
● Correlación indirecta. Es posible que la propia característica
confidencial no sea predictiva de la etiqueta, pero puede haber una
correlación oculta entre la característica confidencial y otra que influya
en la predicción. Por ejemplo, es probable que haya una correlación
entre la edad y el historial de crédito, y entre el historial de crédito y los
incumplimientos de devolución del préstamo. Si la característica de
historial de crédito no se incluye en los datos de entrenamiento, el
algoritmo de entrenamiento puede asignar un peso predictivo a la edad
sin tener en cuenta el historial de crédito, lo que podría marcar la
diferencia en la probabilidad de devolución del préstamo.
● Sesgos sociales. Los sesgos subconscientes en el proceso de
recopilación, preparación o modelado de datos pueden haber influido en
la selección de características u otros aspectos del diseño del modelo.
Mitigación del sesgo

La optimización de la imparcialidad en un modelo de Machine Learning es un
desafío socio técnico. Es decir, no siempre es algo que se pueda conseguir
simplemente mediante la aplicación de correcciones técnicas a un algoritmo de
entrenamiento. Pero se pueden adoptar algunas estrategias para mitigar el sesgo,
entre las que se incluyen las siguientes:
● Equilibre los datos de entrenamiento y validación. Puede aplicar

técnicas de sobremuestreo y submuestreo para equilibrar los datos y
usar algoritmos de división estratificada para mantener proporciones
representativas para el entrenamiento y la validación.
● Realice una amplia selección de características y análisis de ingeniería.
Asegúrese de explorar en su totalidad las correlaciones interconectadas
en los datos para intentar diferenciar las características que se puedan
predecir directamente de las que encapsulan relaciones más complejas
y con matices. Puede usar la compatibilidad de interpretación de
modelos en Azure Machine Learning para entender cómo influyen las
características individuales en las predicciones.
● Evalúe la disparidad de los modelos en función de características
significativas. El sesgo de un modelo no se puede resolver fácilmente si
no se puede cuantificar.
● Intercambie el rendimiento predictivo general por la menor disparidad
del rendimiento predictivo entre grupos de características
confidenciales. Un modelo con una precisión del 99,5 % con un
rendimiento comparable en todos los grupos suele ser más conveniente
que un modelo con una precisión del 99,9 % pero que discrimine a un
subconjunto determinado de casos.
En el resto de este módulo, se explora el paquete Fairlearn, un paquete de Python

que puede usar para evaluar y mitigar la parcialidad en los modelos de Machine
Learning.
Análisis de la imparcialidad de los

modelos con Fairlearn
Fairlearn es un paquete de Python que puede usar para analizar modelos y evaluar
la disparidad entre las predicciones y el rendimiento de la predicción para una o más
características confidenciales.
Para funcionar, calcula métricas de grupo para las características confidenciales que
especifique. Las propias métricas se basan en métricas estándar de evaluación de
modelos de Scikit-learn, como la precisión o la coincidencia para los modelos de
clasificación.
La API de Fairlearn es extensa y ofrece varias maneras de explorar la disparidad en

las métricas entre grupos de características confidenciales. Para un modelo de
clasificación binaria, puede empezar por comparar la proporción de selección (el
número de predicciones positivas para cada grupo) mediante la función
selection_rate. Esta función devuelve la proporción de selección global del conjunto
de datos de pruebas. También puede usar las funciones estándar sklearn.metrics
(como accuracy_score, precision_score o recall_score) para obtener una visión
general del funcionamiento del modelo.
Después, puede definir una o más características confidenciales en el conjunto de

datos con las que quiera agrupar subconjuntos de la población y comparar la
proporción de selección y el rendimiento predictivo. Fairlearn incluye una función
MetricFrame que le permite crear un marco de datos de varias métricas por grupo.
Por ejemplo, en un modelo de clasificación binaria para la predicción de devolución
de préstamos, donde la característica confidencial Age (Edad) está formada por dos
valores de categorías posibles (25-and-under y over-25), un objeto MetricFrame
para estos grupos podría ser similar a la tabla siguiente:
Age selection_rate accuracy Coincidencia Precisión
25 años o menos 0,298178 0,89619 0,825926 0,825926
Más de 25 0,708995 0,888889 0,937984 0,902985
Visualización de métricas en un panel

A menudo, es más fácil comparar las métricas visualmente, por lo que Fairlearn
proporciona un widget de panel interactivo que puede usar en un cuaderno para
mostrar las métricas de grupo de un modelo. El widget permite elegir una
característica confidencial y una métrica de rendimiento para compararlas y,
después, calcula y visualiza las métricas y la disparidad, de la siguiente manera:
Mitigación de la parcialidad con Fairlearn

Además de permitir analizar la disparidad en las proporciones de selección y el
rendimiento predictivo entre características confidenciales, Fairlearn proporciona
compatibilidad para mitigar la parcialidad en los modelos.
Algoritmos de mitigación y restricciones de paridad

La compatibilidad con la mitigación en Fairlearn se basa en el uso de algoritmos
para crear modelos alternativos que aplican restricciones de paridad para generar
métricas comparables entre grupos de características confidenciales. Fairlearn
admite las técnicas de mitigación siguientes.
Técnica Descripción Compatibilidad
con tipos de
modelo
Degradado Una técnica de reducción que aplica un enfoque Clasificación y

exponencial de minimización de costos para obtener el regresión
equilibrio óptimo entre el rendimiento predictivo binarias
general y la disparidad de imparcialidad
Búsqueda Una versión simplificada del algoritmo de Clasificación y

de degradado exponencial que funciona de forma regresión
cuadrícula eficaz con un pequeño número de restricciones binarias
Optimizador Una técnica de posprocesamiento que aplica Clasificación

de umbral una restricción a un clasificador existente, y binaria
transforma la predicción según corresponda.
La elección de la restricción de paridad depende de la técnica que se use y de los

criterios de imparcialidad específicos que se quieran aplicar. Entre las restricciones
de Fairlearn se incluyen las siguientes:
● Paridad demográfica: use esta restricción con cualquiera de los

algoritmos de mitigación para minimizar la disparidad en la proporción
de selección entre los grupos de características confidenciales. Por
ejemplo, en un escenario de clasificación binaria, esta restricción intenta
asegurarse de que se realiza el mismo número de predicciones
positivas en cada grupo.
● Paridad de proporción de verdaderos positivos: use esta restricción con
cualquiera de los algoritmos de mitigación para minimizar la disparidad
en la proporción de verdaderos positivos entre los grupos de
características confidenciales. Por ejemplo, en un escenario de
clasificación binaria, esta restricción intenta asegurarse de que cada
grupo contiene una proporción comparable de predicciones de
verdaderos positivos.
● Paridad de proporción de falsos positivos: use esta restricción con
cualquiera de los algoritmos de mitigación para minimizar la disparidad
en la proporción de falsos positivos entre los grupos de características
confidenciales. Por ejemplo, en un escenario de clasificación binaria,
esta restricción intenta asegurarse de que cada grupo contiene una
proporción comparable de predicciones de falsos positivos.
● Probabilidades ecualizadas: use esta restricción con cualquiera de los
algoritmos de mitigación para minimizar la disparidad en la proporción
combinada de verdaderos positivos y falsos positivos entre los grupos
de características confidenciales. Por ejemplo, en un escenario de
clasificación binaria, esta restricción intenta asegurarse de que cada
grupo contiene una proporción comparable de predicciones de
verdaderos positivos y falsos positivos.
● Paridad de la tasa de errores: use esta restricción con cualquiera de los
algoritmos de mitigación basados en la reducción (Degradado
exponencial y Búsqueda de cuadrícula) a fin de asegurarse de que el
error para cada grupo de características confidenciales no se desvía de
la tasa de errores total en más de una cantidad especificada.
● Pérdida de grupos limitada: use esta restricción con cualquiera de los
algoritmos de mitigación basados en la reducción para limitar la pérdida
de cada grupo de características confidenciales en un modelo de
regresión.
Entrenamiento y evaluación de modelos mitigados

Un enfoque común para la mitigación consiste en usar uno de los algoritmos y las
restricciones para entrenar varios modelos y, después, comparar sus métricas de
rendimiento, proporción de selección y disparidad a fin de determinar el modelo
óptimo para las necesidades. A menudo, la elección del modelo implica un equilibrio
entre el rendimiento predictivo sin procesar y la imparcialidad, en función de lo que
se defina como imparcialidad para un escenario determinado. Por lo general, la
imparcialidad se mide por una reducción en la disparidad de la selección de
características (por ejemplo, asegurarse de que a una proporción igual de miembros
de cada grupo de género se le concede un préstamo bancario), o bien por una
reducción en la disparidad de la métrica de rendimiento (por ejemplo, asegurarse de
que un modelo tiene la misma precisión a la hora de identificar los que pagan el
préstamo y los que no en cada grupo de edad).
Fairlearn le permite entrenar modelos mitigados y visualizarlos mediante el panel de

esta forma:
Puede seleccionar un modelo individual en el diagrama de dispersión para ver sus
detalles, lo que le permite explorar las opciones y seleccionar el mejor modelo para
los requisitos de imparcialidad.
Integración con Azure Machine Learning

Como sucede al analizar un modelo individual, puede registrar todos los modelos
encontrados durante las pruebas de mitigación y cargar las métricas del panel en
Integración con Azure Machine Learning
Fairlearn se integra con Azure Machine Learning y le permite ejecutar un
experimento en el que se cargan las métricas del panel en el área de trabajo de
Azure Machine Learning. De esta forma puede compartir el panel en Estudio de
Azure Machine Learning para que el equipo de ciencia de datos pueda realizar el
seguimiento y comparar las métricas de disparidad de los modelos registrados en el
área de trabajo.
Ejercicio: Uso de Fairlearn con Azure

Machine Learning
Completado
100 XP
25 minutos
Ahora tiene la oportunidad de detectar y mitigar la parcialidad de un modelo.
● Usar el paquete Fairlearn con Azure Machine Learning para evaluar la

disparidad del rendimiento de la predicción.
● Usar el paquete Fairlearn con Azure Machine Learning para mitigar la
parcialidad.
Instrucciones

4. Complete el ejercicio Detección y mitigación de la parcialidad.
Supervisión de modelos con Azure
Machine Learning
Una vez implementado un modelo de aprendizaje automático en producción, es

importante comprender cómo se usa mediante la captura y visualización de la
telemetría.
Aprenda a usar Azure Application Insights para supervisar un modelo de Azure Machine
Learning implementado.
Requisitos previos
● Conocimientos de Python
● Experiencia en el entrenamiento y la implementación de modelos con el
SDK de Azure Machine Learning
Introducción
Application Insights es un servicio de administración del rendimiento de las
aplicaciones de Microsoft Azure que permite capturar, almacenar y analizar los
datos de telemetría de las aplicaciones.
Puede usar Application Insights para supervisar la telemetría de muchos tipos de

aplicaciones, incluidas las que no se ejecutan en Azure. Lo único que se necesita es
un paquete de instrumentación de baja sobrecarga para capturar y enviar los datos
de telemetría a Application Insights. El paquete necesario ya está incluido en los
servicios web Azure Machine Learning, por lo que puede usarlo para capturar y
revisar la telemetría de los modelos publicados con Azure Machine Learning.
● Habilitar la supervisión de Application Insights para un servicio web

Machine Learning.
● Capturar y visualizar la telemetría del modelo.
Habilitación de Application Insights

Para registrar la telemetría en Application Insights desde un servicio de aprendizaje
automático de Azure, debe tener un recurso de Application Insights asociado al área
de trabajo de Azure Machine Learning y configurar el servicio para usarlo en el
registro de telemetría.
Asociación de Application Insights con un área de

trabajo
Al crear un área de trabajo de Azure Machine Learning, puede seleccionar un
recurso de Azure Application Insights con el que asociarlo. Si no selecciona un
recurso de Application Insights existente, se crea uno nuevo en el mismo grupo de
recursos que el área de trabajo.
Para determinar el recurso de Application Insights asociado a su área de trabajo,

consulte la página Información general de la hoja del área de trabajo en Azure Portal
o use el método get_details() de un objeto de área de trabajo, como se muestra en
el ejemplo de código siguiente:
Python
Copiar
ws.get_details()['applicationInsights']
Habilitar Application Insights para un servicio
Al implementar un nuevo servicio en tiempo real, puede habilitar Application Insights
en la configuración de implementación para el servicio, como se muestra en este
ejemplo:
Python
Copiar
dep_config = AciWebservice.deploy_configuration(cpu_cores = 1,
memory_gb = 1,
enable_app_insights=True)
Si quiere habilitar Application Insights para un servicio que ya está implementado,

puede modificar la configuración de implementación de los servicios basados en
Azure Kubernetes Service (AKS) desde Azure Portal. También puede actualizar
cualquier servicio web mediante el SDK de Azure Machine Learning, de la siguiente
manera:
Python
Copiar
service = ws.webservices['my-svc']
service.update(enable_app_insights=True)
Captura y visualización de la telemetría

Application Insights captura automáticamente cualquier información escrita en los
registros de error y de salida estándar, y proporciona una capacidad de consulta
para ver los datos en estos registros.
Escritura de datos de registro
Para capturar datos de telemetría para Application Insights, escriba cualquier valor
del registro de salida estándar en el script de puntuación del servicio usando una
instrucción print, como se muestra en el ejemplo siguiente:
Python
Copiar
def init():
global model
model = joblib.load(Model.get_model_path('my_model'))
def run(raw_data):
data = json.loads(raw_data)['data']
predictions = model.predict(data)
log_txt = 'Data:' + str(data) + ' - Predictions:' +

str(predictions)
print(log_txt)
return predictions.tolist()
Azure Machine Learning creará una dimensión personalizada en el modelo de datos

Application Insights para la salida que escriba.
Consulta de registros en Application Insights

Para analizar los datos de los registros capturados, puede usar la interfaz de
consulta de análisis de registros para Application Insights en Azure Portal. Esta
interfaz admite una sintaxis de consulta similar a SQL que se puede usar para
extraer campos de datos registrados, incluidas las dimensiones personalizadas
creadas por Azure Machine Learning Service.
Por ejemplo, la consulta siguiente devuelve los campos timestamp y

customDimensions.Content de los seguimientos de registro que tienen STDOUT
como valor del campo message (que indica que los datos están en el registro de
salida estándar) y el valor my-svc para el campo customDimensions.["Service
Name"]:
SQL
Copiar
traces
|where message == "STDOUT"
and customDimensions.["Service Name"] = "my-svc"
| project timestamp, customDimensions.Content
Esta consulta devuelve los datos registrados en forma de tabla:
timestamp customDimensions_Content
01/02/2020... Datos:[[1, 2, 2.5, 3.1], [0, 1, 1,7, 2.1]] - Predicciones:[0 1]
01/02/2020... Datos:[[3, 2, 1.7, 2.0]] - Predicciones:[0]
Ejercicio: Supervisar un modelo

Completado
100 XP
30 minutos
Ahora tiene la oportunidad de supervisar un modelo que se implementa como un

servicio de Azure Machine Learning en tiempo real.
● Configurar Application Insights para un servicio implementado.

● Capturar y visualizar la telemetría del modelo.
Instrucciones
4. Realice el ejercicio Supervisar un modelo.
Supervisión del desfase de datos con
Cambiar las tendencias de los datos a lo largo del tiempo puede reducir la precisión
de las predicciones realizadas por un modelo. Supervisar este desfase de datos es
una forma importante de asegurarse de que el modelo sigue haciendo predicciones
de forma precisa.
Obtenga información sobre cómo supervisar el desfase de datos en Azure Machine
Learning.
Introducción
Normalmente los modelos de Machine Learning se entrenan con un conjunto de
datos histórico que es representativo de los nuevos datos que el modelo recibirá
para hacer inferencias. Pero con el tiempo puede haber tendencias que cambien el
perfil de los datos, lo que hará que el modelo sea menos preciso.
Por ejemplo, supongamos que un modelo está entrenado para predecir la previsión
de consumo de combustible por kilómetro de un vehículo en función de su
cilindrada, tamaño, peso y otras características. Con el tiempo, a medida que las
tecnologías de fabricación y motorización de los automóviles progresan, puede ser
que la autonomía habitual de los vehículos mejore drásticamente, con lo que las
predicciones realizadas por el modelo entrenado con datos más antiguos pueden
ser menos precisas.
Este cambio en los perfiles de datos entre el entrenamiento y la inferencia se
denomina desfase de datos y puede ser un problema importante para los modelos
predictivos que se usan en producción. Por lo tanto, es importante poder supervisar
el desfase de datos a lo largo del tiempo y volver a entrenar los modelos si es
necesario para mantener la precisión de las predicciones.
● Crear un monitor de desfase de datos.

● Programar un monitor de desfase de datos.
● Ver los resultados del monitor de desfase de datos.
Creación de un monitor de desfase de

datos
Azure Machine Learning admite el uso del monitor de desfase de datos mediante
conjuntos de datos. Puede capturar nuevos datos de características de un conjunto
de datos y compararlos con el conjunto de datos con el que se entrenó el modelo.
Supervisión del desfase de datos comparando

conjuntos de datos
Normalmente, las organizaciones siguen recopilando datos nuevos después de
haber entrenado un modelo. Por ejemplo, puede ser que una clínica utilice datos
diagnósticos de pacientes anteriores para entrenar un modelo que prediga la
probabilidad de sufrir diabetes y que siga recopilando los mismos datos diagnósticos
de todos los pacientes nuevos. Los científicos de datos de la clínica pueden hacer
comparaciones periódicas entre la colección creciente de datos nuevos con los
datos de entrenamiento originales e identificar cualquier tendencia de datos
cambiante que pudiera afectar a la precisión del modelo.
Para supervisar el desfase de datos mediante conjuntos de datos registrados, debe

registrar dos conjuntos de datos:
● Un conjunto de datos de base de referencia: normalmente se trata de

los datos de entrenamiento originales.
● Un conjunto de datos de destino que se comparará con la base de
referencia en intervalos de tiempo. Este conjunto de datos requiere una
columna para cada característica que quiera comparar y una columna
de marca de tiempo para que se pueda medir la velocidad del desfase
de datos.
Nota
Puede configurar un servicio implementado para recopilar nuevos datos enviados al

modelo para la inferencia, que se guarda en Azure Blob Storage y que se puede
usar como un conjunto de datos de destino para la supervisión de desfase de datos.
Consulte Recopilación de datos de modelos en producción en la documentación de
Azure Machine Learning para obtener más información.
Después de crear estos conjuntos de datos, puede definir un monitor de conjunto de

datos para detectar el desfase y desencadenar alertas si la tasa de desfase supera
un umbral determinado. Puede crear monitores de conjuntos de datos con la interfaz
visual del Estudio de Azure Machine Learning o usando la clase DataDriftDetector
en el SDK de Azure Machine Learning, como se muestra en el código de ejemplo
siguiente:
Python
Copiar
from azureml.datadrift import DataDriftDetector
monitor = DataDriftDetector.create_from_datasets(workspace=ws,
name='dataset-drift-detector',
baseline_data_set=train_ds,
target_data_set=new_data_ds,
compute_target='aml-cluster',
frequency='Week',
feature_list=['age','height', 'bmi'],
latency=24)
Después de crear el monitor del conjunto de datos, puede hacer una reposición para
comparar al instante el conjunto de datos de la base de referencia con los datos
existentes en el conjunto de datos de destino, como se muestra en el ejemplo
siguiente, en el que se repone el monitor en función de los cambios semanales para
las seis semanas anteriores:
Python
Copiar
import datetime as dt
backfill = monitor.backfill( dt.datetime.now() -

dt.timedelta(weeks=6), dt.datetime.now())
Programación de alertas
Al definir un monitor de datos, se especifica la programación en la que se debe
ejecutar. Además, puede especificar un umbral para la tasa de desfase y una
dirección de correo electrónico de un superior al que enviar las notificaciones si se
supera este umbral.
Configuración de programaciones del monitor de

desfase de datos
La supervisión del desfase de datos funciona haciendo una comparación en la
frecuencia programada y calculando las métricas de desfase de datos para las
características del conjunto de datos que quiera supervisar. Puede definir una
programación para que se ejecute cada Día, Semana o Mes.
En el caso de los monitores de conjuntos de datos, puede especificar una latencia,

que indicará el número de horas durante las que se pueden recopilar nuevos datos y
se pueden agregar al conjunto de datos de destino. En el caso de los monitores de
desfase de datos del modelo implementado, puede especificar un valor de tiempo
schedule_start para indicar cuándo se debe iniciar la ejecución del desfase de datos
(si se omite, la ejecución se iniciará en ese mismo momento).
Configurar alertas
El desfase de datos se mide usando una magnitud calculada de cambio en la
distribución estadística de valores de características a lo largo del tiempo. Es
probable que se produzca alguna variación aleatoria natural entre los conjuntos de
datos de base de referencia y de destino, pero debe fijarse en los cambios notables,
que son los que pueden indicar un desfase importante.
Puede definir un umbral de la magnitud del desfase de datos para recibir

notificaciones cuando se supere y configurar las notificaciones de alerta por correo
electrónico. En el código siguiente se muestra un ejemplo de programación de un
monitor de desfase de datos que se ejecuta todas las semanas y envía una alerta si
la magnitud del desfase es superior a 0,3:
Python
Copiar
alert_email = AlertConfiguration('data_scientists@contoso.com')
monitor = DataDriftDetector.create_from_datasets(ws,
'dataset-drift-detector',
baseline_data_set, target_data_set,
compute_target=cpu_cluster,
frequency='Week',
latency=2,
drift_threshold=.3,
alert_configuration=alert_email)
Ejercicio: Supervisar el desfase de datos

Ahora tiene la oportunidad de supervisar el desfase de datos usando conjuntos de
datos en Azure Machine Learning.

● Crear un monitor de desfase de datos.
● Reponer el monitor y ver el desfase de datos.
Instrucciones

4. Realice el ejercicio Supervisar el desfase de datos.
Exploración de conceptos de seguridad
en Azure Machine Learning
Explore y experimente con la protección de un entorno de aprendizaje automático
para garantizar la privacidad de los datos y la precisión de los modelos.
● Aplicar y comprender el control de acceso basado en rol en Azure

Machine Learning
● Describir cómo se administran los secretos en Azure Machine Learning
● Usar un área de trabajo de Azure Machine Learning con Azure Virtual
Network
Introducción
El aprendizaje automático requiere grandes cantidades de datos para entrenar
modelos eficaces. Algunos de estos datos pueden contener información confidencial
de individuos o empresas que deben protegerse para garantizar su privacidad. Los
desafíos de seguridad relacionados con el aprendizaje automático no solo se limitan
a los datos, y la configuración de la creación de un entorno de trabajo seguro puede
ser intimidatoria. Azure Machine Learning (Azure ML) proporciona varios
mecanismos que ofrecen un control pormenorizado del entorno de red, los recursos
que se usan en él y los datos a los que se accede. Establecer las medidas
adecuadas puede proteger tanto de los atacantes externos como de problemas
internos, como la negligencia o los procesos sin consolidar.
Muchos ataques en sistemas de aprendizaje automático implican el acceso a los

modelos mediante redes no seguras para robar o manipular datos, afectar al
rendimiento del modelo y acceder a datos confidenciales. Al crear almacenes de
datos de entrenamiento mejores y más seguros, bloquear las plataformas de
aprendizaje automático y controlar el acceso a las entradas y salidas, es posible
garantizar que los datos permanecen protegidos. Estas características son útiles
para los científicos de datos, los administradores y los ingenieros de operaciones
que quieren crear configuraciones seguras compatibles con las directivas de sus
empresas.
Advertencia
En este módulo se proporcionará información sobre los vectores de ataque que se

deben tener en cuenta y las herramientas de seguridad disponibles en Azure
Machine Learning, pero no es un curso exhaustivo sobre seguridad. Debe leer
minuciosamente la documentación de Azure ML y trabajar con expertos en
seguridad en la nube cualificados antes de determinar que su arquitectura es
segura.
Requisitos previos
● Conocimientos básicos de Azure

Machine Learning
● Usar un área de trabajo de Azure Machine Learning con Azure Virtual
Network
¿Qué es el control de acceso basado en

rol?
El control de acceso basado en rol de Azure (Azure RBAC) es un sistema de
autorización que permite administrar el acceso específico a los recursos de Azure
Machine Learning. Le permite administrar el acceso de los miembros del equipo a
los recursos en la nube de Azure mediante la asignación de roles. Estos roles
determinan qué recursos pueden usar los miembros del equipo en el área de trabajo
y qué pueden hacer con esos recursos. Esto puede ser importante si el equipo
trabaja con datos confidenciales, como registros hospitalarios que contengan
información médica privada, o si quiere restringir el acceso a recursos críticos para
los miembros noveles del equipo en Azure Machine Learning. Con estos roles,
puede reflejar de forma realista la estructura de la organización, lo que garantiza
que las responsabilidades y los recursos críticos se reparten entre los usuarios
correctos.
Roles de usuario
Los roles de Azure RBAC pueden asignarse a usuarios y grupos. Los derechos
asignados a cada grupo se distribuyen como un sistema basado en permisos, con el
acceso establecido y las restricciones claramente definidas. Este control se aplica
en el nivel de área de trabajo y solo pueden cambiarlo los administradores o los
propietarios del área de trabajo específica de Azure Machine Learning. Un área de
trabajo de Azure Machine Learning, al igual que otros recursos de Azure, incluye
tres roles predeterminados cuando se crea. Puede agregar usuarios al área de
trabajo y asignarles uno de estos roles:
● Los propietarios tienen acceso completo al área de trabajo, incluida la

capacidad de ver, crear, editar o eliminar recursos en un área de
trabajo. Los propietarios también pueden cambiar las asignaciones de
roles.
● Los colaboradores pueden ver, crear, editar o eliminar recursos en un
área de trabajo. Por ejemplo, los colaboradores pueden crear un
experimento, crear o conectar un clúster de proceso, enviar una
ejecución e implementar un servicio web.
● Los lectores solo pueden realizar acciones de solo lectura en el área de
trabajo. Los lectores pueden enumerar y ver los recursos (incluidas las
credenciales del almacén de datos) de un área de trabajo. pero no
pueden crear ni actualizar estos recursos.
Roles personalizados
Si los roles predeterminados no satisfacen la necesidad de su organización de

contar con un control de acceso más selectivo, puede crear sus propios roles
personalizados. Los roles personalizados proporcionan flexibilidad para desarrollar
reglas basadas en permisos para usuarios o grupos que proporcionan acceso al
mismo tiempo que definen sus propias estipulaciones de seguridad para proteger
datos o recursos. Puede hacer que un rol esté disponible en un nivel de área de
trabajo específico, un nivel de grupo de recursos específico o un nivel de suscripción
definiendo el ámbito del rol personalizado, que se puede ver en el JSON de ejemplo
siguiente.
Los roles personalizados se pueden crear definiendo las posibles acciones

permitidas y las NotActions para restringir actividades o acceso específicos. Puede
crear roles personalizados con Azure Portal, Azure PowerShell, la CLI de Azure o la
API de REST. A continuación se puede ver una solicitud JSON de rol personalizado
para los científicos de datos:
Copiar
"Name": "Data Scientist Custom",

"IsCustom": true,
"Description": "Can run experiment but can't create or delete

compute or deploy production endpoints.",
"Actions": [
"Microsoft.MachineLearningServices/workspaces/*/read",
"Microsoft.MachineLearningServices/workspaces/*/action",
"Microsoft.MachineLearningServices/workspaces/*/delete",
"Microsoft.MachineLearningServices/workspaces/*/write"
],
"NotActions": [
"Microsoft.MachineLearningServices/workspaces/delete",
"Microsoft.MachineLearningServices/workspaces/write",
"Microsoft.MachineLearningServices/workspaces/computes/*/write",
"Microsoft.MachineLearningServices/workspaces/computes/*/delete",
"Microsoft.Authorization/*",
"Microsoft.MachineLearningServices/workspaces/computes/listKeys/ac
tion",
"Microsoft.MachineLearningServices/workspaces/listKeys/action",
"Microsoft.MachineLearningServices/workspaces/services/aks/write",
"Microsoft.MachineLearningServices/workspaces/services/aks/delete"
,
"Microsoft.MachineLearningServices/workspaces/endpoints/pipelines/
write"
],
"AssignableScopes": [
"/subscriptions/<subscription_id>/resourceGroups/<resource_group_n
ame>/providers/Microsoft.MachineLearningServices/workspaces/<works
pace_name>"
Tenga en cuenta las secciones Actions y NotActions a continuación que definen los
permisos para el rol personalizado y el ámbito asignado que se encuentra en el nivel
de área de trabajo específico. En este ejemplo, las acciones del científico de datos
se definen mediante un carácter comodín (representado por el signo *) que extiende
un permiso a todo lo que coincida con la cadena de acción que proporcione. Por lo
tanto, en el ejemplo anterior, la cadena del carácter comodín agrega todos los
permisos relacionados con la lectura, escritura, acción o eliminación dentro del área
de trabajo.
Sin embargo, si observamos la sección NotActions anterior, podemos ver

restricciones en la eliminación o creación de áreas de trabajo o nuevos recursos de
proceso, entre otros. Estas restricciones tienen prioridad sobre las acciones
permitidas explícitamente.
Sistema
Una dificultad común para los desarrolladores es la administración de los secretos y
las credenciales usados para proteger la comunicación entre los distintos
componentes. Azure Machine Learning se basa en Azure Active Directory (Azure
AD) para la autenticación o la comunicación entre otros recursos en la nube de
Azure. Azure AD es un servicio de identidad basada en la nube y de administración
de acceso que ayuda a los empleados de una organización a iniciar sesión y
acceder a los recursos en la nube de Azure.
Autenticación con Azure AD
En general, hay cuatro flujos de trabajo de autenticación que se pueden usar al

conectarse al área de trabajo:
Interactivo: utiliza su cuenta en Azure Active Directory para realizar la autenticación

manual u obtener un token de autenticación. La autenticación interactiva se usa
durante la experimentación y el desarrollo iterativo. Permite controlar el acceso a los
recursos (por ejemplo, un servicio web) por usuario.
Entidad de servicio: crea una cuenta de entidad de servicio en Azure Active

Directory y la utiliza para la autenticación u obtención de un token de autenticación.
Una entidad de servicio se usa cuando se necesita un proceso automatizado para
autenticarse en el servicio. Por ejemplo, un script de integración e implementación
continuas que entrena y prueba un modelo cada vez que el código de entrenamiento
cambia necesita acceso continuo y, por tanto, se beneficiaría de una cuenta de
entidad de servicio.
Sesión de la CLI de Azure: se usa una sesión activa de la CLI de Azure para
autenticarse. La autenticación con la CLI de Azure se usa durante la
experimentación y el desarrollo iterativo, o cuando se necesita un proceso
automatizado para autenticarse en el servicio mediante una sesión autenticada
previamente. Puede iniciar sesión en Azure mediante la CLI de Azure en la estación
de trabajo local, sin almacenar las credenciales en el código ni pedir al usuario que
se autentique.
Identidad administrada: Si utiliza el SDK de Azure Machine Learning en una

máquina virtual de Azure, puede usar una identidad administrada para Azure. Este
flujo de trabajo permite a la máquina virtual conectarse al área de trabajo mediante
la identidad administrada, sin almacenar las credenciales en el código ni pedir al
usuario que se autentique. Los clústeres de proceso de Azure Machine Learning
también se pueden configurar para usar una identidad administrada para acceder al
área de trabajo cuando se entrenen modelos.
Identidades administradas
Al configurar el área de trabajo de Azure Machine Learning de forma confiable, es

esencial asegurarse de que los distintos servicios en la nube asociados al área de
trabajo tienen el nivel de acceso correcto. Las identidades administradas le permiten
autenticar los servicios proporcionando una identidad administrada automáticamente
para que las aplicaciones o servicios la usen al conectarse a los servicios en la nube
de Azure. Las identidades administradas funcionan con cualquier servicio que
admita la autenticación de Azure AD y proporciona registros de actividad para que
los administradores puedan ver la actividad del usuario, como las horas de inicio de
sesión, cuándo se iniciaron las operaciones y quién las inició.
Hay dos tipos de identidades administradas:
● Asignada por el sistema: algunos servicios de Azure permiten habilitar

identidades administradas directamente en una instancia de servicio.
Cuando se habilita una identidad administrada asignada por el sistema,
se crea una identidad en Azure AD vinculada al ciclo de vida de esa
instancia de servicio. Por defecto, solo ese recurso de Azure puede usar
esta identidad para solicitar tokens de Azure AD y, cuando se elimina el
recurso, Azure elimina automáticamente la identidad automáticamente.
● Asignada por el usuario: también es posible crear una identidad
administrada como un recurso independiente de Azure. Puede crear
una identidad administrada asignada por el usuario y asignarla a una o
varias instancias de un servicio de Azure. La identidad se administra por
separado de los recursos que la usan y se conservará si se elimina un
recurso que la usa. Para simplificar, se recomienda usar roles
asignados por el sistema a menos que necesite una solución de acceso
personalizada.
Una vez que tenga una identidad administrada, puede solicitar tokens mediante un
punto de conexión de token en un recurso como una máquina virtual. Estos tokens
funcionan con la autorización existente de los usuarios de Azure RBAC para
permitirles realizar acciones, como extraer claves de Azure Key Vault o cualquier
otro secreto. Del mismo modo, supongamos que el usuario tiene un rol de Azure
RBAC que permite el uso de una solución de almacenamiento de Azure. En ese
caso, ese token se puede usar para autenticar y leer o insertar datos en el
almacenamiento sin credenciales en su código. Las operaciones sobre identidades
administradas se pueden realizar mediante una plantilla de Azure Resource
Manager (ARM), Azure Portal, la CLI de Azure, PowerShell y las API REST.
A continuación se puede ver el flujo de trabajo típico de una identidad administrada

dentro de una máquina virtual:
Identidades con clústeres de proceso
Los clústeres de proceso de Azure Machine Learning pueden usar identidades

administradas para autenticar el acceso a los recursos de Azure dentro de Azure
Machine Learning sin incluir credenciales en el código. Esto resulta útil para
proporcionar rápidamente los permisos mínimos necesarios para acceder a los
recursos y proteger otros recursos críticos. Por ejemplo, durante el flujo de trabajo
del aprendizaje automático, el área de trabajo necesita acceso a Azure Container
Registry para las imágenes de Docker y a las cuentas de almacenamiento para los
datos de entrenamiento. De forma predeterminada, la identidad asignada por el
sistema está habilitada directamente en los clústeres de proceso de Azure Machine
Learning y todos estos recursos estarán disponibles para su uso. Cuando se elimina
el clúster de proceso, Azure limpiará automáticamente las credenciales y la
identidad en Azure Active Directory. Los clústeres de proceso también pueden
admitir identidades personalizadas asignadas por el usuario asignadas a varios
recursos que se conservarán después de eliminarlos.
Durante la creación del clúster de proceso o la edición de los detalles del clúster de
proceso, en Configuración avanzada, cambie a Assign a managed identity (Asignar
una identidad administrada) y especifique una identidad asignada por el sistema o
una identidad asignada por el usuario. Tenga en cuenta que los clústeres de
proceso de Azure Machine Learning solo admiten una identidad asignada por el
sistema o varias identidades asignadas por el usuario, no ambas de forma
simultánea.
Nota
Las identidades administradas solo se pueden usar con Azure Machine Learning
cuando se usa el SDK de Azure Machine Learning en una máquina virtual de Azure
o un clúster de proceso de Azure Machine Learning. Este flujo de trabajo permite
que la máquina virtual se conecte al área de trabajo mediante la identidad
administrada en lugar de la cuenta de Azure AD del usuario individual, y sin
almacenar las credenciales en el código.
Ejercicio: Configuración de Azure

Machine Learning con roles
personalizados
Completado
Un área de trabajo de Machine Learning es probablemente uno de los recursos más
interesantes para los científicos de datos y los ingenieros de ML.
El área de trabajo de Machine Learning es un recurso de nivel superior donde se

trabaja con los artefactos necesarios en Azure Machine Learning, como conjuntos
de datos, modelos y roles de usuario.
En este ejercicio, configuraremos un área de trabajo de Azure Machine Learning

que se usará en los siguientes ejercicios y módulos.
Requisitos previos
● Una cuenta y una suscripción de Azure
Si aún no tiene una suscripción de Azure, siga las instrucciones del vínculo
siguiente:
Creación de una suscripción en Azure Portal.
Inicio de sesión en Azure

Inicie sesión en el Azure Portal.
Creación de un grupo de recursos

Un grupo de recursos es donde los administradores pueden crear grupos lógicos de
recursos, como volúmenes de almacenamiento, máquinas virtuales y áreas de
trabajo de ML, para que puedan realizar un seguimiento más sencillo de los costos,
aplicar controles de acceso y supervisar la actividad.
Vamos a crear un grupo de recursos para este ejercicio:

1. En Azure Portal, seleccione Grupos de recursos:
2. Seleccione Nuevo o Crear en la lista de grupos de recursos:
3. Rellene el formulario para agregar un nuevo grupo de recursos.

● Seleccione la suscripción que creó anteriormente.
● Use AI-Resource como nombre del grupo de recursos.
● Seleccione su región preferida.
● Seleccione Revisar y crear y, luego, Crear.
4.
Creación de un área de trabajo de ML

Siga estos pasos para crear un área de trabajo de ML:
1. Seleccione Inicio para volver a la página principal.

2. En Azure Portal, seleccione Crear un recurso:
3. Seleccione Ver todo.
4. Desplácese hacia abajo hasta que aparezca la opción IA y Machine

Learning y seleccione Crear.
5. Rellene el formulario y seleccione la suscripción actual y el grupo de

recursos que hemos creado anteriormente (AI-Resource). Use
ml-workspace como nombre del área de trabajo:
6. Seleccione el botón Revisar y crear para cargar la pantalla de
confirmación de revisión:
7. Seleccione Crear para empezar a implementar la nueva área de trabajo

(esto puede tardar unos minutos).
Importante
Observe que la implementación anterior creó otros recursos:
● Una cuenta de almacenamiento, utilizada para almacenar archivos
utilizados por el área de trabajo, así como datos para los experimentos
y el entrenamiento de modelos.
● Una instancia de Application Insights, que se usa para supervisar los
servicios predictivos en el área de trabajo.
● Una instancia de Azure Key Vault, que se usa para administrar secretos
como las claves de autenticación y las credenciales que se usan en el
área de trabajo.
● Un registro de contenedor, creado a medida para administrar
contenedores para los modelos implementados.
Creación de un rol personalizado y asignación al área

de trabajo
1. Seleccione Inicio para volver a la página principal.
2. Abra Azure Cloud Shell.
Seleccione el icono de Cloud Shell:
o utilizar la URL directa en su explorador: https://shell.azure.com.

3. Seleccione Bash o PowerShell (usaremos bash):
Definición de un rol personalizado:
1. Con el editor de texto que prefiera, cree un archivo denominado
data_scientist_custom_role.json, reemplazando la información siguiente:
Variable Value
subscription_id Su Id. de suscripción
resource_group_name AI-Resource
workspace_name ml-workspace
2. Copiar
"Name": "Data Scientist Custom",
"IsCustom": true,
"Description": "Can run experiment but can't create or

delete compute.",
"Actions": ["*"],
"NotActions": [
"Microsoft.MachineLearningServices/workspaces/*/delete",
"Microsoft.MachineLearningServices/workspaces/write",
"Microsoft.MachineLearningServices/workspaces/computes/*/write
",
"Microsoft.MachineLearningServices/workspaces/computes/*/delet
e",
"Microsoft.Authorization/*/write"
],
"AssignableScopes": [
"/subscriptions/<subscription_id>/resourceGroups/<resource_gro
up_name>/providers/Microsoft.MachineLearningServices/workspace
s/<workspace_name>"
3.
4. Cargue el archivo de definición de roles:
● Haga clic en el icono Cargar/Descargar archivos.
● Haga clic en Cargar.
● Seleccione el archivo data_scientist_custom_role.json que
creó anteriormente:
5.
6. Cree una definición de rol con el comando de CLI az role definition
create (observe que el último argumento es el archivo que acaba de
cargar):
7. Copiar
az role definition create --role-definition

data_scientist_custom_role.json
8.
Esto agrega el rol "Científico de datos personalizado", que se limita a ejecutar
experimentos en ml-workspace.
Para comprobar y enumerar los roles existentes mediante el Azure Portal,

seleccione la opción Control de acceso (IAM) en ml-workspace y, a continuación,
seleccione la pestaña Roles:
Resumen
¡Enhorabuena!
En esta unidad se han abordado los temas siguientes:
● Creación de un grupo de recursos

● Creación de un área de trabajo de Machine Learning
● Uso de Cloud Shell para ejecutar comandos y cargar archivos en su
cuenta
● Definición de un rol personalizado para Machine Learning con acceso al
área de trabajo
Claves y secretos con Azure Key Vault
La mayoría de las aplicaciones en red necesitan trabajar con secretos, como
cadenas de conexión de base de datos o contraseñas. Cuando se realiza el
aprendizaje automático en Azure, normalmente se usan secretos para acceder a los
datos de entrenamiento o para ver los resultados. Especialmente cuando se trabaja
con datos privados, es importante asegurarse de que los secretos se administran
correctamente.
No almacenar secretos en el código fuente

El almacenamiento de secretos en el código fuente no es práctico y va en contra de
las prácticas recomendadas de seguridad. Esto se debe a múltiples motivos:
● Cambiar contraseñas significa actualizar el código fuente, lo que puede

significar volver a recompilar y publicar las aplicaciones.
● Los secretos codificados de forma rígida hacen que sea difícil trabajar
con distintos entornos, como entornos de almacenamiento provisional y
producción. También aumentan el riesgo de modificación involuntaria o
destrucción de datos del entorno de producción durante el desarrollo.
● Todas las personas con acceso al código fuente obtienen acceso a
todos los secretos. Esto hace que sea casi imposible asegurarse de que
solo los miembros del equipo de dirección tengan acceso a los recursos
confidenciales. También significa que cualquier uso compartido o
filtración del código fuente podría proporcionar sus claves de seguridad
a terceros.
● El control de código fuente, como git, normalmente conservará las
contraseñas antiguas en el historial. Esto significa que los futuros
miembros del equipo obtienen acceso a todas las contraseñas previas.
Una de las mejores alternativas al almacenamiento de secretos en el código fuente

es que estén disponibles en el entorno de la aplicación. En este patrón, la aplicación
solicita secretos al entorno y, a continuación, los usa para conectarse a los recursos
necesarios. Se eliminan los inconvenientes de almacenar secretos en el código
fuente mencionados anteriormente, siempre que cada entorno tenga valores de
secreto diferentes, como contraseñas distintas para acceder a determinados
recursos.
Azure Key Vault

Azure Key Vault proporciona almacenamiento seguro de secretos genéricos para
aplicaciones en entornos hospedados en Azure. Se puede almacenar cualquier tipo
de secreto, siempre que su valor no sea superior a 25 kb y se pueda leer y devolver
como una cadena. Los secretos tienen nombres, y su tipo de contenido (como
contraseñas o certificados) se puede almacenar opcionalmente junto con el valor
para proporcionar una sugerencia que ayude en su interpretación cuando se
necesite recuperar.
Los secretos almacenados en Azure Key Vault se cifran opcionalmente a nivel de

hardware. Esto se controla de forma transparente y no requiere ninguna acción por
parte del usuario o la aplicación que solicita los secretos. También se pueden
deshabilitar temporalmente y activarse o hacer que caduquen automáticamente en
una fecha determinada.
Funcionamiento de Key Vault con Azure Machine

Learning
Cuando se crea un área de trabajo de Azure Machine Learning, se crea
automáticamente una instancia de Key Vault. Para ver las instancias de Azure Key
Vault asociadas al área de trabajo, abra la pestaña Información general en el área
de trabajo. El almacén de claves aparece en el lado derecho.
La primera vez que cree el área de trabajo, su Key Vault se creará
automáticamente. Se puede acceder al Key Vault mediante la aplicación. Por
ejemplo, puede usar Azure Shell para establecer una variable de entorno con el
nombre del almacén de claves y guardar una contraseña en ese almacén de claves
de la siguiente manera:
Bash
Copiar
# export the name of the vault to an environmental variable
export KEY_VAULT_NAME=<your-unique-keyvault-name>
# Save a new secret, called ExamplePassword
az keyvault secret set --vault-name $KEY_VAULT_NAME --name

"ExamplePassword" --value "hVFkk965BuUv"
Esta contraseña se almacena de forma segura y está cifrada. Por ejemplo, una
aplicación de Python que use el SDK de Azure Machine Learning puede acceder a
esta clave como se muestra a continuación:
Python
Copiar
'''
Simple example of obtaining a secret from the keyvault.
Assumes azure-identity and azure-keyvault-secrets have been
pip installed
'''
import os
from azure.keyvault.secrets import SecretClient
from azure.identity import DefaultAzureCredential
# Get the key vault name
keyVaultName = os.environ["KEY_VAULT_NAME"]
# Create a client to access the secret
credential = DefaultAzureCredential()
client = SecretClient(vault_url=
f"https://{keyVaultName}.vault.azure.net", credential=credential)
# Get a secret and print it to the console
# Note that printing out passwords is bad practice and only
# performed here for learning purposes
retrieved_secret = client.get_secret("ExamplePassword")
print(f"Your secret is '{retrieved_secret.value}'")

El resultado es la contraseña original que se almacenó:
Bash
Copiar
Your secret is 'hVFkk965BuUv'
Trabajo con trabajos remotos
La información anterior proporciona una solución genérica para usar Key Vault.
Normalmente, con Azure Machine Learning, ejecutará código mediante una
ejecución remota.
El flujo estándar para el uso de secretos en este contexto es:
● Inicie sesión en Azure y conéctese al área de trabajo.

● Establezca un secreto en el Key Vault del área de trabajo.
● Envío de un trabajo remoto y, a continuación,
● Dentro del trabajo remoto, obtenga el secreto de Key Vault y úselo.
Cuando se usa el SDK de Python y un trabajo, se puede acceder directamente a los

secretos de forma fácil. Esto se debe a que una ejecución enviada es consciente de
su área de trabajo. Por ejemplo:
Python
Copiar
# Code in submitted job run
from azureml.core import Experiment, Run
secret_value = run.get_secret(name=" ExamplePassword")

Protección de la red de Azure Machine
Learning
Una instancia de Azure Virtual Network (VNet) es similar a una red tradicional, pero
con las ventajas agregadas que proporciona la infraestructura de Azure.
Las VNet permiten que los recursos, como las máquinas virtuales (VM) y las áreas
de trabajo de ML, se comuniquen de forma segura entre sí y con otras redes o con
Internet.
Los ingenieros de Machine Learning pueden usarlas en diversos escenarios, como

vincular una máquina virtual a los datos almacenados localmente, restringir el
acceso a una API de entrenamiento para que solo el personal del laboratorio pueda
verla o exponer un punto de conexión de inferencia a Internet.
En este ejercicio, crearemos una VNet y la usaremos para proteger el acceso al

área de trabajo que creamos en el ejercicio anterior. Aunque en este ejercicio se
ofrecen algunas directrices sobre la mecánica de proteger un área de trabajo, esta
no es una solución completa. Consulte la documentación vinculada al final del
ejercicio para obtener instrucciones completas.
Advertencia
En este ejercicio solo se ofrece una descripción básica del proceso que se lleva a
cabo para realizar la protección de un entorno de red del área de trabajo de ML.
Para obtener el proceso completo paso a paso de un entorno de producción, siga el
vínculo al final de este ejercicio.
Advertencia
Este ejercicio bloqueará el acceso al área de trabajo afectada y no se debe realizar
en un área de trabajo de producción.
Requisitos previos
● Conocimientos básicos sobre conceptos de redes.
● Una cuenta y una suscripción de Azure.
● Un grupo de recursos del área de trabajo de Azure Machine Learning
como se creó en el ejercicio anterior.
Inicio de sesión en Azure

Inicie sesión en Azure Portal.
Creación de una red virtual

Vamos a crear una VNet para este ejercicio:
1. En el Azure Portal, seleccione Crear un recurso en la esquina superior

izquierda del portal.
2. En el cuadro de búsqueda del portal, escriba red virtual. En los
resultados de la búsqueda, seleccione Redes virtuales.
3. En la página Red virtual, seleccione Crear.
4. En Crear red virtual, escriba o seleccione esta información en la
pestaña Conceptos básicos:
● Detalles del proyecto:
○ Suscripción: seleccione la suscripción
○ Grupo de recursos: MLResourceGroup
● Detalles de instancia
○ Nombre: MLVNet
○ Región: East US
5. Seleccione la pestaña Direcciones IP o el botón Siguiente: Direcciones
IP situado en la parte inferior de la página.
6. En Espacio de direcciones IPv4, seleccione el espacio de direcciones
existente y cámbielo a 10.1.0.0/16.
7. Seleccione + Agregar subred y escriba:
● Nombre de subred: default
● Intervalo de direcciones de subred: 10.1.0.0/24
8. Seleccione Agregar.
9. Seleccione la pestaña Revisar y crear o el botón Revisar y crear.
10. Seleccione Crear y espere unos instantes para que se complete la
implementación:
Importante
Para simplificar, estamos creando una sola subred para la red virtual. Una subred es
un intervalo de direcciones IP en la red virtual. Podríamos dividir una red virtual en
varias subredes para la organización y la seguridad, por ejemplo, una subred de
entrenamiento que solo los científicos de datos podrían usar y una subred de
inferencia que esté disponible públicamente.
Acceso al área de trabajo de pruebas

Hemos agregado una VNet al grupo de recursos, pero no sabemos si restringe el
acceso a ml-worskpace.
Podemos usar Estudio de Azure Machine Learning para acceder a los contenidos
del área de trabajo.
Sugerencia
Estudio de Azure Machine Learning es un portal web con herramientas de alto nivel
para el entrenamiento de modelos, la implementación y la administración de
recursos.
1. Seleccione Inicio para volver a la página principal de Azure Portal.

2. Seleccione ml-workspace en la lista de recursos recientes.
3. Seleccione la dirección URL web de Estudio de su área de trabajo.
4. Estudio de Azure Machine Learning debería abrirse en una nueva
pestaña o ventana.
Aunque es posible que todavía no tenga ningún recurso en el área de trabajo, como
en la imagen anterior, no debería haber advertencias ni mensajes de error, lo que
significa que aún no hay restricciones de acceso a la red en esos recursos.
Protección del acceso de red al área de trabajo de

Hasta ahora hemos creado dos recursos independientes:
● Un área de trabajo de Azure Machine Learning (ml-workspace)

● Una VNet (MLVNet)
Ahora tenemos que conectar ambos para que el tráfico de red del área de trabajo
tenga que pasar por nuestra VNet. Es decir, queremos que nuestro área de trabajo
esté disponible solo para los recursos que están conectados a la red virtual MLVNet.
Para ello, es necesario definir un punto de conexión privado para el recurso

ml-workspace.
Nota
Un punto de conexión privado es una interfaz de red que usa una dirección IP
privada de la VNet para crear conexiones seguras y privadas a un recurso.
Creación de un punto de conexión privado

1. Vaya a Azure Portal, haga clic en Grupos de recursos, seleccione el
grupo de recursos MLResourceGroup y después seleccione el área de
trabajo ml_workspace.
2. En el menú de la izquierda, seleccione Red.
3. Seleccione la pestaña Conexiones de punto de conexión privado.
4. Agregue un nuevo punto de conexión privado con la siguiente
configuración:
● Detalles del proyecto:
○ Suscripción: seleccione la suscripción
○ Grupo de recursos: MLResourceGroup
● Detalles de instancia
○ Nombre: MLPrivateEndpoint
○ Nombre de la interfaz de red: se rellena al escribir
un nombre
○ Región: East US
5. Seleccione el botón Siguiente: Recurso >.
6. Revise que los detalles siguientes se muestran en la pestaña Recurso:
● Suscripción: Su suscripción
● Tipo de recurso:
Microsoft.MachineLearningServices/workspaces
● Recurso: ml-workspace
● Target sub resource (Subrecurso de destino) : amlworkspace
7. Seleccione el botón Siguiente: Red virtual>.
8. Deje los valores predeterminados sugeridos:
● Red virtual: MLVNet (MLResourceGroup)
● Subred: default
9. Seleccione el botón Siguiente: DNS>.
10. Deje el valor predeterminado sugerido para Integrar con la zona DNS
privada en Yes.
11. Seleccione el botón Siguiente: Etiquetas >.
12. Seleccione Revisar y crear para validar la implementación y, a
continuación, seleccione Crear para implementar el punto de conexión
(esto puede tardar unos minutos).
Pruebas de la configuración de red

Podemos asegurarnos de que el área de trabajo está ahora dentro de la VNet
probando si todavía tenemos acceso a sus recursos:
1. Vuelva a cargar la ventana Estudio de Azure Machine Learning (o
vuelva a abrir Studio):
2. Como se muestra en la advertencia, el acceso a esos recursos ahora

está bloqueado. Esto sucede porque el área de trabajo ahora está
dentro de la VNet y está configurada para bloquear todas las solicitudes
que no provienen de la subred default que hemos creado (recuerde que
estamos intentando acceder a ella desde fuera del perímetro de red).
Protegida pero inaccesible
Acaba de proteger el acceso de red al área de trabajo de Azure Machine Learning.
Tenga en cuenta que, de la misma manera que no puede acceder a ella, tampoco
pueden acceder otros recursos de la organización que no forman parte de la subred.
Abrir el acceso para que los recursos puedan conectarse requiere un planeamiento
estratégico.
Se recomienda leer la guía Protección de un área de trabajo de Azure Machine

Learning con redes virtuales para obtener información más detallada.
Resumen
En esta unidad se han abordado los temas siguientes:
● Qué es una red virtual y algunos de sus usos

● Creación de una red virtual de Azure
● Creación de subredes en una red virtual
● Uso de puntos de conexión privados para proteger el acceso de red a
las áreas de trabajo de Machine Learning
● Acceso a un área de trabajo mediante Estudio de Azure Machine
Learning y comprobación del bloqueo de los recursos
Resumen
Completado
100 XP
2 minutos
En este módulo, ha aprendido sobre algunas de las herramientas que proporciona

Azure Machine Learning para proteger los datos y el entorno de entrenamiento.
Después de revisar este módulo, debe ser capaz de hacer lo siguiente:

Machine Learning
● Usar un área de trabajo de Azure Machine Learning en Azure Virtual
Network

Apuntes Azure Data Scientist

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apuntes Azure Data Scientist

Uploaded by

Copyright:

Available Formats

Exploring Data with Python

Python is a flexible programming language that is used in a wide range of

Exploring data arrays with NumPy

Suppose a college professor takes a sample of student grades from a class to

Run the cell below to view the shape of the array.

Exploring tabular data with Pandas

Finding and filtering data in a DataFrame

Loading a DataFrame from a file

Handling missing values

Loading our data

Visualizing data with Matplotlib

● Specifies the color of the bar chart.

Resultado: La vetana toma el tamaño definido configurado en el código

A figure can contain multiple subplots, each on its own axis.

Getting started with statistical analysis

Descriptive statistics and data distribution

Measures of central tendency

If we have enough samples, we can calculate something called a probability density

1. Made graphs with Matplotlib.

Real world data distributions

Let's look at the density for this distribution.

Typical statistics that measure variability in the data include:

● Range: The difference between the maximum and minimum. There's no

In any normal distribution:

Comparing numeric and categorical variables

Comparing numeric variables

A common technique when dealing with numeric data in different scales is to

● The StudyHours for each student.

Using the regression coefficients for prediction

1. What an outlier is and how to remove them

Los modelos usan la regresión para predecir un número.

En el aprendizaje automático, el objetivo de la regresión es crear un modelo que

La regresión es una técnica estadística de importancia fundamental para la ciencia

En situaciones reales, especialmente cuando hay pocos datos disponibles, los

● Cuándo usar modelos de regresión.

Siguiente unidad: ¿Qué es la regresión?

A continuación, esta muestra de datos se divide en dos subconjuntos:

● Un conjunto de datos de entrenamiento al que aplicaremos un algoritmo

El uso de datos históricos con valores de etiqueta conocidos para entrenar un

Observemos un ejemplo sencillo para ver cómo funciona el proceso de

Comenzamos con algunos datos que incluyen valores conocidos para la

Ahora seleccionaremos aleatoriamente cinco de estas observaciones y las

Comencemos por trazar los valores de entrenamiento de x e y en un gráfico:

Veamos la comparación de los valores de y e ŷ en un trazado:

El aprendizaje automático se basa en estadísticas y matemáticas, y es importante

En el caso de los datos de validación, el cálculo tiene el siguiente aspecto:

156 159,4 -3,4 11,56

114 111,8 2.2 4.84

129 125,4 3.6 12,96

Ejercicio: Entrenamiento y evaluación de

In most cases, x is actually a vector that consists of multiple feature values, so to be

● Regression algorithms: Algorithms that predict a y value that is a numeric

Explore the Data

● instant: A unique row identifier

As mentioned previously, you can perform some feature engineering to combine or

Train a Regression Model

● X_train: The feature values we'll use to train the model

In Scikit-Learn, training algorithms are encapsulated in estimators, and in this case

Evaluate the Trained Model

Experimentación con modelos

La regresión lineal es la forma más simple de regresión, sin límite en cuanto al

Los algoritmos de conjunto construyen no solo un árbol de decisión, sino un gran

Los científicos de datos suelen experimentar con el uso de modelos diferentes. En el

Now we have the following four datasets: