[PYTHON] Pré-traitement des données préfectorales

Code d'achèvement

transform.py


import re
import pandas as pd
import numpy as np
import codecs
import matplotlib.pyplot as plt
from sklearn import linear_model

with codecs.open(<Données automobiles>, "r", "Shift-JIS", "ignore") as file:   #http://qiita.com/niwaringo/items/d2a30e04e08da8eaa643
    df = pd.read_table(file, delimiter=",")

dfx = df.copy()

dfx.iloc[:,5:] = dfx.iloc[:,5:].applymap(lambda x: re.sub(',','',x)).applymap(lambda x: re.sub('-','',x)).convert_objects(convert_numeric=True)
#FutureWarning: convert_objects is deprecated.  Use the data-type specific converters pd.to_datetime, pd.to_timedelta and pd.to_numeric.


with codecs.open('Zone résidente.csv', "r", "Shift-JIS", "ignore") as file:
    df2 = pd.read_table(file, delimiter=",")

df2.iloc[:,3:] = df2.iloc[:,3:].applymap(lambda x: re.sub(',','',x)).applymap(lambda x: re.sub('-','',x)).convert_objects(convert_numeric=True)

nan = float('nan')
static_data=pd.DataFrame({
        'population_signal':[nan],
        'zone_signal':[nan],
        'Préfectures':[nan],
        'Voiture_signal':[nan],
        'Zone résidente_signal':[nan],
        'Fonction composite_population_zone':[nan],
        'Fonction composite_Voiture_zone':[nan],
        'Fonction composite_population_Zone résidente':[nan],
        'Fonction composite_Voiture_Zone résidente':[nan]
    }).dropna()

