PySpark Tutorial voor beginners: leer met VOORBEELDEN

Voordat je Py leertSpark, laten we het begrijpen:

Wat is apache Spark?

Spark is een big data-oplossing waarvan is bewezen dat deze eenvoudiger en sneller is dan Hadoop MapReduce. Spark is open source-software ontwikkeld door het UC Berkeley RAD-lab in 2009. Sinds de release in 2010 voor het publiek Spark is in populariteit gegroeid en wordt op een ongekende schaal in de industrie gebruikt.

In het tijdperk van Big datahebben praktijkmensen meer dan ooit behoefte aan snelle en betrouwbare tools om het streamen van data te verwerken. Eerdere tools zoals MapReduce waren favoriet, maar waren traag. Om dit probleem te overwinnen, Spark biedt een oplossing die zowel snel als algemeen toepasbaar is. Het belangrijkste verschil tussen Spark en MapReduce is dat Spark voert berekeningen uit in het geheugen tijdens de later op de harde schijf. Het maakt snelle toegang en gegevensverwerking mogelijk, waardoor de tijd wordt teruggebracht van uren naar minuten.

Wat is PySpark?

PySpark is een tool gemaakt door Apache Spark Community voor het gebruik van Python Spark. Het maakt het mogelijk om met RDD (Resilient Distributed Dataset) in Python te werken. Het biedt ook PySpark Shell om Python API's mee te koppelen Spark kern om te beginnen Spark Context. Spark is de naamengine om cluster computing te realiseren, terwijl PySpark is de bibliotheek van Python om te gebruiken Spark.

Hoe werkt Spark werken?

Spark is gebaseerd op een computerengine, wat betekent dat het zorgt voor de plannings-, distributie- en monitoringapplicatie. Elke taak wordt uitgevoerd op verschillende werkmachines, een computercluster genoemd. Een rekencluster verwijst naar de taakverdeling. Eén machine voert één taak uit, terwijl de andere via een andere taak bijdragen aan de uiteindelijke output. Uiteindelijk worden alle taken samengevoegd om een ​​output te produceren. De Spark admin geeft een 360 overzicht van diverse Spark Jobs.

Hoe werkt Spark werkzaamheden
Hoe werkt Spark werkzaamheden

Spark is ontworpen om mee te werken

  • Python
  • Java
  • Scala
  • SQL

Een belangrijk kenmerk van Spark is de enorme hoeveelheid ingebouwde bibliotheek, inclusief MLlib voor machine learning. Spark is ook ontworpen om met Hadoop-clusters te werken en kan het brede type bestanden lezen, waaronder Hive-gegevens, CSV, JSON en Casandra-gegevens.

Waarom gebruik maken van Spark?

Als toekomstig dataprofessional zou je bekend moeten zijn met de beroemde bibliotheken van Python: Pandas en scikit-learn. Deze twee bibliotheken zijn fantastisch om datasets tot middelgrote grootte te verkennen. Er worden regelmatig machine learning-projecten rond de follo gebouwdwing methodologie:

  • Laad de gegevens naar de schijf
  • Importeer de gegevens in het geheugen van de machine
  • Verwerk/analyseer de gegevens
  • Bouw het machine learning-model
  • Sla de voorspelling weer op schijf op

Het probleem ontstaat als de datawetenschapper gegevens wil verwerken die te groot zijn voor één computer. Tijdens de vroegere dagen van de datawetenschap proefden de beoefenaars de data, omdat training over enorme datasets niet altijd nodig was. De datawetenschapper zou een goede statistische steekproef vinden, een extra robuustheidscontrole uitvoeren en met een uitstekend model komen.

Er zijn echter enkele problemen hiermee:

  • Weerspiegelt de dataset de echte wereld?
  • Bevatten de gegevens een specifiek voorbeeld?
  • Is het model geschikt voor bemonstering?

