[PYTHON] Grundlegendes maschinelles Lernverfahren: ② Daten vorbereiten

Einführung

Das letzte Mal habe ich in Grundlegendes maschinelles Lernverfahren: ① Klassifizierungsmodell das Verfahren zum Erstellen eines wirklich grundlegenden Klassifizierungsmodells organisiert. Der Ort zur Vorbereitung der Daten war jedoch defekt. Dieses Mal möchte ich die Prozedur organisieren, um die folgende Tabelle mit BigQuery zu erstellen und in die Python-Umgebung zu importieren.

Analyseumgebung

Google BigQuery Google Colaboratory

Zieldaten

Kaufdaten werden in der unten gezeigten Tabellenstruktur gespeichert.

Der Tabellenname lautet im BQ wie folgt. (Nach Tag in Tabellen unterteilt) myproject.mydataset.transaction_ date

Leider können Artikelnamen nicht auf Japanisch angegeben werden, aber der Übersichtlichkeit halber sind sie hier auf Japanisch. Bitte ändern Sie den Namen je nach Umgebung.

1. Was ist mit BigQuery zu tun?

Ich habe geschrieben, dass ich es auf BigQuery machen werde, aber alle eigentlichen Operationen werden von Python (Google Colaboratory) ausgeführt. Notebook ist auch nützlich, um aufzuzeichnen, was Sie getan haben.

Um BigQuery von Colaboratory aus zu betreiben, können Sie sich einfach mit den folgenden zwei Zeilen authentifizieren. Wenn die URL angezeigt wird, greifen Sie mit Ihrem eigenen Konto darauf zu, geben Sie ein Einmalkennwort ein und fügen Sie es in die in Notebook angezeigte Zelle ein.

from google.colab import auth
auth.authenticate_user()

1-1. Verarbeitung von Einkaufsdaten

Fahren wir nun mit dem Prozess der tatsächlichen Aggregation der ursprünglichen Kaufdaten nach Person und Produkt fort.

from google.cloud import bigquery

#Zielzeitraum ist hier der Januar 2020.
from_day = "20200101"
to_day = "20200131"

query=f"""
SELECT
 id,Waren kaufen, SUM(Kaufpreis)AS Gesamtbetrag
 FROM `myproject.mydataset.transaction_*`
 WHERE _table_suffix between `{from_day}` and `{to_day}`
"""

#Name der auszugebenden Projektdatensatztabelle
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" #Beim Überschreiben einer Tabelle. Wenn Sie hinzufügen möchten"WRITE_APPEND"
job_config.allow_large_results=True #Erlauben Sie groß angelegte Ergebnisse? Grundsätzlich wahr
job_config.use_legacy_sql=False #Verwenden Sie Legacy-SQL? Grundsätzlich falsch
job = client.query(query, job_config=job_config)

result = job.result()

Wenn die Ausführung ohne Ausgabe abgeschlossen ist, wird das Ausführungsergebnis an myproject.mydataset.tmp ausgegeben. Die Einstellungen in job_config sind etwas mühsam, aber zuerst schreiben wir, während wir uns der jeweiligen Einstellung bewusst sind. (Sobald Sie sich daran gewöhnt haben, können Sie es kopieren.)

Wenn Sie es bisher ausführen, wird die folgende Tabelle angezeigt.

1-2. Verarbeitung zur einzelnen Tabelle

Als Nächstes möchte ich eine PivotTable mit dem Kaufpreis id x erstellen, die in das Modell für maschinelles Lernen geladen werden soll.

Wenn Sie Pandas mit Python verwenden, ist es einfach, pivot_table zu verwenden. Abhängig vom Zielzeitraum usw. beträgt die Datengröße jedoch mehrere GB oder einige zehn GB, und das Importieren und Verarbeiten von Daten und damit auch die Konvertierung von Pivot-Tabellen dauert länger Ich mache es mit BigQuery.

new_columns=[]

#Erstellen Sie eine Liste der "gekauften Produkte", die horizontal aufbewahrt werden sollen, und konvertieren Sie sie in einen Datenrahmen
new_column="Waren kaufen"
query = f'SELECT DISTINCT {new_column} FROM `{project}.{dataset}.{tmp}` ORDER BY {new_column}'
df_product = client.query(query).to_dataframe()

##Generieren Sie automatisch SQL, das horizontal gehalten werden soll, indem Sie den Datenrahmen des gekauften Produkts durchlaufen
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}),"Kaufpreis",0)) AS {new_column}_{item}'
	new_columns.append(query_frag)

# new_Fragen Sie eine Liste mit dem Namen Spalten ab_Wechseln Sie zu den Saitenteilen
query_parts = ',\n'.join(new_columns)
query = f'SELECT id + query_parts + FROM `{project}.{dataset}.{tmp}` GROUP BY id'

#Name der Ausgabezieltabelle
table2="pivoted_table"

#Die Ausführung von BigQuery ist dieselbe wie oben
job_config = bigquery.QueryJobConfig()
job_config.destination = ds.table(table2)
job_config.write_disposition="WRITE_TRUNCATE" #Beim Überschreiben einer Tabelle. Wenn Sie hinzufügen möchten"WRITE_APPEND"
job_config.allow_large_results=True #Erlauben Sie groß angelegte Ergebnisse? Grundsätzlich wahr
job_config.use_legacy_sql=False #Verwenden Sie Legacy-SQL? Grundsätzlich falsch
job = client.query(query, job_config=job_config)

result = job.result()

Das Erstellen von SQL für Pivot Table ist etwas kompliziert, da es zweimal wiederholt wird, aber ich möchte das folgende SQL erstellen.

SELECT
 id,
SUM(IF((Waren kaufen='product1'),Kaufpreis,0)) AS Waren kaufen_product1,
SUM(IF((Waren kaufen='product2'),Kaufpreis,0)) AS Waren kaufen_product2,
SUM(IF((Waren kaufen='product3'),Kaufpreis,0)) AS Waren kaufen_product3,
...
FROM `myproject.mydataset.tmp`
GROUP BY id

Es ist ein Standard-SQL, das eine Tabelle zum Pivot macht, aber der SUM (IF (~)) - Teil davon wird automatisch entsprechend der Anzahl der Produkte erstellt. Bisher wurde die folgende Tabelle als myproject.mydataset.pivoted_table gespeichert.

2. Importieren Sie Python in die Umgebung

Importieren Sie abschließend die von BigQuery erstellten Daten mit Pandas Dataframe in die Python-Umgebung. Da ich es jedoch bereits mitten in der Pivot-Konvertierung mit Dataframe importiert habe, ist es noch mehr Zeit, ein Programm zu schreiben. .. ..

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

abschließend

Während ich "Grundlegendes maschinelles Lernverfahren" sagte, begann ich diesmal mit Operationen mit BigQuery. Von Colaboratory aus ist die Authentifizierung einfach, daher habe ich das Gefühl, dass die Hürde für den Betrieb von BigQuery gering ist.

BigQuery ist immer noch leistungsfähig genug, aber jeden Tag werden neue Funktionen veröffentlicht. Ich möchte neue Funktionen gut nutzen.