Einführung

Seit ich angefangen habe, maschinelles Lernen zu studieren, konnte ich verschiedene Kenntnisse eingeben, also mache ich es mit kaggle! Ich habe es versucht, aber ich war frustriert. Ich habe keine Ahnung, wie ich damit umgehen soll! !! Ich war in einem Zustand und meine Motivation zum Lernen war geringer.

Ich fand den folgenden Artikel, als ich nach etwas Interessantem suchte, weil ich dachte, es wäre so nutzlos wie es ist! [Für Super-Anfänger] Python-Umgebungskonstruktion & Scraping & maschinelles Lernen & praktische Anwendung, die Sie genießen können, wenn Sie mit Kopie umziehen [Lassen Sie uns mit SUUMO ein gutes Mietobjekt finden! ]

Ich habe vor kurzem nach einem Mietobjekt gesucht, also fand ich es genau richtig und habe es ausprobiert.

Implementiert mit Bezug auf den Artikel. Ich werde es vorstellen, weil ich auf meine Weise verschiedene Verbesserungen vorgenommen habe.

Für welche Art von Person?

Für selbsternannte Anfänger des maschinellen Lernens wie mich. Dies ist für Leute, die verschiedene Dinge eingegeben haben, aber nicht wissen, was sie danach tun sollen. Ich habe die grundlegenden Begriffe und Methoden des maschinellen Lernens nicht erklärt, also keine Angst.

Meine Umgebung

windous10 Home python3.7.3 Jupyter Notebook (zum Testen)

Quellcode https://github.com/pattatto/scraping

Verbessert

Lassen Sie mich zunächst einen Überblick geben. Die Verzeichnisstruktur ist wie folgt.

Als eine Reihe von Strömungen

Datenerfassung durch Scraping (suumo_getdata.py)
Datenvorverarbeitung (Preprocessing.py)
Feature-Erstellung (Feature_value.py)
Modelllernen (model_lightgbm.py)
Ergebnis der Ausgabevorhersage des trainierten Modells (Create_Otoku_data.py)

Ursprünglich war es ein einzelner Code, aber wir haben diese modularisiert. Das Ergebnis der Datenverarbeitung wird jedes Mal in CSV ausgegeben und bei jeder Verwendung aufgerufen.

Schaben

`suumo_getdata.py`


from bs4 import BeautifulSoup
import urllib3
import re
import requests
import time
import pandas as pd
from pandas import Series, DataFrame

url = input()

result = requests.get(url)
c = result.content

soup = BeautifulSoup(c)

#Ich möchte die Gesamtzahl der Seiten erhalten
summary = soup.find("div",{'id':'js-bukkenList'})
body = soup.find("body")
pages = body.find_all("div",{'class':'pagination pagination_set-nav'})
pages_text = str(pages)
pages_split = pages_text.split('</a></li>\n</ol>')
pages_split0 = pages_split[0]
pages_split1 = pages_split0[-3:]
pages_split2 = pages_split1.replace('>','')#Es stört, wenn es 2-stellig ist>Entfernen
pages_split3 = int(pages_split2)

urls = []

urls.append(url)

#Nach Seite 2 am Ende der URL&page=2 ist beigefügt
for i in range(pages_split3-1):
    pg = str(i+2)
    url_page = url + '&page=' + pg
    urls.append(url_page)

names = []
addresses = []
buildings = []
locations0 = []
locations1 = []
locations2 = []
ages = []
heights = []
floors = []
rent = []
admin = []
others = []
floor_plans = []
areas = []
detail_urls = []


