Programação funcional com JavaScript – Funções puras

Iago Cavalcante em 24/01/2019 no site iMasters

Deivis Wingert

E aí, pessoal! Tudo certo?

Hoje vou começar a falar um pouco sobre programação funcional utilizando JavaScript, bem como as características desse paradigma e vou entrar na primeira parte desta série, que trará os conceitos e as definições das funções puras.

O que é programação funcional?

Nada mais é do que um paradigma onde os programas são executados por meio de avaliação de funções. No sentindo mais puro, é baseada em como funções, variáveis e valores trabalham de fato na matemática.

Além disso, usam uma abordagem mais declarativa do que imperativa em suas estruturas. Sendo assim, temos princípios fundamentais da programação funcional, sendo eles: funções puras, imutabilidade, recursão, composição de função, funções de primeira classe, lambdas e closures.

Neste primeiro artigo, falarei exclusivamente sobre funções puras.

Funções puras

Para uma função ser considerada pura, ela necessariamente tem que ter duas características:

• 1 – Dada a mesma entrada, sempre retornará a mesma saída: a função sempre dá o mesmo valor de retorno para os mesmos argumentos. Isso significa que a função não pode depender de nenhum estado mutável (objetos mutáveis são objetos cujo estado pode mudar, instanciar e atribuir valor a uma variável).
• 2 – Não causa efeito colateral: a função não pode causar efeitos colaterais. Ou seja, a função não acessa ou altera valores globais. Os efeitos secundários podem incluir Entrada/Saída (console.log, Math.random,Date.now).

Exemplo de função pura:

const multiplica = (a, b) => a * b;

Quais as vantagens de se utilizar uma função pura?

• Elas são de fácil processamento, teste e depuração, por não dependerem de estados mutáveis.
• O valor de retorno pode ser guardado, evitando assim uma re-computação no futuro.
• São mais fáceis de testar porque não há dependências (como log, ajax, banco de dados, etc) que precisam ser mockadas.

Como podemos ver, nem todas as funções de nossos sistemas serão puras, mas podemos tentar utilizar as funções puras em pelo menos 80% dos casos, sendo o valor restante destinado a funções de gravação de log, recuperação de data, valores randômicos e etc.

Principais técnicas de machine learning

Natália Raythz em 21/01/2019 no site iMasters

Medium

Se quiser aprender mais sobre machine learning, vá além do Python.

Algoritmos x Técnicas

Embora este artigo seja sobre as técnicas de machine learning, vamos falar brevemente sobre os algoritmos.

Não são a mesma coisa?

Genericamente falando, uma técnica é uma maneira de resolver algo. Agora quando temos um algoritmo, queremos dizer que temos uma entrada e precisamos de uma saída onde, com o algoritmo, damos os passos para chegar até a saída. Logo, o algoritmo pode usar várias técnicas para chegar na saída.

Técnicas de machine learning

• Regressão: na maioria dos livros de estatística encontramos regressão como uma medida de como a média de uma variável e os valores correspondentes de outros valores se relacionam entre si.
• Regressão média: o primo de Charles Darwin, Francis Galton, observou ervilhas durante anos (o experimento, junto com o Mendel, foi muito importante para o avanço dos estudos da genética). Ele concluiu que deixar a natureza fazer o seu trabalho resultaria em diversos tamanhos de ervilhas

A natureza no comando e as ervilhas maiores começam a produzir descendentes menores com o tempo. Bom, temos um certo tamanho para ervilhas que variam, mas podemos mapear esses valores para uma linha ou uma curva específica.

Mas o que a regressão tem a ver com o Machine Learning?

Com determinada técnica a regressão encontra sua base no aprendizado supervisionado. Isso é baseado para prever algo contínuo e numérico e começamos trabalhando nos valores do conjunto de dados que já conhecemos, comparando os valores conhecidos e previstos e identificando a diferença entre os valores esperados e previstos como erro.

Tipos de regressão que são utilizadas no machine learning:

