PySpark Oktatóanyag kezdőknek: Tanuljon PÉLDÁK segítségével

Mielőtt megtanulná PySpark, értsük meg:

Mi az Apache Spark?

Spark egy big data megoldás, amelyről bebizonyosodott, hogy egyszerűbb és gyorsabb, mint a Hadoop MapReduce. Spark egy nyílt forráskódú szoftver, amelyet az UC Berkeley RAD labor fejlesztett ki 2009-ben. Amióta 2010-ben megjelent a nyilvánosság számára, Spark népszerűsége megnőtt, és soha nem látott mértékben használják az iparban.

A korszakban Big adatok, a szakembereknek minden eddiginél nagyobb szükségük van gyors és megbízható eszközökre az adatfolyam feldolgozásához. A korábbi eszközök, például a MapReduce kedvencek voltak, de lassúak voltak. A probléma megoldása érdekében Spark gyors és általános célú megoldást kínál. A fő különbség a között Spark és a MapReduce az Spark a merevlemezen a későbbiekben a memóriában futtatja a számításokat. Nagy sebességű hozzáférést és adatfeldolgozást tesz lehetővé, órákról percekre csökkentve az időt.

Mi az a PySpark?

PySpark az Apache által készített eszköz Spark Közösségi használatra Python ahol Spark. Lehetővé teszi az RDD (Resilient Distributed Dataset) használatát Python. Py-t is kínálSpark Shell a linkhez Python API-k a Spark magot kezdeményezni Spark Kontextus. Spark a fürtszámítás megvalósításának motorja, míg a PySpark is Pythonkönyvtárát használni Spark.

Hogyan működik Spark működik?

Spark számítási motoron alapul, vagyis gondoskodik az ütemező, elosztó és figyelő alkalmazásról. Az egyes feladatokat különféle munkagépeken hajtják végre, amelyeket számítási fürtnek neveznek. A számítási klaszter a feladatok megosztására utal. Az egyik gép egy feladatot hajt végre, míg a többi egy másik feladaton keresztül járul hozzá a végső kimenethez. A végén az összes feladatot összevonják, hogy eredményt kapjanak. A Spark az admin 360 fokos áttekintést ad a különféle Spark Állások.

Spark úgy tervezték, hogy működjön

• Python
• Java
• Scala
• SQL

Jelentős jellemzője Spark a hatalmas mennyiségű beépített könyvtár, beleértve az MLlib-et a gépi tanuláshoz. Spark Hadoop-fürtökkel való együttműködésre is tervezték, és képes olvasni a fájlok széles típusát, beleértve többek között a Hive-adatokat, a CSV-t, a JSON-t és a Casandra-adatokat.

Miért érdemes Spark?

Leendő adatkezelőként ismernie kell a python híres könyvtárait: a Pandákat és a scikit-learn-t. Ez a két könyvtár fantasztikusan alkalmas a közepes méretű adatkészletek felfedezésére. A rendszeres gépi tanulási projektek a következő módszertan köré épülnek:

• Töltse be az adatokat a lemezre
• Importálja az adatokat a gép memóriájába
• Az adatok feldolgozása/elemzése
• Építsd meg a gépi tanulási modellt
• Tárolja vissza a jóslatot a lemezre

A probléma akkor merül fel, ha az adattudós olyan adatokat akar feldolgozni, amelyek túl nagyok egy számítógéphez. Az adattudomány korábbi napjaiban a gyakorló szakemberek mintát vettek, mivel nem mindig volt szükség hatalmas adathalmazokra vonatkozó képzésre. Az adattudós talál egy jó statisztikai mintát, további robusztussági ellenőrzést végez, és kiváló modellt állít elő.

Ezzel azonban van néhány probléma:

• Az adatkészlet a való világot tükrözi?
• Tartalmaznak konkrét példát az adatok?
• Alkalmas-e a modell mintavételre?

Vegyük például a felhasználók ajánlásait. Az ajánlók a felhasználók és más felhasználók összehasonlítására támaszkodnak preferenciáik értékelése során. Ha az adatkezelő az adatoknak csak egy részhalmazát veszi át, akkor nem lesz olyan felhasználók csoportja, akik nagyon hasonlítanak egymáshoz. Az ajánlóknak a teljes adatkészleten vagy egyáltalán nem kell futniuk.

Mi a megoldás?

A megoldás már régóta nyilvánvaló, több számítógépre osztotta fel a problémát. A párhuzamos számítástechnika több problémával is jár. A fejlesztőknek gyakran nehézséget okoz a párhuzamos kód írása, és a végén meg kell oldaniuk a több feldolgozás körüli összetett problémát.

A Pyspark egy API-t ad az adattudósnak, amellyel megoldható a párhuzamos adatfeldolgozási problémák. A Pyspark kezeli a több feldolgozás bonyolultságát, például az adatok elosztását, a kód elosztását és a kimenetek összegyűjtését a dolgozóktól egy gépcsoporton.

Spark önállóan is futhat, de leggyakrabban egy fürt számítási keretrendszer, például a Hadoop tetején fut. A tesztelés és fejlesztés során azonban egy adattudós hatékonyan futhat Spark fejlesztődobozaikon vagy fürt nélküli laptopjaikon

• Az egyik fő előnye Spark olyan architektúra felépítése, amely magában foglalja az adatfolyam-kezelést, a zökkenőmentes adatlekérdezéseket, a gépi tanulás előrejelzését és a különféle elemzésekhez való valós idejű hozzáférést.

• Spark szorosan együttműködik az SQL nyelvvel, azaz a strukturált adatokkal. Lehetővé teszi az adatok valós idejű lekérdezését.

• Az adatkutató fő feladata prediktív modellek elemzése és felépítése. Röviden: egy adattudósnak tudnia kell, hogyan kérdezzen le adatokat a használatával SQL, készítsen statisztikai jelentést, és használja a gépi tanulást az előrejelzések előállításához. Az adattudósok idejük jelentős részét az adatok tisztításával, átalakításával és elemzésével töltik. Amint az adatkészlet vagy adatmunkafolyamat elkészült, az adattudós különféle technikákat használ a betekintések és rejtett minták felfedezésére. Az adatkezelésnek robusztusnak és ugyanolyan könnyen használhatónak kell lennie. Spark sebességének és gazdag API-jainak köszönhetően a megfelelő eszköz.