Neem bijvoorbeeld de aanbeveling van gebruikers. Aanbevelers vertrouwen op het vergelijken van gebruikers met andere gebruikers bij het evalueren van hun voorkeuren. Als de dataprofessional slechts een subset van de gegevens gebruikt, zal er geen cohort gebruikers zijn die erg op elkaar lijken. Recommenders moeten op de volledige dataset draaien of helemaal niet.

Wat is de oplossing?

De oplossing was al lang duidelijk: het probleem werd opgesplitst over meerdere computers. Parallel computergebruik brengt ook meerdere problemen met zich mee. Ontwikkelaars hebben vaak moeite met het schrijven van parallelle code en moeten uiteindelijk een heleboel problemen oplossenplex problemen rond multi-processing zelf.

Pyspark geeft de datawetenschapper een API die kan worden gebruikt om de parallelle gegevensverwerkingsproblemen op te lossen. Pyspark verzorgt de complexaspecten van multiprocessing, zoals het distribueren van de gegevens, het distribueren van code en het verzamelen van output van de werknemers op een cluster van machines.

Spark kan zelfstandig draaien, maar draait meestal bovenop een cluster computing-framework zoals Hadoop. Bij testen en ontwikkelen kan een datawetenschapper echter efficiënt werken Spark op hun ontwikkeling boxes of laptops zonder cluster

• Een van de belangrijkste voordelen van Spark is het bouwen van een architechnologie die het beheer van datastreaming, naadloze dataquery's, machine learning-voorspellingen en realtime toegang tot verschillende analyses omvat.

• Spark werkt nauw samen met de SQL-taal, dat wil zeggen gestructureerde gegevens. Het maakt het mogelijk om de gegevens in realtime op te vragen.

• De belangrijkste taak van datawetenschappers is het analyseren en bouwen van voorspellende modellen. Kortom, een datawetenschapper moet weten hoe hij gegevens moet opvragen met behulp van SQL, produceer een statistisch rapport en maak gebruik van machine learning om voorspellingen te doen. Datawetenschappers besteden een aanzienlijk deel van hun tijd aan het opschonen, transformeren en analyseren van de gegevens. Zodra de dataset of dataworkflow klaar is, gebruikt de datawetenschapper verschillende technieken om inzichten en verborgen patronen te ontdekken. De gegevensmanipulatie moet robuust en eenvoudig te gebruiken zijn. Spark is de juiste tool dankzij de snelheid en rijke API's.

In deze PySpark tutorial leert u hoe u een classificator bouwt met PySpark voorbeelden.

Hoe Py te installerenSpark met AWS

Het Jupyter team bouwt een Docker-image om uit te voeren Spark efficiënt. Hieronder staan ​​de stappen die u kunt volgen om Py te installerenSpark exemplaar in AWS.

Raadpleeg onze tutorial op AWS en TensorFlow

Stap 1: Maak een exemplaar

Allereerst moet u een exemplaar maken. Ga naar uw AWS-account en start de instantie. U kunt de opslag vergroten tot 15 g en dezelfde beveiligingsgroep gebruiken als in de TensorFlow-tutorial.

Stap 2: Open de verbinding

Open de verbinding en installeer docker-container. Voor meer details, raadpleeg de tutorial met TensorFlow met havenarbeider. Houd er rekening mee dat u zich in de juiste werkmap moet bevinden.

Voer eenvoudig deze codes uit om Docker te installeren:

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

Stap 3: Heropen de verbinding en installeer Spark

Nadat u de verbinding opnieuw hebt geopend, kunt u de afbeelding met Py installerenSpark.

## 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

Stap 4: Openen Jupyter

Controleer de container en de naam ervan

docker ps

Start de docker met docker-logboeken gevolgd door de naam van de docker. Docker registreert bijvoorbeeld zealous_goldwasser

Ga naar je browser en start Jupyter. Het adres is http://localhost:8888/. Plak het wachtwoord dat door de terminal is opgegeven.

