<?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 Alexandre #ále on Medium]]></title>
        <description><![CDATA[Stories by Alexandre #ále on Medium]]></description>
        <link>https://medium.com/@alexandre-oliveira?source=rss-91704229bd43------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KjANvjp_5LZYaOiLEuko4A.jpeg</url>
            <title>Stories by Alexandre #ále on Medium</title>
            <link>https://medium.com/@alexandre-oliveira?source=rss-91704229bd43------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:21:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alexandre-oliveira/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[Mochila ilimitada: um estudo de caso sobre como maximizar o lucro]]></title>
            <link>https://alexandre-oliveira.medium.com/mochila-ilimitada-um-estudo-de-caso-sobre-como-maximizar-o-lucro-575d78dd32b3?source=rss-91704229bd43------2</link>
            <guid isPermaLink="false">https://medium.com/p/575d78dd32b3</guid>
            <category><![CDATA[programação-dinâmica]]></category>
            <category><![CDATA[ciencia-de-dados]]></category>
            <category><![CDATA[mochila]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alexandre #ále]]></dc:creator>
            <pubDate>Tue, 14 Mar 2023 03:17:22 GMT</pubDate>
            <atom:updated>2023-03-20T05:34:38.135Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7NfPSMXFP_w3pOCcyZXZ2g.png" /><figcaption>Fonte: Imagem ilustrativa do próprio estudo de caso (2.0)</figcaption></figure><h4>Objetivo</h4><p>Maximizar o lucro.</p><p><strong>Disclaimer:</strong> este é o segundo artigo técnico sobre introdução à <em>Programação Dinâmica</em>. Iremos tratar nesta última etapa os seguintes assuntos: c)<em>tabulação</em>, estratégia de <em>baixo para cima</em> e, em especial, um estudo de caso aplicado à <em>otimização</em> e definição de <em>iniciativas de inovação</em>.</p><p>Para ler a primeira versão deste artigo, basta acessar o conteúdo a seguir:</p><p><a href="https://alexandre-oliveira.medium.com/resolvendo-problemas-de-otimiza%C3%A7%C3%A3o-combinat%C3%B3ria-63598204c9d1">Resolvendo problemas de otimização combinatória</a></p><h3>Algoritmos de baixo para cima</h3><p>Outra estratégia muito comum para problemas de <em>Programação Dinâmica</em> é a técnica <em>de baixo para cima</em> (em inglês: bottom up), a qual obtém-se resultados melhores em termos eficiência. E, evitar a recursividade inversa, <em>de cima para baixo, </em>como descrita no primeiro artigo.</p><p>Na técnica <em>de baixo para cima, </em>primeiramente nós resolvemos todos os <em>subproblemas relacionados</em>. Assim, asseguramos que este procedimento será executado preenchendo uma tabela <em>n-dimensional</em>. Conforme os resultados da tabela a solução para o <em>problema superior</em> (ou geral) será calculada. Vejamos um exemplo prático:</p><pre>def produto_para_n(n):<br>   # Assumindo que n &gt;= 1<br>   return n * produto_para_n(n - 1) if n &gt; 1 else 1</pre><pre>public static int produtoParaN(int n) {<br>    // Assumindo que n &gt;= 1<br>    return (n &gt; 1) ? (n * produtoParaN(n-1)) : 1;<br>}</pre><p>O código (acima), possui um problema: ele cria uma pilha <em>O( n )</em>, o que corresponde, também, a um <em>custo total de memória</em> <em>O( n )</em>. Isso deixa o algoritmo vulnerável, dado que estará passivo de um erro muito conhecido como <em>estouro da pilha,</em> no qual as chamadas se tornam enormes e limitam o espaço.</p><p>Para evitarmos este tipo de situação, vejamos como implementar o algoritmo <em>de baixo para cima</em>:</p><pre>def produto_um_para_n(n):<br>    # Assumindo que n &gt;= 1<br>    resultado = 1<br>    for num in range(1, n + 1):<br>        resultado *= num<br><br>    return resultado</pre><pre>public static int produtoUmParaN(int n) {<br>    // Assumindo que n &gt;= 1<br><br>    int result = 1;<br>    for (int num = 1; num &lt;= n; num++) {<br>        resultado *= num;<br>    }<br><br>    return resultado;<br>}</pre><h3>Recap: mapa de subproblemas já resolvidos</h3><p>A <em>tabulação</em> é o oposto da abordagem de <em>cima para baixo, </em>evitando assim a recursividade, até porque resolvemos o problema <em>de baixo para cima, </em>ou seja, começamos resolvendo primeiro todos os subproblemas relacionados. Vamos aplicar a tabulação ao nosso exemplo de sequência de Fibonacci:</p><pre>class SolucaoTabulacao:<br>  def calculaFibonacci(self, n):<br>    # casos<br>    pd = [0, 1]<br>    for i in range(2, n + 1):<br>      dp.append(pd[i - 1] + pd[i - 2])<br><br>    return pd[n]</pre><pre>public class SolucaoTabulacao {<br>  public int CalculaFibonacci(int n) {<br>    if (n==0) return 0;<br>    int pd[] = new int[n+1];<br><br>    // casos<br>    pd[0] = 0;<br>    pd[1] = 1;<br><br>    for(int i=2; i&lt;=n; i++)<br>      pd[i] = pd[i-1] + pd[i-2];<br><br>    return pd[n];<br>  }<br>}</pre><h4>Dica</h4><p>Para nosso caso, optamos por utilizar a <em>solução recursiva de força bruta</em> para resolver primeiramente, pois é a melhor maneira de solucionar qualquer problema de <em>Programação Dinâmica (PD)</em>.<strong> </strong>Assim, após obtermos o resultado, aplicamos as técnicas de <em>Memo e Tabulação</em>, como já foi exemplificado.</p><h3>Mochila ilimitada: um estudo de caso sobre como maximizar o lucro</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*y00sb3Fh3PkPNHJt.gif" /><figcaption>Fonte: Imagem da internet (3.0)</figcaption></figure><p>Já vimos sobre árvores. Agora, mochila? 🫠<br>Isso ta me parecendo as <em>palestrinhas </em>de &#39;<em>lero lero&#39;</em>, não? 🤪</p><h3>Desafio</h3><p>Dado os seguintes valores — de ’N’ produtos de inovação -, atribuídos estrategicamente pela área de finanças e inteligência de mercado da empresa de marketing Forrest Gump LTDA, uma área de PD&amp;I recebeu a responsabilidade de validar quais dos produtos irão ser rentáveis e viáveis para o negócio em 2023. Além de, responder o desafio, faz-se necessário comprovar por meio de um modelo racional a coerência, precisão e potenciais restrições, vejamos:</p><ol><li>existe uma capacidade &#39;X&#39; para desenvolvimento de novos produtos, atualização de softwares, otimização de algoritmos e código legado;</li><li>não podemos perder a competitividade de negócios, visto as incertezas do mercado financeiro em 12 meses;</li><li>encontrar um solução para um potencial produto que nos dará lucro máximo e que não comprometa os recursos ou exceda a capacidade da empresa para 2023.</li></ol><h3>Interpretação de texto: narrativa do problema</h3><ol><li>Produtos digitais: { novos produtos, atualização de softwares, otimização de algoritmos e código legado }</li><li>Valores: { 10, 30, 20, 40 }</li><li>Lucros: { 150, 200, 50, 25 }</li><li>Capacidade: 50 (produtos para 12 meses)</li></ol><h4>Organizando os dados:</h4><ol><li>Novos produtos + atualização (valor total 40) =&gt; 450 lucro</li><li>Novos produtos + otimização (valor total 30) =&gt; 200 lucro</li><li>Atualização + otimização (valor total 50) =&gt; 250 lucro</li><li>Otimização + legado (valor total 60) =&gt; 75 lucro</li></ol><p>Se o cenário proposto exigisse somente uma análise primária (simplista e interpretativa), bastaríamos seguir para o próximo passo, isto é, incluir estes dados em uma apresentação e <strong>le</strong> <strong>voilà</strong> <strong>bien ! </strong>Fácil né? A resposta é não! Desta maneira estaríamos utilizando <em>pseudociência. </em>Em outras palavras,<em> </em>desde a criação das moedas, todos os bens e serviços das economias são quantificados com uma unidade monetária comum. E, oficialmente ser responsável por transações comerciais modernas sendo utilizada no mundo todo graças ao câmbio. Ou seja, um denominador comum de valores que facilita a conversão de preços no mercado — Neon.</p><h3>Refutabilidade: testando as combinações</h3><p>Uma solução básica<em> </em>de <em>força bruta</em> poderia tentar todas as combinações dos produtos. E, na sequência, escolher aquele com <em>lucro máximo</em> e um <em>valor</em> que não exceda a <em>capacidade</em> &#39;X&#39;. Vejamos o código a seguir:</p><pre>def solucao_mochila(lucros, valores, capacidade):<br>  return solucao_mochila_recursividade(lucros, valores, capacidade, 0)<br><br><br>def solucao_mochila_recursividade(lucros, valores, capacidade, indiceAtual):<br>  n = len(lucros)<br>  # validacao<br>  if capacidade &lt;= 0 or n == 0 or len(lucros) != n or indiceAtual &gt;= n:<br>    return 0<br><br>  # chamada recursiva depois de escolher os itens no indiceAtual<br>  lucro1 = 0<br>  if lucros[indiceAtual] &lt;= capacidade:<br>    lucro1 = lucros[indiceAtual] + solucao_mochila_recursividade(<br>      lucros, valores, capacidade - valores[indiceAtual], indiceAtual)<br><br>  # chamada recursiva após excluir o elemento no indiceAtual<br>  lucro2 = solucao_mochila_recursividade(<br>    lucros, valores, capacidade, indiceAtual + 1)<br><br>  return max(lucro1, lucro2)<br><br><br>def main():<br>  print(solucao_mochila([10, 30, 20, 40], [1, 2, 3, 4], 8))<br>  print(solucao_mochila([10, 30, 20, 40], [1, 2, 3, 4], 6))<br><br><br>main()</pre><pre>class SolucaoMochilaRecursividade {<br><br>  public int solucaoMochila(int[] lucros, int[] valores, int capacidade) {<br>    return this.mochilaRecursiva(lucros, valores, capacidade, 0);<br>  }<br><br>  private int mochilaRecursiva(int[] lucros, int[] valores, int capacidade, int indiceAtual) {<br>    // validacao<br>    if (capacidade &lt;= 0 || lucros.length == 0 || valores.length != lucros.length || <br>        indiceAtual &gt;= lucros.length)<br>      return 0;<br><br>    // chamada recursiva depois de escolher os itens no indiceAtual<br>    int lucro1 = 0;<br>    if (valores[indiceAtual] &lt;= capacidade)<br>      lucro1 = lucros[indiceAtual]<br>          + mochilaRecursiva(lucros, valores, capacidade - valores[indiceAtual], indiceAtual);<br><br>    // chamada recursiva após excluir o elemento no indiceAtual<br>    int lucro2 = mochilaRecursiva(lucros, valores, capacidade, indiceAtual + 1);<br><br>    return Math.max(lucro1, lucro2);<br>  }<br><br>  public static void main(String[] args) {<br>    Solucao mc = new Solucao();<br>    int[] lucros = { 10, 30, 20, 40 };<br>    int[] valores = { 1, 2, 3, 4};<br>    int maxLucro = mc.solucaoMochila(lucros, valores, 8);<br>    System.out.println(maxLucro);<br>  }<br>}</pre><p>Perceba que a <em>complexidade de tempo</em> do algoritmo é <em>exponencial</em> <em>O (2 ˆN+X),</em> onde ’N’ reproduz o número total de itens. A complexidade do espaço será <em>O (N + X) </em>para armazenar a pilha de recursão.</p><h3>Memo: superando os subproblemas sobrepostos</h3><p>Vamos usar a <em>Memo</em> para superar os subproblemas sobrepostos? Assim sendo, armazenamos os resultados de cada <em>subarray</em> para cada capacidade possível. Sugestão:</p><pre>def solucao_mochila(lucros, valores, capacidade):<br>  pd= [[-1 for _ in range(capacidade+1)] for _ in range(len(lucros))]<br>  return solucao_mochila_recursividade(pd, lucros, valores, capacidade, 0)<br><br><br>def solucao_mochila_recursividade(pd, lucros, valores, capacidade, indiceAtual):<br>  n = len(lucros)<br>  # validacao<br>  if capacidade &lt;= 0 or n == 0 or len(valores) != n or indiceAtual &gt;= n:<br>    return 0<br><br>  # verificacao para saber se não processamos um subproblema semelhante<br>  if pd[indiceAtual][capacidade] == -1:<br>    # chamada recursiva depois de escolher os itens no indiceAtual<br>    lucro1 = 0<br>    if lucros[indiceAtual] &lt;= capacidade:<br>      lucro1 = lucros[indiceAtual] + solucao_mochila_recursividade(<br>        pd, lucros, valores, capacidade - lucros[indiceAtual], indiceAtual)<br><br>    # chamada recursiva após excluir o elemento no indiceAtual<br>    lucro2 = solucao_mochila_recursividade(<br>      pd, lucros, valores, capacidade, indiceAtual + 1)<br><br>    pd[indiceAtual][capacidade] = max(lucro1, lucro2)<br><br>  return pd[indiceAtual][capacidade]<br><br><br>def main():<br>  print(solucao_mochila([10, 30, 20, 40], [1, 2, 3, 4], 8))<br>  print(solucao_mochila([10, 30, 20, 40], [1, 2, 3, 4], 6))<br><br><br>main()</pre><pre>class SolucaoMochilaRecursividade {<br><br>  public int solucaoMochila(int[] lucros, int[] valores, int capacidade) {<br>    Integer[][] pd = new Integer[lucros.length][capacidade + 1];<br>    return this.mochilaRecursiva(pd, lucros, valores, capacidade, 0);<br>  }<br><br>  private int mochilaRecursiva(Integer[][] pd, int[] lucros, int[] valores, int capacidade,<br>      int indiceAtual) {<br><br>    // validacao<br>    if (capacidade &lt;= 0 || lucros.length == 0 || valores.length != lucros.length ||<br>        indiceAtual &gt;= lucros.length)<br>      return 0;<br><br>    // verificacao para saber se não processamos um subproblema semelhante<br>    if(pd[indiceAtual][capacidade] == null) {<br>      // chamada recursiva depois de escolher os itens no indiceAtual<br>      int lucro1 = 0;<br>      if( valores[indiceAtual] &lt;= capacidade )<br>          lucro1 = lucros[indiceAtual] + mochilaRecursiva(pd, lucros, valores,<br>                  capacidade - valores[indiceAtual], indiceAtual);<br><br>      // chamada recursiva após excluir o elemento no indiceAtual<br>      int lucro2 = mochilaRecursiva(pd, lucros, valores, capacidade, indiceAtual + 1);<br><br>      dp[indiceAtual][capacidade] = Math.max(lucro1, lucro2);<br>    }<br><br>    return pd[indiceAtual][capacidade];<br>  }<br><br>  public static void main(String[] args) {<br>    Solucao mc = new Solucao();<br>    int[] lucros = {10, 30, 20, 40};<br>    int[] valores = {1, 2, 3, 4};<br>    System.out.println(mc.solucaoMochila(lucros, valores, 8));<br>    System.out.println(mc.solucaoMochila(lucros, valores, 6));<br>  }<br>}</pre><p><strong>Qual é a complexidade de tempo &amp; espaço dessa solução?<br></strong>Como nosso <em>array de Memo pd[lucros.length][capacidade+1]</em> armazena os resultados de todos os subproblemas, podemos concluir que não teremos mais do que N * X subproblemas (onde &#39;N&#39; é o número de itens e &#39;X&#39; é a capacidade). Logo, a <em>complexidade total do espaço</em> será <em>O(N * X + N)</em>, que é <em>assintoticamente</em> equivalente a O(N * X).</p><h3>Tabulação: de baixo para cima</h3><p>Tentaremos preencher nosso <em>array pd[ ][ ]</em>, do código anterior, através da tabulação <em>de baixo para cima</em>. Essencialmente, o que queremos alcançar é: &#39;encontrar o lucro máximo para cada <em>submatriz</em> e para cada capacidade possível&#39;. Desta maneira, para cada capacidade ‘X’ possível (0 &lt;= X &lt;= capacidade), temos duas opções:</p><ol><li>Excluir o item;</li><li>Incluir o item se o valor não for maior que o ‘X’.</li></ol><h4>Exemplo visual</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*j-4BDp-pvwv16UVC7Y20Mw.png" /><figcaption>Fonte: Imagem ilustrativa do próprio estudo de caso (3)</figcaption></figure><ol><li>Imagem 3: Capacidade = 2, IndiceAtual = 1, já que o item no índice ‘1’ tem valor ‘3’, que é maior que a capacidade ‘2’, então vamos pegar o pd[indiceAtual-1][capacidade]</li><li>Imagem 4: Capacidade = 8, IndiceAtual =3, max( pd[2][8], lucro[3] + pd[3][3] )</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*y6j8yuXRyy62InrqZ7Y39g.png" /><figcaption>Fonte: Imagem ilustrativa do próprio estudo de caso (4)</figcaption></figure><pre>def solucao_mochila(lucros, valores, capacidade):<br>  n = len(lucros)<br>  # validacao<br>  if capacidade &lt;= 0 or n == 0 or len(lucros) != n:<br>    return 0<br><br>  pd= [[-1 for _ in range(capacidade+1)] for _ in range(len(lucros))]<br><br>  # preencha as colunas capacidade=0<br>  for i in range(n):<br>    pd[i][0] = 0<br><br>  # processar todos os subarrays para todas as capacidades<br>  for i in range(n):<br>    for x in range(1, capacidade+1):<br>      lucro1, lucro2 = 0, 0<br>      if valores[i] &lt;= x:<br>        lucro1 = lucros[i] + pd[i][x - lucros[i]]<br>      if i &gt; 0:<br>        lucro2 = pd[i - 1][x]<br>      pd[i][x] = lucro1 if lucro1 &gt; lucro2 else lucro2<br><br>  # o lucro máximo estará no canto inferior direito<br>  return pd[n - 1][capacidade]<br><br><br>def main():<br>  print(solucao_mochila([10, 30, 20, 40], [1, 2, 3, 4], 8))<br>  print(solucao_mochila([10, 30, 20, 40], [1, 2, 3, 4], 6))<br><br><br>main()</pre><pre>class SolucaoMochilaRecursividade {<br><br>  public int solucaoMochila(int[] lucros, int[] valores, int capacidade) {<br>    // validacao<br>    if (capacidade &lt;= 0 || lucros.length == 0 || weights.length != lucros.length)<br>      return 0;<br><br>    int n = lucros.length;<br>    int[][] pd = new int[n][capacidade + 1];<br><br>    // preencha as colunas capacidade=0<br>    for(int i=0; i &lt; n; i++)<br>      pd[i][0] = 0;<br><br>    // processar todos os subarrays para todas as capacidades<br>    for(int i=0; i &lt; n; i++) {<br>      for(int x=1; x &lt;= capacity; x++) {<br>        int lucro1=0, lucro2=0;<br>        if(valores[i] &lt;= x)<br>          lucro1 = lucros[i] + pd[i][x-valores[i]];<br>        if( i &gt; 0 )<br>          lucro2 = pd[i-1][x];<br>        pd[i][x] = lucro1 &gt; lucro2 ? lucro1 : lucro2;<br>      }<br>    }<br><br>    // o lucro máximo estará no canto inferior direito<br>    return pd[n-1][capacidade];<br>  }<br><br>  public static void main(String[] args) {<br>    Solucao mc = new Solucao();<br>    int[] lucros = {10, 30, 20, 40};<br>    int[] valores = {1, 2, 3, 4};<br>    System.out.println(mc.solucaoMochila(lucros, valores, 8));<br>    System.out.println(mc.solucaoMochila(lucros, valores, 6));<br>  }<br>}</pre><p>A solução acima tem <em>complexidade de tempo e espaço de</em> <em>O(N * X)</em>, onde ’N’ reflete o total de itens e ‘X’ é a <em>capacidade máxima</em>. E, com isto, finalizamos a segunda parte. 😉</p><p>Até a próxima!</p><p>Autor: <a href="https://medium.com/u/91704229bd43?source=post_page-----402188d3972a--------------------------------">Alexandre (#oale)</a></p><p><strong>Referências:</strong></p><p>[1] Abstract Dynamic Programming, 2nd Edition, by Dimitri P.<br>Bertsekas, 2018, ISBN 978–1–886529–46–5, 360 pages.</p><p>[2] Hernandez-Lerma, O., Carrasco, O., and Perez-Hernandez. 1999. “Markov Control Processes with the Expected Total Cost Criterion: Optimality, Stability, and Transient Models,” Acta Appl. Math., Vol. 59, pp. 229–269.</p><p>[3] Jacobson, D. H., 1973. “Optimal Stochastic Linear Systems with Exponential Performance Criteria and their Relation to Deterministic Differentia.</p><p>[4] Mitten, L. G., 1964. “Preference Order Dynamic Programming,” Management Science, Vol. 21, pp. 43–46.</p><p>[5] Morin, T. L., 1982. “Monotonicity and the Principle of Optimality,” J. of Math. Analysis and Applications, Vol. 88, pp. 665–674.</p><p>[6] Ortega, J. M., and Rheinboldt, W. C., 1970. Iterative Solution of Nonlinear Equations in Several Variables, Academic Press, N. Y.</p><p>7] Patek, S. D., and Bertsekas, D. P., 1999. “Stochastic Shortest Path Games,” SIAM J. on Control and Opt., Vol. 36, pp. 804–824.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=575d78dd32b3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Resolvendo problemas de otimização combinatória]]></title>
            <link>https://alexandre-oliveira.medium.com/resolvendo-problemas-de-otimiza%C3%A7%C3%A3o-combinat%C3%B3ria-63598204c9d1?source=rss-91704229bd43------2</link>
            <guid isPermaLink="false">https://medium.com/p/63598204c9d1</guid>
            <category><![CDATA[programação-dinâmica]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ciencia]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Alexandre #ále]]></dc:creator>
            <pubDate>Mon, 13 Mar 2023 22:45:18 GMT</pubDate>
            <atom:updated>2023-03-19T15:44:26.091Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/801/1*e6u4rkidqU37dZQz-pp7_g.png" /><figcaption>Fonte: Imagem ilustrativa do próprio estudo de caso (1.0)</figcaption></figure><p>Com a crescente demanda por dados, saber como interpretar e tomar decisões factíveis se tornou um segundo idioma. Embora tenhamos dado um salto nos últimos anos sobre o assunto, ainda há quem insista em pressupor as coisas por meio de ideia súbita ou excludente. Que loucura!</p><p>Ao longo da história, diferentes filósofos foram responsáveis por revolucionar a Matemática, destaque para <em>Platão</em>, <em>Galileu Galilei</em> e <em>René Descartes</em>. Estes são apenas alguns dos nomes que asseguraram a união entre Filosofia e Matemática. Curiosamente, as culturas antigas já utilizavam o pensamento matemático para solução de muitos problemas complexos. Posteriormente, a navegação durante a <em>Era da Exploração</em>, bem como as <em>Leis do Movimento de Newton</em>, servem tanto como narrativas quanto prova do racional no século XIX e XX. Assim sendo, não há necessidade de <em>colonizar as pessoas</em>, segundo José Saramago. Para todos efeitos — de <em>tabula rasa -, </em>os fatos (ou dados) separam o <em>joio do trigo</em>, desde a antiguidade.</p><p><strong>Disclaimer:</strong> este é um artigo técnico de introdução sobre <em>Programação Dinâmica</em>. O tema será divido em duas partes para não ficar exaustivo. E, também, não é nosso propósito esgotar o assunto. Nesta primeira etapa, desmistificamos os conceitos práticos da solução; a)<em>recursividade</em> e <em>técnicas de força bruta</em> — que é uma das maneiras de iniciar a resolver qualquer problema de <em>Programação Dinâmica</em>; b)implementação <em>Memo</em> (em inglês: <em>Memoization</em>), <em>de cima para baixo — </em>onde<em> </em>resolvemos o problema maior (geral) encontrando recursivamente a solução para seus <em>subproblemas</em> menores.</p><p>Para ler a segunda parte deste artigo, basta acessar o conteúdo a seguir:</p><p><a href="https://alexandre-oliveira.medium.com/mochila-ilimitada-um-estudo-de-caso-sobre-como-maximizar-o-lucro-575d78dd32b3">Mochila ilimitada: um estudo de caso sobre como maximizar o lucro</a></p><h3>Introdução</h3><p>Para análise de dados, cada conjunto e cada problema é diferente. Embora seja possível usar algoritmos e ferramentas complexas para trabalhar com dados no mundo real, sem entender o que está por trás de cada informação pode ser um desafio enorme. Por esse motivo, construir um pensamento matemático sólido ajudará você a escolher a ferramenta certa para o trabalho certo e, ainda irá corroborar com a transformação do dado em informação relevante. É isso que este artigo se propõe apresentar. Logo, abordaremos as características e exemplos práticos com a <em>Programação</em> <em>Dinâmica</em> e como ela utiliza algoritmos para resolver problemas de otimização combinatória.</p><p>A <em>Programação Dinâmica (PD) </em>é o principal método para analisar uma grande e diversificada classe de problemas de decisão sequencial. Alguns exemplos que utilizam a PD são, <em>problemas de decisão de Markov e semi-Markov com um espaço de estado discreto, determinístico e estocástico com um espaço de estado contínuo, problemas minimax e jogos sequenciais de soma zero</em>. Se bem que a natureza desses problemas possam variar amplamente, suas estruturas subjacentes são muito semelhantes. [1]</p><h3>Praticando: sequência de Fibonacci</h3><p>É sabido que a sequência de Fibonacci representa uma série numérica onde cada número caracteriza a soma dos anteriores. Exemplo: 0, 1, 1, 2, 3, 5 e 8, e eles continuam a partir daí. E se tivéssemos que calcular o <em>n-ésimo</em> número de Fibonacci? Uma sugestão de equação:</p><h4>Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2), for n &gt; 1</h4><p>Ou mais ‘bonitinho’, caso você esteja aí do outro lado me criticando xD</p><pre>def fibonacci(n):<br>   if n == 0 or n == 1:<br>       return n<br>   return fibonacci(n - 1) + fibonacci(n - 2)</pre><pre>public static int fibonacci(int n) {<br>    if (n == 0 || n == 1) {<br>        return n;<br>    }<br>    return fibonacci(n-1) + fibonacci(n-2);<br>}</pre><p>Veja que para resolver o problema geral de Fibonacci(n), nós dividimos o problema em dois <em>subproblemas</em> menores; que são Fibonacci(n-1) e Fibonacci(n-2). O que isso no revela? Uma oportunidade de aplicar a <em>Programação Dinâmica, </em>uai.</p><h3>O que são subproblemas?</h3><p>Os subproblemas são as versões menores do problema original (ou geral). Qualquer problema tem suas derivações incluindo subproblemas (partes menores do todo). Desta maneira, encontrar sua solução envolve resolver o mesmo subproblema diversas vezes. Veja que no exemplo de Fibonacci para encontrarmos fibonacci(4), é necessário decompor nos seguintes subproblemas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bscxz4on9Zlqx3BPCpXREg.png" /><figcaption>Fonte: Árvore de recursividade. Imagem ilustrativa do próprio estudo de caso (2.0)</figcaption></figure><p>Fica evidente o padrão do subproblema aqui sobreposto, visto que fibonacci(2) foi avaliado duas vezes e fibonacci(1) três vezes.</p><h3>Recap: característica de subestrutura ótima</h3><p>Como sabemos, qualquer problema possui sua <em>característica de subestrutura ótima. </em>Isso significa que a <em>solução ótima</em> (problema geral) foi desenvolvida a partir da <em>solução ótima</em> de seus problemas menores. Vejamos:</p><h4>Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)</h4><p>Em outras palavras, um problema de tamanho ’n’ pode ser reduzido a subproblemas com a seguinte dimensões: ‘n-1’ e ‘n-2’. Desse modo, os números de Fibonacci têm propriedades que resultam em subestruturas ótimas.</p><h3>Memo: solução de cima para baixo</h3><p>Vamos agora resolver o problema maior (geral) encontrando recursivamente a solução para seus subproblemas menores. A partir do momento em que solucionarmos um subproblema, armazenamos em cache o resultado para que não seja necessário ter que repetir isso várias vezes. Isto posto, retornamos somente o resultado salvo. Essa técnica de armazenar o resultado de subproblemas já resolvidos é conhecida como <em>Memo</em> (ou do acrônimo em inglês: <em>Memoization</em>).</p><p>Utilizar a estratégia de <em>Memo</em> é um critério muito comum para problemas de <em>Programação Dinâmica</em>. Essa solução é composta de recursos os quais auxiliam na resposta do mesmo problema com entradas menores (a exemplo da sequência de Fibonacci). Vejamos uma função recursiva simples para calcular &#39;n&#39;:</p><pre>def f(n):<br>  if n &lt; 0:<br>      raise IndiceError(<br>          &#39;Indice negativo. &#39;<br>          &#39;Não existe índice negativo em uma série.&#39;<br>      )<br>  elif n in [0, 1]:<br>      # casos<br>      return n<br><br>  print(&quot;f(%i)&quot; % n)<br>  return f(n - 1) + f(n - 2)</pre><pre>public static int f(int n) {<br><br>  if (n &lt; 0) {<br>      throw new IllegalArgumentException(<br>          &quot;Indice negativo. Não existe índice negativo em uma série.&quot;);<br>  }<br><br>  // casos<br>  if (n == 0 || n == 1) {<br>      return n;<br>  }<br><br>  System.out.printf(&quot;f(%d)\n&quot;, n);<br>  return f(n - 1) + f(n - 2);<br>}</pre><p>Repare que as chamadas recursivas desse método através do formato de árvore (visual); os <em>dois filhos</em> de um nó são as duas chamadas recursivas que ele faz. Note que a árvore rapidamente se ramifica fora de controle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*syF7UF77UK1NfQvQT53xqg.png" /><figcaption>Fonte: Chamadas Recursivas. Imagem ilustrativa do próprio estudo de caso (2.1)</figcaption></figure><p>Para evitar duplicidade causada pela ramificação, vamos agora <em>agrupar</em> o método em uma classe que armazena uma variável de instância <em>Memo</em>, que por usa vez irá mapear as entradas e saídas.</p><ol><li>faça a verificação da variável <em>Memo</em> para evitar calcular a resposta de qualquer entrada fornecida;</li><li>salve os resultados dos cálculos na variável <em>Memo.</em></li></ol><pre>class F(object):<br><br>  def __init__(self):<br>      self.memo = {}<br><br>  def f(self, n):<br>      if n &lt; 0:<br>          raise IndiceError(<br>              &#39;Indice negativo. &#39;<br>              &#39;Não existe índice negativo em uma série.&#39;<br>          )<br><br>      # casos<br>      if n in [0, 1]:<br>          return n<br><br>      # Já calculamos isso?<br>      if n in self.memo:<br>          print(&quot;resgatando memo[%i]&quot; % n)<br>          return self.memo[n]<br><br>      print(&quot;f(%i)&quot; % n)<br>      resultado = self.f(n - 1) + self.f(n - 2)<br><br>      # Memo<br>      self.memo[n] = resultado<br><br>      return resultado</pre><pre>import java.util.Map;<br>import java.util.HashMap;<br><br>class F {<br><br>    private Map&lt;Integer, Integer&gt; memo = new HashMap&lt;&gt;();<br><br>    public int f(int n) {<br><br>        if (n &lt; 0) {<br>            throw new IllegalArgumentException(<br>                &quot;Indice negativo. Não existe índice negativo em uma série.&quot;);<br><br>        // casos<br>        } else if (n == 0 || n == 1) {<br>            return n;<br>        }<br><br>        // Já calculamos isso?<br>        if (memo.containsKey(n)) {<br>            System.out.printf(&quot;resgatando memo[%d]\n&quot;, n);<br>            return memo.get(n);<br>        }<br><br>        System.out.printf(&quot;f(%d)\n&quot;, n);<br>        int resultado = f(n - 1) + f(n - 2);<br><br>        // Memo<br>        memo.put(n, resultado);<br><br>        return resultado;<br>    }<br>}</pre><p>Economizamos diversas chamadas verificando a variável <em>Memo, </em>concorda? Agora, nossa árvore não irá aparecer com itens duplicados. <em>Procurando Nemo… Nãooo, é chamando Memo </em>😂</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EsqvRUVkOItsz6376iR5NA.png" /><figcaption>Fonte: Chamando Memo. Imagem ilustrativa do próprio estudo de caso (2.2)</figcaption></figure><p>Conforme prometido, vamos dar continuidade neste assunto apartir do segundo artigo e, principalmente, finalizar com um estudo de caso. Espero que seja útil para seu conhecimento e gere novas ideias para resolver ou aplicar a <em>Programação Dinâmica, </em>exposta até aqui.</p><p>Até lá!</p><p>Autor: <a href="https://medium.com/u/91704229bd43?source=post_page-----402188d3972a--------------------------------">Alexandre (#oale)</a></p><p><strong>Referências:</strong></p><p>[1] Abstract Dynamic Programming, 2nd Edition, by Dimitri P.<br>Bertsekas, 2018, ISBN 978–1–886529–46–5, 360 pages.</p><p>[2] Hernandez-Lerma, O., Carrasco, O., and Perez-Hernandez. 1999. “Markov Control Processes with the Expected Total Cost Criterion: Optimality, Stability, and Transient Models,” Acta Appl. Math., Vol. 59, pp. 229–269.</p><p>[3] Jacobson, D. H., 1973. “Optimal Stochastic Linear Systems with Exponential Performance Criteria and their Relation to Deterministic Differentia.</p><p>[4] Mitten, L. G., 1964. “Preference Order Dynamic Programming,” Management Science, Vol. 21, pp. 43–46.</p><p>[5] Morin, T. L., 1982. “Monotonicity and the Principle of Optimality,” J. of Math. Analysis and Applications, Vol. 88, pp. 665–674.</p><p>[6] Ortega, J. M., and Rheinboldt, W. C., 1970. Iterative Solution of Nonlinear Equations in Several Variables, Academic Press, N. Y.</p><p>7] Patek, S. D., and Bertsekas, D. P., 1999. “Stochastic Shortest Path Games,” SIAM J. on Control and Opt., Vol. 36, pp. 804–824.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63598204c9d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SAC 4.0: a evolução do serviço de atendimento ao consumidor]]></title>
            <link>https://medium.com/itau-data/sac-4-0-como-melhorar-o-relacionamento-com-o-cliente-402188d3972a?source=rss-91704229bd43------2</link>
            <guid isPermaLink="false">https://medium.com/p/402188d3972a</guid>
            <category><![CDATA[industry-4-0]]></category>
            <category><![CDATA[pesquisa-operacional]]></category>
            <category><![CDATA[teoria-de-filas]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[probability]]></category>
            <dc:creator><![CDATA[Alexandre #ále]]></dc:creator>
            <pubDate>Tue, 16 Aug 2022 18:14:44 GMT</pubDate>
            <atom:updated>2022-08-17T13:16:35.889Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FWS2trjmh-dV8nZsiOlmfg.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (1.0)</figcaption></figure><p>Proporcionar interações intuitivas e serviços eficientes é um desafio exponencial para muitas empresas. Como a implementação do <em>SAC 4.0</em> pode contribuir para melhorar o relacionamento com o cliente?<br> <br><strong>Disclaimer:</strong> este artigo tem como objetivo apresentar uma abordagem à análise exploratória de potenciais problemas de negócios e trazer soluções que vão orientar as etapas estatísticas (ou ciência de dados), permitindo, assim, identificar de forma mais assertiva os comportamentos e necessidades dos clientes aplicado às centrais de atendimento.</p><p><strong>Introdução <br></strong>O termo <em>indústria 4.0</em> foi mencionado pela primeira vez na Feira de <em>Hannover</em>, 2011. Foi cunhado a partir de um projeto estratégico voltado para tecnologia do governo alemão (14). Logo, o conceito de <em>SAC 4.0</em> nada mais é que a evolução do serviço de atendimento ao consumidor unindo inovações tecnológicas — habilitadores -, principalmente, foco na experiência e sucesso do cliente.</p><p>E se quiséssemos estimar a frequência de ligações de clientes em um certo intervalo de tempo? Como obter essa resposta através da estatística probabilística?</p><p><strong>Teoria de Filas (Pesquisa Operacional) <br></strong>Primeiramente, é importante ressaltar que a <em>teoria de filas</em> é um setor da <em>Pesquisa Operacional</em> (6) que utiliza conceitos básicos de processos estocásticos. E, de matemática aplicada para analisar o fenômeno de formação de filas, bem como suas características.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0OsgRIBc_-VuiSIrYAdOdA.png" /><figcaption>Fonte: Imagem Youtube (1.2) — (André Corleta, 2016)</figcaption></figure><p><strong>Tipo de filas</strong> <br><strong>Finita</strong> <br>As eleições do sistema brasileiro, por exemplo. À medida que ocorrem as apurações das urnas (cenário brasileiro) há uma redução da população (regiões). <br> <br><strong>Infinita</strong> <br>Uma fila bancária, como exemplo. Logo, enquanto o período de atendimento estiver disponível, não há limites de vezes para chegada ou saída de clientes (4).</p><p><strong>Classificando o nível de paciência do cliente</strong> <br><strong>Impaciente</strong> <br>Não quer esperar. Um exemplo disso é um restaurante, não adianta querer saciar sua fome sem que o prato seja totalmente disponibilizado pela cozinha (1). Existem os processos a serem cumpridos e etapas. <br> <br><strong>Paciente</strong> <br>Espera por um determinado produto ou serviço. As compras online são um ótimo exemplo, na maioria dos casos o processo de logística para entrega final na casa do cliente é determinado por um ‘<em>SLA</em>’, acordo de nível de serviço (do acrônimo em inglês: <strong>Service Level Agreement</strong>).</p><p><strong>Limite</strong> <br>Aguardando atendimento em uma chamada telefônica. Tempo máximo de espera estipulado e mencionado ao cliente de maneira transparente. Pelo menos deveria!</p><h3><strong>Estudo de caso 1: determinando a probabilidade (SAC 4.0)</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EAa7VpxyyLbFIqN8rpVqpw.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (1.3)</figcaption></figure><p>Um sistema de atendimento ao cliente (fraudes), recebe um total de 200 ligações por dia, considerando uma jornada de 6h de trabalho, de maneira aleatória e independente (de ocorrências anteriores). A média é de 33.3 ligações por hora. <br> <br><strong>Assumindo que a equipe deste <em>Call Center</em> trabalha somente em dias úteis qual é a probabilidade de que nenhuma ligação ocorra em um intervalo de 15 minutos?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/0*-tsuN5RLkcVpqoRz.gif" /><figcaption>Fonte: gifman.net (1.4)</figcaption></figure><p>Matemágica! Eitha que o trem lascou de vez. Calma! <br>Vamos entender a definição de alguns conceitos primeiro.</p><p><strong>Método</strong> <br><strong>Probabilidade</strong> <br>A distribuição de Poisson (1) nada mais é que uma distribuição estatística; criada por <em>Siméon Denis Poisson</em> e responsável por publicar em 1838 a teoria da probabilidade. É aplicável quando o número de possíveis ocorrências discretas é muito maior do que o número médio de ocorrências em um determinado intervalo de tempo ou espaço amostral.</p><p><strong>Fórmula de Poisson</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/366/1*O4Gu5MoBE-zQuJkoz_fxLw.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (1.5)</figcaption></figure><p><strong>Solução (estudo de caso 1)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/387/1*7SnZh5qVmozJ7qSS8RxJaw.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (1.6)</figcaption></figure><p>A probabilidade de que nenhuma ligação (ou evento) ocorra em um intervalo de quinze minutos (15min) é de <strong>0,024%</strong>.</p><p><strong>Visualização do gráfico</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/824/1*pcIoWXREOoltDzwW5i2S2A.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (1.7)</figcaption></figure><p>No gráfico acima, o valor de <strong>0,024% (ponto de intersecção) </strong>representa a probabilidade de que nenhuma ligação (evento) ocorra em um intervalo de quinze minutos, dado que a jornada do colaborador corresponde de 0h até às 6h (referência à madrugada).</p><h3><strong>Bônus: estudo de caso 2 (fila bancária)</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0OsgRIBc_-VuiSIrYAdOdA.png" /><figcaption>Fonte: Imagem Youtube (2.0) — (André Corleta, 2016)</figcaption></figure><p>Para o nosso propósito prático, vamos considerar que a nossa média de chegada é de 2 clientes em um intervalo de 30 minutos, de maneira aleatória e independente. Além de, assumir que a capacidade de atendimento dos operadores é de no mínimo 5 e no máximo 8 clientes por guichê.</p><p><strong>Qual é a probabilidade de 5 novos clientes chegarem na fila em um intervalo de uma hora?</strong></p><p><strong>Expressão</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/379/1*U4o40p1Dohu5K3IfZ5fqGA.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (2.1)</figcaption></figure><p><strong>Probabilidade</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*u890oPsY4R_eyej90bb7kw.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (2.2)</figcaption></figure><p>Assim, para um intervalo de uma hora (ou 60min), podemos concluir que existe a probabilidade de <strong>34,97%</strong> de 5 novos clientes chegarem na fila.</p><p>A ‘geração’ do gráfico (case 2) é por sua conta, ok? :)<br>Envie nos comentários suas sugestões e/ou novas soluções. Será um prazer para nós visualizar outras formas de resolução destes problemas de negócio.</p><p><strong>Ambiente de execução (experimento)<br></strong>O experimento foi executado em uma estação de trabalho (computador) com as seguintes configurações:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/760/1*_a20HuuSwxM7wKJ52TXrXg.png" /><figcaption>Fonte: imagem ilustrativa da própria pesquisa (2.3)</figcaption></figure><p><strong>Conclusão</strong> <br>Assim como o Marketing evoluiu junto ao comportamento do consumidor, as empresas de todos os portes estão despertando para a necessidade de modernizar o atendimento ao cliente através dos benefícios do SAC 4.0. <br>É importante ressaltar ainda que durante a transição tecnológica haja desvios e impactos, positivos ou negativos. Estes efeitos devem ser observados, mensurados e ajustados de acordo com a estratégia e contexto de cada empresa.</p><p>Autores: <a href="https://medium.com/u/91704229bd43">Alexandre (#oale)</a> e <a href="https://medium.com/u/4d4565e22feb">Tales Lima Fonseca</a></p><p>Agradecimento: Alceu Costa, Lennon Cruz, Gustavo Bicalho, Diego Wesllen, Rodrigo Mello, Fellows e DED (Itaú Unibanco).</p><p><strong>Referências:</strong></p><ol><li>A. Zibetti. <a href="https://www.inf.ufsc.br/~andre.zibetti/probabilidade/poisson.html">Processos de chegada Distribuição de Poisson</a>. Probabilidade e Estatística para Engenharias utilizando o R (Studio) da Universidade Federal de Santa Catarina (2022)</li><li>A. Corleta. <a href="https://www.youtube.com/watch?v=FasQuWQMqvI">Taxa de Chegadas — Pesquisa Operacional</a>. Post em vídeo no Youtube (2016)</li><li>C. C. Cavalcante, V. S. O. Ribeiro. <a href="https://www.osterne.com/_files/ugd/969fe7_9d014f7256b1422b9f0a90ab3788455a.pdf">Tópicos em Estatística para Engenharia</a>. E-book no blog Osterne (2022)</li><li>E. Bastos. <a href="https://lamfo-unb.github.io/2018/07/06/Otimiza%C3%A7%C3%A3o-de-Filas/">Otimização de Estruturas de Filas</a>. Post no github.io. (2018)</li><li>D.G Kendall. <a href="https://www.scirp.org/(S(351jmbntv-nsjt1aadkposzje))/reference/referencespapers.aspx?referenceid=2221033">Stochastic Processes Occurring in the Theory of Queues and their Analysis by the Method of the Imbedded Markov Chain.</a> The Annals of Mathematical Statistics (1953)</li><li>D. Lindley. <a href="https://www.cambridge.org/core/journals/mathematical-proceedings-of-the-cambridge-philosophical-society/article/abs/theory-of-queues-with-a-single-server/53E80E039A02BCCC909E5C1D3BBC1AD1">The theory of queues with a single server</a>. Mathematical Proceedings of the Cambridge Philosophical Society (1952)</li><li>R. Bruns, S. P. Soncim, M. F. Sinay. <a href="https://abepro.org.br/biblioteca/enegep2001_tr60_0158.pdf">Pesquisa Operacional: Uma Aplicação da Teoria das Filas a um Sistema de Atendimento</a> . Artigo na Associação Brasileira de Engenharia de Produção (2001)</li><li>Anaconda. <a href="https://www.anaconda.com/">Anaconda offers the easiest way to perform Python/R data science and machine learning on a single machine</a>. Website Anaconda Distribution (2022)</li><li>Jupyter. <a href="https://jupyter.org/">Free software, open standards, and web services for interactive computing across all programming languages</a>. Website Jupyter.org (2022)</li><li>Pandas. <a href="https://pandas.pydata.org/">Open source data analysis and manipulation tool, built on top of the Python programming language</a>. Website Pandas.org (2022)</li><li>Numpy. <a href="https://numpy.org/">The fundamental package for scientific computing with Python</a>. Website Numpy.org (2022)</li><li>Matplotlib. Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. Matplotlib makes easy things easy and hard things possible. <a href="https://matplotlib.org/">Website Matplotlib.org</a> (2022)</li><li>R. Pires. <a href="https://rockcontent.com/br/blog/sac-4-0/">Melhore o atendimento ao cliente com o SAC 4.0</a>. Post no blog rockcontent (2022)</li><li>IEDI. Indústria 4.0: <a href="https://www.iedi.org.br/cartas/carta_iedi_n_797.html">A Quarta Revolução Industrial e os desafios para a Indústria e para o desenvolvimento brasileiro</a>. Instituto de Estudos para o Desenvolvimento Industrial (2017)</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=402188d3972a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/itau-data/sac-4-0-como-melhorar-o-relacionamento-com-o-cliente-402188d3972a">SAC 4.0: a evolução do serviço de atendimento ao consumidor</a> was originally published in <a href="https://medium.com/itau-data">itau-data</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Taxa de evasão de clientes]]></title>
            <link>https://alexandre-oliveira.medium.com/churn-rate-taxa-de-evas%C3%A3o-de-clientes-89ecdac629b7?source=rss-91704229bd43------2</link>
            <guid isPermaLink="false">https://medium.com/p/89ecdac629b7</guid>
            <dc:creator><![CDATA[Alexandre #ále]]></dc:creator>
            <pubDate>Fri, 26 Nov 2021 00:41:41 GMT</pubDate>
            <atom:updated>2022-07-16T15:04:14.380Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fmc7oOd9G4NvtmWjAOlIqQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Uso da análise exploratória, estatística e modelos de predição para o contexto bancário</h4><p>Cá estou! Desta vez para iniciar o compartilhamento dos primeiros #ensaios do pensamento sobre #datascience, entre outros assuntos técnicos que curto bastante.</p><p>***<br> <br><strong>Mas afinal o que é “Churn rate”?</strong><br>Em tradução livre, &#39;Churn&#39; significa evasão de clientes (ou rotatividade). Já Churn rate, refere-se ao indicador que mede o índice de clientes que cancelam dividido por clientes do início de um período (mês/ano) multiplicado por 100 de uma determinada empresa.</p><p><strong>Objetivo</strong><br>Para reduzir o &#39;Churn&#39; de clientes do segmento financeiro, utilizei a versão de um &#39;Dataset&#39; (ou conjunto de dados) fictícios que inventei para este exercício. É claro que existem projetos com grandes complexidades, inclusive outras formas mais avançadas no dia a dia. Contudo, a ideia aqui é demonstrar uma abordagem inicial e primeira parte desta paixão por ciência de dados + computação. Irei postar, melhorar, corrigir, conforme meu tempo de extra.</p><p><strong>Perguntas a serem respondidas:</strong><br>a)Qual a taxa de Churn?<br>b)Existe algum padrão ou preferência dos clientes? <br>c)Quais são os serviços/produtos prestados mais lucrativos?<br>d)Qual é a taxa de clientes ativos?<br>e)Quais os motivos que fazem os clientes ativos serem fieis à marca? O que os encanta?</p><h4>Introdução</h4><p>Este projeto será dividido em duas etapas. Esta primeira parte se concentrará na exploração estatística do conjunto de dados e a outra parte demonstrará na construção de modelos de conjuntos.</p><p>GitHub: <a href="https://github.com/oale369/eda-statiscal-projects/tree/main/Churn">https://github.com/oale369/eda-statiscal-projects/tree/main/Churn</a></p><h4>Resumo</h4><p>_O conjunto de dados (#dataset) tem principalmente variáveis categóricas<br>_Realizou-se um teste de hipótese estatística com base em tipos de dados para verificar a normalidade e correlação<br>_Testes estatísticos não paramétricos realizados para as #features que não são normalmente distribuídas<br>_Todos os testes estatísticos foram realizados com um nível de confiança de 95% (ou seja, valor de p &lt;0,05)</p><h4>Descrição Analítica</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wzln9Ju4vD_mm6i51EzUdw.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Importando bibliotecas</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nlliGzuuD6rBwxIBAf1Hhg.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bcDwfWjt6aDCXD6oiUZSAw.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Importando o dataset</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4lAMZm-C9nd-ztX8bpxfsQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Dimensão do dataset</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3uskifajAfxiHqIjrKvzGg.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Resumo das Features Categóricas</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*Kf8mY8YvSko0s3CIwliJ3w.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Data Wrangling (valores ausentes)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VGlVevcYFbH4CHsgVFfpuQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Variáveis Categóricas Correlacionadas</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DFJaar3X6rwbf_SX1-B5tQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*8-DhkhtU8xTmO9Il2iAHtQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Correlação &amp; Classificação</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FzbPK7jbqH4hacwY1Fa5KQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*l36-myZvToKaLpUWT-pGWw.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*0NxxqP3LpYtFMaRySUlWkw.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/1*nXNL03F9vh-KFIdPRjTBWw.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/545/1*YBZPqdZLeUcMNxS-DTbVSQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/579/1*QjfHsxKd9khTzDFyWyU2gQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*voEt4il-hfb7FC5PhSbBhg.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Limpeza dos Dados &amp; Teste Estatístico</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a6QyeRkn5ffUfWl9K-ZyWg.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*faKpaUmmrUA6H9QO-GeroA.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Visualização &amp; Classificação</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OzVf_YScC8pVVINJGwVpHA.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UxjfwSRnmeHuilLTbIU5zg.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VHL9VPt0YFxGRItr2_-rHA.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aeKHlwRYZE_Ywjpjalm8IQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*QMiDVQNn5EHgB8ypeX_aiA.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/826/1*TUFgWtGVqcssrVyuU6Nw-w.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OjELlS2Bf7Nur60Y-ZVbaQ.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sy5nH4ikoqnTSLl2x8SI8w.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*T2PLogzc_AveqorkiVUlZg.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NC3eI8DkQxjXbwZ4Z5j1Og.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*uLM_doK8A01oziNBsdhzCw.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lUhEHsxRTa6_C8mGKz3C_A.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*P71yVDzy_I9kUDQBDTn2zA.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Dados de Treinamento &amp; Teste</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*hPXBU0EAg_KV1XNocu8hVw.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zThU0MKyTz9i_Yf4yYmJpA.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><h4>Heatmap</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*uUcTBEg7dgRqOEhmkRc_4g.png" /><figcaption>Fonte: imagem própria #oale</figcaption></figure><p>Até breve =)</p><p><a href="https://www.linkedin.com/in/alexandreosi/">Alexandre Oliveira (o Ale)</a></p><p>Referências: Analyticsvidhya, Kaggle, StatsTest, Machine Mastery, Web.pdx.edu, Towards Data Science, StatsExchange (…)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89ecdac629b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>