• Regressão linear: quando podemos observar a relação entre um alvo e um preditor em uma linha reta, Por exemplo: y = P1x + P2 +
• Regressão não linear: Quando é observada uma relação não linear entre alvo e preditor, e não é uma linha reta

Neste gráfico, a linha se ajusta melhor a todos os dados marcados pelos pontos. Usando essa linha, podemos prever quais valores encontraremos para x = 70 (com um grau de incerteza).

Classificação

A classificação é uma técnica de mineração de dados que nos ajuda a fazer uma previsão de participação em grupos para instância de dados. Isso usa dados rotulados com antecedência, que é um tipo de aprendizado supervisionado.

Isso quer dizer que treinamos dados e esperamos “prever o futuro” – essa previsão quer dizer que classificamos os dados em dois atributos:

• Atributo de saída ou atributo dependente
• Atributo de entrada ou atributo independente

Métodos de classificação

• Indução da árvore de decisão: uma árvore de decisão da classe tuplas rotuladas. Possui ‘nós’ internos, ramificações e ‘nós’ de folha. Os nós internos possuem o teste em um atributo, as ramificações, os resultados do teste, os nós da folha e o rótulo da classe. Os envolvidos são: aprender e testar
• Classificação baseada em regras: é baseada em um conjunto de regras IF-THEN, ou seja, IF – condição e THEN – conclusão
• Retropropagação: o aprendizado da rede neural é também conhecido por construir conexões. A retropropagação é um algoritmo de aprendizado bem popular, pois ele iterativamente processa dados e compara o valor alvo com os resultados a aprender
• “Preguiçosos”: numa abordagem mais preguiçosa, a máquina guarda uma tupla de treinamento e aguarda outra tupla de teste. Isso suporta o aprendizado incremental e contrasta com a abordagem inicial do aprendiz

Clustering

É uma classificação não supervisionada. É uma análise de dados exploratória, sem dados rotulados disponíveis. Com o agrupamento, separamos os dados não rotulados em conjuntos finitos e discretos de estruturas de dados naturais.

Eles também se dividem em dois tipos:

• Clustering difícil: um objeto pertence a um único cluster.
• Clustering flexível: um objeto pertence a vários clusters.

É assim que um cluster se parece: Código QR, Aztec e Data Matrix estariam em um grupo; nós poderíamos chamar isso de códigos 2D. Os códigos de barras da ITF e os códigos de barras da Code 39 seriam agrupados em uma categoria de ‘Códigos 1D’.

Detecção de anomalias

Anomalia é algo que desvia do curso esperado. Com o machine learning, também (nem sempre) podemos querer detectar uma anomalia. Um exemplo seria detectar uma conta de dentista 85 obturações por hora. Isso equivale a 42 segundos por paciente. Outra seria encontrar uma nota especial do dentista apenas às quintas-feiras.

Tais situações levantam suspeitas, e a detecção de anomalias é uma ótima maneira de destacá-las, já que isso não é algo que procuramos especificamente.

Bom, por enquanto isso é tudo sobre algumas técnicas de machine learning utilizando Python. Não quis entrar em detalhes de códigos, pois já existe bastante material pela internet que detalha mais os códigos de cada técnica. Meu objetivo aqui era entrar na parte teórica de cada uma. Espero que tenham gostado.

Gerando gráficos em Excel com Java usando Apache POI

09/01/2018

por FELIPE RODRIGUES DA SILVA em iMasters

Olá, caros leitores!

Este é o meu primeiro artigo no portal. Venho compartilhar algumas soluções técnicas que demorei pra encontrar em alguns cenários bem específicos.

Acredito que grande parte dos desenvolvedores Java já conhecem a API de documentos Microsoft Apache POI e já fizeram uso dela para gerar relatórios simples. Hoje venho apresentar uma das funcionalidades que a biblioteca também oferece, que é a criação de gráficos.

Para a exemplificação, criei um projeto maven com o spring boot, instalando a dependência WEB, um arquivo index.html para realizar a requisição do arquivo e um controlador responsável por gerar o arquivo, conforme a estrutura definida na imagem abaixo:

