A common use case in Machine Learning life cycle is to have access to the latest training data so as to prevent model deterioration. A lot of times data scientists find it cumbersome to manually export data from data sources such as relational databases or NoSQL data stores or even distributed data. This necessitates automating the data engineering pipeline in Machine Learning. In this post, we will describe how to set up this pipeline for batch data. This workflow is orchestrated via Airflow and can be set up to run at regular intervals: such as hourly, daily, weekly, etc depending on the specific business requirements.
Quick note – In case you are interested in building a real time data engineering pipeline for ML, please look at this post.
In this use case, we are going to export MongoDB data into Google BigQuery via Cloud Storage. The updated data in BigQuery is then made available in Jupyter Notebook as a Pandas Dataframe for downstream model building and analytics. As the pipeline automates the data ingestion and preprocessing, the data scientists always have access to the latest batch data in their Jupyter Notebooks hosted on Google AI Platform.
We have a MongoDB service running in an instance and we have Airflow and mongoexport running on docker on another instance. Mongoexport is a utility that produces a JSON or CSV export of data stored in MongoDB. Now the data in MongoDB shall be extracted and transformed using mongoexport and loaded into CloudStorage. Airflow is used to schedule and orchestrate these exports. Once the data is available in CloudStorage it could be queried in BigQuery. We then get this data from BigQuery to Jupyter Notebook. Following is a step by step sequence of steps to set up this data pipeline.
You can create an instance in GCP by going to Compute Engine. Click on create instance.
Install.sh:
sudo apt-get update
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
sudo usermod -aG docker $USER
sudo apt-get install -y python-pip
export AIRFLOW_HOME=~/airflow
sudo pip install apache-airflow
sudo pip install apache-airflow[postgres,s3]
airflow initdb
airflow webserver -p 8080 -D
airflow scheduler -D
sudo docker pull mongo
sudo docker run --name mongo_client -d mongoPlease run the install.sh file using ./install.sh command (please make sure file is executable), which would install Docker, Airflow, pulls Mongo image and runs the mongo image in a container named mongo_client.
After installation, for Airflow webUI → http://<public-ip-instance>:8080 (You may need to open port 8080 in the network just for your public IP)
Please make sure the Google service account in the running instance must have permissions for accessing Big Query and Cloud Storage. After installation, add the Airflow job Python file (mongo-export.py) inside the airflow/dags folder.
Before running the Python file, please make sure that you create Dataset and create the table in BigQuery. Also change the appropriate values for the MongoDB source database, MongoDB source table, Cloud Storage destination bucket and BigQuery destination dataset in the Airflow job Python file (mongo-export.py). Big Query destination table name is the same as the source table in Mongo DB.
Mongo-export.py:
import airflow
from airflow import DAG
from airflow.operators.bash_operator import BashOperator
from airflow.operators.python_operator import PythonOperator
from datetime import datetime, timedelta
import json
from pandas.io.json import json_normalize
# Following are default arguments which could be overridden
default_args = {
'owner': 'airflow',
'depends_on_past': False,
'start_date': airflow.utils.dates.days_ago(0),
'email': ['airflow@gmail.com'],
'email_on_failure': False,
'email_on_retry': False,
'retries': 1,
'retry_delay': timedelta(minutes=1),
}
bucket_name = '<Your_Bucket>'
db_name = '<Database_Name>'
dataset = '<Dataset_Name>'
table_name = '<Table_Name>'
time_stamp = datetime.now()
cur_date = time_stamp.strftime("%Y-%m-%d")
# It will flatten the nested json
def flatten_json(y):
out = {}
def flatten(x, name=''):
if type(x) is dict:
for a in x:
flatten(x[a], name + a + '_')
elif type(x) is list:
i = 0
for a in x:
flatten(a, name + str(i) + '_')
i += 1
else:
out[name[:-1]] = x
flatten(y)
return out
def convert_string(y):
string_type = {}
def convert(x, name=''):
if type(x) is dict:
for a in x:
convert(str(x[a]), name + a + '_')
elif type(x) is list:
i = 0
for a in x:
flatten(a, name + str(i) + '_')
i += 1
else:
string_type[name[:-1]] = x
convert(y)
return string_type
def json_flat():
lines = [line.rstrip('\n') for line in open('/home/dev/'+ table_name + '-unformat.json')]
flat_list = []
for line in lines:
line = line.replace("\"$", "\"")
line = json.loads(line)
try:
flat_list.append(json.dumps(convert_string(flatten_json(line))))
except Exception as e:
print(e)
flatted_json = '\n'.join(i for i in flat_list)
with open('/home/dev/' + table_name + '.json', 'a') as file:
file.write(flatted_json)
return flatted_json
dag = DAG('mongoexport-daily-gcs-bq', default_args=default_args, params = {'cur_date': cur_date, 'db_name': db_name, 'table_name': table_name, 'dataset': dataset, 'bucket_name': bucket_name})
#exports provide a table data into docker container
t1 = BashOperator(
task_id='mongoexport_to_container',
bash_command='sudo docker exec -i mongo_client sh -c "mongoexport --host=<instance_public_ip> --db {{params.db_name}} --collection {{params.table_name}} --out {{params.table_name}}-unformat.json"',
dag=dag)
# copies exported file into instance
t2 = BashOperator(
task_id='cp_from_container_instance',
bash_command='sudo docker cp mongo_client:/{{params.table_name}}-unformat.json /home/dev/',
dag=dag)
t3 = PythonOperator(
task_id='flattening_json',
python_callable=json_flat,
dag=dag)
# copies the flatten data from cloud storage
t4 = BashOperator(
task_id='cp_from_instance_gcs',
bash_command='gsutil cp /home/dev/{{params.table_name}}.json gs://{{params.bucket_name}}/raw/{{params.table_name}}/date={{params.cur_date}}/',
dag=dag)
#
t5 = BashOperator(
task_id='cp_from_instance_gcs_daily_data',
bash_command='gsutil cp /home/dev/{{params.table_name}}.json gs://{{params.bucket_name}}/curated/{{params.table_name}}/',
dag=dag)
# removes the existing bigquery table
t6 = BashOperator(
task_id='remove_bq_table',
bash_command='bq rm -f {{params.dataset}}.{{params.table_name}}',
dag=dag)
# creates a table in bigquery
t7 = BashOperator(
task_id='create_bq_table',
bash_command='bq load --autodetect --source_format=NEWLINE_DELIMITED_JSON {{params.dataset}}.{{params.table_name}} gs://{{params.bucket_name}}/curated/{{params.table_name}}/{{params.table_name}}.json',
dag=dag)
# removes data from container
t8 = BashOperator(
task_id='remove_file_from_container',
bash_command='sudo docker exec -i mongo_client sh -c "rm -rf {{params.table_name}}*.json"',
dag=dag)
# removes data from instance
t9 = BashOperator(
task_id='remove_file_from_instance',
bash_command='rm -rf /home/dev/{{params.table_name}}*.json',
dag=dag)
t1 >> t2
t2 >> t3
t3 >> [t4, t5]
[t4, t5] >> t6
t6 >> t7
t7 >> [t8, t9]Then run the python file using python <file-path>.py
(example: python airflow/dags/mongo-export.py).
After running the python file, the dag name shows in Airflow webUI. And you could trigger the dag manually. Please make sure toggle button is in ON status
Once the job completes, the data is stored in the bucket and also available in the destination table in BigQuery. You could see the table is created in BigQuery. Click on querytable to perform SQL operations and you could see your results in the preview tab at the bottom.
Now, you could access the data in Jupyter Notebook from BigQuery. Search for notebook in GCP console.
Run the below commands in Jupyter Notebook.
from google.cloud import bigquery
client = bigquery.Client()
sql = """
SELECT * FROM
`<project-name>.<dataset-name>.<table-name>`
"""
df = client.query(sql).to_dataframe()
df.head(10)This loads the BigQuery data into Pandas dataframe and can be used for model creation as required. Later when the data pipeline is run as per schedule, the refreshed data would automatically be available in this Jupyter notebook via this SQL query.
Hope this helps you to automate your batch Data Engineering pipeline for Machine Learning.
This story is co-authored by Santosh and Subbareddy. Santosh is an AWS Cloud Engineer and Subbareddy is a Big Data Engineer.