Deshalb habe ich Pandas verlassen [Data Science 100 Knock (Strukturierte Datenverarbeitung) # 1]

Wir werden das Python-Problem von [Data Science 100 Knock (Strukturierte Datenverarbeitung)] lösen (https://github.com/The-Japan-DataScientist-Society/100knocks-preprocess). Diese Gruppe von Fragen verwendet Pandas für die Datenverarbeitung in der Modellantwort, aber wir werden sie nach dem Studium mit dem strukturierten Array von NumPy verarbeiten.

: arrow_forward: Nächster Artikel (# 2)

Einführung

Viele Leute, die mit Python datenwissenschaftliche Dinge tun, mögen Pandas-Liebhaber sein, aber tatsächlich können Sie dasselbe mit NumPy tun, ohne ** Pandas ** zu verwenden. Und NumPy ist normalerweise schneller. Als eine Person, die Pandas liebt, bin ich es immer noch nicht gewohnt, NumPy zu betreiben. Daher möchte ich versuchen, einen Abschluss von Pandas zu machen, indem ich diesen "Data Science 100 Knock" mit NumPy betreibe.

Dieses Mal werde ich bis zur 8. Frage tun. Es scheint, dass diesmal nur "receive.csv" verwendet wird. Die Ausgangsdaten wurden wie folgt gelesen (Datentypspezifikation wird vorerst verschoben).

import numpy as np
import pandas as pd

#Für Modellantwort
df_receipt = pd.read_csv('data/receipt.csv')

#Daten, mit denen wir umgehen
arr_receipt = np.genfromtxt(
    'data/receipt.csv', delimiter=',', encoding='utf-8',
    names=True, dtype=None)

Es spart Speicher.

import sys

sys.getsizeof(df_receipt)
# 26065721
sys.getsizeof(arr_receipt)
# 15074160

P_001

P-001: Zeigen Sie die ersten 10 Elemente aller Elemente aus dem Datenrahmen (df_receipt) der Belegdetails an und überprüfen Sie visuell, welche Art von Daten Sie haben.

Nimm es in Scheiben.

`In[001]`


arr_receipt[:10]

Sie können die Daten wie folgt erhalten. Darüber hinaus ist es intelligent genug, die Kommas auszurichten (es sei denn, es gibt eine Zeichenfolge in voller Breite).

`Out[001]`


array([(20181103, 1257206400, 'S14006',  112, 1, 'CS006214000001', 'P070305012', 1, 158),
       (20181118, 1258502400, 'S13008', 1132, 2, 'CS008415000097', 'P070701017', 1,  81),
       (20170712, 1215820800, 'S14028', 1102, 1, 'CS028414000014', 'P060101005', 1, 170),
       (20190205, 1265328000, 'S14042', 1132, 1, 'ZZ000000000000', 'P050301001', 1,  25),
       (20180821, 1250812800, 'S14025', 1102, 2, 'CS025415000050', 'P060102007', 1,  90),
       (20190605, 1275696000, 'S13003', 1112, 1, 'CS003515000195', 'P050102002', 1, 138),
       (20181205, 1259971200, 'S14024', 1102, 2, 'CS024514000042', 'P080101005', 1,  30),
       (20190922, 1285113600, 'S14040', 1102, 1, 'CS040415000178', 'P070501004', 1, 128),
       (20170504, 1209859200, 'S13020', 1112, 2, 'ZZ000000000000', 'P071302010', 1, 770),
       (20191010, 1286668800, 'S14027', 1102, 1, 'CS027514000015', 'P071101003', 1, 680)],
      dtype=[('sales_ymd', '<i4'), ('sales_epoch', '<i4'), ('store_cd', '<U6'), ('receipt_no', '<i4'), ('receipt_sub_no', '<i4'), ('customer_id', '<U14'), ('product_cd', '<U10'), ('quantity', '<i4'), ('amount', '<i4')])

Vergleichen wir die Geschwindigkeit mit der Modellantwort (Pandas).

`Time[001]`


#Musterantwort
%timeit df_receipt.head(10)
# 130 µs ± 5.02 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit arr_receipt[:10]
# 244 ns ± 8.23 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Ich konnte es mit 1/500 der Geschwindigkeit der Modellantwort bekommen.

P_002

P-002: Geben Sie Spalten in der Reihenfolge des Verkaufsdatums (sales_ymd), der Kunden-ID (customer_id), des Produktcodes (product_cd) und des Verkaufsbetrags (Betrag) aus dem Datenrahmen der Belegabrechnung (df_receipt) an und zeigen Sie 10 Artikel an.

Das strukturierte Array von NumPy kann auf die gleiche Weise wie der gewohnte "pd.DataFrame" bearbeitet werden.

`In[002]`


arr_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']][:10]

`Out[002]`


array([(20181103, 'CS006214000001', 'P070305012', 158),
       (20181118, 'CS008415000097', 'P070701017',  81),
       (20170712, 'CS028414000014', 'P060101005', 170),
       (20190205, 'ZZ000000000000', 'P050301001',  25),
       (20180821, 'CS025415000050', 'P060102007',  90),
       (20190605, 'CS003515000195', 'P050102002', 138),
       (20181205, 'CS024514000042', 'P080101005',  30),
       (20190922, 'CS040415000178', 'P070501004', 128),
       (20170504, 'ZZ000000000000', 'P071302010', 770),
       (20191010, 'CS027514000015', 'P071101003', 680)],
      dtype={'names':['sales_ymd','customer_id','product_cd','amount'], 'formats':['<i4','<U14','<U10','<i4'], 'offsets':[0,40,96,140], 'itemsize':144})

Schneller als das Manipulieren von "pd.DataFrame".

`Time[002]`


%timeit df_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']].head(10)
# 5.19 ms ± 43.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit arr_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']][:10]
# 906 ns ± 17.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

P_003

P-003: Geben Sie Spalten in der Reihenfolge des Verkaufsdatums (sales_ymd), der Kunden-ID (customer_id), des Produktcodes (product_cd), des Verkaufsbetrags (Betrag) aus dem Datenrahmen der Belegabrechnung (df_receipt) an und zeigen Sie 10 Artikel an. Sales_ymd sollte jedoch extrahiert werden, während der Artikelname in sales_date geändert wird.

Das Umbenennen ist eine einfache und nervige Sache. Es ist am einfachsten, np.lib.recfunctions.rename_fields () durchzugehen, aber diese Funktion ist immer noch recht umständlich zu verwenden.

`In[003]`


np.lib.recfunctions.rename_fields(arr_receipt, {'sales_ymd': 'sales_date'})[
    ['sales_date', 'customer_id', 'product_cd', 'amount']][:10]

`Out[003]`


array([(20181103, 'CS006214000001', 'P070305012', 158),
       (20181118, 'CS008415000097', 'P070701017',  81),
       (20170712, 'CS028414000014', 'P060101005', 170),
       (20190205, 'ZZ000000000000', 'P050301001',  25),
       (20180821, 'CS025415000050', 'P060102007',  90),
       (20190605, 'CS003515000195', 'P050102002', 138),
       (20181205, 'CS024514000042', 'P080101005',  30),
       (20190922, 'CS040415000178', 'P070501004', 128),
       (20170504, 'ZZ000000000000', 'P071302010', 770),
       (20191010, 'CS027514000015', 'P071101003', 680)],
      dtype={'names':['sales_date','customer_id','product_cd','amount'], 'formats':['<i4','<U14','<U10','<i4'], 'offsets':[0,40,96,140], 'itemsize':144})

Es verarbeitet sich jedoch im Vergleich zu Pandas sehr schnell.

`Time[003]`


%timeit df_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']].rename(columns={'sales_ymd': 'sales_date'}).head(10)
# 12.8 ms ± 252 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit np.lib.recfunctions.rename_fields(arr_receipt, {'sales_ymd': 'sales_date'})[['sales_date', 'customer_id', 'product_cd', 'amount']][:10]
# 6.19 µs ± 132 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Es ist langsam und schwer, weil Pandas bei jeder Verarbeitung neue Datenrahmenobjekte erstellt.

P_004

P-004: Daten, die die folgenden Bedingungen erfüllen, indem Spalten in der Reihenfolge des Verkaufsdatums (sales_ymd), der Kunden-ID (customer_id), des Produktcodes (product_cd) und des Verkaufsbetrags (Betrag) aus dem Datenrahmen der Belegabrechnung (df_receipt) angegeben werden. Extrakt.

--Kunden-ID (Kunden-ID) lautet "CS018205000001"

Dies kann auch durch intuitive Bedienung erreicht werden.

`In[004]`


arr_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']][
    arr_receipt['customer_id'] == 'CS018205000001']

`Out[004]`


arr_receipt[['sales_ymd','customer_id','product_cd','amount']][arr_receipt['customer_id'] == 'CS018205000001']
array([(20180911, 'CS018205000001', 'P071401012', 2200),
       (20180414, 'CS018205000001', 'P060104007',  600),
       (20170614, 'CS018205000001', 'P050206001',  990),
       (20170614, 'CS018205000001', 'P060702015',  108),
       (20190216, 'CS018205000001', 'P071005024',  102),
       (20180414, 'CS018205000001', 'P071101002',  278),
       (20190226, 'CS018205000001', 'P070902035',  168),
       (20190924, 'CS018205000001', 'P060805001',  495),
       (20190226, 'CS018205000001', 'P071401020', 2200),
       (20180911, 'CS018205000001', 'P071401005', 1100),
       (20190216, 'CS018205000001', 'P040101002',  218),
       (20190924, 'CS018205000001', 'P091503001',  280)],
      dtype={'names':['sales_ymd','customer_id','product_cd','amount'], 'formats':['<i4','<U14','<U10','<i4'], 'offsets':[0,40,96,140], 'itemsize':144})

Die Modellantwort scheint "pd.DataFrame.query ()" zu lieben. Ich denke, es sollte normal indiziert werden.

`Time[004]`


%timeit df_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']].query('customer_id == "CS018205000001"')
# 11.6 ms ± 477 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit df_receipt.loc[df_receipt['customer_id'] == 'CS018205000001', ['sales_ymd', 'customer_id', 'product_cd', 'amount']]
# 9.49 ms ± 212 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit arr_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']][arr_receipt['customer_id'] == 'CS018205000001']
# 2.7 ms ± 475 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

P_005

P-005: Daten, die die folgenden Bedingungen erfüllen, indem Spalten in der Reihenfolge des Verkaufsdatums (sales_ymd), der Kunden-ID (customer_id), des Produktcodes (product_cd) und des Verkaufsbetrags (Betrag) aus dem Datenrahmen der Belegabrechnung (df_receipt) angegeben werden. Extrakt.

--Kunden-ID (Kunden-ID) lautet "CS018205000001"

Der Verkaufsbetrag (Betrag) beträgt 1.000 oder mehr

Dies ist auch dann der Fall, wenn mehrere Bedingungen vorliegen.

`In[005]`


arr_receipt[['sales_ymd', 'customer_id', 'product_cd', 'amount']][
    (arr_receipt['customer_id'] == 'CS018205000001') & (arr_receipt['amount'] >= 1000)]

`Out[005]`


array([(20180911, 'CS018205000001', 'P071401012', 2200),
       (20190226, 'CS018205000001', 'P071401020', 2200),
       (20180911, 'CS018205000001', 'P071401005', 1100)],
      dtype={'names':['sales_ymd','customer_id','product_cd','amount'], 'formats':['<i4','<U14','<U10','<i4'], 'offsets':[0,40,96,140], 'itemsize':144})

P_006

P-006: Geben Sie im Datenrahmen für Belegdetails "df_receipt" die Spalten in der Reihenfolge des Verkaufsdatums (sales_ymd), der Kunden-ID (customer_id), des Produktcodes (product_cd), der Verkaufsmenge (Menge), des Verkaufsbetrags (Betrag) usw. an Extrahieren Sie Daten, die die Bedingungen von erfüllen.

--Kunden-ID (Kunden-ID) lautet "CS018205000001"

Die Verkaufsmenge (Menge) beträgt 1.000 oder mehr oder die Verkaufsmenge (Menge) beträgt 5 oder mehr

Irgendwie wird die Linie länger, also werde ich sie teilen.

`In[006]`


col_list = ['sales_ymd', 'customer_id', 'product_cd', 'quantity', 'amount']
cond = ((arr_receipt['customer_id'] == 'CS018205000001')
        & ((arr_receipt['amount'] >= 1000) | (arr_receipt['quantity'] >= 5)))

arr_receipt[col_list][cond]

`Out[006]`


array([(20180911, 'CS018205000001', 'P071401012', 2200),
       (20180414, 'CS018205000001', 'P060104007',  600),
       (20170614, 'CS018205000001', 'P050206001',  990),
       (20190226, 'CS018205000001', 'P071401020', 2200),
       (20180911, 'CS018205000001', 'P071401005', 1100)],
      dtype={'names':['sales_ymd','customer_id','product_cd','amount'], 'formats':['<i4','<U14','<U10','<i4'], 'offsets':[0,40,96,140], 'itemsize':144})

P_007

P-007: Daten, die die folgenden Bedingungen erfüllen, indem Spalten in der Reihenfolge des Verkaufsdatums (sales_ymd), der Kunden-ID (customer_id), des Produktcodes (product_cd) und des Verkaufsbetrags (Betrag) aus dem Datenrahmen der Belegabrechnung (df_receipt) angegeben werden. Extrakt.

--Kunden-ID (Kunden-ID) lautet "CS018205000001"

Der Verkaufsbetrag (Betrag) beträgt 1.000 oder mehr und 2.000 oder weniger

`In[007]`


col_list = ['sales_ymd', 'customer_id', 'product_cd', 'quantity', 'amount']
cond = ((arr_receipt['customer_id'] == 'CS018205000001')
        & ((1000 <= arr_receipt['amount']) & (arr_receipt['amount'] <= 2000)))

arr_receipt[col_list][cond]

`Out[007]`


array([(20180911, 'CS018205000001', 'P071401005', 1, 1100)],
      dtype={'names':['sales_ymd','customer_id','product_cd','quantity','amount'], 'formats':['<i4','<U14','<U10','<i4','<i4'], 'offsets':[0,40,96,136,140], 'itemsize':144})

P_008

P-008: Daten, die die folgenden Bedingungen erfüllen, indem Spalten in der Reihenfolge des Verkaufsdatums (sales_ymd), der Kunden-ID (customer_id), des Produktcodes (product_cd) und des Verkaufsbetrags (Betrag) aus dem Datenrahmen der Belegabrechnung (df_receipt) angegeben werden. Extrakt.

--Kunden-ID (Kunden-ID) lautet "CS018205000001"

Der Produktcode (product_cd) ist nicht "P071401019".

`In[008]`


col_list = ['sales_ymd', 'customer_id', 'product_cd', 'quantity', 'amount']
cond = ((arr_receipt['customer_id'] == 'CS018205000001')
        & (arr_receipt['product_cd'] != 'P071401019'))

arr_receipt[col_list][cond]

`Out[008]`


array([(20180911, 'CS018205000001', 'P071401012', 1, 2200),
       (20180414, 'CS018205000001', 'P060104007', 6,  600),
       (20170614, 'CS018205000001', 'P050206001', 5,  990),
       (20170614, 'CS018205000001', 'P060702015', 1,  108),
       (20190216, 'CS018205000001', 'P071005024', 1,  102),
       (20180414, 'CS018205000001', 'P071101002', 1,  278),
       (20190226, 'CS018205000001', 'P070902035', 1,  168),
       (20190924, 'CS018205000001', 'P060805001', 1,  495),
       (20190226, 'CS018205000001', 'P071401020', 1, 2200),
       (20180911, 'CS018205000001', 'P071401005', 1, 1100),
       (20190216, 'CS018205000001', 'P040101002', 1,  218),
       (20190924, 'CS018205000001', 'P091503001', 1,  280)],
      dtype={'names':['sales_ymd','customer_id','product_cd','quantity','amount'], 'formats':['<i4','<U14','<U10','<i4','<i4'], 'offsets':[0,40,96,136,140], 'itemsize':144})

`Time[008]`


col_list = ['sales_ymd', 'customer_id', 'product_cd', 'quantity', 'amount']

%timeit df_receipt[col_list].query('customer_id == "CS018205000001" & product_cd != "P071401019"')
# 15.6 ms ± 1.19 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit arr_receipt[col_list][((arr_receipt['customer_id'] == 'CS018205000001') & (arr_receipt['product_cd'] != 'P071401019'))]
# 4.28 ms ± 86.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

abschließend

Hallo Dies ist eine Hochgeschwindigkeits-Hochgeschwindigkeitsdatenverarbeitung mit NumPy. Sie können es nach der Verarbeitung an csv ausspucken, und Pandas führen keine schwere Verarbeitung durch. Also habe ich Pandas verlassen

[PYTHON] Deshalb habe ich Pandas verlassen [Data Science 100 Knock (Strukturierte Datenverarbeitung) # 1]

Deshalb habe ich Pandas verlassen [Data Science 100 Knock (Strukturierte Datenverarbeitung) # 1]

Einführung

In[001]

Out[001]

Time[001]

In[002]

Out[002]

Time[002]

In[003]

Out[003]

Time[003]

In[004]

Out[004]

Time[004]

In[005]

Out[005]

In[006]

Out[006]

In[007]

Out[007]

In[008]

Out[008]

Time[008]