[PYTHON] Procédure d'apprentissage automatique de base: ② Préparer les données

introduction

La dernière fois, dans Procédure d'apprentissage automatique de base: ① Modèle de classification, j'ai organisé la procédure de création d'un modèle de classification vraiment basique. Cependant, le lieu de préparation des données était cassé. Donc, cette fois, je voudrais organiser la procédure pour créer le tableau suivant à l'aide de BigQuery et l'importer dans l'environnement Python.

Environnement analytique

Google BigQuery Google Colaboratory

Données cibles

Les données d'achat sont stockées dans la structure de tableau ci-dessous.

Le nom de la table est le suivant sur le BQ. (Divisé en tables par jour) myproject.mydataset.transaction_ date

Malheureusement, les noms d'éléments ne peuvent pas être donnés en japonais, mais par souci de clarté, ils sont ici en japonais. Veuillez changer le nom en fonction de chaque environnement.

1. Que faire sur BigQuery

J'ai écrit que je le ferais sur BigQuery, mais toutes les opérations réelles sont effectuées à partir de Python (Google Colaboratory). Notebook est également utile pour garder une trace de ce que vous avez fait.

Pour utiliser BigQuery à partir de Colaboratory, vous pouvez facilement vous authentifier avec les deux lignes suivantes. Lorsque l'URL s'affiche, accédez-y avec votre propre compte, émettez un mot de passe à usage unique et collez-le dans la cellule affichée dans Notebook.

from google.colab import auth
auth.authenticate_user()

1-1. Traitement des données d'achat

Passons maintenant au processus d'agrégation des données d'achat d'origine par personne et par produit.

from google.cloud import bigquery

#Ici, la période cible est janvier 2020.
from_day = "20200101"
to_day = "20200131"

query=f"""
SELECT
 id,Biens achetés, SUM(Prix d'achat)AS montant total
 FROM `myproject.mydataset.transaction_*`
 WHERE _table_suffix between `{from_day}` and `{to_day}`
"""

#Nom de la table du jeu de données du projet à afficher
project = "myproject"
client = bigquery.Client(project=project)
dataset = "mydataset"
ds = client.dataset(dataset )
table = "tmp"

job_config = bigquery.QueryJobConfig()
job_config.destination = ds.table(table)
job_config.write_disposition="WRITE_TRUNCATE" #Lors de l'écrasement d'une table. Si vous souhaitez ajouter"WRITE_APPEND"
job_config.allow_large_results=True #Autorisez-vous des résultats à grande échelle? Fondamentalement vrai
job_config.use_legacy_sql=False #Utilisez-vous l'ancien SQL? Fondamentalement faux
job = client.query(query, job_config=job_config)

result = job.result()

Désormais, lorsque l'exécution est terminée sans aucune sortie, le résultat de l'exécution est affiché dans myproject.mydataset.tmp. Les paramètres de job_config sont un peu gênants, mais écrivons d'abord tout en sachant en quoi consiste chaque paramètre. (Une fois que vous vous y êtes habitué, vous pouvez le copier)

Si vous l'exécutez jusqu'à présent, vous verrez le tableau suivant.

1-2. Traitement vers une table individuelle

Ensuite, je voudrais créer un tableau croisé dynamique du prix d'achat id x à charger dans le modèle d'apprentissage automatique.

Si vous utilisez Pandas avec Python, il est facile d'utiliser pivot_table, mais en fonction de la période cible, etc., la taille des données est de plusieurs Go ou plusieurs dizaines de Go, et il faut plus de temps pour importer et traiter les données, donc même la conversion de tableau croisé dynamique Je le fais avec BigQuery.

new_columns=[]

#Créer une liste de "produits achetés" à tenir horizontalement et la convertir en bloc de données
new_column="Biens achetés"
query = f'SELECT DISTINCT {new_column} FROM `{project}.{dataset}.{tmp}` ORDER BY {new_column}'
df_product = client.query(query).to_dataframe()

##Générez automatiquement du SQL à tenir horizontalement en bouclant la trame de données du produit acheté
for index, row in df_product.iterrows():
	item_frag = []
	condition_frag = []

	for i, v in zip(row.index, row.values):
		formula=f"{i}='{v}'"
		condition_frag.append(formula)
		item_frag.append(v)

	item=''.join(item_frag)
	condition=' AND '.join(condition_frag)
	query_frag = f'SUM(IF(({condition}),"Prix d'achat",0)) AS {new_column}_{item}'
	new_columns.append(query_frag)

# new_Interroger une liste appelée colonnes_Passer aux parties de la chaîne
query_parts = ',\n'.join(new_columns)
query = f'SELECT id + query_parts + FROM `{project}.{dataset}.{tmp}` GROUP BY id'

#Nom de la table de destination de sortie
table2="pivoted_table"

#L'exécution de BigQuery est la même que ci-dessus
job_config = bigquery.QueryJobConfig()
job_config.destination = ds.table(table2)
job_config.write_disposition="WRITE_TRUNCATE" #Lors de l'écrasement d'une table. Si vous souhaitez ajouter"WRITE_APPEND"
job_config.allow_large_results=True #Autorisez-vous des résultats à grande échelle? Fondamentalement vrai
job_config.use_legacy_sql=False #Utilisez-vous l'ancien SQL? Fondamentalement faux
job = client.query(query, job_config=job_config)

result = job.result()

Le processus de création de SQL pour le tableau croisé dynamique est un peu compliqué car il boucle deux fois, mais je veux créer le SQL suivant.

SELECT
 id,
SUM(IF((Biens achetés='product1'),Prix d'achat,0)) AS Biens achetés_product1,
SUM(IF((Biens achetés='product2'),Prix d'achat,0)) AS Biens achetés_product2,
SUM(IF((Biens achetés='product3'),Prix d'achat,0)) AS Biens achetés_product3,
...
FROM `myproject.mydataset.tmp`
GROUP BY id

C'est un SQL standard qui fait pivoter une table, mais la partie SUM (IF (~)) de celle-ci est automatiquement créée en fonction du nombre de produits. Jusqu'à présent, le tableau suivant est enregistré sous myproject.mydataset.pivoted_table.

2. Importez Python dans l'environnement

Enfin, importez les données créées par BigQuery dans l'environnement Python avec Pandas Dataframe. Cependant, comme je l'ai déjà importé avec Dataframe au milieu de la conversion Pivot, il est encore temps d'écrire un programme. .. ..

query = f'SELECT * FROM `{project}.{dataset}.{table2}`'
df = client.query(query).to_dataframe()

en conclusion

En disant "procédure de machine learning de base", cette fois j'ai commencé par les opérations avec BigQuery. Depuis Colaboratory, l'authentification est facile, je pense donc que l'obstacle au fonctionnement de BigQuery est faible.

BigQuery est encore assez puissant, mais de nouvelles fonctionnalités sont publiées chaque jour. Je veux faire bon usage des nouvelles fonctions.