for url in urls:
    result = requests.get(url)
    c = result.content
    soup = BeautifulSoup(c)
    summary = soup.find("div",{'id':'js-bukkenList'})
    apartments = summary.find_all("div",{'class':'cassetteitem'})

    for apartment in apartments:

        room_number = len(apartment.find_all('tbody'))

        name = apartment.find('div', class_='cassetteitem_content-title').text
        address = apartment.find('li', class_='cassetteitem_detail-col1').text
        building = apartment.find('span', class_='ui-pct ui-pct--util1').text
        #Fügen Sie der Liste so viele Objektnamen und Adressen hinzu, wie für jede Vermietung Zimmer vorhanden sind
        for i in range(room_number):
            names.append(name)
            addresses.append(address)
            buildings.append(building)

        sublocation = apartment.find('li', class_='cassetteitem_detail-col2')
        cols = sublocation.find_all('div')
        for i in range(len(cols)):
            text = cols[i].find(text=True)
            #Fügen Sie jeder Liste Daten hinzu, so viele wie die Anzahl der Räume
            for j in range(room_number):
                if i == 0:
                    locations0.append(text)
                elif i == 1:
                    locations1.append(text)
                elif i == 2:
                    locations2.append(text)

        age_and_height = apartment.find('li', class_='cassetteitem_detail-col3')
        age = age_and_height('div')[0].text
        height = age_and_height('div')[1].text

        for i in range(room_number):
            ages.append(age)
            heights.append(height)

        table = apartment.find('table')
        rows = []
        rows.append(table.find_all('tr'))#Informationen zu jedem Zimmer

        data = []
        for row in rows:
            for tr in row:
                cols = tr.find_all('td')#td detaillierte Zimmerinformationen
                if len(cols) != 0:
                    _floor = cols[2].text
                    _floor = re.sub('[\r\n\t]', '', _floor)

                    _rent_cell = cols[3].find('ul').find_all('li')
                    _rent = _rent_cell[0].find('span').text#Miete
                    _admin = _rent_cell[1].find('span').text#Verwaltungsgebühr

                    _deposit_cell = cols[4].find('ul').find_all('li')
                    _deposit = _deposit_cell[0].find('span').text
                    _reikin = _deposit_cell[1].find('span').text
                    _others = _deposit + '/' + _reikin

                    _floor_cell = cols[5].find('ul').find_all('li')
                    _floor_plan = _floor_cell[0].find('span').text
                    _area = _floor_cell[1].find('span').text

                    _detail_url = cols[8].find('a')['href']
                    _detail_url = 'https://suumo.jp' + _detail_url

                    text = [_floor, _rent, _admin, _others, _floor_plan, _area, _detail_url]
                    data.append(text)

        for row in data:
            floors.append(row[0])
            rent.append(row[1])
            admin.append(row[2])
            others.append(row[3])
            floor_plans.append(row[4])
            areas.append(row[5])
            detail_urls.append(row[6])


        time.sleep(3)

names = Series(names)
addresses = Series(addresses)
buildings = Series(buildings)
locations0 = Series(locations0)
locations1 = Series(locations1)
locations2 = Series(locations2)
ages = Series(ages)
heights = Series(heights)
floors = Series(floors)
rent = Series(rent)
admin = Series(admin)
others = Series(others)
floor_plans = Series(floor_plans)
areas = Series(areas)
detail_urls = Series(detail_urls)

suumo_df = pd.concat([names, addresses, buildings, locations0, locations1, locations2, ages, heights, floors, rent, admin, others, floor_plans, areas, detail_urls], axis=1)

suumo_df.columns=['Name der Wohnung','Adresse', 'Gebäudetyp', 'Standort 1','Standort 2','Standort 3','Alter','Gebäude höhe','Hierarchie','Miete','Verwaltungsgebühr', 'Shiki/Vielen Dank/Garantie/Shiki引,Amortisation','Gebäudeplan','Besetztes Gebiet', 'Detaillierte URL']

suumo_df.to_csv('suumo.csv', sep = '\t', encoding='utf-16', header=True, index=False)

Der Gebäudetyp (Wohnung, Wohnung usw.) wird zusätzlich erworben. Als ich den ursprünglichen Code ausführte, standen oben in den Angeboten einige Wohnungen. Unter den gleichen Bedingungen ist es natürlich, dass die Wohnung billiger ist.

Vorbehandlung

`Preprocessing.py`


import pandas as pd
import numpy as np
from sklearn.preprocessing import OrdinalEncoder
from sklearn import preprocessing
import pandas_profiling as pdp

df = pd.read_csv('otokuSearch/data/suumo.csv', sep='\t', encoding='utf-16')

splitted1 = df['Standort 1'].str.split('Ayumu', expand=True)
splitted1.columns = ['Standort 11', 'Standort 12']
splitted2 = df['Standort 2'].str.split('Ayumu', expand=True)
splitted2.columns = ['Standort 21', 'Standort 22']
splitted3 = df['Standort 3'].str.split('Ayumu', expand=True)
splitted3.columns = ['Standort 31', 'Standort 32']

splitted4 = df['Shiki/Vielen Dank/Garantie/Shiki引,Amortisation'].str.split('/', expand=True)
splitted4.columns = ['Anzahlung', 'Schlüsselgeld']

