Nous allons résoudre le problème Python de Data Science 100 Knock (traitement des données structurées). Ce groupe de questions utilise des pandas pour le traitement des données dans la réponse du modèle, mais nous le traiterons à l'aide de NumPy après étude.
: arrow_up: Premier article (# 1) : arrow_backward: article précédent (# 2) : arrow_forward: Article suivant (# 4)
En tant qu'étude de NumPy, je résoudrai le problème Python de Data Science 100 Knock (traitement des données structurées).
Beaucoup de gens qui font des activités de science des données en Python sont peut-être des amateurs de pandas, mais en fait, vous pouvez faire de même avec NumPy sans utiliser ** pandas **. Et NumPy est généralement plus rapide. En tant que personne qui aime les pandas, je ne suis toujours pas habitué à utiliser NumPy, donc j'aimerais essayer de sortir des pandas en exploitant ce "Data Science 100 Knock" avec NumPy.
Cette fois, je répondrai aux 17e à 22e questions. Cette zone semble être le thème du tri et du classement.
Les données initiales ont été lues comme suit.
C'est une politique de ne pas vectoriser les fonctions par np.vectorize () ou np.frompyfunc ().
import numpy as np
import pandas as pd
from numpy.lib import recfunctions as rfn
#Pour la réponse du modèle
df_customer = pd.read_csv('data/customer.csv')
df_receipt = pd.read_csv('data/receipt.csv')
#Données que nous traitons
arr_customer = np.genfromtxt(
'data/customer.csv', delimiter=',', encoding='utf-8',
names=True, dtype=None)
arr_receipt = np.genfromtxt(
'data/receipt.csv', delimiter=',', encoding='utf-8',
names=True, dtype=None)
P_017
P-17: Trier le bloc de données client (df_customer) par date de naissance (date_anniversaire) dans l'ordre chronologique, et afficher les 10 premiers éléments.
Si vous voulez trier le tableau, utilisez np.sort (), qui retournera le tableau trié. Cette fois, je veux l'ordre de tri, alors utilisez np.argsort () ou np.ndarray.argsort (). Il existe également un moyen de passer le nom de la colonne à l'argument ʻorder de np.sort () `, mais ce n'est pas recommandé car le comportement n'est pas bon.
In[017]
arr_customer[arr_customer['birth_day'].argsort()][:10]
Out[017]
array([('CS003813000014', 'Nanami Murayama', 1, 'Femme', '1928-11-26', 90, '182-0007', 'Kikunodai, ville de Chofu, Tokyo**********', 'S13003', 20160214, '0-00000000-0'),
('CS026813000004', 'Yoshimura Chaoyang', 1, 'Femme', '1928-12-14', 90, '251-0043', 'Motomachi Tsujido, ville de Fujisawa, préfecture de Kanagawa**********', 'S14026', 20150723, '0-00000000-0'),
('CS018811000003', 'Misato Kumazawa', 1, 'Femme', '1929-01-07', 90, '204-0004', 'Noshio, Kiyose City, Tokyo**********', 'S13018', 20150403, '0-00000000-0'),
('CS027803000004', 'Takuro Uchimura', 0, 'Masculin', '1929-01-12', 90, '251-0031', 'Kugenuma Fujigaya, ville de Fujisawa, préfecture de Kanagawa**********', 'S14027', 20151227, '0-00000000-0'),
('CS013801000003', 'Takuro Amano', 0, 'Masculin', '1929-01-15', 90, '274-0824', 'Maehara Higashi, ville de Funabashi, préfecture de Chiba**********', 'S12013', 20160120, '0-00000000-0'),
('CS001814000022', 'Riho Tsuruta', 1, 'Femme', '1929-01-28', 90, '144-0045', 'Minami Rokugo, Ota-ku, Tokyo**********', 'S13001', 20161012, 'A-20090415-7'),
('CS016815000002', 'Miki Yamamoto', 1, 'Femme', '1929-02-22', 90, '184-0005', 'Sakuramachi, ville de Koganei, Tokyo**********', 'S13016', 20150629, 'C-20090923-C'),
('CS009815000003', 'Riho Nakata', 1, 'Femme', '1929-04-08', 89, '154-0014', 'Shinmachi, Setagaya-ku, Tokyo**********', 'S13009', 20150421, 'D-20091021-E'),
('CS005813000015', 'Erika Kanaya', 1, 'Femme', '1929-04-09', 89, '165-0032', 'Sagimiya, Nakano-ku, Tokyo**********', 'S13005', 20150506, '0-00000000-0'),
('CS012813000013', 'Uno Minami Tomo', 1, 'Femme', '1929-04-09', 89, '231-0806', 'Honmoku-cho, Naka-ku, Yokohama-shi, Kanagawa**********', 'S14012', 20150712, '0-00000000-0')],
dtype=[('customer_id', '<U14'), ('customer_name', '<U10'), ('gender_cd', '<i4'), ('gender', '<U2'), ('birth_day', '<U10'), ('age', '<i4'), ('postal_cd', '<U8'), ('address', '<U26'), ('application_store_cd', '<U6'), ('application_date', '<i4'), ('status_cd', '<U12')])
Time[017]
%timeit df_customer.sort_values('birth_day', ascending=True).head(10)
# 21.8 ms ± 346 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit arr_customer[arr_customer['birth_day'].argsort()][:10]
# 17.1 ms ± 473 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
P_018
P-18: Triez le bloc de données client (df_customer) par date de naissance (anniversaire_jour) dans l'ordre croissant, et affichez les 10 premiers éléments.
Inversez simplement l'ordre.
In[018]
arr_customer[arr_customer['birth_day'].argsort()][::-1][:10]
Out[018]
array([('CS035114000004', 'Misato Omura', 1, 'Femme', '2007-11-25', 11, '156-0053', 'Sakura, Setagaya-ku, Tokyo**********', 'S13035', 20150619, '6-20091205-6'),
('CS022103000002', 'Fukuyama Hajime', 9, 'inconnue', '2007-10-02', 11, '249-0006', 'Zushi, ville de Zushi, préfecture de Kanagawa**********', 'S14022', 20160909, '0-00000000-0'),
('CS002113000009', 'Mayuko Shibata', 1, 'Femme', '2007-09-17', 11, '184-0014', 'Nukii Minamimachi, ville de Koganei, Tokyo**********', 'S13002', 20160304, '0-00000000-0'),
('CS004115000014', 'Kyoko Matsui', 1, 'Femme', '2007-08-09', 11, '165-0031', 'Kamisagimiya, Nakano-ku, Tokyo**********', 'S13004', 20161120, '1-20081231-1'),
('CS002114000010', 'Haruka Yamauchi', 1, 'Femme', '2007-06-03', 11, '184-0015', 'Nukii Kitamachi, ville de Koganei, Tokyo**********', 'S13002', 20160920, '6-20100510-1'),
('CS025115000002', 'Natsuki Koyanagi', 1, 'Femme', '2007-04-18', 11, '245-0018', 'Ville de Kamiida, quartier d'Izumi, ville de Yokohama, préfecture de Kanagawa**********', 'S14025', 20160116, 'D-20100913-D'),
('CS002113000025', 'Manami Hirosue', 1, 'Femme', '2007-03-30', 12, '184-0015', 'Nukii Kitamachi, ville de Koganei, Tokyo**********', 'S13002', 20171030, '0-00000000-0'),
('CS033112000003', 'Miki Nagano', 1, 'Femme', '2007-03-22', 12, '245-0051', 'Ville de Nase, quartier de Totsuka, ville de Yokohama, préfecture de Kanagawa**********', 'S14033', 20150606, '0-00000000-0'),
('CS007115000006', 'Fukuoka Shun', 1, 'Femme', '2007-03-10', 12, '285-0845', 'Nishishizu, ville de Sakura, préfecture de Chiba**********', 'S12007', 20151118, 'F-20101016-F'),
('CS014113000008', 'Rio Yaguchi', 1, 'Femme', '2007-03-05', 12, '260-0041', 'Higashi Chiba, Chuo-ku, Chiba City, Préfecture de Chiba**********', 'S12014', 20150622, '3-20091108-6')],
dtype=[('customer_id', '<U14'), ('customer_name', '<U10'), ('gender_cd', '<i4'), ('gender', '<U2'), ('birth_day', '<U10'), ('age', '<i4'), ('postal_cd', '<U8'), ('address', '<U26'), ('application_store_cd', '<U6'), ('application_date', '<i4'), ('status_cd', '<U12')])
P_019
P-19: Attribuez des rangs au bloc de données des détails du reçu (df_receipt) dans l'ordre décroissant du montant des ventes (montant) par article, et extrayez les 10 premiers articles. Les articles doivent afficher l'ID client (customer_id), le montant des ventes (montant) et le rang attribué. Si le montant (montant) des ventes est le même, le même classement sera donné.
Il est facile de trier par montant de ventes le plus élevé.
sorted_array = arr_receipt[['customer_id', 'amount']][
arr_receipt['amount'].argsort()[::-1]]
sorted_array[:10]
# array([('CS011415000006', 10925), ('ZZ000000000000', 6800),
# ('CS028605000002', 5780), ('ZZ000000000000', 5480),
# ('ZZ000000000000', 5480), ('CS015515000034', 5480),
# ('CS021515000089', 5440), ('ZZ000000000000', 5440),
# ('ZZ000000000000', 5280), ('ZZ000000000000', 5280)],
# dtype={'names':['customer_id','amount'], 'formats':['<U14','<i4'], 'offsets':[40,140], 'itemsize':144})
Classez ce montant de vente. Le moyen le plus simple est d'utiliser scipy.stats.rankdata (). Cette fois, nous demandons le plus, mais cette fonction renvoie le classement par ordre croissant, alors soustrayez-la de la valeur maximale et retournez-la.
import scipy.stats
rank_asc = scipy.stats.rankdata(sorted_array['amount'], 'max')
rank = rank_asc.max() - rank_asc + 1
rank[:10]
# array([1, 2, 3, 4, 4, 4, 7, 7, 9, 9], dtype=int64)
Si vous n'utilisez pas la fonction scipy.stats.rankdata (), elle vérifie l'existence de liens et dit "quelle est la plus grande valeur de chaque ligne" et "quelle est la nième valeur la plus grande". Créez un tableau pour créer un tableau de rangs.
#False si elle a le même rang que la ligne supérieure suivante, True sinon
rank_cutidx = np.concatenate(
([True], sorted_array['amount'][1:] != sorted_array['amount'][:-1]))
# rank_cutidx.cumsum()-1: un tableau affichant la valeur la plus élevée de chaque ligne
# rank_cutidx.nonzero(): Un tableau indiquant le nombre de chaque "nième valeur la plus grande"
rank = rank_cutidx.nonzero()[0][rank_cutidx.cumsum()-1] + 1
rank[:10]
# array([1, 2, 3, 4, 4, 4, 7, 7, 9, 9], dtype=int64)
J'utilise numpy.lib.recfunctions.append_fields () pour ajouter des colonnes, mais cette fonction était extrêmement lente (elle semble recréer un nouveau tableau à partir de zéro).
In[019]
sorted_array = arr_receipt[['customer_id', 'amount']][
arr_receipt['amount'].argsort()[::-1]]
rank_cutidx = np.concatenate(
([True], sorted_array['amount'][1:] != sorted_array['amount'][:-1]))
rank = rank_cutidx.nonzero()[0][rank_cutidx.cumsum()-1]+1
rfn.append_fields(sorted_array, 'ranking', rank,
dtypes=rank.dtype, usemask=False)[:10]
Ensuite, vous devez préparer vous-même une table vierge ...
In[019]
sorter_index = arr_receipt['amount'].argsort()[::-1]
sorted_id = arr_receipt['customer_id'][sorter_index]
sorted_amount = arr_receipt['amount'][sorter_index]
rank_cutidx = np.concatenate(
([True], sorted_amount[1:] != sorted_amount[:-1]))
rank = rank_cutidx.nonzero()[0][rank_cutidx.cumsum()-1]+1
#Arrangement
new_arr = np.empty(arr_receipt.size, dtype=[('customer_id', sorted_id.dtype),
('amount', sorted_amount.dtype),
('ranking', rank.dtype)])
new_arr['customer_id'] = sorted_id
new_arr['amount'] = sorted_amount
new_arr['ranking'] = rank
new_arr[:10]
Out[019]
array([('CS011415000006', 10925, 1), ('ZZ000000000000', 6800, 2),
('CS028605000002', 5780, 3), ('ZZ000000000000', 5480, 4),
('ZZ000000000000', 5480, 4), ('CS015515000034', 5480, 4),
('CS021515000089', 5440, 7), ('ZZ000000000000', 5440, 7),
('ZZ000000000000', 5280, 9), ('ZZ000000000000', 5280, 9)],
dtype=[('customer_id', '<U14'), ('amount', '<i4'), ('ranking', '<i8')])
Time[019]
#Le modèle de réponse
%%timeit
df_tmp = pd.concat([df_receipt[['customer_id', 'amount']],
df_receipt['amount'].rank(method='min', ascending=False)], axis=1)
df_tmp.columns = ['customer_id', 'amount', 'ranking']
df_tmp.sort_values('ranking', ascending=True).head(10)
# 35 ms ± 643 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
#Une petite amélioration en une ligne
%%timeit
df_receipt[['customer_id', 'amount']] \
.assign(ranking=df_receipt['amount'].rank(method='min', ascending=False)) \
.sort_values('ranking', ascending=True).head(10)
# 34.1 ms ± 943 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
# Numpy
%%timeit
tmp_amount = np.ascontiguousarray(arr_receipt['amount'])
sorter_index = tmp_amount.argsort()[::-1]
sorted_id = arr_receipt['customer_id'][sorter_index]
sorted_amount = tmp_amount[sorter_index]
rank_cutidx = np.concatenate(([True], sorted_amount[1:] != sorted_amount[:-1]))
rank = rank_cutidx.nonzero()[0][rank_cutidx.cumsum()-1]+1
new_arr = np.empty(arr_receipt.size, dtype=[('customer_id', sorted_id.dtype), ('amount', sorted_amount.dtype), ('ranking', rank.dtype)])
new_arr['customer_id'] = sorted_id
new_arr['amount'] = sorted_amount
new_arr['ranking'] = rank
new_arr[:10]
# 22.6 ms ± 464 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
J'ai réussi à le traiter plus rapidement que les pandas.
P_020
P-020: attribuez des rangs au bloc de données des détails du reçu (df_receipt) dans l'ordre décroissant du montant des ventes (montant) par article, et extrayez les 10 premiers articles. Les articles doivent afficher l'ID client (customer_id), le montant des ventes (montant) et le rang attribué. Même si le montant (montant) des ventes est le même, un autre classement doit être donné.
Ceci est un classement, ou juste un numéro de série avec np.arange ().
In[020]
rfn.append_fields(arr_receipt[['customer_id', 'amount']]
[arr_receipt['amount'].argsort()[::-1]],
'ranking', np.arange(1, arr_receipt.size+1),
dtypes='<i4', usemask=False)[:10]
In[020]
sorter_index = arr_receipt['amount'].argsort()[::-1]
sorted_id = arr_receipt['customer_id'][sorter_index]
sorted_amount = arr_receipt['amount'][sorter_index]
rank = np.arange(1, sorted_id.size+1)
#Arrangement
new_arr = np.empty(arr_receipt.size, dtype=[('customer_id', sorted_id.dtype),
('amount', sorted_amount.dtype),
('ranking', rank.dtype)])
new_arr['customer_id'] = sorted_id
new_arr['amount'] = sorted_amount
new_arr['ranking'] = rank
new_arr[:10]
Out[020]
array([('CS011415000006', 10925, 1), ('ZZ000000000000', 6800, 2),
('CS028605000002', 5780, 3), ('ZZ000000000000', 5480, 4),
('ZZ000000000000', 5480, 5), ('CS015515000034', 5480, 6),
('CS021515000089', 5440, 7), ('ZZ000000000000', 5440, 8),
('ZZ000000000000', 5280, 9), ('ZZ000000000000', 5280, 10)],
dtype=[('customer_id', '<U14'), ('amount', '<i4'), ('ranking', '<i4')])
P_021
P-021: Comptez le nombre de caisses pour la trame de données des détails de réception (df_receipt).
In[021]
arr_receipt.size
len(arr_receipt)
arr_receipt.shape[0]
Out[021]
104681
104681
104681
P_022
P-022: Comptez le nombre de cas uniques pour l'ID client (customer_id) du bloc de données des détails du reçu (df_receipt).
Le nombre unique de données de chaîne de caractères n'est pas bon pour NumPy.
In[022]
np.unique(arr_receipt['customer_id']).size
Out[022]
8307
Ceci est connu pour être beaucoup plus rapide avec les pandas qu'avec NumPy, comme les pandas se vantent dans la documentation officielle, et nous, les pilotes de NumPy, ne pouvons probablement pas aider.
Time[022]
%timeit len(df_receipt['customer_id'].unique())
# 8.19 ms ± 204 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit np.unique(arr_receipt['customer_id']).size
# 30.9 ms ± 635 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
Recommended Posts