Note: als u een bestand naar uw AWS-machine wilt uploaden/downloaden, kunt u de software Cyberduck gebruiken, https://cyberduck.io/.

Hoe Py te installerenSpark on Windows/Mac met Conda

Following is een gedetailleerd proces voor het installeren van PySpark on Windows/Mac met Anaconda:

Om te installeren Spark op uw lokale computer is het een aanbevolen praktijk om een ​​nieuwe Conda-omgeving te maken. Deze nieuwe omgeving installeert Python 3.6, Spark en alle afhankelijkheden.

Mac-gebruiker

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

Windows Gebruiker

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

U kunt het .yml-bestand bewerken. Wees voorzichtig met het streepje. Er zijn twee ruimtes nodig voordat –

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

Bewaar het en creëer de omgeving. Het kost wat tijd

conda env create -f hello-spark.yml

Voor meer details over de locatie, bekijk de tutorial Installeer TensorFlow

U kunt de volledige omgeving controleren die op uw machine is geïnstalleerd

conda env list
Activate hello-spark

Mac-gebruiker

source activate hello-spark

Windows Gebruiker

activate hello-spark

Opmerking: U heeft al een specifieke TensorFlow-omgeving aangemaakt om de tutorials op TensorFlow uit te voeren. Het is handiger om een ​​nieuwe omgeving te creëren die anders is dan hello-tf. Het heeft geen zin om hello-tf te overbelasten Spark of andere machine learning-bibliotheken.

Stel je voor dat het grootste deel van je project TensorFlow betreft, maar dat je het moet gebruiken Spark voor één bepaald project. U kunt voor al uw projecten een TensorFlow-omgeving instellen en er een aparte omgeving voor creëren Spark. U kunt zoveel bibliotheken toevoegen Spark omgeving zoals u dat wilt, zonder de TensorFlow-omgeving te verstoren. Zodra u klaar bent met de Spark's project kunt u het wissen zonder dat dit gevolgen heeft voor de TensorFlow-omgeving.

Jupyter

Openen Jupyter Notebook en probeer of PySpark werken. Plak in een nieuw notitieboekje het volgendewing PySpark voorbeeldcode:

import pyspark
from pyspark import SparkContext
sc =SparkContext()

Als er een foutmelding wordt weergegeven, is Java waarschijnlijk niet op uw computer geïnstalleerd. Open in Mac de terminal en schrijf java -version. Als er een Java-versie is, zorg er dan voor dat deze 1.8 is. In Windows, ga naar Applicatie en controleer of er een Java-map is. Als er een Java-map aanwezig is, controleer dan of Java 1.8 is geïnstalleerd. Op het moment van schrijven is PySpark is niet compatibel met Java9 en hoger.

Als je Java moet installeren, moet je nadenken link en download jdk-8u181-windows-x64.exe

Jupyter

Voor Mac-gebruikers wordt het aanbevolen om `brew.` te gebruiken

brew tap caskroom/versions
brew cask install java8

Raadpleeg deze stapsgewijze zelfstudie op hoe Java te installeren

Note: gebruik verwijderen om een ​​omgeving volledig te wissen.

 conda env remove -n hello-spark -y

Spark Context

SparkContext is de interne motor die de verbindingen met de clusters mogelijk maakt. Als u een bewerking wilt uitvoeren, hebt u een SparkContext.

Maak een SparkContext

Allereerst moet u een SparkContext.

import pyspark
from pyspark import SparkContext
sc =SparkContext()

Nu de SparkContext is klaar, u kunt een verzameling gegevens maken met de naam RDD, Resilient Distributed Dataset. De berekeningen in een RDD worden automatisch over het hele cluster geparallelliseerd.

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

Met take heeft u toegang tot de eerste rij

nums.take(1)
[1]

U kunt een transformatie op de gegevens toepassen met een lambda-functie. In de PySpark In het onderstaande voorbeeld geeft u het kwadraat van nums terug. Het is een kaarttransformatie

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