df = pd.concat([df, splitted1, splitted2, splitted3, splitted4], axis=1)

df.drop(['Standort 1','Standort 2','Standort 3','Shiki/Vielen Dank/Garantie/Shiki引,Amortisation'], axis=1, inplace=True)

df = df.dropna(subset=['Miete'])

df['Miete'] = df['Miete'].str.replace(u'Zehntausend Yen', u'')
df['Anzahlung'] = df['Anzahlung'].str.replace(u'Zehntausend Yen', u'')
df['Schlüsselgeld'] = df['Schlüsselgeld'].str.replace(u'Zehntausend Yen', u'')
df['Verwaltungsgebühr'] = df['Verwaltungsgebühr'].str.replace(u'Kreis', u'')
df['Alter'] = df['Alter'].str.replace(u'Neubau', u'0')
df['Alter'] = df['Alter'].str.replace(u'Über 99 Jahre', u'0') #
df['Alter'] = df['Alter'].str.replace(u'Gebaut', u'')
df['Alter'] = df['Alter'].str.replace(u'Jahr', u'')
df['Besetztes Gebiet'] = df['Besetztes Gebiet'].str.replace(u'm', u'')
df['Standort 12'] = df['Standort 12'].str.replace(u'Protokoll', u'')
df['Standort 22'] = df['Standort 22'].str.replace(u'Protokoll', u'')
df['Standort 32'] = df['Standort 32'].str.replace(u'Protokoll', u'')

df['Verwaltungsgebühr'] = df['Verwaltungsgebühr'].replace('-',0)
df['Anzahlung'] = df['Anzahlung'].replace('-',0)
df['Schlüsselgeld'] = df['Schlüsselgeld'].replace('-',0)

splitted5 = df['Standort 11'].str.split('/', expand=True)
splitted5.columns = ['Route 1', 'Station 1']
splitted5['1 Spaziergang vom Bahnhof entfernt'] = df['Standort 12']
splitted6 = df['Standort 21'].str.split('/', expand=True)
splitted6.columns = ['Route 2', 'Station 2']
splitted6['2 zu Fuß vom Bahnhof entfernt'] = df['Standort 22']
splitted7 = df['Standort 31'].str.split('/', expand=True)
splitted7.columns = ['Route 3', 'Station 3']
splitted7['3 zu Fuß vom Bahnhof entfernt'] = df['Standort 32']

df = pd.concat([df, splitted5, splitted6, splitted7], axis=1)

df.drop(['Standort 11','Standort 12','Standort 21','Standort 22','Standort 31','Standort 32'], axis=1, inplace=True)

df['Miete'] = pd.to_numeric(df['Miete'])
df['Verwaltungsgebühr'] = pd.to_numeric(df['Verwaltungsgebühr'])
df['Anzahlung'] = pd.to_numeric(df['Anzahlung'])
df['Schlüsselgeld'] = pd.to_numeric(df['Schlüsselgeld'])
df['Alter'] = pd.to_numeric(df['Alter'])
df['Besetztes Gebiet'] = pd.to_numeric(df['Besetztes Gebiet'])

df['Miete'] = df['Miete'] * 10000
df['Anzahlung'] = df['Anzahlung'] * 10000
df['Schlüsselgeld'] = df['Schlüsselgeld'] * 10000

df['1 Spaziergang vom Bahnhof entfernt'] = pd.to_numeric(df['1 Spaziergang vom Bahnhof entfernt'])
df['2 zu Fuß vom Bahnhof entfernt'] = pd.to_numeric(df['2 zu Fuß vom Bahnhof entfernt'])
df['3 zu Fuß vom Bahnhof entfernt'] = pd.to_numeric(df['3 zu Fuß vom Bahnhof entfernt'])

splitted8 = df['Hierarchie'].str.split('-', expand=True)
splitted8.columns = ['1. Stock', 'Etage 2']
splitted8['1. Stock'].str.encode('cp932')
splitted8['1. Stock'] = splitted8['1. Stock'].str.replace(u'Fußboden', u'')
splitted8['1. Stock'] = splitted8['1. Stock'].str.replace(u'B', u'-')
splitted8['1. Stock'] = splitted8['1. Stock'].str.replace(u'M', u'')
splitted8['1. Stock'] = pd.to_numeric(splitted8['1. Stock'])
df = pd.concat([df, splitted8], axis=1)

