Este artigo é a primeira parte da série de blogs "Greenplum for End-to-End Data Science & ML", que aborda como usar as funções integradas de análise de banco de dados do Greenplum para lidar com projetos de ciência de dados, desde a experimentação até a implantação massiva.

O crescimento, o desafio e a oportunidade dos dados

Estamos na era digital e tudo o que fazemos com nossos smartphones, tablets, computadores e até eletrodomésticos produz uma enorme quantidade e variedade de dados. Embora isso possa parecer empolgante, coletar dados para ter mais dados não é um exercício significativo ou produtivo. Precisamos entender quais objetivos do usuário ou resultados de negócios podem se beneficiar desses dados e investir tempo e esforço para extrair valor dos dados. E é aqui que os cientistas de dados entram em cena.

Como os cientistas de dados podem ajudar

Entre todos os campos relacionados a dados, a ciência de dados é um campo de estudo que utiliza dados e modelagem quantitativa para criar resultados significativos para os usuários. O cientista de dados se envolve em uma ampla gama de atividades neste contexto, incluindo, mas não se limitando ao seguinte:

1. Parceria com designers para criar empatia com os usuários para entender suas necessidades e explorar como podemos usar dados e algoritmos para encantá-los
2. Priorize o que construir a seguir com os gerentes de produto.
3. Colabore com engenheiros de dados na identificação e preparação de dados para análise.
4. Explore os dados e crie modelos de máquina para atender às necessidades do usuário — geralmente codificando em Python, R ou SQL.
5. Integre-se com engenheiros de software para implantar modelos como serviços a serem consumidos por aplicativos ou diretamente pelos usuários.
6. Repetir iterativamente (1)-(5) para o valor de acionamento contínuo para usuários

As atividades listadas acima incluem aspectos relacionados a como os cientistas de dados trabalham (por exemplo, centrado no usuário, enxuto, ágil) e também as ferramentas e tecnologias necessárias para ser mais produtivo. Focamos esta série de blog técnico no componente de ferramentas relacionado principalmente a (4) na lista acima.

Especificamente, exploramos cenários em que o cientista de dados explora dados e constrói modelos de aprendizado de máquina com um conjunto massivo de dados. Nesse contexto, o cientista de dados pode encontrar desafios técnicos específicos, incluindo os seguintes:

• Pipeline lento de ciência de dados com grandes volumes de dados
• Atingindo os limites da memória e da computação em tempos de execução Python/R tradicionais
• Funcionalidade analítica limitada em plataformas que permitem a computação de big data

Por que Greenplum?

Exportar dados de um banco de dados e importá-los para um servidor ou ambiente de desktop com ferramentas comumente usadas para ciência de dados (por exemplo, Python, R) não é um fluxo de trabalho ideal para análise de big data. Conforme descrito acima, os cientistas de dados podem precisar de ajuda com as limitações de memória e escalabilidade dessas ferramentas e os gargalos restritivos associados à transferência de grandes quantidades de dados entre diferentes plataformas.

É aqui que alavancar a ferramenta certa se torna uma decisão importante para o cientista de dados. Nesta postagem, nos concentramos no Greenplum , um mecanismo PostgreSQL de processamento massivamente paralelo que fornece ferramentas integradas para cientistas de dados para exploração de dados em alta escala e treinamento de modelos. Essas ferramentas e extensões incluem:

• Apache MADlib para aprendizado de máquina
• Extensões de linguagem procedural para massivamente paralelizar Python e R
• PostGIS para análise geoespacial e GPText para pesquisa e processamento de texto
• Interoperabilidade com ferramentas de dashboard como Tableau, PowerBI…

Parte 1: Configuração e conectividade

1. Instalar pacotes:

!pip install ipython-sql pandas numpy sqlalchemy plotly-express sql_magic pgspecial

import pandas as pd
import numpy as np
import os
import sys
import plotly_express as px
# For DB Connection
from sqlalchemy import create_engine
import psycopg2
import pandas.io.sql as psql
import sql_magic

• Instalação no cliente:

!pip install ipython-sql

% load_ext _ sql
% sql postgresql://<user>:<password>@<IP_address>:<port>/<database_name>

%% sql 
SELECT version ();

       
                

                    
                    
                
            

Nesta série de blogs, um conjunto de dados de notícias financeiras diárias para ações da Kaggle com licença CC0: domínio público foi selecionado para uso. Usaremos o Greenplum e seguiremos o ciclo de ciência de dados (Exploração de dados — Preparação de dados — Modelagem de dados — Avaliação de modelo — Implantação de modelo) para treinar um modelo de PNL para processar Análise Sentimental para notícias.