A versão escolhida do POI foi a 3.17 (suportada por versões mais antigas do Java) e para que a solução funcione, é preciso importar duas bibliotecas no arquivo pom.xml conforme abaixo:

<dependency>
 <groupId>org.apache.poi</groupId>
 <artifactId>poi</artifactId>
 <version>3.17</version>
</dependency>
<dependency>
 <groupId>org.apache.poi</groupId>
 <artifactId>poi-ooxml</artifactId>
 <version>3.17</version>
</dependency>

Nesta versão do POI temos algumas limitações sobre criar gráficos em um nível alto de representação (modo simples). Então, são “suportados” pelo apache poi, nesta versão, apenas gráficos de linhas e de dispersão, mas isso não quer dizer que só se pode gerar esses dois tipos de gráficos.

O POI oferece para os outros tipos presentes no Excel, a biblioteca poi-ooxml-schemas, que disponibiliza objetos subjacentes baseados no xml gerado por arquivos xlsx.

Então, caso precise gerar outros tipos de gráficos na versão 3.17, será um pouco mais trabalhoso, mas não impossível (disponibilizarei posteriormente artigos ensinando a gerar outros tipos de gráficos nessa versão do poi).

Hoje já temos a versão 4.0, que oferece, em um nível alto de representação, suporte para outros tipos de gráficos. Porém, esta versão só pode ser utilizada em ambientes cuja versão mínima do Java é a 8 (assuntos para os próximos artigos).

Para que o código não ficasse muito extenso, utilizei uma planilha pronta como template, que exibe os gastos em determinadas categorias do primeiro semestre do ano de 2018. Nela, lemos os dados e geramos o gráfico do tipo linha conforme a imagem abaixo:

Os passos para gerar gráficos são simples – utilizamos classes e interfaces definidas nos pacotes.

· org.apache.poi.ss.usermodel

· org.apache.poi.xssf.usermodel

· org.apache.poi.ss.util

O principal é deixar bem claro o mapeamento dos dados dentro da planilha, para que ao selecionar as células que gerarão o gráfico, não ocorra erros (você só saberá se ocorreu erro de seleção de dados após abrir o arquivo gerado).

O código do controlador que gera o arquivo está abaixo, contendo comentários sobre os passos para criar o gráfico.

package com.teste.poi.testeExcel.controller;

import java.io.IOException;
import java.io.InputStream;

import javax.servlet.http.HttpServletResponse;

import org.apache.poi.ss.usermodel.charts.AxisPosition;
import org.apache.poi.ss.usermodel.charts.ChartAxis;
import org.apache.poi.ss.usermodel.charts.ChartDataSource;
import org.apache.poi.ss.usermodel.charts.DataSources;
import org.apache.poi.ss.usermodel.charts.LegendPosition;
import org.apache.poi.ss.usermodel.charts.LineChartData;
import org.apache.poi.ss.usermodel.charts.LineChartSeries;
import org.apache.poi.ss.usermodel.charts.ValueAxis;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.xssf.usermodel.XSSFChart;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFDrawing;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xssf.usermodel.charts.XSSFChartLegend;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("excel")
public class ExcelController {