SQLContext

Een handiger manier is om het DataFrame te gebruiken. SparkContext is al ingesteld, u kunt deze gebruiken om het dataFrame te maken. U moet ook de SQLContext declareren

Met SQLContext kunt u de engine verbinden met verschillende gegevensbronnen. Het wordt gebruikt om de functionaliteiten van te initiëren Spark SQL.

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

sqlContext = SQLContext(sc)

Nu in dit Spark tutorial Python, laten we een lijst met tuple maken. Elke tupel bevat de naam van de mensen en hun leeftijd. Er zijn vier stappen nodig:

Stap 1) Maak de lijst met tuple met de informatie

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

Stap 2) Bouw een RDD

rdd = sc.parallelize(list_p)

Stap 3) Converteer de tupels

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

Stap 4) Maak een DataFrame-context

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)

Als u toegang wilt krijgen tot het type van elke functie, kunt u printSchema() gebruiken

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

Machine Learning-voorbeeld met PySpark

Nu je er een kort idee van hebt Spark en SQLContext bent u klaar om uw eerste Machine learning-programma te bouwen.

Following zijn de stappen om een ​​Machine Learning-programma met Py te bouwenSpark:

  • Stap 1) Basisbediening met PySpark
  • Stap 2) Data voorverwerking
  • Stap 3) Bouw een pijplijn voor gegevensverwerking
  • Stap 4) Bouw de classificator: logistiek
  • Stap 5) Train en evalueer het model
  • Stap 6) Stem de hyperparameter af

In deze PySpark Machine Learning-tutorial, we zullen de dataset voor volwassenen gebruiken. Het doel van deze zelfstudie is om te leren hoe u Py kunt gebruikenspark. Raadpleeg deze zelfstudie voor meer informatie over de gegevensset.

Houd er rekening mee dat de dataset niet significant is en dat u misschien denkt dat de berekening lang duurt. Spark is ontworpen om een ​​aanzienlijke hoeveelheid gegevens te verwerken. Spark's prestaties nemen toe ten opzichte van andere machine learning-bibliotheken wanneer de verwerkte dataset groter wordt.

Stap 1) Basisbediening met PySpark

Allereerst moet u initialiseren dat SQLContext nog niet is gestart.

#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)

vervolgens kunt u het cvs-bestand lezen met sqlContext.read.csv. U gebruikt inferSchema ingesteld op True om het te vertellen Spark om automatisch het type gegevens te raden. Standaard is dit False.

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

Laten we eens kijken naar het gegevenstype

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)

U kunt de gegevens bekijken met show.

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

Als u inderShema niet op True hebt ingesteld, gebeurt er het volgende met het type. Er zijn allemaal strings.

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)

Om de continue variabele in het juiste formaat te converteren, kunt u de kolommen herschikken. U kunt withColumn gebruiken om dit te vertellen Spark welke kolom de transformatie moet uitvoeren.

# 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()

Selecteer kolommen

U kunt de rijen selecteren en weergeven met select en de namen van de objecten. Hieronder worden leeftijd en fnlwgt geselecteerd.

df.select('age','fnlwgt').show(5)
+---+------+
|age|fnlwgt|
+---+------+
| 39| 77516|
| 50| 83311|
| 38|215646|
| 53|234721|
| 28|338409|
+---+------+
only showing top 5 rows

Tel per groep

Als u het aantal voorkomens per groep wilt tellen, kunt u het volgende koppelen:

  • groepDoor()
  • tellen ()

samen. In de PySpark In het onderstaande voorbeeld telt u het aantal rijen per opleidingsniveau.

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|
+------------+-----+

Beschrijf de gegevens

Om een ​​samenvatting van de statistieken van de gegevens te krijgen, kunt u beschrijven() gebruiken. Het berekent de:

  • tellen
  • gemiddelde
  • standaardafwijking
  • Min
  • 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|
+-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+