Ebben a PySpark oktatóanyagból megtudhatja, hogyan kell Py-vel osztályozót készíteniSpark példák.

Hogyan telepítsük a PySpark AWS-sel

A Jupyter csapat létrehoz egy Docker-képet a futtatáshoz Spark hatékonyan. Az alábbiakban bemutatjuk a Py telepítésének lépéseitSpark példa az AWS-ben.

Tekintse meg oktatóanyagunkat AWS és a TensorFlow

1. lépés: Hozzon létre egy példányt

Először is létre kell hoznia egy példányt. Nyissa meg AWS-fiókját, és indítsa el a példányt. A tárhelyet 15 g-ra növelheti, és ugyanazt a biztonsági csoportot használhatja, mint a TensorFlow oktatóanyagában.

2. lépés: Nyissa meg a kapcsolatot

Nyissa meg a kapcsolatot, és telepítse a dokkolótartályt. További részletekért tekintse meg a TensorFlow with oktatóanyagát Dokkmunkás. Vegye figyelembe, hogy a megfelelő munkakönyvtárban kell lennie.

Egyszerűen futtassa ezeket a kódokat a Docker telepítéséhez:

sudo yum update -y
sudo yum install -y docker
sudo service docker start
sudo user-mod -a -G docker ec2-user
exit

3. lépés: Nyissa meg újra a kapcsolatot és telepítse Spark

A kapcsolat újbóli megnyitása után telepítheti a Py-t tartalmazó lemezképetSpark.

## Spark
docker run -v ~/work:/home/jovyan/work -d -p 8888:8888 jupyter/pyspark-notebook

## Allow preserving Jupyter notebook
sudo chown 1000 ~/work

## Install tree to see our working directory next
sudo yum install -y tree

4 lépés: Nyitott Jupyter

Ellenőrizze a tartályt és a nevét

docker ps

Indítsa el a dokkolót a dokkolónaplókkal, majd írja be a dokkoló nevét. Például a docker naplózza a zealous_goldwasser értéket

Nyissa meg a böngészőt, és indítsa el Jupyter. A cím: http://localhost:8888/. Illessze be a terminál által megadott jelszót.

Megjegyzések: ha fájlt szeretne feltölteni/letölteni AWS gépére, használhatja a Cyberduck szoftvert, https://cyberduck.io/.

Hogyan telepítsük a PySpark on Windows/Mac Condával

Az alábbiakban bemutatjuk a Py telepítésének részletes folyamatátSpark on Windows/Mac Anaconda használatával:

A telepítéshez Spark a helyi gépen ajánlott gyakorlat egy új conda környezet létrehozása. Ez az új környezet telepítésre kerül Python 3.6, Spark és az összes függőséget.

Mac felhasználó

cd anaconda3
touch hello-spark.yml
vi hello-spark.yml

Windows használó

cd C:\Users\Admin\Anaconda3
echo.>hello-spark.yml
notepad hello-spark.yml

Az .yml fájlt szerkesztheti. Legyen óvatos a behúzással. Előtte két szóköz szükséges –

name: hello-spark 
    dependencies:
    
    - python=3.6
    - jupyter
    - ipython
    - numpy
    - numpy-base
    - pandas
    - py4j
    - pyspark
    - pytz

Mentse el és teremtse meg a környezetet. Kell egy kis idő

conda env create -f hello-spark.yml

A hellyel kapcsolatos további részletekért tekintse meg a TensorFlow telepítése című oktatóanyagot

Ellenőrizheti a gépére telepített összes környezetet

conda env list

Activate hello-spark

Mac felhasználó

source activate hello-spark

Windows használó

activate hello-spark

Jegyzet: Már létrehozott egy adott TensorFlow-környezetet az oktatóanyagok TensorFlow-on való futtatásához. Kényelmesebb a hello-tf-től eltérő új környezetet létrehozni. Nincs értelme a hello-tf-vel túlterhelni Spark vagy bármely más gépi tanulási könyvtár.

Képzelje el, hogy projektje nagy része a TensorFlow-t tartalmazza, de használnia kell Spark egy adott projekthez. Beállíthat egy TensorFlow környezetet az összes projekthez, és külön környezetet hozhat létre Spark. Annyi könyvtárat adhat hozzá Spark tetszőleges környezetbe a TensorFlow környezetbe való beavatkozás nélkül. Miután végzett a Spark's projektet, törölheti a TensorFlow környezet befolyásolása nélkül.

Jupyter

Nyisd ki Jupyter Notebook és próbálja ki, ha PySpark művek. Egy új jegyzetfüzetbe illessze be a következő PySpark minta kód:

import pyspark
from pyspark import SparkContext
sc =SparkContext()

Ha hiba jelenik meg, akkor valószínű Java nincs telepítve a gépére. Mac-en nyisd meg a terminált és írd be a java -verziót, ha van java verzió, akkor győződj meg róla, hogy 1.8-as. In Windows, lépjen az Alkalmazásba, és ellenőrizze, hogy van-e a Java mappát. Ha van a Java mappát, ellenőrizze Java 1.8 telepítve van. Az írás pillanatában PySpark nem kompatibilis a Java9 és újabb.

Ha telepítenie kell Java, gondold át link és töltse le a jdk-8u181-windows-x64.exe fájlt

Mac felhasználók számára a `brew.` használata javasolt

brew tap caskroom/versions
brew cask install java8

Tekintse meg ezt a lépésről lépésre szóló oktatóanyagot hogyan kell telepíteni Java

Megjegyzések: Az eltávolítás használatával teljesen törölheti a környezetet.

 conda env remove -n hello-spark -y

Spark Kontextus

SparkA kontextus a belső motor, amely lehetővé teszi a kapcsolatokat a fürtökkel. Ha műveletet szeretne végrehajtani, szüksége van a SparkKontextus.

Hozzon létre egy SparkKontextus

Először is kezdeményeznie kell a SparkKontextus.

import pyspark
from pyspark import SparkContext
sc =SparkContext()

Most, hogy a SparkA kontextus készen áll, létrehozhat egy adatgyűjteményt RDD, Resilient Distributed Dataset néven. Az RDD-ben végzett számítások automatikusan párhuzamosításra kerülnek a fürtben.