df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'U-Bahn 1 oberirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'U-Bahn 2 oberirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'U-Bahn 3 oberirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'U-Bahn 4 oberirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'U-Bahn 5 oberirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'U-Bahn 6 oberirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'7 unterirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'8 unterirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'U-Bahn 9 oberirdisch', u'')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'Eine Geschichte', u'1')
df['Gebäude höhe'] = df['Gebäude höhe'].str.replace(u'Fußboden', u'')
df['Gebäude höhe'] = pd.to_numeric(df['Gebäude höhe'])

df = df.reset_index(drop=True)
df['Layout DK'] = 0
df['Layout K.'] = 0
df['Layout L.'] = 0
df['Layout S.'] = 0
df['Gebäudeplan'] = df['Gebäudeplan'].str.replace(u'Studio', u'1')

for x in range(len(df)):
    if 'DK' in df['Gebäudeplan'][x]:
        df.loc[x,'Layout DK'] = 1
df['Gebäudeplan'] = df['Gebäudeplan'].str.replace(u'DK',u'')

for x in range(len(df)):
    if 'K' in df['Gebäudeplan'][x]:
        df.loc[x,'Layout K.'] = 1
df['Gebäudeplan'] = df['Gebäudeplan'].str.replace(u'K',u'')

for x in range(len(df)):
    if 'L' in df['Gebäudeplan'][x]:
        df.loc[x,'Layout L.'] = 1
df['Gebäudeplan'] = df['Gebäudeplan'].str.replace(u'L',u'')

for x in range(len(df)):
    if 'S' in df['Gebäudeplan'][x]:
        df.loc[x,'Layout S.'] = 1
df['Gebäudeplan'] = df['Gebäudeplan'].str.replace(u'S',u'')

df['Gebäudeplan'] = pd.to_numeric(df['Gebäudeplan'])

splitted9 = df['Adresse'].str.split('Station', expand=True)
splitted9.columns = ['Kommunal']
#splitted9['Station'] = splitted9['Station'] + 'Station'
#splitted9['Station'] = splitted9['Station'].str.replace('Tokio','')
df = pd.concat([df, splitted9], axis=1)

splitted10 = df['Station 1'].str.split('Bus', expand=True)
splitted10.columns = ['Station 1', 'Bus 1']
splitted11 = df['Station 2'].str.split('Bus', expand=True)
splitted11.columns = ['Station 2', 'Bus 2']
splitted12 = df['Station 3'].str.split('Bus', expand=True)
splitted12.columns = ['Station 3', 'Bus 3']

splitted13 = splitted10['Bus 1'].str.split('Protokoll\(Bushaltestelle\)', expand=True)
splitted13.columns = ['Buszeit 1', 'Bushaltestelle 1']
splitted14 = splitted11['Bus 2'].str.split('Protokoll\(Bushaltestelle\)', expand=True)
splitted14.columns = ['Buszeit 2', 'Bushaltestelle 2']
splitted15 = splitted12['Bus 3'].str.split('Protokoll\(Bushaltestelle\)', expand=True)
splitted15.columns = ['Buszeit 3', 'Bushaltestelle 3']

splitted16 = pd.concat([splitted10, splitted11, splitted12, splitted13, splitted14, splitted15], axis=1)
splitted16.drop(['Bus 1','Bus 2','Bus 3'], axis=1, inplace=True)

df.drop(['Station 1','Station 2','Station 3'], axis=1, inplace=True)
df = pd.concat([df, splitted16], axis=1)

splitted17 = df['Station 1'].str.split('Wagen', expand=True)
splitted17.columns = ['Station 1', 'Auto 1']
splitted18 = df['Station 2'].str.split('Wagen', expand=True)
splitted18.columns = ['Station 2', 'Auto 2']
splitted19 = df['Station 3'].str.split('Wagen', expand=True)
splitted19.columns = ['Station 3', 'Auto 3']

splitted20 = splitted17['Auto 1'].str.split('Protokoll', expand=True)
splitted20.columns = ['Autozeit 1', 'Fahrzeugentfernung 1']
splitted21 = splitted18['Auto 2'].str.split('Protokoll', expand=True)
splitted21.columns = ['Autozeit 2', 'Fahrzeugentfernung 2']
splitted22 = splitted19['Auto 3'].str.split('Protokoll', expand=True)
splitted22.columns = ['Autozeit 3', 'Fahrzeugentfernung 3']

