Almacén de datos con PostgreSQL en Python para científicos de datos

Este post fue difundido como parte del Blogatón de ciencia de datos

Introducción

Almacén de datos generaliza y mezcla datos en un espacio multidimensional. La construcción o estructura de un almacén de datos implica la limpieza de datos, la integración de datos y la transformación de datos, y puede verse como un «paso previo al procesamiento importante para la minería de datos».

Al mismo tiempo, los almacenes de datos proporcionan procesamiento analítico en línea (llamado OLAP) herramientas para el análisis interactivo de datos multidimensionales de diversa granularidad, lo que facilita la generalización y minería de datos efectivas. Hay muchas otras funciones de minería de datos, como asociación,
clasificación, predicción y agrupación en clústeres, que se pueden integrar con las operaciones OLAP para impulsar la extracción interactiva del conocimiento.

Es es por esto que que el almacén de datos se ha convertido en una importante plataforma escalada para el análisis de datos y OLAP. El almacén de datos proporcionará una plataforma constructiva para la minería de datos. Por eso, el almacenamiento de datos y OLAP forman un paso esencial en el procedimiento de descubrimiento de conocimiento (KDD). Esta es la descripción general que es esencial para comprender el procedimiento general de minería de datos y descubrimiento de conocimientos.

Ahora entendamos el concepto básico del almacén de datos.

Concepto básico de almacén de datos:

El almacenamiento de datos ofrece arquitecturas y herramientas para que los profesionales empresariales organicen, comprendan y utilicen estos datos de forma sistemática para tomar decisiones estratégicas. Los sistemas de almacenamiento de datos son herramientas beneficiosas en el mundo competitivo y en rápida evolución de hoy. Desde los últimos años, muchas compañías e industrias han gastado muchos millones de dólares en la construcción de almacenes de datos para toda la compañía.

«Entonces, ¿qué es exactamente un almacén de datos?» En términos generales, un almacén de datos se refiere a un repositorio de datos que se mantiene de forma separada de las bases de datos operativas de una organización. Los almacenes de datos posibilitan la integración de una gama de sistemas de aplicaciones. Las cuatro palabras clave (enfocadas al tema, integradas, variables en el tiempo y no volátiles) distinguen los almacenes de datos de otros sistemas de almacenamiento de datos, como
sistemas de bases de datos relacionalesRDBMS), sistemas de procesamiento de transacciones y otros sistemas de archivos.

Hay tres claves para poner en práctica un almacén de datos:

– servidor

– Tablero

– Indexación

Analicemos todos estos puntos en detalle: –

1) Servidor:

Postgre SQL

«Postgre SQL» es un sistema de base de datos relacional open source (RDMS). Aún cuando es un sistema de administración de bases de datos estructuradas (DBMS), además almacena datos no estructurados. Lo más importante es que la interfaz gráfica de usuario de Postgre SQL hace que sea muy fácil entregar y administrar bases de datos en el montaje.

Antes de continuar, debe descargar e instalar Postgres usando el link PostgreSQL.

Una vez completada la instalación, puede iniciar sesión en el servidor ejecutando la aplicación que abrirá un portal en su navegador de pgadmin.

Hay una base de datos predeterminada etiquetada como Postgre, a pesar de esto, puede crear su propia base de datos haciendo clic con el botón derecho en el «Bases de datos ” menú y después seleccione «Crear» para crear una nueva base de datos.

2) Implementación de Python

Ahora que hemos creado nuestro servidor y base de datos, primero debe instalar el paquete llamado «sqlalchemy » que se utilizará para conectarse a la base de datos a través de Python. Además puede descargar e instalar este paquete usando el siguiente comando en el indicador de Anaconda como-

pip install sqlalchemy

Instalemos y después importemos otras bibliotecas imprescindibles en el script de Python de la próxima manera:

from sqlalchemy import create_engine
import psycopg2
import pandas as pd
import streamlit as st

Ahora, necesitamos determinar una conexión entre nuestro «records_db ” base de datos y crear una nueva tabla donde podamos almacenar nuestros registros. Al mismo tiempo, necesitamos crear otra conexión con el «datasets_db » base de datos donde podemos almacenar nuestros conjuntos de datos.

p_engine = create_engine("postgresql://<username>:<password>@localhost:5432/records_db")
p_engine_dataset = create_engine("postgresql://<username>:<password>@localhost:5432/datasets_db")
p_engine.execute("CREATE TABLE IF NOT EXISTS records (name text PRIMARY KEY, details text[])")

Como conocemos la convención de nomenclatura de postegre, los nombres de las tablas deben comenzar con guiones bajos (_) o letras (“a, b, c” y no números), no deben contener guiones (-) y tener menos de 64 caracteres. Considere nuestro «registros» tabla, crearemos una «nombre» campo con un «texto» tipo de datos declarado como CLAVE PRIMARIA y un detalles campo como texto[](capacitación) que es la notación de Postgres para una matriz unidimensional. Al mismo tiempo, si desea almacenar las credenciales de su base de datos de forma segura, guárdelas en un archivo de configuración y después invoquelas como parámetros en su código según sus requerimientos.

