<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Marcius Dellano on Medium]]></title>
        <description><![CDATA[Stories by Marcius Dellano on Medium]]></description>
        <link>https://medium.com/@marciusdellano?source=rss-52f1cc150aaa------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*QDjDVFaKOlRsT4X7</url>
            <title>Stories by Marcius Dellano on Medium</title>
            <link>https://medium.com/@marciusdellano?source=rss-52f1cc150aaa------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 00:11:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@marciusdellano/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[A practical application of web-scraping with Scrapy — part 2]]></title>
            <link>https://medium.com/@marciusdellano/a-practical-application-of-web-scraping-with-scrapy-part-2-e4cf6cee857e?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4cf6cee857e</guid>
            <category><![CDATA[storytelling]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[streamlit]]></category>
            <category><![CDATA[web-scraping]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Sat, 20 Jul 2024 02:45:21 GMT</pubDate>
            <atom:updated>2024-07-21T01:37:57.684Z</atom:updated>
            <content:encoded><![CDATA[<h3>A practical application of web-scraping with Scrapy — part 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yPc8PtljHRmsGj-aSmOhzw.png" /></figure><p>This article is a continuation of the article that deals with extracting the list of songs that reached the top of the Billboard Hot 100 chart from English-language Wikipedia. Click <a href="https://bit.ly/3KX1g3P">here</a> to read part 1 if you haven’t already.</p><p>While in the first part the focus was only on extracting the content from the pages, in this part, we will deal with creating an interactive <em>dashboard</em> to display the data obtained in the previous step. To build the <em>dashboard,</em> a Python library called <a href="https://streamlit.io/">Streamlit</a> will be used. Below is a small introduction to this library.</p><h3>Streamlit</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/1*Z6-jytnjAnH9DM_GaCuo7A.png" /></figure><p>Streamlit is a tool written in Python that allows data scientists and machine <em>learning</em> engineers to build web applications with few lines of code and without the need to know HTML and CSS.</p><p>Installing Streamlit is a simple task. You only need Python from version 3.8 and run the command pip install streamlit to install it.</p><p>Streamlit offers a demonstration of its capabilities by simply running the command streamlit hello. Once this is done, your default browser will open with the following content:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*XagmTU-oP2bgemhq.png" /></figure><p>To end this demonstration, type CTRL+C and return to the terminal.</p><h3>Creating your first Streamlit app</h3><p>Create a main.py file (can be any other name). And add the code below:</p><pre>import streamlit as st <br>import pandas as pd <br><br># Title<br> st.title( &#39;My first Streamlit app&#39; ) <br><br># Text<br> st.write( &#39;Welcome to Streamlit!&#39; ) <br><br># Data<br> data = st.slider( &#39;Select a value&#39; , 0 , 100 , 50 ) <br>st.write( &#39;You selected:&#39; , data) <br><br>st.divider() <br>st.header( &quot;Displaying a dataframe&quot; ) <br>df = pd.DataFrame({ <br>  &#39;first column&#39; : [ 1 , 2 , 3 , 4 ], <br>  &#39;second column&#39; : [ 10 , 20 , 30 , 40 ] <br>}) <br>st.write(df)</pre><p>Then type the command in the terminal:</p><pre>streamlit run main.py</pre><p>The following window will open in your browser:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*67oRGTycavQ8zMOm2v_8EA.png" /></figure><p>In the first two lines of this code, we import the Streamlit library by applying the <em>alias</em> st and Pandas. Next, we execute the command st.titleto define a title for the page. The next line generates common text between tags &lt;div&gt;.</p><p>In the next step,<em> </em>we create <em>a slider</em> control wich allows you to pick an integer value between 0 and 100. The chosen number is then saved in the variable data, which is shown in the paragraph below the control. Each time the value of this control is changed, Streamlit re-executes the entire contents of the main.py file and, consequently, the text at the bottom is also updated.</p><p>The command st.divider()generates a horizontal ruler, which corresponds to the HTML tag &lt;hr&gt;. The statement st.header()creates a header.</p><p>Finally, we generate a dataframe, and Streamlit is able to display it in tabular format by simply invoking the instruction st.write(dataframe).</p><h3>Displaying Billboard Hot 100 data.</h3><p>After presenting Streamlit, we will return to building the dashboard that will show content extracted from the scraping process seen in part 1 of this article.</p><h4>The dashboard structure</h4><p>The dashboard will consist of a page that features a sidebar on the left that presents some controls for filtering data by year or range of years, by decade and by artist. The main content will contain a table with all records that satisfy the filter entered, in addition to 3 bar graphs. The first one shows the ranking of the 10 artists who topped the chart for the most weeks. The second shows the artists who have the most number of songs that reached 1st position. The third shows the 10 songs that remained in 1st place for the longest time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ym2oTTwXikHC3u5_d3OMiA.png" /><figcaption>Dashboard overview</figcaption></figure><h4>Side filters</h4><p>There are 4 filters:</p><ul><li>By year: a text box where the user can directly type a value between 1959 and 2023.</li><li>By year range: a slider control <em>,</em> allowing you to select any range between 1959 and 2023;</li><li>By decade: a combo box with values ​​between 1950 and 2020, out of 10;</li><li>Filter by artist: another combo box that allows you to select an artist. This control lists only the artists who reached number one in the selected year or years.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/299/1*hOvNkLSs8A_sSBz-uNNcaw.png" /><figcaption>Side bar with filters</figcaption></figure><h4>Main content</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*5x5jAdcHU3wrolsxKxy5Ag.png" /><figcaption>Main content</figcaption></figure><p>When an artist is selected, only the last graph is displayed. When a decade is selected, the year range is automatically changed to match the selection. When a year is entered, the period is also updated, in this case the beginning and end of the interval coincide with the value entered. The following three images illustrate these characteristics:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gOemtD1Bz3pSG8b-KNqr4Q.png" /><figcaption>When a decade is selected, the slider is automatically filled with a range varying from the first year of the selected decade to the last year (e.g. 1980–1989)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OrBQcTQl5-4IPGkIQcKzgA.png" /><figcaption>When user types a year, automatically, the slider is utomatically filled with with both starting and ending values ​​coinciding and the filter by decade is cleared</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rOwl9VGB1VZ8Y8jB56sl_w.png" /><figcaption>When a artist is selected, only the 3rd chart, i. e. top 10 with most weeks at number one, is displayed</figcaption></figure><p>Other notable features of the dashboard:</p><ul><li>For each record listed, a column is added with a link to the Billboard page that contains the chart of the week to which the record refers;</li><li>When hovering the mouse over each of the graph bars, a tooltip<em> </em>is displayed. For example, the 3rd chart displays the artist, the name of the song and the number of weeks it was topped the chart (see figure above).</li></ul><h3>Some implementation details</h3><h4>The organization of application source files</h4><p>For this application, the Streamlit libraries and also Scrapy are used, which extracts data from Wikipedia entries that contain the lists of songs that reached the top of the Billboard chart between 1959 and 2023, which was already the subject of the first part of this article. There are some small modifications compared to what was done previously, which will be shown later.</p><p>The files that make up the application’s source code are organized as follows:</p><pre>C:\PyCharmProjects\billboardscrapy_pt02\billboard <br>│ items.json --&gt; JSON file generated from the web-scraping process<br>│ main.py - -&gt; Main file, invokes the crawler and generates the dashboard <br>│ scrapy.cfg - -&gt; Scrapy configuration file <br>│ <br>└───billboard - - &gt; files used by the Scrapy library <br>    │ crawler.py - -&gt; starts the web-scraping process <br>    │ Helper.py - -&gt; auxiliary functions for string manipulation <br>    │ items.py - -&gt; Information about each line obtained by Scrapy <br>    │ middlewares .py - -&gt; Generated by scrapy, without modifications <br>    │ pipelines.py - -&gt; Post processing of each line <br>    │ settings.py - -&gt; spider settings <br>    │ <br>    ├───spiders <br>     │ hot100.py - -&gt; Spider  definition. Access Wikipedia pages and extract songs</pre><p>The files underbillboard\billboardfolder are used by the Scrapy library and have already been described in part 1 of this article. There is a major difference here: the web-scraping process is triggered via script within the crawler.py file, instead of being triggered by command scrapy crawl. We will show below how this is done:</p><pre>## File crawler.py <br>from scrapy.crawler import CrawlerProcess <br>from billboard.spiders.hot100 import Hot100Spider <br><br>def  start_crawler (): <br>    process = CrawlerProcess( <br>        settings={ <br>            &quot;FEEDS&quot; : { <br>                &quot;items.json&quot; : { &quot;format&quot; : &quot;json &quot; }, <br>            }, <br>            &quot;ITEM_PIPELINES&quot; : { <br>                &quot;billboard.pipelines.BillboardPipeline&quot; : 300 , <br>            } <br>        } <br>    ) <br>    process.crawl(Hot100Spider) <br>    process.start()</pre><p>Above, we defined the function start_crawler, which defines an object CrawlerProcess, whose parameter consists of a dictionary in which an output file is defined, in this case items.jsonand a pipeline, which is processed each time an item is generated by the Spider class . As we saw previously, this pipeline is necessary because not all lines have the information we need, so we have to get the missing data from previously read items.</p><p>Next, the method crawlis invoked to define which spider will be used, in this case the Hot100Spider. And finally, we start the process by calling the method start().</p><h3>The main file</h3><p>Let’s now dissect the file main.py, which contains the instructions to generate our <em>dashboard</em> . First we import the necessary libraries:</p><pre>from billboard import crawler <br>import streamlit as st <br>import pandas as pd <br>import altair as alt <br>from altair import  Axis</pre><p>The following code is the first to be run when the command stremlit run main.pyis executed:</p><pre>if __name__ == &#39;__main__&#39; : <br>    load_panel()</pre><p>The function load_panel()is started with the following instructions:</p><pre>def load_panel():<br>    st.title(&quot;Billboard Hot 100&quot;)<br>    st.header(&quot;Displaying songs which topped Billboard Hot 100 chart&quot;)<br>    data_load_state = st.text(&#39;Loading data...&#39;)<br>    get_data()<br>    df = pd.read_json(&#39;items.json&#39;)<br>    df[&quot;link_chart&quot;] = df.apply(lambda row: f&quot;https://www.billboard.com/charts/hot-100/{row.date:%Y-%m-%d}&quot;, axis=1)</pre><p>First we define title and subtitle, and then we invoke the function get_data()shown below:</p><pre>@st.cache_data<br>def get_data():<br> crawler.start_crawler()</pre><p>The function get_date() calls the function start_crawlerthat is defined in the file crawler.pydescribed above. The annotation @st.cache_datatells Streamlit to cache the output of the scraping process, so that Streamlit will not rerun this function each time a filter is modified. If this annotation was not included, Streamlit will run the crawler again, which is not desirable as the scraping process takes around 3 minutes to complete.</p><p>The instruction data_load_state = st.text(‘Loading data…’)displays the text “Loading data…” while the process of extracting content from Wikipedia pages occurs. When this process completes, this text is replaced, so we assign a new value to the variable data_load_state.</p><p>Upon completing this process, we create a Dataframe object from the generated JSON file. Later, we added an extra column with a URL that will take the user to the Billboard.com website on the page for the selected week’s chart.</p><p>Still inload_panel()method we define the filters that will appear on the left side of the page:</p><pre>    st.sidebar.header(&quot;Filters&quot;)<br>    st.sidebar.subheader(&quot;By year&quot;)<br>    st.sidebar.number_input(&quot;Year:&quot;, value=None, key=&quot;selected_year&quot;,min_value=1959, max_value=2023, step=1, on_change=set_interval_from_year)<br>    st.sidebar.subheader(&quot;By interval of years&quot;)<br>    st.sidebar.slider(&#39;Select the desired interval&#39;, 1959, 2023, (1959, 2023), key=&quot;years&quot;,<br>                      on_change=clear_decade_year)<br>    st.sidebar.subheader(&quot;Or&quot;)<br>    st.sidebar.subheader(&quot;By decade&quot;)<br>    st.sidebar.selectbox(&quot;Decade&quot;, range(1950, 2030, 10), index=None, key=&quot;decade&quot;, on_change=set_years_from_decade)</pre><p>In each of these controls, an attribute namedkey is defned. This attribute allows the contents of the controls to be retrieved through the object session_state, for example, if a control has the attribute key=&quot;key1&quot;, then its content can be retrieved through the property st.session_state.key1orst.session_state[&#39;key1&#39;]</p><p>As explained previously, the <em>slider</em> that specifies the range of years is updated when a value in the ‘year’ field or the ‘decade’ field is selected, so to filter the <em>dataframe</em> by date, is enough to take the minimum and maximum values ​​selected in the <em>slider :</em></p><pre>(min_year, max_year) = st.session_state.years<br>filtered_df = df[(df[&quot;year&quot;] &gt;= min_year) &amp; (df[&quot;year&quot;] &lt;= max_year)]</pre><p>The next step is to take the artists that at some point between the initial and final year selected reached number 1 on the Billboard Hot 100, and feed the corresponding combobox . When one of them is selected, then the dataframe is filtered again and a variable is defined — filtered_by_artistwhich will be used to show or hide the graphs that show the first two rankings (by weeks in 1st place or by number of songs)</p><pre>    (min_year, max_year) = st.session_state.years<br>    filtered_df = df[(df[&quot;year&quot;] &gt;= min_year) &amp; (df[&quot;year&quot;] &lt;= max_year)]<br>    artists = sorted(filtered_df[&quot;artist&quot;].unique())<br>    st.sidebar.subheader(&quot;By artist&quot;)<br>    st.sidebar.selectbox(&quot;Artist&quot;, artists, index=None, key=&quot;artist&quot;)<br>    if &quot;artist&quot; in st.session_state.keys() and st.session_state.artist:<br>        filtered_df = filtered_df[filtered_df[&quot;artist&quot;] == st.session_state.artist]<br>        is_filtered_by_artist = True<br>    else:<br>        is_filtered_by_artist = False</pre><p>Next, we show the list of songs based on the specified filters and replace the text “Loading data” with another that informs the total records (remember that a reference to this control was saved in the variable data_load_state, so just modify this variable to change the current text content):</p><pre>    st.dataframe(filtered_df,<br>                 column_config={&quot;sequential_no&quot;: &quot;Sequencial&quot;,<br>                                &quot;date&quot;: st.column_config.DateColumn(<br>                                    &quot;Data&quot;, format=&quot;DD/MM/YYYY&quot;),<br>                                &quot;song&quot;: &quot;Song&quot;,<br>                                &quot;artist&quot;: &quot;Artist&quot;,<br>                                &quot;year&quot;: st.column_config.NumberColumn(<br>                                    &quot;Ano&quot;, format=&quot;%d&quot;),<br>                                &quot;link_chart&quot;: st.column_config.LinkColumn(<br>                                    &quot;Referência&quot;, help=&quot;Link to Billboard chart page&quot;,<br>                                    display_text=&quot;Go to the chart&quot;)<br>                                },<br>                 hide_index=True<br>                 )<br><br>    returned_records = filtered_df.shape[0]<br>    if returned_records &gt; 1:<br>        message = f&quot;{returned_records} records have been returned&quot;<br>    else:<br>        message = f&quot;{returned_records} record has been returned&quot;<br>    data_load_state.info(message)<br>    display_graphics(filtered_df, is_filtered_by_artist)</pre><p>The parameter column_configabove is used to configure the <em>dataframe</em> columns. Above, we display the columns sequential_no, song, artistas is, modifying only the column header. As for the column, yearwe define it as numeric and define format %d, which displays only numbers (By default, this column would be displayed in American format, with commas separating the unit from thousands, so 1996 would be written as 1.996, something meaningless for languages ​​where the comma is used as a decimal separator, as is the case in Portuguese. By default, the date would also be shown in North American format, that is, month/day/year, so we have to explicitly define the format as day/month/year. Finally, the last column is a link type with fixed text that directs to the Billboard website on the page that shows the music chart of the week that corresponds to the selected record.</p><p>The last step is to show the graphics:</p><p>A útlima etapa é mostrar os gráficos:</p><pre>def display_graphics(df, filtered_by_artist):<br>    if not filtered_by_artist:<br>        st.subheader(&quot;Ranking of artists with number one singles&quot;)<br>        df_grouped_artist = df.groupby(&quot;artist&quot;, as_index=False)<br>        st.markdown(&quot;#### By cumulative weeks&quot;)<br>        st.write(alt.Chart(<br>            get_top10_artists_by_weeks(df_grouped_artist),<br>        ).mark_bar().encode(<br>            y=alt.Y(&quot;artist:N&quot;, axis=Axis(title=&#39;Artist&#39;)).sort(&quot;-x&quot;),<br>            x=alt.X(&#39;date:Q&#39;, axis=Axis(title=&quot;Total of weeks at 1st. place&quot;)),<br>            tooltip=[<br>                alt.Tooltip(&quot;artist&quot;, title=&quot;Artist:&quot;),<br>                alt.Tooltip(&quot;date&quot;, title=&quot;Total of weeks at 1st. place:&quot;)<br>            ]<br>        ))<br>        # st.bar_chart(get_top10_artists_by_weeks(df_grouped_artist), horizontal=True)<br>        st.markdown(&quot;#### By number of singles&quot;)<br>        st.write(alt.Chart(<br>            get_top10_artists_by_song(df_grouped_artist)<br>        ).mark_bar().encode(<br>            y=alt.Y(&quot;artist:N&quot;, axis=Axis(title=&#39;Artist&#39;)).sort(&quot;-x&quot;),<br>            x=alt.X(&#39;song:Q&#39;, axis=Axis(title=&#39;Number of singles&#39;, tickMinStep=1)),<br>            tooltip=[<br>                alt.Tooltip(&quot;artist&quot;, title=&quot;Artist:&quot;),<br>                alt.Tooltip(&quot;song&quot;, title=&quot;Number of singles:&quot;),<br>            ]<br>        ))<br><br>    # st.bar_chart(get_top10_artists_by_song(df_grouped_artist), horizontal=True)<br>    st.subheader(&quot;Top 10 songs which remained in 1st place for the longest time&quot;)<br>    st.write(alt.Chart(<br>        get_top_10_songs_by_number_of_weeks(df),<br>    ).mark_bar().encode(<br>        y=alt.Y(&quot;song_artist:N&quot;, axis=Axis(title=&quot;Song&quot;)).sort(&quot;-x&quot;),<br>        x=alt.X(&#39;date:Q&#39;, axis=Axis(title=&quot;Total of weeks at 1st. place&quot;, tickMinStep=1)),<br>        tooltip=[<br>            alt.Tooltip(&quot;artist&quot;, title=&quot;Artist:&quot;),<br>            alt.Tooltip(&quot;song&quot;, title=&quot;Song:&quot;),<br>            alt.Tooltip(&quot;date&quot;, title=&quot;Total of weeks at 1st. place:&quot;)<br>        ]<br><br>    ))<br><br>def get_top10_artists_by_weeks(grouped):<br>    return grouped[[&quot;date&quot;]].count().sort_values(by=&quot;date&quot;, ascending=False)[0:10]<br><br><br>def get_top10_artists_by_song(grouped):<br>    return grouped[&quot;song&quot;].nunique().sort_values(by=&quot;song&quot;, ascending=False)[0:10]<br><br><br>def get_top_10_songs_by_number_of_weeks(df):<br>    df_group_by_song = df.groupby([&quot;artist&quot;, &quot;song&quot;], as_index=False)<br>    df_count = df_group_by_song.count()<br>    df_count[&quot;song_artist&quot;] = df_count.apply(lambda row: row.song + &quot; - &quot; + row.artist.upper(), axis=1)<br>    return df_count.sort_values(by=&quot;date&quot;, ascending=False)[0:10]</pre><p>By default, Streamlit uses the <a href="https://altair-viz.github.io/index.html">Vega-Altair</a> library to generate graphics, although it is possible to use other libraries such as <a href="https://matplotlib.org/">Matplotlib</a> and <a href="https://bokeh.org/">Bokeh</a> . Above, I could have used the method st.bar_chart, but if this was done, the graphics would be sorted in alphabetical order by the artist. Therefore, to sort in descending order by weeks in 1st place or by number of songs, it is necessary to directly invoke the Vega-Altair library so that it would be possible to customize the ordering of the graph, which is done next, taking the ranking by number of weeks as example:</p><pre>y=alt.Y(&quot;song_artist:N&quot;, axis=Axis(title=&quot;Música&quot;)).sort(&quot;-x&quot;),<br>x=alt.X(&#39;date:Q&#39;, axis=Axis(title=&quot;Total of weeks at number one&quot;, tickMinStep=1)),</pre><h3>Conclusion</h3><p>The article above aimed to show some of the most important features of the Streamlit tool, demonstrating how, with just a few lines of code, it is possible to create a simple, yet functional application, with a pleasant interface, without the need to know in depth interface tools. user, such as HTML, CSS, Bootstrap and the like. Additionally, this article and the previous one seek to show that Scrapy and Streamlit make a good partnership for extracting and displaying data scraped from web pages.</p><p>Click <a href="https://github.com/marciusdm/webscraping/raw/main/scrapy_billboard_pt02/billboard_pt02.zip">here</a> to download the complete source code of the application shown in this article</p><p>Click <a href="https://medium.com/@marciusdellano">here</a> to read my other articles written on the Medium platform</p><p>My professional <a href="https://github.com/marciusdm/portfolio">portfolio</a></p><p>My <a href="https://www.linkedin.com/in/marciusdm">profile</a> on Linkedin</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4cf6cee857e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Um aplicação prática de web-scraping com Scrapy — parte 2]]></title>
            <link>https://medium.com/@marciusdellano/um-aplica%C3%A7%C3%A3o-pr%C3%A1tica-de-web-scraping-com-scrapy-parte-2-a9bfeb78cf92?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/a9bfeb78cf92</guid>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[storytelling]]></category>
            <category><![CDATA[streamlit]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Sat, 20 Jul 2024 02:45:10 GMT</pubDate>
            <atom:updated>2024-07-20T19:40:11.135Z</atom:updated>
            <content:encoded><![CDATA[<h3>Um aplicação prática de web-scraping com Scrapy — parte 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yg1uNw4KytT6n7v68MwkPw.jpeg" /><figcaption><a href="https://www.freepik.com/free-photo/modern-equipped-computer-lab_21797025.htm#fromView=search&amp;page=1&amp;position=7&amp;uuid=43ed8416-5a89-401f-b09c-8128472fd263">Image by freepik</a></figcaption></figure><p>Este artigo é a continuação do artigo que trata da extração de lista de músicas que atingiram o topo da parada da Billboard Hot 100 a partir da Wikipediia em língua inglesa. Clique <a href="https://medium.com/@marciusdellano/um-aplica%C3%A7%C3%A3o-pr%C3%A1tica-de-web-scraping-com-scrapy-de7eae815af8">aqui</a> para ler a parte 1, se você ainda não o leu.</p><p>Enquanto que na primeira parte o foco foi apenas na extração do conteúdo das páginas, nesta parte iremos tratar da criação de um <em>dashboard</em> interativo para exibição dos dados obtidos na etapa anterior. Para a construção do <em>dashboard </em>será utilizada uma biblioteca do Python chamada <a href="https://streamlit.io/">Streamlit</a>. A seguir uma pequena introdução a esta biblioteca.</p><h3>O Streamlit</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/1*as2Swf0rzbKlCP_9sCiWlA.png" /></figure><p>O Streamlit é uma ferramenta escrita em Python que permite a cientistas de dados e engenheiros de m<em>achine learning</em> a construir aplicações web com poucas linhas de código e sem a necessidade de se ter conhecimentos em HTML e CSS.</p><p>Instalar o Streamlit é uma tarefa simples. Só é necessário ter o Python a partir da versão 3.8 e executar o comando pip install streamlit para instalá-lo.</p><p>O Streamlit oferece uma demonstração de suas capacidades, bastando para isso executar o comando streamlit hello. Feito isso uma seu navegador padrão irá ser aberto com o conteúdo a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z046lBSYzQC51PzGjZdf1Q.png" /></figure><p>Para encerrar esta demonstração digitar CTRL+C e voltar ao terminal.</p><h4>Criando seu primeiro aplicativo Streamlit</h4><p>Crie um arquivo main.py (pode ser qualquer outro nome). E acrescente o código abaixo:</p><pre>import streamlit as st<br>import pandas as pd<br><br># Title<br>st.title(&#39;Meu primeiro aplicativo Streamlit&#39;)<br><br># Text<br>st.write(&#39;Bem vindo ao Streanlit!&#39;)<br><br># Data<br>data = st.slider(&#39;Selecione um valor&#39;, 0, 100, 50)<br>st.write(&#39;Você selecionou:&#39;, data)<br><br>st.divider()<br>st.header(&quot;Exibindo um dataframe&quot;)<br>df = pd.DataFrame({<br>  &#39;first column&#39;: [1, 2, 3, 4],<br>  &#39;second column&#39;: [10, 20, 30, 40]<br>})<br>st.write(df)</pre><p>A seguir digite no terminal o comando:</p><pre>streamlit run main.py</pre><p>A janela a seguir irá se abrir em seu navegador:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*yTdf0v89HfHpNuWYczaBZg.png" /></figure><p>Nas duas primeiras linhas deste código importamos a biblioteca Streamlit aplicando o <em>alias</em> st e o Pandas. A seguir executamos o comando st.title para definir um título para a página. A linha seguinte gera um texto comum entre tags &lt;div&gt;.</p><p>Na próxima etapa é criado um controle do tipo <em>slider</em> que permite definir um valor inteiro entre 0 e 100. O número escolhido é, então salvo na variável data, que por sua vez, é mostrado no parágrafo abaixo do controle. Cada vez que o valor deste controle é alterado, o Streamlit executa novamente todo o conteúdo do arquivo main.py e, por consequência, o texto na parte de baixo também é atualizado.</p><p>O comando st.divider() gera uma régua horizontal, que corresponde à tag HTML &lt;hr&gt;. A instrução st.header() cria um cabeçalho.</p><p>Por fim, geramos um dataframe, sendo que o Streamlit é capaz de exibi-lo em formato tabular bastando invocar a instrução st.write(dataframe).</p><h3>Exibindo os dados da Billboard Hot 100.</h3><p>Após apresentarmos o Streamlit vamos retornar à construção do dashboard que irá mostrar conteúdo extraído a partir do processo de scraping visto na parte 1 deste artigo.</p><h4>A estrutura do dashboard</h4><p>O dashboard irá constituir de uma página que apresenta uma barra lateral à esquerda que apresenta alguns controles que permitem ao usuário fazer uma filtragem por ano ou intervalo de anos, por década e por artista. O conteúdo principal irá conter uma tabela com todos os registros que satisfazem o filtro informado, além de 3 gráficos de barras. O primeiro mostra o ranking dos 10 artistas que mais semanas figuraram no topo da parada. O segundo mostra os artistas que possuem mais músicas que chegaram à 1ª posição. O terceiro mostra as 10 músicas que permaneceram por mais tempo em 1° lugar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*OU-s-pZAOf39GB_pW3FN8g.png" /><figcaption>Visão geral do dashboard</figcaption></figure><h4>Os filtros laterais.</h4><p>São 4 os filtros:</p><ul><li>Por ano: uma caixa de texto onde o usuário pode digitar diretamente um valor entre 1959 e 2023.</li><li>Por intervalo de anos: um controle do tipo <em>slider</em>, permitindo selecionar qualquer intervalo entre 1959 e 2023;</li><li>Por década: uma caixa de combinação com valores entre 1950 e 2020, de 10 em 10;</li><li>Filtro por artista: outra caixa de combinação que permite seleciona um artista. Este controle lista somente os artistas que chegaram ao primeiro no ano, ou período de anos selecionado.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/331/1*_ed5rl4nq5_FN_99BGbZ5g.png" /><figcaption>A barra lateral com os filtros</figcaption></figure><h4>O conteúdo principal</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/685/1*JJ3NBoxcuz25KhwvDJdEwA.png" /><figcaption>O conteúdo principal do dashboard, com o grid mais os três rankings</figcaption></figure><p>Quando algum artista está selecionado, somente o último gráfico é exibido, Quando alguma década é selecionada, automaticamente o intervalo de anos é alterado para corresponder à seleção. Quando um ano é digitado, o período também é atualizado, neste caso o início e o final do intervalo coincidem com o valor inserido. As três imagens a seguir ilustram estas características:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rkDdWJemmj7KPaZEcl7bSA.png" /><figcaption>Filtro por década. Ao selecionar a década de 1980, por exemplo, o intervalo de anos é atualizado p/ o intervalo 1980–1989</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jTd1-OFz3AB8pqzNvm4j4g.png" /><figcaption>Filtro por ano: ao informar um ano: o intervalo é definido com os valores inicial e final coincidentes e o filtro por década é limpo</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J-UYCAx7Ta0FBTnGlQyYew.png" /><figcaption>Quando um artista é selecionado, somente o gráfico com as suas músicas que mais tempo ficaram no topo da parada é exibido</figcaption></figure><p>Outras características notáveis do dashboard:</p><ul><li>Para cada registro listado é acrescentada uma coluna com um link p/ a página da Billboard que contém a parada da semana a que se refere o registro;</li><li>Ao passar o mouse em cima de cada uma das barras dos gráficos um <em>tooltip </em>é exibida. Por exemplo, no 3º gráfico é exibido o artista, o nome da música e o número de semanas em que ela ficou no topo da parada (ver figura acima.</li></ul><h3>Alguns detalhes de implementação</h3><h4>A organização dos arquivos fonte da aplicação</h4><p>Para esta aplicação são utilizadas as bibliotecas Streamlit e também o Scrapy, que faz a extração dos dados dos verbetes da Wikipedia que contém as listas de músicas que alcançaram o topo da parada da Billboard entre 1959 e 2023, que já foi assunto da primeira parte deste artigo. Há algumas pequenas modificações em relação ao que foi feito anteriormente, e que serão mostradas mais adiante.</p><p>Os arquivos que compõem o código fonte da aplicação estão organizados da seguinte forma:</p><pre>C:\PyCharmProjects\billboardscrapy_pt02\billboard<br>│   items.json --&gt; Arquivo JSON gerado a partir do processo de web-scraping<br>│   main.py --&gt; Arquivo principal, invoca o crawler e gera p dashboard<br>│   scrapy.cfg --&gt; arquivo de configuração do Scrapy<br>│<br>└───billboard --&gt; arquivos utilizados pela biblioteca Scrapy<br>    │   crawler.py --&gt; inicia o processo de web-scraping<br>    │   Helper.py --&gt; funções auxiliares p/ manipulação de strings<br>    │   items.py --&gt; Informações sobre cada linha obtida pelo Scrapy<br>    │   middlewares.py --&gt; Gerado pelo scrapy, sem modificações<br>    │   pipelines.py --&gt; Pós processamento de cada linha<br>    │   settings.py --&gt; configuraçãoes do spider<br>    │<br>    ├───spiders<br>    │   │   hot100.py --&gt; Definição do spider (aranha). Acessa as páginas da Wikipedia e extrai as músicas</pre><p>Os arquivos logo abaixo de billboard\billboard são utilizados pela biblioteca Scrapy e já foram descritos na parte 1 deste artigo. Há uma diferença fundamental aqui: o processo de web-scraping é disparado via script dentro do arquivo crawler.py, em vez de ser através comando scrapy crawl. Vamos mostrar a seguir como isto é feito:</p><pre>## Arquivo crawler.py<br>from scrapy.crawler import CrawlerProcess<br>from billboard.spiders.hot100 import Hot100Spider<br><br>def start_crawler():<br>    process = CrawlerProcess(<br>        settings={<br>            &quot;FEEDS&quot;: {<br>                &quot;items.json&quot;: {&quot;format&quot;: &quot;json&quot;},<br>            },<br>            &quot;ITEM_PIPELINES&quot; : {<br>                &quot;billboard.pipelines.BillboardPipeline&quot;: 300,<br>            }<br>        }<br>    )<br>    process.crawl(Hot100Spider)<br>    process.start()</pre><p>Acima, definimos a função start_crawler, que , por sua vez define um objeto CrawlerProcess, cujo parâmetro consiste em um dicionário em que é definido um arquivo de saída, no caso o items.json e um pipeline, que é processado cada vez que um item é gerado pela classe Spider. Conforme vimos anteriormente, este pipeline é necessário porque nem todas as linhas possuem as informações que necessitamos, então temos de pegar os dados faltantes dos itens lidos previamente.</p><p>A seguir o método crawl é invocado para definirmos qual aranha será utilizada, no caso a Hot100Spider. E por fim, iniciamos o processo ao chamarmos o método start().</p><h4>O arquivo principal</h4><p>Vamos agora dissecar o arquivo main.py, que contém as instruções para gerar nosso <em>dashboard</em>. Primeiro importamos as bibliotecas necessárias:</p><pre>from billboard import crawler<br>import streamlit as st<br>import pandas as pd<br>import altair as alt<br>from altair import Axis</pre><p>O código a seguir é o primeiro a ser executado quando o comando stremlit run main.py:</p><pre>if __name__ == &#39;__main__&#39;:<br>    load_panel()</pre><p>A função load_panel()é iniciada com as seguintes instruções:</p><pre>def load_panel():<br>    st.title(&quot;Billboard Hot 100&quot;)<br>    st.header(&quot;Exibindo lista de músicas que atingiram o topo da parada Billboard Hot 100&quot;)<br>    data_load_state = st.text(&#39;Carregando dados...&#39;)<br>    get_data()<br>    df = pd.read_json(&#39;items.json&#39;)<br>    df[&quot;link_chart&quot;] = df.apply(lambda row: f&quot;https://www.billboard.com/charts/hot-100/{row.date:%Y-%m-%d}&quot;, axis=1)<br>    #continua</pre><p>Primeiramente definimos título e subtítulo, e então, invocamos a função get_data()mostrado abaixo:</p><pre>@st.cache_data<br>def get_data():<br>    crawler.start_crawler()</pre><p>A função get_date() chama a função start_crawler que está definida no arquivo crawler.py descrito acima. A anotação @st.cache_data indica ao Streamlit para armazenar a saída do processo de scraping em cache, de modo que o Streamlit não irá executar novamente esta função a cada vez que um filtro for modificado. Se esta anotação não foi incluí o Streamlit irá executar o crawler novamente, o que não é desejável pois o processo de scraping demora cerca de 3 minutos para completar.</p><p>A instrução data_load_state = st.text(‘Carregando dados…’) exibe o texto “Carregando dados…” enquanto ocorre o processo de extração de conteúdo das páginas da wikipedia. Quando este processo completa, este texto é substituído, para isso atribuímos um novo valor à variável data_load_state.</p><p>Ao completar este processo, criamos um objeto Dataframe a partir do arquivo JSON gerado. Posteriormente, adicionamos uma coluna extra com uma URL que levará o usuário ao site da Billboard.com na página referente à parada da semana selecionada.</p><p>Ainda no método load_panel() definimos os filtros que irão aparecer na parte lateral esquerda da página:</p><pre>    st.sidebar.header(&quot;Filtros&quot;)<br>    st.sidebar.subheader(&quot;Filtro por ano&quot;)<br>    st.sidebar.number_input(&quot;Ano:&quot;,value=None, key=&quot;selected_year&quot;,min_value=1959, max_value=2023, step=1, on_change=set_interval_from_year)<br>    st.sidebar.subheader(&quot;Filtro por período&quot;)<br>    st.sidebar.slider(&#39;Selecione o período desejado&#39;, 1959, 2023, (1959, 2023), key=&quot;years&quot;,<br>                      on_change=clear_decade_year)<br>    st.sidebar.subheader(&quot;Ou&quot;)<br>    st.sidebar.subheader(&quot;Filtro por década&quot;)<br>    st.sidebar.selectbox(&quot;Década&quot;, range(1950, 2030, 10), index=None, key=&quot;decade&quot;, on_change=set_years_from_decade)<br><br><br></pre><p>Em cada um dos controles é definido um atributo key que permite recuperar os conteúdos dos controles através do objeto session_state, por exemplo, se um controle possui o atributo key=&quot;chave1&quot;, então seu conteúdo pode ser recuperado através da propriedade st.session_state.chave1ou st.session_state[&#39;chave1&#39;]</p><p>Conforme explicado anteriormente, o <em>slider</em> que especifica o intervalo de anos é atualizado quando um valor no campo ‘ano’ ou no campo ‘década’ é selecionado, então para filtrar o <em>dataframe</em> por data basta pegar os valores mínimo e máximo selecionados no <em>slider:</em></p><pre>(min_year, max_year) = st.session_state.years<br>filtered_df = df[(df[&quot;year&quot;] &gt;= min_year) &amp; (df[&quot;year&quot;] &lt;= max_year)]</pre><p>A próxima etapa é pegar os artistas que em algum momento entre o ano inicial e o final selecionados chegaram ao 1º lugar da Billboard Hot 100, então preencho a lista de valores para o filtro por artistas. Quando um deles é selecionado, então o dataframe é filtrado novamente e definida uma variável — filtered_by_artist que será utilizada para mostrar ou esconder os gráficos que mostram os dois rankings de artistas (por semanas em 1º lugar ou por número de músicas)</p><pre>    artists = sorted(filtered_df[&quot;artist&quot;].unique())<br>    st.sidebar.subheader(&quot;Filtro por artista&quot;)<br>    st.sidebar.selectbox(&quot;Artista&quot;, artists, index=None, key=&quot;artist&quot;)<br>    if &quot;artist&quot; in st.session_state.keys() and st.session_state.artist:<br>        filtered_df = filtered_df[filtered_df[&quot;artist&quot;] == st.session_state.artist]<br>        is_filtered_by_artist = True<br>    else:<br>        is_filtered_by_artist = False</pre><p>A seguir, mostramos a lista de músicas com base nos filtros especificados e substituímos o texto “Carregando dados” por outro que informa o total de registros (lembre-se que uma referência a este controle foi salva na variável data_load_state, então basta modificar esta variável para mudar o conteúdo atual do texto):</p><pre>st.dataframe(filtered_df,<br>                 column_config={&quot;sequential_no&quot;: &quot;Sequencial&quot;,<br>                                &quot;date&quot;: st.column_config.DateColumn(<br>                                    &quot;Data&quot;, format=&quot;DD/MM/YYYY&quot;),<br>                                &quot;song&quot;: &quot;Música&quot;,<br>                                &quot;artist&quot;: &quot;Artista&quot;,<br>                                &quot;year&quot;: st.column_config.NumberColumn(<br>                                    &quot;Ano&quot;, format=&quot;%d&quot;),<br>                                &quot;link_chart&quot;: st.column_config.LinkColumn(<br>                                    &quot;Referência&quot;, help=&quot;Link p/ a página da Billboard&quot;,<br>                                    display_text=&quot;Ir p/ parada&quot;)<br>                                },<br>                 hide_index=True<br>                 )<br>data_load_state.info(f&quot;{filtered_df.shape[0]} registro(s) carregado(s)&quot;)</pre><p>O parâmetro column_config acima permite configurar as colunas do <em>dataframe</em>. Acima, exibimos as colunas sequential_no, song, artist do jeito que está, modificando apenas o cabeçalho da coluna. Quanto à coluna year definimo-la como numérica e definimos formato %d, que exibe somente números (Por padrão, esta coluna seria exibida em formato americano, com vírgulas separando a unidade de milhar, assim 1996 seria escrito como 1,996, algo sem sentido para idiomas em que a vírgula é utilizada como separador decimal, como é o caso do português. Por padrão também a data seria mostrada em formato norte-americano, ou seja mês/dia/ano, então temos que explicitamente definir o formato como dia/mês/ano. Por fim, a última coluna é do tipo link com texto fixo e que direciona para o site da Billboard na página que mostra a parada musical da semana que corresponde ao registro selecionado.</p><p>A útlima etapa é mostrar os gráficos:</p><pre>display_graphics(filtered_df, is_filtered_by_artist).<br><br>def display_graphics(df, filtered_by_artist):<br>    if not filtered_by_artist:<br>        st.subheader(&quot;Ranking dos artistas que mais figuraram no topo da parada&quot;)<br>        df_grouped_artist = df.groupby(&quot;artist&quot;, as_index=False)<br>        st.markdown(&quot;#### Por número de semanas&quot;)<br>      # Se o método abaixo, com as opções padrão, fosse invocado, o gráfico seria ordenado por artista<br>      # st.bar_chart(get_top10_artists_by_song(df), horizont al=True)<br>        st.write(alt.Chart(<br>            get_top10_artists_by_weeks(df_grouped_artist),<br>        ).mark_bar().encode(<br>            y=alt.Y(&quot;artist:N&quot;, axis=Axis(title=&#39;Artista&#39;)).sort(&quot;-x&quot;),<br>            x=alt.X(&#39;date:Q&#39;, axis=Axis(title=&quot;Total de semanas em 1º lugar&quot;)),<br>            tooltip=[<br>                alt.Tooltip(&quot;artist&quot;, title=&quot;Artista:&quot;),<br>                alt.Tooltip(&quot;date&quot;, title=&quot;Total de semanas em 1ºlugar:&quot;)<br>            ]<br>        ))<br>        st.markdown(&quot;#### Por número de músicas&quot;)<br>        st.write(alt.Chart(<br>            get_top10_artists_by_song(df_grouped_artist),<br>        ).mark_bar().encode(<br>            y=alt.Y(&quot;artist:N&quot;, axis=Axis(title=&#39;Artista&#39;)).sort(&quot;-x&quot;),<br>            x=alt.X(&#39;song:Q&#39;, axis=Axis(title=&#39;Quantidade de Músicas&#39;)),<br>            tooltip=[<br>                alt.Tooltip(&quot;artist&quot;, title=&quot;Artista:&quot;),<br>                alt.Tooltip(&quot;song&quot;, title=&quot;Qtde. de músicas:&quot;),<br>            ]<br>        ))<br><br>    st.subheader(&quot;As músicas que mais tempo permaneceram em primeiro lugar &quot;)<br>    st.write(alt.Chart(<br>        get_top_10_songs_by_number_of_weeks(df),<br>    ).mark_bar().encode(<br>        y=alt.Y(&quot;song_artist:N&quot;, axis=Axis(title=&quot;Música&quot;)).sort(&quot;-x&quot;),<br>        x=alt.X(&#39;date:Q&#39;, axis=Axis(title=&quot;Total de semanas em 1º lugar&quot;, tickMinStep=1)),<br>        tooltip=[<br>            alt.Tooltip(&quot;artist&quot;, title=&quot;Artista:&quot;),<br>            alt.Tooltip(&quot;song&quot;, title=&quot;Música:&quot;),<br>            alt.Tooltip(&quot;date&quot;, title=&quot;Total de semanas em 1ºlugar:&quot;)<br>        ]<br><br>    ))<br><br>def get_top10_artists_by_weeks(grouped):<br>    return grouped[[&quot;date&quot;]].count().sort_values(by=&quot;date&quot;, ascending=False)[0:10]<br><br><br>def get_top10_artists_by_song(grouped):<br>    return grouped[&quot;song&quot;].nunique().sort_values(by=&quot;song&quot;, ascending=False)[0:10]<br><br><br>def get_top_10_songs_by_number_of_weeks(df):<br>    df_group_by_song = df.groupby([&quot;artist&quot;, &quot;song&quot;], as_index=False)<br>    df_count = df_group_by_song.count()<br>    df_count[&quot;song_artist&quot;] = df_count.apply(lambda row: row.song + &quot; - &quot; + row.artist.upper(), axis=1)<br>    return df_count.sort_values(by=&quot;date&quot;, ascending=False)[0:10]</pre><p>Por padrão, o Streamlit utiliza a abiblioteca <a href="https://altair-viz.github.io/index.html">Vega-Altair</a> para gerar gráficos, embora seja possível utilizar outras ferramentas como o <a href="https://matplotlib.org/">Matplotlib</a> e o <a href="https://bokeh.org/">Bokeh</a>. Acima poderia ter utilizado o método st.bar_chart, porém se isto fosse feito os gráficos ficariam ordenados por ordem de alfabética do artista. Daí para ordenar em ordem decrescente por semanas em 1º lugar ou por número de músicas, é necessário invocar diretamente a biblioteca Vega-Altair para que fosse possível personalizar a ordenação do gráfico, que é feita a seguir, pegando o ranking por número de semanas como exemplo:</p><pre>y=alt.Y(&quot;song_artist:N&quot;, axis=Axis(title=&quot;Música&quot;)).sort(&quot;-x&quot;),<br>x=alt.X(&#39;date:Q&#39;, axis=Axis(title=&quot;Total de semanas em 1º lugar&quot;, tickMinStep=1)),</pre><p>Acima, o método sort(-x) diz à biblioteca para ordenar o gráfico em ordem decrescente dos valores do eixo “X”. Os sufixos “N” e “Q” aos nomes das variáveis, indicam que elas são do tipo nominal (string) e quantitativa *numérica), respectivamente.</p><h3>Conclusão</h3><p>O artigo acima procurou mostrar alguns dos recursos mais importantes da ferramenta Streamlit, demonstrando como, com poucas linhas de código é possível criar um aplicativo simples, porém funcional, e com uma interface agradável, sem a necessidade de se conhecer a fundo ferramentas de interface de usuário, como HTML, CSS, Bootstrap e afins. Além disso, este artigo e o anterior procuram mostrar que o Scrapy e o Streamlit formam uma boa parceria para extração e exibição de dados extraídos de páginas da Web.</p><p>Clique <a href="https://github.com/marciusdm/webscraping/raw/main/scrapy_billboard_pt02/billboard_pt02.zip">aqui</a> para baixar o código fonte completo da aplicação mostrada neste artigo</p><p>Clique <a href="https://medium.com/@marciusdellano">aqui</a> para ler meus outros artigos escritos na plataforma Medium</p><p>Meu <a href="https://github.com/marciusdm/portfolio">portfolio</a> profissional</p><p>Meu <a href="https://www.linkedin.com/in/marciusdm">perfil</a> no Linkedin</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a9bfeb78cf92" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A practical web-scraping application with Scrapy]]></title>
            <link>https://medium.com/@marciusdellano/a-practical-web-scraping-application-with-scrapy-a4e2a2a2938d?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4e2a2a2938d</guid>
            <category><![CDATA[billboard-hot-100]]></category>
            <category><![CDATA[wikipedia]]></category>
            <category><![CDATA[python-scrapy]]></category>
            <category><![CDATA[web-scraping]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Mon, 24 Jun 2024 19:09:11 GMT</pubDate>
            <atom:updated>2024-07-21T01:40:25.227Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*SM96nQRutDMT50_g2amp-g.png" /><figcaption>IA generated image</figcaption></figure><p>In this article, divided into two parts, we will show a web scraping application, which consists of extracting from Wikipedia, songs that reached the top of the <a href="https://www.billboard.com/charts/hot-100/">Billboard Hot 100</a> chart, from 1959 to 2023. The first part will deal with the process of extracting information using a web-scraping tool, and the second part will deal with displaying the data, using an interactive <em>dashboard.</em></p><h3>The application context</h3><h3>The Billboard Hot 100</h3><p>The Billboard Hot 100, published by <em>Billboard magazine,</em> is the standard music chart for the music industry in the United States and indicates, weekly, which are the 100 most popular songs in that country. Currently, this ranking is based on sales, both physical and digital, radio airplay, and streaming services<em>,</em> but the methodology for classifying songs has varied over time.</p><p>Billboard had been organizing music charts since the beginning of the 40s, however, the Hot 100 only debuted on August 4, 1958. The first number one song on the chart was “Poor Little Fool” by <a href="https://pt.wikipedia.org/wiki/Ricky_Nelson">Ricky<em> </em>Nelson</a>, and to date in which this article is written, — 06/15/24–1172 different songs reached the top of this chart.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/1*oSTQmqKCXF-7x-cyFyrCrw.png" /><figcaption>Billboard Hot 100 logo</figcaption></figure><h3><strong>The origin of the data and how it is obtained</strong></h3><p>The data used in this application was obtained from entries in the English version of Wikipedia corresponding to the list of number-one songs from the years 1959 to 2023. I left out the year 1958 because until the beginning of the Hot 100, there were 3 different charts and the structure of the table that contains the data is very different from the tables from other years.</p><p>The tool used to get the data is <a href="https://www.scrapy.org/">Scrapy</a>, which is a library written in Python. In this <a href="https://bit.ly/45pYI7J">article</a>, I give a brief presentation of this library. I recommend reading it before proceeding if you are unfamiliar with this library. I also use PyCharm to create a Python project, using a virtual environment.</p><p>Here, I will cover slightly more advanced concepts, such as <em>pipeline</em> and <em>item loaders,</em> and show some additional features not covered in the Scrapy presentation article.</p><p><strong>The structure of the pages to be scraped</strong></p><p>As previously mentioned, the data will be collected from English Wikipedia pages containing lists of all the songs that reached #1 on the Billboard Hot 100 chart. The page addresses have the format <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_(year)where">https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_(year)</a> where (year) varies from 1959 to 2023. On each page, there is a table with the list of songs, from which the name of the artist, the song, and the date on which the classification was made will be collected for each line. This table is the second on the page when the following warning is not present. When it does, as is the case with the page referring to 1970, it is the third one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_TRXuDJDZo1fkmPf86sYog.png" /><figcaption>Warning present on some of the pages searched.</figcaption></figure><p>Below, as a sample, is a <em>print</em> of part of the page containing the list of songs from 1981.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/0*QJ2D18oB2q1ONCCr.png" /></figure><p>We can observe some patterns on this page:</p><ul><li>Songs and artists at number one for more than one week are displayed as a single cell that spans as many rows as the consecutive weeks the songs ranked at number one;</li><li>For each song or artist, a link is placed that directs to the respective entries on Wikipedia, but only the first time they appear in the table. For example, Dolly Parton’s song “9 to 5” ranked first in two non-consecutive weeks. The links are only present in their first appearance, in the week of February 27th. The band Blondie, in turn, reached first place, with the song “The Tide is High” on 01/31/81 and with “Rapture” on 03/28. In this case, the link to the entry “Blondie” only appears in its first occurrence, on 01/27.</li></ul><p>There are still two important aspects, but they are only visible when viewing the source code of the pages:</p><ol><li>The message in yellow is also an HTML table</li><li>The table header is not separated from the other lines by an element &lt;thead&gt;, but together with them within tbody.</li></ol><p>In general, the table containing the music list has the following structure (the attributes of the HTML tags were omitted):</p><pre>&lt;table&gt;<br> &lt;tbody&gt;<br>   &lt;tr&gt;<br>     &lt;th&gt;No.&lt;/th&gt;<br>     &lt;th&gt;Issue Date&lt;/th&gt;<br>     &lt;th&gt;Song&lt;/th&gt;<br>     &lt;th&gt;Artist(s)&lt;/th&gt;<br>     &lt;th&gt;Ref&lt;/th&gt;&lt;!-- this column is ignored --&gt;<br>   &lt;/tr&gt;<br>   &lt;tr&gt;<br>    &lt;td&gt;[Seq number]&lt;/td&gt;<br>    &lt;td&gt;[date]&lt;/td&gt;<br>    &lt;td  rowspan = &quot;[weeks consecutive]&quot;&gt;&lt;a&gt;Song 1&lt;/a&gt;&lt;/td&gt;<br>    &lt;td  rowspan = &quot;[consecutive weeks]&quot;&gt;&lt;a&gt;Artist 1&lt;/a&gt;&lt;/td&gt;<br>    &lt;td&gt;[Ref]&lt;/td&gt;<br>   &lt;/tr&gt;<br>  &lt;tr&gt;&lt;!-- when it is the same song and artist --&gt;<br>    &lt;td&gt;[Consecutive week 2]&lt;/td&gt;<br>    &lt;td&gt;[Ref]&lt;/td&gt;<br>  &lt;/tr&gt;<br>    . . . <br> &lt;tr&gt;<br>    &lt;td&gt;[Consecutive week n&lt;/td&gt;<br>    &lt;td&gt;[Ref]&lt;/td&gt;<br> &lt;/tr&gt;<br>&lt;!-- there are also rare cases in which an artist appears in first place for <br>a few consecutive weeks,but with different songs --&gt;<br>&lt;tr&gt;<br>    &lt;td&gt;[Seq number]&lt;/td&gt;<br>    &lt;td&gt;[date]&lt;/td&gt;<br>    &lt;td  rowspan = &quot;[consecutive weeks]&quot;&gt;&lt;a&gt;Artist 2&lt;/a&gt;&lt;/td&gt;<br>    &lt;td&gt;[Ref]&lt;/td&gt;<br>&lt;/tr&gt;<br>&lt;tr&gt;<br>    &lt;td&gt;[Seq number]&lt;/td&gt;<br>    &lt;td&gt;[data]&lt;/td&gt;<br>    &lt;td  rowspan = &quot;[consecutive weeks]&quot;&gt;&lt;a&gt;Song 2&lt;/a&gt;&lt;/td&gt;<br>    &lt;td  rowspan = &quot;[consecutive weeks]&quot;&gt;&lt;a&gt;Artist 2&lt;/a&gt;&lt;/td&gt;<br>    &lt;td&gt;[ Ref]&lt;/td&gt;<br>&lt;/tr&gt;<br> . . . <br>&lt;tr&gt;<br>    &lt;td&gt;[Seq nnumber]&lt;/td&gt;<br>    &lt;td&gt;[date]&lt;/td&gt;<br>    &lt;td&gt;Repeated song&lt;/td&gt;<br>    &lt;td&gt;Repeated artist&lt;/td&gt;<br>    &lt;td&gt;[Ref]&lt;/td&gt;<br>&lt;/tr&gt;<br>&lt;tr&gt;<br>    &lt;td&gt;[Seq number]&lt;/td&gt;<br>    &lt;td  rowspan = &quot;[consecutive weeks]&quot;&gt;[date]&lt;/td&gt;<br>    &lt;td&gt;&lt;a&gt;Song 2&lt;/a&gt;&lt;/td&gt;<br>    &lt;td&gt;&lt;a&gt;Artist 2&lt;/a&gt;&lt;/td&gt;<br>    &lt;td&gt;[Ref]&lt;/td&gt;<br>&lt;/tr&gt;<br><br> . . .<br>&lt;/tbody&gt;<br>&lt;/table&gt;</pre><p>Note that some lines are incomplete, with only the date and references for footnotes. The remaining fields are contained in the complete lines immediately preceding them</p><h3>Creating the application</h3><p>After creating a project in Pycharm and installing the Scrapy library, you must run the command in the PyCharm terminal to create a scrapy project with the name “billboard”</p><pre>scrapy startproject billboard</pre><p>This creates a folder within the folder created by PyCharm, with the following structure:</p><pre>billboard/ <br>    scrapy.cfg # deploy configuration file# deploy configuration file<br>    billboard/              # project&#39;s Python module, you&#39;ll import your code from here<br>         __init__.py <br>        items.py           # project items definition file<br>         middlewares.py     # project middlewares file<br>         pipelines.py       # project pipelines file<br>         settings.py        # project settings file<br>         spiders/           # a directory where you&#39;ll later put your spiders<br>             __init__.py</pre><p>Now we must create our spider. Using the terminal, we must go to the directory billboardand type the following command:</p><pre>scrapy genspider hot100 &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;&quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;</pre><p>This creates a named file hot100.pywithin the folder spidersdefining a named class Hot100Spiderwith the following content:</p><pre>import scrapy <br>class  Hot100Spider (scrapy.Spider): <br>  name = &quot;hot100&quot;<br>  allowed_domains = [ &quot;en.wikipedia.org&quot; ] <br>  start_urls = [ <br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot; <br>  ] <br>  def  parse ( self, response ): <br>        pass</pre><p>Then I’ve changed the contents of star_urls variable to store all pages from 1959, to 2023:</p><pre>start_urls = [<br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;,<br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1960&quot;,<br>                    . . .<br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_2023&quot;]<br>]</pre><p>Note: It is not mandatory to use the scrapy genspider command, as the Spider class can be created manually. This command makes the job easier by generating a skeleton for the spider, and there are 4 templates available. See the Scrapy <a href="https://docs.scrapy.org/en/latest/topics/commands.html#std-command-genspider">documentation</a> for more details. We need to define the method parse, but first let&#39;s dive into some topics not covered in my introductory article on Scrapy</p><h3>The items.py file</h3><p>The main objective of web-scraping is to extract structured data from unstructured sources, such as web pages. <em>Spiders</em> classes can return data as <em>items</em> , which can be dictionaries or Python objects, inheritors of the class scrapy.Item. In our case, we will return an object containing a sequential number, the name of the artist or band, the name of the song, and the date it reached number one. To do this, we define, within the file Items.pya class called BillboarItemwith the following content:</p><pre>class  BillboardItem (scrapy.Item): <br>    # define the fields for your item here like: <br>    # name = scrapy.Field()<br>     sequential_no=scrapy.Field() <br>    artist = scrapy.Field() <br>    song = scrapy.Field() <br>    year = scrapy .Field() <br>    date = scrapy.Field()</pre><p>Internally, Scrapy creates a dictionary from the subclass of scrapy.ItemThe method scrapy.Field()only creates the keys of this dictionary. This dictionary is populated during the execution of parse()the class method Spider.</p><h3>Item Loaders</h3><p>Loaders are a mechanism that allows you to populate <em>scraped</em> items using CSS, XPath, or literal values. They are generally invoked in parse()the spider method. Here in this application, an object is invoked for each line read, ItemLoaderwhich is responsible for populating an object of the type BillboardItemseen above. Each object property BillboardItemis populated from the content of an element indicated by the expression passed through the load_cssor methods load_xpath. The code below shows how each object property is filled in BillboardItem:</p><pre>  def parse(self, response): <br>         #extract the year from the page title<br>         year = int (response.css(&quot;h1::text&quot;).getall()[1][-4:]) <br>         chart_history = response .xpath(&quot;//table[2]/tbody/tr&quot;) <br><br>        # ignore first line<br>         for week_chart in chart_history[1:]: <br>            loader = ItemLoader(item=BillboardItem(), selector=week_chart) <br>            // the bottom line too could be: <br>            // loader.add_xpath(&quot;sequential_no&quot;,td[1]/text()&quot;)<br>            loader.add_css(&quot;sequential_no&quot; , &quot;td:nth_child(1)::text&quot; ) <br>            loader.add_css(&quot;date&quot; , &quot;td:nth_child(2)&quot; , TakeFirst()) <br>            loader.add_css(&quot;song&quot; , &quot;td:nth_child(3)&quot; , TakeFirst()) <br>            loader.add_css(&quot;artist&quot; , &quot;td:nth_child(4)&quot; , TakeFirst()) <br>            loader.add_value(&quot;year&quot; , year) <br>            yield loader.load_item()</pre><p>In the first line within the loop, foran object is created ItemLoader, passing two parameters to the constructor:</p><ul><li>item: which will be the object BillboardItem, which will store the data extracted from the page;</li><li>selector: from where to extract the data, in this case, each element returned by the expression response.xpath(“//table[2]/tbody/tr”)with the exception of the first, which corresponds to the table header.</li></ul><p>In the following lines, the method add_css is invoked, passing as a parameter the object property BillboardItemto be filled and the element selector whose content will be the value of this property. Optionally, a third parameter is passed, which is a <em>callback</em> function used to process the output generated by the method. We use her the function TakeFirst() which gets only the first element, if the specified selector returns more than one. There are other predefined functions, for example, Join()which returns all found elements separated by commas. In the penultimate line, a literal value for the property is entered year. Then on the last line, the command loader.load_item()that populates the item with the information provided by the methods load_xxx.</p><h3>The pipeline class</h3><p>Each time an item is generated by the spider, a <em>pipeline</em> is executed. A <em>pipeline</em> is a Python class that must implement at least the method process_item, with two parameters: the object itemreturned by the method loader.loader_item()and the object spider:</p><pre>def process_item(self, item, spider): </pre><p>Although it is possible, within a <em>pipeline,</em> to work directly with the itemclass, it is good practice to use the class ItemAdapterprovided by the Scrapy library.</p><p>Pipelines allow you to perform activities such as data validation, elimination of duplicate items, insertion into a database, among others. In this application, the <em>pipeline</em> will be used for the following tasks:</p><ul><li>Temporarily store each new song entry, as in the following lines in which it appears, information about song and artist will not be available, having to be filled in with the previously saved data;</li><li>As in some lines, the songs and artists are contained in links, that is, within elements &lt;a&gt;, and in others they are not, so the solution is to take the content within the respective ones &lt;td&gt;and strip off the HTML tags;</li><li>The type of content of the cells in each row varies, as it can contain 2, 4 or 5 cells. then, the distinction between each type is made using regular expressions.</li></ul><p>Then the <em>pipelines.py</em> file will look like this:</p><pre>class  BillboardPipeline: <br>    last_song = &quot;&quot;<br>    last_artist = &quot;&quot;<br>    last_date = &quot;&quot;<br>    last_sequential = &quot;&quot; <br><br><br>    def  _fill_last_song (self, adapter): <br>        # When it is the first occurrence of a song, <br>        # it is saved in a variable <br>        if &#39;song&#39;  in adapter .keys(): <br>            self.last_song = adapter[&quot;song&quot;] <br>        # when the song information is taken from the last occurrence <br>        else : <br>            adapter[&quot;song&quot;] = self.last_song <br><br>    def  _fill_last_artist (self, adapter): <br>        # in item loader , the artist was defined as the fourth element &lt;td&gt; of the line # <br>        # but when it only has two cells or when the fourth cell is a reference # <br>        # then when I get the last saved artist # <br>        if  &#39;artist&#39;  in adapter.keys( ) and  not Helper.is_note_or_empty(adapter[&quot;artist&quot;][0]): <br>            self.last_artist = adapter[&quot;artist&quot;] <br>        #when the line is complete, save the artist for future use <br>        else : <br>            adapter[&quot;artist&quot;] = self.last_artist <br><br>    def  _treat_date_and_sequential (self, adapter): <br>        # eliminates HTML tags and quotes <br>        # the load_xxx methods always return a list, even when only <br>        # one element is returned, but then I only get the first item from the list<br>        adapter[&quot;date&quot;] = Helper.strip_html_and_quotes(adapter[&quot;date&quot;][0]) <br>        if  &#39;sequential_no&#39;  in adapter.keys(): <br>            adapter[&quot; sequential_no&quot;] = Helper.strip_html_and_quotes( <br>                adapter[&quot;sequential_no&quot;][0] ) <br>        if Helper.is_note_or_empty(adapter[&quot;date&quot;]): <br>            # adapter[&quot;date&quot;] is always the second cell <br>            # but, if the line is incomplete,the date is in the first <br>            # so you need to read the date from adapter<br>             adapter[&#39;date&#39;] = adapter[&quot;sequential_no&quot;] <br>            adapter[&quot;sequential_no&quot;] = self.last_sequential <br>        elif &#39;sequential_no&#39;  in adapter.keys(): <br>            # store the current value of the sequential number<br>             self.last_sequential = adapter[&quot;sequential_no&quot;] <br>        else : <br>            # to return it when the information is missing. <br>            # This occurs from 2012<br>             adapter[&quot;sequential_no&quot;] = self.last_sequential <br>        adapter[&quot;sequential_no&quot;] = adapter[&quot;sequential_no&quot;] <br><br>    def  _treat_artist_and_song (self, adapter): <br>        # HTML tags, quotation marks and the character † present when<br>        # the song is &#39;song of the year&#39; are stripped off<br>        adapter[&quot;song&quot;] = Helper.strip_html_and_quotes(adapter[&quot;song&quot;][0]) <br>        adapter[&quot;song&quot;] = Helper.strip_song_of_the_year_mark(adapter[&quot;song &quot;]) <br>        adapter[&quot;artist&quot;] = Helper.strip_html_and_quotes(adapter[&quot;artist&quot;][0]) <br><br>    # converts an English date to dd/mm/yyyy format. The year is read from <br>    # adapter[&quot;year&quot;] <br>    # e.g.: February 18 to 18/02 <br>    def  _convert_date ( self, adapter ): <br>        adapter[&quot;date&quot;] = Helper.convert_english_date(adapter[&quot;date&quot;], adapter[&quot; year&quot;]) <br><br>    # For each line read, an item object is passed to the &#39;process_item <br>    # which, when encapsulated by the ItemAdapter, has the following data: <br>    # adapter[&quot;sequential_no&quot;]: first cell <br>    # adapter[&quot;date&quot;]: second cell <br>    # adapter[&quot;song&quot;]: third cell <br>    # adapter[&quot;artist&quot;]: fourth cell <br>    # adapter[&quot;year&quot;]: read directly from a variable in the spider&#39;s &#39;parse&#39; method <br>    def  process_item (self, item, spider): <br>        adapter = ItemAdapter(item) <br>        adapter[&quot;year&quot;]=adapter[&quot;year&quot;][0] <br>        self._fill_last_song(adapter) <br>        self._fill_last_artist(adapter) <br>        self._treat_artist_and_song(adapter) <br>        self._treat_date_and_sequential(adapter) <br>        self._convert_date (adapter) <br><br>        return item</pre><p>Note: at the end of this article there will be a link so you can download the complete source code of this application.</p><p>For the above pipeline to be executed, it must be registered in the system. To do this, you need to edit the file settings.pyand add the following entry:</p><pre># Configure item pipelines <br># See https://docs.scrapy.org/en/latest/topics/item-pipeline.html<br> ITEM_PIPELINES = { <br>    &quot;billboard.pipelines.BillboardPipeline&quot; : 300, <br>}</pre><p>Comments:</p><ol><li>Normally, this piece of code is already generated by the command scrapy startprojectbut it is commented, so you just need to uncomment it.</li><li>The number 300 associated with the class BillboardPipelineindicates the order of execution of the pipeline, if there is more than one. The order of execution is from the pipeline with the lowest value to those with the highest value.</li></ol><h3>Some additional treatments</h3><p>This application, as coded so far, will only work for some pages, as some of them have some particularities:</p><ul><li>The entries referring to the years <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1966">1966</a> , <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1967]">1967</a> , <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1968">1968</a> , <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1969">1969</a> , <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1970">1970</a> , <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1971">1971</a> , <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1974">1974</a> , <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1975">1975</a> and <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1997">1997</a> present the warning shown at the beginning of the article, which is within a&lt;table&gt;</li><li>As of 2011, the cell containing the date is a tag &lt;th&gt;and not&lt;td&gt;</li><li>The variable start_urlsinforms all the pages that will be visited by the spider. The problem is that Scrapy does not guarantee that they will be visited in the same order in which they are declared in this variable. Furthermore, several simultaneous execution lines are generated, and thus, the pipeline class does not process the lines sequentially, causing the information to be stored incorrectly, as can be seen from the file snippet obtained when running Scrapy with the option to generate output in JSON format:</li></ul><pre>{&quot;sequential_no&quot;: &quot;710&quot;, &quot;date&quot;: &quot;06/01/1990&quot;, &quot;song&quot;: &quot;Another Day in Paradise&quot;, &quot;artist&quot;: &quot;Phil Collins&quot;, &quot;year&quot;: 1990},<br>{&quot;sequential_no&quot;: &quot;710&quot;, &quot;date&quot;: &quot;01/12/1962&quot;, &quot;year&quot;: 1962, &quot;song&quot;: &quot;Another Day in Paradise&quot;, &quot;artist&quot;: &quot;Phil Collins&quot;},<br>{&quot;sequential_no&quot;: &quot;710&quot;, &quot;date&quot;: &quot;08/12/1962&quot;, &quot;year&quot;: 1962, &quot;song&quot;: &quot;Another Day in Paradise&quot;, &quot;artist&quot;: &quot;Phil Collins&quot;},</pre><p>What happened above is that the pipeline first read the line referring to the date January 6th, on the <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1990">1990</a> page , storing the information about the artist (Phil Collins) and the song (“Another Day in Paradise”); however, Scrapy was simultaneously visiting this page and the <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1962">1962</a> page, and the next items to be read by the pipeline were the lines dated 12/01 and 12/08/1962, coincidentally incomplete lines as they referred to a song that was in first place since 11/17 of that year — “Big Girls Don’t Cry” by The Four Seasons — , so the pipeline filled these last two lines with the data that was stored when it read the first one, i.e. “Another Day in Paradise ” instead of “Big Girls Don’t Cry.” Therefore, it is necessary to create a mechanism for Scrapy to visit the pages in sequence. This is done by defining the content of the variable start_urlsas only that of the first year ( <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959">1959</a> ), then onparsemethod, Scrapy will be instructed to visit the page of the following year and invoke the parse method again. This is achieved by adding the following code after the last line of the method parse():</p><pre>  if(year &lt;2023):<br>                url_next_year = f&quot;/wiki/List_of_Billboard_Hot_100_number_ones_of_{year+1}&quot;<br>                url_next_year = response.urljoin(url_next_year)<br>                yield scrapy.Request(url_next_year, callback=self.parse)</pre><p>In the code above, it is checked whether the year 2023 has already been reached, the last one on our list. If not, I take the URL of the page for the next year, combine the two parts (server + path), then make a new request for this page, causing the method parseto be executed again.</p><p>With all these particularities in mind, our spider class will look like this:</p><pre>class Hot100Spider(scrapy.Spider):<br>    name = &quot;hot100&quot;<br>    allowed_domains = [&quot;en.wikipedia.org&quot;]<br>    start_urls = [<br>        &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;,<br>    ]<br><br>    def parse(self, response):<br>        sleep(3)<br>        year = int(response.css(&quot;h1::text&quot;).getall()[1][-4:])<br>        # Os artigos referentes aos anos abaixo, a tabela com as relação de músicas em 1º lugar na Billboard<br>        # é a terceira e não a segunda da página<br>        years_with_warning = [1966, 1967, 1968, 1969, 1970, 1971, 1974, 1975, 1997]<br>        chart_history = response.xpath(&quot;//table[3]/tbody/tr&quot;) if year in years_with_warning \<br>            else response.xpath(&quot;//table[2]/tbody/tr&quot;)<br><br>        # ignore first line<br>        for week_chart in chart_history[1:]:<br>            loader = ItemLoader(item=BillboardItem(), selector=week_chart)<br>            loader.add_css(&quot;sequential_no&quot;, &quot;td:nth_child(1)::text&quot;)<br>            if year &lt;= 2011:<br>                loader.add_css(&quot;date&quot;, &quot;td:nth_child(2)&quot;, TakeFirst())<br>            else:<br>                loader.add_css(&quot;date&quot;, &quot;th::text&quot;, TakeFirst())<br>            loader.add_css(&quot;song&quot;, &quot;td:nth_child(3)&quot;, TakeFirst())<br>            loader.add_css(&quot;artist&quot;, &quot;td:nth_child(4)&quot;, TakeFirst())<br>            loader.add_value(&quot;year&quot;, year)<br>            yield loader.load_item()<br><br>            if(year &lt;2023):<br>                url_next_year = f&quot;/wiki/List_of_Billboard_Hot_100_number_ones_of_{year+1}&quot;<br>                url_next_year = response.urljoin(url_next_year)<br>                yield scrapy.Request(url_next_year, callback=self.parse)</pre><h3>Conclusion</h3><p>We can conclude by stating that the process of extracting data from a page can be quite challenging, since pages do not always follow a single pattern, so much so that it was necessary to carry out special treatment for some of them. Unlike the “ <a href="https://quotes.toscrape.com/">Quotes to Scrape</a> ” site featured in my introductory article on web scraping with Scrapy, most sites don’t make our job of collecting your data very easy.</p><p>Click <a href="https://github.com/marciusdm/webscraping/tree/main/scrapy_billboard">here</a> to access and download the source code used in this article.</p><p>Click <a href="https://bit.ly/46g0x7H">here</a> to read the part 2 of this article</p><p>Click <a href="https://medium.com/@marciusdellano">here</a> to read my other articles written on the Medium platform.</p><p>My professional <a href="https://github.com/marciusdm/portfolio/blob/main/Readme_en.md">portfolio</a>.</p><p>My <a href="https://www.linkedin.com/in/marciusdm">profile</a> on Linkedin.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4e2a2a2938d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Um aplicação prática de web-scraping com Scrapy]]></title>
            <link>https://medium.com/@marciusdellano/um-aplica%C3%A7%C3%A3o-pr%C3%A1tica-de-web-scraping-com-scrapy-de7eae815af8?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/de7eae815af8</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[scrapy]]></category>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[wikipedia]]></category>
            <category><![CDATA[billboard]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Sun, 23 Jun 2024 02:58:02 GMT</pubDate>
            <atom:updated>2024-07-20T14:38:32.656Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ys03gaq8YH0ZS9_El53KKA.jpeg" /></figure><p>Click <a href="https://medium.com/@marciusdellano/a-practical-web-scraping-application-with-scrapy-a4e2a2a2938d">here</a> to read an English version of this article</p><p>Neste artigo, dividido em duas partes, será mostrada uma aplicação de web scraping que consiste em extrair de páginas da Wikipedia em inglês, as músicas que atingiram o topo da parada da <a href="https://www.billboard.com/charts/hot-100/">Billboard Hot 100</a>, desde 1959 até 2023. A primeira parte irá tratar do processo de extração das informações utilizando uma ferramenta da web-scraping, e a segunda parte irá tratar da exibição dos dados, utilizando um <em>dashboard</em> interativo.</p><h3>O contexto da aplicação</h3><h4>A Billboard Hot 100</h4><p>A Billboard Hot 100, publicada pela revista <em>Billboard,</em> é a parada musical padrão da indústria musical nos Estados Unidos e indica, semanalmente, quais são as 100 músicas mais populares daquele país. Atualmente, este <em>ranking</em> é montado com base em vendas, tanto físicas quanto digitais, e execuções em rádio e serviços de <em>streaming, </em>mas a metodologia de classificação das músicas variou ao longo do tempo.</p><p>A<em> Billboard</em> já organizava paradas musicais desde o começo da década de 40, no entanto, a Hot 100 estreou somente em 4 de agosto de 1958. A primeira música número um da parada foi “Poor Little Fool” de <a href="https://pt.wikipedia.org/wiki/Ricky_Nelson">Ricky Nelson</a>, e até a data em que este artigo é escrito, — 15/06/24 — 1172 músicas diferentes chegaram ao topo da parada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/1*XFgv4sxf-uc8SQEDEFoDqA.png" /></figure><h4>A origem dos dados e sua forma de obtenção</h4><p>Os dados utilizados nesta aplicação foram obtidos dos verbetes da versão em língua inglesa da Wikipedia correspondentes a lista de músicas número um dos anos 1959 a 2023. Deixei de fora o ano de 1958, pois até o início de Hot 100, havia 3 paradas diferentes e a estrutura da tabela que contém os dados é muito diferente das tabelas dos demais anos.</p><p>A ferramenta utilizada para pegar os dados é o <a href="https://www.scrapy.org/">Scrapy</a>, que é uma biblioteca escrita em Python. Neste <a href="https://bit.ly/45pYI7J">artigo</a>, de minha autoria, faço uma breve apresentação desta biblioteca. Recomendo que você o leia, antes de prosseguir, caso não conheça a ferramenta. Também utilizo o PyCharm para criar um projeto Python, utilizando um ambiente virtual.</p><p>Aqui, irei abordar conceitos um pouco mais avançados, tais como <em>pipeline </em>e <em>item loaders</em> e mostrar algumas características adicionais não mostradas no artigo de apresentação do Scrapy.</p><h4>A estrutura das páginas a serem escrapeadas</h4><p>Conforme foi dito anteriormente, os dados serão coletados das páginas da Wikipedia em inglês, que contêm as listas de todas as músicas que chegaram ao 1º lugar da parada Billboard Hot 100. Os endereços das páginas possuem o formato https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_(year) onde (year) varia de 1959 a 2023. Em cada página há uma tabela com a lista de músicas, da qual será coletada, para cada linha o nome do artista, da música e a data em que a classificação foi feita. Esta tabela é a segunda da página , quando o aviso a seguir não está presente. Quando possui, como é o caso da página referente ao ano de 1970, é a terceira.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZBqg39gYpNWSVB6c2YBLWA.png" /><figcaption>Aviso presente em alguns das páginas pesquisadas.</figcaption></figure><p>Segue abaixo, como amostra, um <em>print </em>de parte da página que contém a lista de músicas do ano de 1981.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*x9nCQ0q18zAbImi50USK4g.png" /></figure><p>Podemos observar alguns padrões nesta página:</p><ul><li>Músicas e artistas em primeiro lugar por mais de uma semana são exibidos como uma única célula que se expande por tantas linhas quanto forem as semanas consecutivas em que as canções figuraram em primeiro lugar;</li><li>Para cada canção ou artista é colocado um link que direciona p/ os respectivos verbetes na Wikipedia, mas somente na primeira vez que eles aparecem na tabela. Por exemplo a canção “9 to 5” da cantora Dolly Parton ficou em primeiro lugar em duas semanas não consecutivas. Os links só estão presentes em sua primeira aparição, na semana de 27 de fevereiro. A banda Blondie, por sua vez atingiu o primeiro lugar, com a música “The Tide is High” em 31/01/81 e com “Rapture” em 28/03. Neste caso, o link para o verbete “Blondie” só aparece na primeira ocorrência desta, em 27/01.</li></ul><p>Há ainda dois aspectos importantes, mas que só são visíveis ao se visualizar o código-fonte das páginas:</p><ol><li>A mensagem em amarelo também é uma tabela HTML</li><li>O cabeçalho da tabela não está separado das demais linhas por um elemento &lt;thead&gt; , mas juntamente com elas dentro de tbody.</li></ol><p>De maneira geral a tabela que contém a relação de música possui a seguinte estrutura (os atributos das tags HTML foram omitidos):</p><pre>&lt;table&gt;<br>  &lt;tbody&gt;<br>    &lt;tr&gt;<br>      &lt;th&gt;No.&lt;/th&gt;<br>      &lt;th&gt;Issue Date&lt;/th&gt;<br>      &lt;th&gt;Song&lt;/th&gt;<br>      &lt;th&gt;Artist(s)&lt;/th&gt;<br>      &lt;th&gt;Ref&lt;/th&gt;&lt;!-- esta coluna é ignorada --&gt;<br>    &lt;/tr&gt;<br>    &lt;tr&gt;<br>     &lt;td&gt;[Seq number]&lt;/td&gt;<br>     &lt;td&gt;[data]&lt;/td&gt;<br>     &lt;td rowspan=&quot;[semanas consecutivas]&quot;&gt;&lt;a&gt;Música 1&lt;/a&gt;&lt;/td&gt;<br>     &lt;td rowspan=&quot;[semanas consecutivas]&quot;&gt;&lt;a&gt;Artista 1&lt;/a&gt;&lt;/td&gt;<br>     &lt;td&gt;[Ref]&lt;/td&gt;<br>    &lt;/tr&gt;<br>   &lt;tr&gt;&lt;!-- quando se trata da mesma música e artista --&gt;<br>     &lt;td&gt;[Semana consecutiva 2&lt;/td&gt;<br>     &lt;td&gt;[Ref]&lt;/td&gt;<br>   &lt;/tr&gt;<br>   . . .<br>  &lt;tr&gt;<br>     &lt;td&gt;[Semana consecutiva n&lt;/td&gt;<br>     &lt;td&gt;[Ref]&lt;/td&gt;<br>  &lt;/tr&gt;<br>&lt;!-- há ainda os raros casos em que um artista figura em primeiro lugar por<br>algumas semanas consecutivas, porém com músicas diferentes --&gt;<br>&lt;tr&gt;<br>     &lt;td&gt;[Seq number]&lt;/td&gt;<br>     &lt;td&gt; [data]&lt;/td&gt;<br>     &lt;td rowspan=&quot;[semanas consecutivas]&quot;&gt;&lt;a&gt;Artista 2&lt;/a&gt;&lt;/td&gt;<br>     &lt;td&gt;[Ref]&lt;/td&gt;<br>&lt;/tr&gt;<br>&lt;tr&gt;<br>     &lt;td&gt;[Seq number]&lt;/td&gt;<br>     &lt;td&gt; [data]&lt;/td&gt;<br>     &lt;td rowspan=&quot;[semanas consecutivas]&quot;&gt;&lt;a&gt;Música 2&lt;/a&gt;&lt;/td&gt;<br>     &lt;td rowspan=&quot;[semanas consecutivas]&quot;&gt;&lt;a&gt;Artista 2&lt;/a&gt;&lt;/td&gt;<br>     &lt;td&gt;[Ref]&lt;/td&gt;<br> &lt;/tr&gt;<br> . . .<br>&lt;tr&gt;<br>     &lt;td&gt;[Seq nnumber]&lt;/td&gt;<br>     &lt;td&gt;[data]&lt;/td&gt;<br>     &lt;td&gt;Música repetida&lt;/td&gt;<br>     &lt;td&gt;Artista repetido&lt;/td&gt;<br>     &lt;td&gt;[Ref]&lt;/td&gt;<br> &lt;/tr&gt;<br>&lt;tr&gt;<br>     &lt;td&gt;[Seq number]&lt;/td&gt;<br>     &lt;td rowspan=&quot;[semanas consecutivas]&quot;&gt;[data]&lt;/td&gt;<br>     &lt;td&gt;&lt;a&gt;Música 2&lt;/a&gt;&lt;/td&gt;<br>     &lt;td &gt;&lt;a&gt;Artista 2&lt;/a&gt;&lt;/td&gt;<br>     &lt;td&gt;[Ref]&lt;/td&gt;<br> &lt;/tr&gt;<br><br> . . .<br>&lt;/tbody&gt;<br>&lt;/table&gt;</pre><p>Nota-se que algumas linhas estão incompletas, possuindo somente a data e as referências para notas de rodapé. Os demais campos estão contidos na linhas completas imediatamente anteriores a elas</p><h3>Criando a aplicação</h3><p>Depois de criado um projeto no Pycharm e instalar a biblioteca Scrapy, deve-se executar o comando no terminal do PyCharm para criar um projeto scrapy com nome “billboard”</p><pre>scrapy startproject billboard</pre><p>Isto cria uma pasta dentro da pasta criada pelo PyCharm, com a seguinte estrutura:</p><pre>billboard/<br>    scrapy.cfg            # deploy configuration file<br><br>    billboard/             # project&#39;s Python module, you&#39;ll import your code from here<br>        __init__.py<br><br>        items.py          # project items definition file<br><br>        middlewares.py    # project middlewares file<br><br>        pipelines.py      # project pipelines file<br><br>        settings.py       # project settings file<br><br>        spiders/          # a directory where you&#39;ll later put your spiders<br>            __init__.py</pre><p>Agora devemos criar nossa aranha. Pelo terminal, devemos ir para o diretório billboard e digitar o comando a seguir:</p><pre>scrapy genspider hot100 &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;</pre><p>Isto cria um arquivo chamado hot100.pydentro da pasta spiders definindo uma classe chamada Hot100Spider com o conteúdo a seguir:</p><pre>import scrapy<br><br><br>class Hot100Spider(scrapy.Spider):<br>    name = &quot;hot100&quot;<br>    allowed_domains = [&quot;en.wikipedia.org&quot;]<br>    start_urls = [<br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;,<br><br>    def parse(self, response):<br>        pass</pre><p>Então, para acessar todos os verbetes de 1959 até 2023 foi necessário alterar o conteúdo da variável start_urls para:</p><pre>start_urls = [<br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;,<br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1960&quot;,<br>                    . . .<br>         &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_2023&quot;]<br>]</pre><p>Observação: não é obrigatório comando scrapy genspider, pois a classe Spider pode ser criada manualmente. Este comando facilita o trabalho gerando um esqueleto para a aranha, sendo que existem 4 templates disponíveis. Consulte a <a href="https://docs.scrapy.org/en/latest/topics/commands.html#std-command-genspider">documentação</a> do Scrapy para mais detalhes. Precisamos definir o método parse, mas antes vamos abordar alguns tópicos não abrangidos pelo meu artigo introdutório sobre o Scrapy</p><h3>O arquivo items.py</h3><p>A atividade de web-scraping tem como principal objetivo extrair dados estruturados a partir de fontes não estruturadas, como é o caso de páginas web. As classes <em>Spiders</em> podem retornar dados como <em>items</em>, que podem ser dicionários ou objetos Python, herdeiros da classe scrapy.Item. Em nosso caso, vamos retornar um objeto contendo um número sequencial, o nome do artista ou banda, o nome da música e a data em que ela chegou ao número um. Para isso definimos, dentro do arquivo Items.pyuma classe chamadaBillboarItem com o seguinte conteúdo:</p><pre>class BillboardItem(scrapy.Item):<br>    # define the fields for your item here like:<br>    # name = scrapy.Field()<br>    sequential_no=scrapy.Field()<br>    artist = scrapy.Field()<br>    song = scrapy.Field()<br>    year = scrapy.Field()<br>    date = scrapy.Field()</pre><p>Internamente, o Scrapy cria um dicionário a partir da subclasse de scrapy.ItemO método scrapy.Field() tão somente cria as chaves deste dicionário. Este dicionário é populado na execução do método parse()da classe Spider .</p><h3>Item Loaders</h3><p>Os <em>loaders </em>são um mecanismo que permite popular os itens escrapeados, a partir de expressões CSS, XPath, ou valores literais. Eles são invocados, geralmente, no método parse() da aranha. Aqui nesta aplicação, é invocado, para cada linha lida, um objeto ItemLoaderque é responsável por popular um objeto do tipo BillboardItemvisto acima. Cada propriedade do objeto BillboardItem é preenchida a partir do conteúdo de um elemento indicado pela expressão passada pelos métodos load_css ou load_xpath. O código abaixo mostra como é preenchido cada propriedade dos objetos BillboardItem:</p><pre>    def parse(self, response):<br>        //extraio o ano a partir do título da página<br>        year = int(response.css(&quot;h1::text&quot;).getall()[1][-4:])<br>        chart_history = response.xpath(&quot;//table[2]/tbody/tr&quot;)<br><br>        # ignore first line<br>        for week_chart in chart_history[1:]:<br>            loader = ItemLoader(item=BillboardItem(), selector=week_chart)<br>            // a linha de baixo também poderia ser:<br>            // loader.add_xpath(&quot;sequential_no&quot;,td[1]/text()&quot;)<br>            loader.add_css(&quot;sequential_no&quot;, &quot;td:nth_child(1)::text&quot;)<br>            loader.add_css(&quot;date&quot;, &quot;td:nth_child(2)&quot;, TakeFirst())<br>            loader.add_css(&quot;song&quot;, &quot;td:nth_child(3)&quot;, TakeFirst())<br>            loader.add_css(&quot;artist&quot;, &quot;td:nth_child(4)&quot;, TakeFirst())<br>            loader.add_value(&quot;year&quot;, year)<br>            yield loader.load_item()</pre><p>Na primeira linha dentro do laço for é criado um objeto ItemLoader, passando-se, obrigatoriamente, dois parâmetros para o construtor:</p><ul><li>item: que vai ser o objeto BillboardItem , que vai armazenar os dados extraídos da página;</li><li>selector: de onde extrair os dados, no caso, cada elemento retornado pela expressão response.xpath(“//table[2]/tbody/tr”)com exceção do primeiro, que corresponde ao cabeçalho da tabela.</li></ul><p>Nas linhas seguintes é invocado o método add_css, passando-se como parâmetro a propriedade do objeto BillboardItem a ser preenchida e o seletor do elemento cujo conteúdo será o valor desta propriedade. E opcionalmente é passado um terceiro parâmetro que é uma função <em>callback</em> utilizada para processar a saída gerada pelo método. Aqui a função TakeFirst() retorna apenas o primeiro elemento, caso o seletor especificado retorne mais de um. Há outras funções já predefinidas, com por exemplo, Join() que retorna todos os elementos encontrados seprados por vírgulas. Na penúltima linha, é informado um valor literal para a propriedade year. Então na última linha, o comando loader.load_item() que popula o item com as informações fornecidas pelos métodos load_xxx.</p><h3>A classe pipeline</h3><p>A cada vez que um item é gerado pela aranha, um <em>pipeline</em> é executado. Um <em>pipeline</em> é uma classe Python que deve implementar ao menos o método process_item, com dois parâmetros: o objetoitem retornado pelo método loader.loader_item()e o objeto spider:</p><pre>    def process_item(self, item, spider): </pre><p>Embora é possível, dentro de um <em>pipeline,</em> trabalhar diretamente com a classe item é uma boa prática usar a classe ItemAdapter fornecida pela biblioteca Scrapy.</p><p>Os pipelines permitem fazer atividades tais como, validação de dados, eliminação de itens duplicados, inserção em banco de dados entre outras. Nesta aplicação, o <em>pipeline</em> será utilizado para as seguinte tarefas:</p><ul><li>Armazenar temporariamente cada nova entrada de música, pois nas linhas seguintes em que ela figurar, a informação sobre música e artista não estará disponível, tendo de ser preenchida com os dados salvos anteriormente;</li><li>Como em algumas linhas, as músicas e artistas estão contidas em links, ou seja dentro de elementos &lt;a&gt; , e em outras não, então a solução é pegar o conteúdo dentro dos respectivos &lt;td&gt;e eliminar as tags HTML;</li><li>Como o tipo de conteúdo das células de cada linha varia, já que ela pode conter 2, 4 ou 5 células. então, a distinção entre cada tipo é feita por meio de expressões regulares.</li></ul><p>Então o arquivo <em>pipelines.py</em> ficará assim:</p><pre>class BillboardPipeline:<br>    last_song = &quot;&quot;<br>    last_artist = &quot;&quot;<br>    last_date = &quot;&quot;<br>    last_sequential = &quot;&quot;<br><br><br>    def _fill_last_song(self, adapter):<br>        # Quando se trata da primeira ocorrência de uma música,<br>        # é salva em uma variável<br>        if &#39;song&#39; in adapter.keys():<br>            self.last_song = adapter[&quot;song&quot;]<br>        # quando a informação da música, pego da última ocorrência<br>        else:<br>            adapter[&quot;song&quot;] = self.last_song<br><br>    def _fill_last_artist(self, adapter):<br>        # no item loader, o artista foi definido como o quarto elemento &lt;td&gt; da linha       #<br>        # mas quando ela só possui duas células ou quando a quarta célula for uma referência#<br>        # então ao pego o último artista salvo                                              #<br>        if &#39;artist&#39; in adapter.keys() and not Helper.is_note_or_empty(adapter[&quot;artist&quot;][0]):<br>            self.last_artist = adapter[&quot;artist&quot;]<br>        # pt: quando a linha está completa, salvo o artista para uso futuro<br>        else:<br>            adapter[&quot;artist&quot;] = self.last_artist<br><br>    def _treat_date_and_sequential(self, adapter):<br>        # elimina as tags HTML e aspas<br>        # os métodos load_xxx sempre retornam uma lista, mesmo quando apenas<br>        # um elemento é retornado, mas aí eu pego somente o primeiro item da lista<br>        adapter[&quot;date&quot;] = Helper.strip_html_and_quotes(adapter[&quot;date&quot;][0])<br>        if &#39;sequential_no&#39; in adapter.keys():<br>            adapter[&quot;sequential_no&quot;] = Helper.strip_html_and_quotes(<br>                adapter[&quot;sequential_no&quot;][0])<br>        if Helper.is_note_or_empty(adapter[&quot;date&quot;]):<br>            # adapter[&quot;date&quot;] é sempre a segunda célula<br>            # mas, se a linha está incompleta, a data está na primeira<br>            # daí é preciso ler a data de adapter<br>            adapter[&#39;date&#39;] = adapter[&quot;sequential_no&quot;]<br>            adapter[&quot;sequential_no&quot;] = self.last_sequential<br>        elif &#39;sequential_no&#39; in adapter.keys():<br>            # armazeno o valor atual do número sequencial<br>            self.last_sequential = adapter[&quot;sequential_no&quot;]<br>        else:<br>            # para retorná-lo, quando a informação estiver ausente.<br>            # Isto ocorre a partir de 2012<br>            adapter[&quot;sequential_no&quot;] = self.last_sequential<br>        adapter[&quot;sequential_no&quot;] = adapter[&quot;sequential_no&quot;]<br><br>    def _treat_artist_and_song(self, adapter):<br>        # elimina-se as tags HTML e aspas, e o caracter † presente quando<br>        # a música é a &#39;música do ano&#39; <br>        adapter[&quot;song&quot;] = Helper.strip_html_and_quotes(adapter[&quot;song&quot;][0])<br>        adapter[&quot;song&quot;] = Helper.strip_song_of_the_year_mark(adapter[&quot;song&quot;])<br>        adapter[&quot;artist&quot;] = Helper.strip_html_and_quotes(adapter[&quot;artist&quot;][0])<br><br>    # converte uma data em inglês para formato dd/mm/aaaa. O ano é lido de <br>    # adapter[&quot;year&quot;] <br>    # ex: February 18 para 18/02<br>    def _convert_date(self, adapter):<br>        adapter[&quot;date&quot;] = Helper.convert_english_date(adapter[&quot;date&quot;], adapter[&quot;year&quot;])<br><br>    # Para cada linha lida, é passado um objeto item para o &#39;process_item <br>    # que ao ser encapsulado pelo ItemAdapter possui os seguintes dados:<br>    # adapter[&quot;sequential_no&quot;]: primeira célula<br>    # adapter[&quot;date&quot;]: segunda célula<br>    # adapter[&quot;song&quot;]: terceira célula<br>    # adapter[&quot;artist&quot;]: quarta célula<br>    # adapter[&quot;year&quot;]: lido diretamente de uma variável no método &#39;parse&#39; do spider<br>    def process_item(self, item, spider):<br>        adapter = ItemAdapter(item)<br>        adapter[&quot;year&quot;]=adapter[&quot;year&quot;][0]<br>        self._fill_last_song(adapter)<br>        self._fill_last_artist(adapter)<br>        self._treat_artist_and_song(adapter)<br>        self._treat_date_and_sequential(adapter)<br>        self._convert_date(adapter)<br><br>        return item</pre><p>Observação: ao final deste artigo haverá um link para que você possa baixar o código fonte completo desta aplicação.</p><p>Para o pipeline acima ser executado é preciso registrá-lo no sistema. Para isto, é necessário editar o arquivo settings.py e adicionar a entrada a seguir:</p><pre># Configure item pipelines<br># See https://docs.scrapy.org/en/latest/topics/item-pipeline.html<br>ITEM_PIPELINES = {<br>    &quot;billboard.pipelines.BillboardPipeline&quot;: 300,<br>}</pre><p>Observações:</p><ol><li>Normalmente, este trecho de código já é gerado pelo comando scrapy startproject mas ele vem comentado, bastando apenas descomentar.</li><li>O número 300 associado à classe BillboardPipelineindica a ordem de execução do pipeline, caso haja mais de um. A ordem de execução é do pipeline com menor valor para os de maior valor.</li></ol><h3>Alguns tratamentos adicionais</h3><p>Esta aplicação, do jeito que está codificada até aqui, irá funcionar somente para algumas páginas, pois algumas delas apresentam algumas particularidades:</p><ul><li>Os verbetes referentes aos anos de <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1966">1966</a>, <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1967]">1967</a>, <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1968">1968</a>, <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1969">1969</a>, <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1970">1970</a>, <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1971">1971</a>, <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1974">1974</a>, <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1975">1975</a> e <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1997">1997</a> apresentam o alerta mostrado no começo do artigo, que está dentro de um &lt;table&gt;</li><li>A partir de 2011, a célula que contém a data é uma tag &lt;th&gt; e não &lt;td&gt;</li><li>Na variável start_urls são informadas todas as páginas que irão ser visitadas pela aranha. O problema é o Scrapy não garante que elas serão visitadas na mesma ordem em que são declaradas nesta variável. Além disso, são gerados vários linha de execução simultâneas, e assim, a classe pipeline não processa as linhas de forma sequencial fazendo com que as informações sejam armazenadas incorretamente., como se pode ver pelo trecho de arquivo obtido ao se rodar o rodar o Scrapy com a opção de gerar uma saída em formato JSON:</li></ul><pre>{&quot;sequential_no&quot;: &quot;710&quot;, &quot;date&quot;: &quot;06/01/1990&quot;, &quot;song&quot;: &quot;Another Day in Paradise&quot;, &quot;artist&quot;: &quot;Phil Collins&quot;, &quot;year&quot;: 1990},<br>{&quot;sequential_no&quot;: &quot;710&quot;, &quot;date&quot;: &quot;01/12/1962&quot;, &quot;year&quot;: 1962, &quot;song&quot;: &quot;Another Day in Paradise&quot;, &quot;artist&quot;: &quot;Phil Collins&quot;},<br>{&quot;sequential_no&quot;: &quot;710&quot;, &quot;date&quot;: &quot;08/12/1962&quot;, &quot;year&quot;: 1962, &quot;song&quot;: &quot;Another Day in Paradise&quot;, &quot;artist&quot;: &quot;Phil Collins&quot;},</pre><p>O que aconteceu acima, é que o pipeline primeiro leu a linha referente a data de 06 de janeiro, na página de <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1990">1990</a>, armazenando a informação do artista (Phill Collins) e da música (“Another Day in Paradise”); entretanto, o Scrapy estava visitando simultaneamente esta página e a de <a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1962">1962</a>, e os próximos itens a serem lidos pelo pipeline foram as linhas datadas de 01/12 e 08/12/1962, coincidentemente linhas incompletas, pois se referiam a uma música que estava em primeiro lugar desde 17/11 daquele ano — “Big Girls Don’t Cry” de The Four Seasons — , então o pipeline preencheu esta duas últimas linhas com os dados que estavam armazenados quando leu a primeiram, ou seja “Another Day in Paradise” em vez de “Big Girls Don’t Cry”. Assim, é necessário fazer um mecanismo para que o Scrapy visite as páginas na sequencia. Isto é feito definindo o conteúdo da variável start_urls como somente a do primeiro ano (<a href="https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959">1959</a>), no método parse instrui-se o Scrapy a visitar a página do ano seguinte e invocar o método parse novamente. Isto é feito adicionando-se o código a seguir após a última linha do método parse():</p><pre>            if(year &lt;2023):<br>                url_next_year = f&quot;/wiki/List_of_Billboard_Hot_100_number_ones_of_{year+1}&quot;<br>                url_next_year = response.urljoin(url_next_year)<br>                yield scrapy.Request(url_next_year, callback=self.parse)</pre><p>No código acima, verifica-se se já atingiu o ano de 2023, o último de nossa listagem. Se não, eu pego a URL da página referente ao próximo ano, junto as duas partes (servidor + caminho), daí faço uma nova requisição para esta página, fazendo com que o método parse seja executado novamente.</p><p>Com todas essas particularidades em vista, nossa classe aranha ficará assim:</p><pre>class Hot100Spider(scrapy.Spider):<br>    name = &quot;hot100&quot;<br>    allowed_domains = [&quot;en.wikipedia.org&quot;]<br>    start_urls = [<br>        &quot;https://en.wikipedia.org/wiki/List_of_Billboard_Hot_100_number_ones_of_1959&quot;,<br>    ]<br><br>    def parse(self, response):<br>        sleep(3)<br>        year = int(response.css(&quot;h1::text&quot;).getall()[1][-4:])<br>        # Os artigos referentes aos anos abaixo, a tabela com as relação de músicas em 1º lugar na Billboard<br>        # é a terceira e não a segunda da página<br>        years_with_warning = [1966, 1967, 1968, 1969, 1970, 1971, 1974, 1975, 1997]<br>        chart_history = response.xpath(&quot;//table[3]/tbody/tr&quot;) if year in years_with_warning \<br>            else response.xpath(&quot;//table[2]/tbody/tr&quot;)<br><br>        # ignore first line<br>        for week_chart in chart_history[1:]:<br>            loader = ItemLoader(item=BillboardItem(), selector=week_chart)<br>            loader.add_css(&quot;sequential_no&quot;, &quot;td:nth_child(1)::text&quot;)<br>            if year &lt;= 2011:<br>                loader.add_css(&quot;date&quot;, &quot;td:nth_child(2)&quot;, TakeFirst())<br>            else:<br>                loader.add_css(&quot;date&quot;, &quot;th::text&quot;, TakeFirst())<br>            loader.add_css(&quot;song&quot;, &quot;td:nth_child(3)&quot;, TakeFirst())<br>            loader.add_css(&quot;artist&quot;, &quot;td:nth_child(4)&quot;, TakeFirst())<br>            loader.add_value(&quot;year&quot;, year)<br>            yield loader.load_item()<br><br>            if(year &lt;2023):<br>                url_next_year = f&quot;/wiki/List_of_Billboard_Hot_100_number_ones_of_{year+1}&quot;<br>                url_next_year = response.urljoin(url_next_year)<br>                yield scrapy.Request(url_next_year, callback=self.parse)</pre><p>Então podemos executar nossa aranha, para tanto, devemos navegar até o diretório onde se encontra o arquivo scrapy.cfg e executar o comando:</p><pre>scrapy crawl hot100 -o scrapy.json</pre><p>Isto gera um arquivo JSON com todas as entradas lidas em sequência crescente de data. Segue abaixo um trecho deste arquivo:</p><pre>{&quot;sequential_no&quot;: &quot;520&quot;, &quot;date&quot;: &quot;18/09/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Hard to Say I&#39;m Sorry&quot;, &quot;artist&quot;: &quot;Chicago&quot;},<br>{&quot;sequential_no&quot;: &quot;re&quot;, &quot;date&quot;: &quot;25/09/1982&quot;, &quot;song&quot;: &quot;Abracadabra&quot;, &quot;artist&quot;: &quot;Steve Miller Band&quot;, &quot;year&quot;: 1982},<br>{&quot;sequential_no&quot;: &quot;521&quot;, &quot;date&quot;: &quot;02/10/1982&quot;, &quot;song&quot;: &quot;Jack &amp; Diane&quot;, &quot;artist&quot;: &quot;John Cougar&quot;, &quot;year&quot;: 1982},<br>{&quot;sequential_no&quot;: &quot;521&quot;, &quot;date&quot;: &quot;09/10/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Jack &amp; Diane&quot;, &quot;artist&quot;: &quot;John Cougar&quot;},<br>{&quot;sequential_no&quot;: &quot;521&quot;, &quot;date&quot;: &quot;16/10/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Jack &amp; Diane&quot;, &quot;artist&quot;: &quot;John Cougar&quot;},<br>{&quot;sequential_no&quot;: &quot;521&quot;, &quot;date&quot;: &quot;23/10/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Jack &amp; Diane&quot;, &quot;artist&quot;: &quot;John Cougar&quot;},<br>{&quot;sequential_no&quot;: &quot;522&quot;, &quot;date&quot;: &quot;30/10/1982&quot;, &quot;song&quot;: &quot;Who Can It Be Now?&quot;, &quot;artist&quot;: &quot;Men at Work&quot;, &quot;year&quot;: 1982},<br>{&quot;sequential_no&quot;: &quot;523&quot;, &quot;date&quot;: &quot;06/11/1982&quot;, &quot;song&quot;: &quot;Up Where We Belong&quot;, &quot;artist&quot;: &quot;Joe Cocker and Jennifer Warnes&quot;, &quot;year&quot;: 1982},<br>{&quot;sequential_no&quot;: &quot;523&quot;, &quot;date&quot;: &quot;13/11/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Up Where We Belong&quot;, &quot;artist&quot;: &quot;Joe Cocker and Jennifer Warnes&quot;},<br>{&quot;sequential_no&quot;: &quot;523&quot;, &quot;date&quot;: &quot;20/11/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Up Where We Belong&quot;, &quot;artist&quot;: &quot;Joe Cocker and Jennifer Warnes&quot;},<br>{&quot;sequential_no&quot;: &quot;524&quot;, &quot;date&quot;: &quot;27/11/1982&quot;, &quot;song&quot;: &quot;Truly&quot;, &quot;artist&quot;: &quot;Lionel Richie&quot;, &quot;year&quot;: 1982},<br>{&quot;sequential_no&quot;: &quot;524&quot;, &quot;date&quot;: &quot;04/12/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Truly&quot;, &quot;artist&quot;: &quot;Lionel Richie&quot;},<br>{&quot;sequential_no&quot;: &quot;525&quot;, &quot;date&quot;: &quot;11/12/1982&quot;, &quot;song&quot;: &quot;Mickey&quot;, &quot;artist&quot;: &quot;Toni Basil&quot;, &quot;year&quot;: 1982},<br>{&quot;sequential_no&quot;: &quot;526&quot;, &quot;date&quot;: &quot;18/12/1982&quot;, &quot;song&quot;: &quot;Maneater&quot;, &quot;artist&quot;: &quot;Daryl Hall and John Oates&quot;, &quot;year&quot;: 1982},<br>{&quot;sequential_no&quot;: &quot;526&quot;, &quot;date&quot;: &quot;25/12/1982&quot;, &quot;year&quot;: 1982, &quot;song&quot;: &quot;Maneater&quot;, &quot;artist&quot;: &quot;Daryl Hall and John Oates&quot;},<br>{&quot;sequential_no&quot;: &quot;526&quot;, &quot;date&quot;: &quot;01/01/1983&quot;, &quot;song&quot;: &quot;Maneater&quot;, &quot;artist&quot;: &quot;Daryl Hall and John Oates&quot;, &quot;year&quot;: 1983},<br>{&quot;sequential_no&quot;: &quot;526&quot;, &quot;date&quot;: &quot;08/01/1983&quot;, &quot;year&quot;: 1983, &quot;song&quot;: &quot;Maneater&quot;, &quot;artist&quot;: &quot;Daryl Hall and John Oates&quot;},<br>{&quot;sequential_no&quot;: &quot;527&quot;, &quot;date&quot;: &quot;15/01/1983&quot;, &quot;song&quot;: &quot;Down Under&quot;, &quot;artist&quot;: &quot;Men at Work&quot;, &quot;year&quot;: 1983},<br>{&quot;sequential_no&quot;: &quot;527&quot;, &quot;date&quot;: &quot;22/01/1983&quot;, &quot;year&quot;: 1983, &quot;song&quot;: &quot;Down Under&quot;, &quot;artist&quot;: &quot;Men at Work&quot;},<br>{&quot;sequential_no&quot;: &quot;527&quot;, &quot;date&quot;: &quot;29/01/1983&quot;, &quot;year&quot;: 1983, &quot;song&quot;: &quot;Down Under&quot;, &quot;artist&quot;: &quot;Men at Work&quot;},<br>{&quot;sequential_no&quot;: &quot;528&quot;, &quot;date&quot;: &quot;05/02/1983&quot;, &quot;song&quot;: &quot;Africa&quot;, &quot;artist&quot;: &quot;Toto&quot;, &quot;year&quot;: 1983},<br>{&quot;sequential_no&quot;: &quot;re&quot;, &quot;date&quot;: &quot;12/02/1983&quot;, &quot;song&quot;: &quot;Down Under&quot;, &quot;artist&quot;: &quot;Men at Work&quot;, &quot;year&quot;: 1983},<br>{&quot;sequential_no&quot;: &quot;529&quot;, &quot;date&quot;: &quot;19/02/1983&quot;, &quot;song&quot;: &quot;Baby, Come to Me&quot;, &quot;artist&quot;: &quot;Patti Austin and James Ingram&quot;, &quot;year&quot;: 1983},</pre><h3>Conclusão</h3><p>Podemos concluir afirmando que o processo de extrair dados de uma página pode ser bastante desafiador, visto que, nem sempre as páginas seguem um único padrão, tanto que foi necessário fazer um tratamento especial para algumas delas. Diferentemente do site “<a href="https://quotes.toscrape.com/">Quotes to Scrape</a>” mostrado em meu artigo introdutório sobre web scraping com Scrapy, a maioria dos sites não facilitam muito nosso trabalho de coletar seus dados.</p><p>Clique <a href="https://github.com/marciusdm/webscraping/raw/main/scrapy_billboard/billboard.zip">aqui</a> para acessar e baixar o código fonte utilizado neste artigo.</p><p>Clique <a href="https://bit.ly/4fcywlx">aqui</a> para ler a parte 2 deste artigo.</p><p>Clique <a href="https://medium.com/@marciusdellano">aqui</a> para ler meus outros artigos escritos na plataforma Medium</p><p>Meu <a href="https://github.com/marciusdm/portfolio">portfolio</a> profissional</p><p>Meu <a href="https://www.linkedin.com/in/marciusdm">perfil</a> no Linkedin</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de7eae815af8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction to web scraping using the Scrapy tool]]></title>
            <link>https://medium.com/@marciusdellano/introduction-to-web-scraping-using-the-scrapy-tool-e0138dd95080?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0138dd95080</guid>
            <category><![CDATA[web-scraping-tools]]></category>
            <category><![CDATA[scrapy]]></category>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Tue, 11 Jun 2024 01:52:09 GMT</pubDate>
            <atom:updated>2024-06-11T01:52:09.097Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/383/1*pAoPCoZjQHo6uUmDYJ1Bgg.png" /></figure><h3>Before you start</h3><p>This article assumes you have basic knowledge of HTML, CSS, and XPath. If you don’t have them, the links below may help you:</p><ul><li><a href="https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web">Getting started with the web</a> , a short course created by Mozilla, developer of Firefox, which teaches HTML, CSS and Javascript;</li><li><a href="https://www.w3schools.com/html/">HTML</a> , <a href="https://www.w3schools.com/css">CSS</a> and <a href="https://www.w3schools.com/xml/xpath_intro.asp">XPath</a> tutorials from the W3Schools website</li><li><a href="https://www.blog.datahut.co/post/xpath-for-web-scraping-step-by-step-tutorial">Mastering XPath for Web Scraping: A Step-by-Step Tutorial</a></li></ul><h3>What is web scraping</h3><p>In many situations, it is necessary to collect information available on websites. The simplest way to do this is through APIs that some platforms, such as social networks (Facebook, Instgram, X, etc., or corporate tools such as JIRA, Monday.com, Basecamp, among others, make available to their users. Typically, these APIs work with JSON or XML files, making it easy to extract the desired information from these files.</p><p>Unfortunately, there are few websites that offer such APIs and, most of the time, it is necessary to carry out web scraping work, which is nothing more than the act of automatically analyzing the HTML code of internet pages and extracting the desired data.</p><p>There are several web scraping tools available for the most varied development environments, such as Java, Python, C#, Rust, among others. The focus in this article will be on the Scrapy tool, an open source library developed in Python.</p><h3>What is Scrapy?</h3><p>Scrapy is a web-scraping tool that aims to extract structured data that can be used for a huge range of applications, such as data mining, information processing and archiving, among others.</p><p>Scrapy’s characteristics are that it is a simple, fast, robust, extensible tool, that is, it is possible to plug in new features without the need to know the tool in depth and — due to the fact that it is developed in Python — it is portable, that is, it can run on a Mac , Windows or Linux.</p><p>Before presenting Scrapy, let’s explain some important concepts of this library</p><h3>Important Scrapy Concepts</h3><ul><li><strong>Project:</strong> this is a structure of files and folders containing configuration files, files that allow you to insert additional functionality, as well as one or more <em>Spiders</em> classes , which read and collect information from the pages.</li><li><strong>Spiders :</strong> these are classes that present instructions to navigate one or more pages and collect the desired data</li><li><strong>Items:</strong> Collected information can be stored in an object or a collection of objects. For example, if we are browsing a car classifieds website we could store information about each vehicle listed, such as price, model, year, in an object and later return the objects created in a JSON or XML file, for example;</li><li><strong>Pipeline</strong> : A <em>pipeline</em> is a special class that allows you to perform additional processing on each item returned during the scraping step. It’s possible to add a validation mechanism or store the collected items on a database.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*xdJFggFjgQfIVfS6.png" /><figcaption>The process of scraping a page</figcaption></figure><h3>Scrapy Limitations</h3><p>Scrapy is not able to interact with elements on a page. It is not possible, for example, to log in to a website or click on a button. If you need interaction, use another tool, such as <a href="https://www.selenium.dev/">Selenium</a> .</p><h3>Installing Scrapy</h3><p>You can install Scrapy via condaor pip. Run the command below to install using conda:</p><pre>conda install -c conda-forge scrapy- c conda - forge scrapy</pre><p>Installing Scrapy through pip:</p><pre>pip install Scrapy</pre><p>It is recommended to install Scrapy in a virtual environment instead of using Python installed on the system, in order to avoid conflicts with already installed packages. It is advisable to use the PyCharm IDE, which allows you to create virtual environments very easily.</p><h3>Creating a Scrapy project</h3><p>Let’s now get our hands dirty and create a Scrapy project. To do this, let’s create a new project in Pycharm, giving it any name, for examplescrapyquotes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*qv69_9e_-wcp0hKY.png" /></figure><h4>Creating a project in PyCharm</h4><p>Now open a terminal in PyCharm and type the command pip install scrapyto download the library. To confirm that the installation was successful, type the command scrapywithout arguments and press &lt;Enter&gt; . A help text on using this command should be shown, as shown in the figure below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/0*pt6_KZjHrSeKBqeD.png" /></figure><h4>Testing installation of the Scrapy library</h4><p>Now we can proceed with creating the Scrapy project. Let’s now type in terminal scrapy startproject quoteswhere “quotes” is the name of our project:</p><pre>(.venv) PS C:\Users\Marcius\PyCharmProject\scrapyquotes&gt;scrapy startproject quotes</pre><p>This command creates a directory called ‘quotes’ whose structure is shown below:</p><pre>quotes/ <br>    scrapy.cfg # deploy configuration file# deploy configuration file<br>    quotes/              # project&#39;s Python module, you&#39;ll import your code from here<br>         __init__.py <br>        items.py           # project items definition file<br>         middlewares.py     # project middlewares file<br>         pipelines.py       # project pipelines file<br>         settings.py        # project settings file<br>         spiders/           # a directory where you&#39;ll later put your spiders<br>             __init__.py</pre><h3>Creating our first spider</h3><p>Inside the folder, quotes\quotes\spiderscreate a file called quotes_spiderwith the following content:</p><pre># importing scrapy library<br>import scrapy<br><br>class QuotesSpider(scrapy.Spider):<br>    name = &quot;quotes&quot;<br>    start_urls = [&quot;https://quotes.toscrape.com&quot;]<br><br>  def parse(self, response, **kwargs):</pre><p>First, we import the library scrapy, then we define a class called QuotesSpider, as a subclass of scrapy.Spider. Then we define a name for the spider, which will be used in the command that performs the scraping (seen below). We also define a variable start_urlsas an array containing the URLs that the spider will visit. Finally, we define a method parse, which accepts two parameters:</p><ul><li>response: class object scrapy.http.response.html.HtmlResponsethat returns the page content, along with some useful methods for manipulating it;</li><li>**kwargs: additional parameters whose explanation is beyond the scope of this article, as it is introductory. We will not use this parameter.</li></ul><p>In the method parsewe write the code that will scroll through the page and collect the information we need. Normally the information is transformed into an <em>array</em>of dictionaries, then the Python yieldkeyword is used to return each dictionary. The pseudocode below illustrates what has just been said:</p><pre>def  parse ( self, response, **kwargs ): <br>   for &lt;container&gt; in &lt;selector&gt;: <br>      yield : <br>        &quot;campo 1&quot; : &lt;container.element1&gt; <br>        &quot;campo 2&quot; : &lt;container.elemtnto2&gt; <br>        ....</pre><p>Before continuing, it is important to know how we access an element on an HTML page through Scrapy, this is what will be seen below.</p><h3>How to access page elements in Scrapy</h3><p>We can find elements on a web page in two different ways: via CSS selectors or by XPath, to do this we invoke the response.css()and methods response.xpath()respectively. Examples:</p><pre>#Find the first paragraph of a &#39;div&#39; section with class=&quot;container&quot; attribute:<br>response.css(&quot;div.container &gt; p::firstchild&quot;)<br>#or<br>response.xpath(&quot;//div[@class=&#39;container]/p[1]&quot;)</pre><h3>Testing our expressions</h3><p>Scrapy provides an interactive <em>shell</em> so we can test CSS and XPath expressions without having to run <em>spiders.</em> To do this, we just need to execute the command in the terminal scrapy shell &quot;&lt;page_url&gt;&quot;. For this article we will access the <em>Quotes to Scrape</em> page ( <a href="https://quotes.toscrape.com/">https://quotes.toscrape.com</a> ). So let&#39;s type in the terminal:</p><pre>scrapy shell &quot;https://quotes.toscrape.com&quot;</pre><p>The Scrapy shell provides some objects, including the responsethat stores the content of the visited page and offers the methods response.css()seen response.xpath()above to access the page elements.</p><p><strong>Suggestion</strong> : install the <a href="https://ipython.org/">ipython</a> package. When this is installed, scrapy shell starts using it, instead of the standard Python console. ipython offers additional features such as auto-completion, colored output, as well as maintaining the history of commands entered, even when you exit the console and log back in.</p><p>We will now use the scrapy shell to find the information we want, but first we will be shown a <em>print</em> of the page with part of the source code that shows the code of each element that we will extract later:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*9yy1dxIJuhS45qDT.png" /></figure><p>We can see above that each of the blocks with citations is encapsulated in a tag &lt;div class=&quot;quote&quot;&gt;, the phrase is contained in a tag &lt;span&gt;with attribute <em>class</em> =”text”, the author within a tag &lt;small&gt;whose CSS class is <em>authors</em> and the tags that dentify the type of phrase comes inside a tag &lt;a&gt;whose class is “tag”. So let&#39;s access these elements in the interactive <em>shell</em> we just opened</p><pre>In [1]: quotes = response.css(&quot;div.quote&quot;)</pre><p>Or using response.xpath():</p><pre>In[1]: quotes=response.xpath(&quot;//div[@class=&#39;quote&#39;]&quot;)1 ]: quotes=response.xpath( &quot;//div[@class=&#39;quote&#39;]&quot; )</pre><p>Let’s check the type of the variable quotes:</p><pre>In [2]: type(quotes)<br>Out[2]: scrapy.selector.unified.SelectorList<br><br>In[3}: len(quotes)<br>Out[3]: 10<br></pre><p>The class SelectorListis a list containing objects of the class Selector, which corresponds to each element that matches the expression given in response.css()or response.xpath(). In our case, we see that the list contains 10 elements. Let&#39;s now take the first element of this list:</p><pre>In[4}: quotes[0]<br>Out[4]:&lt;Selector query=&quot;descendant-or-self::div[@class and contains(concat(&#39; &#39;, normalize-space(@class), &#39; &#39;), &#39; quote &#39;)]&quot; data=&#39;&lt;div class=&quot;quote&quot; itemsco<br>pe itemtype...&#39;&gt;<br><br>In[5}: type(quotes[0])<br>Out[5]: scrapy.selector.unified.Selector</pre><p>To access the content of an object Selector, we use get()method as below:</p><pre>In [6]: quotes[0].get()<br>Out[6]: &#39;&lt;div class=&quot;quote&quot; itemscope itemtype=&quot;http://schema.org/CreativeWork&quot;&gt;\n        &lt;span class=&quot;text&quot; itemprop=&quot;text&quot;&gt;“The world as we have created it<br> is a process of our thinking. It cannot be changed without changing our thinking.”&lt;/span&gt;\n        &lt;span&gt;by &lt;small class=&quot;author&quot; itemprop=&quot;author&quot;&gt;Albert Ei<br>nstein&lt;/small&gt;\n        &lt;a href=&quot;/author/Albert-Einstein&quot;&gt;(about)&lt;/a&gt;\n        &lt;/span&gt;\n        &lt;div class=&quot;tags&quot;&gt;\n            Tags:\n            &lt;meta class<br>=&quot;keywords&quot; itemprop=&quot;keywords&quot; content=&quot;change,deep-thoughts,thinking,world&quot;&gt; \n            \n            &lt;a class=&quot;tag&quot; href=&quot;/tag/change/page/1/&quot;&gt;change&lt;/a<br>&gt;\n            \n            &lt;a class=&quot;tag&quot; href=&quot;/tag/deep-thoughts/page/1/&quot;&gt;deep-thoughts&lt;/a&gt;\n            \n            &lt;a class=&quot;tag&quot; href=&quot;/tag/thinking/<br>page/1/&quot;&gt;thinking&lt;/a&gt;\n</pre><p>Several HTML elements, such as divand ul, contains nested elements, so Selector class also provides the xpath()and css() methods. Thus, in order to access the &lt;span&gt;element which contains the code we can call the command below:</p><pre>In [7]: quotes[0].css(&quot;span:first-child&quot;).get()<br>Out[7]: &#39;&lt;span class=&quot;text&quot; itemprop=&quot;text&quot;&gt;“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking<br>.”&lt;/span&gt;&#39;</pre><p>The above command returns the entire HTML code of the selected element, if we just want the text, then we must add the suffix ::textto the selector:</p><pre>In [ 8 ]: quotes[ 0 ].css( &quot;span:first-child::text&quot; ). get () <br>Out[ 8 ]: &#39;“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”&#39;</pre><p><strong>Note</strong> : the suffix ::text(in fact, expressions starting with ::are called &#39;pseudo-elements&#39;) is not a CSS standard defined by the <a href="https://www.w3.org/TR/selectors-3/">W3C</a> , but rather a Scrapy extension so that we can access the text of an element using the css(). Unlike XPath which allows, by default, access to text, through the operator text():</p><pre>In [9]: quotes[0].xpath(&quot;span[1]/text()&quot;).get() <br>Out[9]: &#39;“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”&#39;</pre><p>Let’s now look at the author of the sentence:</p><pre>In [10]: quotes[0].css(&quot;span:nth_child(2) small::text&quot;).get()<br>Out[10]: &#39;Albert Einstein&#39;</pre><p>Or:</p><pre>In [11]: quotes[0].xpath(&quot;span[2]/small/text()&quot;).get()<br>Out[11]: &#39;Albert Einstein&#39;</pre><p>For catching the tags, we will use the method getall(), which returns all elements that satisfy the selected selector:</p><pre>In [12]: quotes[0].css(&quot;div.tags a::text&quot;).getall()<br>Out[12]: [&#39;change&#39;, &#39;deep-thoughts&#39;, &#39;thinking&#39;, &#39;world&#39;]</pre><p>via xpath():</p><pre>In [13]: quotes[0].xpath(&quot;div[@class=&#39;tags&#39;]/a/text()&quot;).getall()<br>Out[13]: [&#39;change&#39;, &#39;deep-thoughts&#39;, &#39;thinking&#39;, &#39;world&#39;]</pre><p>With this, we already have all the elements we need to configure our spider.</p><h3>Creating and running the spider</h3><p>Let’s complete the class QuotesSpiderby defining the method parse:</p><pre># import libraries <br>import scrapy<br><br>class QuotesSpider(scrapy.Spider):<br>    name = &quot;quotes&quot;<br>    start_urls = [&quot;https://quotes.toscrape.com&quot;]<br><br>    def parse(self, response, **kwargs):<br>        for quote in response.css(&quot;div.quote&quot;):<br>            yield {<br>                &#39;text:&#39;: quote.css(&quot;span:first-child::text&quot;).get(),<br>                &#39;author&#39;: quote.css(&quot;span:nth_child(2) small::text&quot;).get(),<br>                &#39;tags&#39;: quote.css(&quot;div.tags a::text&quot;).getall()<br>            }</pre><pre>c</pre><p>In the code above, for each block &lt;div class=&quot;quote&quot;&gt;found, a dictionary is returned with the keys &#39;text&#39;, &#39;author&#39;and &#39;tags&#39;and whose values ​​correspond to the elements that contain the respective data.</p><p>Now let’s run our spider, so we must execute in terminal the command scrapy crawl quotes(&#39;quotes&#39; is the value of namethe class property QuotesSpider, but before that, we must go to the project&#39;s root directory, which contains the file scrapy.cfg:</p><pre>(.venv) PS C:\Users\Marcius\PyCharmProject\scrapyquotes&gt;cd quotes<br>(.venv) PS C:\Users\Marcius\PyCharmProject\scrapyquotes\quotes&gt;scrapy crawl quotes</pre><p>When executing this command, several outputs similar to the following will be generated:</p><pre>2024-06-09 12:10:49 [scrapy.core.scraper] DEBUG: Scraped from &lt;200 https://quotes.toscrape.com&gt;<br>{&#39;text:&#39;: &#39;&quot;Try not to become a man of success. Rather become a man of value.&quot;&#39;, &#39;author&#39;: &#39;Albert Einstein&#39;, &#39;tags&#39;: [&#39;adulthood&#39;, &#39;success&#39;, &#39;value&#39;]}      <br>2024-06-09 12:10:49 [scrapy.core.scraper] DEBUG: Scraped from &lt;200 https://quotes.toscrape.com&gt;<br>{&#39;text:&#39;: &#39;&quot;It is better to be hated for what you are than to be loved for what you are not.&quot;&#39;, &#39;author&#39;: &#39;André Gide&#39;, &#39;tags&#39;: [&#39;life&#39;, &#39;love&#39;]}<br>2024-06-09 12:10:49 [scrapy.core.scraper] DEBUG: Scraped from &lt;200 https://quotes.toscrape.com&gt;<br>{&#39;text:&#39;: &quot;&quot;I have not failed. I&#39;ve just found 10,000 ways that won&#39;t work.&quot;&quot;, &#39;author&#39;: &#39;Thomas A. Edison&#39;, &#39;tags&#39;: [&#39;edison&#39;, &#39;failure&#39;, &#39;inspirational&#39;, &#39;p<br>araphrased&#39;]}</pre><p>We can send the command output in a JSON file, to do this, we will add the option -o &lt;file_name&gt;:</p><pre>scrapy crawl quotes -o quotes.jsonquotes -o quotes .json</pre><p>This creates a JSON file called “quotes.json” with the following content:</p><pre>[<br>{&quot;text:&quot;: &quot;&quot;The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.&quot;&quot;, &quot;author&quot;: &quot;Albert Einstein&quot;, &quot;tags&quot;: [&quot;change&quot;, &quot;deep-thoughts&quot;, &quot;thinking&quot;, &quot;world&quot;]},<br>{&quot;text:&quot;: &quot;&quot;It is our choices, Harry, that show what we truly are, far more than our abilities.&quot;&quot;, &quot;author&quot;: &quot;J.K. Rowling&quot;, &quot;tags&quot;: [&quot;abilities&quot;, &quot;choices&quot;]},<br>{&quot;text:&quot;: &quot;&quot;There are only two ways to live your life. One is as though nothing is a miracle. The other is as though everything is a miracle.&quot;&quot;, &quot;author&quot;: &quot;Albert Einstein&quot;, &quot;tags&quot;: [&quot;inspirational&quot;, &quot;life&quot;, &quot;live&quot;, &quot;miracle&quot;, &quot;miracles&quot;]},<br>{&quot;text:&quot;: &quot;&quot;The person, be it gentleman or lady, who has not pleasure in a good novel, must be intolerably stupid.&quot;&quot;, &quot;author&quot;: &quot;Jane Austen&quot;, &quot;tags&quot;: [&quot;aliteracy&quot;, &quot;books&quot;, &quot;classic&quot;, &quot;humor&quot;]},<br>{&quot;text:&quot;: &quot;&quot;Imperfection is beauty, madness is genius and it&#39;s better to be absolutely ridiculous than absolutely boring.&quot;&quot;, &quot;author&quot;: &quot;Marilyn Monroe&quot;, &quot;tags&quot;: [&quot;be-yourself&quot;, &quot;inspirational&quot;]},<br>{&quot;text:&quot;: &quot;&quot;Try not to become a man of success. Rather become a man of value.&quot;&quot;, &quot;author&quot;: &quot;Albert Einstein&quot;, &quot;tags&quot;: [&quot;adulthood&quot;, &quot;success&quot;, &quot;value&quot;]},<br>{&quot;text:&quot;: &quot;&quot;It is better to be hated for what you are than to be loved for what you are not.&quot;&quot;, &quot;author&quot;: &quot;André Gide&quot;, &quot;tags&quot;: [&quot;life&quot;, &quot;love&quot;]},<br>{&quot;text:&quot;: &quot;&quot;I have not failed. I&#39;ve just found 10,000 ways that won&#39;t work.&quot;&quot;, &quot;author&quot;: &quot;Thomas A. Edison&quot;, &quot;tags&quot;: [&quot;edison&quot;, &quot;failure&quot;, &quot;inspirational&quot;, &quot;paraphrased&quot;]},<br>{&quot;text:&quot;: &quot;&quot;A woman is like a tea bag; you never know how strong it is until it&#39;s in hot water.&quot;&quot;, &quot;author&quot;: &quot;Eleanor Roosevelt&quot;, &quot;tags&quot;: [&quot;misattributed-eleanor-roosevelt&quot;]},<br>{&quot;text:&quot;: &quot;&quot;A day without sunshine is like, you know, night.&quot;&quot;, &quot;author&quot;: &quot;Steve Martin&quot;, &quot;tags&quot;: [&quot;humor&quot;, &quot;obvious&quot;, &quot;simile&quot;]}<br>]</pre><p>It is possible to save the captured data to a file, or even to a database. It is also possible to follow links on a page, but for an introductory article, what has been shown so far is enough to introduce Scrapy and show its possibilities and limitations.</p><p>Click <a href="https://github.com/marciusdm/artigos/tree/main/intro_web_scraping_scrapy">here</a> to access and download the source code used in this article.</p><p>Click <a href="https://medium.com/@marciusdellano">here</a> to read my other articles written on the Medium platform</p><p>Click <a href="https://github.com/marciusdm/portfolio/blob/main/Readme_en.md">here</a> to view my professional portfolio</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0138dd95080" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introdução ao web scraping utilizando ferramenta Scrapy]]></title>
            <link>https://medium.com/@marciusdellano/introdu%C3%A7%C3%A3o-ao-web-scraping-utilizando-ferramenta-scrapy-65d7a845d2a2?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/65d7a845d2a2</guid>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[scrapy]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Sun, 09 Jun 2024 20:17:39 GMT</pubDate>
            <atom:updated>2024-06-09T20:17:39.671Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/383/1*ih1kkYPeFVx_HWe_-_t3Jg.png" /></figure><h3>Antes de começar</h3><p>Este artigo pressupõe que você tenha conhecimentos básicos em HTML, CSS e XPath. Caso você não os possua, os links abaixo podem lhe auxiliar:</p><ul><li><a href="https://developer.mozilla.org/pt-BR/docs/Learn/Getting_started_with_the_web">Introdução à Web</a> , um minicurso criado pela Mozilla, desenvolvedora do Firefox, que ensina HTML, CSS e Javascript;</li><li><a href="https://www.brasilcode.com.br/html-e-css-guia-basico/">HTML e CSS: Guia Básico para Iniciantes</a>: um artigo introdutório sobre HTML e CSS;</li><li>Tutoriais de <a href="https://www.w3schools.com/html/">HTML</a>, <a href="https://www.w3schools.com/css">CSS </a>e <a href="https://www.w3schools.com/xml/xpath_intro.asp">XPath</a> do site W3Schools (em inglês)</li><li><a href="https://hub.asimov.academy/tutorial/como-localizar-elementos-em-html-usando-xpath/">Como utilizar XPATH para extrair informações das páginas da internet</a></li></ul><h3>O que é Web scraping</h3><p>Em muitas situações, é necessário coletar informações disponíveis em web-sites. A maneira mais simples de se fazer isso é através de API’s que algumas plataformas, tais como redes sociais (Facebook, Instgram, X, etc, ou ferramentas corporativas tais como JIRA, Monday.com, Basecamp, entre outras, disponibilizam a seus usuários. Normalmente, essas API’s trabalham com arquivos JSON ou XML, sendo fácil extrair as informações desejadas destes arquivos.</p><p>Infelizmente, são poucos os sites que oferecem tais API’s e, na maioria das vezes é necessário fazer um trabalho de web scraping, que nada mais é o ato de analisar de forma automatizada o código HTML de páginas na internet e extrair os dados desejados.</p><p>Existem várias ferramentas de web scraping disponíveis para os mais variados ambientes de desenvolvimento, como o Java, Python, C#, Rust, entre outros. O foco neste artigo será na ferramenta Scrapy, uma biblioteca de código aberto desenvolvida em Python.</p><h3>O Scrapy</h3><p>O Scrapy é uma ferramenta de web-scraping que visa extrair dados estruturados que podem ser utilizados para uma enorme gama de aplicações, tais como, mineração de dados, processamento e arquivamento de informações, entre outras.</p><p>O Scrapy tem como características ser uma ferramenta simples, rápida robusta, extensível ou seja, é possível plugar novas funcionalidades sem a necessidade de conhecer a fundo a ferramenta e - pelo fato de ser desenvolvida em Python — ser portável, ou seja pode rodar em Mac, Windows ou Linux.</p><p>Antes de apresentar o Scrapy vamos expor alguns conceitos importantes desta biblioteca</p><h3>Conceitos importantes do Scrapy</h3><ul><li><strong>Projeto: </strong>trata-se de uma estrutura de arquivos e pastas contendo arquivos de configuração, arquivos que permitem inserir funcionalidades adicionais, além de uma ou mais classes <em>Spiders</em>, que leem e coletam as informações das páginas.</li><li><strong>Spiders (</strong>aranhas<strong>): </strong>são classes que apresentam instruções para navegar em uma ou mais páginas e coletar os dados desejados</li><li><strong>Items: </strong>as informações coletadas podem ser armazenadas em um objeto ou uma coleção de objetos. Por exemplo, se estivermos navegando em um site de classificados de automóveis poderíamos armazenar informações de cada veículo listado, como preço, modelo, ano, em um objeto e retornar posteriormente os objetos criados em um arquivo JSON ou XML, por exemplo;</li><li><strong>Pipeline</strong>: um <em>pipeline</em> é uma classe especial que permite executar processamento adicional em cada item retornado durante a etapa de scraping. Podemos adicionar, um mecanismo de validação ou armazená-lo em um banco de dados.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*te2gDeNaOHARn7H5vOSW4w.png" /><figcaption>O processo de scraping de uma página</figcaption></figure><h3>Limitações do Scrapy</h3><p>O Scrapy não é capaz de interagir com elementos de uma página. Não é possível, por exemplo, fazer login em um site ou clicar em um botão. Caso você necessite de interação utilize uma outra ferramenta, como por exemplo, o <a href="https://www.selenium.dev/">Selenium</a>.</p><h3>Instalando o Scrapy</h3><p>Pode-se instalar o Scrapy pelo conda ou pelo pip . Execute o comando abaixo para instalação através do conda:</p><pre>conda install -c conda-forge scrapy</pre><p>Instalando o Scrapy através do pip:</p><pre>pip install Scrapy</pre><p>Recomenda-se instalar o Scrapy em um ambiente virtual em vez de se utilizar o Python instalado no sistema, a fim de se evitar conflito com pacotes já instalados. É aconselhável utilizar o IDE PyCharm que permite criar ambientes virtuais com grande facilidade.</p><h3>Criando um projeto Scrapy</h3><p>Vamos agora pôr a mão na massa e criar um projeto Scrapy. Para isso, vamos criar um novo projeto no Pycharm, dando um nome qualquer, no meu caso scrapyquotes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/813/1*G-GgrP0n-ppDvSgHLAsvsg.png" /><figcaption>Criando um projeto no PyCharm</figcaption></figure><p>Agora abra um terminal no PyCharm e digite o comando pip install scrapy para baixar a biblioteca. Para confirmar que a instalação foi bem sucedida digite o comando scrapy sem argumentos e tecle &lt;Enter&gt; . Um texto de ajuda sobre o uso deste comando deverá ser mostrado, conforme figura abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*Wfn9Io9xax_c-xjEPwMrgg.png" /><figcaption>Testando instalação da biblioteca Scrapy</figcaption></figure><p>Agora podemos prosseguir com a criação do projeto Scrapy. Vamos agora digitar no terminal o comando scrapy startproject quotes onde “quotes” é o nome do nosso projeto:</p><pre>(.venv) PS C:\Users\Marcius\PyCharmProject\scrapyquotes&gt;scrapy startproject quotes</pre><p>Este comando cria um diretório chamado ‘quotes’ cuja estrutura é a seguinte:</p><pre>quotes/<br>    scrapy.cfg            # deploy configuration file<br><br>    quotes/             # project&#39;s Python module, you&#39;ll import your code from here<br>        __init__.py<br><br>        items.py          # project items definition file<br><br>        middlewares.py    # project middlewares file<br><br>        pipelines.py      # project pipelines file<br><br>        settings.py       # project settings file<br><br>        spiders/          # a directory where you&#39;ll later put your spiders<br>            __init__.py</pre><h4>Criando nossa primeira aranha</h4><p>Dentro da pasta quotes\quotes\spiders crie um um arquivo chamado quotes_spider com o conteúdo a seguir:</p><pre># importar bibliotecas<br>import scrapy<br><br><br>class QuotesSpider(scrapy.Spider):<br>    name = &quot;quotes&quot;<br>    start_urls = [&quot;https://quotes.toscrape.com/page/1/&quot;,<br>                  &quot;https://quotes.toscrape.com/page/2/&quot;]<br><br>  def parse(self, response, **kwargs):</pre><p>Primeiramente, importamos a biblioteca scrapy, a seguir definimos uma classe chamada QuotesSpider , como uma subclasse de scrapy.Spider . Então definimos um nome para a aranha, que será utilizado no comando que executa o scraping (visto logo a seguir). Também definimos uma variável start_urls como um array contendo as URLs que a aranha irá visitar. Por fim, definimos um método parse , que aceita dois parâmetros:</p><ul><li>response : objeto da classe scrapy.http.response.html.HtmlResponse que retorna o conteúdo da página , juntamente com alguns métodos úteis para manipulá-lo;</li><li>**kwargs : parâmetros adicionais cuja explicação foge ao escopo deste artigo, por ser introdutório. Não utilizaremos este parâmetro.</li></ul><p>No método parse escrevemos o código que irá percorrer a página e coletar as informações que necessitamos. Normalmente as informações são transformadas em um <em>array</em> de dicionários, então utiliza-se a palavra-chave yield do Python para retornar cada dicionário. O pseudocódigo abaixo ilustra o que acabou de ser dito:</p><pre>def parse(self, response, **kwargs):<br>   for &lt;container&gt; in &lt;seletor&gt;:<br>      yield:<br>        &quot;campo 1&quot;: &lt;container.elemento1&gt;<br>        &quot;campo 2&quot;: &lt;container.elemtnto2&gt;<br>        ....</pre><p>Antes de continuar, é importante saber como temos acesso a um elemento de uma página HTML através do Scrapy, isto é o que será visto a seguir.</p><h4>Como acessar elementos de uma página no Scrapy</h4><p>Podemos encontrar elementos em uma página web de duas formas distintas: via seletores do CSS ou por XPath, para isso invocamos os métodos response.css() e response.xpath() respectivamente. Exemplos:</p><pre>#Localizar o primeiro parágrafo de uma seção &#39;div&#39; com atributo class=&quot;container&quot;:<br>response.css(&quot;div &gt; p::firstchild&quot;)<br>#ou<br>response.xpath(&quot;//div/p[1]&quot;)</pre><h4>Testando as nossas expressões</h4><p>O Scrapy fornece um <em>shell</em> interativo para que possamos testar as expressões CSS e XPath sem ter de executar os <em>spiders. </em>Para isso basta que executemos no terminal o comando scrapy shell &quot;&lt;url_da_pagina&gt;&quot;. Para este artigo vamos acessar o página <em>Quotes to Scrape</em> (<a href="https://quotes.toscrape.com/">https://quotes.toscrape.com</a>). Então vamos digitar no terminal:</p><pre>scrapy shell &quot;https://quotes.toscrape.com&quot;</pre><p>O Scrapy shell disponibiliza alguns objetos entre eles o response que armazena o conteúdo da página visitada e oferece os métodos response.css() e response.xpath() vistos acima, para acessarmos os elementos da página.</p><p><strong>Sugestão</strong>: instale o pacote <a href="https://ipython.org/">ipython</a>. Quando este está instalado, o scrapy shell passa a utilizá-lo, em vez do console padrão do Python. O ipython oferece recursos adicionais, como autocompletar, saída colorida, além de manter o histórico de comandos digitados, mesmo quando você sai do console e entra novamente.</p><p>Vamos agora utilizar o scrapy shell para encontrar as informações que desejamos, mas antes será mostrado um <em>print</em> da página com parte do código fonte que mostra o código de cada elemento que vamos extrair posteriormente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3sjlOewqlTzBK2GZndUEtQ.png" /></figure><p>Vimos acima que cada um dos blocos com as citações vem encapsulado em uma tag &lt;div class=&quot;quote&quot;&gt; , a frase está contida em uma tag &lt;span&gt; com atributo <em>class</em>=”text”, o autor dentro de uma tag &lt;small&gt; cuja classe CSS é <em>authors</em> e as etiquetas (<em>tags</em>) que identificam o tipo de frase vêm dentro uma tag &lt;a&gt;cuja classe é “tag”. Então vamos acessar estes elementos no <em>shell</em> interativo que acabamos de abrir</p><pre>In [1]: quotes = response.css(&quot;div.quote&quot;)</pre><p>Ou utilizando o response.xpath():</p><pre>In[1]: quotes=response.xpath(&quot;//div[@class=&#39;quote&#39;]&quot;)</pre><p>Vamos verificar o tipo da variável quotes:</p><pre>In [2]: type(quotes)<br>Out[2]: scrapy.selector.unified.SelectorList<br><br>In[3}: len(quotes)<br>Out[3]: 10</pre><p>A classe SelectorListé uma lista contendo objetos da classe Selector, que corresponde a cada elemento que combina com a expressão fornecida no response.css()ou response.xpath(). No nosso caso, verificamos que a lista contém 10 elementos. Vamos agora pegar o primeiro elemento desta lista:</p><pre>In[4}: quotes[0]<br>Out[4]:&lt;Selector query=&quot;descendant-or-self::div[@class and contains(concat(&#39; &#39;, normalize-space(@class), &#39; &#39;), &#39; quote &#39;)]&quot; data=&#39;&lt;div class=&quot;quote&quot; itemsco<br>pe itemtype...&#39;&gt;<br><br>In[5}: type(quotes[0])<br>Out[5]: scrapy.selector.unified.Selector<br></pre><p>Para acessarmos o conteúdo de um objeto Selector, utilizamos o método get() conforme abaixo:</p><pre>In [6]: quotes[0].get()<br>Out[6]: &#39;&lt;div class=&quot;quote&quot; itemscope itemtype=&quot;http://schema.org/CreativeWork&quot;&gt;\n        &lt;span class=&quot;text&quot; itemprop=&quot;text&quot;&gt;“The world as we have created it<br> is a process of our thinking. It cannot be changed without changing our thinking.”&lt;/span&gt;\n        &lt;span&gt;by &lt;small class=&quot;author&quot; itemprop=&quot;author&quot;&gt;Albert Ei<br>nstein&lt;/small&gt;\n        &lt;a href=&quot;/author/Albert-Einstein&quot;&gt;(about)&lt;/a&gt;\n        &lt;/span&gt;\n        &lt;div class=&quot;tags&quot;&gt;\n            Tags:\n            &lt;meta class<br>=&quot;keywords&quot; itemprop=&quot;keywords&quot; content=&quot;change,deep-thoughts,thinking,world&quot;&gt; \n            \n            &lt;a class=&quot;tag&quot; href=&quot;/tag/change/page/1/&quot;&gt;change&lt;/a<br>&gt;\n            \n            &lt;a class=&quot;tag&quot; href=&quot;/tag/deep-thoughts/page/1/&quot;&gt;deep-thoughts&lt;/a&gt;\n            \n            &lt;a class=&quot;tag&quot; href=&quot;/tag/thinking/<br>page/1/&quot;&gt;thinking&lt;/a&gt;\n            \n            &lt;a class=&quot;tag&quot; href=&quot;/tag/world/page/1/&quot;&gt;world&lt;/a&gt;\n            \n        &lt;/div&gt;\n    &lt;/div&gt;&#39;</pre><p>Como elementos de uma página podem conter elementos aninhados, como ocorre com os blocos &lt;div&gt; e &lt;ul&gt;, o objeto Selector também fornece os métodos css() e xpath() . Então para acessarmos o elemento &lt;span&gt; que contém a citação, podemos invocar o comando abaixo:</p><pre>In [7]: quotes[0].css(&quot;span:first-child&quot;).get()<br>Out[7]: &#39;&lt;span class=&quot;text&quot; itemprop=&quot;text&quot;&gt;“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking<br>.”&lt;/span&gt;&#39;</pre><p>O comando acima retorna todo o código HTML do elemento selecionado, se quisermos apenas o texto, então devemos acrescentar o sufixo ::textao seletor:</p><pre>In [8]: quotes[0].css(&quot;span:first-child::text&quot;).get()<br>Out[8]: &#39;“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”&#39;</pre><p><strong>Observação</strong>: o sufixo ::text (na verdade, expressões iniciadas por :: são chamadas de ‘pseudoelementos’) não é um padrão do CSS definido pela <a href="https://www.w3.org/TR/selectors-3/">W3C</a>, mas sim uma extensão do Scrapy para podermos acessar o texto de um elemento usando o método css() . Diferentemente do XPath que permite, por padrão, acessar o texto, através do operador text():</p><pre>In [9]: quotes[0].xpath(&quot;span[1]/text()&quot;).get()<br>Out[9]: &#39;“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”&#39;</pre><p>Vamos agora pegar o autor da frase:</p><pre>In [10]: quotes[0].css(&quot;span:nth_child(2) small::text&quot;).get()<br>Out[10]: &#39;Albert Einstein&#39;</pre><p>Ou:</p><pre>In [11]: quotes[0].xpath(&quot;span[2]/small/text()&quot;).get()<br>Out[11]: &#39;Albert Einstein&#39;</pre><p>Para as tags vamos utilizar o método getall(), que retorna todos os elementos que satisfazem o seletor informado</p><pre>In [12]: quotes[0].css(&quot;div.tags a::text&quot;).getall()<br>Out[12]: [&#39;change&#39;, &#39;deep-thoughts&#39;, &#39;thinking&#39;, &#39;world&#39;]</pre><p>via xpath():</p><pre>In [13]: quotes[0].xpath(&quot;div[@class=&#39;tags&#39;]/a/text()&quot;).getall()<br>Out[13]: [&#39;change&#39;, &#39;deep-thoughts&#39;, &#39;thinking&#39;, &#39;world&#39;]</pre><p>Com isso, já temos todos os elementos que precisamos para configurar nossa aranha.</p><h4>Criando e executando a aranha</h4><p>Vamos completar a classe QuotesSpider definindo o método parse:</p><pre># importar bibliotecas<br>import scrapy<br><br><br>class QuotesSpider(scrapy.Spider):<br>    name = &quot;quotes&quot;<br>    start_urls = [&quot;https://quotes.toscrape.com&quot;]<br><br>    def parse(self, response, **kwargs):<br>        for quote in response.css(&quot;div.quote&quot;):<br>            yield {<br>                &#39;text:&#39;: quote.css(&quot;span:first-child::text&quot;).get(),<br>                &#39;author&#39;: quote.css(&quot;span:nth_child(2) small::text&quot;).get(),<br>                &#39;tags&#39;: quote.css(&quot;div.tags a::text&quot;).getall()<br>            }</pre><p>No código acima, para cada bloco &lt;div class=&quot;quote&quot;&gt; encontrado é retornado um dicionário com as chaves &#39;text&#39; ,&#39;author&#39; e &#39;tags&#39; e cujos valores correspondem aos elementos que contêm os respectivos dados.</p><p>Agora vamos rodar nossa aranha para isso devemos executar no terminal,o comando scrapy crawl quotes (‘quotes’ é valor da propriedade name da classe QuotesSpider , mas antes disso, devemos avançar até o diretório raiz do projeto, o que contém o arquivo scrapy.cfg` :</p><pre>(.venv) PS C:\Users\Marcius\PyCharmProject\scrapyquotes&gt;cd quotes<br>(.venv) PS C:\Users\Marcius\PyCharmProject\scrapyquotes\quotes&gt;scrapy crawl quotes<br></pre><p>Ao executar este comando serão geradas várias saídas semelhantes a estas:</p><pre>2024-06-09 12:10:49 [scrapy.core.scraper] DEBUG: Scraped from &lt;200 https://quotes.toscrape.com&gt;<br>{&#39;text:&#39;: &#39;“Try not to become a man of success. Rather become a man of value.”&#39;, &#39;author&#39;: &#39;Albert Einstein&#39;, &#39;tags&#39;: [&#39;adulthood&#39;, &#39;success&#39;, &#39;value&#39;]}      <br>2024-06-09 12:10:49 [scrapy.core.scraper] DEBUG: Scraped from &lt;200 https://quotes.toscrape.com&gt;<br>{&#39;text:&#39;: &#39;“It is better to be hated for what you are than to be loved for what you are not.”&#39;, &#39;author&#39;: &#39;André Gide&#39;, &#39;tags&#39;: [&#39;life&#39;, &#39;love&#39;]}<br>2024-06-09 12:10:49 [scrapy.core.scraper] DEBUG: Scraped from &lt;200 https://quotes.toscrape.com&gt;<br>{&#39;text:&#39;: &quot;“I have not failed. I&#39;ve just found 10,000 ways that won&#39;t work.”&quot;, &#39;author&#39;: &#39;Thomas A. Edison&#39;, &#39;tags&#39;: [&#39;edison&#39;, &#39;failure&#39;, &#39;inspirational&#39;, &#39;p<br>araphrased&#39;]}</pre><p>Podemos jogar a saída do comando em um arquivo JSON, para isto, vamos acrescentar a opção -o &lt;nome de arquivo&gt;:</p><pre>scrapy crawl quotes -o quotes.json</pre><p>Isto cria um arquivo JSON chamado quotes.json com o seguinte conteúdo:</p><pre>[<br>{&quot;text:&quot;: &quot;“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”&quot;, &quot;author&quot;: &quot;Albert Einstein&quot;, &quot;tags&quot;: [&quot;change&quot;, &quot;deep-thoughts&quot;, &quot;thinking&quot;, &quot;world&quot;]},<br>{&quot;text:&quot;: &quot;“It is our choices, Harry, that show what we truly are, far more than our abilities.”&quot;, &quot;author&quot;: &quot;J.K. Rowling&quot;, &quot;tags&quot;: [&quot;abilities&quot;, &quot;choices&quot;]},<br>{&quot;text:&quot;: &quot;“There are only two ways to live your life. One is as though nothing is a miracle. The other is as though everything is a miracle.”&quot;, &quot;author&quot;: &quot;Albert Einstein&quot;, &quot;tags&quot;: [&quot;inspirational&quot;, &quot;life&quot;, &quot;live&quot;, &quot;miracle&quot;, &quot;miracles&quot;]},<br>{&quot;text:&quot;: &quot;“The person, be it gentleman or lady, who has not pleasure in a good novel, must be intolerably stupid.”&quot;, &quot;author&quot;: &quot;Jane Austen&quot;, &quot;tags&quot;: [&quot;aliteracy&quot;, &quot;books&quot;, &quot;classic&quot;, &quot;humor&quot;]},<br>{&quot;text:&quot;: &quot;“Imperfection is beauty, madness is genius and it&#39;s better to be absolutely ridiculous than absolutely boring.”&quot;, &quot;author&quot;: &quot;Marilyn Monroe&quot;, &quot;tags&quot;: [&quot;be-yourself&quot;, &quot;inspirational&quot;]},<br>{&quot;text:&quot;: &quot;“Try not to become a man of success. Rather become a man of value.”&quot;, &quot;author&quot;: &quot;Albert Einstein&quot;, &quot;tags&quot;: [&quot;adulthood&quot;, &quot;success&quot;, &quot;value&quot;]},<br>{&quot;text:&quot;: &quot;“It is better to be hated for what you are than to be loved for what you are not.”&quot;, &quot;author&quot;: &quot;André Gide&quot;, &quot;tags&quot;: [&quot;life&quot;, &quot;love&quot;]},<br>{&quot;text:&quot;: &quot;“I have not failed. I&#39;ve just found 10,000 ways that won&#39;t work.”&quot;, &quot;author&quot;: &quot;Thomas A. Edison&quot;, &quot;tags&quot;: [&quot;edison&quot;, &quot;failure&quot;, &quot;inspirational&quot;, &quot;paraphrased&quot;]},<br>{&quot;text:&quot;: &quot;“A woman is like a tea bag; you never know how strong it is until it&#39;s in hot water.”&quot;, &quot;author&quot;: &quot;Eleanor Roosevelt&quot;, &quot;tags&quot;: [&quot;misattributed-eleanor-roosevelt&quot;]},<br>{&quot;text:&quot;: &quot;“A day without sunshine is like, you know, night.”&quot;, &quot;author&quot;: &quot;Steve Martin&quot;, &quot;tags&quot;: [&quot;humor&quot;, &quot;obvious&quot;, &quot;simile&quot;]}<br>]</pre><p>É possível salvar os dados capturados em um arquivo, ou mesmo em um banco de dados. Também é possível seguir links em uma página, mas para um artigo introdutório, o que foi mostrado até aqui já é o bastante para apresentar o Scrapy e mostrar as suas possibilidades e limitações.</p><p>Clique <a href="https://github.com/marciusdm/artigos/tree/main/intro_web_scraping_scrapy">aqui</a> para acessar e baixar o código fonte utilizado neste artigo.</p><p>Clique <a href="https://medium.com/@marciusdellano">aqui</a> para ler meus outros artigos escritos na plataforma Medium</p><p>Meu portfolio profissional</p><p>Meu <a href="https://www.linkedin.com/in/marciusdm">perfil</a> no Linkedin</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65d7a845d2a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Soluções de machine learning na nuvem: prós e contras]]></title>
            <link>https://medium.com/@marciusdellano/solu%C3%A7%C3%B5es-de-machine-learning-na-nuvem-pr%C3%B3s-e-contras-8f28dab3be42?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f28dab3be42</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Sat, 25 Nov 2023 01:02:28 GMT</pubDate>
            <atom:updated>2023-11-25T01:02:28.024Z</atom:updated>
            <content:encoded><![CDATA[<p>Neste artigo iremos falar brevemente sobre soluções de machine learning em nuvem, suas vantagens e desvantagens e as principais plataformas disponíveis no mercado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yuGFIAyVP1oowdiU" /><figcaption>Photo by <a href="https://unsplash.com/@growtika?utm_source=medium&amp;utm_medium=referral">Growtika</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Introdução</h3><p>Soluções em machine learning, especialmente aquelas que envolvem <em>deep learning</em> e redes neurais, podem ser complexas e consumir muitos recursos de <em>hardware </em>como memória e disco, pois trabalham com um grande volume de dados. Além disso, mudanças podem ocorrer em todo o processo de criação da solução, ou até mesmo após sua criação gerando novas demandas por <em>hardware </em>e <em>software.<br></em>Manter localmente uma estrutura computacional, com servidores, estações de trabalho e equipamentos de rede é uma atividade que demanda planejamento — desde a organização do espaço físico, cabeamento até políticas de segurança, tempo — gasto com as rotinas de administração e manutenção, e dinheiro — para aquisição de licenças de <em>software</em>, upgrade de servidores.<br>Diante de toda a complexidade do que foi exposto acima, muitas empresas consideram utilizar soluções em nuvem para seus projetos de machine learning.</p><h3>Afinal o que é a “nuvem”?</h3><p>De uma maneira bastante simplificada, “nuvem” (ou a palavra inglesa <em>cloud</em>) é um recurso computacional oferecido por uma plataforma, mediante um pagamento mensal. Os recursos disponibilizados por estas empresas se encontram em datacenters espalhados em diversos pontos do globo terrestre e os clientes conseguem acessá-los remotamente. Desta forma, toda a complexa tarefa de montar uma infraestrutura de hardware para a execução das soluções de machine learning fica a cargo das empresas que fornecem os serviços em nuvem. Seus clientes só precisam de um computador com Internet para ter acesso a todo poder de processamento que lhes é oferecido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*VlRGcDWIo0LAEoEgREpKww.png" /><figcaption>Modelo de computação em nuvem — Por Sam Johnston — <a href="http://upload.wikimedia.org/wikipedia/commons/b/b5/Cloud_computing.svg">http://upload.wikimedia.org/wikipedia/commons/b/b5/Cloud_computing.svg</a>, CC BY-SA 3.0, <a href="https://commons.wikimedia.org/w/index.php?curid=28083204">https://commons.wikimedia.org/w/index.php?curid=28083204</a></figcaption></figure><h3>Quais são as vantagens da nuvem?</h3><p>Além de não ter de se preocupar com instalações de hardware e custos de aquisição de software, a computação em nuvem oferece outros benefícios:</p><ul><li><strong>Escalabilidade</strong>: esta é a palavra-chave do modelo de computação em nuvem. Escalabilidade é a capacidade de adicionar ou remover recursos de acordo com as demandas do usuário. As plataformas em nuvem ofertam máquinas virtuais desde as mais básicas com alguns poucos GB de armazenamento e 2GB ou 4GB de memória RAM até as mais robustas com armazenamento chegando na casa dos terabytes e com centenas de GB de RAM. E é um procedimento simples modificar as configurações de máquina virtual.</li><li>Já que não hospedam suas aplicações localmente, as empresas podem ter uma infraestrutura de rede mais enxuta;</li><li>As plataformas em nuvem trabalham constantemente para manter seus sistemas atualizados tanto em nível de hardware quanto de software;</li><li>O cliente paga apenas pelo que usar de recursos da plataforma, o que permite um maior controle de gastos;</li><li>Acesso aos dados e recursos da plataforma podem ser feitos de qualquer lugar, não apenas do local de trabalho.</li></ul><h3>Quais são as desvantagens da nuvem?</h3><ul><li>Dependendo da complexidade da solução de machine learning, os custos podem se tornar elevados;</li><li>Segurança: seus dados estão nas mãos de terceiros; por mais que as plataformas invistam em segurança, a integridade e confidencialidade dos dados não é 100% garantida.</li></ul><h3>As principais plataformas para ML na nuvem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/787/1*hbVQ9USKOrnP3JaiL1Q5hw.png" /></figure><h4>Google Cloud</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UNO5O3vYmqyfnEHuza1rFA.png" /></figure><p>O <a href="https://cloud.google.com/data-science?hl=pt_br">Google Cloud</a> oferece inúmeros serviços voltados para projetos de ciência de dados, desde as etapas iniciais de coleta e armazenamento de dados, até a parte de <em>story telling, </em>passando pela engenharia de dados e de ML. Estas são algumas ferramentas do Google Cloud</p><ul><li><strong>VertexAI</strong>: para criação de IA generativa;</li><li><strong>Dataflow</strong> e <strong>Dataproc:</strong> ferramentas para pré-processamento de dados e criação de <em>pipelines</em> de machine learning;</li><li><strong>AutoML</strong>: ferramenta <em>low-code </em>para treinamento de modelos de machine learning;</li><li><strong>Looker Studio</strong>: ferramenta de <em>business intelligence</em> para criação de <em>dashboards </em>e relatórios</li></ul><h4>Amazon Web Services (AWS)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nX3DP2BSOKePNGNY41XRTA.png" /></figure><p>A <a href="https://aws.amazon.com/pt/machine-learning/">AWS</a> também oferece vários serviços para criar e treinar modelos de ML. Segue abaixo alguns dos serviços:</p><ul><li><strong>Amazon SageMaker</strong>: para criação, treinamento e implantação de modelos de ML com suporte para as principais plataformas e linguagens utilizadas em contexto de machine learning, tais como o Jupyter Notebook, Scikit-learn, Keras, TensorFlow, Python e R. Além disso, é disponibilizada uma IDE própria denominada <strong>SageMaker Studio </strong>e uma ferramenta para gerar previsões de machine learning sem a necessidade de se escrever linhas de código</li><li><strong>Amazon Forecast:</strong> um serviço para previsão de séries temporais</li><li><strong>Amazon Fraud Detector: </strong>uma ferramenta especializada de IA para detecção de anomalias, tais como fraudes em cartões, inscrições falsas, entre outas;</li><li><strong>Amazon Kendra:</strong> serviço de busca que utiliza processamento de linguagem natural para pesquisas mais refinadas;</li><li><strong>Amazon Comprehend: a</strong>nalisador de texto não estruturado. Também há uma ferramenta especializada para textos médicos denominada <strong>Amazon Comprehend Medical</strong></li></ul><h4>Microsoft Azure</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b7nRyQ7uZdkH6rd9w4FeKw.png" /></figure><p>A plataforma de computação em nuvem da Microsoft possui o <a href="https://azure.microsoft.com/pt-br/products/machine-learning">Microsoft Azure Machine Learning</a> para criar, desenvolver e implantar modelos de machine learning. Além deste serviço, a plataforma também conta com ferramentas de IA generativa, de tradução e para visão computacional. Outra ferramenta útil é Azure Synapse Analytics para análise de dados e extração de <em>insights.</em></p><h3>Conclusão</h3><p>Atualmente, diversas plataformas apresentam soluções de machine learning para a criação, treinamento e implantação de modelos robustos e escaláveis, sendo as principais, o Google Cloud, AWS e Microsoft Azure. Todas elas possuem um período de testes gratuito, permitindo aos cientistas dados experimentar os recursos destas plataformas antes de decidir se vale a pena adotar soluções em nuvem, e qual plataforma atende melhor às suas necessidades.</p><h3>Links interessantes:</h3><ul><li><a href="https://www.veritis.com/blog/top-15-aws-machine-learning-tools-in-the-cloud/">Top 15 AWS Machine Learning Tools in the Cloud</a></li><li><a href="https://blog.qinetwork.com.br/escalabilidade-da-nuvem-flexibilidade-no-armazenamento-de-dados/#:~:text=A%20escalabilidade%20se%20refere%20a,como%20o%20Google%20Cloud%20Platform.">Escalabilidade da nuvem: flexibilidade no armazenamento de dados</a></li><li><a href="https://www.whizlabs.com/blog/google-cloud-machine-learning/">Introduction to Machine Learning on Google Cloud Platform</a></li><li><a href="https://smartconsulting.com.br/o-que-e-azure-machine-learning/">O que é Azure Machine Learning?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f28dab3be42" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Previsão de demanda utilizando séries temporais]]></title>
            <link>https://medium.com/@marciusdellano/previs%C3%A3o-de-demanda-utilizando-s%C3%A9ries-temporais-19a776f172d2?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/19a776f172d2</guid>
            <category><![CDATA[time-series-forecasting]]></category>
            <category><![CDATA[prophet]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Thu, 26 Oct 2023 03:24:59 GMT</pubDate>
            <atom:updated>2023-10-26T03:24:59.629Z</atom:updated>
            <content:encoded><![CDATA[<p>Neste artigo será abordado um projeto de <em>data scicence </em>que descreve um método para prever a demanda por vinhos com base em um histórico de vendas anterior. Para isso será utilizada a biblioteca <em>Prophet</em>, criada pela equipe de desenvolvimento do Facebook.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/657/1*Bn02BUJaiUkprp_-8dX6gw.png" /><figcaption><a href="https://colab.research.google.com/corgiredirector?site=https%3A%2F%2Fbr.freepik.com%2Ffotos-gratis%2Fdespejando-vinho-tinto-no-copo_22243350.htm%23query%3Dvinho%26position%3D5%26from_view%3Dsearch%26track%3Dsph">Imagem de fabrikasimf</a> no Freepik</figcaption></figure><h3>O contexto do projeto</h3><p>Neste projeto iremos lidar com previsão de demanda para uma fictícia loja de vinhos. Diferentemente dos projetos anteriores, este conterá duas bases de dados. A primeira é uma carta de vinhos, com produtos reais, ofertados em uma loja brasileira de e-commerce de vinhos. A segunda é uma base de dados de vendas adaptada de uma competição do Kaggle. Esta base, originalmente continha 5 anos de vendas, porém foi modificada para conter apenas registros de janeiro de 2018 a dezembro de 2020 e além disso, os registros foram alterados para conter somente produtos desta carta de vinhos. Ou seja, são dados forjados que podem conter algumas discordâncias com a realidade:</p><ul><li>Vendas de vinhos de safras de um ano posterior ao ano da venda. Exemplo safra de 2019 com venda em 2018;</li><li>Tipos de vinho com volume de venda maior que o que vende na realidade. Por exemplo, podemos ter um vinho rosé como o mais vendido, sendo que estes vendem menos que os tintos e os brancos.</li></ul><h3>Quais os benefícios da previsão de demanda?</h3><p>Se antecipar às tendências de compras por parte dos clientes traz muitos benefícios ao negócio pois permite entre outras coisas:</p><ul><li>Fazer um planejamento orçamentário mais eficaz, pelo fato de que ao saber o que os cientes vão consumir a empresa consegue estimar de modo mais preciso os custos de aquisição dos produtos que serão ofertados aos clientes;</li><li>Gerenciar melhor os estoques de bebidas, na medida em que se evita manter por muito tempo produtos com pouca saída e dar prioridade para os produtos mais vendidos. Junte-se a isso, o fato de que alguns tipos de vinho são mais delicados e não podem ficar armazenados por muito tempo antes que comecem a ter uma degradação;</li><li>Aumentar o poder de barganha junto aos fornecedores, em particular, nas bebidas mais vendidas, pois ao comprar mais unidades destas, a empresa pode negociar descontos melhores;</li><li>Sinalizar aos produtores de vinho, que tipo de bebida deve ser mais ou menos fabricada de acordo com as perspectivas de demanda por parte dos consumidores.</li></ul><h3>A carta de vinhos</h3><p>O conjunto de dados da carta de vinhos contém 219 registros e 9 colunas a seguir:</p><ul><li><strong>item_id</strong>: identificador único do vinho;</li><li><strong>name</strong>: nome do vinho;</li><li><strong>producer</strong>: produtor;</li><li><strong>country</strong>: país de origem;</li><li><strong>region</strong>: região de origem;</li><li><strong>kind</strong>: tipo de vinho (ver abaixo);</li><li><strong>price_brl</strong>: Preço em reais;</li><li><strong>price_usd</strong>: preço em dólar.</li></ul><p>Os tipos de vinho:</p><ul><li><strong>sparkling</strong>: espumante;</li><li><strong>rose sparkling</strong>: espumante rosé;</li><li><strong>white</strong>: branco;</li><li><strong>rose</strong>: rosé;</li><li><strong>red</strong>: tinto.</li></ul><h4>Exibindo as primeiras linhas</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/1*HdD4jQBNpMvIXLovS1mz3g.png" /></figure><p>Verificando os tipos de dados</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/162/1*Bu86vRTKcKz8Iuar0-O_9Q.png" /></figure><h4>Efetuando um tratamento nos dados</h4><p>O Pandas trata todas as colunas, com exceção de item_id, como texto, mesmo as que deveriam ser numéricas: price_brl e price_usd. O problema é a existência de vírgulas em algumas registros. Será necessário eliminá-las:</p><pre># limpando as vírgulas<br>df.replace(&#39;,&#39;,&#39;&#39;, regex=True, inplace=True)<br>df.head()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*5OiQVO5AH0U6PDubJhOk5w.png" /></figure><p>Outras alterações realizadas:</p><ul><li>converter para float as colunas price_brl e price_usd ;</li><li>modificar na coluna vintageos valores NV (sem safra) para 0;</li><li>Acrescentar um código de país com 2 letras à coluna region , para que possamos identificar o país;</li><li>Criar uma coluna adicional combinando o produto com a safra.</li></ul><pre>def get_iso_code(country):<br> if country == &#39;France&#39;:<br>  return &quot;FR&quot;<br> elif country == &#39;Italy&#39;:<br>  return &quot;IT&quot;<br> elif country == &#39;Spain&#39;:<br>  return &quot;ES&quot;<br> elif country == &#39;Portugal&#39;:<br>  return &quot;PT&quot;<br> elif country == &#39;Chile&#39;:<br>  return &quot;CH&quot;<br> elif country == &#39;Argentina&#39;:<br>  return &quot;AR&quot;<br><br>#Função para combinar o nome do vinho com sua safra<br>def get_name_vintage(name, vintage):<br> if(vintage == 0): return name<br> else: return &quot;{} {}&quot;.format(name, str(vintage))<br><br>df.price_brl = pd.to_numeric(df.price_brl)<br>df.price_usd = pd.to_numeric(df.price_usd)<br>df[&#39;vintage&#39;] = df[&#39;vintage&#39;].apply(lambda x:  0 if(x==&#39;NV&#39;) else int(x) )<br>df[&quot;name_vintage&quot;] = df.apply(lambda d: get_name_vintage(d[&quot;name&quot;], d.vintage), axis=1)<br>df[&quot;region&quot;] = df.apply(lambda d: &quot;{} ({})&quot;.format(d.region, get_iso_code(d.country)) , axis=1 )</pre><p>Daí vamos exibir novamente as 5 primeiras linhas após estes tratamentos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/907/1*VdDdZIXQMSBPsfOaj6UViw.png" /></figure><h4>Análise de dados</h4><p>Vamos realizar algumas consultas para entender melhor o nosso conjunto de dados.</p><ul><li>Dados gerais:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*uqX-PVWRdfLg8wpOHSN0-A.png" /></figure><ul><li>Consultando os vinhos mais baratos e os mais caros:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/477/1*xUFoqyLxvrmPXM9OxNwdqQ.png" /></figure><ul><li>Consultando os produtores de vinho:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/168/1*Ktoo_ZCxdNnxzpRrHmZiHw.png" /></figure><ul><li>Distribuição de vinhos por safra e região:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8AU6rrcCaIjwtsKsPXZtTA.png" /></figure><p><strong>Mais alguns dados a respeito do preço dos vinhos:<br></strong>A maioria dos vinhos custa até 600 reais, e alguns poucos custam mais de 3000 reais. A média de preços está em torno de 967 reais. Metade dos produtos custa até 510 reais. Um quarto deles custa até 264 reais, e 75% deles custam até 949 reais. Para visualizar melhor estas informações, iremos plotar um box-plot. Os outliers não serão mostrados pois alguns deles possuem valores muito acima do 3º quartil, e seria gerado um box plot muito estreito</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YuxdkEIXwaNQYv-p0Pb-uQ.png" /></figure><p>Caso o leitor queira visualizar mais informações, pode acessar o notebook com o código fonte completo. O link p/ baixá-lo está no fim deste artigo.</p><h3>Dados da venda de produtos</h3><p>Como dito anteriormente, esse conjunto de dados foi criado tendo como base um conjunto similar que foi utilizado em uma competição do Kaggle. O conjunto original tinha 5 anos de registros diários de vendas, distribuídos em 10 lojas, sobre 50 produtos.<br>Nosso conjunto foi criado para ter 3 anos de vendas, distribuídos por 3 lojas com um catálogo de 219 produtos.<br>Lembrando que podemos encontrar problemas que não necessariamente aconteceriam no mundo real, e podem ser causados pela natureza dos nossos dados. De qualquer forma, a intenção é estruturar o problema, e apresentar um projeto relevante, mostrando nosso melhor trabalho com os dados que nos foram disponibilizados.<br>Uma empresa real, teria dados muito mais completos, incluindo dados sobre os consumidores, de onde poderíamos tirar ainda mais insights, trabalhar com sistemas de recomendação, segmentação de clientes, etc.</p><p>Vamos agora fazer uma breve análise dos dados das vendas de vinhos.</p><h4>Obtendo os dados</h4><pre># dados de vendas<br>store = pd.read_csv(&#39;https://raw.githubusercontent.com/rafaelnduarte/sigmoidal_data/master/sales-clean.csv&#39;)</pre><p>Exibindo as primeiras e as últimas entradas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/318/1*T1lC48nuqSq4QYHR0PB9GQ.png" /></figure><p>Como se pode notar, o registro de vendas vai de 1º de janeiro de 2018 a 31 de dezembro de 2020</p><h4>Efetuando um tratamento nos dados</h4><pre># dados de vendas<br>store.rename(columns= {&#39;item&#39;: &#39;item_id&#39;}, inplace=True)<br>store.item_id = store.item_id.astype(np.int64)<br><br>store = df.merge(store, on=&#39;item_id&#39;, how=&#39;right&#39;)<br><br>store[&#39;date&#39;] = pd.to_datetime(store[&#39;date&#39;])<br><br>print(store.shape)<br>store.head()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*c5lAQorrePCB0i5mZyeqqg.png" /></figure><p>Também iremos criar algumas colunas auxiliares para melhorar nossa análise:</p><pre>store[&quot;sale_value_brl&quot;] = store.price_brl * store.sales #Valor das vendas = valor unitário x qtde vendida<br>store[&quot;Year&quot;] = store.date.apply(lambda x: x.year) #Ano<br>store[&quot;Quarter&quot;] = store.date.apply(lambda x: x.quarter) #trimestre<br>store[&quot;Month&quot;] = store.date.apply(lambda x: x.month) #mês<br>store[&quot;Week&quot;] = store.date.apply(lambda x: x.week) #semana<br>store[&quot;Weekday&quot;] = store.date.apply(lambda x: x.weekday()) #dia da semana<br>store[&quot;Day&quot;] = store.date.apply(lambda x: x.day) #dia<br>store[&quot;Dayofyear&quot;] = store.date.apply(lambda x: x.dayofyear) #dia do ano<br>store.drop(store[store.Year == 2016].index, axis=0, inplace=True) #Removendo registros de 2016, que não são relevantes p/ nossa análise<br>store[&quot;Year_Quarter&quot;] = store.apply(lambda d: &quot;{} Q{}&quot;.format(d.Year, d.Quarter) , axis=1 )</pre><h4>Analisando os dados</h4><ul><li>Resumo estatístico das vendas:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*qNQz9MnCezNabUDuPa9zdg.png" /></figure><ul><li>Evolução das vendas ao longo dos três anos por trimestre (volume de vendas):</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*DXV7ij1uI3HCY4LlNTcLTA.png" /></figure><p>Interessante notar que nos três anos abrangidos por este conjunto de dados o volume de vendas por trimestre segue o mesmo padrão sendo o terceiro trimestre o que tem mais vendas, seguido pelo segundo, o quarto e, finalmente, o primeiro trimestre. Também para cada um dos trimestres, as vendas são em número suavemente maior que o período correspondente no ano anterior. Além do quantidade de itens vendidos, vamos verificar também a receita obtida</p><ul><li>Receita líquida por trimestre:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*jNn-nr21cAiUspovgI32BQ.png" /></figure><p>Os gráficos acima mostram que a tendência é de crescimento, tanto em quantidade de vendas quanto em receita. Porém, resta analisar, quais os vinhos têm mais saída e quais os que geram mais receita, a fim de sinalizar a empresa quais marcas devem ter prioridade na aquisição junto a seus fornecedores. O primeiro gráfico abaixo mostra os vinhos mais vendidos em volume de vendas. O segundo mostra os vinhos que geram mais receita. Já o terceiro e o quarto, são análogos ao primeiro e o segundo respectivamente. Porém, levam em conta o produto e a safra.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j7gP5pZS6BmE_vSY0nZTGw.png" /></figure><p>Temos algumas informações muito interessantes aqui. De fato, o vinho que mais gera receita (<em>Domaine Ponsot Chapelle-Chambertin Grand Cru</em>) é o que mais vende. Porém o segundo colocado em receita é apenas o oitavo colocado em vendas (<em>Domaine Ponsot Clos de La Roche Grand Cru Cuvee Vieilles Vignes</em>) é apenas o oitavo vinho mais vendido. Por outro lado, o segundo vinho mais vendido (<em>Potensac</em>) nem aparece entre os 20 vinhos que trazem mais receita para a empresa. Vemos também que quando levamos em conta a safra de cada vinho, o ranking dos mais vendidos se altera significativamente. O que faz com que a empresa tenha de pensar em estratégias de compras de curto e de longo prazo, pois a preferência por determinada safra tem uma certa duração de tempo, porém no longo prazo, ela se reduz, devido ao seu esgotamento e à oferta de novas safras.</p><ul><li>Vendas por região e por produtor</li></ul><p>Vamos agora visualizar o volume de vendas e a receita por produtor e por região:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cLXlH4nHoLWE6tjq2yPaqg.png" /></figure><p>Como era de se esperar, as regiões de Burgundy e Bordeaux, ambas francesas, são as que estão no topo das vendas, justamente por terem mais produtos. Já os vinhos Domaine Ponsot são os que lideram a lista de mais vendidos e os que geram mais receita. Sendo que nesta última, a diferença para o o segundo colocado é mais acentuada pelo fato de seus vinhos serem mais caros, na média, que os demais.</p><h3>Fazendo as previsões</h3><p>Como dito anteriormente, a ferramenta escolhida para fazer a previsão de demanda é o <a href="https://facebook.github.io/prophet/">Prophet</a>, criada pela equipe de desenvolvimento do Facebook. Basicamente, esta biblioteca faz predições futuras a partir de um conjunto de dados que deverá conter duas colunas:</p><ul><li>ds: coluna do tipo data;</li><li>y: coluna numérica, representa as medidas que serão preditas.</li></ul><p>Em nosso caso, a coluna y será dada pela na coluna sales. Vamos agora criar nosso dataset de previsão e vendas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/1*c_QLrgAsVmjYLvpG6_iyiQ.png" /></figure><h4>Séries estacionárias</h4><p>A primeira coisa que temos de fazer é verificar se nossa série temporal é <strong>estacionária</strong>. Uma série dita estacionária é aquela em que, embora apresente oscilações sazonais, suas propriedades estatísticas, tais como média, variância e covariância não variam ao longo do tempo. Uma série estacionária apresenta um gráfico como este abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/339/1*TNR0n81xocwg0U8HL7kXaA.png" /></figure><p>Embora o pacote <em>Prophet</em> consiga trabalhar com séries não estacionárias, seu desempenho é melhor com as estacionárias, conforme veremos mais adiante.</p><h4>Verificando se uma série temporal é estacionária</h4><p>Para verificar se esta série em que estamos trabalhando é estacionária lançaremos mão de uma teste estatístico denominada de <strong>Augmented Dickey-Fuller (ADF)</strong>. Nestes teste examinamos duas possíveis hipóteses:</p><ul><li>A hipótese nula (H0) é que a série <strong>não é estacionária</strong>, ou seja, apresenta modificações em suas medidas estatísticas ao longo do tempo.</li><li>A hipótese alternativa(Ha) é de que a série <strong>é estacionária</strong>.</li></ul><p>Como em todo teste estatístico, o ADF gera um valor-p, que é verificado contra um valor de significância preestabelecido, representado pela letra grega “alfa” α. Os valores mais comuns de α são 0,01, 0,05 e 0,1; Se o valor-p &lt; α então a hipótese nula é rejeitada, ou seja, podemos considerar a série como estacionária. Se valor-p &gt; α, então não se rejeita a hipótese nula, o que quer dizer que a evidência de que a série é estacionária não é forte o suficiente.<br>No jargão estatístico se rejeitamos H0 e ela é verdadeira, então dizemos ocorre um erro tipo I. Agora se não rejeitamos H0 e ela é falsa, dizemos que ocorre um erro do tipo II. Um valor de α baixo reduz as chances de erro tipo I, mas aumenta as chances de erro tipo II. Portanto, deve-se levar em conta qual tipo de erro é mais danoso ao escolhermos o valor de α. Se o primeiro erro for mais grave, devemos pegar um valor baixo, mas se o segundo for mais grave, devemos utilizar um α maior.<br>Como o Prophet trabalha melhor com série estacionária convém reduzir o risco de tratar uma série não estacionária como se fosse estacionária, incorrendo em um erro tipo I. Assim iremos trabalhar com um valor de 0,01 para α e rejeitaremos a hipótese nula se valor-p for menor que isso.<br>Vamos aplicar o teste ADF à nossa série temporal:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/372/1*RE2JkUrvH3RxwmQDCI0zEw.png" /><figcaption>Teste ADF</figcaption></figure><p>Nosso valor-p foi de 0,1533 portanto maior que o nosso α. Portanto não rejeitaremos a hipótese nula, e assim, consideraremos nossa série como não estacionária. Há técnicas para transformar uma série não estacionária em estacionária, o que será visto em uma etapa posterior, porém, agora vamos testar nossa série do jeito que está para verificar como que o Prophet se sai ao lidar com séries não estacionárias</p><h4>Fazendo previsões na série original</h4><p>Ao lidar com séries temporais devemos nos ater ao fato de que quanto maior for o período de previsão, menos confiáveis serão nossas estimativas. Por isso a previsão de vendas irá se limitar a 30 dias:</p><pre># definindo o tamanho da previsão para trinta dias<br>prediction_size = 30<br>train_df = df_ts[:-prediction_size] #retira do conjunto de treino os dados dos últimos 30 dias, que ficarão para teste<br><br># instantiating the model<br>b = Prophet()<br><br># training the model<br>b.fit(train_df)<br><br># make predictions<br>future = b.make_future_dataframe(periods=prediction_size)<br><br>forecast = b.predict(future)<br><br>forecast.head()</pre><p>A última linha deste trecho de código gera saída abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fHsiswoNDdFN4tJPlZ_f0g.png" /></figure><p>O dataframe retornado pela ferramenta <em>prophet</em> traz diversas informações, das quais as mais importantes são o yhat que são os valores previstos, yhat_lower e yhat_upper que delimitam um limite de incerteza da previsão. Vamos agora visualizar a previsão:</p><pre># plotando as previsões<br>b.plot(forecast).savefig(&#39;forecast_non_stationary.png&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/989/1*fm4xoGhQnrUYu1gh7Bj7uA.png" /></figure><p>O <em>Prophet</em> também permite visualizar gráficos com tendências gerais, semanais e anuais como se pode verificar abaixo:</p><pre># plotando componentes<br>b.plot_components(forecast).savefig(&#39;non_st_components.png&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*BMlCMGb5WSrxiOguNQa0rw.png" /></figure><h4>Avaliando o desempenho da série não estacionária</h4><p>Chegou a hora de medir o desempenho do nosso modelo. Iremos utilizar duas medidas:</p><p>utilizaremos as seguintes métricas:</p><ul><li>Mean Absolute Percentage Error — Mostra quanto as nossas previsões diferem do valor real em porcentagem.</li><li>Mean Absolute Error — Valor absoluto do nosso erro na previsão em relação à série real.</li></ul><p>Abaixo temos uma função para calcular o MAPE e MAE da nossa série:</p><pre># definindo a função<br>def make_comparison_dataframe(historical, forecast):<br>  return forecast.set_index(&#39;ds&#39;)[[&#39;yhat&#39;, &#39;yhat_lower&#39;,<br>                                &#39;yhat_upper&#39;]].join(historical.set_index(&#39;ds&#39;))<br><br>def calculate_forecast_errors(df_ts, prediction_size):<br><br>  df = df_ts.copy()<br>  df[&#39;e&#39;] = df[&#39;y&#39;] - df[&#39;yhat&#39;]<br>  df[&#39;p&#39;] = 100 * df[&#39;e&#39;] / df[&#39;y&#39;]<br>  predicted_part = df[-prediction_size:]<br><br>  error_mean = lambda error_name: np.mean(np.abs(predicted_part[error_name]))<br><br>  return{&#39;MAPE&#39;: error_mean(&#39;p&#39;), &#39;MAE&#39;: error_mean(&#39;e&#39;)}</pre><p>Vamos agora verificar o MAE e o MAPE de nossa série</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/618/1*dJ-X0d0LTfscIgt-xoRRJQ.png" /></figure><p>Um erro de 2% não parece tão grande, porém um erro absoluto na ordem de 1000, parece um tanto elevado. Vamos visualizar as diferenças entre as previsões e os valores reais:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*onyv3G6pFoeRByzkr5lpfQ.png" /></figure><h4>Transformando a série temporal em estacionária.</h4><p>Existem algumas técnicas para se transformar uma série temporal não estacionária em estacionária. Algumas destas técnicas podem ser vistas neste <a href="https://medium.com/ensina-ai/princ%C3%ADpios-b%C3%A1sicos-para-criar-previs%C3%B5es-de-s%C3%A9ries-temporais-e58c451a25b">artigo</a>. A técnica que iremos abordar aqui consiste em transformar os valores de y em seus respectivos logaritmos e a seguir subtraímos a média móvel de um determinado período em relação aos logaritmos.</p><pre># 1ª etapa: obter o log da TS<br># aplicando o log<br>df_log = np.log(df_ts)<br>ma_log = df_log.rolling(24).mean() #Obtendo a média móvel dos últimos 24 dias<br><br>fig, ax = plt.subplots(figsize=(12,8))<br>df_log.plot(ax=ax, color=&quot;b&quot;,legend=False)<br>ma_log.plot(ax=ax, color=&#39;r&#39;, legend=False)<br>plt.tight_layout()</pre><p>Plotando o gráfico da série temporal, com os logaritmos de y , juntamente com a média móvel de 24 dias:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9VasNfcejqrf9hPoSY9GXQ.png" /></figure><pre># subtraindo a média do log nos dados<br>df_sub = (df_log - ma_log).dropna()<br>ma_sub = df_sub.rolling(24).mean()<br>std_sub = df_sub.rolling(24).std()<br><br>fig, ax = plt.subplots(figsize=(12,8))<br>df_sub.plot(ax=ax, color=&#39;b&#39;, legend=False)<br>ma_sub.plot(ax=ax, color=&#39;r&#39;, legend=False)<br>std_sub.plot(ax=ax, color=&#39;g&#39;, legend=False)<br>plt.show();</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*ICu4pZWj577hIxLuaF8Ugw.png" /></figure><p>Pelo gráfico acima, percebe-se que a série aparenta ser estacionária, mas vamos agora aplicar novamente o teste ADF para termos certeza disto:</p><pre># repetindo o ADF<br>X_sub = df_sub.y.values<br><br># aplicando o ADF e imprimindo os resultados<br>result_sub = adfuller(X_sub)<br>print(&#39;Augmented Dickey–Fuller&#39;)<br>print(&#39;Statistical Test: {:.4f}&#39;.format(result_sub[0]))<br>print(&#39;P Value: {:.10f}&#39;.format(result_sub[1]))<br>print(&#39;Critical Values:&#39;)<br>for key, value in result_sub[4].items():<br> print(&#39;\t{}: {:.4f}&#39;.format(key, value))<br><br>------------------------------------<br>Augmented Dickey–Fuller<br>Statistical Test: -6.8574<br>P Value: 0.0000000016<br>Critical Values:<br> 1%: -3.4365<br> 5%: -2.8643<br> 10%: -2.5682</pre><p>Agora o valor-p está muito abaixo do valor α de 0,01. Com isso, podemos tranquilamente rejeitar a hipótese nula e assumir que esta série é estacionária.</p><h4>Fazendo previsões na série estacionária</h4><p>Agora vamos repetir todo o processo de predição agora aplicado nesta série</p><pre># definindo o tamanho da previsão<br>prediction_size = 30<br>train_df = df_log[:-prediction_size]<br><br># transformando no formato do Prophet<br>df_log.reset_index(inplace=True)<br><br># instanciando o modelo<br>m = Prophet()<br><br># treinando o modelo<br>m.fit(train_df)<br><br># fazer previsões<br>future = m.make_future_dataframe(periods=prediction_size)<br><br>forecast = m.predict(future)<br><br>forecast.head()</pre><p>Verificando os novos dados:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*ttWDMXAGEDPq0Gkj9nmRkQ.png" /></figure><p>Obtendo as medidas de desempenho:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/798/1*mkd8R6no0YX4dRbZcBQaZA.png" /></figure><p>Vejam como as medidas de desempenho melhoram signficativamente. O MAPE foi de 2,25% para 0,021%. Um resultado excepcional.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oIQQvMkXiEMsOn9V0MwcgA.png" /></figure><p>Só que agora, temos de voltar nossa série à escala original, para isso faremos uma transformação exponencial, que é o oposto da logarítmica:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/530/1*N6DcCnIGuXmpK2Xf5LIwDQ.png" /></figure><p>Por fim, vamos plotar um gráfico para visualizar a diferença entre os valores reais e os previstos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*RLDxs25lhmdRlWPyw5OLGA.png" /></figure><h3>Conclusões</h3><p>Neste projeto buscou-se modelar uma ferramenta para a previsão de vendas de uma loja de vinhos e foi constatado que a tarefa de administrar os estoques de uma revendedora de vinhos é uma tarefa bastante complexa que requer estratégias de longo e de curto prazo, e que e uma ferramenta para predição de vendas usando técnicas de aprendizado de máquina pode ajudar bastante nesta tarefa. A ferramenta que utilizamos para fazer as previsões foi o <em>Prophet</em>, desenvolvida pela equipe de desenvolvimento do Facebook.<br>A série temporal utilizada para nossa previsão não era estacionária, mas foi feita uma transformação logarítmica que a transformou em estacionária, daí foi feita comparação da qualidade das previsões nas duas séries, o que mostrou que o desempenho do <em>Prophet</em> foi incomparavelmente melhor quando a série é estacionária.</p><p>Clique <a href="https://github.com/marciusdm/dsnp/blob/main/projeto6_3/ProjetoTimeSeries.ipynb">aqui</a> para baixar o notebook utilizado neste projeto</p><p>Clique <a href="https://github.com/marciusdm/portfolio">aqui</a> para acessar meu portfolio profissional</p><p>Clique <a href="https://www.linkedin.com/in/marciusdm">aqui</a> para acessar meu perfil no Linkedin</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19a776f172d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Utilizando a ferramenta PyCaret em um experimento de classificação]]></title>
            <link>https://medium.com/@marciusdellano/utilizando-a-ferramenta-pycaret-em-um-experimento-de-classifica%C3%A7%C3%A3o-e6b56ff7f1b7?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6b56ff7f1b7</guid>
            <category><![CDATA[pycaret]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[automl]]></category>
            <category><![CDATA[classification]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Wed, 25 Oct 2023 02:24:50 GMT</pubDate>
            <atom:updated>2023-10-25T02:24:50.209Z</atom:updated>
            <content:encoded><![CDATA[<p>Este artigo discorrerá sobre o uso da ferramenta PyCaret em um experimento de classificação multiclasse para predição da saúde de fetos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/0*U3yCC5Pzq4X5-IB_" /><figcaption><a href="https://colab.research.google.com/corgiredirector?site=https%3A%2F%2Fbr.freepik.com%2Ffotos-gratis%2Fuma-mulher-gravida-de-trimestre_18641424.htm%23query%3Dultrassom%2520gravida%26position%3D13%26from_view%3Dkeyword%26track%3Dais">Imagem de rawpixel.com</a> no Freepik</figcaption></figure><p>O PyCaret possibilita, com poucas linhas de código, criar uma solução de machine learning. Em <a href="https://medium.com/@marciusdellano/automated-machine-learning-com-pycaret-17a87a5e3374">artigo</a> anterior já dei uma visão geral sobre esta ferramenta. Vamos falar um pouco do experimento a ser desenvolvido.</p><h3>O contexto do experimento</h3><p>Neste experimentos, iremos utilizar uma solução de <em>machine learning </em>para tentar traçar um diagnóstico da saúde de fetos, e com isso, reduzir as taxas de mortalidade infantil e materna. Para isso será utilizada uma base de dados com registros de exames de <a href="https://medicalway.com.br/blog/cardiotocografia-entenda-a-importancia-para-a-saude-do-bebe/">cardiotocografia</a> realizados em cerca de 2100 fetos.<br>O exame de cardiotocografia, também conhecido pela sigla CTG, avalia os sinais vitais do bebê durante as últimas semanas de gestão e indica se há necessidade de se antecipar o parto devido a alguma condição adversa tal como posicionamento inadequado do feto ou cordão umbilical ao redor do pescoço. É um procedimento não invasivo que monitora ao mesmo tempo os movimentos do feto, sua frequência cardíaca e as contrações no útero materno e dura cerca de 20 minutos.</p><p>Neste exame são levados em conta as seguintes variáveis:</p><ul><li>Frequência cardíaca fetal basal (FCF) — linha de base: é a Frequência cardíaca média, avaliada durante um certo intervalo de tempo. A FCF considerada normal é de 110 a 160 batimentos por minuto (bpm);</li><li>Variabilidade: oscilações ocorridas na frequência cardíacas. Podem ser microscilações (de curta duração) — variações batimento a batimento, detectada somente com CTGs computadorizadas — ou macroscilações, (variabilidade de longa duração): representa a diferença entre a maior e a menor FCF no intervalo de um minuto de exame;</li><li>Aceleração: são aumentos periódicos da FCF devido à atividade motora do feto ou contração uterina;</li><li>Desaceleração: quedas periódicas na FCF, podendo ser patológicas ou não. Normalmente estão relacionadas a contrações uterinas, mas também podem ser causadas por compressão no cordão umbilical.</li></ul><p>Os dados que serão utilizados neste projeto são de registros extraídos de exames CTG, os quais, são classificados, por obstetras peritos em três possíveis estados:</p><ul><li>Normal;</li><li>Suspeito;</li><li>Patológico.</li></ul><p>Conforme descrito em:</p><blockquote><em>Ayres de Campos et al. (2000) SisPorto 2.0 A Program for Automated Analysis of Cardiotocograms. J Matern Fetal Med 5:311–318</em></blockquote><p>Mais informações sobre estes dados podem ser vistas <a href="https://colab.research.google.com/corgiredirector?site=https%3A%2F%2Fwww.kaggle.com%2Fdatasets%2Fandrewmvd%2Ffetal-health-classification">aqui</a>.</p><h3>Análise exploratória dos dados</h3><p>O dados aqui utilizados foram obtidos na plataforma <a href="https://colab.research.google.com/corgiredirector?site=https%3A%2F%2Fwww.kaggle.com%2Fdatasets%2Fandrewmvd%2Ffetal-health-classification">Kaggle</a>. Ela contém 2126 linhas por 22 colunas, cujos significados são mostrados abaixo:</p><h4>Dicionário de dados</h4><ul><li><strong>baseline value</strong> (FHR): Freqüência cardíaca fetal basal (FCF);</li><li><strong>accelerations</strong>: número de acelerações por segundo nos batimentos cardiácos do feto;</li><li><strong>fetal_movement</strong>: número de movimentos fetais por segundo;</li><li><strong>uterine_contractions</strong>: número de contrações uterinas por segundo;</li><li><strong>light_decelerations</strong>: número de desacelerações leves no batimentos cardíacos fetais por segundo;</li><li><strong>severe_decelerations</strong>: número de desacelerações severas por segundo</li><li><strong>prolongued_decelerations</strong>: número de desacelerações prolongadas por segundo;</li><li><strong>abnormal_short_term_variability</strong>: Porcentagem de tempo com variabilidade anormal de curta duração;</li><li><strong>mean_value_of_short_term_variability</strong>: Valor médio de variabilidade de curta duração;</li><li><strong>percentage_of_time_with_abnormal_long_term_variability</strong>: Porcentagem de tempo com variação anormal de longa duração;</li><li><strong>mean_value_of_long_term_variability</strong>: Valor médio de variabilidade de longa duração</li><li><strong>histogram_width</strong>: diferença entre o valor mínimo e o valor máximo do histograma de batimentos cardíacos criado para cada registro;</li><li><strong>histogram_min</strong>: valor mínimo no histograma;</li><li><strong>histogram_max</strong>: valor máximo no histograma;</li><li><strong>histogram_number_of_peaks</strong>: número de picos no histograma do exame;</li><li><strong>histogram_number_of_zeroes</strong>: número de zeros no histograma;</li><li><strong>histogram_mode</strong>: valor mais frequente no histograma (moda);</li><li><strong>histogram_mean</strong>: média no histograma;</li><li><strong>histogram_median</strong>: mediana no histograma;</li><li><strong>histogram_variance</strong>: variância no histograma;</li><li><strong>histogram_tendency</strong>: comportamento do histograma. Os possíveis valores são : -1: assimetria negativa (mais concentração de valores mais altos); 0: simétrico; 1: assimetria positiva (maior concentração de valores mais baixos);</li><li><strong>fetal_health</strong>: variável alvo. Valores possíveis: 1 (normal), 2 (suspeito) e 3 (patológico)</li></ul><h4>Obtendo os dados</h4><p>Exibindo as cinco primeiras linhas através do comando</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tWQZ71y3h4oB0PtS1o8QDA.png" /><figcaption>Exibindo as cinco primeiras linhas do conjunto de dados — 1/4</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nf41fgC2eJBr8b471v-7XA.png" /><figcaption>Exibindo as cinco primeiras linhas do conjunto de dados —21/4</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nf41fgC2eJBr8b471v-7XA.png" /><figcaption>Exibindo as cinco primeiras linhas do conjunto de dados — 3/4</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*wyC991vtIg96a0K5rU9TNA.png" /><figcaption>Exibindo as cinco primeiras linhas do conjunto de dados — 4/4</figcaption></figure><h4>Exibindo os tipos de dados das colunas</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/482/1*o5yfM2lobbbARMmzqfjl1g.png" /></figure><h4>Verificando se existem valores nulos</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/590/1*DEICBP4g1U0QT3iH0lktyw.png" /></figure><p>Não existem valores nulos no conjunto de dados</p><h4>Efetuando algumas transformações</h4><p>Embora todas as colunas sejam decimais, grande parte delas exibe somente valores inteiros. Daí foi feito um processo para converter estas colunas para inteiros:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6BbOuN8DnesroyGry2wcnQ.png" /><figcaption>Convertendo algumas colunas para inteiros</figcaption></figure><p>Foi verificado também que as colunas que mostram quantidades de eventos por segundo, tais como accelerations e fetal_movement apresentam valores bem próximos de zero, então foi feito um processo para convertê-las em quantidades de eventos por hora. Para isso, seus valores foram multiplicados por 3600:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1PBLGcwy0XxvLJYVnLPL2g.png" /></figure><h4>Traçando uma visão geral dos dados</h4><p>Vamos agora fazer mais algumas análises antes de passarmos à próxima etapa. Primeiramente, existem 3 colunas, que embora contenham números, podem ser consideradas categóricas, por possuirem poucos valores distintos. São elas fetal_health , histogram_tendency e severe_decelerations</p><p>Segue abaixo um gráfico com a frequência de cada um dos valores destas colunas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gDL3_pnM0keHDVZ0fOjwvw.png" /></figure><p>Na maioria dos registros, o feto é considerado saudável (77,8% do total). Os registros considerados suspeitos representam 13,9% do total, e os patológicos constituem os restantes 8,3%. Portanto, a variável alvo está desbalanceada, o que ensejará um pré-processamento na base de dados antes de se aplicar os modelos de aprendizado de máquina.</p><p>Quanto às demais colunas segue abaixo um resumo estatístico e na sequencia, histogramas para cada uma delas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XeLg8FDmVcecPMCvRqw80g.png" /><figcaption>Sumário estatístico das colunas numéricas (1/2)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QTIte5wB-FvS3-Z2K_TMGQ.png" /><figcaption>Sumário estatístico das colunas numéricas (2/2)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ovJKJVn1DjDQx-UNsxmhCw.png" /><figcaption>Histograma das variáveis numéricas</figcaption></figure><h4>Verificando correlações entre as variáveis</h4><p>Vamos agora verificar correlações entre as variáveis, para isto iremos plotar uma matriz de correlação</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*4dZvq2MKnaUp2V8sfAktqQ.png" /><figcaption>Correlações entre as variáveis</figcaption></figure><p>Percebe-se que as colunas baseline_value , histogram_mode, histogram_meane histogram_median são fortemente correlacionadas</p><p>Agora vamos ver de forma um pouco mais detalhada as colunas que se correlacionam mais com nossa variável alvo — fetal_health :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*RvpdmLFKmmq7FgT_XkcHNg.png" /></figure><p>As variáveis que mais se correlacionam com a variável alvo — fetal_health são prolongued_decelerations, abnormal_short_term_variability e percentage_of_time_with_abnormal_long_term_variability . O que faz sentido, pois desacelerações em variações anormais são indícios de algo não está bem com o feto.</p><h4>Observando diferenças nos perfis de casos saudáveis, suspeitos e patológicos</h4><p>Os gráficos a seguir mostram o comportamento das variáveis de acordo com o estado de saúde do feto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TVqOc35XeUft4Ze87UHT-Q.png" /></figure><p>Pelos gráficos acima pode-se observar que são indícios fortes de haver alguma patologia no feto:</p><ul><li>não possuir acelerações nos batimentos cardíacos ( repare no gráfico correspondente à variável accelerations os casos patológicos e suspeitos estão com valores concentrados próximos de zero);</li><li>apresentar desacelerações;</li><li>variabilidade anormal nos batimentos;</li><li>apresentar poucas contrações uterinas;</li><li>grandes variações nos batimentos cardíacos, indicados pala variável histogram_variance</li></ul><p>Além disso, registros tidos como suspeitos apresentam batimentos cardíacos mais acelerados como se pode atestar pelos gráficos das variáveis histogram_mean e histogram_median. Repare que a média e a mediana são maiores nestes casos.</p><p>Obs: no fim deste artigo há um link para baixar o notebook com todas as análises feitas</p><h3>Construindo os modelos de machine learning</h3><p>Agora sim, vamos instanciar a ferramenta PyCaret p/ criação de modelos de ML que irão classificar o estado de saúde dos fetos do conjunto de dados.</p><h4>Dividindo os dados em treino e teste</h4><p>Primeiramente faremos a divisão do conjunto de dados em treino e teste. Serão separados 10% para fazer o teste do modelo no final do experimento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/793/1*zV3dSgKloIIOykfUpGRPfg.png" /></figure><h4>Configurando o PyCaret</h4><p>Agora iremos configurar a ferramenta PyCaret. Não iremos dar detalhes aqui de todo o processo de utilização, pois já foi escrito outro <a href="https://medium.com/@marciusdellano/automated-machine-learning-com-pycaret-17a87a5e3374">artigo</a> dando mais informações do fluxo de trabalho com o PyCaret.<br>Primeiramente, será feito o <em>setup, </em>que<em> </em>prepara ambiente de execução do PyCaret e configura uma sequência de procedimentos que deixa os dados pronto para uso pelos modelos de aprendizado de máquina:</p><pre># configurando o ambiente<br># O parâmetro session_id serve apenas para garantir que os resultados obtidos são sempre os mesmos a cada execução<br>reg = setup(data = train, target = &#39;fetal_health&#39;,<br>            transformation = True,<br>            fix_imbalance = True,<br>            session_id=1)</pre><p>Acima, definimos os dados que vamos utilizar, no caso, o conjunto de treino separado na etapa anterior. Além disso utilizaremos o parâmetro transform para deixar as colunas com uma distribuição aproximadamente normal. Mais detalhes podem ser vistos <a href="https://pycaret.gitbook.io/docs/get-started/preprocessing/scale-and-transform">aqui</a> e <a href="https://medium.com/@patricklcavins/using-scipys-powertransformer-3e2b792fd712">aqui</a>. Também utilizaremos o parâmetro fix_imbalance para balancear os dados, de modo a deixar cada um dos três valores possíveis da variável alvo, com um número aproximadamente igual de registros. Por padrão a técnica de balanceamento é a de <em>over-fitting</em> , que consiste na geração de registros das classes minoritárias. O setup gera o grid abaixo, com os parâmetros empregados pelo PyCaret:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*F0bkGJA6yS3_k2o79ZpwNQ.png" /></figure><p>Repare que o conjunto de dados ficou maior, isto é devido ao processo de balanceamento que cria novos registros das classes minoritárias. Observe também que, pelo item target mapping, o PyCaret converteu os valores da coluna alvo (fetal_health), sendo que o valor 1 (normal) foi convertido para 0, 2 (patológico) para 1 e 3 (suspeito) foi convertido 2.</p><h4>Comparando os modelos de machine learning</h4><p>Vamos agora invocar a função compare_models para comparar o desempenho de diversos modelos de <em>machine learning</em> para classificação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*_LbE3c5PMfsJ4h4A5MWJmQ.png" /></figure><p>O modelo que saiu melhor aqui foi o <em>Light Gradient Boost Machine. </em>Então iremos criar uma instância deste modelo. Para isso o PyCaret usa uma função chamada create_model que utiliza como parâmetro uma string que corresponde ao modelo a ser criado. Para este modelo a string é ´lightgbm’</p><pre>lightgbm = create_model(&#39;lightgbm´)</pre><p>Esta função cria o modelo e o avalia usando uma validação cruzada estratificada. Assim como o compare_models, a saída é uma tabela de pontuação que mostra as métricas de desempenho para classificação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/483/1*DAad_lhyEgHdeiK89afdzA.png" /></figure><h4>Efetuando um ajuste fino do modelo</h4><p>Vamos agora tentar achar uma combinação de hiperparâmetros que melhoram o desempenho do modelo vencedor. Para isto o PyCaret disponibiliza a função tune_model . Iremos passar dois parâmetros para esta função: o modelo a ser melhorado (parâmetro obrigatório) e o parâmetro optimize , que informa qual métrica deve ser tomada como base para avaliação de desempenho. Neste experimento a métrica escolhida foi a acurácia</p><pre>tuned_lightgbm = tune_model(lightgbm,optimize=&quot;Accuracy&quot;)</pre><p>Como saída, este comando mostra os resultados da validação cruzada com a melhor combinação de hiperpârametros:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/432/1*8iJU2yQsdgm9x5GAY2277g.png" /></figure><p>Repare que o modelo original se saiu melhor que o modelo ajustado. Acurácia de 93,9% do primeiro contra 93,3% do segundo. Quando isto acontece o PyCaret exibe a mensagem abaixo:</p><blockquote>Original model was better than the tuned model, hence it will be returned. NOTE: The display metrics are for the tuned model (not the original one).</blockquote><p>Quando isso acontece, é interessante fazer o ajuste fino com o segundo , e talvez também com o terceiro modelo melhor classificado. Em <a href="https://medium.com/@marciusdellano/utilizando-a-ferramenta-pycaret-em-experimentos-de-regress%C3%A3o-95e923d65648">artigo </a>anterior, que discorre sobre um experimento de regressão, foi feito ajuste fino com o segundo e o terceiro colocados, e foram obtidos resultados melhores com o este último. Porém neste experimento, como os resultados já foram expressivos, não sentimos necessidade de fazer isto. Então iremos prosseguir com o modelo lightgbm</p><h4>Visualizando o modelo vencedor</h4><p>Iremos agora visualizar o desempenho do melhor modelo através do comando plot_model , já explicado em <a href="https://medium.com/@marciusdellano/automated-machine-learning-com-pycaret-17a87a5e3374">artigo</a> introdutório sobre o PyCaret.</p><ul><li>Visualizando os hiperparâmetros utilizados pelo modelo:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/269/1*_Mg1XFcW_qkm5tdi7lGnzA.png" /><figcaption>Hiperparâmetros</figcaption></figure><ul><li>Visualizando o <em>pipeline </em>de pré-processamento do modelo:</li></ul><pre>plot_model(lightgbm,&#39;pipeline&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TAHFBGBWHbO6my1FBQ5SDQ.png" /><figcaption>Pipeline</figcaption></figure><ul><li>Gráfico de importância das variáveis (<em>features):</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*5b5S_GE_gi9__ILQFipO7w.png" /></figure><p>Como era de se esperar as colunas que indicam alguma anormalidade são as que mais contribuíram para fazer as previsões.</p><ul><li>Gráfico de área sobre a curva (AUC):</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*Q42p1GXxC1WsnYe7wFWnaQ.png" /></figure><p>O gráfico indica que o modelo se saiu muito bem nas previsões. Mais tarde vamos fazer os testes com dados nunca vistos para verificar se não houve sobreajuste.</p><ul><li>Matriz de confusão:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/753/1*jJ-QV1o6LmDfWumFP1V55Q.png" /></figure><h3>Fazendo previsões</h3><p>Chegou a hora de testar nosso modelo, primeiro iremos fazer previsões nos dados de treino e comparar com resultados obtidos com a validação cruzada. A seguir faremos o teste nos 10% dos dados que foram separados no início do experimento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/632/1*sEYjD5bYBNcE23pKDkQ2tA.png" /></figure><p>A acurácia com o modelo executando sobre os dados de teste ficou em 95,4%. Um pouco maior que o obtido durante o processo de validação cruzada, que ficou em 94,6%. Isto indica que o modelo está bem ajustado aos dados.</p><h4>Finalizando o modelo</h4><p>Chegou a hora de finalizar o modelo para deixá-lo pronto para salvar e fazer o deploy:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/1*aX3r89nWk1cR5h-Ir39o7Q.png" /></figure><p>Ao executar o comando print no modelo conseguimos visualizar todas suas etapas de configuração e pré-processamento.</p><h4>Fazendo previsões em dados novos</h4><p>Agora vamos fazer as previsões nos dados que foram separados antes do setup do Pycaret:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AZD78GUqIVSURVHhVnmeKw.png" /></figure><p>As métricas de desempenho sofreram poucas alterações. A acurácia, por exemplo, ficou em 95,7%, não muito diferente dos resultados obtidos anteriormente, o que indica que o modelo acerta a grande maioria dos resultados.</p><p><strong>Atenção: </strong>a discrepância entre os valores de fetal_health e prediction_label se deve ao processo de conversão descrito pelo parâmetro target mapping no setup do PyCaret. Lembre-se que na coluna fetal_health, 1 foi convertido para 0, 2 para 1 e 3 para 2.</p><h4>Salvando o modelo</h4><p>Por fim, iremos salvar nosso modelo de modo a utilizá-lo posteriormente para novas previsões. A biblioteca PyCaret inclusive oferece suporte para as plataformas AWS, Google Cloud e Microsoft Azure, permitindo salvar seu modelo em nuvem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/591/1*sS_ezyVLaBxo-CbFaz9zNA.png" /></figure><p>O PyCaret mostra todo o <em>pipeline</em> de pré-processamento do modelo ao executar o comando save_model .</p><h3>Conclusões</h3><p>A bibilioteca PyCaret simplica bastante o processo de criar e testar modelos de <em>machine learning</em>. Tarefas que demandariam muitas linhas de código são feitas com poucos comandos, dando agilidade à execução de projetos de <em>data science. </em>Compare, por exemplo, com o experimento descrito no artigo “<a href="https://medium.com/@marciusdellano/churn-prediction-para-uma-empresa-de-telecomunica%C3%A7%C3%B5es-c4d5841baa95">Churn Prediction para uma empresa de telecomunicações</a>”, em que os modelos de ML foram criados e testados manualmente.</p><p>Vimos também que o melhor modelo dentre os testados por esta ferramenta, obteve um índice de acertos de mais de 95%, um desempenho bastante expressivo. Isto torna a solução de machine learning como uma excelente ferramenta para tentar prever problemas de saúde dos bebês, com índice de acertos bastante alto.</p><p>Clique <a href="https://github.com/marciusdm/dsnp/blob/main/projeto6_2/ProjetoClassificacaoPyCaret.ipynb">aqui</a> para acessar o notebook utilizado neste experimento</p><p>Confira também meu artigo introdutório sobre o PyCaret: “<a href="https://medium.com/@marciusdellano/automated-machine-learning-com-pycaret-17a87a5e3374">Automated Machine Learning com PyCaret</a>”</p><p>Veja também meu artigo “<a href="https://medium.com/@marciusdellano/utilizando-a-ferramenta-pycaret-em-experimentos-de-regress%C3%A3o-95e923d65648">Utilizando a ferramenta PyCaret em experimentos de regressão</a>”</p><p>Clique <a href="https://github.com/marciusdm/portfolio">aqui</a> para acessar meu portfolio profissional</p><p>Clique <a href="https://www.linkedin.com/in/marciusdm">aqui</a> para acessar meu perfil no Linkedin</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6b56ff7f1b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Utilizando a ferramenta PyCaret em experimentos de regressão]]></title>
            <link>https://medium.com/@marciusdellano/utilizando-a-ferramenta-pycaret-em-experimentos-de-regress%C3%A3o-95e923d65648?source=rss-52f1cc150aaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/95e923d65648</guid>
            <category><![CDATA[regression-modeling]]></category>
            <category><![CDATA[pycaret]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Marcius Dellano]]></dc:creator>
            <pubDate>Thu, 19 Oct 2023 23:01:09 GMT</pubDate>
            <atom:updated>2023-10-25T03:07:29.741Z</atom:updated>
            <content:encoded><![CDATA[<p>Neste artigo iremos abordar um experimento de regressão utilizando a ferramenta de Automated Machine Learning chamada PyCaret. Tal experimento consiste na previsão de valores a serem pagos por clientes de por um seguro de saúde.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZCqZt67_Ydq1cCHV" /><figcaption>Photo by <a href="https://unsplash.com/@homajob?utm_source=medium&amp;utm_medium=referral">Scott Graham</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>O PyCaret possibilita, com poucas linhas de código, criar uma solução de machine learning. Em <a href="https://medium.com/@marciusdellano/automated-machine-learning-com-pycaret-17a87a5e3374">artigo</a> anterior já dei uma visão geral sobre esta ferramenta. Vamos falar um pouco do experimento a ser desenvolvido.</p><h3>O contexto do experimento</h3><p>Conforme já foi dito, trata-se de prever os valores pagos por clientes de uma companhia que oferece seguros de saúde. No jargão das seguradores, o valor que o cliente paga para ter direito a uma apólice de seguros chama-se <em>prêmio</em>. O conjunto de dados que iremos utilizar em nossos testes foi obtido na plataforma <a href="https://colab.research.google.com/corgiredirector?site=https%3A%2F%2Fwww.kaggle.com%2Fannetxu%2Fhealth-insurance-cost-prediction">Kaggle</a>. Infelizmente, não há mais informações a respeito destes dados, nem se são reais ou fictícios. É um conjunto de dados bastante simples com apenas 7 colunas e 1338 registros. <br>De fato, o cálculo de prêmios é uma operação bastante complexa, em que os clientes se submetem a entrevistas, respondem a longos questionários a respeito de seus históricos de tratamentos de saúde realizados, doenças preexistentes, cirurgias já realizadas, entre outras para traçar um perfil e com base neste perfil, chegar ao prêmio a ser pago. Entretanto, uma solução de <em>machine learning</em> pode auxiliar as seguradoras a reduzir a complexidade deste cálculo.</p><h3>Análise exploratória dos dados</h3><h4>Dicionário de dados</h4><p>Conforme já dito anteriormente o conjunto de dados apresenta 7 colunas:</p><ul><li>age: idade do cliente, nesta base de dados, varia de 18 a 64 anos;</li><li>sex: sexo masculino ou femininoo. Nesta base há um equilíbrio entre</li><li>os sexos, sendo cerca de 50,5% dos clientes sendo do sexo masculino e 49,5% do sexo feminino;</li><li>bmi: Índice de massa corporal, que corresponde ao peso dividido pelo quadrado da altura. Os registros apontam uma média de 30,7 com valor mínimo de 15,96 e valor máximo 53,13;</li><li>children: quantidade de filhos do cliente. Os registros variam entre 0 e 5, com um média de 1,09 filhos por cliente;</li><li>smoker: se fumante ou não. 20,5% dos clientes são fumantes;</li><li>region: onde o cliente mora. Há apenas quatro valores distintos: <em>southeast, southwest</em>,<em> northeast</em> e<em> northwest</em></li><li>charges: prêmio pago pelo cliente. Varia entre $1121 e $63770 com um valor médio de $13270</li></ul><h4>Visualizando os dados</h4><p>A seguir, vamos visualizar algumas tabelas e gráficios gerados pelo pacote <a href="https://github.com/ydataai/ydata-profiling">ydata-profiling</a>, antigo pandas-profiling. Uma poderosa ferramenta para análise exploratória de dados:</p><ul><li>Visão geral dos dados</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/1*qCAL9e-GLdeOyVI-_gzdUw.png" /></figure><ul><li>Dados estatísticos das colunas</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1aqROiJBkkUcTjiqIdGm8A.png" /><figcaption>Coluna <em>age (idade)</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*40B5bDElIyuDF5otAcnaBQ.png" /><figcaption>Coluna sex (sexo)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oT_RJ4jJmz2K40Rtwe-nug.png" /><figcaption>Coluna bmi (índice de massa corporal)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*k91cOVvsSL2dL2ggopD48A.png" /><figcaption>Coluna children (nº de filhos)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AFWkm62ezva1kiexIL_bpA.png" /><figcaption>Coluna smoker (fumante)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*27TckukGw1lS3VpZA5Akeg.png" /><figcaption>Coluna region (região)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*TpIHHUH_uHr4S3DKMSSGxg.png" /><figcaption>Coluna charges (prêmio)</figcaption></figure><ul><li>Correlações entre as variáveis:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/1*sjwOXrQ4Oh32ilXyVr92TQ.png" /><figcaption>Correlações</figcaption></figure><h4>Conclusões da análise exploratória</h4><p>Analisando os elementos acima pode-se depreender que:</p><ul><li>não existem valores nulos;</li><li>como era de se esperar, a idade e o fato de ser fumante possuem uma forte influência no valor a ser pago pelo segurado. Já as outras variáveis, como sexo, índice de massa corporal e local de moradia têm um peso menor;</li><li>mais da metade dos segurados possui um índice de massa corporal acima de 30, o que é considerado como obeso. Menos de 1/4 possui um índice de massa corporal considerado como o ideal, que é entre 20 e 25;</li><li>a proporção entre homens e mulheres é bastante equilibrada;</li><li>pouco mais 20% dos segurados é fumante. Embora não saibamos da origem destes dados, é notório que há uma tendência de queda ocasionada pela campanhas antitabagistas promovidas ao longo das últimas décadas;</li><li>a maioria dos valores pagos é de no máximo $10.000, apenas alguns seguros excedem os $50.000.</li></ul><h3>Fazendo as previsões</h3><p>Basicamente um experimento de regressão utilizando o PyCaret segue o segunte fluxo de trabalho:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/988/1*6NwSvhMl7GQRc-Qg_5P_2g.png" /></figure><p>No meu artigo “<a href="https://medium.com/@marciusdellano/automated-machine-learning-com-pycaret-17a87a5e3374">Automated Machine Learning com PyCaret</a>” há descrições um pouco mais detalhadas sobre cada uma destas etapas. Aqui só irei expor o que foi feito, sem perder tempo com descrições mais detalhadas. <br>Antes de mais nada temos de separar os conjunto de dados em treino e validação. Digo validação por que irei separar 10% dos dados para validação final após a finalização do modelo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/479/1*i2lYKsq6T-evV46KN2m9tQ.png" /></figure><p>O conjunto de dados testsó irá ser utilizado ao final deste experimento. Agora iremos fazer o setup do PyCaret</p><h4>Setup do PyCaret</h4><pre># configurando o ambiente<br># O parâmetro session_id serve apenas para garantir que os resultados obtidos são sempre os mesmos a cada execução<br>reg = setup(data = train, target = &#39;charges&#39;, session_id=1)</pre><p>Eis o conjunto de parâmetros utilizados pelo PyCaret após o setup:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/370/1*qBEQrpvq7Byp098PWbh6zw.png" /><figcaption>Saída gerada pelo setup do PyCaret</figcaption></figure><p>A saída acima mostra que o PyCaret irá fazer um experimento de regressão (item target_type ) e aumentou o número de colunas de 7 para 10, fazendo codificação nas colunas categórias (leia meu artigo “<a href="https://medium.com/@marciusdellano/lidando-com-vari%C3%A1veis-categ%C3%B3ricas-em-machine-learning-833dc0bd391d">Lidando com variáveis categóricas em Machine Learnin</a>g” para saber mais sobre métodos de codificação). Além disso, será aplicada validação cruzada com 10 dobras (parâmetro Fold Number).</p><p>Mais algumas informações adicionais sobre as linhas acima:</p><ul><li><em>Original Data</em>: Mostra o tamanho do conjunto de dados original, assim como o passamos.</li><li><em>Missing Values</em>: Mostrará como True quando houver dados ausentes no conjunto recebido.</li><li><em>Numeric Features</em>: Número de features inferidas como numéricos.</li><li><em>Categorical Features</em>: Número de features inferidas como categóricas.</li><li><em>Transformed Train Set </em>: Mostra o shape do conjunto de treino. Repare que o conjunto original é (1204,7), mas foi transformado em (842, 10) para o conjunto de treino. O número de features cresceu de 14 para 23 por causa do encoding feito nas variáveis categóricas.</li><li><em>Transformed Test Set</em>: Mostra o shape do conjunto de teste/validação. O split é feito na proporção padrão 70/30, que pode ser mudada usando o parâmetro train_size no setup.</li></ul><h4>Comparando modelos de regressão</h4><p>Nesta etapa invocaremos o método compare_models para testar o desempenho de diversos modelos de regressão, dos mais utilizados. Ao final deste teste o PyCaret mostra o resultado em um <em>grid</em>.</p><p>Para regressão as medidas mostradas são as seguintes:</p><ul><li>MAE — Mean Absolute Error mostra a média de erro em valores absolutos.</li><li>MSE — Mean Squared Error, Erro Quadrático Médio</li><li>RMSE — Root Mean Squared Error, Raiz do Erro Quadrático Médio</li><li>R2 — Coefficient of Determination R2 Score</li><li>RMSLE — Root Mean Squared Log Error</li><li>MAPE — Mean Absolute Percentage Error mostra a média do erro absoluto em valores percentuais.</li></ul><p>Por padrão o PyCaret ordena os modelos por R², do melhor para o pior, mas isto pode ser alterado pelo parâmetro sort . Por exemplo, se quisermos que o PyCaret retorne os modelos ordenados pelo RMSE basta invocar o comando compare_models(sort=&quot;RMSE&quot;). Neste experimento iremos invocar este comando com as opções padrão, retornando resultados pelo R²:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/868/1*gYqs0BPsJt62BezO6V2EyQ.png" /></figure><p>O melhor modelo foi o <em>Gradient Boost Regresssor</em>, como o compare_models não retorna nenhum modelos temos de instanciá-lo usando o método create_model()</p><h4>Criando uma instância do melhor modelo</h4><p>O melhor modelo foi o Gradient Boosting, uma técnica do tipo <em>ensemble</em>, que utiliza métodos aprendizes fracos que combinados produzem um aprendiz forte. Para isso, cada método ‘fraco’ é executado em sequência e tenta reduzir o erro gerado pelo método executado anteriormente, tendo como referência uma medida denominada de erro residual.<br>Primeiramente vamos criar o modelo. Para isto utilizamos o método create_model passando como parâmetro um código, que identifica o método (no caso do Gradient Boosting é &#39;gbr&#39;). Ao final da execução o PyCaret mostra os resultados dos experimentos de validação cruzada:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*XTsRwbv4V3XtcNN43lShZQ.png" /></figure><h4>Tuning do modelo</h4><p>Vamos agora pegar o método que se saiu melhor e fazer um ajuste fino usando a função tune_model() . Neste experimento irei ordenar as medições pelo RMSE (Raiz do Erro Quadrático Médio):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e8AmpWo3r_kZk6aKMtKwXQ.png" /></figure><p>Veja que o ajuste fino não gerou medidas melhores que a configuração padrão de hiperparâmetros. Por exemplo, o RMSE do modelo original ficou em 4545.3965, ao passo que no modelo ajustado ficou em 4642.4066. Então irei proceder de forma um tanto diferente aqui. Serão selecionados dentre os outros modelos, segundo e o terceiro melhores classificados e fazer ajuste fino neles. Os modelos são Light Gradient Boosting e Random Forest respectivamente.</p><pre># Irei omitir as saídas destes comandos, mas você baixar o notebook <br># utilizado neste artigo através de link no final deste.<br>lightgbm = create_model(&#39;lightgbm&#39;) #RMSE: 4838.4064<br>rf = create_model(&#39;rf&#39;) # RMSE: 4847.0754<br></pre><p>Agora iremos executar um ajuste fino destes dois modelos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*w9QukImSxC1YoDgr2sRKUw.png" /><figcaption>Ajuste fino do modelo Random Forest</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*9Lg6tKozwDGlp02bIiScYQ.png" /><figcaption>Ajuste fino do modelo Light Gradient Boosting</figcaption></figure><p>Repare que o modelo ajustado do Random Forest foi o que se saiu melhor (RMSE: 4508.5559, lembre-se que quanto menor esta medida, melhor é o desempenho do modelo). Portanto é este modelo que será utilizado nas próximas etapas</p><h4>Analisando o melhor modelo</h4><p>O PyCaret oferece muitos recursos para visualizar o desempenho dos modelos de machine learning. Estes recursos podem ser acessados pela função plot_model() do PyCaret, cuja sintaxe é:</p><pre>plot_model(modelo_ml,plot=&#39;&lt;tipo_plot&gt;&#39;)<br></pre><p>onde:</p><ul><li>modelo_ml : modelo previamente criado com o comando create_model()a ser visualizado;</li><li>&lt;tipo_plot&gt;: varia de acordo com o tipo de experimento. Para regressão os valores são: ‘pipeline’, ‘residuals_interactive’, ‘residuals’, ‘error’, ‘cooks’, ‘rfe’, ‘learning’, ‘vc’, ‘manifold’, ‘feature’, ‘feature_all’, ‘parameter’, ‘tree’. Mais informações podem ser vistas <a href="https://pycaret.readthedocs.io/en/latest/api/regression.html#pycaret.regression.plot_model">aqui</a></li></ul><p>Vamos mostrar alguns dos plots a seguir:</p><ul><li>plot_model(tuned_rf, plot=”pipeline”): pipeline de pré-processamento do modelo</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C7sCMXTjmQpygf9_2p6ZBg.png" /><figcaption>Pipeline do pré-processamento do modelo ‘tuned_rf’</figcaption></figure><ul><li>plot_model(tuned_rf, plot=”parameter”): hiperparâmetros utilizados pleo modelo</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/341/1*EmPllrgcnafR2OyxbfFRBQ.png" /><figcaption>Hiperparâmetros utilizados</figcaption></figure><ul><li>plot_model(tuned_rf, plot=”feature”) : <em>feature importance</em> se refere a técnicas que medem a importância que cada uma das variáveis teve no cálculo da previsão. Neste caso, a variável <em>smoker</em> foi a que teve o maior peso, seguido por <em>bmi</em> (índice de massa corporal)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/827/1*5u9VFwRPPIYE8Fp8th_mIA.png" /><figcaption>A importância de cada coluna na previsão dos prêmios</figcaption></figure><ul><li>plot_model(tuned_rf, plot=”residuals”)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*L254O7QLt6yBuWq337Ef7A.png" /><figcaption>Gráfico residual para o modelo de regressão.</figcaption></figure><p>Ao final deste artigo deixarei um link para download do notebook utilizado neste experimento.</p><h4>Fazendo previsões</h4><p>Chegou a hora de testar nosso modelo, primeiro iremos fazer previsões nos dados de treino e comparar com resultados obtidos com a validação cruzada. A seguir faremos o teste nos 10% dos dados que foram separados no início do experimento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*tNzlz69dXkoQ1AwWWestVQ.png" /></figure><p>O RMSE do conjunto de testes ficou em 4804, um desempenho não muito diferente do RMSE da validação cruzada que foi de 4508.</p><h4>Finalizando o modelo</h4><p>Chegou a hora de finalizar o modelo para deixá-lo pronto para salvar e fazer o deploy:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/901/1*hDWG6Oe2ppXEVYfWsvvYvA.png" /></figure><p>Repare que o modelo finalizado contém a sequência de todos os procedimentos de pré-processamento efetuados</p><h4>Fazendo previsões em dados novos</h4><p>Agora iremos utilizar os dados de validação, separados no começo do experimento e verificar como o modelo se comporta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/741/1*w7XiOIEDxIlAzUJd0rAr8A.png" /></figure><p>Repare que o RMSE até teve uma pequena melhora, saindo de 4508 para 4332. Note também o acréscimo da coluna prediction_label com os valores previstos pelo modelo. Isto indica que nosso modelo é capaz de prever razoavelmente o valor dos prêmios dos seguros.</p><h4>Salvando o modelo</h4><p>Por fim, iremos salvar nosso modelo de modo a utilizá-lo posteriormente para novas previsões. A biblioteca PyCaret inclusive oferece suporte para as plataformas AWS, Google Cloud e Microsoft Azure, permitindo salvar seu modelo em nuvem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*zdX8xXdenid2Egdr-z4oYA.png" /></figure><h3>Conclusões</h3><p>A bibilioteca PyCaret simplica bastante o processo de criar e testar modelos de <em>machine learning</em>. Tarefas que demandariam muitas linhas de código são feitas com poucos comandos, dando agilidade à execução de projetos de <em>data science.<br></em>Vimos também que nosso modelo de regressão se saiu razoavelmente bem, embora existam algumas disparidades devido ao número pequeno de variáveis utilzadas, apenas 6.<br>Acrescentando-se mais variáveis, o modelo certamente será mais preciso e isso pode fazer com que uma solução de <em>machine learning</em> seja interessante para as companhias de seguros, com o intuito de agilizar o processo de cálculos de prêmios.</p><p>Clique <a href="https://github.com/marciusdm/dsnp/blob/main/projeto6_1/ProjetoRegressaoPyCaret.ipynb">aqui</a> para acessar o notebook utilizado neste experimento</p><p>Confira também meu artigo introdutório sobre o PyCaret: “<a href="https://medium.com/@marciusdellano/automated-machine-learning-com-pycaret-17a87a5e3374">Automated Machine Learning com PyCaret</a>”</p><p>Veja também meu artigo “<a href="https://medium.com/@marciusdellano/utilizando-a-ferramenta-pycaret-em-um-experimento-de-classifica%C3%A7%C3%A3o-e6b56ff7f1b7">Utilizando a ferramenta PyCaret em um experimento de classificação</a>”</p><p>Clique <a href="https://github.com/marciusdm/portfolio">aqui</a> para acessar meu portfolio profissional</p><p>Clique <a href="https://www.linkedin.com/in/marciusdm">aqui</a> para acessar meu perfil no Linkedin</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95e923d65648" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>