Databases provide efficient ways to store and query data using query languages, but the most flexible method for processing data is writing your own program to manipulate it. Often, database queries are more effective, but in cases where complex data processing is required, SQL may not be sufficient.
While databases offer very efficient ways to store data and query them using query languages, the most flexible way of data processing is writing your own program to manipulate data. In many cases, doing a database query would be a more effective way. However in some cases when more complex data processing is needed, it cannot be done easily using SQL.
Data processing can be programmed in any programming language, but there are certain languages that are higher level with respect to working with data. Data scientists typically prefer one of the following languages:
Data processing can be done in any programming language, but some languages are better suited for working with data. Data scientists typically use one of the following:
* **[Python](https://www.python.org/)**, a general-purpose programming language, which is often considered one of the best options for beginners due to its simplicity. Python has a lot of additional libraries that can help you solve many practical problems, such as extracting your data from ZIP archive, or converting picture to grayscale. In addition to data science, Python is also often used for web development.
* **[R](https://www.r-project.org/)** is a traditional toolbox developed with statistical data processing in mind. It also contains large repository of libraries (CRAN), making it a good choice for data processing. However, R is not a general-purpose programming language, and is rarely used outside of data science domain.
* **[Julia](https://julialang.org/)** is another language developed specifically for data science. It is intended to give better performance than Python, making it a great tool for scientific experimentation.
* **[Python](https://www.python.org/)**: A general-purpose programming language often recommended for beginners due to its simplicity. Python has many libraries that can help solve practical problems, such as extracting data from ZIP archives or converting images to grayscale. Beyond data science, Python is widely used for web development.
* **[R](https://www.r-project.org/)**: A traditional tool designed for statistical data processing. It has a large library repository (CRAN), making it a strong choice for data analysis. However, R is not a general-purpose language and is rarely used outside of data science.
* **[Julia](https://julialang.org/)**: A language specifically developed for data science, offering better performance than Python, making it ideal for scientific experiments.
In this lesson, we will focus on using Python for simple data processing. We will assume basic familiarity with the language. If you want a deeper tour of Python, you can refer to one of the following resources:
In this lesson, we will focus on Python for simple data processing, assuming basic familiarity with the language. For a deeper dive into Python, consider these resources:
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse) - GitHub-based quick intro course into Python Programming
* [Take your First Steps with Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Learning Path on [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse) - A quick intro course on GitHub.
* [Take your First Steps with Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) - A learning path on [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum).
Data can come in many forms. In this lesson, we will consider three forms of data - **tabular data**, **text** and **images**.
Data can take many forms. In this lesson, we will focus on three types: **tabular data**, **text**, and **images**.
We will focus on a few examples of data processing, instead of giving you full overview of all related libraries. This would allow you to get the main idea of what's possible, and leave you with understanding on where to find solutions to your problems when you need them.
> **Most useful advice**. When you need to perform certain operation on data that you do not know how to do, try searching for it in the internet. [Stackoverflow](https://stackoverflow.com/) usually contains a lot of useful code sample in Python for many typical tasks.
Rather than covering all related libraries, we will focus on a few examples of data processing. This approach will give you a sense of what's possible and help you understand where to find solutions when needed.
> **Best advice**: If you're unsure how to perform a specific data operation, search online. [Stackoverflow](https://stackoverflow.com/) often has useful Python code samples for common tasks.
You’ve already encountered tabular data when learning about relational databases. When dealing with large datasets spread across multiple linked tables, SQL is the best tool. However, when working with a single table and trying to gain **insights** or **understanding**—such as analyzing distributions or correlations—Python is a great choice. Data science often involves transforming data and visualizing it, both of which are easily done in Python.
You have already met tabular data when we talked about relational databases. When you have a lot of data, and it is contained in many different linked tables, it definitely makes sense to use SQL for working with it. However, there are many cases when we have a table of data, and we need to gain some **understanding** or **insights** about this data, such as the distribution, correlation between values, etc. In data science, there are a lot of cases when we need to perform some transformations of the original data, followed by visualization. Both those steps can be easily done using Python.
Two key Python libraries for working with tabular data are:
* **[Pandas](https://pandas.pydata.org/)**: Enables manipulation of **DataFrames**, which are similar to relational tables. You can name columns and perform operations on rows, columns, or entire DataFrames.
* **[Numpy](https://numpy.org/)**: A library for working with **tensors**, or multi-dimensional **arrays**. Arrays contain values of the same type and are simpler than DataFrames, offering more mathematical operations with less overhead.
There are two most useful libraries in Python that can help you deal with tabular data:
* **[Pandas](https://pandas.pydata.org/)** allows you to manipulate so-called **Dataframes**, which are analogous to relational tables. You can have named columns, and perform different operations on row, columns and dataframes in general.
* **[Numpy](https://numpy.org/)** is a library for working with **tensors**, i.e. multi-dimensional **arrays**. Array has values of the same underlying type, and it is simpler than dataframe, but it offers more mathematical operations, and creates less overhead.
Other useful libraries include:
* **[Matplotlib](https://matplotlib.org/)**: Used for data visualization and graph plotting.
* **[SciPy](https://www.scipy.org/)**: Provides additional scientific functions. You may recall this library from discussions on probability and statistics.
There are also a couple of other libraries you should know about:
* **[Matplotlib](https://matplotlib.org/)** is a library used for data visualization and plotting graphs
* **[SciPy](https://www.scipy.org/)** is a library with some additional scientific functions. We have already come across this library when talking about probability and statistics
Here’s a typical code snippet for importing these libraries at the start of a Python program:
Here is a piece of code that you would typically use to import those libraries in the beginning of your Python program:
```python
import numpy as np
import pandas as pd
@ -47,15 +48,15 @@ import matplotlib.pyplot as plt
from scipy import ... # you need to specify exact sub-packages that you need
```
Pandas revolves around a few key concepts.
Pandas is centered around a few basic concepts.
### Series
A **Series** is a sequence of values, similar to a list or numpy array. The key difference is that a Series has an **index**, which is considered during operations like addition. The index can be as simple as an integer row number (default when creating a Series from a list or array) or more complex, like a date range.
**Series** is a sequence of values, similar to a list or numpy array. The main difference is that series also has an **index**, and when we operate on series (eg., add them), the index is taken into account. Index can be as simple as integer row number (it is the index used by default when creating a series from list or array), or it can have a complex structure, such as date interval.
> **Note**: Introductory Pandas code is available in the accompanying notebook [`notebook.ipynb`](notebook.ipynb). We’ll outline some examples here, but feel free to explore the full notebook.
> **Note**: There is some introductory Pandas code in the accompanying notebook [`notebook.ipynb`](notebook.ipynb). We only outline some the examples here, and you are definitely welcome to check out the full notebook.
For example, let’s analyze sales at an ice cream shop. We’ll generate a Series of daily sales numbers over a period of time:
Consider an example: we want to analyze sales of our ice-cream spot. Let's generate a series of sales numbers (number of items sold each day) for some time period:
```python
start_date = "Jan 1, 2020"
@ -67,20 +68,20 @@ items_sold.plot()
```
Now, suppose we host weekly parties where we consume an additional 10 packs of ice cream. We can create another Series indexed by week to represent this:
Now suppose that each week we are organizing a party for friends, and we take additional 10 packs of ice-cream for a party. We can create another series, indexed by week, to demonstrate that:
> **Note**: We don’t use the simple syntax `total_items + additional_items`. Doing so would result in many `NaN` (*Not a Number*) values in the resulting Series because missing values in the `additional_items` Series lead to `NaN` when added. Instead, we specify the`fill_value` parameter during addition.
> **Note** that we are not using simple syntax `total_items+additional_items`. If we did, we would have received a lot of `NaN` (*Not a Number*) values in the resulting series. This is because there are missing values for some of the index point in the `additional_items` series, and adding `Nan` to anything results in `NaN`. Thus we need to specify`fill_value` parameter during addition.
With time series, we can also **resample**data at different intervals. For instance, to calculate monthly average sales:
With time series, we can also **resample**the series with different time intervals. For example, suppose we want to compute mean sales volume monthly. We can use the following code:
```python
monthly = total_items.resample("1M").mean()
ax = monthly.plot(kind='bar')
@ -89,23 +90,23 @@ ax = monthly.plot(kind='bar')
### DataFrame
A DataFrame is essentially a collection of Series with the same index. We can combine multiple Series into a DataFrame:
A DataFrame is essentially a collection of series with the same index. We can combine several series together into a DataFrame:
```python
a = pd.Series(range(1,10))
b = pd.Series(["I","like","to","play","games","and","will","not","change"],index=range(0,9))
Here, `.T` transposes the DataFrame (swapping rows and columns), and `rename` allows us to rename columns to match the previous example.
Here`.T` means the operation of transposing the DataFrame, i.e. changing rows and columns, and `rename` operation allows us to rename columns to match the previous example.
Key operations on DataFrames include:
Here are a few most important operations we can perform on DataFrames:
**Column selection**: Select individual columns with `df['A']` (returns a Series) or a subset of columns with `df[['B', 'A']]` (returns another DataFrame).
**Column selection**. We can select individual columns by writing `df['A']` - this operation returns a Series. We can also select a subset of columns into another DataFrame by writing `df[['B','A']]` - this return another DataFrame.
**Filtering rows**: Filter rows based on criteria, e.g., `df[df['A'] > 5]` keeps rows where column `A` is greater than 5.
**Filtering** only certain rows by criteria. For example, to leave only rows with column `A` greater than 5, we can write `df[df['A']>5]`.
> **Note**: Filtering works by creating a boolean Series (`df['A'] <5`)thatindicateswhethertheconditionis`True`or`False`foreachelement.UsingthisbooleanSeriesasanindexreturnsthefilteredrows.AvoidusingPythonbooleanexpressionslike`df[df['A'] > 5 and df['A'] < 7]`.Instead,use`&`forbooleanSeries:`df[(df['A'] > 5) & (df['A'] < 7)]`(*bracketsarerequired*).
> **Note**: The way filtering works is the following. The expression `df['A']<5` returns a boolean series, which indicates whether expression is `True` or `False` for each element of the original series `df['A']`. When boolean series is used as an index, it returns subset of rows in the DataFrame. Thus it is not possible to use arbitrary Python boolean expression, for example, writing `df[df['A']>5 and df['A']<7]` would be wrong. Instead, you should use special `&` operation on boolean series, writing `df[(df['A']>5) & (df['A']<7)]` (*brackets are important here*).
**Creating new columns**: Add new columns with expressions like:
**Creating new computable columns**. We can easily create new computable columns for our DataFrame by using intuitive expression like this:
```python
df['DivA'] = df['A']-df['A'].mean()
```
This calculates the divergence of `A` from its mean value. The left-hand side assigns the computed Series to a new column. Avoid incompatible operations, such as:
This example calculates divergence of A from its mean value. What actually happens here is we are computing a series, and then assigning this series to the left-hand-side, creating another column. Thus, we cannot use any operations that are not compatible with series, for example, the code below is wrong:
```python
# Wrong code -> df['ADescr'] = "Low" if df['A'] <5else"Hi"
df['LenB'] = len(df['B']) # <-Wrongresult
```
This example assigns the length of Series `B` to all values in the column, not the length of individual elements.
The latter example, while being syntactically correct, gives us wrong result, because it assigns the length of series `B` to all values in the column, and not the length of individual elements as we intended.
For complex expressions, use the `apply` function:
If we need to compute complex expressions like this, we can use `apply` function. The last example can be written as follows:
```python
df['LenB'] = df['B'].apply(lambda x : len(x))
# or
# or
df['LenB'] = df['B'].apply(len)
```
After these operations, the resulting DataFrame looks like this:
After operations above, we will end up with the following DataFrame:
| | A | B | DivA | LenB |
| --- | --- | ------ | ---- | ---- |
@ -165,22 +166,22 @@ After these operations, the resulting DataFrame looks like this:
| 7 | 8 | very | 3.0 | 4 |
| 8 | 9 | much | 4.0 | 4 |
**Selecting rows by index**: Use `iloc` to select rows by position. For example, to select the first 5 rows:
**Selecting rows based on numbers** can be done using `iloc` construct. For example, to select first 5 rows from the DataFrame:
```python
df.iloc[:5]
```
**Grouping**: Grouping is useful for results similar to *pivot tables* in Excel. For example, to calculate the mean of column `A` for each unique value in `LenB`:
**Grouping** is often used to get a result similar to *pivot tables* in Excel. Suppose that we want to compute mean value of column `A` for each given number of `LenB`. Then we can group our DataFrame by `LenB`, and call `mean`:
```python
df.groupby(by='LenB')[['A','DivA']].mean()
```
For more complex aggregations, use the`aggregate` function:
If we need to compute mean and the number of elements in the group, then we can use more complex`aggregate` function:
@ -191,81 +192,84 @@ This produces the following table:
| 6 | 2 | 6.000000 |
### Getting Data
We have seen how simple it is to create Series and DataFrames from Python objects. However, data is often stored in text files or Excel tables. Fortunately, Pandas provides an easy way to load data from disk. For instance, reading a CSV file is as straightforward as this:
We have seen how easy it is to construct Series and DataFrames from Python objects. However, data usually comes in the form of a text file, or an Excel table. Luckily, Pandas offers us a simple way to load data from disk. For example, reading CSV file is as simple as this:
```python
df = pd.read_csv('file.csv')
```
We will explore more examples of loading data, including retrieving it from external websites, in the "Challenge" section.
```
We will see more examples of loading data, including fetching it from external web sites, in the "Challenge" section
### Printing and Plotting
A Data Scientist frequently needs to explore data, so being able to visualize it is crucial. When working with large DataFrames, we often want to ensure everything is functioning correctly by printing the first few rows. This can be achieved by calling `df.head()`. If you run this in Jupyter Notebook, it will display the DataFrame in a neat tabular format.
A Data Scientist often has to explore the data, thus it is important to be able to visualize it. When DataFrame is big, many times we want just to make sure we are doing everything correctly by printing out the first few rows. This can be done by calling `df.head()`. If you are running it from Jupyter Notebook, it will print out the DataFrame in a nice tabular form.
We’ve also seen how to use the `plot` function to visualize specific columns. While `plot` is highly versatile and supports various graph types via the `kind=` parameter, you can always use the raw `matplotlib` library for more complex visualizations. We will delve deeper into data visualization in separate course lessons.
We have also seen the usage of `plot` function to visualize some columns. While `plot` is very useful for many tasks, and supports many different graph types via `kind=` parameter, you can always use raw `matplotlib` library to plot something more complex. We will cover data visualization in detail in separate course lessons.
This overview covers the key concepts of Pandas, but the library is incredibly rich, offering endless possibilities! Let’s now apply this knowledge to solve specific problems.
This overview covers most important concepts of Pandas, however, the library is very rich, and there is no limit to what you can do with it! Let's now apply this knowledge for solving specific problem.
## 🚀 Challenge 1: Analyzing COVID Spread
The first problem we’ll tackle is modeling the spread of the COVID-19 epidemic. To do this, we’ll use data on the number of infected individuals across different countries, provided by the [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) at [Johns Hopkins University](https://jhu.edu/). The dataset is available in [this GitHub Repository](https://github.com/CSSEGISandData/COVID-19).
First problem we will focus on is modelling of epidemic spread of COVID-19. In order to do that, we will use the data on the number of infected individuals in different countries, provided by the [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) at [Johns Hopkins University](https://jhu.edu/). Dataset is available in [this GitHub Repository](https://github.com/CSSEGISandData/COVID-19).
To demonstrate how to work with data, we encourage you to open [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) and go through it from start to finish. You can also execute the cells and try out some challenges we’ve included at the end.
Since we want to demonstrate how to deal with data, we invite you to open [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) and read it from top to bottom. You can also execute cells, and do some challenges that we have left for you at the end.
> If you’re unfamiliar with running code in Jupyter Notebook, check out [this article](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
> If you do not know how to run code in Jupyter Notebook, have a look at [this article](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
## Working with Unstructured Data
While data often comes in tabular form, there are cases where we need to work with less structured data, such as text or images. In these situations, to apply the data processing techniques we’ve discussed, we need to**extract** structured data. Here are a few examples:
While data very often comes in tabular form, in some cases we need to deal with less structured data, for example, text or images. In this case, to apply data processing techniques we have seen above, we need to somehow**extract** structured data. Here are a few examples:
* Extracting keywords from text and analyzing their frequency
* Using neural networks to identify objects in images
* Detecting emotions in video camera feeds
* Extracting keywords from text, and seeing how often those keywords appear
* Using neural networks to extract information about objects on the picture
* Getting information on emotions of people on video camera feed
## 🚀 Challenge 2: Analyzing COVID Papers
In this challenge, we’ll continue exploring the COVID pandemic by focusing on processing scientific papers on the topic. The [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) contains over 7,000 papers (at the time of writing) on COVID, along with metadata and abstracts (and full text for about half of them).
In this challenge, we will continue with the topic of COVID pandemic, and focus on processing scientific papers on the subject. There is [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) with more than 7000 (at the time of writing) papers on COVID, available with metadata and abstracts (and for about half of them there is also full text provided).
A complete example of analyzing this dataset using the [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) cognitive service is described [in this blog post](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). We’ll discuss a simplified version of this analysis.
A full example of analyzing this dataset using [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) cognitive service is described [in this blog post](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). We will discuss simplified version of this analysis.
> **NOTE**: This repository does not include a copy of the dataset. You may need to download the [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) file from [this Kaggle dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Registration with Kaggle may be required. Alternatively, you can download the dataset without registration [from here](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), which includes all full texts in addition to the metadata file.
> **NOTE**: We do not provide a copy of the dataset as part of this repository. You may first need to download the [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) file from [this dataset on Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Registration with Kaggle may be required. You may also download the dataset without registration [from here](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), but it will include all full texts in addition to metadata file.
Open [`notebook-papers.ipynb`](notebook-papers.ipynb) and go through it from start to finish. You can also execute the cells and try out some challenges we’ve included at the end.
Open [`notebook-papers.ipynb`](notebook-papers.ipynb) and read it from top to bottom. You can also execute cells, and do some challenges that we have left for you at the end.
## Processing Image Data
Recently, powerful AI models have been developed to analyze images. Many tasks can be accomplished using pre-trained neural networks or cloud services. Examples include:
Recently, very powerful AI models have been developed that allow us to understand images. There are many tasks that can be solved using pre-trained neural networks, or cloud services. Some examples include:
* **Image Classification**, which categorizes images into predefined classes. You can train your own classifiers using services like [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum).
* **Object Detection**, which identifies various objects in an image. Services like [Computer Vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) can detect common objects, and you can train [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) models to detect specific objects of interest.
* **Face Detection**, including age, gender, and emotion recognition. This can be achieved using the [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
* **Image Classification**, which can help you categorize the image into one of the pre-defined classes. You can easily train your own image classifiers using services such as [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum)
* **Object Detection** to detect different objects in the image. Services such as [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) can detect a number of common objects, and you can train [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) model to detect some specific objects of interest.
* **Face Detection**, including Age, Gender and Emotion detection. This can be done via [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
All these cloud services can be accessed via [Python SDKs](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), making it easy to integrate them into your data exploration workflow.
All those cloud services can be called using [Python SDKs](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), and thus can be easily incorporated into your data exploration workflow.
Here are some examples of working with image data sources:
* In the blog post [How to Learn Data Science without Coding](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/), we analyze Instagram photos to understand what makes people like a photo more. We extract information from images using [Computer Vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) and use [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) to build an interpretable model.
* In the [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies), we use the [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) to analyze emotions in event photographs to understand what makes people happy.
Here are some examples of exploring data from Image data sources:
* In the blog post [How to Learn Data Science without Coding](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) we explore Instagram photos, trying to understand what makes people give more likes to a photo. We first extract as much information from pictures as possible using [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), and then use [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) to build interpretable model.
* In [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) we use [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) to extract emotions on people on photographs from events, in order to try to understand what makes people happy.
## Conclusion
Whether you’re working with structured or unstructured data, Python allows you to perform all steps related to data processing and analysis. It’s one of the most flexible tools for data processing, which is why most data scientists use Python as their primary tool. If you’re serious about pursuing data science, learning Python in depth is highly recommended!
Whether you already have structured or unstructured data, using Python you can perform all steps related to data processing and understanding. It is probably the most flexible way of data processing, and that is the reason the majority of data scientists use Python as their primary tool. Learning Python in depth is probably a good idea if you are serious about your data science journey!
* [Wes McKinney. Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython](https://www.amazon.com/gp/product/1491957662)
**Online Resources**
* Official [10 minutes to Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html) tutorial
**Online Resources**
* Official [10 minutes to Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html) tutorial
* [Documentation on Pandas Visualization](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html)
**Learning Python**
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse)
**Learning Python**
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse)
* [Take your First Steps with Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Learning Path on [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
## Assignment
@ -274,9 +278,11 @@ Whether you’re working with structured or unstructured data, Python allows you
## Credits
This lesson was created with ♥️ by [Dmitry Soshnikov](http://soshnikov.com)
This lesson has been authored with ♥️ by [Dmitry Soshnikov](http://soshnikov.com)
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we aim for accuracy, please note that automated translations may include errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is advised. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please be aware that automated translations may contain errors or inaccuracies. The original document in its native language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not liable for any misunderstandings or misinterpretations arising from the use of this translation.
[](https://youtu.be/dZjWOGbsN4Y)
Aunque las bases de datos ofrecen formas muy eficientes de almacenar datos y consultarlos mediante lenguajes de consulta, la forma más flexible de procesar datos es escribir tu propio programa para manipularlos. En muchos casos, realizar una consulta en una base de datos sería una forma más efectiva. Sin embargo, en algunos casos donde se necesita un procesamiento de datos más complejo, no se puede hacer fácilmente usando SQL.
El procesamiento de datos se puede programar en cualquier lenguaje de programación, pero hay ciertos lenguajes que son de nivel más alto en lo que respecta al trabajo con datos. Los científicos de datos suelen preferir uno de los siguientes lenguajes:
Mientras que las bases de datos ofrecen formas muy eficientes para almacenar datos y consultarlos usando lenguajes de consulta, la manera más flexible de procesar datos es escribiendo tu propio programa para manipularlos. En muchos casos, hacer una consulta en la base de datos sería un método más efectivo. Sin embargo, en algunos casos, cuando se necesita un procesamiento de datos más complejo, no se puede hacer fácilmente usando SQL.
El procesamiento de datos puede programarse en cualquier lenguaje de programación, pero hay ciertos lenguajes que son de más alto nivel respecto a trabajar con datos. Los científicos de datos típicamente prefieren uno de los siguientes lenguajes:
* **[Python](https://www.python.org/)**, un lenguaje de programación de propósito general, que a menudo se considera una de las mejores opciones para principiantes debido a su simplicidad. Python tiene muchas bibliotecas adicionales que pueden ayudarte a resolver muchos problemas prácticos, como extraer datos de un archivo ZIP o convertir una imagen a escala de grises. Además de la ciencia de datos, Python también se utiliza a menudo para el desarrollo web.
* **[R](https://www.r-project.org/)** es una herramienta tradicional desarrollada con el procesamiento de datos estadísticos en mente. También contiene un gran repositorio de bibliotecas (CRAN), lo que lo convierte en una buena opción para el procesamiento de datos. Sin embargo, R no es un lenguaje de propósito general y rara vez se utiliza fuera del ámbito de la ciencia de datos.
* **[Julia](https://julialang.org/)** es otro lenguaje desarrollado específicamente para la ciencia de datos. Está diseñado para ofrecer un mejor rendimiento que Python, lo que lo convierte en una gran herramienta para la experimentación científica.
* **[Python](https://www.python.org/)**, un lenguaje de programación de propósito general, que a menudo se considera una de las mejores opciones para principiantes debido a su simplicidad. Python tiene muchas bibliotecas adicionales que pueden ayudarte a resolver muchos problemas prácticos, como extraer tus datos de un archivo ZIP, o convertir una imagen a escala de grises. Además del análisis de datos, Python también se usa frecuentemente para desarrollo web.
* **[R](https://www.r-project.org/)** es una caja de herramientas tradicional desarrollada con el procesamiento estadístico en mente. También contiene un gran repositorio de bibliotecas (CRAN), lo que lo hace una buena elección para procesamiento de datos. Sin embargo, R no es un lenguaje de programación de propósito general, y raramente se usa fuera del dominio de la ciencia de datos.
* **[Julia](https://julialang.org/)** es otro lenguaje desarrollado específicamente para la ciencia de datos. Está pensado para ofrecer mejor rendimiento que Python, convirtiéndolo en una gran herramienta para experimentación científica.
En esta lección, nos centraremos en el uso de Python para el procesamiento simple de datos. Supondremos un conocimiento básico del lenguaje. Si deseas un recorrido más profundo por Python, puedes consultar uno de los siguientes recursos:
En esta lección, nos enfocaremos en usar Python para procesamiento simple de datos. Supondremos familiaridad básica con el lenguaje. Si quieres un recorrido más profundo por Python, puedes consultar uno de los siguientes recursos:
* [Aprende Python de una manera divertida con Turtle Graphics y Fractales](https://github.com/shwars/pycourse) - Curso introductorio rápido basado en GitHub sobre programación en Python
* [Da tus primeros pasos con Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Ruta de aprendizaje en [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Aprende Python de Manera Divertida con Turtle Graphics y Fractales](https://github.com/shwars/pycourse) - Curso rápido basado en GitHub sobre programación en Python
* [Da tus Primeros Pasos con Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Ruta de Aprendizaje en [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
Los datos pueden venir en muchas formas. En esta lección, consideraremos tres formas de datos:**datos tabulares**, **texto** e **imágenes**.
Los datos pueden venir en muchas formas. En esta lección, consideraremos tres formas de datos -**datos tabulares**, **texto** e **imágenes**.
Nos centraremos en algunos ejemplos de procesamiento de datos, en lugar de darte una visión completa de todas las bibliotecas relacionadas. Esto te permitirá comprender la idea principal de lo que es posible y te dejará con el conocimiento de dónde encontrar soluciones a tus problemas cuando las necesites.
Nos centraremos en algunos ejemplos de procesamiento de datos, en lugar de darte una visión completa de todas las bibliotecas relacionadas. Esto te permitirá obtener la idea principal de lo que es posible, y te dejará con una comprensión de dónde encontrar soluciones a tus problemas cuando las necesites.
> **El consejo más útil**. Cuando necesites realizar una operación específica en datos y no sepas cómo hacerlo, intenta buscarlo en internet. [Stackoverflow](https://stackoverflow.com/) suele contener muchos ejemplos de código útiles en Python para muchas tareas típicas.
> **Consejo más útil**. Cuando necesites realizar cierta operación sobre datos que no sabes cómo hacer, intenta buscarla en Internet. [Stackoverflow](https://stackoverflow.com/) usualmente contiene muchos ejemplos útiles de código en Python para muchas tareas típicas.
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ds/quiz/12)
## [Cuestionario Previo a la Clase](https://ff-quizzes.netlify.app/en/ds/quiz/12)
## Datos Tabulares y Dataframes
Ya te has encontrado con datos tabulares cuando hablamos de bases de datos relacionales. Cuando tienes muchos datos y están contenidos en muchas tablas vinculadas diferentes, definitivamente tiene sentido usar SQL para trabajar con ellos. Sin embargo, hay muchos casos en los que tenemos una tabla de datos y necesitamos obtener algún **entendimiento** o **perspectivas**sobre estos datos, como la distribución, la correlación entre valores, etc. En la ciencia de datos, hay muchos casos en los que necesitamos realizar algunas transformaciones de los datos originales, seguidas de visualización. Ambos pasos se pueden realizar fácilmente usando Python.
Ya te has encontrado con datos tabulares cuando hablamos de bases de datos relacionales. Cuando tienes mucha data y está contenida en muchas tablas vinculadas diferentes, definitivamente tiene sentido usar SQL para trabajar con ella. Sin embargo, hay muchos casos en los que tenemos una tabla de datos y necesitamos obtener algún **entendimiento** o **perspectivas**acerca de esos datos, como la distribución, la correlación entre valores, etc. En la ciencia de datos, hay muchos casos cuando necesitamos realizar algunas transformaciones de los datos originales, seguidas por visualización. Ambos pasos pueden hacerse fácilmente usando Python.
Hay dos bibliotecas más útiles en Python que pueden ayudarte a trabajar con datos tabulares:
* **[Pandas](https://pandas.pydata.org/)** te permite manipular los llamados **Dataframes**, que son análogos a las tablas relacionales. Puedes tener columnas con nombres y realizar diferentes operaciones en filas, columnas y dataframes en general.
* **[Numpy](https://numpy.org/)** es una biblioteca para trabajar con **tensores**, es decir, **arreglos** multidimensionales. Un arreglo tiene valores del mismo tipo subyacente, y es más simple que un dataframe, pero ofrece más operaciones matemáticas y genera menos sobrecarga.
Hay dos bibliotecas muy útiles en Python que pueden ayudarte a manejar datos tabulares:
* **[Pandas](https://pandas.pydata.org/)** te permite manipular los llamados **Dataframes**, que son análogos a tablas relacionales. Puedes tener columnas nombradas y realizar diferentes operaciones sobre filas, columnas y dataframes en general.
* **[Numpy](https://numpy.org/)** es una biblioteca para trabajar con **tenores**, es decir, **arrays** multidimensionales. Un array tiene valores del mismo tipo subyacente y es más simple que un dataframe, pero ofrece más operaciones matemáticas y crea menos sobrecarga.
También hay un par de otras bibliotecas que deberías conocer:
* **[Matplotlib](https://matplotlib.org/)** es una biblioteca utilizada para la visualización de datos y la creación de gráficos.
* **[SciPy](https://www.scipy.org/)** es una biblioteca con algunas funciones científicas adicionales. Ya nos hemos encontrado con esta biblioteca al hablar de probabilidad y estadística.
También hay un par de otras bibliotecas que deberías conocer:
* **[Matplotlib](https://matplotlib.org/)** es una biblioteca usada para visualización de datos y graficar gráficos
* **[SciPy](https://www.scipy.org/)** es una biblioteca con algunas funciones científicas adicionales. Ya nos encontramos con esta biblioteca al hablar de probabilidad y estadística
Aquí tienes un fragmento de código que normalmente usarías para importar estas bibliotecas al inicio de tu programa en Python:
Aquí hay un fragmento de código que típicamente usarías para importar esas bibliotecas al principio de tu programa Python:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import ... # you need to specify exact sub-packages that you need
```
from scipy import ... # necesitas especificar los sub-paquetes exactos que necesitas
```
Pandas se centra en algunos conceptos básicos.
Pandas se centra en unos pocos conceptos básicos.
### Series
**Series** es una secuencia de valores, similar a una lista o un arreglo de numpy. La principal diferencia es que las series también tienen un **índice**, y cuando operamos con series (por ejemplo, las sumamos), el índice se tiene en cuenta. El índice puede ser tan simple como un número entero que representa el número de fila (es el índice utilizado por defecto al crear una serie a partir de una lista o arreglo), o puede tener una estructura compleja, como un intervalo de fechas.
**Series** es una secuencia de valores, similar a una lista o array numpy. La principal diferencia es que una serie también tiene un **índice**, y cuando operamos sobre series (por ejemplo, sumarlas), el índice es tomado en cuenta. El índice puede ser tan simple como el número entero de la fila (es el índice usado por defecto al crear una serie desde una lista o array), o puede tener una estructura compleja, como un intervalo de fechas.
> **Nota**: Hay algo de código introductorio de Pandas en el cuaderno acompañante [`notebook.ipynb`](notebook.ipynb). Solo presentamos algunos ejemplos aquí, y definitivamente eres bienvenido a revisar el cuaderno completo.
> **Nota**: Hay algo de código introductorio de Pandas en el cuaderno adjunto [`notebook.ipynb`](notebook.ipynb). Aquí solo esbozamos algunos ejemplos, y definitivamente te invitamos a revisar el cuaderno completo.
Considera un ejemplo: queremos analizar las ventas de nuestra heladería. Generemos una serie de números de ventas (número de artículos vendidos cada día) para un cierto periodo de tiempo:
Considera un ejemplo: queremos analizar las ventas de nuestro puesto de helados. Generemos una serie de números de ventas (número de artículos vendidos cada día) durante un período de tiempo:
```
Ahora supongamos que cada semana organizamos una fiesta para amigos y tomamos 10 paquetes adicionales de helado para la fiesta. Podemos crear otra serie, indexada por semana, para demostrar eso:
Supón ahora que cada semana organizamos una fiesta para amigos y llevamos 10 paquetes adicionales de helado para la fiesta. Podemos crear otra serie, indexada por semana, para demostrar esto:
```
> **Nota** que no estamos usando la sintaxis simple `total_items+additional_items`. Si lo hiciéramos, recibiríamos muchos valores `NaN` (*Not a Number*) en la serie resultante. Esto se debe a que hay valores faltantes para algunos puntos del índice en la serie `additional_items`, y sumar `NaN` a cualquier cosa da como resultado`NaN`. Por lo tanto, necesitamos especificar el parámetro `fill_value` durante la suma.
> **Nota** que no estamos usando la sintaxis simple `total_items+additional_items`. Si lo hiciéramos, recibiríamos muchos valores `NaN` (*Not a Number*) en la serie resultante. Esto es porque hay valores faltantes para algunos puntos del índice en la serie `additional_items`, y sumar `NaN` a cualquier cosa resulta en`NaN`. Por lo tanto, necesitamos especificar el parámetro `fill_value` durante la suma.
Con las series temporales, también podemos **re-muestrear** la serie con diferentes intervalos de tiempo. Por ejemplo, supongamos que queremos calcular el volumen promedio de ventas mensuales. Podemos usar el siguiente código:
Con series temporales, también podemos **remuestrear** la serie con diferentes intervalos de tiempo. Por ejemplo, supón que queremos calcular el promedio mensual del volumen de ventas. Podemos usar el siguiente código:
```python
monthly = total_items.resample("1M").mean()
ax = monthly.plot(kind='bar')
```
```
### DataFrame
Un DataFrame es esencialmente una colección de series con el mismo índice. Podemos combinar varias series en un DataFrame:
Un DataFrame es esencialmente una colección de series con el mismo índice. Podemos combinar varias series en un DataFrame:
```python
a = pd.Series(range(1,10))
b = pd.Series(["I","like","to","play","games","and","will","not","change"],index=range(0,9))
Aquí `.T` significa la operación de transponer el DataFrame, es decir, cambiar filas y columnas, y la operación `rename` nos permite renombrar columnas para que coincidan con el ejemplo anterior.
Aquí hay algunas de las operaciones más importantes que podemos realizar en DataFrames:
Estas son algunas de las operaciones más importantes que podemos realizar en DataFrames:
**Selección de columnas**. Podemos seleccionar columnas individuales escribiendo `df['A']` - esta operación devuelve una Serie. También podemos seleccionar un subconjunto de columnas en otro DataFrame escribiendo `df[['B','A']]` - esto devuelve otro DataFrame.
**Selección de columna**. Podemos seleccionar columnas individuales escribiendo `df['A']` - esta operación devuelve una Serie. También podemos seleccionar un subconjunto de columnas en otro DataFrame escribiendo `df[['B','A']]` - esto devuelve otro DataFrame.
**Filtrar** solo ciertas filas según un criterio. Por ejemplo, para dejar solo las filas con la columna `A` mayor que 5, podemos escribir `df[df['A']>5]`.
**Filtrar** solo ciertas filas por criterio. Por ejemplo, para dejar solo filas con columna `A` mayor que 5, podemos escribir `df[df['A']>5]`.
> **Nota**: La forma en que funciona el filtrado es la siguiente. La expresión `df['A']<5` devuelve una serie booleana, que indica si la expresión es `True` o `False` para cada elemento de la serie original `df['A']`. Cuando se usa una serie booleana como índice, devuelve un subconjunto de filas en el DataFrame. Por lo tanto, no es posible usar expresiones booleanas arbitrarias de Python, por ejemplo, escribir `df[df['A']>5 and df['A']<7]` sería incorrecto. En su lugar, debes usar la operación especial `&` en series booleanas, escribiendo `df[(df['A']>5) & (df['A']<7)]` (*los paréntesis son importantes aquí*).
> **Nota**: La forma en que funciona el filtrado es la siguiente. La expresión `df['A']<5` devuelve una serie booleana, que indica si la expresión es `True` o `False` para cada elemento de la serie original `df['A']`. Cuando una serie booleana se usa como índice, devuelve el subconjunto de filas en el DataFrame. Por lo tanto, no es posible usar expresiones booleanas arbitrarias de Python, por ejemplo escribir `df[df['A']>5 and df['A']<7]` sería incorrecto. En cambio, debes usar la operación especial `&` en series booleanas, escribiendo `df[(df['A']>5) & (df['A']<7)]` (*los paréntesis son importantes aquí*).
**Crear nuevas columnas calculables**. Podemos crear fácilmente nuevas columnas calculables para nuestro DataFrame usando expresiones intuitivas como esta:
**Crear nuevas columnas computables**. Podemos crear fácilmente nuevas columnas computables para nuestro DataFrame usando expresiones intuitivas como esta:
```python
df['DivA'] = df['A']-df['A'].mean()
```
Este ejemplo calcula la divergencia de A respecto a su valor medio. Lo que realmente sucede aquí es que estamos calculando una serie y luego asignando esta serie al lado izquierdo, creando otra columna. Por lo tanto, no podemos usar operaciones que no sean compatibles con series, por ejemplo, el siguiente código es incorrecto:
```
Este ejemplo calcula la divergencia de A respecto a su valor medio. Lo que realmente ocurre aquí es que estamos computando una serie y luego asignando esta serie al lado izquierdo, creando otra columna. Por lo tanto, no podemos usar operaciones que no sean compatibles con series, por ejemplo, el siguiente código está mal:
```python
# Wrong code -> df['ADescr'] = "Low" if df['A'] <5else"Hi"
df['LenB'] = len(df['B']) # <-Wrong result
```
El último ejemplo, aunque sintácticamente correcto, nos da un resultado incorrecto, porque asigna la longitud de la serie `B` a todos los valores en la columna, y no la longitud de los elementos individuales como pretendíamos.
# Código incorrecto -> df['ADescr'] = "Bajo" si df['A'] <5sino"Alto"
El último ejemplo, aunque es sintácticamente correcto, nos da un resultado incorrecto, porque asigna la longitud de la serie `B` a todos los valores en la columna, y no la longitud de los elementos individuales como se pretendía.
Si necesitamos calcular expresiones complejas como esta, podemos usar la función `apply`. El último ejemplo se puede escribir de la siguiente manera:
Si necesitamos computar expresiones complejas como esta, podemos usar la función `apply`. El último ejemplo puede escribirse así:
```python
df['LenB'] = df['B'].apply(lambda x : len(x))
# or
# o
df['LenB'] = df['B'].apply(len)
```
```
Después de las operaciones anteriores, terminaremos con el siguiente DataFrame:
@ -163,21 +166,21 @@ Después de las operaciones anteriores, terminaremos con el siguiente DataFrame:
| 7 | 8 | very | 3.0 | 4 |
| 8 | 9 | much | 4.0 | 4 |
**Seleccionar filas según números** se puede hacer usando la construcción `iloc`. Por ejemplo, para seleccionar las primeras 5 filas del DataFrame:
**Seleccionar filas basándose en números** puede hacerse usando la construcción `iloc`. Por ejemplo, para seleccionar las primeras 5 filas del DataFrame:
```python
df.iloc[:5]
```
```
**Agrupación** se utiliza a menudo para obtener un resultado similar a las *tablas dinámicas* en Excel. Supongamos que queremos calcular el valor medio de la columna `A` para cada número dado de `LenB`. Entonces podemos agrupar nuestro DataFrame por `LenB` y llamar a `mean`:
**Agrupar** se usa a menudo para obtener un resultado similar a las *tablas dinámicas* en Excel. Supongamos que queremos calcular el valor medio de la columna `A` para cada número dado de `LenB`. Entonces podemos agrupar nuestro DataFrame por `LenB`, y llamar a `mean`:
```python
df.groupby(by='LenB')[['A','DivA']].mean()
```
Si necesitamos calcular la media y el número de elementos en el grupo, entonces podemos usar la función más compleja `aggregate`:
```
Si necesitamos calcular la media y el número de elementos en el grupo, podemos usar la función más compleja `aggregate`:
@ -188,93 +191,98 @@ Esto nos da la siguiente tabla:
| 4 | 3 | 6.333333 |
| 6 | 2 | 6.000000 |
### Obtener Datos
Hemos visto lo fácil que es construir Series y DataFrames a partir de objetos de Python. Sin embargo, los datos suelen venir en forma de un archivo de texto o una tabla de Excel. Afortunadamente, Pandas nos ofrece una manera sencilla de cargar datos desde el disco. Por ejemplo, leer un archivo CSV es tan simple como esto:
### Obteniendo Datos
Hemos visto lo fácil que es construir Series y DataFrames a partir de objetos de Python. Sin embargo, los datos usualmente vienen en forma de un archivo de texto o una tabla de Excel. Por suerte, Pandas nos ofrece una forma sencilla de cargar datos desde el disco. Por ejemplo, leer un archivo CSV es tan simple como esto:
```python
df = pd.read_csv('file.csv')
```
Veremos más ejemplos de cómo cargar datos, incluyendo cómo obtenerlos de sitios web externos, en la sección "Desafío".
```
Veremos más ejemplos de carga de datos, incluyendo cómo obtenerlos desde sitios web externos, en la sección "Desafío"
### Imprimir y Graficar
### Imprimir y Graficar
Un Científico de Datos a menudo tiene que explorar los datos, por lo que es importante poder visualizarlos. Cuando el DataFrame es grande, muchas veces queremos asegurarnos de que estamos haciendo todo correctamente imprimiendo las primeras filas. Esto se puede hacer llamando a `df.head()`. Si lo ejecutas desde Jupyter Notebook, imprimirá el DataFrame en una forma tabular agradable.
Un Científico de Datos a menudo tiene que explorar los datos, por lo tanto es importante poder visualizarlos. Cuando el DataFrame es grande, muchas veces solo queremos asegurarnos de que estamos haciendo todo correctamente imprimiendo las primeras filas. Esto se puede hacer llamando a `df.head()`. Si lo haces desde Jupyter Notebook, imprimirá el DataFrame en una forma tabular agradable.
También hemos visto el uso de la función `plot` para visualizar algunas columnas. Aunque `plot` es muy útil para muchas tareas y admite muchos tipos de gráficos diferentes mediante el parámetro `kind=`, siempre puedes usar la biblioteca `matplotlib` para graficar algo más complejo. Cubriremos la visualización de datos en detalle en lecciones separadas del curso.
También hemos visto el uso de la función `plot` para visualizar algunas columnas. Mientras que `plot` es muy útil para muchas tareas y soporta diferentes tipos de gráficos vía el parámetro `kind=`, siempre puedes usar la biblioteca `matplotlib` para graficar algo más complejo. Cubriremos la visualización de datos en detalle en lecciones separadas del curso.
Este resumen cubre los conceptos más importantes de Pandas, sin embargo, la biblioteca es muy rica y no hay límite para lo que puedes hacer con ella. ¡Ahora apliquemos este conocimiento para resolver un problema específico!
Esta visión general cubre los conceptos más importantes de Pandas, sin embargo, la biblioteca es muy rica, ¡y no hay límite a lo que puedes hacer con ella! Ahora apliquemos este conocimiento para resolver un problema específico.
## 🚀 Desafío 1: Analizando la Propagación del COVID
## 🚀 Desafío 1: Analizando la Propagación del COVID
El primer problema en el que nos enfocaremos es el modelado de la propagación epidémica del COVID-19. Para ello, utilizaremos los datos sobre el número de personas infectadas en diferentes países, proporcionados por el [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) de la [Universidad Johns Hopkins](https://jhu.edu/). El conjunto de datos está disponible en [este repositorio de GitHub](https://github.com/CSSEGISandData/COVID-19).
El primer problema en el que nos enfocaremos es el modelado de la propagación epidémica del COVID-19. Para ello, usaremos los datos sobre el número de individuos infectados en diferentes países, proporcionados por el [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) de la [Universidad Johns Hopkins](https://jhu.edu/). El conjunto de datos está disponible en [este repositorio de GitHub](https://github.com/CSSEGISandData/COVID-19).
Como queremos demostrar cómo manejar datos, te invitamos a abrir [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) y leerlo de principio a fin. También puedes ejecutar las celdas y realizar algunos desafíos que hemos dejado para ti al final.
Ya que queremos demostrar cómo trabajar con datos, te invitamos a abrir [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) y leerlo de arriba a abajo. También puedes ejecutar las celdas y realizar algunos desafíos que hemos dejado para ti al final.
> Si no sabes cómo ejecutar código en Jupyter Notebook, consulta [este artículo](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
> Si no sabes cómo ejecutar código en Jupyter Notebook, echa un vistazo a [este artículo](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
## Trabajando con Datos No Estructurados
## Trabajando con Datos No Estructurados
Aunque los datos suelen venir en forma tabular, en algunos casos necesitamos trabajar con datos menos estructurados, como texto o imágenes. En este caso, para aplicar las técnicas de procesamiento de datos que hemos visto anteriormente, necesitamos de alguna manera **extraer** datos estructurados. Aquí hay algunos ejemplos:
Aunque los datos muy a menudo vienen en forma tabular, en algunos casos necesitamos trabajar con datos menos estructurados, por ejemplo, texto o imágenes. En estos casos, para aplicar las técnicas de procesamiento de datos que hemos visto arriba, necesitamos de alguna forma **extraer** datos estructurados. Aquí algunos ejemplos:
* Extraer palabras clave de un texto y ver con qué frecuencia aparecen.
* Usar redes neuronales para extraer información sobre objetos en una imagen.
* Obtener información sobre las emociones de las personas en un video.
* Extraer palabras clave del texto y ver con qué frecuencia aparecen esas palabras clave
* Usar redes neuronales para extraer información sobre objetos en la imagen
* Obtener información sobre emociones de personas en la transmisión de video de una cámara
## 🚀 Desafío 2: Analizando Artículos sobre COVID
## 🚀 Desafío 2: Analizando Artículos sobre COVID
En este desafío, continuaremos con el tema de la pandemia de COVID y nos enfocaremos en procesar artículos científicos sobre el tema. Existe el [Conjunto de Datos CORD-19](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) con más de 7000 (en el momento de escribir esto) artículos sobre COVID, disponible con metadatos y resúmenes (y para aproximadamente la mitad de ellos también se proporciona el texto completo).
En este desafío, continuaremos con el tema de la pandemia de COVID y nos enfocaremos en procesar artículos científicos sobre el tema. Existe el Conjunto de Datos [CORD-19](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) con más de 7000 (al momento de escribir) artículos sobre COVID, disponible con metadatos y resúmenes (y para aproximadamente la mitad de ellos también se proporciona el texto completo).
Un ejemplo completo de análisis de este conjunto de datos utilizando el servicio cognitivo [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) se describe [en este blog](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Discutiremos una versión simplificada de este análisis.
Un ejemplo completo de análisis de este conjunto de datos usando el servicio cognitivo [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) está descrito [en esta publicación de blog](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Discutiremos una versión simplificada de este análisis.
> **NOTE**: No proporcionamos una copia del conjunto de datos como parte de este repositorio. Es posible que primero necesites descargar el archivo [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) de [este conjunto de datos en Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Es posible que se requiera registrarse en Kaggle. También puedes descargar el conjunto de datos sin registrarte [desde aquí](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), pero incluirá todos los textos completos además del archivo de metadatos.
> **NOTA**: No proporcionamos una copia del conjunto de datos como parte de este repositorio. Primero puede que necesites descargar el archivo [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) desde [este conjunto de datos en Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Puede ser necesaria la inscripción en Kaggle. También puedes descargar el conjunto de datos sin registrarte [desde aquí](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), pero incluirá todos los textos completos además del archivo de metadatos.
Abre [`notebook-papers.ipynb`](notebook-papers.ipynb) y léelo de principio a fin. También puedes ejecutar las celdas y realizar algunos desafíos que hemos dejado para ti al final.
Abre [`notebook-papers.ipynb`](notebook-papers.ipynb) y léelo de arriba a abajo. También puedes ejecutar las celdas y realizar algunos desafíos que hemos dejado para ti al final.
Recientemente, se han desarrollado modelos de IA muy potentes que nos permiten comprender imágenes. Hay muchas tareas que se pueden resolver utilizando redes neuronales preentrenadas o servicios en la nube. Algunos ejemplos incluyen:
Recientemente, se han desarrollado modelos de IA muy poderosos que nos permiten comprender imágenes. Hay muchas tareas que pueden resolverse usando redes neuronales preentrenadas o servicios en la nube. Algunos ejemplos incluyen:
* **Clasificación de Imágenes**, que puede ayudarte a categorizar la imagen en una de las clases predefinidas. Puedes entrenar fácilmente tus propios clasificadores de imágenes utilizando servicios como [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum).
* **Detección de Objetos** para detectar diferentes objetos en la imagen. Servicios como [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) pueden detectar varios objetos comunes, y puedes entrenar un modelo de [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) para detectar objetos específicos de interés.
* **Detección de Rostros**, incluyendo edad, género y emociones. Esto se puede hacer mediante [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
* **Clasificación de Imágenes**, que puede ayudarte a categorizar la imagen en una de las clases predefinidas. Puedes entrenar fácilmente tus propios clasificadores de imágenes usando servicios como [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum)
* **Detección de Objetos** para detectar diferentes objetos en la imagen. Servicios como [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) pueden detectar varios objetos comunes, y puedes entrenar un modelo [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) para detectar algunos objetos específicos de interés.
* **Detección de Rostros**, incluyendo detección de Edad, Género y Emoción. Esto puede hacerse mediante [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
Todos estos servicios en la nube se pueden llamar utilizando [Python SDKs](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), y por lo tanto pueden incorporarse fácilmente en tu flujo de trabajo de exploración de datos.
Todos esos servicios en la nube pueden ser llamados usando [SDKs de Python](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), y así pueden incorporarse fácilmente en tu flujo de trabajo de exploración de datos.
Aquí hay algunos ejemplos de exploración de datos a partir de fuentes de datos de imágenes:
* En el blog [Cómo Aprender Ciencia de Datos sin Programar](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) exploramos fotos de Instagram, tratando de entender qué hace que las personas den más "me gusta" a una foto. Primero extraemos tanta información como sea posible de las imágenes utilizando [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), y luego usamos [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) para construir un modelo interpretable.
* En el [Taller de Estudios Faciales](https://github.com/CloudAdvocacy/FaceStudies) usamos [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) para extraer emociones de personas en fotografías de eventos, con el objetivo de entender qué hace felices a las personas.
Aquí algunos ejemplos de exploración de datos desde fuentes de datos de imágenes:
* En el post del blog [Cómo aprender ciencia de datos sin programar](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) exploramos fotos de Instagram, tratando de entender qué hace que las personas den más "me gusta" a una foto. Primero extraemos tanta información como sea posible de las imágenes usando [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), y luego usamos [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) para construir un modelo interpretable.
* En [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) usamos [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) para extraer emociones de personas en fotografías de eventos, con el fin de tratar de entender qué hace felices a las personas.
## Conclusión
## Conclusión
Ya sea que tengas datos estructurados o no estructurados, usando Python puedes realizar todos los pasos relacionados con el procesamiento y la comprensión de datos. Probablemente sea la forma más flexible de procesar datos, y esa es la razón por la que la mayoría de los científicos de datos usan Python como su herramienta principal. ¡Aprender Python en profundidad probablemente sea una buena idea si estás serio sobre tu camino en la ciencia de datos!
Ya sea que ya tengas datos estructurados o no estructurados, usando Python puedes realizar todos los pasos relacionados con el procesamiento y entendimiento de datos. Probablemente es la forma más flexible de procesar datos, y esa es la razón por la que la mayoría de los científicos de datos usan Python como su herramienta principal. Aprender Python en profundidad probablemente sea una buena idea si estás serio en tu camino en ciencia de datos.
## [Examen posterior a la lección](https://ff-quizzes.netlify.app/en/ds/quiz/13)
## Revisión y Autoestudio
## Repaso y Autoestudio
**Libros**
* [Wes McKinney. Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython](https://www.amazon.com/gp/product/1491957662)
**Libros**
* [Wes McKinney. Python para el Análisis de Datos: Manipulación de Datos con Pandas, NumPy e IPython](https://www.amazon.com/gp/product/1491957662)
**Recursos en Línea**
* Tutorial oficial [10 minutos con Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html)
* [Documentación sobre Visualización en Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html)
**Recursos en línea**
* Tutorial oficial [10 minutos para Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html)
* [Documentación sobre Visualización en Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html)
**Aprendiendo Python**
* [Aprende Python de una manera divertida con Turtle Graphics y Fractales](https://github.com/shwars/pycourse)
* [Da tus primeros pasos con Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Ruta de aprendizaje en [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
**Aprender Python**
* [Aprende Python de forma divertida con Turtle Graphics y Fractales](https://github.com/shwars/pycourse)
* [Da tus primeros pasos con Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Camino de aprendizaje en [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
## Tarea
## Tarea
[Realiza un estudio de datos más detallado para los desafíos anteriores](assignment.md)
[Realiza un estudio de datos más detallado para los desafíos anteriores](assignment.md)
## Créditos
## Créditos
Esta lección ha sido creada con ♥️ por [Dmitry Soshnikov](http://soshnikov.com)
Esta lección ha sido creada con ♥️ por [Dmitry Soshnikov](http://soshnikov.com)
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por garantizar la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
Bien que les bases de données offrent des moyens très efficaces de stocker et d'interroger des données à l'aide de langages de requête, la méthode la plus flexible pour traiter les données reste d'écrire son propre programme pour les manipuler. Dans de nombreux cas, effectuer une requête dans une base de données serait plus efficace. Cependant, dans certains cas où un traitement de données plus complexe est nécessaire, cela ne peut pas être facilement réalisé avec SQL.
Le traitement des données peut être programmé dans n'importe quel langage, mais certains langages sont plus adaptés au travail avec les données. Les data scientists préfèrent généralement l'un des langages suivants :
Bien que les bases de données offrent des moyens très efficaces de stocker des données et de les interroger en utilisant des langages de requête, la méthode la plus flexible de traitement des données est d'écrire votre propre programme pour manipuler les données. Dans de nombreux cas, effectuer une requête en base de données serait une méthode plus efficace. Cependant, dans certains cas où un traitement de données plus complexe est nécessaire, cela ne peut pas être fait facilement avec SQL.
Le traitement des données peut être programmé dans n'importe quel langage de programmation, mais certains langages sont plus haut niveau en ce qui concerne le travail avec les données. Les data scientists préfèrent généralement l'un des langages suivants :
* **[Python](https://www.python.org/)**, un langage de programmation généraliste, souvent considéré comme l'une des meilleures options pour les débutants grâce à sa simplicité. Python dispose de nombreuses bibliothèques supplémentaires qui peuvent vous aider à résoudre de nombreux problèmes pratiques, comme extraire vos données d'une archive ZIP ou convertir une image en niveaux de gris. En plus de la science des données, Python est également souvent utilisé pour le développement web.
* **[R](https://www.r-project.org/)** est un outil traditionnel développé spécifiquement pour le traitement statistique des données. Il contient également un vaste dépôt de bibliothèques (CRAN), ce qui en fait un bon choix pour le traitement des données. Cependant, R n'est pas un langage de programmation généraliste et est rarement utilisé en dehors du domaine de la science des données.
* **[Julia](https://julialang.org/)** est un autre langage développé spécifiquement pour la science des données. Il est conçu pour offrir de meilleures performances que Python, ce qui en fait un excellent outil pour les expérimentations scientifiques.
* **[Python](https://www.python.org/)**, un langage de programmation à usage général, considéré souvent comme l'une des meilleures options pour les débutants grâce à sa simplicité. Python possède de nombreuses bibliothèques supplémentaires qui peuvent vous aider à résoudre de nombreux problèmes pratiques, comme extraire vos données d'une archive ZIP, ou convertir une image en niveaux de gris. En plus de la science des données, Python est souvent utilisé pour le développement web.
* **[R](https://www.r-project.org/)** est une boîte à outils traditionnelle développée pour le traitement statistique des données. Elle contient également un vaste dépôt de bibliothèques (CRAN), ce qui en fait un bon choix pour le traitement des données. Cependant, R n’est pas un langage de programmation à usage général, et est rarement utilisé en dehors du domaine de la science des données.
* **[Julia](https://julialang.org/)** est un autre langage développé spécifiquement pour la science des données. Il est destiné à offrir de meilleures performances que Python, ce qui en fait un excellent outil pour l'expérimentation scientifique.
Dans cette leçon, nous nous concentrerons sur l'utilisation de Python pour un traitement simple des données. Nous supposerons une familiarité de base avec le langage. Si vous souhaitez une introduction plus approfondie à Python, vous pouvez consulter l'une des ressources suivantes :
Dans cette leçon, nous nous concentrerons sur l'utilisation de Python pour un traitement simple des données. Nous supposerons une familiarité de base avec ce langage. Si vous souhaitez un tour plus approfondi de Python, vous pouvez vous référer à l'une des ressources suivantes :
* [Apprenez Python de manière ludique avec Turtle Graphics et les fractales](https://github.com/shwars/pycourse) - Un cours d'introduction rapide à Python sur GitHub
* [Faites vos premiers pas avec Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) - Parcours d'apprentissage sur [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Apprenez Python de manière ludique avec Turtle Graphics et les fractales](https://github.com/shwars/pycourse) - Cours d'introduction rapide à la programmation Python sur GitHub
* [Faites vos premiers pas avec Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Parcours d’apprentissage sur [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
Les données peuvent se présenter sous de nombreuses formes. Dans cette leçon, nous examinerons trois formes de données : **les données tabulaires**, **le texte** et **les images**.
Les données peuvent se présenter sous plusieurs formes. Dans cette leçon, nous examinerons trois formes de données : **les données tabulaires**, **le texte** et **les images**.
Nous nous concentrerons sur quelques exemples de traitement de données, au lieu de vous donner un aperçu complet de toutes les bibliothèques associées. Cela vous permettra de comprendre les possibilités principales et de savoir où chercher des solutions à vos problèmes lorsque vous en aurez besoin.
Nous nous concentrerons sur quelques exemples de traitement des données, au lieu de vous donner une vue d'ensemble complète de toutes les bibliothèques associées. Cela vous permettra de saisir l'idée principale de ce qui est possible, et de comprendre où trouver des solutions à vos problèmes lorsque vous en aurez besoin.
> **Le conseil le plus utile** : Lorsque vous devez effectuer une opération sur des données que vous ne savez pas comment réaliser, essayez de chercher sur Internet. [Stackoverflow](https://stackoverflow.com/) contient généralement de nombreux exemples de code utiles en Python pour de nombreuses tâches typiques.
> **Conseil le plus utile**. Lorsque vous devez effectuer une certaine opération sur des données que vous ne savez pas comment faire, essayez de la rechercher sur internet. [Stackoverflow](https://stackoverflow.com/) contient généralement beaucoup d'exemples de code utiles en Python pour de nombreuses tâches typiques.
Vous avez déjà rencontré des données tabulaires lorsque nous avons parlé des bases de données relationnelles. Lorsque vous avez beaucoup de données contenues dans de nombreuses tables liées, il est logique d'utiliser SQL pour les manipuler. Cependant, il existe de nombreux cas où nous avons une table de données et où nous devons obtenir une **compréhension** ou des **informations** sur ces données, comme leur distribution, les corrélations entre les valeurs, etc. En science des données, il y a de nombreux cas où nous devons effectuer des transformations des données originales, suivies de visualisations. Ces deux étapes peuvent être facilement réalisées avec Python.
## [Quiz avant la conférence](https://ff-quizzes.netlify.app/en/ds/quiz/12)
Il existe deux bibliothèques Python particulièrement utiles pour travailler avec des données tabulaires :
* **[Pandas](https://pandas.pydata.org/)** permet de manipuler ce qu'on appelle des **DataFrames**, qui sont analogues aux tables relationnelles. Vous pouvez avoir des colonnes nommées et effectuer différentes opérations sur les lignes, les colonnes et les DataFrames en général.
* **[Numpy](https://numpy.org/)** est une bibliothèque pour travailler avec des **tenseurs**, c'est-à-dire des **tableaux** multidimensionnels. Un tableau contient des valeurs d'un même type sous-jacent, il est plus simple qu'un DataFrame, mais offre davantage d'opérations mathématiques et génère moins de surcharge.
## Données tabulaires et Dataframes
Il existe également quelques autres bibliothèques que vous devriez connaître :
* **[Matplotlib](https://matplotlib.org/)** est une bibliothèque utilisée pour la visualisation des données et la création de graphiques.
* **[SciPy](https://www.scipy.org/)** est une bibliothèque contenant des fonctions scientifiques supplémentaires. Nous avons déjà rencontré cette bibliothèque en parlant de probabilité et de statistiques.
Vous avez déjà rencontré des données tabulaires lorsque nous avons parlé des bases de données relationnelles. Lorsque vous avez beaucoup de données contenues dans plusieurs tables liées, il est effectivement judicieux d'utiliser SQL pour travailler avec elles. Cependant, il y a beaucoup de cas où nous disposons d'une table de données et devons obtenir une **compréhension** ou des **informations** sur ces données, telles que la distribution, la corrélation entre les valeurs, etc. En science des données, il y a beaucoup de cas où nous devons effectuer certaines transformations sur les données originales, suivies de visualisation. Ces deux étapes peuvent être facilement réalisées avec Python.
Voici un exemple de code que vous utiliseriez typiquement pour importer ces bibliothèques au début de votre programme Python :
Il existe deux bibliothèques très utiles en Python qui peuvent vous aider avec les données tabulaires :
* **[Pandas](https://pandas.pydata.org/)** vous permet de manipuler les **Dataframes**, qui sont analogues aux tables relationnelles. Vous pouvez avoir des colonnes nommées et effectuer différentes opérations sur les lignes, les colonnes et les Dataframes en général.
* **[Numpy](https://numpy.org/)** est une bibliothèque pour travailler avec les **tenseurs**, c'est-à-dire des **tableaux** multidimensionnels. Un tableau a des valeurs du même type sous-jacent, il est plus simple qu’un DataFrame, mais offre plus d'opérations mathématiques et crée moins de surcharge.
Il y a également quelques autres bibliothèques que vous devriez connaître :
* **[Matplotlib](https://matplotlib.org/)** est une bibliothèque utilisée pour la visualisation des données et le traçage de graphes
* **[SciPy](https://www.scipy.org/)** est une bibliothèque avec des fonctions scientifiques supplémentaires. Nous avons déjà rencontré cette bibliothèque en parlant de probabilité et de statistiques
Voici un extrait de code que vous utilisez typiquement pour importer ces bibliothèques au début de votre programme Python :
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import ... # you need to specify exact sub-packages that you need
```
from scipy import ... # vous devez spécifier les sous-paquets exacts dont vous avez besoin
```
Pandas repose sur quelques concepts de base.
Pandas est centré autour de quelques concepts de base.
### Series
Une **Series** est une séquence de valeurs, similaire à une liste ou un tableau numpy. La principale différence est qu'une série possède également un **index**, et lorsque nous effectuons des opérations sur les séries (par exemple, les additionner), l'index est pris en compte. L'index peut être aussi simple qu'un numéro de ligne entier (c'est l'index utilisé par défaut lors de la création d'une série à partir d'une liste ou d'un tableau), ou il peut avoir une structure complexe, comme un intervalle de dates.
**Series** est une séquence de valeurs, similaire à une liste ou à un tableau numpy. La principale différence est que la série a aussi un **index**, et lorsque nous opérons sur les séries (ex., les additionner), l'index est pris en compte. L'index peut être aussi simple que le numéro entier de ligne (c'est l'index utilisé par défaut lors de la création d'une série à partir d'une liste ou d'un tableau), ou il peut avoir une structure complexe, comme un intervalle de dates.
> **Note** : Il y a un peu de code introductif sur Pandas dans le carnet associé [`notebook.ipynb`](notebook.ipynb). Nous ne présentons ici que quelques exemples, et vous êtes bien sûr invités à consulter le carnet complet.
> **Note** : Il y a du code introductif sur Pandas dans le notebook associé [`notebook.ipynb`](notebook.ipynb). Nous ne présentons ici que quelques exemples, mais n'hésitez pas à consulter le notebook complet.
Considérons un exemple : nous voulons analyser les ventes de notre glacier. Générons une série de nombres de ventes (nombre d’articles vendus chaque jour) pour une période donnée :
Prenons un exemple : nous voulons analyser les ventes de notre stand de glaces. Générons une série de chiffres de ventes (nombre d'articles vendus chaque jour) pour une certaine période :
Supposons maintenant que chaque semaine, nous organisons une fête pour nos amis et que nous prenons 10 packs de glaces supplémentaires pour la fête. Nous pouvons créer une autre série, indexée par semaine, pour le démontrer :
Supposons maintenant que chaque semaine nous organisons une fête pour des amis, et prenons 10 paquets de glace supplémentaires pour la fête. Nous pouvons créer une autre série, indexée par semaine, pour le démontrer :
> **Note**: Nous n'utilisons pas la syntaxe simple `total_items+additional_items`. Si nous l'avions fait, nous aurions obtenu de nombreuses valeurs `NaN` (*Not a Number*) dans la série résultante. Cela est dû au fait qu'il manque des valeurs pour certains points d'index dans la série `additional_items`, et additionner `NaN` à quoi que ce soit donne `NaN`. Ainsi, nous devons spécifier le paramètre `fill_value` lors de l'addition.
> **Note**que nous n'utilisons pas la syntaxe simple `total_items+additional_items`. Si nous le faisions, nous obtiendrions beaucoup de valeurs `NaN` (*Not a Number*) dans la série résultante. C’est parce qu’il manque des valeurs pour certains points de l’index dans la série `additional_items`, et ajouter `NaN` à quoi que ce soit donne `NaN`. Nous devons donc spécifier le paramètre `fill_value` lors de l’addition.
Avec les séries temporelles, nous pouvons également **reéchantillonner** la série avec différents intervalles de temps. Par exemple, supposons que nous voulons calculer le volume moyen des ventes mensuelles. Nous pouvons utiliser le code suivant :
Avec les séries temporelles, nous pouvons également **rééchantillonner** la série avec des intervalles de temps différents. Par exemple, supposons que nous voulons calculer la moyenne mensuelle des volumes de vente. Nous pouvons utiliser le code suivant :
```python
monthly = total_items.resample("1M").mean()
ax = monthly.plot(kind='bar')
```
```
### DataFrame
Un DataFrame est essentiellement une collection de séries ayant le même index. Nous pouvons combiner plusieurs séries pour créer un DataFrame :
Un DataFrame est essentiellement une collection de séries ayant le même index. Nous pouvons combiner plusieurs séries ensemble dans un DataFrame :
```python
a = pd.Series(range(1,10))
b = pd.Series(["I","like","to","play","games","and","will","not","change"],index=range(0,9))
df = pd.DataFrame([a,b])
```
Cela créera une table horizontale comme celle-ci :
```
Cela créera une table horizontale comme celle-ci :
Ici, `.T` signifie l'opération de transposition du DataFrame, c'est-à-dire l'inversion des lignes et des colonnes, et l'opération `rename` nous permet de renommer les colonnes pour correspondre à l'exemple précédent.
Ici, `.T` signifie l'opération de transposition du DataFrame, c’est-à-dire le changement de lignes en colonnes, et l’opération `rename` nous permet de renommer les colonnes pour correspondre à l'exemple précédent.
Voici quelques-unes des opérations les plus importantes que nous pouvons effectuer sur les DataFrames :
**Sélection de colonnes**. Nous pouvons sélectionner des colonnes individuelles en écrivant `df['A']` - cette opération renvoie une série. Nous pouvons également sélectionner un sous-ensemble de colonnes dans un autre DataFrame en écrivant `df[['B','A']]` - cela renvoie un autre DataFrame.
**Sélection de colonne**. Nous pouvons sélectionner des colonnes individuelles en écrivant `df['A']` - cette opération retourne une Series. Nous pouvons aussi sélectionner un sous-ensemble de colonnes dans un autre DataFrame en écrivant `df[['B','A']]` - cela retourne un autre DataFrame.
**Filtrage** de certaines lignes selon des critères. Par exemple, pour ne conserver que les lignes où la colonne `A` est supérieure à 5, nous pouvons écrire `df[df['A']>5]`.
**Filtrer** seulement certaines lignes selon des critères. Par exemple, pour ne retenir que les lignes dont la colonne `A` est supérieure à 5, on peut écrire `df[df['A']>5]`.
> **Note** : Le fonctionnement du filtrage est le suivant. L'expression `df['A']<5` renvoie une série booléenne, qui indique si l'expression est `True` ou `False` pour chaque élément de la série originale `df['A']`. Lorsqu'une série booléenne est utilisée comme index, elle renvoie un sous-ensemble de lignes dans le DataFrame. Ainsi, il n'est pas possible d'utiliser une expression booléenne Python arbitraire, par exemple, écrire `df[df['A']>5 and df['A']<7]` serait incorrect. À la place, vous devez utiliser l'opérateur spécial`&` sur les séries booléennes, en écrivant `df[(df['A']>5) & (df['A']<7)]` (*les parenthèses sont importantes ici*).
> **Note** : Le filtrage fonctionne ainsi. L'expression `df['A']<5` retourne une série booléenne, indiquant si l'expression est `True` ou `False` pour chaque élément de la série originale `df['A']`. Quand une série booléenne est utilisée comme index, elle retourne un sous-ensemble de lignes dans le DataFrame. Il n’est donc pas possible d'utiliser une expression booléenne Python arbitraire, par exemple écrire `df[df['A']>5 and df['A']<7]` serait incorrect. À la place, vous devez utiliser l'opération spéciale`&` sur les séries booléennes, en écrivant `df[(df['A']>5) & (df['A']<7)]` (*les parenthèses sont importantes ici*).
**Création de nouvelles colonnes calculables**. Nous pouvons facilement créer de nouvelles colonnes calculables pour notre DataFrame en utilisant une expression intuitive comme celle-ci :
**Créer de nouvelles colonnes calculables**. Nous pouvons facilement créer de nouvelles colonnes calculables dans notre DataFrame en utilisant des expressions intuitives comme celle-ci :
```python
df['DivA'] = df['A']-df['A'].mean()
```
Cet exemple calcule la divergence de `A` par rapport à sa valeur moyenne. Ce qui se passe réellement ici, c'est que nous calculons une série, puis nous l'assignons au côté gauche, créant une autre colonne. Ainsi, nous ne pouvons pas utiliser d'opérations incompatibles avec les séries, par exemple, le code ci-dessous est incorrect :
```
Cet exemple calcule la divergence de A par rapport à sa valeur moyenne. Ce qui se passe réellement ici, c'est que nous calculons une série, puis affectons cette série à la gauche, créant une nouvelle colonne. Nous ne pouvons donc pas utiliser d'opérations qui ne sont pas compatibles avec les séries, par exemple, le code ci-dessous est erroné :
```python
# Wrong code -> df['ADescr'] = "Low" if df['A'] <5else"Hi"
df['LenB'] = len(df['B']) # <-Wrong result
```
Ce dernier exemple, bien que syntaxiquement correct, donne un mauvais résultat, car il assigne la longueur de la série `B` à toutes les valeurs de la colonne, et non la longueur des éléments individuels comme nous l'avions prévu.
# Code incorrect -> df['ADescr'] = "Low" si df['A'] <5sinon"Hi"
df['LenB'] = len(df['B']) # <-Résultatincorrect
```
Le dernier exemple, bien que syntaxiquement correct, donne un résultat erroné, car il assigne la longueur de la série `B` à toutes les valeurs de la colonne, et non la longueur des éléments individuels comme nous le voulions.
Si nous devons calculer des expressions complexes comme celle-ci, nous pouvons utiliser la fonction `apply`. Le dernier exemple peut être écrit comme suit :
Si nous devons calculer des expressions complexes comme celle-ci, nous pouvons utiliser la fonction `apply`. Le dernier exemple peut s'écrire ainsi :
```python
df['LenB'] = df['B'].apply(lambda x : len(x))
# or
# ou
df['LenB'] = df['B'].apply(len)
```
@ -163,21 +166,21 @@ Après les opérations ci-dessus, nous obtiendrons le DataFrame suivant :
| 7 | 8 | very | 3.0 | 4 |
| 8 | 9 | much | 4.0 | 4 |
**Sélection de lignes par numéro** peut être effectuée à l'aide de la construction `iloc`. Par exemple, pour sélectionner les 5 premières lignes du DataFrame :
**Sélectionner des lignes selon leur position** peut se faire avec la construction `iloc`. Par exemple, pour sélectionner les 5 premières lignes du DataFrame :
```python
df.iloc[:5]
```
**Regroupement** est souvent utilisé pour obtenir un résultat similaire aux *tableaux croisés dynamiques* dans Excel. Supposons que nous souhaitons calculer la valeur moyenne de la colonne `A` pour chaque nombre donné de `LenB`. Nous pouvons alors regrouper notre DataFrame par `LenB` et appeler `mean` :
**Groupement** est souvent utilisé pour obtenir un résultat semblable aux *tableaux croisés dynamiques* dans Excel. Supposons que nous voulions calculer la valeur moyenne de la colonne `A` pour chaque valeur de `LenB`. Nous pouvons alors grouper notre DataFrame par `LenB` et appeler `mean` :
```python
df.groupby(by='LenB')[['A','DivA']].mean()
```
Si nous devons calculer la moyenne et le nombre d'éléments dans le groupe, nous pouvons utiliser la fonction `aggregate` plus complexe :
```
Si nous devons calculer la moyenne et le nombre d’éléments dans le groupe, nous pouvons utiliser la fonction plus complexe `aggregate` :
@ -188,93 +191,98 @@ Cela nous donne le tableau suivant :
| 4 | 3 | 6.333333 |
| 6 | 2 | 6.000000 |
### Obtenir des données
Nous avons vu à quel point il est facile de construire des Series et des DataFrames à partir d'objets Python. Cependant, les données se présentent généralement sous forme de fichier texte ou de tableau Excel. Heureusement, Pandas nous offre un moyen simple de charger des données depuis le disque. Par exemple, lire un fichier CSV est aussi simple que cela :
### Récupérer les données
Nous avons vu à quel point il est facile de construire des Series et des DataFrames à partir d'objets Python. Cependant, les données proviennent généralement sous forme de fichier texte ou de tableau Excel. Heureusement, Pandas nous offre un moyen simple de charger des données depuis le disque. Par exemple, lire un fichier CSV est aussi simple que cela :
```python
df = pd.read_csv('file.csv')
```
Nous verrons plus d'exemples de chargement de données, y compris leur récupération depuis des sites web externes, dans la section "Challenge".
Nous verrons plus d'exemples de chargement de données, y compris leur récupération depuis des sites web externes, dans la section "Challenge"
### Impression et Visualisation
### Impression et Tracé
Un Data Scientist doit souvent explorer les données, il est donc important de pouvoir les visualiser. Lorsque le DataFrame est volumineux, il est souvent utile de vérifier que tout fonctionne correctement en affichant les premières lignes. Cela peut être fait en appelant `df.head()`. Si vous l'exécutez depuis Jupyter Notebook, cela affichera le DataFrame sous une forme tabulaire agréable.
Un Data Scientist doit souvent explorer les données, il est donc important de pouvoir les visualiser. Lorsque le DataFrame est volumineux, souvent on veut juste s'assurer que tout est correct en affichant les premières lignes. Cela peut être fait en appelant `df.head()`. Si vous l'exécutez depuis Jupyter Notebook, cela affichera le DataFrame sous une forme tabulaire agréable.
Nous avons également vu l'utilisation de la fonction `plot` pour visualiser certaines colonnes. Bien que `plot` soit très utile pour de nombreuses tâches et prenne en charge différents types de graphiques via le paramètre `kind=`, vous pouvez toujours utiliser la bibliothèque `matplotlib` brute pour tracer quelque chose de plus complexe. Nous couvrirons la visualisation des données en détail dans des leçons de cours séparées.
Nous avons également vu l'utilisation de la fonction `plot` pour visualiser certaines colonnes. Bien que `plot` soit très utile pour de nombreuses tâches et supporte différents types de graphiques via le paramètre `kind=`, vous pouvez toujours utiliser la bibliothèque brute `matplotlib` pour tracer quelque chose de plus complexe. Nous aborderons la visualisation des données en détail dans des leçons distinctes.
Cette vue d'ensemble couvre les concepts les plus importants de Pandas, mais la bibliothèque est très riche, et il n'y a pas de limite à ce que vous pouvez faire avec elle ! Appliquons maintenant ces connaissances pour résoudre un problème spécifique.
Cette vue d'ensemble couvre les concepts les plus importants de Pandas, cependant, la bibliothèque est très riche, et il n'y a pas de limite à ce que vous pouvez faire avec ! Appliquons maintenant ces connaissances pour résoudre un problème spécifique.
## 🚀 Challenge 1 : Analyser la propagation du COVID
## 🚀 Challenge 1 : Analyse de la propagation du COVID
Le premier problème sur lequel nous allons nous concentrer est la modélisation de la propagation de l'épidémie de COVID-19. Pour ce faire, nous utiliserons les données sur le nombre de personnes infectées dans différents pays, fournies par le [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) de l'[Université Johns Hopkins](https://jhu.edu/). Le jeu de données est disponible dans [ce dépôt GitHub](https://github.com/CSSEGISandData/COVID-19).
Le premier problème sur lequel nous allons nous concentrer est la modélisation de la propagation épidémique du COVID-19. Pour ce faire, nous utiliserons les données sur le nombre d'individus infectés dans différents pays, fournies par le [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) de [l'Université Johns Hopkins](https://jhu.edu/). Le jeu de données est disponible dans [ce dépôt GitHub](https://github.com/CSSEGISandData/COVID-19).
Puisque nous voulons démontrer comment traiter les données, nous vous invitons à ouvrir [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) et à le lire de haut en bas. Vous pouvez également exécuter les cellules et relever certains défis que nous avons laissés pour vous à la fin.
Comme nous voulons montrer comment traiter les données, nous vous invitons à ouvrir [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) et à le lire de haut en bas. Vous pouvez aussi exécuter les cellules, et réaliser certains défis que nous avons laissés pour vous à la fin.
> Si vous ne savez pas comment exécuter du code dans Jupyter Notebook, consultez [cet article](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
> Si vous ne savez pas comment exécuter du code dans Jupyter Notebook, jetez un œil à [cet article](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
## Travailler avec des données non structurées
Bien que les données soient souvent sous forme tabulaire, dans certains cas, nous devons traiter des données moins structurées, comme du texte ou des images. Dans ce cas, pour appliquer les techniques de traitement des données que nous avons vues précédemment, nous devons**extraire** des données structurées. Voici quelques exemples :
Bien que les données soient très souvent sous forme tabulaire, dans certains cas il est nécessaire de traiter des données moins structurées, par exemple, du texte ou des images. Dans ce cas, pour appliquer les techniques de traitement des données vues ci-dessus, nous devons d'une manière ou d'une autre**extraire** des données structurées. Voici quelques exemples :
* Extraire des mots-clés d'un texte et voir à quelle fréquence ces mots-clés apparaissent
* Extraire des mots-clés du texte, et voir la fréquence d'apparition de ces mots-clés
* Utiliser des réseaux neuronaux pour extraire des informations sur les objets dans une image
* Obtenir des informations sur les émotions des personnes à partir d'un flux vidéo
* Obtenir des informations sur les émotions des personnes via un flux vidéo de caméra
## 🚀 Challenge 2 : Analyser les articles sur le COVID
## 🚀 Challenge 2 : Analyse des articles COVID
Dans ce défi, nous continuerons avec le sujet de la pandémie de COVID et nous concentrerons sur le traitement des articles scientifiques sur le sujet. Il existe un [jeu de données CORD-19](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) contenant plus de 7000 articles (au moment de la rédaction) sur le COVID, disponibles avec des métadonnées et des résumés (et pour environ la moitié d'entre eux, le texte complet est également fourni).
Dans ce challenge, nous continuerons sur le sujet de la pandémie de COVID, en nous concentrant sur le traitement d'articles scientifiques à ce sujet. Il existe un [jeu de données CORD-19](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) avec plus de 7000 (au moment de la rédaction) articles sur le COVID, disponible avec les métadonnées et les résumés (et pour environ la moitié d'entre eux, le texte complet est aussi fourni).
Un exemple complet d'analyse de ce jeu de données en utilisant le service cognitif [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) est décrit [dans ce billet de blog](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Nous discuterons d'une version simplifiée de cette analyse.
Un exemple complet d'analyse de ce jeu de données en utilisant le service cognitif [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) est décrit [dans cet article de blog](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Nous discuterons d'une version simplifiée de cette analyse.
> **NOTE** : Nous ne fournissons pas une copie du jeu de données dans ce dépôt. Vous devrez peut-être d'abord télécharger le fichier [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) depuis [ce jeu de données sur Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Une inscription sur Kaggle peut être requise. Vous pouvez également télécharger le jeu de données sans inscription [ici](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), mais cela inclura tous les textes complets en plus du fichier de métadonnées.
> **NOTE** : Nous ne fournissons pas une copie du jeu de données dans ce dépôt. Vous devrez d'abord télécharger le fichier [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) depuis [ce jeu de données sur Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Une inscription à Kaggle peut être requise. Vous pouvez également télécharger le jeu de données sans inscription [depuis ici](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), mais cela inclura tous les textes complets en plus du fichier de métadonnées.
Ouvrez [`notebook-papers.ipynb`](notebook-papers.ipynb) et lisez-le de haut en bas. Vous pouvez également exécuter les cellules et relever certains défis que nous avons laissés pour vous à la fin.
Ouvrez [`notebook-papers.ipynb`](notebook-papers.ipynb) et lisez-le de haut en bas. Vous pouvez aussi exécuter les cellules et relever les défis que nous avons laissés pour vous à la fin.
## Traitement des données d'image
## Traitement des données d’images
Récemment, des modèles d'IA très puissants ont été développés pour comprendre les images. De nombreuses tâches peuvent être résolues en utilisant des réseaux neuronaux pré-entraînés ou des services cloud. Voici quelques exemples :
Récemment, des modèles d'IA très puissants ont été développés pour nous permettre de comprendre les images. De nombreuses tâches peuvent être résolues en utilisant des réseaux neuronaux pré-entraînés ou des services cloud. Voici quelques exemples :
* **Classification d'images**, qui peut vous aider à catégoriser une image dans l'une des classes prédéfinies. Vous pouvez facilement entraîner vos propres classificateurs d'images en utilisant des services comme [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum)
* **Détection d'objets** pour détecter différents objets dans une image. Des services comme [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) peuvent détecter un certain nombre d'objets courants, et vous pouvez entraîner un modèle [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) pour détecter des objets spécifiques d'intérêt.
* **Détection de visages**, y compris l'âge, le genre et les émotions. Cela peut être fait via [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
* **Classification d'images**, qui peut vous aider à classer l'image dans l'une des catégories prédéfinies. Vous pouvez facilement entraîner vos propres classificateurs d'images en utilisant des services tels que [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum)
* **Détection d'objets** pour détecter différents objets dans l'image. Des services comme [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) peuvent détecter plusieurs objets courants, et vous pouvez entraîner un modèle [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) pour détecter certains objets spécifiques d’intérêt.
* **Détection des visages**, y compris la détection de l'âge, du genre et des émotions. Cela peut être réalisé via [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
Tous ces services cloud peuvent être appelés en utilisant les [SDK Python](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), et peuvent donc être facilement intégrés dans votre flux de travail d'exploration de données.
Tous ces services cloud peuvent être appelés en utilisant des [SDK Python](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), et peuvent donc être facilement intégrés dans votre flux de travail d'exploration des données.
Voici quelques exemples d'exploration de données à partir de sources d'images :
* Dans le billet de blog [Comment apprendre la science des données sans coder](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/), nous explorons les photos Instagram, en essayant de comprendre ce qui pousse les gens à donner plus de "likes" à une photo. Nous extrayons d'abord autant d'informations que possible des images en utilisant [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), puis nous utilisons [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) pour construire un modèle interprétable.
* Dans l'[atelier sur les études faciales](https://github.com/CloudAdvocacy/FaceStudies), nous utilisons [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) pour extraire les émotions des personnes sur des photographies d'événements, afin de tenter de comprendre ce qui rend les gens heureux.
Voici quelques exemples d'exploration des données à partir de sources d'images :
* Dans l'article de blog [Comment apprendre la Data Science sans coder](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) nous explorons les photos Instagram, en essayant de comprendre ce qui fait que les gens aiment plus une photo. Nous extrayons d'abord autant d'informations que possible des images en utilisant [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), puis utilisons [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) pour construire un modèle interprétable.
* Dans [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) nous utilisons [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) pour extraire les émotions des personnes sur des photographies d'événements, afin d'essayer de comprendre ce qui rend les gens heureux.
## Conclusion
Que vous disposiez déjà de données structurées ou non structurées, avec Python, vous pouvez effectuer toutes les étapes liées au traitement et à la compréhension des données. C'est probablement le moyen le plus flexible de traiter les données, et c'est la raison pour laquelle la majorité des data scientists utilisent Python comme principal outil. Apprendre Python en profondeur est probablement une bonne idée si vous êtes sérieux dans votre parcours en science des données !
Que vous ayez déjà des données structurées ou non structurées, en utilisant Python vous pouvez effectuer toutes les étapes liées au traitement et à la compréhension des données. C'est probablement la manière la plus flexible de traiter les données, et c’est la raison pour laquelle la majorité des data scientists utilisent Python comme outil principal. Apprendre Python en profondeur est probablement une bonne idée si vous êtes sérieux dans votre parcours en data science !
* [Wes McKinney. Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython](https://www.amazon.com/gp/product/1491957662)
* [Wes McKinney. Python for Data Analysis : Manipulation de données avec Pandas, NumPy et IPython](https://www.amazon.com/gp/product/1491957662)
**Ressources en ligne**
* Tutoriel officiel [10 minutes pour Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html)
* Tutoriel officiel [10 minutes to Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html)
* [Documentation sur la visualisation avec Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html)
**Apprendre Python**
* [Apprenez Python de manière ludique avec Turtle Graphics et Fractals](https://github.com/shwars/pycourse)
* [Faites vos premiers pas avec Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) sur [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Apprendre Python de manière ludique avec Turtle Graphics et Fractales](https://github.com/shwars/pycourse)
* [Faites vos premiers pas avec Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Parcours d'apprentissage sur [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
## Devoir
[Effectuez une étude de données plus détaillée pour les défis ci-dessus](assignment.md)
[Effectuer une étude de données plus détaillée pour les défis ci-dessus](assignment.md)
## Crédits
Cette leçon a été rédigée avec ♥️ par [Dmitry Soshnikov](http://soshnikov.com)
Cette leçon a été réalisée avec ♥️ par [Dmitry Soshnikov](http://soshnikov.com)
---
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
localizeflow[bot]
3 days ago