Als je de samenvattende statistiek van slechts één kolom wilt, voeg dan de naam van de kolom toe in de beschrijving()

df.describe('capital_gain').show()
+-------+------------------+
|summary|      capital_gain|
+-------+------------------+
|  count|             32561|
|   mean|1077.6488437087312|
| stddev| 7385.292084840354|
|    min|                 0|
|    max|             99999|
+-------+------------------+

Kruistabelberekening

In sommige gevallen kan het interessant zijn om de beschrijvende statistieken tussen twee paren te zienwise kolommen. U kunt bijvoorbeeld het aantal mensen met een inkomen onder of boven de 50 tellen per opleidingsniveau. Deze bewerking wordt een kruistabel genoemd.

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

Je kunt zien dat geen enkel mens een omzet boven de 50 heeft als hij jong is.

Kolom laten vallen

Er zijn twee intuïtieve API's om kolommen neer te zetten:

  • drop(): Zet een kolom neer
  • dropna(): NA's laten vallen

Hieronder zet je de kolom education_num neer

df.drop('education_num').columns

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

Gegevens filteren

U kunt filter() gebruiken om beschrijvende statistieken toe te passen op een subset van gegevens. U kunt bijvoorbeeld het aantal mensen boven de 40 jaar tellen

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

13443

Beschrijvende statistieken per groep

Ten slotte kunt u gegevens per groep groeperen en statistische bewerkingen zoals het gemiddelde berekenen.

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|
+--------------------+------------------+

Stap 2) Voorverwerking van gegevens

Gegevensverwerking is een cruciale stap in machine learning. Nadat u ongewenste gegevens heeft verwijderd, krijgt u enkele belangrijke inzichten.

U weet bijvoorbeeld dat leeftijd geen lineaire functie is met het inkomen. Als mensen jong zijn, is hun inkomen doorgaans lager dan dat van middelbare leeftijd. Na pensionering gebruikt een huishouden zijn spaargeld, wat een inkomensdaling betekent. Om dit patroon vast te leggen, kunt u een vierkant aan het leeftijdselement toevoegen

Voeg een leeftijdsvierkant toe

Om een ​​nieuwe functie toe te voegen, moet je:

  1. Selecteer de kolom
  2. Pas de transformatie toe en voeg deze toe aan het DataFrame
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)

U kunt zien dat age_square met succes aan het dataframe is toegevoegd. Met select kunt u de volgorde van de variabelen wijzigen. Hieronder zet je age_square direct na age.

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')

Exclusief Nederland-Nederland

Wanneer een groep binnen een kenmerk slechts één waarneming heeft, brengt dit geen informatie naar het model. Integendeel, het kan tot een fout leiden tijdens de kruisvalidatie.

Laten we de oorsprong van het huishouden controleren

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

De functie native_country heeft slechts één huishouden afkomstig uit Nederland. Je sluit het uit.

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

Stap 3) Bouw een pijplijn voor gegevensverwerking

Vergelijkbaar met scikit-learn, Pyspark heeft een pijplijn-API.

Een pijplijn is erg handig om de structuur van de gegevens te behouden. Je duwt de gegevens in de pijplijn. Binnen de pijplijn worden verschillende bewerkingen uitgevoerd, de uitvoer wordt gebruikt om het algoritme te voeden.

Eén universele transformatie in machine learning bestaat bijvoorbeeld uit het converteren van een string naar één hot encoder, dat wil zeggen één kolom per groep. Eén hot encoder is meestal een matrix vol nullen.

De stappen om de gegevens te transformeren lijken sterk op scikit-learn. Je moet:

  • Indexeer de tekenreeks naar numeriek
  • Creëer de enige hete encoder
  • Transformeer de gegevens

Twee API's doen het werk: StringIndexer, OneHotEncoder

  1. Allereerst selecteert u de tekenreekskolom die u wilt indexeren. De inputCol is de naam van de kolom in de gegevensset. outputCol is de nieuwe naam die aan de getransformeerde kolom wordt gegeven.
