Dieser Artikel ist der erste Teil der Blogreihe „Greenplum für End-to-End Data Science & ML“, in der es darum geht, wie man die integrierten datenbankinternen Analysefunktionen von Greenplum nutzt , um Data-Science-Projekte vom Experimentieren bis zum massiven Einsatz anzugehen.

Das Wachstum, die Herausforderung und die Chance von Daten

Wir leben im digitalen Zeitalter und alles, was wir mit unseren Smartphones, Tablets, Computern und sogar Haushaltsgeräten tun, erzeugt eine enorme Menge und Vielfalt an Daten. Das mag zwar spannend klingen, aber das Sammeln von Daten, um mehr Daten zu haben, ist weder eine sinnvolle noch produktive Übung. Wir müssen verstehen, welche Benutzerziele oder Geschäftsergebnisse von diesen Daten profitieren könnten, und Zeit und Mühe investieren, um aus den Daten einen Mehrwert zu ziehen. Und hier kommen Datenwissenschaftler ins Spiel.

Wie Datenwissenschaftler helfen könnten

Unter allen datenbezogenen Bereichen ist die Datenwissenschaft ein Studienbereich, der Daten und quantitative Modellierung nutzt, um aussagekräftige Ergebnisse für Benutzer zu erzielen. Der Datenwissenschaftler engagiert sich in diesem Zusammenhang in einer Vielzahl von Aktivitäten, unter anderem in den folgenden:

1. Wir arbeiten mit Designern zusammen, um Empathie für die Benutzer aufzubauen, um ihre Bedürfnisse zu verstehen und herauszufinden, wie wir Daten und Algorithmen nutzen können, um sie zu begeistern
2. Legen Sie gemeinsam mit den Produktmanagern fest, was als Nächstes entwickelt werden soll.
3. Arbeiten Sie mit Dateningenieuren bei der Identifizierung und Vorbereitung von Daten für die Analyse zusammen.
4. Erkunden Sie Daten und erstellen Sie Maschinenmodelle, um den Benutzeranforderungen gerecht zu werden – am häufigsten programmieren Sie in Python, R oder SQL.
5. Arbeiten Sie mit Softwareentwicklern zusammen, um Modelle als Dienste bereitzustellen, die von Anwendungen oder direkt von Benutzern genutzt werden können.
6. Wiederholen Sie (1)–(5) iterativ, um den Wert für Benutzer kontinuierlich zu steigern

Die oben aufgeführten Aktivitäten umfassen Aspekte im Zusammenhang mit der Arbeitsweise von Datenwissenschaftlern (z. B. benutzerzentriert, schlank, agil) und auch mit den Tools und Technologien, die für eine maximale Produktivität erforderlich sind. Wir konzentrieren uns in dieser technischen Blogserie auf die Werkzeugkomponente, die sich hauptsächlich auf (4) in der obigen Liste bezieht.

Konkret untersuchen wir Szenarien, in denen der Datenwissenschaftler Daten untersucht und Modelle für maschinelles Lernen mit einem riesigen Datensatz erstellt. In diesem Zusammenhang kann der Datenwissenschaftler auf besondere technische Herausforderungen stoßen, darunter die folgenden:

• Langsame Data-Science-Pipeline mit großen Datenmengen
• Erreichen Sie die Grenzen von Speicher und Rechenleistung in herkömmlichen Python/R-Laufzeiten
• Begrenzte analytische Funktionalität in Plattformen, die Big-Data-Computing ermöglichen

Warum Greenplum?

Der Export von Daten aus einer Datenbank und deren Import in eine Server- oder Desktop-Umgebung mit häufig verwendeten Tools für die Datenwissenschaft (z. B. Python, R) ist kein idealer Arbeitsablauf für Big-Data-Analysen. Wie oben beschrieben, benötigen Datenwissenschaftler möglicherweise Hilfe bei den Speicher- und Skalierbarkeitsbeschränkungen dieser Tools sowie bei den restriktiven Engpässen, die mit der Übertragung großer Datenmengen zwischen verschiedenen Plattformen verbunden sind.

An dieser Stelle wird der Einsatz des richtigen Tools zu einer wichtigen Entscheidung für den Datenwissenschaftler. In diesem Beitrag konzentrieren wir uns auf Greenplum , eine massiv parallel verarbeitende PostgreSQL-Engine, die integrierte Tools für Datenwissenschaftler für die Datenexploration und das Modelltraining in großem Maßstab bereitstellt. Zu diesen Tools und Erweiterungen gehören:

• Apache MADlib für maschinelles Lernen
• Prozedurale Spracherweiterungen zur massiven Parallelisierung von Python und R
• PostGIS für Geodatenanalysen und GPText für die Textsuche und -verarbeitung
• Interoperabilität mit Dashboarding-Tools wie Tableau, PowerBI…

Teil 1: Einrichtung und Konnektivität

1. Pakete installieren:

!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

• Installation auf dem Client:

!pip install ipython-sql

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

%% sql 
SELECT version ();

       
                

                    
                    
                
            