nums= sc.parallelize([1,2,3,4])

Az első sort a take gombbal érheti el

nums.take(1)

[1]

Transzformációt alkalmazhatunk az adatokra lambda függvénnyel. A PySpark Az alábbi példában a számok négyzetét adja vissza. Ez egy térképátalakítás

squared = nums.map(lambda x: x*x).collect()
for num in squared:
    print('%i ' % (num))

1 
4 
9 
16

SQLContext

Egy kényelmesebb módja a DataFrame használata. SparkA kontextus már be van állítva, felhasználhatja a dataFrame létrehozásához. Az SQLContextet is deklarálnia kell

Az SQLContext lehetővé teszi a motor összekapcsolását különböző adatforrásokkal. A funkcióinak elindítására szolgál Spark sql.

from pyspark.sql import Row
from pyspark.sql import SQLContext

sqlContext = SQLContext(sc)

Most ebben Spark oktatói Python, hozzuk létre a tuple listáját. Minden sor tartalmazza az emberek nevét és életkorát. Négy lépés szükséges:

Step 1) Hozza létre a tuple listáját az információkkal

[('John',19),('Smith',29),('Adam',35),('Henry',50)]

Step 2) Építs egy RDD-t

rdd = sc.parallelize(list_p)

Step 3) Konvertálja a sorokat

rdd.map(lambda x: Row(name=x[0], age=int(x[1])))

Step 4) Hozzon létre egy DataFrame környezetet

sqlContext.createDataFrame(ppl)
list_p = [('John',19),('Smith',29),('Adam',35),('Henry',50)]
rdd = sc.parallelize(list_p)
ppl = rdd.map(lambda x: Row(name=x[0], age=int(x[1])))
DF_ppl = sqlContext.createDataFrame(ppl)

Ha szeretné elérni az egyes funkciók típusát, használja a printSchema()

DF_ppl.printSchema()
root
 |-- age: long (nullable = true)
 |-- name: string (nullable = true)

Gépi tanulási példa Py-velSpark

Most, hogy van egy rövid ötleted Spark és az SQLContext, készen áll az első gépi tanulási program elkészítésére.

Az alábbiakban bemutatjuk a gépi tanulási program Py-vel való felépítésének lépéseitSpark:

• Step 1) Alapvető művelet Py-velSpark
• Step 2) Adatok előfeldolgozása
• Step 3) Készítsen adatfeldolgozási folyamatot
• Step 4) Építse fel az osztályozót: logisztika
• Step 5) A modell képzése és értékelése
• Step 6) Hangolja be a hiperparamétert

Ebben a PySpark Gépi tanulási oktatóanyag, a felnőtt adatkészletet fogjuk használni. Ennek az oktatóanyagnak a célja a Pyspark használatának megtanulása. Az adatkészletről további információkért tekintse meg ezt az oktatóanyagot.

Vegye figyelembe, hogy az adatkészlet nem jelentős, és azt gondolhatja, hogy a számítás hosszú időt vesz igénybe. Spark jelentős mennyiségű adat feldolgozására tervezték. Sparka teljesítménye nő a többi gépi tanulási könyvtárhoz képest, ha a feldolgozott adatkészlet nagyobb.

1. lépés) Alapművelet Py-velSpark

Először is inicializálnia kell, hogy az SQLContext még nincs elindítva.

#from pyspark.sql import SQLContext
url = "https://raw.githubusercontent.com/guru99-edu/R-Programming/master/adult_data.csv"
from pyspark import SparkFiles
sc.addFile(url)
sqlContext = SQLContext(sc)

majd elolvashatja a cvs fájlt az sqlContext.read.csv paranccsal. Az inferSchema True értékre van állítva Spark hogy automatikusan kitalálja az adattípust. Alapértelmezés szerint hamisra vált.

df = sqlContext.read.csv(SparkFiles.get("adult_data.csv"), header=True, inferSchema= True)

Nézzük meg az adattípust

