PySpark Hướng dẫn dành cho người mới bắt đầu: Học với VÍ DỤ
Evelyn Clarke
Trước khi học PySpark, hãy hiểu:
Apache là gì Spark?
Spark là một giải pháp dữ liệu lớn đã được chứng minh là dễ dàng và nhanh hơn Hadoop MapReduce. Spark là một phần mềm nguồn mở được phát triển bởi phòng thí nghiệm UC Berkeley RAD vào năm 2009. Kể từ khi được phát hành ra công chúng vào năm 2010, Spark đã trở nên phổ biến và được sử dụng trong toàn ngành với quy mô chưa từng có.
Trong kỷ nguyên của Dữ Liệu Lớn., những người thực hành cần nhiều công cụ nhanh chóng và đáng tin cậy hơn bao giờ hết để xử lý luồng dữ liệu. Các công cụ trước đây như MapReduce được yêu thích nhưng hoạt động chậm. Để khắc phục vấn đề này, Spark cung cấp một giải pháp vừa nhanh vừa có mục đích chung. Sự khác biệt chính giữa Spark và MapReduce là vậy Spark chạy các phép tính trong bộ nhớ trong thời gian sau đó trên ổ cứng. Nó cho phép truy cập và xử lý dữ liệu tốc độ cao, giảm thời gian từ nhiều giờ xuống còn vài phút.
Py là gìSpark?
PySpark là một công cụ được tạo bởi Apache Spark Cộng đồng sử dụng Python với Spark. Nó cho phép làm việc với RDD (Bộ dữ liệu phân tán linh hoạt) trong Python. Nó cũng cung cấp PySpark Vỏ để liên kết Python API với Spark cốt lõi để bắt đầu Spark Bối cảnh. Spark là công cụ tên để hiện thực hóa tính toán cụm, trong khi PySpark is Pythonthư viện của để sử dụng Spark.
Làm thế nào Spark làm việc?
Spark dựa trên công cụ tính toán, nghĩa là nó đảm nhiệm việc lập kế hoạch, phân phối và giám sát ứng dụng. Mỗi nhiệm vụ được thực hiện trên nhiều máy công nhân khác nhau được gọi là cụm máy tính. Một cụm điện toán đề cập đến việc phân chia các nhiệm vụ. Một máy thực hiện một nhiệm vụ, trong khi những máy khác đóng góp vào kết quả cuối cùng thông qua một nhiệm vụ khác. Cuối cùng, tất cả các nhiệm vụ được tổng hợp lại để tạo ra đầu ra. Các Spark quản trị viên cung cấp cái nhìn tổng quan 360 độ về nhiều loại khác nhau Spark Việc làm.
Spark được thiết kế để làm việc với
- Python
- Java
- Scala
- SQL
Một đặc điểm quan trọng của Spark là số lượng lớn thư viện tích hợp sẵn, bao gồm MLlib cho máy học. Spark cũng được thiết kế để hoạt động với các cụm Hadoop và có thể đọc nhiều loại tệp, bao gồm dữ liệu Hive, dữ liệu CSV, JSON, Casandra.
Tại sao sử dụng Spark?
Là một chuyên gia dữ liệu tương lai, bạn nên quen thuộc với các thư viện nổi tiếng của Python: Pandas và scikit-learn. Hai thư viện này rất tuyệt vời để khám phá tập dữ liệu có kích thước trung bình. Các dự án học máy thông thường được xây dựng xung quanh phương pháp sau:
- Nạp dữ liệu vào đĩa
- Nhập dữ liệu vào bộ nhớ của máy
- Xử lý/phân tích dữ liệu
- Xây dựng mô hình học máy
- Lưu trữ dự đoán trở lại đĩa
Vấn đề nảy sinh nếu nhà khoa học dữ liệu muốn xử lý dữ liệu quá lớn đối với một máy tính. Trong những ngày đầu của khoa học dữ liệu, những người thực hành sẽ lấy mẫu vì không phải lúc nào cũng cần đào tạo về các tập dữ liệu khổng lồ. Nhà khoa học dữ liệu sẽ tìm một mẫu thống kê tốt, thực hiện kiểm tra độ tin cậy bổ sung và đưa ra một mô hình xuất sắc.
Tuy nhiên, có một số vấn đề với điều này:
- Tập dữ liệu có phản ánh thế giới thực không?
- Dữ liệu có bao gồm một ví dụ cụ thể không?
- Mô hình có phù hợp để lấy mẫu không?
Lấy đề xuất của người dùng làm ví dụ. Người giới thiệu dựa vào việc so sánh người dùng với người dùng khác để đánh giá sở thích của họ. Nếu người thực hiện dữ liệu chỉ lấy một tập hợp con dữ liệu thì sẽ không có một nhóm người dùng nào giống nhau. Người đề xuất cần phải chạy trên toàn bộ tập dữ liệu hoặc không chạy chút nào.
Giải pháp là gì?
Giải pháp đã rõ ràng từ lâu, chia nhỏ vấn đề thành nhiều máy tính. Tính toán song song cũng đi kèm với nhiều vấn đề. Các nhà phát triển thường gặp khó khăn khi viết mã song song và cuối cùng phải giải quyết một loạt các vấn đề phức tạp xung quanh bản thân đa xử lý.
Pyspark cung cấp cho nhà khoa học dữ liệu một API có thể được sử dụng để giải quyết các vấn đề xử lý dữ liệu song song. Pyspark xử lý sự phức tạp của đa xử lý, chẳng hạn như phân phối dữ liệu, phân phối mã và thu thập đầu ra từ các công nhân trên một cụm máy.
Spark có thể chạy độc lập nhưng thường chạy trên nền tảng điện toán cụm như Hadoop. Tuy nhiên, trong thử nghiệm và phát triển, nhà khoa học dữ liệu có thể chạy một cách hiệu quả Spark trên hộp phát triển hoặc máy tính xách tay của họ mà không có cụm
• Một trong những ưu điểm chính của Spark là xây dựng một kiến trúc bao gồm quản lý luồng dữ liệu, truy vấn dữ liệu liền mạch, dự đoán bằng máy học và truy cập thời gian thực vào nhiều phân tích khác nhau.
• Spark hoạt động chặt chẽ với ngôn ngữ SQL, tức là dữ liệu có cấu trúc. Nó cho phép truy vấn dữ liệu theo thời gian thực.
• Công việc chính của nhà khoa học dữ liệu là phân tích và xây dựng các mô hình dự đoán. Nói tóm lại, một nhà khoa học dữ liệu cần biết cách truy vấn dữ liệu bằng cách sử dụng SQL, tạo báo cáo thống kê và sử dụng máy học để đưa ra dự đoán. Nhà khoa học dữ liệu dành một lượng thời gian đáng kể để làm sạch, chuyển đổi và phân tích dữ liệu. Sau khi tập dữ liệu hoặc quy trình làm việc dữ liệu đã sẵn sàng, nhà khoa học dữ liệu sẽ sử dụng nhiều kỹ thuật khác nhau để khám phá những hiểu biết sâu sắc và các mẫu ẩn. Thao tác dữ liệu phải mạnh mẽ và dễ sử dụng. Spark là công cụ phù hợp nhờ tốc độ và API phong phú.
Ở Py nàySpark hướng dẫn này, bạn sẽ học cách xây dựng bộ phân loại bằng PySpark ví dụ.
Cách cài đặt PySpark với AWS
Jupyter nhóm xây dựng hình ảnh Docker để chạy Spark một cách hiệu quả. Dưới đây là các bước bạn có thể làm theo để cài đặt PySpark ví dụ trong AWS.
Hãy tham khảo hướng dẫn của chúng tôi về AWS và TensorFlow
Bước 1: Tạo một phiên bản
Trước hết, bạn cần tạo một instance. Đi tới tài khoản AWS của bạn và khởi chạy phiên bản. Bạn có thể tăng dung lượng lưu trữ lên tới 15g và sử dụng nhóm bảo mật tương tự như trong hướng dẫn TensorFlow.
Bước 2: Mở kết nối
Mở kết nối và cài đặt container docker. Để biết thêm chi tiết, hãy tham khảo hướng dẫn với TensorFlow với phu bến tàu. Lưu ý rằng, bạn cần phải ở đúng thư mục làm việc.
Chỉ cần chạy các mã này để cài đặt Docker:
sudo yum update -y sudo yum install -y docker sudo service docker start sudo user-mod -a -G docker ec2-user exit
Bước 3: Mở lại kết nối và cài đặt Spark
Sau khi mở lại kết nối, bạn có thể cài đặt image chứa 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
Bước 4: Mở Jupyter
Kiểm tra thùng chứa và tên của nó
docker ps
Khởi chạy docker với nhật ký docker theo sau là tên của docker. Ví dụ: docker log zealous_goldwasser
Đi tới trình duyệt của bạn và khởi chạy Jupyter. Địa chỉ là http://localhost:8888/. Dán mật khẩu được cung cấp bởi thiết bị đầu cuối.
Chú thích: nếu bạn muốn tải lên/tải một tệp xuống máy AWS của mình, bạn có thể sử dụng phần mềm Cyberduck, https://cyberduck.io/.
Cách cài đặt PySpark on Windows/Mac với Conda
Sau đây là quy trình chi tiết về cách cài đặt PySpark on Windows/Mac sử dụng Anaconda:
Để cài đặt Spark trên máy cục bộ của bạn, cách thực hành được khuyến nghị là tạo môi trường conda mới. Môi trường mới này sẽ cài đặt Python 3.6, Spark và tất cả các phụ thuộc.
Người dùng Mac
cd anaconda3 touch hello-spark.yml vi hello-spark.yml
Windows người sử dang
cd C:\Users\Admin\Anaconda3 echo.>hello-spark.yml notepad hello-spark.yml
Bạn có thể chỉnh sửa tệp .yml. Hãy thận trọng với vết lõm. Cần có hai khoảng trắng trước –
name: hello-spark
dependencies:
- python=3.6
- jupyter
- ipython
- numpy
- numpy-base
- pandas
- py4j
- pyspark
- pytz
Lưu nó và tạo môi trường. Phải mất một thời gian
conda env create -f hello-spark.yml
Để biết thêm chi tiết về vị trí, vui lòng kiểm tra hướng dẫn Cài đặt TensorFlow
Bạn có thể kiểm tra tất cả môi trường được cài đặt trong máy của mình
conda env list
Activate hello-spark
Người dùng Mac
source activate hello-spark
Windows người sử dang
activate hello-spark
Lưu ý: Bạn đã tạo một môi trường TensorFlow cụ thể để chạy các hướng dẫn về TensorFlow. Sẽ thuận tiện hơn khi tạo một môi trường mới khác với hello-tf. Thật vô nghĩa khi quá tải hello-tf với Spark hoặc bất kỳ thư viện máy học nào khác.
Hãy tưởng tượng hầu hết dự án của bạn đều liên quan đến TensorFlow, nhưng bạn cần sử dụng Spark cho một dự án cụ thể. Bạn có thể đặt môi trường TensorFlow cho tất cả dự án của mình và tạo một môi trường riêng cho Spark. Bạn có thể thêm bao nhiêu thư viện vào Spark môi trường như bạn muốn mà không can thiệp vào môi trường TensorFlow. Một khi bạn đã làm xong với Sparkdự án của TensorFlow, bạn có thể xóa nó mà không ảnh hưởng đến môi trường TensorFlow.
Jupyter
Mở Jupyter Notebook và thử nếu PySpark hoạt động. Trong một sổ tay mới dán Py sauSpark mã mẫu:
import pyspark from pyspark import SparkContext sc =SparkContext()
Nếu một lỗi được hiển thị, có khả năng là Java không được cài đặt trên máy của bạn. Trong mac, hãy mở terminal và viết java -version, nếu có phiên bản java, hãy đảm bảo là 1.8. Trong Windows, hãy vào Ứng dụng và kiểm tra xem có Java thư mục. Nếu có một Java thư mục, kiểm tra xem Java 1.8 đã được cài đặt. Khi viết bài này, PySpark không tương thích với Java9 trở lên.
Nếu bạn cần cài đặt Java, bạn hãy suy nghĩ liên kết này và tải xuống jdk-8u181-windows-x64.exe
Đối với người dùng Mac, nên sử dụng `brew.`
brew tap caskroom/versions brew cask install java8
Tham khảo hướng dẫn từng bước này trên làm thế nào để cài đặt Java
Chú thích: Sử dụng loại bỏ để xóa hoàn toàn một môi trường.
conda env remove -n hello-spark -y
Spark Bối cảnh
SparkBối cảnh là công cụ nội bộ cho phép kết nối với các cụm. Nếu bạn muốn thực hiện một thao tác, bạn cần có một SparkBối cảnh.
Tạo ra một SparkBối cảnh
Trước hết, bạn cần bắt đầu một SparkBối cảnh.
import pyspark from pyspark import SparkContext sc =SparkContext()
Bây giờ là SparkBối cảnh đã sẵn sàng, bạn có thể tạo một bộ sưu tập dữ liệu có tên RDD, Bộ dữ liệu phân tán linh hoạt. Tính toán trong RDD được tự động song song trên toàn cụm.
nums= sc.parallelize([1,2,3,4])
Bạn có thể truy cập hàng đầu tiên bằng take
nums.take(1)
[1]
Bạn có thể áp dụng phép chuyển đổi cho dữ liệu bằng hàm lambda. Ở PySpark ví dụ dưới đây, bạn trả về bình phương của các số. Đó là sự chuyển đổi bản đồ
squared = nums.map(lambda x: x*x).collect()
for num in squared:
print('%i ' % (num))
1 4 9 16
Bối cảnh SQL
Một cách thuận tiện hơn là sử dụng DataFrame. SparkNgữ cảnh đã được đặt sẵn, bạn có thể sử dụng nó để tạo DataFrame. Bạn cũng cần khai báo SQLContext
SQLContext cho phép kết nối công cụ với các nguồn dữ liệu khác nhau. Nó được sử dụng để khởi tạo các chức năng của Spark sql.
from pyspark.sql import Row from pyspark.sql import SQLContext sqlContext = SQLContext(sc)
Bây giờ trong này Spark hướng dẫn Python, hãy tạo một danh sách các bộ dữ liệu. Mỗi bộ dữ liệu sẽ chứa tên của mọi người và tuổi của họ. Cần có bốn bước:
Bước 1) Tạo danh sách tuple với thông tin
[('John',19),('Smith',29),('Adam',35),('Henry',50)]
Bước 2) Xây dựng RDD
rdd = sc.parallelize(list_p)
Bước 3) Chuyển đổi các bộ dữ liệu
rdd.map(lambda x: Row(name=x[0], age=int(x[1])))
Bước 4) Tạo bối cảnh 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)
Nếu bạn muốn truy cập loại của từng tính năng, bạn có thể sử dụng printSchema()
DF_ppl.printSchema() root |-- age: long (nullable = true) |-- name: string (nullable = true)
Ví dụ về học máy với PySpark
Bây giờ bạn đã có ý tưởng ngắn gọn về Spark và SQLContext, bạn đã sẵn sàng xây dựng chương trình Machine learning đầu tiên của mình.
Sau đây là các bước để xây dựng chương trình Machine Learning với PySpark:
- Bước 1) Thao tác cơ bản với PySpark
- Bước 2) Tiền xử lý dữ liệu
- Bước 3) Xây dựng quy trình xử lý dữ liệu
- Bước 4) Xây dựng bộ phân loại: logistic
- Bước 5) Huấn luyện và đánh giá mô hình
- Bước 6) Điều chỉnh siêu tham số
Ở Py nàySpark Hướng dẫn về Machine Learning, chúng ta sẽ sử dụng tập dữ liệu người lớn. Mục đích của hướng dẫn này là tìm hiểu cách sử dụng Pyspark. Để biết thêm thông tin về tập dữ liệu, hãy tham khảo hướng dẫn này.
Lưu ý rằng tập dữ liệu không đáng kể và bạn có thể cho rằng quá trình tính toán mất nhiều thời gian. Spark được thiết kế để xử lý một lượng lớn dữ liệu. Sparkhiệu suất của nó tăng lên so với các thư viện máy học khác khi tập dữ liệu được xử lý ngày càng lớn hơn.
Bước 1) Thao tác cơ bản với PySpark
Trước hết, bạn cần khởi tạo SQLContext chưa được khởi tạo.
#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)
sau đó, bạn có thể đọc tệp cvs bằng sqlContext.read.csv. Bạn sử dụng inferSchema được đặt thành True để biết Spark để tự động đoán loại dữ liệu. Theo mặc định, nó được chuyển thành Sai.
df = sqlContext.read.csv(SparkFiles.get("adult_data.csv"), header=True, inferSchema= True)
Chúng ta hãy xem kiểu dữ liệu
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)
Bạn có thể xem dữ liệu bằng 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
Nếu bạn không đặt inderShema thành True thì đây là điều đang xảy ra với loại này. Có tất cả trong chuỗi.
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)
Để chuyển đổi biến liên tục theo đúng định dạng, bạn có thể sử dụng cách viết lại các cột. Bạn có thể sử dụng withColumn để nói Spark cột nào để thực hiện phép biến đổi.
# 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()
Chọn cột
Bạn có thể chọn và hiển thị các hàng có lựa chọn và tên của các tính năng. Dưới đây, tuổi và fnlwgt được chọn.
df.select('age','fnlwgt').show(5)
+---+------+ |age|fnlwgt| +---+------+ | 39| 77516| | 50| 83311| | 38|215646| | 53|234721| | 28|338409| +---+------+ only showing top 5 rows
Tính theo nhóm
Nếu bạn muốn đếm số lần xuất hiện theo nhóm, bạn có thể xâu chuỗi:
- nhómBy()
- đếm()
cùng nhau. Ở PySpark ví dụ dưới đây, bạn đếm số hàng theo trình độ học vấn.
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| +------------+-----+
Mô tả dữ liệu
Để có được số liệu thống kê tóm tắt về dữ liệu, bạn có thể sử dụng mô tả(). Nó sẽ tính toán:
- tính
- nghĩa là
- độ lệch chuẩn
- phút
- tối đa
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| +-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+
Nếu bạn muốn thống kê tóm tắt chỉ một cột, hãy thêm tên của cột bên trong mô tả()
df.describe('capital_gain').show()
+-------+------------------+ |summary| capital_gain| +-------+------------------+ | count| 32561| | mean|1077.6488437087312| | stddev| 7385.292084840354| | min| 0| | max| 99999| +-------+------------------+
Tính toán chéo bảng
Trong một số trường hợp, có thể thú vị khi xem số liệu thống kê mô tả giữa hai cột theo cặp. Ví dụ, bạn có thể đếm số người có thu nhập dưới hoặc trên 50 nghìn theo trình độ học vấn. Hoạt động này được gọi là bảng chéo.
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
Bạn có thể thấy không có người nào có doanh thu trên 50k khi còn trẻ.
Thả cột
Có hai API trực quan để thả cột:
- drop(): Thả một cột
- dropna(): Bỏ NA
Bên dưới bạn thả cột 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']
Lọc dữ liệu
Bạn có thể sử dụng filter() để áp dụng số liệu thống kê mô tả trong một tập hợp con dữ liệu. Chẳng hạn, bạn có thể đếm số người trên 40 tuổi
df.filter(df.age > 40).count()
13443
Descriptive thống kê theo nhóm
Cuối cùng, bạn có thể nhóm dữ liệu theo nhóm và tính toán các phép toán thống kê như giá trị trung bình.
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| +--------------------+------------------+
Bước 2) Tiền xử lý dữ liệu
Xử lý dữ liệu là một bước quan trọng trong học máy. Sau khi xóa dữ liệu rác, bạn sẽ nhận được một số thông tin chi tiết quan trọng.
Ví dụ, bạn biết rằng tuổi tác không phải là một hàm tuyến tính với thu nhập. Khi mọi người còn trẻ, thu nhập của họ thường thấp hơn so với tuổi trung niên. Sau khi nghỉ hưu, một hộ gia đình sử dụng tiền tiết kiệm của mình, đồng nghĩa với việc thu nhập bị giảm. Để nắm bắt mẫu này, bạn có thể thêm hình vuông vào đặc điểm tuổi
Thêm bình phương tuổi
Để thêm một tính năng mới, bạn cần:
- Chọn cột
- Áp dụng phép chuyển đổi và thêm nó vào 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)
Bạn có thể thấy age_square đã được thêm thành công vào khung dữ liệu. Bạn có thể thay đổi thứ tự của các biến bằng cách chọn. Bên dưới bạn mang age_square ngay sau tuổi.
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')
Loại trừ Hà Lan-Hà Lan
Khi một nhóm trong một đối tượng chỉ có một quan sát, nó sẽ không mang lại thông tin nào cho mô hình. Ngược lại, nó có thể dẫn đến lỗi trong quá trình xác thực chéo.
Hãy kiểm tra nguồn gốc của hộ gia đình
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
Tính năng Native_country chỉ có một hộ gia đình đến từ Hà Lan. Bạn loại trừ nó.
df_remove = df.filter(df.native_country != 'Holand-Netherlands')
Bước 3) Xây dựng quy trình xử lý dữ liệu
Tương tự như scikit-learn, Pyspark có API đường ống.
Một đường ống rất thuận tiện để duy trì cấu trúc của dữ liệu. Bạn đẩy dữ liệu vào đường ống. Bên trong đường ống, nhiều hoạt động khác nhau được thực hiện, đầu ra được sử dụng để cung cấp cho thuật toán.
Ví dụ: một phép biến đổi phổ biến trong học máy bao gồm chuyển đổi một chuỗi thành một bộ mã hóa nóng, tức là một cột theo một nhóm. Một bộ mã hóa nóng thường là một ma trận chứa đầy các số 0.
Các bước chuyển đổi dữ liệu rất giống với scikit-learn. Bạn cần phải:
- Lập chỉ mục chuỗi thành số
- Tạo một bộ mã hóa nóng
- Chuyển đổi dữ liệu
Hai API thực hiện công việc: StringIndexer, OneHotEncode
- Trước hết các bạn chọn cột chuỗi để lập chỉ mục. inputCol là tên của cột trong tập dữ liệu. đầu raCol là tên mới được đặt cho cột được chuyển đổi.
StringIndexer(inputCol="workclass", outputCol="workclass_encoded")
- Điều chỉnh dữ liệu và biến đổi nó
model = stringIndexer.fit(df) `indexed = model.transform(df)``
- Tạo các cột tin tức dựa trên nhóm. Ví dụ: nếu có 10 nhóm trong đối tượng địa lý thì ma trận mới sẽ có 10 cột, mỗi cột cho một nhóm.
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
Xây dựng đường ống
Bạn sẽ xây dựng một quy trình để chuyển đổi tất cả các tính năng chính xác và thêm chúng vào tập dữ liệu cuối cùng. Quy trình sẽ có bốn thao tác nhưng bạn có thể thoải mái thêm bao nhiêu thao tác tùy thích.
- Mã hóa dữ liệu phân loại
- Lập chỉ mục tính năng nhãn
- Thêm biến liên tục
- Tập hợp các bước.
Mỗi bước được lưu trữ trong một danh sách có tên là các giai đoạn. Danh sách này sẽ cho VectorAssembler biết thao tác nào cần thực hiện bên trong đường ống.
1. Mã hóa dữ liệu phân loại
Bước này hoàn toàn giống với ví dụ trên, ngoại trừ việc bạn lặp lại tất cả các tính năng phân loại.
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. Lập chỉ mục tính năng nhãn
Spark, giống như nhiều thư viện khác, không chấp nhận giá trị chuỗi cho nhãn. Bạn chuyển đổi tính năng nhãn bằng StringIndexer và thêm nó vào các giai đoạn danh sách
# Convert label into label indices using the StringIndexer label_stringIdx = StringIndexer(inputCol="label", outputCol="newlabel") stages += [label_stringIdx]
3. Thêm biến liên tục
inputCols của VectorAssembler là danh sách các cột. Bạn có thể tạo một danh sách mới chứa tất cả các cột mới. Mã bên dưới điền vào danh sách các tính năng phân loại được mã hóa và các tính năng liên tục.
assemblerInputs = [c + "classVec" for c in CATE_FEATURES] + CONTI_FEATURES
4. Tập hợp các bước.
Cuối cùng, bạn vượt qua tất cả các bước trong VectorAssembler
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="features")stages += [assembler]
Bây giờ tất cả các bước đã sẵn sàng, bạn đẩy dữ liệu vào quy trình.
# Create a Pipeline. pipeline = Pipeline(stages=stages) pipelineModel = pipeline.fit(df_remove) model = pipelineModel.transform(df_remove)
Nếu bạn kiểm tra tập dữ liệu mới, bạn có thể thấy rằng nó chứa tất cả các tính năng, được chuyển đổi và không được chuyển đổi. Bạn chỉ quan tâm đến nhãn mới và các tính năng. Các tính năng bao gồm tất cả các tính năng được chuyển đổi và các biến liên tục.
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}))]
Bước 4) Xây dựng bộ phân loại: logistic
Để thực hiện tính toán nhanh hơn, bạn chuyển đổi mô hình thành DataFrame.
Bạn cần chọn nhãn mới và các tính năng từ mô hình bằng bản đồ.
from pyspark.ml.linalg import DenseVector input_data = model.rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"])))
Bạn đã sẵn sàng tạo dữ liệu tàu dưới dạng DataFrame. Bạn sử dụng sqlContext
df_train = sqlContext.createDataFrame(input_data, ["label", "features"])
Kiểm tra hàng thứ hai
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
Tạo tập huấn luyện/kiểm tra
Bạn chia tập dữ liệu 80/20 bằng RandomSplit.
# Split the data into train and test sets train_data, test_data = df_train.randomSplit([.8,.2],seed=1234)
Hãy đếm xem có bao nhiêu người có thu nhập dưới/trên 50k trong cả tập huấn luyện và tập kiểm tra
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| +-----+------------+
Xây dựng bộ hồi quy logistic
Cuối cùng nhưng không kém phần quan trọng, bạn có thể xây dựng trình phân loại. Pyspark có một API có tên là LogisticRegression để thực hiện hồi quy logistic.
Bạn khởi tạo lr bằng cách chỉ ra cột nhãn và cột tính năng. Bạn đặt tối đa 10 lần lặp và thêm tham số chính quy có giá trị 0.3. Lưu ý rằng trong phần tiếp theo, bạn sẽ sử dụng xác thực chéo với lưới tham số để điều chỉnh mô hình
# 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)
#Bạn có thể thấy các hệ số từ hồi quy
# 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
Bước 5) Huấn luyện và đánh giá mô hình
Để tạo dự đoán cho bộ thử nghiệm của bạn,
Bạn có thể sử dụng LinearModel với Transform() trên test_data
# Make predictions on test data using the transform() method. predictions = linearModel.transform(test_data)
Bạn có thể in các phần tử trong dự đoán
predictions.printSchema() root |-- label: double (nullable = true) |-- features: vector (nullable = true) |-- rawPrediction: vector (nullable = true) |-- probability: vector (nullable = true) |-- prediction: double (nullable = false)
Bạn quan tâm đến nhãn hiệu, dự đoán và xác suất
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
Đánh giá mô hình
Bạn cần nhìn vào số liệu chính xác để xem mô hình hoạt động tốt (hoặc tệ) như thế nào. Hiện tại chưa có API để tính toán độ chính xác trong Spark. Giá trị mặc định là ROC, đường cong đặc tính vận hành máy thu. Đó là một số liệu khác có tính đến tỷ lệ dương tính giả.
Trước khi nhìn vào ROC, hãy xây dựng thước đo độ chính xác. Bạn quen thuộc hơn với số liệu này. Thước đo độ chính xác là tổng của dự đoán đúng trên tổng số quan sát.
Bạn tạo một DataFrame với nhãn và `dự đoán.
cm = predictions.select("label", "prediction")
Bạn có thể kiểm tra số lớp trong nhãn và dự đoán
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| +----------+-----------------+
Ví dụ: trong bộ thử nghiệm, có 1578 hộ gia đình có thu nhập trên 50 nghìn và 5021 hộ ở dưới. Tuy nhiên, bộ phân loại dự đoán 617 hộ gia đình có thu nhập trên 50 nghìn.
Bạn có thể tính toán độ chính xác bằng cách tính số lượng khi nhãn được phân loại chính xác trên tổng số hàng.
cm.filter(cm.label == cm.prediction).count() / cm.count()
0.8237611759357478
Bạn có thể gói mọi thứ lại với nhau và viết một hàm để tính toán độ chính xác.
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%
Số liệu ROC
Mô-đun Đánh giá phân loại nhị phân bao gồm các thước đo ROC. Người nhận OperaĐường cong đặc tính là một công cụ phổ biến khác được sử dụng với phân loại nhị phân. Nó rất giống với đường cong độ chính xác/thu hồi, nhưng thay vì vẽ đồ thị độ chính xác so với thu hồi, đường cong ROC hiển thị tỷ lệ dương thực (tức là thu hồi) so với tỷ lệ dương tính giả. Tỷ lệ dương tính giả là tỷ lệ các trường hợp âm tính được phân loại không chính xác thành dương tính. Nó bằng một trừ đi tỷ lệ âm thực sự. Tỷ lệ âm thực sự còn được gọi là độ đặc hiệu. Do đó, đường cong ROC biểu thị độ nhạy (thu hồi) so với 1 – độ đặc hiệu
### Use ROC from pyspark.ml.evaluation import BinaryClassificationEvaluator # Evaluate model evaluator = BinaryClassificationEvaluator(rawPredictionCol="rawPrediction") print(evaluator.evaluate(predictions)) print(evaluator.getMetricName())
0.8940481662695192khu vựcDướiROC
print(evaluator.evaluate(predictions))
0.8940481662695192
Bước 6) Điều chỉnh siêu tham số
Cuối cùng nhưng không kém phần quan trọng, bạn có thể điều chỉnh các siêu tham số. Tương tự như học scikit bạn tạo một lưới tham số và thêm các tham số bạn muốn điều chỉnh.
Để giảm thời gian tính toán, bạn chỉ điều chỉnh tham số chính quy hóa chỉ với hai giá trị.
from pyspark.ml.tuning import ParamGridBuilder, CrossValidator
# Create ParamGrid for Cross Validation
paramGrid = (ParamGridBuilder()
.addGrid(lr.regParam, [0.01, 0.5])
.build())
Cuối cùng, bạn đánh giá mô hình bằng phương pháp xác định chéo 5 lần. Mất khoảng 16 phút để đào tạo.
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)
Thời gian huấn luyện mô hình: 978.807 giây
Siêu tham số chính quy tốt nhất là 0.01, với độ chính xác là 85.316%.
accuracy_m(model = cvModel) Model accuracy: 85.316%
Bạn có thể trích xuất tham số được đề xuất bằng cách nối chuỗi cvModel.bestModel với 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}
Tổng kết
Spark là một công cụ cơ bản cho một nhà khoa học dữ liệu. Nó cho phép người thực hành kết nối ứng dụng với các nguồn dữ liệu khác nhau, thực hiện phân tích dữ liệu một cách liền mạch hoặc thêm mô hình dự đoán.
Đầu tiên là Spark, bạn cần bắt đầu một Spark Bối cảnh với:
'SparkBối cảnh()'
và và SQL bối cảnh để kết nối với nguồn dữ liệu:
'SQLContext()'
Trong hướng dẫn này, bạn tìm hiểu cách đào tạo hồi quy logistic:
- Chuyển đổi tập dữ liệu thành Dataframe với:
rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"]))) sqlContext.createDataFrame(input_data, ["label", "features"])
Lưu ý rằng tên cột của nhãn là newlabel và tất cả các tính năng đều được tập hợp trong các tính năng. Thay đổi các giá trị này nếu khác trong tập dữ liệu của bạn.
- Tạo tập huấn luyện/kiểm tra
randomSplit([.8,.2],seed=1234)
- Đào tạo mô hình
LogisticRegression(labelCol="label",featuresCol="features",maxIter=10, regParam=0.3)
lr.fit()
- Đưa ra dự đoán
linearModel.transform()