In dieser Blog-Serie wurde ein Daily Financial News- Datensatz für Aktien von Kaggle mit der Lizenz CC0: Public Domain zur Verwendung ausgewählt. Wir werden Greenplum verwenden und dem Data-Science-Zyklus (Datenexploration – Datenvorbereitung – Datenmodellierung – Modellbewertung – Modellbereitstellung) folgen, um ein NLP-Modell für die Verarbeitung von Sentimentalanalysen für Nachrichten zu trainieren.

Der Datensatz enthält Raw-Schlagzeilen von Benzinga.com und seinen Partnern. Seine Größe wird auf etwa vier Millionen Zeilen erhöht , was einen ziemlich umfangreichen Datensatz zur Manipulation darstellt, und er hat sieben Spalten :

• docid – Ganzzahl: Index eindeutig
• Titel – Text: Überschrift der Zeile
• Inhalt – Text: entspricht dem Titel
• URL – Text: Link zu Neuigkeiten
• Herausgeber – Text: Nachrichtenverleger
• Datum – Datum: Veröffentlichungsdatum
• stock – Text: Börsenticker-Symbol im Zusammenhang mit Nachrichten

Teil 3: Datenvorbereitung

Der Datensatz wird in der Tabelle gespeichert source_financial_news. Werfen wir einen Blick auf eine Zeile dieser Tabelle:

%%sql
SELECT * FROM source_financial_news LIMIT 1;

      
                

                    
                    
                
            

%%sql
SELECT count(*) FROM source_financial_news;

      
                

                    
                    
                
            

Da alte Nachrichten nicht häufig verwendet werden, erstellen wir eine Tabelle, ds_demo.financial_newsin dateder wir uns nur für Nachrichten interessieren, die nach 2010 veröffentlicht wurden.

Durch Festlegen des verteilten Schlüssels auf den eindeutigen Index docid können Daten gleichmäßig auf verschiedene Segmente verteilt werden.

Darüber hinaus verbessert die Einstellung der Speicherung auf spaltenorientiert und appendoptimized auf „True“ die Analyseleistung insgesamt.

%%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

      
                

                    
                    
                
            

Überprüfen Sie, ob unsere Tabelle gleichmäßig verteilt ist

Nachdem unsere neue Tabelle erstellt wurde, überprüfen wir ihre Verteilung, indem wir die Standardabweichung der Anzahl der Zeilen pro Segment berechnen.

%%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 ;

      
                

                    
                    
                
            

Partitionen zum Scannen nur benötigter Daten

Bei Partitionen ist es überhaupt nicht erforderlich, die älteren Partitionen zu scannen, um die folgende Abfrage zu beantworten.

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

      
                

                    
                    
                
            

Teil 4: Explorative Datenanalyse mit SQL & MADlib

Nachdem wir unsere ds_demo.financial_newsTabelle vorbereitet haben, verwenden wir SQL ( sqlmagicfür interaktive Ergebnisse mit der Greenplum-Datenbank) und MADlib , eine Open-Source-SQL-basierte Bibliothek für skalierbare datenbankinterne Analysen .

Es bietet datenparallele Implementierungen mathematischer, statistischer, grafischer und maschineller Lernmethoden für strukturierte und unstrukturierte Daten.

1. Eine weitere Übersicht über die ersten beiden Zeilen der Tabelle

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

      
                

                    
                    
                
            

• Stellen Sie sicher, dass die MADlibErweiterung aktiviert ist!

%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;

      
                

                    
                    
                
            

Um die Entwicklung der Anzahl der Nachrichten im Laufe der Monate zu sehen:

1. Konvertieren Sie zunächst die dateSpalte mithilfe der to_charSQL-Funktion in das Jahr-Monat-Format.
2. Gruppieren Sie dann nach Format dateund berechnen Sie die Häufigkeiten anhandCOUNT(*)
3. Ordnen Sie die Endergebnisse basierend auf der 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()

      
                

                    
                    
                
            

Verwenden Sie MADlib summarydie Ergebnisse, um die häufigsten Bestände zu visualisieren.

%%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")

      
                

                    
                    
                
            

Suchen wir die dominantesten Verlage in unserem Datensatz:

%%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()

      
                

                    
                    
                
            

Zusammenfassend lässt sich sagen, dass Datenanalysten und Wissenschaftler die Leistung von Greenplum und die Möglichkeiten der massiv parallelen Verarbeitung nutzen können, um große Datensätze mithilfe integrierter Analysefunktionen zu verarbeiten und zu untersuchen, indem sie SQL und Apache MADlib kombinieren und die Ergebnisse mit Python visualisieren .

In einem späteren Blog werden wir entdecken, wie Greenplum erweiterte Textanalyse und Textsuche ermöglicht , indem es mithilfe seiner GPText-Lösung (Greenplum Text) große Mengen an Textdaten verarbeitet .

Danke fürs Lesen! Alle Kommentare oder Vorschläge sind willkommen! Weitere Greenplum-Artikel finden Sie hier .