O conjunto de dados contém manchetes Raw de Benzinga.com e seus parceiros. Seu tamanho é aumentado para cerca de quatro milhões de linhas , o que é um conjunto de dados bastante extenso para manipulação e possui sete colunas :

• docid — inteiro: índice único
• título — texto: título da linha
• conteúdo — texto: equivalente ao título
• url — texto: link relacionado a Notícias
• editor — texto: editor de notícias
• data — data: data de publicação
• estoque — texto: símbolo de cotações de ações relacionado a notícias

Parte 3: Preparação de dados

O conjunto de dados é salvo na tabela source_financial_news. Vamos dar uma olhada em uma linha desta tabela:

%%sql
SELECT * FROM source_financial_news LIMIT 1;

      
                

                    
                    
                
            

%%sql
SELECT count(*) FROM source_financial_news;

      
                

                    
                    
                
            

Como as notícias antigas não serão usadas com frequência, vamos criar uma tabela ds_demo.financial_newsparticionada por dateonde estamos interessados ​​apenas nas notícias publicadas após 2010.

Definir a chave distribuída para o índice único docid permite que os dados sejam distribuídos igualmente em diferentes segmentos.

Além disso, definir o armazenamento como orientado a coluna e otimizado por anexo como True melhora o desempenho analítico geral.

%%sql 
DROP TABLE IF EXISTS ds_demo.financial_news;
CREATE TABLE ds_demo.financial_news 
(
    LIKE source_financial_news
)
WITH (appendoptimized=true, orientation=column)
DISTRIBUTED BY(docid)
PARTITION BY RANGE (date)
(
    START (date '2010-01-01') INCLUSIVE
    END (date '2024-01-01') EXCLUSIVE
    EVERY (INTERVAL '1 month'), 
    DEFAULT PARTITION old_news
);

-- Insert data from the source table into a newly created partitioned table
INSERT INTO ds_demo.financial_news SELECT * FROM source_financial_news;

%sql \d+ ds_demo.financial_news

      
                

                    
                    
                
            

Verifique se nossa mesa está distribuída uniformemente

Agora que nossa nova tabela foi criada, vamos verificar sua distribuição calculando o desvio padrão do número de linhas por segmento.

%%sql
-- Standard deviation to check table distribution
SELECT STDDEV(count) 
FROM (
    SELECT gp_segment_id, COUNT(*)
    FROM ds_demo.financial_news
    GROUP BY 1
) table_distribution ;

      
                

                    
                    
                
            

Partições para digitalizar apenas os dados necessários

Com Partições, não há necessidade de verificar as partições mais antigas para responder à consulta abaixo.

%%sql
-- Show the execution plan "EXPLAIN" and check scanned partitions
EXPLAIN SELECT COUNT(*) 
        FROM ds_demo.financial_news 
          WHERE date >= '2020-01-01'::date

      
                

                    
                    
                
            

Parte 4: Análise exploratória de dados com SQL e MADlib

Depois de preparar nossa ds_demo.financial_newstabela, usaremos SQL ( sqlmagicpara resultados interativos com o banco de dados Greenplum) e MADlib , uma biblioteca baseada em SQL de código aberto para análise escalonável no banco de dados .

Ele fornece implementações paralelas de dados de métodos matemáticos, estatísticos, gráficos e de aprendizado de máquina para dados estruturados e não estruturados.

1. Outra visão geral das duas primeiras linhas da Tabela

%%sql 
SELECT * FROM ds_demo.financial_news LIMIT 2 ;

      
                

                    
                    
                
            

• Certifique-se de que a MADlibextensão está habilitada!

%sql SELECT madlib.version();

       
                

                    
                    
                
            

%%sql
DROP TABLE IF EXISTS ds_demo.financial_news_summary;
SELECT * FROM madlib.summary( 
        'ds_demo.financial_news', 'ds_demo.financial_news_summary'  
);

      
                

                    
                    
                
            

%%sql
SELECT 
    target_column, distinct_values, missing_values, blank_values, 
    min, max, mean, median, variance, most_frequent_values
FROM ds_demo.financial_news_summary;

      
                

                    
                    
                
            

Para ver a evolução do número de notícias ao longo dos meses:

