PySpark Tutorial untuk Pemula: Belajar dengan CONTOH
Evelyn Clarke
Sebelum mempelajari PySpark, mari kita pahami:
Apa itu Apache Spark?
Spark adalah solusi big data yang terbukti lebih mudah dan cepat dibandingkan Hadoop MapReduce. Spark merupakan perangkat lunak open source yang dikembangkan oleh lab UC Berkeley RAD pada tahun 2009. Sejak dirilis ke publik pada tahun 2010, Spark semakin populer dan digunakan melalui industri dengan skala yang belum pernah terjadi sebelumnya.
Di era Big data, para praktisi membutuhkan alat yang lebih cepat dan andal untuk memproses streaming data. Alat-alat sebelumnya seperti MapReduce adalah favorit tetapi lambat. Untuk mengatasi masalah ini, Spark menawarkan solusi yang cepat dan bertujuan umum. Perbedaan utama antara Spark dan MapReduce adalah itu Spark menjalankan komputasi dalam memori pada hard disk. Hal ini memungkinkan akses dan pemrosesan data berkecepatan tinggi, mengurangi waktu dari jam menjadi menit.
Apa itu Py?Spark?
PySpark adalah alat yang dibuat oleh Apache Spark Komunitas untuk menggunakan Python dengan Spark. Ini memungkinkan bekerja dengan RDD (Resilient Distributed Dataset) di Python. Ia juga menawarkan PySpark Shell untuk ditautkan Python API dengan Spark inti untuk memulai Spark Konteks. Spark adalah mesin nama untuk mewujudkan komputasi cluster, sementara PySpark is Pythonperpustakaan untuk digunakan Spark.
Bagaimana Spark bekerja?
Spark berbasis pada mesin komputasi, artinya ia mengurus penjadwalan, pendistribusian, dan pemantauan aplikasi. Setiap tugas dilakukan di berbagai mesin pekerja yang disebut klaster komputasi. Klaster komputasi mengacu pada pembagian tugas. Satu mesin melakukan satu tugas, sementara yang lain berkontribusi pada hasil akhir melalui tugas yang berbeda. Pada akhirnya, semua tugas digabungkan untuk menghasilkan keluaran. Spark admin memberikan gambaran 360 yang beragam Spark Jobs.
Spark dirancang untuk digunakan
- Python
- Java
- Scala
- SQL
Sebuah fitur penting dari Spark adalah banyaknya perpustakaan bawaan, termasuk MLlib untuk pembelajaran mesin. Spark juga dirancang untuk bekerja dengan kluster Hadoop dan dapat membaca berbagai jenis file, termasuk data Hive, CSV, JSON, data Casandra, dan lainnya.
Mengapa menggunakan Spark?
Sebagai praktisi data masa depan, Anda harus familier dengan pustaka Python yang terkenal: Pandas dan scikit-learn. Kedua pustaka ini fantastis untuk mengeksplorasi kumpulan data hingga ukuran sedang. Proyek pembelajaran mesin reguler dibangun berdasarkan metodologi berikut:
- Muat data ke disk
- Impor data ke dalam memori mesin
- Memproses/menganalisis data
- Bangun model pembelajaran mesin
- Simpan prediksi kembali ke disk
Masalah muncul jika data scientist ingin memproses data yang terlalu besar untuk satu komputer. Pada masa-masa awal ilmu data, para praktisi akan mengambil sampel karena pelatihan tentang kumpulan data yang besar tidak selalu diperlukan. Ilmuwan data akan menemukan sampel statistik yang bagus, melakukan pemeriksaan ketahanan tambahan, dan menghasilkan model yang sangat baik.
Namun, ada beberapa masalah dalam hal ini:
- Apakah kumpulan data mencerminkan dunia nyata?
- Apakah data menyertakan contoh spesifik?
- Apakah model tersebut layak untuk diambil sampelnya?
Ambil contoh rekomendasi pengguna. Pemberi rekomendasi mengandalkan perbandingan pengguna dengan pengguna lain dalam mengevaluasi preferensi mereka. Jika praktisi data hanya mengambil sebagian data, tidak akan ada kelompok pengguna yang sangat mirip satu sama lain. Pemberi rekomendasi harus dijalankan pada kumpulan data lengkap atau tidak sama sekali.
Apa solusinya?
Solusinya sudah terbukti sejak lama, yaitu membagi masalah ke beberapa komputer. Komputasi paralel juga memiliki banyak masalah. Pengembang sering kali mengalami kesulitan menulis kode paralel dan akhirnya harus menyelesaikan sejumlah masalah rumit seputar multiprosesing itu sendiri.
Pyspark memberi ilmuwan data sebuah API yang dapat digunakan untuk memecahkan masalah pemrosesan data paralel. Pyspark menangani kompleksitas multiprosesing, seperti mendistribusikan data, mendistribusikan kode, dan mengumpulkan output dari pekerja pada sekelompok mesin.
Spark dapat berjalan secara mandiri tetapi paling sering berjalan di atas kerangka komputasi cluster seperti Hadoop. Namun, dalam pengujian dan pengembangan, seorang ilmuwan data dapat secara efisien menjalankan Spark pada kotak pengembangan atau laptop mereka tanpa cluster
• Salah satu keuntungan utama Spark adalah untuk membangun arsitektur yang mencakup manajemen aliran data, kueri data yang lancar, prediksi pembelajaran mesin, dan akses waktu nyata ke berbagai analisis.
• Spark bekerja erat dengan bahasa SQL, yaitu data terstruktur. Ini memungkinkan kueri data secara real time.
• Tugas utama data scientist adalah menganalisis dan membangun model prediktif. Singkatnya, seorang data scientist perlu mengetahui cara mengkueri data menggunakan SQL, menghasilkan laporan statistik dan memanfaatkan pembelajaran mesin untuk menghasilkan prediksi. Ilmuwan data menghabiskan banyak waktunya untuk membersihkan, mengubah, dan menganalisis data. Setelah kumpulan data atau alur kerja data siap, data scientist menggunakan berbagai teknik untuk menemukan wawasan dan pola tersembunyi. Manipulasi data harus kuat dan mudah digunakan. Spark adalah alat yang tepat berkat kecepatan dan API yang kaya.
Dalam hal iniSpark tutorial, Anda akan belajar cara membuat pengklasifikasi dengan PySpark contoh.
Cara Memasang PySpark dengan AWS
The Jupyter tim membuat image Docker untuk dijalankan Spark efisien. Berikut adalah langkah-langkah yang dapat Anda ikuti untuk menginstal PySpark contoh di AWS.
Lihat tutorial kami di AWS dan TensorFlow
Langkah 1: Buat Instance
Pertama-tama, Anda perlu membuat sebuah instance. Buka akun AWS Anda dan luncurkan instansnya. Anda dapat meningkatkan penyimpanan hingga 15g dan menggunakan grup keamanan yang sama seperti dalam tutorial TensorFlow.
Langkah 2: Buka koneksi
Buka koneksi dan instal kontainer docker. Untuk detail lebih lanjut, lihat tutorial dengan TensorFlow dengan Buruh pelabuhan. Perhatikan bahwa, Anda harus berada di direktori kerja yang benar.
Cukup jalankan kode ini untuk menginstal Docker:
sudo yum update -y sudo yum install -y docker sudo service docker start sudo user-mod -a -G docker ec2-user exit
Langkah 3: Buka kembali koneksi dan instal Spark
Setelah Anda membuka kembali koneksi, Anda dapat menginstal image yang berisi PySpark.
## 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
Langkah 4: Buka Jupyter
Periksa wadah dan namanya
docker ps
Luncurkan buruh pelabuhan dengan log buruh pelabuhan diikuti dengan nama buruh pelabuhan. Misalnya, buruh pelabuhan mencatat zealous_goldwasser
Buka browser Anda dan luncurkan Jupyter. Alamatnya adalah http://localhost:8888/. Rekatkan kata sandi yang diberikan oleh terminal.
Note: jika Anda ingin mengunggah/mengunduh file ke mesin AWS Anda, Anda dapat menggunakan perangkat lunak Cyberduck, https://cyberduck.io/.
Cara Memasang PySpark on Windows/Mac dengan Conda
Berikut ini adalah proses terperinci tentang cara menginstal PySpark on Windows/Mac menggunakan Anaconda:
Untuk menginstal Spark di mesin lokal Anda, praktik yang disarankan adalah membuat lingkungan conda baru. Lingkungan baru ini akan diinstal Python 3.6, Spark dan semua ketergantungan.
Pengguna Mac
cd anaconda3 touch hello-spark.yml vi hello-spark.yml
Windows Pengguna
cd C:\Users\Admin\Anaconda3 echo.>hello-spark.yml notepad hello-spark.yml
Anda dapat mengedit file .yml. Berhati-hatilah dengan indentasi. Dua spasi diperlukan sebelum –
name: hello-spark
dependencies:
- python=3.6
- jupyter
- ipython
- numpy
- numpy-base
- pandas
- py4j
- pyspark
- pytz
Simpan dan ciptakan lingkungan. Ini membutuhkan waktu
conda env create -f hello-spark.yml
Untuk detail lebih lanjut tentang lokasi, silakan periksa tutorial Instal TensorFlow
Anda dapat memeriksa semua lingkungan yang terpasang di mesin Anda
conda env list
Activate hello-spark
Pengguna Mac
source activate hello-spark
Windows Pengguna
activate hello-spark
Catatan: Anda telah membuat lingkungan TensorFlow tertentu untuk menjalankan tutorial di TensorFlow. Akan lebih mudah untuk membuat lingkungan baru yang berbeda dari hello-tf. Tidak masuk akal untuk membebani hello-tf secara berlebihan Spark atau perpustakaan pembelajaran mesin lainnya.
Bayangkan sebagian besar proyek Anda melibatkan TensorFlow, tetapi Anda perlu menggunakannya Spark untuk satu proyek tertentu. Anda dapat mengatur lingkungan TensorFlow untuk semua proyek Anda dan membuat lingkungan terpisah untuknya Spark. Anda dapat menambahkan perpustakaan sebanyak-banyaknya Spark lingkungan sesuai keinginan Anda tanpa mengganggu lingkungan TensorFlow. Setelah Anda selesai dengan Sparkproyek Anda, Anda dapat menghapusnya tanpa memengaruhi lingkungan TensorFlow.
Jupyter
Open Jupyter Notebook dan coba jika PySpark berfungsi. Pada buku catatan baru, tempel kode Py berikutSpark Kode sampel:
import pyspark from pyspark import SparkContext sc =SparkContext()
Jika kesalahan ditampilkan, kemungkinan besar demikian Java tidak terpasang di komputer Anda. Di Mac, buka terminal dan tulis java -version, jika ada versi Java, pastikan versinya adalah 1.8. Di Windows, buka Aplikasi dan periksa apakah ada Java map. Jika ada Java folder, periksa itu Java 1.8 diinstal. Pada tulisan ini, PySpark tidak kompatibel dengan Java9 ke atas.
Jika Anda perlu menginstal Java, kamu berpikir link dan unduh jdk-8u181-windows-x64.exe
Untuk Pengguna Mac, disarankan untuk menggunakan `brew.`
brew tap caskroom/versions brew cask install java8
Lihat tutorial langkah demi langkah ini bagaimana cara menginstall Java
Note: Gunakan hapus untuk menghapus lingkungan sepenuhnya.
conda env remove -n hello-spark -y
Spark Konteks
SparkKonteks adalah mesin internal yang memungkinkan koneksi dengan cluster. Jika Anda ingin menjalankan operasi, Anda memerlukan SparkKonteks.
Membuat SparkKonteks
Pertama-tama, Anda perlu memulai a SparkKonteks.
import pyspark from pyspark import SparkContext sc =SparkContext()
Sekarang bahwa SparkKonteks sudah siap, Anda dapat membuat kumpulan data yang disebut RDD, Resilient Distributed Dataset. Perhitungan dalam RDD secara otomatis diparalelkan di seluruh klaster.
nums= sc.parallelize([1,2,3,4])
Anda dapat mengakses baris pertama dengan take
nums.take(1)
[1]
Anda dapat menerapkan transformasi ke data dengan fungsi lambda. Di PySpark contoh di bawah ini, Anda mengembalikan kuadrat angka. Ini adalah transformasi peta
squared = nums.map(lambda x: x*x).collect()
for num in squared:
print('%i ' % (num))
1 4 9 16
SQLKonteks
Cara yang lebih nyaman adalah dengan menggunakan DataFrame. SparkKonteks sudah ditetapkan, Anda dapat menggunakannya untuk membuat dataFrame. Anda juga perlu mendeklarasikan SQLContext
SQLContext memungkinkan menghubungkan mesin dengan sumber data yang berbeda. Ini digunakan untuk memulai fungsionalitas Spark sql
from pyspark.sql import Row from pyspark.sql import SQLContext sqlContext = SQLContext(sc)
Sekarang dalam hal ini Spark tutorial Python, mari buat daftar Tuple. Setiap tupel akan berisi nama orang dan umur mereka. Empat langkah diperlukan:
Langkah 1) Buat daftar Tuple dengan informasinya
[('John',19),('Smith',29),('Adam',35),('Henry',50)]
Langkah 2) Membangun RDD
rdd = sc.parallelize(list_p)
Langkah 3) Konversikan tupel
rdd.map(lambda x: Row(name=x[0], age=int(x[1])))
Langkah 4) Buat konteks DataFrame
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)
Jika Anda ingin mengakses tipe setiap fitur, Anda dapat menggunakan printSchema()
DF_ppl.printSchema() root |-- age: long (nullable = true) |-- name: string (nullable = true)
Contoh Pembelajaran Mesin dengan PySpark
Sekarang Anda memiliki gambaran singkat tentangnya Spark dan SQLContext, Anda siap membuat program Machine learning pertama Anda.
Berikut adalah langkah-langkah untuk membangun program Machine Learning dengan PySpark:
- Langkah 1) Operasi dasar dengan PySpark
- Langkah 2) Preprocessing data
- Langkah 3) Bangun jalur pemrosesan data
- Langkah 4) Bangun pengklasifikasi: logistik
- Langkah 5) Melatih dan mengevaluasi model
- Langkah 6) Sesuaikan hyperparameternya
Dalam hal iniSpark Tutorial Machine Learning, kita akan menggunakan dataset dewasa. Tujuan dari tutorial ini adalah untuk mempelajari cara menggunakan Pyspark. Untuk informasi lebih lanjut tentang dataset, lihat tutorial ini.
Perhatikan bahwa kumpulan datanya tidak signifikan dan Anda mungkin berpikir bahwa penghitungannya memerlukan waktu lama. Spark dirancang untuk memproses sejumlah besar data. SparkPerformanya meningkat dibandingkan dengan pustaka pembelajaran mesin lainnya ketika kumpulan data yang diproses bertambah besar.
Langkah 1) Operasi dasar dengan PySpark
Pertama-tama, Anda perlu menginisialisasi SQLContext yang belum dimulai.
#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)
kemudian, Anda dapat membaca file cvs dengan sqlContext.read.csv. Anda menggunakan inferSchema yang disetel ke True untuk mengetahuinya Spark untuk menebak secara otomatis jenis datanya. Secara default, ini berubah menjadi False.
df = sqlContext.read.csv(SparkFiles.get("adult_data.csv"), header=True, inferSchema= True)
Mari kita lihat tipe datanya
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)
Anda dapat melihat datanya dengan 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
Jika Anda tidak menyetel inderShema ke True, inilah yang terjadi pada tipenya. Semuanya ada dalam string.
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)
Untuk mengonversi variabel kontinu ke format yang tepat, Anda dapat menggunakan penyusunan ulang kolom. Anda dapat menggunakan withColumn untuk mengetahuinya Spark kolom mana untuk mengoperasikan transformasi.
# 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()
Pilih kolom
Anda dapat memilih dan menampilkan baris dengan pilihan dan nama fitur. Di bawah, umur dan fnlwgt dipilih.
df.select('age','fnlwgt').show(5)
+---+------+ |age|fnlwgt| +---+------+ | 39| 77516| | 50| 83311| | 38|215646| | 53|234721| | 28|338409| +---+------+ only showing top 5 rows
Hitung berdasarkan kelompok
Jika Anda ingin menghitung jumlah kemunculan berdasarkan kelompok, Anda dapat membuat rantai:
- grupBy()
- menghitung()
bersama. Di PySpark contoh dibawah ini, anda menghitung jumlah baris berdasarkan tingkat pendidikan.
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| +------------+-----+
Jelaskan datanya
Untuk mendapatkan ringkasan statistik data, Anda dapat menggunakan deskripsikan(). Ini akan menghitung:
- menghitung
- berarti
- deviasi standar
- menit
- 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| +-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+
Jika Anda ingin statistik ringkasan hanya satu kolom, tambahkan nama kolom di dalam deskripsikan()
df.describe('capital_gain').show()
+-------+------------------+ |summary| capital_gain| +-------+------------------+ | count| 32561| | mean|1077.6488437087312| | stddev| 7385.292084840354| | min| 0| | max| 99999| +-------+------------------+
Perhitungan tab silang
Dalam beberapa kesempatan, menarik untuk melihat statistik deskriptif antara dua kolom berpasangan. Misalnya, Anda dapat menghitung jumlah orang dengan pendapatan di bawah atau di atas 50 ribu berdasarkan tingkat pendidikan. Operasi ini disebut crosstab.
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
Anda dapat melihat tidak ada orang yang memiliki pendapatan di atas 50k ketika mereka masih muda.
Jatuhkan kolom
Ada dua API intuitif untuk menghapus kolom:
- drop(): Jatuhkan kolom
- dropna(): Jatuhkan NA
Di bawah Anda letakkan kolom education_num
df.drop('education_num').columns
['age',
'workclass',
'fnlwgt',
'education',
'marital',
'occupation',
'relationship',
'race',
'sex',
'capital_gain',
'capital_loss',
'hours_week',
'native_country',
'label']
Saring datanya
Anda dapat menggunakan filter() untuk menerapkan statistik deskriptif dalam subkumpulan data. Misalnya, Anda dapat menghitung jumlah orang yang berusia di atas 40 tahun
df.filter(df.age > 40).count()
13443
Descriptstatistik saya berdasarkan kelompok
Terakhir, Anda dapat mengelompokkan data berdasarkan kelompok dan menghitung operasi statistik seperti rata-rata.
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| +--------------------+------------------+
Langkah 2) Pemrosesan awal data
Pemrosesan data adalah langkah penting dalam pembelajaran mesin. Setelah Anda menghapus data sampah, Anda mendapatkan beberapa wawasan penting.
Misalnya, Anda mengetahui bahwa usia bukanlah fungsi linier dengan pendapatan. Ketika masyarakat masih muda, pendapatan mereka biasanya lebih rendah dibandingkan usia paruh baya. Setelah pensiun, rumah tangga menggunakan tabungannya, yang berarti penurunan pendapatan. Untuk menangkap pola ini, Anda dapat menambahkan kotak ke fitur usia
Tambahkan kuadrat usia
Untuk menambahkan fitur baru, Anda perlu:
- Pilih kolom
- Terapkan transformasi dan tambahkan ke 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)
Anda dapat melihat bahwa age_square telah berhasil ditambahkan ke bingkai data. Anda dapat mengubah urutan variabel dengan pilih. Di bawah, Anda membawa age_square tepat setelah 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')
Kecualikan Belanda-Belanda
Jika suatu grup dalam suatu fitur hanya memiliki satu observasi, maka grup tersebut tidak membawa informasi ke model. Sebaliknya, hal ini dapat menyebabkan kesalahan saat validasi silang.
Mari kita periksa asal usul rumah tangganya
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
Fitur native_country hanya memiliki satu rumah tangga yang berasal dari Belanda. Anda mengecualikannya.
df_remove = df.filter(df.native_country != 'Holand-Netherlands')
Langkah 3) Bangun jalur pemrosesan data
Mirip dengan scikit-learn, Pyspark memiliki API pipeline.
Pipeline sangat berguna untuk menjaga struktur data. Anda memasukkan data ke dalam pipeline. Di dalam pipeline, berbagai operasi dilakukan, output digunakan untuk memberi masukan pada algoritma.
Misalnya, satu transformasi universal dalam pembelajaran mesin terdiri dari konversi string menjadi satu hot encoder, yaitu satu kolom per grup. Satu hot encoder biasanya berupa matriks yang penuh dengan angka nol.
Langkah-langkah untuk mengubah data sangat mirip dengan scikit-learn. Kamu butuh:
- Indeks string ke numerik
- Buat satu encoder panas
- Ubah datanya
Dua API melakukan pekerjaan itu: StringIndexer, OneHotEncoder
- Pertama-tama, Anda memilih kolom string yang akan diindeks. inputCol adalah nama kolom dalam kumpulan data. outputCol adalah nama baru yang diberikan pada kolom yang diubah.
StringIndexer(inputCol="workclass", outputCol="workclass_encoded")
- Sesuaikan data dan ubah
model = stringIndexer.fit(df) `indexed = model.transform(df)``
- Buat kolom berita berdasarkan grup. Misalnya, jika ada 10 grup dalam fitur, matriks baru akan memiliki 10 kolom, satu kolom untuk setiap grup.
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
Bangun saluran pipa
Anda akan membangun alur kerja untuk mengonversi semua fitur yang tepat dan menambahkannya ke kumpulan data akhir. Alur kerja akan memiliki empat operasi, tetapi Anda bebas menambahkan operasi sebanyak yang Anda inginkan.
- Enkode data kategorikal
- Indeks fitur label
- Tambahkan variabel kontinu
- Susun langkah-langkahnya.
Setiap langkah disimpan dalam daftar yang diberi nama tahapan. Daftar ini akan memberi tahu VectorAssembler operasi apa yang harus dilakukan di dalam alur kerja.
1. Encode data kategorikal
Langkah ini sama persis dengan contoh di atas, hanya saja Anda mengulang semua fitur kategoris.
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. Indeks fitur label
Spark, seperti banyak perpustakaan lainnya, tidak menerima nilai string untuk labelnya. Anda mengonversi fitur label dengan StringIndexer dan menambahkannya ke tahapan daftar
# Convert label into label indices using the StringIndexer label_stringIdx = StringIndexer(inputCol="label", outputCol="newlabel") stages += [label_stringIdx]
3. Tambahkan variabel kontinu
inputCols dari VectorAssembler adalah daftar kolom. Anda dapat membuat daftar baru yang berisi semua kolom baru. Kode di bawah ini mengisi daftar dengan fitur kategorikal yang disandikan dan fitur berkelanjutan.
assemblerInputs = [c + "classVec" for c in CATE_FEATURES] + CONTI_FEATURES
4. Susun langkah-langkahnya.
Terakhir, Anda melewati semua langkah di VectorAssembler
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="features")stages += [assembler]
Sekarang semua langkah sudah siap, Anda memasukkan data ke alur.
# Create a Pipeline. pipeline = Pipeline(stages=stages) pipelineModel = pipeline.fit(df_remove) model = pipelineModel.transform(df_remove)
Jika Anda memeriksa kumpulan data baru, Anda dapat melihat bahwa kumpulan data tersebut berisi semua fitur, yang diubah dan tidak diubah. Anda hanya tertarik dengan label dan fitur baru. Fitur-fiturnya mencakup semua fitur yang diubah dan variabel kontinu.
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}))]
Langkah 4) Bangun pengklasifikasi: logistik
Untuk mempercepat komputasi, Anda mengonversi model menjadi DataFrame.
Anda perlu memilih label dan fitur baru dari model menggunakan peta.
from pyspark.ml.linalg import DenseVector input_data = model.rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"])))
Anda siap membuat data kereta sebagai DataFrame. Anda menggunakan sqlContext
df_train = sqlContext.createDataFrame(input_data, ["label", "features"])
Periksa baris kedua
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
Buat set kereta/ujian
Anda membagi kumpulan data 80/20 dengan randomSplit.
# Split the data into train and test sets train_data, test_data = df_train.randomSplit([.8,.2],seed=1234)
Mari kita hitung berapa banyak orang yang berpenghasilan di bawah/di atas 50k baik di set pelatihan maupun tes
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| +-----+------------+
Bangun regresi logistik
Terakhir, Anda dapat membuat pengklasifikasi. Pyspark memiliki API yang disebut LogisticRegression untuk melakukan regresi logistik.
Anda menginisialisasi lr dengan menunjukkan kolom label dan kolom fitur. Anda menetapkan maksimal 10 iterasi dan menambahkan parameter regularisasi dengan nilai 0.3. Perhatikan bahwa di bagian selanjutnya, Anda akan menggunakan validasi silang dengan kisi parameter untuk menyempurnakan model
# 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)
#Anda dapat melihat koefisien dari regresi
# 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
Langkah 5) Latih dan evaluasi model
Untuk menghasilkan prediksi untuk set pengujian Anda,
Anda dapat menggunakan linearModel dengan transform() pada test_data
# Make predictions on test data using the transform() method. predictions = linearModel.transform(test_data)
Anda dapat mencetak elemen dalam prediksi
predictions.printSchema() root |-- label: double (nullable = true) |-- features: vector (nullable = true) |-- rawPrediction: vector (nullable = true) |-- probability: vector (nullable = true) |-- prediction: double (nullable = false)
Anda tertarik dengan label, prediksi, dan probabilitasnya
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
Evaluasi modelnya
Anda perlu melihat metrik akurasi untuk melihat seberapa baik (atau buruk) performa model. Saat ini, tidak ada API untuk menghitung ukuran akurasi SparkNilai default adalah ROC, kurva karakteristik operasi penerima. Ini adalah metrik berbeda yang memperhitungkan rasio positif palsu.
Sebelum Anda melihat ROC, mari kita buat ukuran akurasinya. Anda lebih familiar dengan metrik ini. Ukuran akurasi adalah jumlah prediksi yang benar terhadap jumlah total observasi.
Anda membuat DataFrame dengan label dan `prediksi.
cm = predictions.select("label", "prediction")
Anda dapat memeriksa jumlah kelas di label dan prediksinya
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| +----------+-----------------+
Misalnya, pada set pengujian, terdapat 1578 rumah tangga dengan pendapatan di atas 50k dan 5021 di bawah. Namun pengklasifikasi memperkirakan 617 rumah tangga dengan pendapatan di atas 50 ribu.
Anda dapat menghitung keakuratannya dengan menghitung jumlah saat label diklasifikasikan dengan benar pada jumlah total baris.
cm.filter(cm.label == cm.prediction).count() / cm.count()
0.8237611759357478
Anda dapat menggabungkan semuanya dan menulis fungsi untuk menghitung keakuratannya.
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%
Metrik ROC
Modul BinaryClassificationEvaluator mencakup langkah-langkah ROC. Penerima OperaKurva karakteristik adalah alat umum lainnya yang digunakan dalam klasifikasi biner. Hal ini sangat mirip dengan kurva presisi/recall, namun alih-alih memplot presisi versus perolehan, kurva ROC menunjukkan tingkat positif sebenarnya (yaitu perolehan kembali) terhadap tingkat positif palsu. Tingkat positif palsu adalah rasio kejadian negatif yang salah diklasifikasikan sebagai positif. Nilai ini sama dengan satu dikurangi tingkat negatif sebenarnya. Tingkat negatif sebenarnya juga disebut spesifisitas. Oleh karena itu kurva ROC memplot sensitivitas (recall) versus 1 – spesifisitas
### Use ROC from pyspark.ml.evaluation import BinaryClassificationEvaluator # Evaluate model evaluator = BinaryClassificationEvaluator(rawPredictionCol="rawPrediction") print(evaluator.evaluate(predictions)) print(evaluator.getMetricName())
0.8940481662695192areaDi BawahROC
print(evaluator.evaluate(predictions))
0.8940481662695192
Langkah 6) Sesuaikan hyperparameter
Terakhir, Anda dapat menyetel hyperparameter. Mirip dengan scikit belajar Anda membuat kisi parameter, dan menambahkan parameter yang ingin Anda sesuaikan.
Untuk mengurangi waktu komputasi, Anda hanya menyetel parameter regularisasi dengan dua nilai saja.
from pyspark.ml.tuning import ParamGridBuilder, CrossValidator
# Create ParamGrid for Cross Validation
paramGrid = (ParamGridBuilder()
.addGrid(lr.regParam, [0.01, 0.5])
.build())
Terakhir, Anda mengevaluasi model dengan menggunakan metode cross valiation sebanyak 5 kali lipat. Dibutuhkan sekitar 16 menit untuk berlatih.
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)
Waktu untuk melatih model: 978.807 detik
Hyperparameter regularisasi terbaik adalah 0.01 dengan akurasi 85.316 persen.
accuracy_m(model = cvModel) Model accuracy: 85.316%
Anda dapat mengekstrak parameter yang direkomendasikan dengan merantai cvModel.bestModel dengan ekstrakParamMap()
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}
Ringkasan
Spark adalah alat mendasar bagi ilmuwan data. Hal ini memungkinkan praktisi untuk menghubungkan aplikasi ke sumber data yang berbeda, melakukan analisis data dengan lancar atau menambahkan model prediktif.
Memulai dengan Spark, Anda perlu memulai a Spark Konteks dengan:
'SparkKonteks()'
dan dan SQL konteks untuk terhubung ke sumber data:
'Konteks SQL()'
Dalam tutorial ini, Anda mempelajari cara melatih regresi logistik:
- Ubah kumpulan data menjadi Dataframe dengan:
rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"]))) sqlContext.createDataFrame(input_data, ["label", "features"])
Perhatikan bahwa nama kolom label adalah label baru dan semua fitur dikumpulkan dalam fitur. Ubah nilai-nilai ini jika berbeda dalam kumpulan data Anda.
- Buat set kereta/pengujian
randomSplit([.8,.2],seed=1234)
- Latih modelnya
LogisticRegression(labelCol="label",featuresCol="features",maxIter=10, regParam=0.3)
lr.fit()
- Buat prediksi
linearModel.transform()