splitted23 = pd.concat([splitted17, splitted18, splitted19, splitted20, splitted21, splitted22], axis=1)
splitted23.drop(['Auto 1','Auto 2','Auto 3'], axis=1, inplace=True)

df.drop(['Station 1','Station 2','Station 3'], axis=1, inplace=True)
df = pd.concat([df, splitted23], axis=1)

df['Fahrzeugentfernung 1'] = df['Fahrzeugentfernung 1'].str.replace(u'\(', u'')
df['Fahrzeugentfernung 1'] = df['Fahrzeugentfernung 1'].str.replace(u'km\)', u'')
df['Fahrzeugentfernung 2'] = df['Fahrzeugentfernung 2'].str.replace(u'\(', u'')
df['Fahrzeugentfernung 2'] = df['Fahrzeugentfernung 2'].str.replace(u'km\)', u'')
df['Fahrzeugentfernung 3'] = df['Fahrzeugentfernung 3'].str.replace(u'\(', u'')
df['Fahrzeugentfernung 3'] = df['Fahrzeugentfernung 3'].str.replace(u'km\)', u'')

df[['Route 1','Route 2','Route 3', 'Station 1', 'Station 2','Station 3','Kommunal', 'Bushaltestelle 1', 'Bushaltestelle 2', 'Bushaltestelle 3']] = df[['Route 1','Route 2','Route 3', 'Station 1', 'Station 2','Station 3','Kommunal', 'Bushaltestelle 1', 'Bushaltestelle 2', 'Bushaltestelle 3']].fillna("NAN")
df[['Buszeit 1','Buszeit 2','Buszeit 3',]] = df[['Buszeit 1','Buszeit 2','Buszeit 3']].fillna(0)#Wenn ein Wert fehlt, tritt bei der Berechnung des Merkmalsbetrags ein Fehler auf. Ersetzen Sie ihn daher durch 0.
df['Buszeit 1'] = df['Buszeit 1'].astype(float)
df['Buszeit 2'] = df['Buszeit 2'].astype(float)
df['Buszeit 3'] = df['Buszeit 3'].astype(float)

oe = preprocessing.OrdinalEncoder()
df[['Gebäudetyp', 'Route 1','Route 2','Route 3', 'Station 1', 'Station 2','Station 3','Kommunal', 'Bushaltestelle 1', 'Bushaltestelle 2', 'Bushaltestelle 3']] = oe.fit_transform(df[['Gebäudetyp', 'Route 1','Route 2','Route 3', 'Station 1', 'Station 2','Station 3','Kommunal', 'Bushaltestelle 1', 'Bushaltestelle 2', 'Bushaltestelle 3']].values)

df['Miete+Verwaltungsgebühr'] = df['Miete'] + df['Verwaltungsgebühr']

df_for_search = df.copy()

#Legen Sie den Höchstpreis fest
df = df[df['Miete+Verwaltungsgebühr'] < 300000]

df = df[["Name der Wohnung",'Gebäudetyp', 'Miete+Verwaltungsgebühr', 'Alter', 'Gebäude höhe', '1. Stock',
       'Besetztes Gebiet','Route 1','Route 2','Route 3', 'Station 1', 'Station 2','Station 3','1 Spaziergang vom Bahnhof entfernt', '2 zu Fuß vom Bahnhof entfernt','3 zu Fuß vom Bahnhof entfernt','Gebäudeplan', 'GebäudeplanDK', 'GebäudeplanK', 'GebäudeplanL', 'GebäudeplanS',
       'Kommunal', 'Bushaltestelle 1', 'Bushaltestelle 2', 'Bushaltestelle 3', 'Buszeit 1','Buszeit 2','Buszeit 3']]

df.columns = ['name', 'building', 'real_rent','age', 'hight', 'level','area', 'route_1','route_2','route_3','station_1','station_2','station_3','station_wolk_1','station_wolk_2','station_wolk_3','room_number','DK','K','L','S','adress', 'bus_stop1', 'bus_stop2', 'bus_stop3', 'bus_time1', 'bus_time2', 'bus_time3']


#pdp.ProfileReport(df)
df.to_csv('otokuSearch/Preprocessing/Preprocessing.csv', sep = '\t', encoding='utf-16', header=True, index=False)
df_for_search.to_csv('otokuSearch/Preprocessing/df_for_search.csv', sep = '\t', encoding='utf-16', header=True, index=False)