Por eso, vamos a crear las siguientes cinco funciones que son para leer, escribir, actualizar, listar nuestros datos hacia / desde nuestra base de datos. Vamos a ver:-

def write_record(name,details,p_engine):
    p_engine.execute("INSERT INTO records (name,details) VALUES ('%s','%s')" % (name,details))

def read_record(field,name,p_engine):
    result = p_engine.execute("SELECT %s FROM records WHERE name="%s"" % (field,name))
    return result.first()[0]
    
def update_record(field,name,new_value,p_engine):
    p_engine.execute("UPDATE records SET %s="%s" WHERE name="%s"" % (field,new_value,name))

def write_dataset(name,dataset,p_engine):
    dataset.to_sql('%s' % (name),p_engine,index=False,if_exists="replace",chunksize=1000)

def read_dataset(name,p_engine):
    try:
        dataset = pd.read_sql_table(name,p_engine)
    except:
        dataset = pd.DataFrame([])
    return dataset

def list_datasets(p_engine):
    datasets = p_engine.execute("SELECT table_name FROM information_schema.tables WHERE table_schema="public" ORDER BY table_name;")
    return datasets.fetchall()

3) Tablero de instrumentos:

Streamlit

«Streamlit» es un framework web Python puro que nos posibilita desarrollar e poner en práctica interfaces de usuario (UI) y aplicaciones en tiempo real. Aquí estamos usando streamlit para renderizar el tablero para interactuar con la base de datos.

En el código que se muestra a continuación, estamos usando diferentes entradas de texto para insertar los valores en nuestros registros, matrices y nombres para nuestros conjuntos de datos. A continuación, usamos las funciones de Streamlit para visualizar de forma interactiva nuestro conjunto de datos en forma de gráfico y además como marco de datos.

st.title('Dashboard')
column_1, column_2 = st.beta_columns(2)

with column_1:
    st.header('Save records')
    name = st.text_input('Please enter name')
    details = st.text_input('Please enter your details (separated by comma ",")')
    details = ('{%s}' % (details))
    if st.button('Save record to database'):
        write_record(name,details,p_engine)
        st.info('Name: **%s** and details: **%s** saved to database' % (name,details[1:-1]))

    st.header('Update records')
    field = st.selectbox('Please select field to update',('name','details'))
    name_key = st.text_input('Please enter name of record that to be updated')    
    if field == 'name':
        updated_name = st.text_input('Please enter your updated name')
        if st.button('Update records'):
            update_record(field,name_key,updated_name,p_engine)
            st.info('Updated name to **%s** in record **%s**' % (updated_name,name_key))                
    elif field == 'details':
        updated_details = st.text_input('Please enter updated details (separated by comma)')
        updated_details = ('{%s}' % (updated_details))  
        if st.button('Update records'):
            update_record(field,name_key,updated_details,p_engine)
            st.info('Updated details to  **%s** in record **%s**' % (updated_details[1:-1],name_key))
            
    st.header('Read records')
    record_to_read = st.text_input('Please enter name of record to read')
    if st.button('Search'):
        read_name = read_record('name',record_to_read,p_engine)
        read_details = read_record('details',record_to_read,p_engine)
        st.info('Record name is **%s**, record details is **%s**' % (read_name,str(read_details)[1:-1]))

with column_2:
    st.header('Save datasets')
    dataset = st.file_uploader('Please upload dataset')
    if dataset is not None:
        dataset = pd.read_csv(dataset)
        dataset_name = st.text_input('Please enter name for dataset')
        if st.button('Save dataset to database'):
            write_dataset('%s' % (dataset_name),dataset,p_engine_dataset)
            st.info('**%s** saved to database' % (dataset_name))

    try:
        read_title = st.empty()
        dataset_to_read = st.selectbox('Please select dataset to read',([x[0] for x in list_datasets(p_engine_dataset)]))
        read_title.header('Read datasets')
        if st.button('Read dataset'):
            df = read_dataset(dataset_to_read,p_engine_dataset)
            st.subheader('Chart')
            st.line_chart(df['value'])
            st.subheader('Dataframe')
            st.write(df)    
    except:
        pass

Puede ejecutar su panel en un navegador local desde su máquina, escribiendo los siguientes comandos en aviso de anaconda. Entonces, primero, debe cambiar su directorio raíz al lugar donde se guardó su código fuente.

cd C:Usersyour directory path...

Ahora ejecutaremos el siguiente código para ejecutar nuestra aplicación …

streamlit run file_name.py

Resultado final

Para terminar, tenemos un tablero que se puede utilizar para escribir, leer, tokenizar, actualizar, cargar y visualizar nuestros datos en tiempo real. Podemos ver la belleza de nuestro almacén de datos que se puede ampliar para que el usuario / host tenga tantos datos como necesite dentro de la misma estructura.