Un mémo personnel que je mets à jour de temps en temps au fur et à mesure que j'apprends le "pré-traitement" des données à l'aide de pandas.
――Lorsque vous pensez au prétraitement, vous pourriez penser à l'IA / l'apprentissage automatique. Le but de l'apprentissage de prétraitement est que je veux pouvoir traiter et analyser les données accumulées comme je le souhaite. Il peut être insuffisant en tant qu'informations de prétraitement à des fins d'apprentissage automatique. «Je ne suis pas une personne dans le domaine de l'IA, donc si vous recherchez des connaissances dans ce domaine, je pense qu'il serait préférable de garder le contenu de cet article à titre de référence uniquement. «Parce qu'il est sur le point d'être écrit, il y a de nombreuses expressions ambiguës et il peut y avoir des informations difficiles à comprendre. Nous prévoyons de le mettre à jour de temps en temps, mais nous vous serions reconnaissants si vous pouviez signaler toute information incorrecte.
Pour nettoyer ou traiter les données accumulées afin d'effectuer le travail souhaité (apprentissage automatique, etc.). Il semble que les personnes qui font de l'apprentissage automatique passent également le plus de temps à ce travail avec le travail de collecte de données.
--Nettoyage des données --Synonyme de nettoyage des données. Se réfère peut-être à certains travaux de «prétraitement». --Nettoyage des données --Synonyme de nettoyage des données. --Data Langling -Plus large que les deux ci-dessus. Peut-être "synonyme de prétraitement" ou "comprend le prétraitement".
Procédez comme suit: Il peut y avoir une commande plus efficace et des tâches plus détaillées.
Préparez un environnement de test Python pour l'apprentissage.
--Environnement local
Ce serait bien de pouvoir préparer rapidement des données de test à la fois en série et en Dataframe.
Series
en préparation
Dataframe
en préparation
#Références pour maximum, minimum, moyenne, écart type, etc.
df.describe()
#Référence du type de données de chaque colonne
df.info()
#Parcourir les premières lignes de données
df.head()
#Parcourir les dernières lignes de données
df.tail()
#Nombre de dimensions des données (combien de lignes et de colonnes)
df.shape
#Nombre de valeurs
df["column"].value_counts()
#Nombre de valeurs (identique à ci-dessus)
pd.value_counts(df["column"])
#Liste des noms de colonnes ①
df.columns
#Liste des noms de colonnes ②
df.count()
#Nombre de valeurs manquantes ("Nombre de lignes-Le nombre de données"Lors de la demande à)
#Vous pouvez répertorier l'état manquant de la colonne entière.
df_s.shape[0] - df_s.count()
#Nombre de valeurs manquantes(Colonne spécifique)
df_s["Contenu défectueux.1"].isnull().value_counts()
#Afficher les lignes avec des valeurs manquantes(Dans une colonne spécifique)
df_s.loc[df_s["Contenu défectueux.1"].isnull()]
#Supprimer une ligne s'il y a même une valeur manquante dans df
df.dropna(axis = 0, how = 'any', inplace=True)
#Définir un seuil et supprimer (supprimer les lignes avec 3 colonnes ou plus manquantes)
#S'il n'est pas remplacé, il ne sera pas reflété dans les données source.
df.dropna(thresh=3,inplace=True)
fillna
df.loc[df["Prix unitaire"].isna(),"Prix unitaire"] = 0
#S'il y a des valeurs manquantes dans le calcul, le résultat sera Nan. Utilisez l'option pour ignorer les valeurs manquantes.
df.sum(skipna=False)
df.mean(skipna=False)
df_s.duplicated().value_counts()
df_s[df_s.duplicated() == True].count()
#Unité de colonne
df_s[df_s.duplicated() == True ]["les pièces"].count()
Vérifiez qu'il a le type de données correct et convertissez-le au type approprié si nécessaire. Lors de la conversion en un type numérique, il est nécessaire de se souvenir du travail tel que la définition de la chaîne de caractères sur une valeur numérique et la définition des données nulles à 0 à l'avance. La méthode ʻAstype` est principalement utilisée.
#Référence du type de données
df2.info()
#Conversion de type de données (réalisée en ajoutant une nouvelle colonne)
df["Numéro de pièce 2"] = df["Numéro de produit"].astype(object)
#Conversion de type de données(Remplacez et convertissez la colonne d'origine telle quelle)
df_s["test"] = df_s["test"].astype(object) # object(string)
df_s["test"] = df_s["test"].astype(str) # object(string)
df_s["test"] = df_s["test"].astype(float) # Float
df_s["test"] = df_s["test"].astype(int) # integer
#Convertir en type numérique tout en éliminant de force les valeurs mal saisies (To Nan)
df_s["test"] = pd.to_numeric(df_s["test"] , errors="coerce")
#Extraire une colonne spécifique (ne modifie pas les données d'origine)
df[["colB","colD"]]
#Extraire à l'aide d'expressions régulières
tanka_nan = df["Prix unitaire"].str.extract("(^\D*)", expand=False)
tanka_nan.value_counts()
#「[La valeur dans la colonne de prix unitaire est"Produit en vrac"]Extrait par "extraction de ligne" et "extraction de colonne de la colonne de prix unitaire"
df.loc[df["Prix unitaire"] == "Produit en vrac","Prix unitaire"]
#Filtrer les lignes de la liste et créer un nouveau DF
df2 = df[df["Numéro de produit"].isin(mylist)]
dftest["grade"] = dftest["Nom du produit"].apply(lambda x : x[0:2] )
dftest = pd.DataFrame({"prefecture":["hokkaidou","shizuoka","okinawa"],"city":["sapporo","shizuoka","naha"]})
dftest_map = {"hokkaidou":10,"shizuoka":20,"okinawa":30}
dftest["maptest"] = dftest.prefecture.map(dftest_map)
dftest
# Créez la fonction suivante.
# # Si la valeur de l'argument contient "limited", la chaîne de caractères "limited product" est renvoyée.
# # Si la valeur de l'argument contient "nouveau", la chaîne de caractères "nouveau produit" est renvoyée.
# # Si la valeur de l'argument est différente de cela, la chaîne de caractères "na" est renvoyée.
def newitem(x):
if "Limité" in str(x):
return "Produit limité"
elif "Nouveau" in str(x):
return "nouveau produit"
else:
return "na"
# Créez une nouvelle colonne "Catégorie de produit" et renvoyez le résultat en évaluant la colonne de nom de produit avec la fonction créée.
df["Catégorie de produit"] = df["Nom du produit"].apply(newitem)
#Renommer la colonne(Changement de format de dictionnaire)
df = df.rename(columns={'Nom du produit':'Nom du produit'})
#Renommer la colonne (changer la toute première colonne)
df.rename(columns={df.columns[0]: "Nom du produit"})
df.loc[:,"Prix unitaire"] = 0
df.loc[df["Prix unitaire"] == "La fourniture", "Prix unitaire"] = 0
df["grade"] = df["Nom du produit"].str.extract(
"(^[Ａ-Ｚ]{2}|^[A-Z]{2}|^/d/d?／/d+|^[０-９][０-９]?／[０-９]*)", expand=False)
Le groupe utilise un objet groupby
--Utilisez df.groupby ().
--Si vous groupez et placez-le dans une variable, la variable contiendra un objet Group by. (Pas DataFraem, Series)
df.groupby('items').get_group('item_1')
g1 = df.groupby('items')
print(g1.groups)
df.groupby('items').size()
#Agréger collectivement
df_s.groupby("Lieu d'ensachage").agg(np.sum)
#Agrégation à l'aide d'un dictionnaire
df_s.groupby("Lieu d'ensachage").agg({"Nombre total de production":np.sum, "lot":"first" })
train["year"]= train["datetime"].apply(lambda x : x.split("-")[0] )
Principalement fait ci-dessous. L'écriture.
--melt (qui signifie fondre)
en préparation
en préparation
Diviser les valeurs discontinues en nombres plus petits à l'aide de groupes pour les regrouper. Aussi appelé division de bac. Bin semble signifier une étagère.
Par exemple, s'il existe une colonne contenant l'âge d'une personne, utilisez-la pour grouper par section par groupe d'âge tel que [adolescents, 20 ans, 30 ans ...].
Utilisez cut et qcut.
Une image de tri des données d'origine (dans ce cas, les données d'âge) dans la "tablette" créée. Sans surprise, le nombre de casiers est inférieur aux données source.
#Tout d'abord, supposons qu'il existe de telles données d'âge.
ages = [random.randint(0, 100) for i in range(20)]
print(ages)
#[84, 73, 27, 85, 8, 17, 46, 16, 95, 62, 38, 47, 63, 44, 69, 26, 0, 40, 34, 79]
#Préparer les bacs pour regrouper ces données d'âge
bins = np.arange(0,90,10) #Générer le numéro de série
print(bin)
# >>> [ 0 10 20 30 40 50 60 70 80]
#Couper
cats = pd.cut(ages, bins)
print(cats)
# [NaN, (70.0, 80.0], (20.0, 30.0], NaN, (0.0, 10.0], ..., (20.0, 30.0], NaN, (30.0, 40.0], (30.0, 40.0], (70.0, 80.0]]
# Length: 20
# Categories (8, interval[int64]): [(0, 10] < (10, 20] < (20, 30] < (30, 40] < (40, 50] < (50, 60] < (60, 70] < (70, 80]]
Quantité de fonctionnalités = une colonne donnée directement lors de la création d'un modèle de prédiction pour l'apprentissage automatique.
Lors de la création d'un modèle prédictif, toutes les colonnes des données collectées ne sont pas requises pour le modèle prédictif. Il est également possible qu'il n'y ait pas assez de lignes. Dans l'apprentissage automatique, il est important de sélectionner cette colonne ou d'ajouter une nouvelle colonne pour augmenter la quantité d'entités, et l'augmentation de la colonne de quantité d'entités s'appelle création de quantité d'entités. La création et le réglage des fonctionnalités s'appelle «Ingénierie des fonctionnalités».
--Book (lien vers Amazon)
--Vidéo (udemy)
Recommended Posts