for iteritem in range(1,48):
    iter_shape = df2[df2['Code préfecture']==iteritem]

    iter_data = dfx[
                    (dfx['Code préfecture']==iteritem)
                  & (dfx['Municipalité'].str.contains('ville$') | dfx['Municipalité'].str.contains('Total$') | dfx['Municipalité'].str.contains('ville$') | dfx['Municipalité'].str.contains('village$'))
                  & (dfx['Type d'entreprise'].str.contains('^Total$'))
                ]

    iter_data2 = iter_data.copy()
    iter_data2.loc[:,'Municipalité'] = iter_data2.loc[:,'Municipalité'].apply(lambda x: re.sub(r'Total de la ville$','ville',x))
    iter_data2.loc[:,'Municipalité'] = iter_data2.loc[:,'Municipalité'].apply(lambda x: re.sub(r'^.*comté','',x))

    merged = pd.merge(iter_shape,iter_data2,on='Municipalité')
    merged = merged.assign(
Fonction composite_population=np.nan,
Fonction composite_Voiture_zone=(merged['Total total']**(2/3))*(merged['総zone']**(1/3)),
Fonction composite_population_zone=(merged['population総数']**(2/3))*(merged['総zone']**(1/3)),
Fonction composite_Voiture_Zone résidente=(merged['Total total']**(2/3))*(merged['Zone résidente']**(1/3)),
Fonction composite_population_Zone résidente=(merged['population総数']**(2/3))*(merged['Zone résidente']**(1/3)),
Superficie racine carrée=np.sqrt(merged['Superficie totale']),
Racine carrée de la zone résidente=np.sqrt(merged['Zone résidente']),
Estimation du signal= np.around(0.0027*merged['Total total'].astype(np.float),0)        
             )

    people_signal = linear_model.LinearRegression(fit_intercept=False)
    car_signal = linear_model.LinearRegression(fit_intercept=False)
    shape_signal = linear_model.LinearRegression(fit_intercept=False)
    liveshape_signal = linear_model.LinearRegression(fit_intercept=False)
    people_shape = linear_model.LinearRegression(fit_intercept=False)
    car_shape = linear_model.LinearRegression(fit_intercept=False)
    people_liveshape = linear_model.LinearRegression(fit_intercept=False)
    car_liveshape = linear_model.LinearRegression(fit_intercept=False)

    people = np.array(merged['Superficie totale']).reshape(-1,1)
    car = np.array(merged['Total total']).reshape(-1,1)
    shape = np.array(merged['Superficie racine carrée']).reshape(-1,1)
    liveshape = np.array(merged['Racine carrée de la zone résidente']).reshape(-1,1)
    peopleShape = np.array(merged['Fonction composite_population_zone']).reshape(-1,1)
    carShape = np.array(merged['Fonction composite_Voiture_zone']).reshape(-1,1)
    peopleLiveShape = np.array(merged['Fonction composite_population_Zone résidente']).reshape(-1,1)
    carLiveShape = np.array(merged['Fonction composite_Voiture_Zone résidente']).reshape(-1,1)
    y_data=np.array(merged['Estimation du signal']).reshape(-1,1)

    people_signal.fit(people,y_data)
    car_signal.fit(car,y_data)
    shape_signal.fit(shape,y_data)
    liveshape_signal.fit(liveshape,y_data)
    people_shape.fit(peopleShape,y_data)
    car_shape.fit(carShape,y_data)
    people_liveshape.fit(peopleLiveShape,y_data)
    car_liveshape.fit(carLiveShape,y_data)

    df_result=pd.DataFrame({
        'population_signal':[people_signal.score(people,y_data)],
        'zone_signal':[shape_signal.score(shape,y_data)],
        'Préfectures':[merged['Préfectures'][0]],
        'Voiture_signal':[car_signal.score(car,y_data)],
        'Zone résidente_signal':[liveshape_signal.score(liveshape,y_data)],
        'Fonction composite_population_zone':[people_shape.score(peopleShape,y_data)],
        'Fonction composite_Voiture_zone':[car_shape.score(carShape,y_data)],
        'Fonction composite_population_Zone résidente':[people_liveshape.score(peopleLiveShape,y_data)],
        'Fonction composite_Voiture_Zone résidente':[car_liveshape.score(carLiveShape,y_data)]
    })

    static_data = static_data.append(df_result)

static_data.to_csv('static_data.csv',encoding='shift_jis')

Lire les données csv

with codecs.open(<Données automobiles>, "r", "Shift-JIS", "ignore") as file:   #http://qiita.com/niwaringo/items/d2a30e04e08da8eaa643
    df = pd.read_table(file, delimiter=",")

Passer à une forme facile à utiliser

hokkaido_data = df[(df['Bureau régional des transports'].str.contains('la mer du Nord')) 
                              & (df['Municipalité'].str.contains('ville$') | df['Municipalité'].str.contains('Total$') | df['Municipalité'].str.contains('ville$') | df['Municipalité'].str.contains('village$'))
                              & (df['Type d'entreprise'].str.contains('Total')) ]
#Bureau des transports locaux comprend la mer du Nord&& (Le nom de la ville se termine par la ville|Le nom de la ville comprend le comté=>Le nom municipal se termine par la ville, le village|Se termine dans ville, village) &&Le type d'entreprise est total
#Match de fin de ligne

Aligner les noms des tables pour les jointures (rechercher, remplacer)

Source: http://sinhrks.hatenablog.com/entry/2014/12/06/233032

Par conséquent, en ajoutant l'accesseur str, le traitement par lots des chaînes de caractères devient possible.

df[(df['Bureau régional des transports'].str.contains('^la mer du Nord'))].Bureau régional des transports.str.replace(r'^la mer du Nord道', '')
#Tous"Bureau des transports d'Hokkaido"À"Bureau des transports"Remplacer par

Convertit une chaîne de 3 chiffres séparés par des virgules en un nombre

dfx.iloc[:,4:] =    # iloc()Comme celui extrait avec n'est pas une tranche, la valeur peut être modifiée directement.
dfx.iloc[:,4:].applymap(lambda x: re.sub(',','',x))      
.applymap(lambda x: re.sub('-','',x))
.convert_objects(convert_numeric=True)

・ Puisqu'une copie est créée dans ʻapplymap, remplacez-la. ・ ʻApply map applique la fonction de l'argument à tous les éléments. -Remplacer le premier argument de re.sub (pattern, str, argument) => ʻargument` par le second argument ・ Agneau (x: x ** 2) => Fonction anonyme

Régression linéaire

from sklearn import linear_model

lm = linear_model.LinearRegression(fit_intercept=False) #Option pour définir la section sur 0

x_data=merged['Zone résidente']
y_data=merged['Population totale']

#Puisque sklearn ne peut gérer que numpy, changez-le en type numpy. Remodelez-le également, car il doit être sous la forme de colonnes au lieu de lignes.
x_data = np.array(x_data).reshape(-1,1) 
y_data = np.array(y_data).reshape(-1,1)

lm.fit(x_data,y_data)
print(lm.coef_)      #Coefficient de régression partiel
print(lm.intercept_) #=> 0.0 Naturellement, car la section est définie sur 0
print(lm.score(x_data,y_data)) #Coefficient de décision

référence

http://qiita.com/irs/items/4ebbfd8bef63db1892fb http://qiita.com/Attsun/items/5af3efdc241aa2fd3959 http://sinhrks.hatenablog.com/entry/2015/01/28/073327 À propos de la fonction anonyme lambda http://www.lifewithpython.com/2013/01/python-anonymous-function-lambda.html

Recommended Posts

Pré-traitement des données préfectorales
Visualisation des données par préfecture
Analyse des séries chronologiques 3 Prétraitement des données des séries chronologiques
Corrélation par prétraitement des données
Nettoyage des données 3 Utilisation d'OpenCV et prétraitement des données d'image
Sélection des données de mesure
À propos du prétraitement des données des systèmes utilisant l'apprentissage automatique
Vérification des performances du prétraitement des données dans le traitement du langage naturel
Vue d'ensemble du traitement du langage naturel et de son prétraitement des données
Pré-traitement et post-traitement de pytest
Expérience de réglage des données Tensorflow
Transformée de Fourier des données brutes
Prétraitement des données texte (vectorisation, TF-IDF)
Estimation moyenne des données plafonnées
À propos de la gestion des données d'Anvil-App-Server
Prédiction de probabilité de données déséquilibrées
Vérification des performances du prétraitement des données pour l'apprentissage automatique (données numériques) (partie 2)
Application de Python: Nettoyage des données Partie 3: Utilisation d'OpenCV et prétraitement des données d'image
Implémentez la normalisation du prétraitement des données d'entraînement Python avec scikit-learn [fit_transform]
Vérification des performances du prétraitement des données pour l'apprentissage automatique (données numériques) (partie 1)
[Python] Version Taple du menu déroulant de la préfecture
Notes personnelles de prétraitement des données Python Pandas
Conversion matricielle d'économie de mémoire des données de journal
Modèle de prétraitement pour l'analyse des données (Python)
Prétraitement dans l'apprentissage automatique 2 Acquisition de données
Différenciation des données de séries chronologiques (discrètes)
10 sélections d'extraction de données par pandas.DataFrame.query
Animation des géodonnées par geopandas
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.3. Prétraitement des données
Prétraitement dans l'apprentissage automatique 4 Conversion de données
Traitement des données 2 Analyse de divers formats de données
Python: prétraitement en machine learning: gestion des données manquantes / aberrantes / déséquilibrées
Bases de la théorie de l'information quantique: compression de données (1)
100 traitement du langage knock-91: Préparation des données d'analogie
Acquisition des données de croissance des plantes Acquisition des données des capteurs
Python: prétraitement en machine learning: acquisition de données
Séparation de la conception et des données dans matplotlib
Conversion des données de temps en notation 25 heures
Recommandation d'Altair! Visualisation des données avec Python
Python: prétraitement dans l'apprentissage automatique: conversion de données
Visualisez les données d'exportation du journal Piyo
Prétraitement dans l'apprentissage automatique 1 Processus d'analyse des données
Exemple de traitement efficace des données avec PANDAS
Bases de la théorie de l'information quantique: compression de données (2)
[Introduction au Data Scientist] Bases de Python ♬
Connaissance de l'utilisation de l'API de données Aurora Severless
Un mémorandum de problème lors du formatage des données
Grattage des données et des informations statistiques sur les nouvelles infections à coronavirus dans la préfecture de Yamanashi
[Python] Tracer les données par préfecture sur une carte (nombre de voitures possédées dans tout le pays)