StringIndexer(inputCol="workclass", outputCol="workclass_encoded")
  1. Pas de gegevens aan en transformeer deze
model = stringIndexer.fit(df)		
`indexed = model.transform(df)``
  1. Maak de nieuwskolommen op basis van de groep. Als het object bijvoorbeeld 10 groepen bevat, heeft de nieuwe matrix 10 kolommen, één voor elke groep.
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

Bouw de pijpleiding

Je bouwt een pijplijn om alle precieze features te converteren en toe te voegen aan de uiteindelijke dataset. De pijplijn heeft vier bewerkingen, maar u kunt gerust zoveel bewerkingen toevoegen als u wilt.

  1. Codeer de categorische gegevens
  2. Indexeer de labelfunctie
  3. Voeg een continue variabele toe
  4. Monteer de stappen.

Elke stap wordt opgeslagen in een lijst met de naam fasen. Deze lijst vertelt de VectorAssembler welke bewerking binnen de pijplijn moet worden uitgevoerd.

1. Codeer de categorische gegevens

Deze stap is precies hetzelfde als het bovenstaande voorbeeld, behalve dat u alle categorische kenmerken doorloopt.

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. Indexeer de labelfunctie

Sparkaccepteert, net als veel andere bibliotheken, geen tekenreekswaarden voor het label. U converteert de labelfunctie met StringIndexer en voegt deze toe aan de lijstfasen

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

3. Voeg een continue variabele toe

De inputCols van de VectorAssembler is een lijst met kolommen. U kunt een nieuwe lijst maken met alle nieuwe kolommen. De onderstaande code vult de lijst met gecodeerde categorische kenmerken en de doorlopende kenmerken.

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

4. Zet de treden in elkaar.

Tenslotte doorloopt u alle stappen in de VectorAssembler

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

Nu alle stappen klaar zijn, push je de gegevens naar de pijplijn.

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

Als u de nieuwe dataset controleert, kunt u zien dat deze alle kenmerken bevat, getransformeerd en niet getransformeerd. U bent alleen geïnteresseerd in het nieuwe label en de functies. De kenmerken omvatten alle getransformeerde kenmerken en de continue variabelen.

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}))]

Stap 4) Bouw de classificator: logistiek

Om de berekening sneller te maken, converteert u het model naar een DataFrame.

U moet een nieuw label en functies uit het model selecteren met behulp van de kaart.

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

U bent klaar om de treingegevens als DataFrame aan te maken. U gebruikt de sqlContext

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

Controleer de tweede rij

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

Maak een trein-/testset

Je splitst de dataset 80/20 met randomSplit.

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

Laten we tellen hoeveel mensen met een inkomen onder/boven de 50 in zowel de training als de testset

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|
+-----+------------+

Bouw de logistieke regressor

Last but not least kunt u de classificatie bouwen. Pyspark heeft een API genaamd LogisticRegression om logistieke regressie uit te voeren.

U initialiseert lr door de labelkolom en de featurekolommen aan te geven. U stelt maximaal 10 iteraties in en voegt een regularisatieparameter toe met een waarde van 0.3. Merk op dat u in de volgende sectie kruisvalidatie met een parameterraster zult gebruiken om het model af te stemmen

# 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)

#Je kunt de coëfficiënten uit de regressie zien

# 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

Stap 5) Train en evalueer het model

Om voorspellingen voor uw testset te genereren,

U kunt linearModel gebruiken met transform() op test_data

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

U kunt de elementen in voorspellingen afdrukken

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

Je bent geïnteresseerd in het label, de voorspelling en de waarschijnlijkheid

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

Evalueer het model

U moet naar de nauwkeurigheidsmetriek kijken om te zien hoe goed (of slecht) het model presteert. Momenteel is er geen API om de nauwkeurigheidsmeting te berekenen Spark. De standaardwaarde is de ROC, de karakteristieke curve van de ontvanger. Het zijn andere statistieken die rekening houden met het percentage vals-positieve resultaten.

Voordat we naar de ROC kijken, gaan we eerst de nauwkeurigheidsmeting construeren. U bent meer bekend met deze statistiek. De nauwkeurigheidsmaatstaf is de som van de juiste voorspelling over het totale aantal waarnemingen.

U maakt een DataFrame met het label en de `prediction.

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

