PySpark Tutorial voor beginners: leer met VOORBEELDEN
Evelien Clarke
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 latere op de harde schijf. Het maakt snelle toegang en gegevensverwerking mogelijk, waardoor de tijd van uren naar minuten wordt teruggebracht.
Wat is PySpark?
PySpark is een tool gemaakt door Apache Spark Gemeenschap voor gebruik Python met Spark. Het maakt het mogelijk om met RDD (Resilient Distributed Dataset) te werken in Python. Het biedt ook PySpark Shell om te koppelen Python API's met Spark kern om te beginnen Spark Context. Spark is de naam engine om cluster computing te realiseren, terwijl PySpark is Python's bibliotheek te gebruiken Spark.
Hoe werkt Spark werken?
Spark is gebaseerd op een computationele engine, wat betekent dat het zorgt voor de planning, distributie en monitoring van de applicatie. Elke taak wordt uitgevoerd op verschillende werkmachines, ook wel computing cluster genoemd. Een computing cluster verwijst naar de verdeling van taken. Eén machine voert één taak uit, terwijl de andere bijdragen aan de uiteindelijke output via een andere taak. Uiteindelijk worden alle taken samengevoegd om een output te produceren. De Spark admin geeft een 360 overzicht van diverse Spark Jobs.
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 te werken met Hadoop-clusters en kan de meeste bestandstypen lezen, waaronder Hive-gegevens, CSV, JSON, Casandra-gegevens en meer.
Waarom gebruik maken van Spark?
Als toekomstige data-beoefenaar zou u 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. Regelmatige machine learning-projecten worden gebouwd rond de volgende 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 is al lang duidelijk: verdeel het probleem over meerdere computers. Parallel computing brengt ook meerdere problemen met zich mee. Ontwikkelaars hebben vaak moeite met het schrijven van parallelle code en moeten uiteindelijk een hoop van de complexe problemen rondom multi-processing zelf oplossen.
Pyspark biedt de datawetenschapper een API die kan worden gebruikt om de parallelle dataprocessingproblemen op te lossen. Pyspark behandelt de complexiteit van multiprocessing, zoals het distribueren van de data, het distribueren van code en het verzamelen van output van de workers op een cluster van machines.
Spark kan standalone draaien, maar draait meestal bovenop een cluster computing framework zoals Hadoop. In test en ontwikkeling kan een datawetenschapper echter efficiënt draaien Spark op hun ontwikkelboxen of laptops zonder cluster
• Een van de belangrijkste voordelen van Spark is het bouwen van een architectuur die datastreambeheer, naadloze dataquery's, voorspellingen op basis van machinaal leren en realtime toegang tot diverse 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
De 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. Raadpleeg voor meer details 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
Hieronder volgt 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 wordt geïnstalleerd 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, zie de tutorial TensorFlow installeren
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 werkt. Plak in een nieuw notitieboek de volgende PySpark voorbeeldcode:
import pyspark from pyspark import SparkContext sc =SparkContext()
Als er een fout wordt weergegeven, is dat waarschijnlijk het geval Java is niet op uw machine geïnstalleerd. Open in Mac de terminal en schrijf java -version, als er een java-versie is, zorg er dan voor dat het 1.8 is. In Windows, ga naar Applicatie en controleer of er een Java map. Als er een Java map, controleer dat Java 1.8 is geïnstalleerd. Op het moment van schrijven is PySpark is niet compatibel met Java9 en hoger.
Als je moet installeren Java, jij om na te denken link en download jdk-8u181-windows-x64.exe
Voor Mac-gebruikers wordt het aanbevolen om `brew.` te gebruiken
brew tap caskroom/versions brew cask install java8
Raadpleeg deze stapsgewijze zelfstudie op hoe te installeren Java
Note: gebruik verwijderen om een omgeving volledig te wissen.
conda env remove -n hello-spark -y
Spark Context
SparkContext is de interne engine 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 gereed, u kunt een verzameling gegevens maken met de naam RDD, Resilient Distributed Dataset. Berekeningen in een RDD worden automatisch geparallelliseerd over het cluster.
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 zelfstudie 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.
Hieronder staan de stappen om een Machine Learning-programma te bouwen met PySpark:
- Stap 1) Basisbewerking 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 gebruiken de adult dataset. Het doel van deze tutorial is om te leren hoe je Pyspark gebruikt. Voor meer informatie over de dataset, zie deze tutorial.
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) Basisbewerking 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
Soms kan het interessant zijn om de beschrijvende statistieken tussen twee paarsgewijze kolommen te bekijken. U kunt bijvoorbeeld het aantal mensen met een inkomen onder of boven de 50k tellen op 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
Descriptive statistieken per groep
Ten slotte kunt u gegevens groeperen per groep en statistische bewerkingen uitvoeren, zoals het gemiddelde.
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:
- Selecteer de kolom
- 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
Pyspark heeft, net als scikit-learn, een pipeline-API.
Een pijplijn is erg handig om de structuur van de data te behouden. Je pusht de data in de pijplijn. Binnen de pijplijn worden verschillende bewerkingen uitgevoerd, de output 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
- 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")
- Pas de gegevens aan en transformeer deze
model = stringIndexer.fit(df) `indexed = model.transform(df)``
- 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
U bouwt een pijplijn om alle precieze features te converteren en ze toe te voegen aan de uiteindelijke dataset. De pijplijn heeft vier bewerkingen, maar u kunt er zoveel bewerkingen aan toevoegen als u wilt.
- Codeer de categorische gegevens
- Indexeer de labelfunctie
- Voeg een continue variabele toe
- Monteer de stappen.
Elke stap wordt opgeslagen in een lijst met de naam stages. Deze lijst vertelt de VectorAssembler welke bewerking moet worden uitgevoerd in de pijplijn.
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, je kunt de classifier 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, receiver operating characteristic curve. Het is een andere metriek die rekening houdt met de false positive rate.
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 ontvanger OperaKarakteristieke 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}
Samenvatting
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:
- 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.
- Maak de trein/testset
randomSplit([.8,.2],seed=1234)
- Train het model
LogisticRegression(labelCol="label",featuresCol="features",maxIter=10, regParam=0.3)
lr.fit()
- Maak voorspelling
linearModel.transform()