Die Verarbeitung war hier recht schwierig. Die verbesserte Spalte enthält Stationsinformationen. Ursprünglich war es nur Stationsinformation und Entfernung von der Station. Zu den Bahnhofsinformationen gehörten jedoch weiterhin die Fahrzeit mit Bushaltestelle und Bus sowie die Zeit mit dem Auto zum nächsten Bahnhof.

So was ** Kawaguchi Station Bus 9 Minuten (Bushaltestelle) Motogo Junior High School 1 Minute zu Fuß ** Wenn diese Daten vorverarbeitet werden

Station 1	1 zu Fuß
Kawaguchi Station Bus 9 Minuten(Bushaltestelle)Motogo Junior High School	1

In der Spalte von Station 1 Kawaguchi Station Bus 9 Minuten (Bushaltestelle) Motogo Junior High School Zu Fuß 1 1 Minute) Es ist 1 Gehminute von der nächsten Station entfernt. Da die Businformationen im Stationsnamen enthalten sind, unterscheiden sich die Stationsinformationen von der Kawaguchi-Station, wenn sie später mit einem Label codiert werden. Also teile ich dies in ** Bushaltestelle **, ** Buszeit **, ** Autofahrzeit ** ein.

Außerdem sind der hinzugefügte Gebäudetyp und die Bushaltestelle beschriftungscodiert.

Feature-Erstellung

`Feature_value.py`


import pandas as pd
import numpy as np

df = pd.read_csv('otokuSearch/Preprocessing/Preprocessing.csv', sep='\t', encoding='utf-16')

df["per_area"] = df["area"]/df["room_number"]
df["hight_level"] = df["hight"]*df["level"]
df["area_hight_level"] = df["area"]*df["hight_level"]
df["distance_staion_1"] = df["station_1"]*df["station_wolk_1"]+df["bus_stop1"]*df["bus_time1"]
df["distance_staion_2"] = df["station_2"]*df["station_wolk_2"]+df["bus_stop2"]*df["bus_time2"]
df["distance_staion_3"] = df["station_3"]*df["station_wolk_3"]+df["bus_stop3"]*df["bus_time3"]

df.to_csv('otokuSearch/Featurevalue/Fettur_evalue.csv', sep = '\t', encoding='utf-16', header=True, index=False)

Mit den neu erstellten Busdaten haben wir einen neuen Merkmalsbetrag für die Entfernung zum Bahnhof erstellt.

Zuerst habe ich einen solchen Funktionsbetrag erstellt. df["per_real_rent"] = df["real_rent"]/df["area"] Bei genauerem Hinsehen habe ich es jedoch gelöscht, da es die Zielvariable (vorhergesagte Mietinformationen) enthielt. Später werde ich die Wichtigkeit jeder Funktion während des Lernens visualisieren. Zunächst freute ich mich, dass ich eine gute Anzahl von Funktionen erhalten konnte, da die Bedeutung hervorragend war. .. ..

Modelllernen

`model_lightgbm.py`


#Datenanalysebibliothek
import pandas as pd
import numpy as np

#Datenvisualisierungsbibliothek
import matplotlib.pyplot as plt
import seaborn as sns

#Zufällige Waldbibliothek
import lightgbm as lgb

#Eine Bibliothek, die Trainingsdaten und Modellbewertungsdaten für die Kreuzungsüberprüfung trennt
from sklearn.model_selection import KFold

#Für die Funktionsverarbeitung erforderliche Bibliothek
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score
#Zum Speichern des Modells erforderliche Bibliothek
import pickle

#Eine Funktion, die die vorhergesagten und korrekten Werte beschreibt
def True_Pred_map(pred_df):
    RMSE = np.sqrt(mean_squared_error(pred_df['true'], pred_df['pred']))
    R2 = r2_score(pred_df['true'], pred_df['pred'])
    plt.figure(figsize=(8,8))
    ax = plt.subplot(111)
    ax.scatter('true', 'pred', data=pred_df)
    ax.set_xlabel('True Value', fontsize=15)
    ax.set_ylabel('Pred Value', fontsize=15)
    ax.set_xlim(pred_df.min().min()-0.1 , pred_df.max().max()+0.1)
    ax.set_ylim(pred_df.min().min()-0.1 , pred_df.max().max()+0.1)
    x = np.linspace(pred_df.min().min()-0.1, pred_df.max().max()+0.1, 2)
    y = x
    ax.plot(x,y,'r-')
    plt.text(0.1, 0.9, 'RMSE = {}'.format(str(round(RMSE, 5))), transform=ax.transAxes, fontsize=15)
    plt.text(0.1, 0.8, 'R^2 = {}'.format(str(round(R2, 5))), transform=ax.transAxes, fontsize=15)