U kunt het klassenummer in het label en de voorspelling controleren

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|
+----------+-----------------+

In de testset zijn er bijvoorbeeld 1578 huishoudens met een inkomen boven de 50 en 5021 daaronder. De classificator voorspelde echter 617 huishoudens met een inkomen boven de 50.

U kunt de nauwkeurigheid berekenen door het aantal te berekenen wanneer de labels correct zijn geclassificeerd over het totale aantal rijen.

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

0.8237611759357478

Je kunt alles samenvoegen en een functie schrijven om de nauwkeurigheid te berekenen.

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-statistieken

In de module BinaryClassificationEvaluator zijn de ROC-maatregelen opgenomen. De Receiver Operating Characteristic-curve is een ander veelgebruikt hulpmiddel bij binaire classificatie. Het lijkt erg op de precisie/herinneringscurve, maar in plaats van precisie versus herinnering weer te geven, toont de ROC-curve het werkelijk positieve percentage (dwz herinnering) tegenover het fout-positieve percentage. Het percentage fout-positieve resultaten is het aantal negatieve gevallen dat ten onrechte als positief is geclassificeerd. Het is gelijk aan één minus het werkelijk negatieve tarief. Het werkelijk negatieve percentage wordt ook wel specificiteit genoemd. Daarom geeft de ROC-curve de gevoeligheid (herinnering) weer versus 1 – specificiteit

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

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

0.8940481662695192gebiedOnder ROC

print(evaluator.evaluate(predictions))

0.8940481662695192

Stap 6) Stem de hyperparameter af

Last but not least kunt u de hyperparameters afstemmen. Gelijkwaardig aan scikit leren u maakt een parameterraster en voegt de parameters toe die u wilt afstemmen.

Om de berekeningstijd te verkorten, stemt u de regularisatieparameter slechts af met slechts twee waarden.

from pyspark.ml.tuning import ParamGridBuilder, CrossValidator

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

Tenslotte evalueer je het model met behulp van de kruisvalidatiemethode met 5 vouwen. Het duurt ongeveer 16 minuten om te trainen.

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)

Tijd om te trainen: 978.807 seconden

De beste regularisatie-hyperparameter is 0.01, met een nauwkeurigheid van 85.316 procent.

accuracy_m(model = cvModel)
Model accuracy: 85.316%

U kunt de aanbevolen parameter extraheren door cvModel.bestModel te koppelen aan extractParamMap()

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}

Samengevat

Spark is een fundamenteel hulpmiddel voor een datawetenschapper. Hiermee kan de arts een app verbinden met verschillende databronnen, naadloos data-analyses uitvoeren of een voorspellend model toevoegen.

Beginnen met Spark, moet u een Spark Context met:

'SparkContext()'

en en SQL context om verbinding te maken met een gegevensbron:

'SQLContext()'

In de tutorial leer je hoe je een logistieke regressie traint:

  1. Converteer de dataset naar een dataframe met:
rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"])))
sqlContext.createDataFrame(input_data, ["label", "features"])

Houd er rekening mee dat de kolomnaam van het label newlabel is en dat alle functies in features zijn verzameld. Wijzig deze waarden als deze verschillend zijn in uw gegevensset.

  1. Maak de trein/testset
randomSplit([.8,.2],seed=1234)
  1. Train het model
LogisticRegression(labelCol="label",featuresCol="features",maxIter=10, regParam=0.3)
lr.fit()
  1. Maak voorspelling
linearModel.transform()