    @GetMapping("/grafico")
    public ResponseEntity<String> exportExcelGrafico(HttpServletResponse response){

        try{

            InputStream input = ExcelController.class.getResourceAsStream("/templates/gastos.xlsx");

            XSSFWorkbook book = getExcelFile(input);

            response.setContentType("application/octet-stream");
            response.setHeader("Content-Disposition",
                    "attachment; filename=\""
                            + "Gerando Gráfico excel"
                            + ".xlsx\"");

            book.write(response.getOutputStream());
            return new ResponseEntity<String>(HttpStatus.OK);
        }
        catch(Exception e){
            return new ResponseEntity<String>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
        
    }

    public XSSFWorkbook getExcelFile(InputStream fileTemplate) throws Exception{

        try{
            XSSFWorkbook book = new XSSFWorkbook(fileTemplate);
            XSSFSheet abaSheet = book.getSheet("gastos");
            int numRows = abaSheet.getPhysicalNumberOfRows();

            XSSFDrawing designer = abaSheet.createDrawingPatriarch();
            // criamos a posição do gráfico
            XSSFClientAnchor position = designer.createAnchor(0, 0, 0, 0, 0, numRows+1, 12, numRows +12);
            XSSFChart graphic = designer.createChart(position);
            // aqui definimos aonde serão exibidos as categorias dos gastos
            XSSFChartLegend legend = graphic.getOrCreateLegend();
            legend.setPosition(LegendPosition.BOTTOM);

            // aqui definimos o título que é apresentado dentro do gráfico
            graphic.setTitleText("Gastos do primeiro semestre de 2018");

            // aqui criamos o tipo do gráfico, no caso um gráfico de linha
            LineChartData data = graphic.getChartDataFactory().createLineChartData();

            // aqui criamos o eixo y  que exibirá os valores minímos e máximos na horizontal
            ValueAxis yAxis = graphic.getChartAxisFactory().createValueAxis(AxisPosition.LEFT);

            // aqui criamos o eixo x que exibirá os meses do semestre  para marcar os valores no gráfico
            //  de cada categoria 
            ChartAxis xAxis = graphic.getChartAxisFactory().createCategoryAxis(AxisPosition.BOTTOM);
            yAxis.setMinimum(0);
        
            /*
                Aqui  criamos uma referência para  as categorias através da posição de cada uma delas.
                Como o nome does meses estão presentes na primeira linha da planilha e temos apenas 6 meses,
                definimos um range da linha 0  começando da coluna 1 , até a 6 coluna
            */
            ChartDataSource<String> columns = DataSources.fromStringCellRange(abaSheet, new CellRangeAddress(0,0,1,6));

            /*
                Agora iremos , através do contador i utilizado para percorrer as lnnhas,
                 selecionar as linhas das categorias com os dados de cada mes.
            */
            for(int i = 1 ; i < numRows; i++){
                // aqui  criamos referência aos dados de cada linha da categoria de gastos
                // novamente utilizamos um range de colunas de 1 a 6 , pois é onde os gastos de cadas mes estão
                ChartDataSource<Number> valueLinhas = DataSources.fromNumericCellRange(abaSheet, new CellRangeAddress(i,i,1,6));
                
                /*
                    Nesta linha adicionamos os valores da categoria de gastos , relacionados com os meses definidos
                    na variável columns, e atribuímos a váriavel série uma referência a categoria de dados que acabou de 
                    ser colocada nos dados do gráfico
                */
                LineChartSeries serie = data.addSeries(columns, valueLinhas);
                /*
                 * Aqui criamos referência a célula que contém o título da categoria de gastos e atríbuimos a varíavel de referência 'serie'
                 * Observação : utilizamos a string 'gastos' porque é o nome da aba em que estamos trabalhando,
                 *  se colocarmos nomes nas abas do arquivo , é necessário que criemos a referência da célula,
                 *  com o nome da aba em que ela se encontra
                 */
                CellReference titleSerie = new CellReference("gastos",i,0,false,false);
                serie.setTitle(titleSerie);
            }

            /*            
                E   por último atribuímos a váriavel gráphic todads as definições de dados do gráfico
                com os eixos definidos.
            */
            graphic.plot(data, new ChartAxis[] { xAxis , yAxis });

            return book;
        }catch(IOException ex){
            System.out.print("Erro ao carregar arquivo :" + ex.getMessage());
            throw ex;
        }     
    }
}

Temos o resultado como na imagem abaixo:

Como podem ver, não é muito difícil e também não é muito utilizado em vários cenários. Contudo, talvez um dia seja necessário.

Tendo em vista que a versão 4.0 do poi foi lançada no dia 07/09/2018, e foi retirado suporte para o Java 6 e 7, muitas aplicações que utilizam a biblioteca ainda não foram atualizados, ou – por restrição do Java – não podem atualizar.

Espero que tenha ajudado!