df = pd.read_csv('otokuSearch/Featurevalue/Fettur_evalue.csv', sep='\t', encoding='utf-16')

#kf :Ein Feld, das das Verhalten der Datenpartitionierung angibt. Dieses Mal gibt es 10 Abteilungen und Datenmischungen.
kf = KFold(n_splits=10, shuffle=True, random_state=1)

#predicted_df :Erleichtern Sie leere Datenrahmen, wenn Sie von nun an jeden vorhergesagten Wert kombinieren
predicted_df = pd.DataFrame({'index':0, 'pred':0}, index=[1])

#Die Parameter wurden nicht angepasst
lgbm_params = {
        'objective': 'regression',
        'metric': 'rmse',
        'num_leaves':80
}

#Kreuzungsüberprüfung Da die Schleife in 4 Teile unterteilt ist, wird sie 10 Mal wiederholt.
#Geben Sie kf einen Index und bitten Sie sie, den Trainingsdatenindex und den Bewertungsdatenindex zu bestimmen.
#df,Trainieren Sie die Indexnummer der Trainingsdaten und die Indexnummer der erstmals verwendeten Bewertungsdaten aus dem Index_index, val_Ausgabe in den Index
for train_index, val_index in kf.split(df.index):

    #Unterteilen Sie in Trainingsdaten und Bewertungsdaten sowie erklärende Variablen und objektive Variablen unter Verwendung des Trainingsdatenindex und des Bewertungsdatenindex
    X_train = df.drop(['real_rent','name'], axis=1).iloc[train_index]
    y_train = df['real_rent'].iloc[train_index]
    X_test = df.drop(['real_rent','name'], axis=1).iloc[val_index]
    y_test = df['real_rent'].iloc[val_index]

    #In einen Datensatz verarbeiten, um LightGBM zu beschleunigen
    lgb_train = lgb.Dataset(X_train, y_train)
    lgb_eval = lgb.Dataset(X_test, y_test)

    #LightGBM Modellbau
    gbm = lgb.train(lgbm_params,
                lgb_train,
                valid_sets=(lgb_train, lgb_eval),
                num_boost_round=10000,
                early_stopping_rounds=100,
                verbose_eval=50)

    #Fügen Sie die erklärenden Variablen zur Bewertung in das Modell ein und geben Sie den vorhergesagten Wert aus
    predicted = gbm.predict(X_test)

    #temp_df :Kombinieren Sie den vorhergesagten Wert mit dem ursprünglichen Index, um den vorhergesagten Wert mit dem richtigen Antwortwert abzugleichen
    temp_df = pd.DataFrame({'index':X_test.index, 'pred':predicted})

    #predicted_df :Temp in einem leeren Datenrahmen_Kombiniere df → In der Schleife nach der zweiten Runde, vorhergesagt_temp to df (Inhalt Ameise)_df beitreten
    predicted_df = pd.concat([predicted_df, temp_df], axis=0)

predicted_df = predicted_df.sort_values('index').reset_index(drop=True).drop(index=[0]).set_index('index')
predicted_df = pd.concat([predicted_df, df['real_rent']], axis=1).rename(columns={'real_rent' : 'true'})

True_Pred_map(predicted_df)

print(r2_score(y_test, predicted)  )
lgb.plot_importance(gbm, figsize=(12, 6))
plt.show()

#Modell speichern
with open('otokuSearch/model/model.pickle', mode='wb') as fp:
    pickle.dump(gbm, fp)

Wie im Originalartikel erwähnt, sind die Trainingsdaten und die Daten, die Sie vorhersagen möchten, nahezu identisch. Es befindet sich im "Dosen" -Zustand

Also habe ich eine Kreuzvalidierung implementiert. Ich habe den Code hier ausgeliehen. Es wird sehr leicht verständlich erklärt. https://rin-effort.com/2019/12/31/machine-learning-8/

Um die Gegenüberstellung kurz zu erklären