df.printSchema()
root
 |-- age: integer (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: integer (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: integer (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: integer (nullable = true)
 |-- capital_loss: integer (nullable = true)
 |-- hours_week: integer (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)

Az adatokat a show segítségével láthatja.

df.show(5, truncate = False)

+---+----------------+------+---------+-------------+------------------+-----------------+-------------+-----+------+------------+------------+----------+--------------+-----+
|age|workclass       |fnlwgt|education|education_num|marital           |occupation       |relationship |race |sex   |capital_gain|capital_loss|hours_week|native_country|label|
+---+----------------+------+---------+-------------+------------------+-----------------+-------------+-----+------+------------+------------+----------+--------------+-----+
|39 |State-gov       |77516 |Bachelors|13           |Never-married     |Adm-clerical     |Not-in-family|White|Male  |2174        |0           |40        |United-States |<=50K|
|50 |Self-emp-not-inc|83311 |Bachelors|13           |Married-civ-spouse|Exec-managerial  |Husband      |White|Male  |0           |0           |13        |United-States |<=50K|
|38 |Private         |215646|HS-grad  |9            |Divorced          |Handlers-cleaners|Not-in-family|White|Male  |0           |0           |40        |United-States |<=50K|
|53 |Private         |234721|11th     |7            |Married-civ-spouse|Handlers-cleaners|Husband      |Black|Male  |0           |0           |40        |United-States |<=50K|
|28 |Private         |338409|Bachelors|13           |Married-civ-spouse|Prof-specialty   |Wife         |Black|Female|0           |0           |40        |Cuba          |<=50K|
+---+----------------+------+---------+-------------+------------------+-----------------+-------------+-----+------+------------+------------+----------+--------------+-----+
only showing top 5 rows

Ha nem állította be az inderShema értéket True értékre, akkor ez történik a típussal. Mind benne van a szövegben.

df_string = sqlContext.read.csv(SparkFiles.get("adult.csv"), header=True, inferSchema=  False)
df_string.printSchema()
root
 |-- age: string (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: string (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: string (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: string (nullable = true)
 |-- capital_loss: string (nullable = true)
 |-- hours_week: string (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)

A folytonos változó megfelelő formátumba konvertálásához használhatja az oszlopok újraírását. A withColumn segítségével elmondhatja Spark melyik oszlopban kell működtetni a transzformációt.

# Import all from `sql.types`
from pyspark.sql.types import *

# Write a custom function to convert the data type of DataFrame columns
def convertColumn(df, names, newType):
    for name in names: 
        df = df.withColumn(name, df[name].cast(newType))
    return df 
# List of continuous features
CONTI_FEATURES  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
# Convert the type
df_string = convertColumn(df_string, CONTI_FEATURES, FloatType())
# Check the dataset
df_string.printSchema()
root
 |-- age: float (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: float (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: float (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: float (nullable = true)
 |-- capital_loss: float (nullable = true)
 |-- hours_week: float (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)

from pyspark.ml.feature import StringIndexer
#stringIndexer = StringIndexer(inputCol="label", outputCol="newlabel")
#model = stringIndexer.fit(df)
#df = model.transform(df)
df.printSchema()

Válasszon oszlopokat

Kijelölheti és megjelenítheti a sorokat a kijelöléssel és a szolgáltatások neveivel. Az alábbiakban az életkor és az fnlwgt van kiválasztva.

df.select('age','fnlwgt').show(5)

+---+------+
|age|fnlwgt|
+---+------+
| 39| 77516|
| 50| 83311|
| 38|215646|
| 53|234721|
| 28|338409|
+---+------+
only showing top 5 rows

Számoljon csoportonként

Ha csoportonként szeretné megszámolni az előfordulások számát, láncolhatja:

• csoportosít()
• számol ()

együtt. A PySpark Az alábbi példában az iskolai végzettség szerint számolja meg a sorok számát.

df.groupBy("education").count().sort("count",ascending=True).show()

+------------+-----+
|   education|count|
+------------+-----+
|   Preschool|   51|
|     1st-4th|  168|
|     5th-6th|  333|
|   Doctorate|  413|
|        12th|  433|
|         9th|  514|
| Prof-school|  576|
|     7th-8th|  646|
|        10th|  933|
|  Assoc-acdm| 1067|
|        11th| 1175|
|   Assoc-voc| 1382|
|     Masters| 1723|
|   Bachelors| 5355|
|Some-college| 7291|
|     HS-grad|10501|
+------------+-----+

Ismertesse az adatokat

Az adatok összefoglaló statisztikájának megtekintéséhez használja a description()-et. Kiszámítja a következőket:

• számít
• jelent
• szórás
• perc
• max

df.describe().show()

+-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+
|summary|               age|  workclass|            fnlwgt|   education|    education_num| marital|      occupation|relationship|              race|   sex|      capital_gain|    capital_loss|        hours_week|native_country|label|
+-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+
|  count|             32561|      32561|             32561|       32561|            32561|   32561|           32561|       32561|             32561| 32561|             32561|           32561|             32561|         32561|32561|
|   mean| 38.58164675532078|       null|189778.36651208502|        null| 10.0806793403151|    null|            null|        null|              null|  null|1077.6488437087312| 87.303829734959|40.437455852092995|          null| null|
| stddev|13.640432553581356|       null|105549.97769702227|        null|2.572720332067397|    null|            null|        null|              null|  null| 7385.292084840354|402.960218649002|12.347428681731838|          null| null|
|    min|                17|          ?|             12285|        10th|                1|Divorced|               ?|     Husband|Amer-Indian-Eskimo|Female|                 0|               0|                 1|             ?|<=50K|
|    max|                90|Without-pay|           1484705|Some-college|               16| Widowed|Transport-moving|        Wife|             White|  Male|             99999|            4356|                99|    Yugoslavia| >50K|
+-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+

Ha csak egy oszlop összefoglaló statisztikáját szeretné, adja hozzá az oszlop nevét a description()-hez

df.describe('capital_gain').show()

+-------+------------------+
|summary|      capital_gain|
+-------+------------------+
|  count|             32561|
|   mean|1077.6488437087312|
| stddev| 7385.292084840354|
|    min|                 0|
|    max|             99999|
+-------+------------------+

Kereszttábla számítás

Egyes esetekben érdekes lehet látni a leíró statisztikákat két páronkénti oszlop között. Például megszámolhatja az 50 ezer alatti vagy feletti jövedelemmel rendelkező emberek számát iskolai végzettség szerint. Ezt a műveletet kereszttáblának nevezik.

df.crosstab('age', 'label').sort("age_label").show()

+---------+-----+----+
|age_label|<=50K|>50K|
+---------+-----+----+
|       17|  395|   0|
|       18|  550|   0|
|       19|  710|   2|
|       20|  753|   0|
|       21|  717|   3|
|       22|  752|  13|
|       23|  865|  12|
|       24|  767|  31|
|       25|  788|  53|
|       26|  722|  63|
|       27|  754|  81|
|       28|  748| 119|
|       29|  679| 134|
|       30|  690| 171|
|       31|  705| 183|
|       32|  639| 189|
|       33|  684| 191|
|       34|  643| 243|
|       35|  659| 217|
|       36|  635| 263|
+---------+-----+----+
only showing top 20 rows

Látható, hogy fiatalon senkinek nincs 50 XNUMX feletti bevétele.

Dobja el az oszlopot

Két intuitív API van az oszlopok eldobásához:

• drop(): Oszlop eldobása
• dropna(): Drop NA's

Lent dobja az oktatási_szám oszlopot

df.drop('education_num').columns

['age',
 'workclass',
 'fnlwgt',
 'education',
 'marital',
 'occupation',
 'relationship',
 'race',
 'sex',
 'capital_gain',
 'capital_loss',
 'hours_week',
 'native_country',
 'label']

Adatok szűrése

A filter() segítségével leíró statisztikákat alkalmazhat az adatok egy részében. Például megszámolhatja a 40 év felettiek számát

df.filter(df.age > 40).count()

13443

Descriptive statisztika csoportonként

Végül az adatokat csoportonként csoportosíthatja, és statisztikai műveleteket számíthat ki, például az átlagot.

df.groupby('marital').agg({'capital_gain': 'mean'}).show()

+--------------------+------------------+
|             marital| avg(capital_gain)|
+--------------------+------------------+
|           Separated| 535.5687804878049|
|       Never-married|376.58831788823363|
|Married-spouse-ab...| 653.9832535885167|
|            Divorced| 728.4148098131893|
|             Widowed| 571.0715005035247|
|   Married-AF-spouse| 432.6521739130435|
|  Married-civ-spouse|1764.8595085470085|
+--------------------+------------------+

2. lépés) Adatok előfeldolgozása

Az adatfeldolgozás kritikus lépés a gépi tanulásban. A hulladékadatok eltávolítása után néhány fontos betekintést nyerhet.

Például tudja, hogy az életkor nem lineáris függvénye a jövedelemnek. Amikor az emberek fiatalok, jövedelmük általában alacsonyabb, mint a középkorú. Nyugdíjba vonulás után egy háztartás felhasználja a megtakarítását, vagyis a jövedelem csökkenését. Ennek a mintának a rögzítéséhez adjon hozzá egy négyzetet az életkor funkcióhoz

Adja hozzá az életkor négyzetét

Új funkció hozzáadásához a következőket kell tennie:

1. Válassza ki az oszlopot
2. Alkalmazza az átalakítást, és adja hozzá a DataFrame-hez

from pyspark.sql.functions import *

# 1 Select the column
age_square = df.select(col("age")**2)

# 2 Apply the transformation and add it to the DataFrame
df = df.withColumn("age_square", col("age")**2)

df.printSchema()
root
 |-- age: integer (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: integer (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: integer (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: integer (nullable = true)
 |-- capital_loss: integer (nullable = true)
 |-- hours_week: integer (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)
 |-- age_square: double (nullable = true)

Látható, hogy az age_square sikeresen hozzáadva az adatkerethez. A változók sorrendjét a select gombbal módosíthatja. Az alábbiakban az életkor négyzetét közvetlenül az életkor után hozza.

COLUMNS = ['age', 'age_square', 'workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country', 'label']
df = df.select(COLUMNS)
df.first()

Row(age=39, age_square=1521.0, workclass='State-gov', fnlwgt=77516, education='Bachelors', education_num=13, marital='Never-married', occupation='Adm-clerical', relationship='Not-in-family', race='White', sex='Male', capital_gain=2174, capital_loss=0, hours_week=40, native_country='United-States', label='<=50K')

Hollandia-Hollandia kizárása

Ha egy jellemzőn belül egy csoportnak csak egy megfigyelése van, az nem ad információt a modellnek. Éppen ellenkezőleg, ez hibához vezethet a keresztellenőrzés során.

Vizsgáljuk meg a háztartás eredetét

df.filter(df.native_country == 'Holand-Netherlands').count()
df.groupby('native_country').agg({'native_country': 'count'}).sort(asc("count(native_country)")).show()

+--------------------+---------------------+
|      native_country|count(native_country)|
+--------------------+---------------------+
|  Holand-Netherlands|                    1|
|            Scotland|                   12|
|             Hungary|                   13|
|            Honduras|                   13|
|Outlying-US(Guam-...|                   14|
|          Yugoslavia|                   16|
|            Thailand|                   18|
|                Laos|                   18|
|            Cambodia|                   19|
|     Trinadad&Tobago|                   19|
|                Hong|                   20|
|             Ireland|                   24|
|             Ecuador|                   28|
|              Greece|                   29|
|              France|                   29|
|                Peru|                   31|
|           Nicaragua|                   34|
|            Portugal|                   37|
|                Iran|                   43|
|               Haiti|                   44|
+--------------------+---------------------+
only showing top 20 rows

A native_country funkciónak csak egy háztartása van Hollandiából. Kizárod.

df_remove = df.filter(df.native_country !=	'Holand-Netherlands')

3. lépés) Készítsen adatfeldolgozási folyamatot

A scikit-learn-hez hasonlóan a Pyspark is rendelkezik egy pipeline API-val.

A csővezeték nagyon kényelmes az adatok szerkezetének fenntartásához. Benyomja az adatokat a folyamatba. A csővezetéken belül különféle műveleteket végeznek, a kimenetet az algoritmus betáplálására használják.

Például egy univerzális transzformáció a gépi tanulásban abból áll, hogy egy karakterláncot egy hot encoderré alakítanak át, azaz csoportonként egy oszlopot. Az egyik forró kódoló általában egy nullákkal teli mátrix.

Az adatok átalakításának lépései nagyon hasonlóak a scikit-learn-hez. Neked kell:

• Indexelje a karakterláncot numerikusra
• Hozd létre az egyetlen forró kódolót
• Alakítsa át az adatokat

Két API végzi a feladatot: StringIndexer, OneHotEncoder

1. Először is válassza ki az indexelni kívánt karakterlánc oszlopot. Az inputCol az adatkészlet oszlopának neve. outputCol az átalakított oszlop új neve.

StringIndexer(inputCol="workclass", outputCol="workclass_encoded")

2. Illessze az adatokat és alakítsa át

model = stringIndexer.fit(df)		
`indexed = model.transform(df)``

3. Híroszlopok létrehozása a csoport alapján. Például, ha a szolgáltatásban 10 csoport van, az új mátrixban 10 oszlop lesz, mindegyik csoporthoz egy.

OneHotEncoder(dropLast=False, inputCol="workclassencoded", outputCol="workclassvec")

### Example encoder
from pyspark.ml.feature import StringIndexer, OneHotEncoder, VectorAssembler

stringIndexer = StringIndexer(inputCol="workclass", outputCol="workclass_encoded")
model = stringIndexer.fit(df)
indexed = model.transform(df)
encoder = OneHotEncoder(dropLast=False, inputCol="workclass_encoded", outputCol="workclass_vec")
encoded = encoder.transform(indexed)
encoded.show(2)

+---+----------+----------------+------+---------+-------------+------------------+---------------+-------------+-----+----+------------+------------+----------+--------------+-----+-----------------+-------------+
|age|age_square|       workclass|fnlwgt|education|education_num|           marital|     occupation| relationship| race| sex|capital_gain|capital_loss|hours_week|native_country|label|workclass_encoded|workclass_vec|
+---+----------+----------------+------+---------+-------------+------------------+---------------+-------------+-----+----+------------+------------+----------+--------------+-----+-----------------+-------------+
| 39|    1521.0|       State-gov| 77516|Bachelors|           13|     Never-married|   Adm-clerical|Not-in-family|White|Male|        2174|           0|        40| United-States|<=50K|              4.0|(9,[4],[1.0])|
| 50|    2500.0|Self-emp-not-inc| 83311|Bachelors|           13|Married-civ-spouse|Exec-managerial|      Husband|White|Male|           0|           0|        13| United-States|<=50K|              1.0|(9,[1],[1.0])|
+---+----------+----------------+------+---------+-------------+------------------+---------------+-------------+-----+----+------------+------------+----------+--------------+-----+-----------------+-------------+
only showing top 2 rows

Építsd meg a csővezetéket

Fel kell építeni egy folyamatot az összes precíz szolgáltatás konvertálásához és hozzáadásához a végső adatkészlethez. A folyamat négy műveletből áll majd, de nyugodtan adjon hozzá annyi műveletet, amennyit csak szeretne.

1. Kódolja a kategorikus adatokat
2. Indexelje a címke funkciót
3. Folyamatos változó hozzáadása
4. Szerelje össze a lépéseket.

Minden lépés egy szakaszok nevű listában van tárolva. Ez a lista megmondja a VectorAssemblernek, hogy milyen műveletet kell végrehajtania a folyamatban.

1. Kódolja a kategorikus adatokat

Ez a lépés pontosan megegyezik a fenti példával, azzal a különbséggel, hogy az összes kategorikus jellemzőt át kell ismételni.

from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoderEstimator
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']
stages = [] # stages in our Pipeline
for categoricalCol in CATE_FEATURES:
    stringIndexer = StringIndexer(inputCol=categoricalCol, outputCol=categoricalCol + "Index")
    encoder = OneHotEncoderEstimator(inputCols=[stringIndexer.getOutputCol()],
                                     outputCols=[categoricalCol + "classVec"])
    stages += [stringIndexer, encoder]

2. Indexelje a címke funkciót

Spark, mint sok más könyvtár, nem fogad el karakterlánc-értékeket a címkéhez. A címkefunkciót a StringIndexerrel konvertálja, és hozzáadja a lista szakaszaihoz

# Convert label into label indices using the StringIndexer
label_stringIdx =  StringIndexer(inputCol="label", outputCol="newlabel")
stages += [label_stringIdx]

3. Folyamatos változó hozzáadása

A VectorAssembler inputCols oszlopa oszlopok listája. Létrehozhat egy új listát, amely az összes új oszlopot tartalmazza. Az alábbi kód kódolt kategorikus jellemzőkkel és folyamatos jellemzőkkel tölti fel a listát.

assemblerInputs = [c + "classVec" for c in CATE_FEATURES] + CONTI_FEATURES

4. Szerelje össze a lépéseket.

Végül a VectorAssembler összes lépését teljesíti

assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="features")stages += [assembler]

Most, hogy az összes lépés készen áll, továbbítsa az adatokat a folyamathoz.

# Create a Pipeline.
pipeline = Pipeline(stages=stages)
pipelineModel = pipeline.fit(df_remove)
model = pipelineModel.transform(df_remove)

Ha megnézi az új adatkészletet, láthatja, hogy az összes szolgáltatást tartalmazza, átalakítva és nem átalakítva. Csak az új címke és a funkciók érdeklik. A jellemzők az összes átalakított jellemzőt és a folytonos változókat tartalmazzák.

model.take(1)

[Row(age=39, age_square=1521.0, workclass='State-gov', fnlwgt=77516, education='Bachelors', education_num=13, marital='Never-married', occupation='Adm-clerical', relationship='Not-in-family', race='White', sex='Male', capital_gain=2174, capital_loss=0, hours_week=40, native_country='United-States', label='<=50K', workclassIndex=4.0, workclassclassVec=SparseVector(8, {4: 1.0}), educationIndex=2.0, educationclassVec=SparseVector(15, {2: 1.0}), maritalIndex=1.0, maritalclassVec=SparseVector(6, {1: 1.0}), occupationIndex=3.0, occupationclassVec=SparseVector(14, {3: 1.0}), relationshipIndex=1.0, relationshipclassVec=SparseVector(5, {1: 1.0}), raceIndex=0.0, raceclassVec=SparseVector(4, {0: 1.0}), sexIndex=0.0, sexclassVec=SparseVector(1, {0: 1.0}), native_countryIndex=0.0, native_countryclassVec=SparseVector(40, {0: 1.0}), newlabel=0.0, features=SparseVector(99, {4: 1.0, 10: 1.0, 24: 1.0, 32: 1.0, 44: 1.0, 48: 1.0, 52: 1.0, 53: 1.0, 93: 39.0, 94: 77516.0, 95: 2174.0, 96: 13.0, 98: 40.0}))]

4. lépés) Építse fel az osztályozót: logisztika

A számítás gyorsabbá tétele érdekében konvertálja a modellt DataFrame-re.

Új címkét és jellemzőket kell kiválasztania a modellből a térkép segítségével.

from pyspark.ml.linalg import DenseVector
input_data = model.rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"])))

Készen áll a vonatadatok DataFrame-ként történő létrehozására. Az sqlContextet használod

df_train = sqlContext.createDataFrame(input_data, ["label", "features"])

Ellenőrizze a második sort

df_train.show(2)

+-----+--------------------+
|label|            features|
+-----+--------------------+
|  0.0|[0.0,0.0,0.0,0.0,...|
|  0.0|[0.0,1.0,0.0,0.0,...|
+-----+--------------------+
only showing top 2 rows

Hozzon létre egy vonat/tesztkészletet

Az adatkészletet 80/20 arányban osztja fel a randomSplit segítségével.

# Split the data into train and test sets
train_data, test_data = df_train.randomSplit([.8,.2],seed=1234)

Számoljuk meg, hány embernek van 50k alatti/feletti jövedelme mind a képzésben, mind a tesztben

train_data.groupby('label').agg({'label': 'count'}).show()

+-----+------------+
|label|count(label)|
+-----+------------+
|  0.0|       19698|
|  1.0|        6263|
+-----+------------+

test_data.groupby('label').agg({'label': 'count'}).show()

+-----+------------+
|label|count(label)|
+-----+------------+
|  0.0|        5021|
|  1.0|        1578|
+-----+------------+

Építsd fel a logisztikai regresszort

Végül, de nem utolsósorban elkészítheti az osztályozót. A Pyspark rendelkezik egy LogisticRegression nevű API-val a logisztikai regresszió végrehajtásához.

Az lr inicializálása a címkeoszlop és a szolgáltatásoszlopok megadásával történik. Maximum 10 iterációt állíthat be, és hozzáadhat egy 0.3 értékű szabályzási paramétert. Vegye figyelembe, hogy a következő részben keresztellenőrzést fog használni egy paraméterrács segítségével a modell hangolásához

# Import `LinearRegression`
from pyspark.ml.classification import LogisticRegression

# Initialize `lr`
lr = LogisticRegression(labelCol="label",
                        featuresCol="features",
                        maxIter=10,
                        regParam=0.3)

# Fit the data to the model
linearModel = lr.fit(train_data)

#A regresszióból láthatja az együtthatókat

# Print the coefficients and intercept for logistic regression
print("Coefficients: " + str(linearModel.coefficients))
print("Intercept: " + str(linearModel.intercept))

Coefficients: [-0.0678914665262,-0.153425526813,-0.0706009536407,-0.164057586562,-0.120655298528,0.162922330862,0.149176870438,-0.626836362611,-0.193483661541,-0.0782269980838,0.222667203836,0.399571096381,-0.0222024341804,-0.311925857859,-0.0434497788688,-0.306007744328,-0.41318209688,0.547937504247,-0.395837350854,-0.23166535958,0.618743906733,-0.344088614546,-0.385266881369,0.317324463006,-0.350518889186,-0.201335923138,-0.232878560088,-0.13349278865,-0.119760542498,0.17500602491,-0.0480968101118,0.288484253943,-0.116314616745,0.0524163478063,-0.300952624551,-0.22046421474,-0.16557996579,-0.114676231939,-0.311966431453,-0.344226119233,0.105530129507,0.152243047814,-0.292774545497,0.263628334433,-0.199951374076,-0.30329422583,-0.231087515178,0.418918551,-0.0565930184279,-0.177818073048,-0.0733236680663,-0.267972912252,0.168491215697,-0.12181255723,-0.385648075442,-0.202101794517,0.0469791640782,-0.00842850210625,-0.00373211448629,-0.259296141281,-0.309896554133,-0.168434409756,-0.11048086026,0.0280647963877,-0.204187030092,-0.414392623536,-0.252806580669,0.143366465705,-0.516359222663,-0.435627370849,-0.301949286524,0.0878249035894,-0.210951740965,-0.621417928742,-0.099445190784,-0.232671473401,-0.1077745606,-0.360429419703,-0.420362959052,-0.379729467809,-0.395186242741,0.0826401853838,-0.280251589972,0.187313505214,-0.20295228799,-0.431177064626,0.149759018379,-0.107114299614,-0.319314858424,0.0028450133235,-0.651220387649,-0.327918792207,-0.143659581445,0.00691075160413,8.38517628783e-08,2.18856717378e-05,0.0266701216268,0.000231075966823,0.00893832698698]
Intercept: -1.9884177974805692

5. lépés) Tanítsa meg és értékelje a modellt

Ha előrejelzést szeretne generálni a tesztkészlethez,

Használhatja a linearModel-t a transform() paraméterrel a test_data-ban

# Make predictions on test data using the transform() method.
predictions = linearModel.transform(test_data)

Kinyomtathatja az elemeket az előrejelzésekben

predictions.printSchema()
root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)
 |-- rawPrediction: vector (nullable = true)
 |-- probability: vector (nullable = true)
 |-- prediction: double (nullable = false)

Érdekel a címke, az előrejelzés és a valószínűség

selected = predictions.select("label", "prediction", "probability")
selected.show(20)

+-----+----------+--------------------+
|label|prediction|         probability|
+-----+----------+--------------------+
|  0.0|       0.0|[0.91560704124179...|
|  0.0|       0.0|[0.92812140213994...|
|  0.0|       0.0|[0.92161406774159...|
|  0.0|       0.0|[0.96222760777142...|
|  0.0|       0.0|[0.66363283056957...|
|  0.0|       0.0|[0.65571324475477...|
|  0.0|       0.0|[0.73053376932829...|
|  0.0|       1.0|[0.31265053873570...|
|  0.0|       0.0|[0.80005907577390...|
|  0.0|       0.0|[0.76482251301640...|
|  0.0|       0.0|[0.84447301189069...|
|  0.0|       0.0|[0.75691912026619...|
|  0.0|       0.0|[0.60902504096722...|
|  0.0|       0.0|[0.80799228385509...|
|  0.0|       0.0|[0.87704364852567...|
|  0.0|       0.0|[0.83817652582377...|
|  0.0|       0.0|[0.79655423248500...|
|  0.0|       0.0|[0.82712311232246...|
|  0.0|       0.0|[0.81372823882016...|
|  0.0|       0.0|[0.59687710752201...|
+-----+----------+--------------------+
only showing top 20 rows

Értékelje a modellt

Meg kell néznie a pontossági mutatót, hogy megtudja, milyen jól (vagy rosszul) teljesít a modell. Jelenleg nincs API a pontossági mérték kiszámításához Spark. Az alapértelmezett érték a ROC, vevő működési jelleggörbéje. Ez egy másik mérőszám, amely figyelembe veszi a hamis pozitív arányt.

Mielőtt megnézné a ROC-t, készítsük el a pontossági mértéket. Ön jobban ismeri ezt a mérőszámot. A pontosság mértéke a helyes előrejelzés összege a megfigyelések teljes számához viszonyítva.

Létrehoz egy DataFrame-et a címkével és a `előrejelzéssel.

cm = predictions.select("label", "prediction")

Ellenőrizheti az osztályok számát a címkében és az előrejelzésben

cm.groupby('label').agg({'label': 'count'}).show()

+-----+------------+
|label|count(label)|
+-----+------------+
|  0.0|        5021|
|  1.0|        1578|
+-----+------------+

cm.groupby('prediction').agg({'prediction': 'count'}).show()

+----------+-----------------+
|prediction|count(prediction)|
+----------+-----------------+
|       0.0|             5982|
|       1.0|              617|
+----------+-----------------+

Például a tesztkészletben 1578 háztartás van 50 ezer felett, és 5021 alacsonyabb. Az osztályozó ugyanakkor 617 olyan háztartást jósolt, amelyek jövedelme meghaladja az 50 ezret.

Kiszámíthatja a pontosságot a szám kiszámításával, amikor a címke helyesen van besorolva a sorok teljes számához képest.

cm.filter(cm.label == cm.prediction).count() / cm.count()

0.8237611759357478

Mindent összevonhat, és függvényt írhat a pontosság kiszámításához.

def accuracy_m(model): 
    predictions = model.transform(test_data)
    cm = predictions.select("label", "prediction")
    acc = cm.filter(cm.label == cm.prediction).count() / cm.count()
    print("Model accuracy: %.3f%%" % (acc * 100)) 
accuracy_m(model = linearModel)
Model accuracy: 82.376%

ROC mérőszámok

A BinaryClassificationEvaluator modul tartalmazza a ROC mértékeket. A fogadó Operating A karakterisztikus görbe egy másik gyakori eszköz, amelyet a bináris osztályozáshoz használnak. Nagyon hasonló a precíziós/visszahívási görbéhez, de ahelyett, hogy a pontosságot a felidézéssel ábrázolná, a ROC görbe a valódi pozitív arányt (azaz visszahívást) mutatja a hamis pozitív aránnyal szemben. A hamis pozitív arány a hibásan pozitívnak minősített negatív esetek aránya. Ez egyenlő eggyel mínusz a valódi negatív ráta. A valódi negatív rátát specifitásnak is nevezik. Ezért a ROC-görbe ábrázolja az érzékenységet (visszahívás) az 1-es specifitás függvényében

### Use ROC 
from pyspark.ml.evaluation import BinaryClassificationEvaluator

# Evaluate model
evaluator = BinaryClassificationEvaluator(rawPredictionCol="rawPrediction")
print(evaluator.evaluate(predictions))
print(evaluator.getMetricName())

0.8940481662695192ROC alatti terület

print(evaluator.evaluate(predictions))

0.8940481662695192

6. lépés) Hangolja be a hiperparamétert

Végül, de nem utolsósorban a hiperparamétereket is hangolhatja. Hasonló scikit tanulni létrehoz egy paraméterrácsot, és hozzáadja a hangolni kívánt paramétereket.

A számítási idő csökkentése érdekében csak két értékkel kell hangolni a regularizációs paramétert.

from pyspark.ml.tuning import ParamGridBuilder, CrossValidator

# Create ParamGrid for Cross Validation
paramGrid = (ParamGridBuilder()
             .addGrid(lr.regParam, [0.01, 0.5])
             .build())

Végül kiértékeli a modellt a keresztellenőrzés módszerével 5 hajtással. Körülbelül 16 percet vesz igénybe az edzés.

from time import *
start_time = time()

# Create 5-fold CrossValidator
cv = CrossValidator(estimator=lr,
                    estimatorParamMaps=paramGrid,
                    evaluator=evaluator, numFolds=5)

# Run cross validations
cvModel = cv.fit(train_data)
# likely take a fair amount of time
end_time = time()
elapsed_time = end_time - start_time
print("Time to train model: %.3f seconds" % elapsed_time)

A modell betanításának ideje: 978.807 másodperc

A legjobb regularizációs hiperparaméter a 0.01, 85.316 százalékos pontossággal.

accuracy_m(model = cvModel)
Model accuracy: 85.316%

Az ajánlott paramétert a cvModel.bestModel láncolásával vonhatja ki az extractParamMap() paranccsal.

bestModel = cvModel.bestModel
bestModel.extractParamMap()

{Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='aggregationDepth', doc='suggested depth for treeAggregate (>= 2)'): 2,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='elasticNetParam', doc='the ElasticNet mixing parameter, in range [0, 1]. For alpha = 0, the penalty is an L2 penalty. For alpha = 1, it is an L1 penalty'): 0.0,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='family', doc='The name of family which is a description of the label distribution to be used in the model. Supported options: auto, binomial, multinomial.'): 'auto',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='featuresCol', doc='features column name'): 'features',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='fitIntercept', doc='whether to fit an intercept term'): True,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='labelCol', doc='label column name'): 'label',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='maxIter', doc='maximum number of iterations (>= 0)'): 10,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='predictionCol', doc='prediction column name'): 'prediction',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='probabilityCol', doc='Column name for predicted class conditional probabilities. Note: Not all models output well-calibrated probability estimates! These probabilities should be treated as confidences, not precise probabilities'): 'probability',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='rawPredictionCol', doc='raw prediction (a.k.a. confidence) column name'): 'rawPrediction',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='regParam', doc='regularization parameter (>= 0)'): 0.01,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='standardization', doc='whether to standardize the training features before fitting the model'): True,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='threshold', doc='threshold in binary classification prediction, in range [0, 1]'): 0.5,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='tol', doc='the convergence tolerance for iterative algorithms (>= 0)'): 1e-06}

Összegzésként

Spark az adattudósok alapvető eszköze. Lehetővé teszi a szakember számára, hogy egy alkalmazást különböző adatforrásokhoz csatlakoztasson, zökkenőmentesen végezzen adatelemzést, vagy adjon hozzá prediktív modellt.

Mindenekelőtt Spark, kezdeményeznie kell a Spark Kontextus a következővel:

"SparkKontextus()'

És és SQL kontextus az adatforráshoz való csatlakozáshoz:

'SQLContext()'

Az oktatóanyagból megtudhatja, hogyan taníthat logisztikus regressziót:

1. Konvertálja az adatkészletet adatkeretté a következővel:

rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"])))
sqlContext.createDataFrame(input_data, ["label", "features"])

Ne feledje, hogy a címke oszlopának neve newlabel, és az összes szolgáltatás jellemzőkben van összegyűjtve. Módosítsa ezeket az értékeket, ha eltérnek az adatkészletben.

2. Hozza létre a vonat/tesztkészletet

randomSplit([.8,.2],seed=1234)

3. Tanítsd meg a modellt

LogisticRegression(labelCol="label",featuresCol="features",maxIter=10, regParam=0.3)

lr.fit()

4. Készítsen jóslatot

linearModel.transform()