1. Em primeiro lugar, converta a datecoluna no formato Ano-Mês usando a to_charfunção SQL.
2. Em seguida, agrupe pelos formatados datee calcule as frequências usandoCOUNT(*)
3. Ordene os resultados finais com base no arquivo date.

%%read_sql df_news_per_date
SELECT 
    to_char(date,'YYYY-MM') as date, 
    COUNT(*) 
FROM ds_demo.financial_news 
    WHERE date IS NOT NULL
GROUP BY 1
ORDER BY 1
DESC;

       
                

                    
                    
                
            

px.line(df_news_per_date, 
        x = 'date', 
        y = 'count', 
        title='Evolution of number of Stock Market News over time')

       
                

                    
                    
                
            

%%read_sql df_histogram
WITH drb_stats AS (
    SELECT min(length(title)) AS min,
           max(length(title)) AS max
      FROM ds_demo.financial_news
),
     histogram AS (
   SELECT width_bucket(length(title), min, max, 10) AS bucket,
          int4range(MIN(length(title)), MAX(length(title)), '[]') AS range,
          COUNT(*) AS freq
     FROM ds_demo.financial_news, drb_stats
     GROUP BY bucket
     ORDER BY bucket
)

SELECT bucket, range, freq,
        repeat('■',
               (   freq::FLOAT
                 / MAX(freq) OVER()
                 * 30
               )::INT
        ) AS bar
FROM histogram
ORDER BY bucket ASC
;

      
                

                    
                    
                
            
fig = px.histogram(y = df_histogram.freq, 
                   x = df_histogram.range.astype(str), 
                   nbins=10, 
                   title = 'News titles length histogram')
fig.update_layout(yaxis_title="Frequencies", xaxis_title = 'Bucket (range)')
fig.show()

      
                

                    
                    
                
            

Use MADlib summaryos resultados para visualizar os estoques mais frequentes.

%%read_sql df_stock_frequencies
SELECT most_frequent_values, mfv_frequencies 
FROM ds_demo.financial_news_summary 
  WHERE target_column = 'stock';

      
                

                    
                    
                
            
px.bar(y = df_stock_frequencies.most_frequent_values.values[0], 
       x = df_stock_frequencies.mfv_frequencies.values[0], 
       color = df_stock_frequencies.most_frequent_values.values[0],
       labels={'x':'News frequency', 'y': 'Stock'},text_auto='.2s',
       title="10 Most Frequent Stocks")

      
                

                    
                    
                
            

Vamos encontrar os editores mais dominantes em nosso conjunto de dados:

%%read_sql df_publisher_frequencies
SELECT most_frequent_values, mfv_frequencies 
FROM ds_demo.financial_news_summary 
  WHERE target_column = 'publisher';

      
                

                    
                    
                
            
px.bar(y = df_publisher_frequencies.most_frequent_values.values[0], 
       x = df_publisher_frequencies.mfv_frequencies.values[0], 
       color = df_publisher_frequencies.most_frequent_values.values[0],
       labels={'x':'News frequency', 'y': 'Publisher'},text_auto='.2s',
       title="Top 10 - Frequent News sources")

      
                

                    
                    
                
            

%%read_sql df_url_domain
SELECT 
        split_part(REGEXP_REPLACE(url, '^(https?://)?(www\.)?', ''), '/', 1) AS source_url,
        count(*) as frequency
FROM (SELECT 
        CASE WHEN url IS NOT NULL THEN url ELSE 'Other' END 
        AS url 
      FROM ds_demo.financial_news
      ) t
GROUP BY 1
ORDER BY 2 ASC;

      
                

                    
                    
                
            
fig = px.pie(df_url_domain, 
             names = 'source_url', values = 'frequency',  
             width=800, height=600, 
             title='Source websites of Stock Market News')

fig.update_traces(textposition='inside', textinfo='percent+label')
fig.show()

      
                

                    
                    
                
            

Para concluir, os analistas e cientistas de dados podem liberar o desempenho do Greenplum e os recursos de processamento massivamente paralelos para processar e explorar grandes conjuntos de dados usando funções analíticas integradas, combinando SQL e Apache MADlib e visualizando os resultados usando Python .

Em um blog posterior, descobriremos como o Greenplum habilita a análise avançada de texto e a pesquisa de texto processando grandes quantidades de dados textuais usando sua solução GPText (Greenplum Text) .

Obrigado por ler! Quaisquer comentários ou sugestões são bem-vindos! Confira outros artigos da Greenplum aqui .