Teilen Sie die Trainingsdaten (diesmal 10)
Lernen mit einem von ihnen als Validierung und dem Rest als Trainingsdaten
Mit Validierungsdaten auswerten
Wiederholen Sie das Lernen → Auswerten, indem Sie die Validierungsdaten durch den geteilten Betrag ändern
Bewerten Sie das Modell, indem Sie diese Werte mitteln

Ich habe versucht, das später erstellte Modell zu speichern. Es ist jedes Mal mühsam zu lernen.

Bei der Ausführung auf die gleiche Weise wie der ursprüngliche Code werden eine vorhergesagte gültige Wertekarte und ein Diagramm wichtiger Merkmale ausgegeben. Es ist eine ziemliche Korrelation! Der neu erworbene Gebäudetyp hat nicht viel beigetragen.

Profitable Erstellung von Immobiliendaten

`Create_Otoku_data.py`


import pandas as pd
import numpy as np
import lightgbm as lgb
import pickle

#Daten lesen
df = pd.read_csv('otokuSearch/Featurevalue/Fettur_evalue.csv', sep='\t', encoding='utf-16')

#Geladenes trainiertes Modell laden
with open('otokuSearch/model/model.pickle', mode='rb') as fp:
    gbm = pickle.load(fp)


#Erstellung profitabler Immobiliendaten
y = df["real_rent"]
X = df.drop(['real_rent',"name"], axis=1)
pred = list(gbm.predict(X, num_iteration=gbm.best_iteration))
pred = pd.Series(pred, name="Voraussichtlicher Wert")
diff = pd.Series(df["real_rent"]-pred,name="Unterschied zum vorhergesagten Wert")
df_for_search = pd.read_csv('otokuSearch/Preprocessing/df_for_search.csv', sep='\t', encoding='utf-16')
df_for_search['Miete+Verwaltungsgebühr'] = df_for_search['Miete'] + df_for_search['Verwaltungsgebühr']
df_search = pd.concat([df_for_search,diff,pred], axis=1)
df_search = df_search.sort_values("Unterschied zum vorhergesagten Wert")
df_search = df_search[["Name der Wohnung",'Miete+Verwaltungsgebühr', 'Voraussichtlicher Wert',  'Voraussichtlicher Wertとの差', 'Detaillierte URL', 'Gebäudeplan', 'Besetztes Gebiet', 'Hierarchie', 'Station 1', '1 zu Fuß', 'GebäudeplanDK', 'GebäudeplanK', 'GebäudeplanL']]
df_search.to_csv('otokuSearch/Otoku_data/otoku.csv', sep = '\t',encoding='utf-16')

Keine wesentlichen Änderungen Wir haben gerade das Trainingsmodell gelesen und Spalten für die Ausgabedaten hinzugefügt.

Klicken Sie hier für den ersten Platz, der aus der Ausgabedatei hervorgeht! 2 Minuten zu Fuß vom Bahnhof entfernt! 3LDK! Damit ist die Miete von 82.000 Yen wunderbar! Die Route ist jedoch etwas lokal. .. ..

Ergebnis

Es ist jetzt möglich, angemessene Eigenschaftsdaten zu erstellen. Es gibt jedoch überhaupt keine EDA (Exploratory Data Analysis), sodass weitere Analysen erforderlich sind, um die Genauigkeit zu verbessern. Danach wäre es gut, die Daten zu erhöhen, die geschabt werden. Zum Beispiel gibt es verschiedene Arten wie Stadtgas und Klimaanlagen. Andere Dinge wie das Einstellen von Hyperparametern haben kein Ende. Nun, ich konnte tun, was ich wollte, also Yoshi!

Nachdem ich verschiedene Codes verwaltet hatte, verstand ich endlich die Notwendigkeit von Git. Es gibt verschiedene Ernten wie die Verwendung von Atom und das Erlernen der Verwendung von Git. Ich erkannte, dass Programmieren der beste Weg ist, um in der Praxis zu lernen.

von jetzt an

Ich möchte das diesmal mit Django erstellte Modell irgendwie in die Form eines Systems bringen. Wenn Sie die URL der Seite eingeben, wird anscheinend die Miete vorhergesagt und der Gewinn angegeben. Ich werde einen Artikel schreiben, wenn ich es versuchen kann.

[PYTHON] Ich war frustriert von Kaggle und versuchte, durch Schaben und maschinelles Lernen ein gutes Mietobjekt zu finden