Spark期末
1. spark单词统计示例程序local运行模式示例
这段可以不看，考PySpark 这段代码是java写的，看另一篇文章那个
public class WordCountLocal {
public static void main(String[] args) {
String str = countWord("D:/var/hello.txt");
try {
FileTools.writeInFile(new File("D:/var/count.txt"), str, false);
} catch (Exception e) {
e.printStackTrace();
}
}
public static String countWord(String filePath) {
// 初始化 SparkConf setAppName:设置应用名称 setMaster:设置运行模式
SparkConf conf = new SparkConf().setMaster("local[3]").setAppName("WordCountLocal");
// 初始化 SparkContext对象
JavaSparkContext jsc = new JavaSparkContext(conf);
// 使用SparkContext对象读取文件，存为JavaRdd
JavaRDD<String> dataRdd = jsc.textFile(filePath);
//每一行都分割成单词，返回单词集合
JavaRDD<String> flatMapRdd = dataRdd.flatMap(strTxt -> Arrays.asList(strTxt.split(" ")).iterator());
// 使用mapToPair进行map操作 key是单词，value是1
JavaPairRDD<String, Integer> mapRdd = flatMapRdd.mapToPair(word -> new Tuple2<>(word, 1));
// 使用reduceByKey进行单词统计 返回 （word，CountSum）
JavaPairRDD<String, Integer> res = mapRdd.reduceByKey((a, b) -> a +b);
//先将key和value倒过来，再按照key排序
JavaPairRDD<Integer, String> sortsTpl = res.mapToPair(tpl -> new Tuple2<>(tpl._2(), tpl._1())).sortByKey(false);
//取前10个
List<Tuple2<Integer, String>> top10 = sortsTpl.take(10);
StringBuilder resultSb = new StringBuilder();
//打印出来
for(Tuple2<Integer, String> tuple2 : top10){
String str = tuple2._2() + "\t" + tuple2._1() + "\n";
resultSb.append(str);
}
//关闭context
jsc.close();
return resultSb.toString();
}
}
2. PySpark操作
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("LearnPySpark").getOrCreate()
dfGrade=spark.read.format("json").load ("file:/media/z/win10/2023下-重师/spark分布式/sparksqlLearn/data/people.json")
#dfGrade.show(3)
dfGrade.select(dfGrade.name,dfGrade.age).show()
#为数据增加一列
new=dfGrade.withColumn('work', dfGrade.age+10000)
new=dfGrade.withColumn('address', dfGrade.age+10000)
#垂直显示1条记录
new.show(1,vertical=True)
print(new.columns)
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("LearnPySpark").getOrCreate()
df1 = spark.createDataFrame([("ZhangSan", 86,88), ("LiSi",90,85)]).toDF("name", "Java","Python")
df2 = spark.createDataFrame([("ZhangSan", 86,88), ("LiSi",90,85), ("WangWU", 86,88), ("WangFei",90,85)]).toDF("name","Java","Scala")
# 显示订单总数量最少的3个地点
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("LearnSpark").getOrCreate()
order = spark.read.csv("file:/media/z/win10/2023下-重师/spark分布式/sparksqlLearn/test/tbStock.txt",header=False,inferSchema=True)
order2 = order.toDF('orderid','place','date')
order2.show(3)
a = order2.groupby('place').count()
b = a.orderBy('count',ascending=True).limit(3)
b.show()
#c=b.first()
quit()
# 修改以上程序，显示所涉产品数量最大前10个订单的订单号和所涉产品数量
from pyspark.sql import SparkSession
spark = SparkSession.builder .appName("LearnSpark").getOrCreate()
order = spark.read.csv("/media/z/win10/2023下-重师/spark分布式/sparksqlLearn/test/tbStockDetail.txt",header=False,inferSchema=True)
order2 = order.toDF('orderid','rownum','ltemid','qty','price','amount')
#order2.show(3)
#a = order2.groupby('date').count()
#b=a.orderBy('count',ascending=False)
#b.show(1)
#order2.show(3)
a = order2.groupby('orderid').sum("qty")
#a.show(10)
b = a.orderBy('sum(qty)',ascending=False)
b.show(10)
quit()
# 分析并显示每年总订单数，按总订单数从高到底排序
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("LearnPySpark").getOrCreate()
df1=spark.read.csv("tbDate.txt",header=True,inferSchema=True).toDF('dateid','yearmonth','year','month','date','week','weeks','quot','tenday','halfmonth')
df2=spark.read.csv("tbStock.txt",header=True,inferSchema=True).toDF('orderid','place','dateid')
df3=spark.read.csv("tbStockDetail.txt",header=True,inferSchema=True).toDF('orderid','rownum','itemid','qty','price','amount')
df1.createOrReplaceTempView("tbDate")
df2.createOrReplaceTempView('tbStock')
df3.createOrReplaceTempView('tbStockDetail')
# queryA="select tbDate.dateid from tbDate , tbStock where tbDate.dateid=tbStock.dateid "
# queryB="select tbStock.dateid, count(tbStock.orderid) as dingDanShu from tbStock group by(tbStock.dateid) order by dingDanShu Desc"
queryC="select tbDate.year, count(tbStock.orderid) as zongDingDanShu from tbDate , tbStock where tbDate.dateid=tbStock.dateid group by(tbDate.year) order by zongDingDanShu Desc"
sqlResultA=spark.sql( queryC ).limit( 33 )
sqlResultA.show(2333333)
#统计有病人数
from pyspark.sql import SparkSession
from pyspark.sql import functions as f
spark = SparkSession.builder.appName("LearnPySpark").getOrCreate()
df = spark.read.csv("ill.csv",header = True , inferSchema = True)
df.printSchema()
df2 = df.filter(df["Outcome"] == 1).count()
print(df2)
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("LearnPySpark" ).getOrCreate()
df=spark.read.csv("ill.csv" , header=False, inferSchema=True).toDF( 'Pre' , 'Glu' , 'Blo','Ski','Ins','BMI','Dia','Age','Out')
df.createOrReplaceTempView('ill')
df.groupby('Out').count().show()
补充一些平时的课后练习(部分)
# 导入PySpark库，这是Apache Spark的Python API。
import pyspark
# 导入SparkContext和SparkConf类。SparkContext是Spark应用程序的入口点，而SparkConf用于配置Spark应用程序。
from pyspark import SparkContext, SparkConf
# 创建一个SparkConf对象，并设置应用程序的名称和运行模式。这里，应用程序的名称为"test"，运行模式为"local[1]"，意味着在本地模式下运行，使用一个线程。
conf = SparkConf().setAppName("test").setMaster("local[1]")
# 使用创建的SparkConf对象来创建一个SparkContext对象。SparkContext用于在集群中执行操作。
sc = SparkContext(conf = conf)
# 这行代码被注释掉了，但如果取消注释，它将打印PySpark的版本信息。
# print("spark version is:",pyspark.__version__)
# 这行代码被注释掉了，但如果取消注释，它将从本地文件系统中读取一个文件，并将其作为RDD（弹性分布式数据集）返回。
# textFile = sc.textFile("file://home/zhangsan/Code/Python/spark4.py")
# 使用SparkContext的parallelize方法将一个Python列表转换为一个RDD（弹性分布式数据集）。这里，列表包含了一些编程语言的名称。
rdd1 = sc.parallelize(['scala','java','hadoop','python','pyspark','java','java','scala'])
# 使用count方法计算RDD中的元素数量。这里，它会返回8，因为列表中有8个不同的元素。
result = rdd1.count()
print(result)
# 使用collect方法将RDD中的所有元素收集到一个Python列表中。这里，它会返回列表 ['scala', 'java', 'hadoop', 'python', 'pyspark', 'java', 'java', 'scala']。
collect1 = rdd1.collect()
print(collect1)
# 使用filter方法对RDD中的元素进行过滤，只保留包含'py'字符串的元素。这里，它会返回列表 ['python', 'pyspark']。
m = rdd1.filter(lambda x:'py' in x).collect()
print(m)
# 使用map方法对RDD中的每个元素应用一个函数，这里是将每个元素映射为一个元组 (元素, 1)。这里，它会返回一个元组的列表，每个元组包含一个元素和1。
n = rdd1.map(lambda x:(x,1)).collect()
print(n)
# 导入PySpark库，这是Apache Spark的Python API。
import pyspark
# 导入operator模块，它包含了一些用于操作数据的函数，比如这里用到的add函数。
import operator
# 导入SparkContext和SparkConf类。SparkContext是Spark应用程序的入口点，而SparkConf用于配置Spark应用程序。
from pyspark import SparkContext, SparkConf
# 创建一个SparkConf对象，并设置应用程序的名称和运行模式。这里，应用程序的名称为"test"，运行模式为"local[1]"，意味着在本地模式下运行，使用一个线程。
conf = SparkConf().setAppName("test").setMaster("local[1]")
# 使用创建的SparkConf对象来创建一个SparkContext对象。SparkContext用于在集群中执行操作。
sc = SparkContext(conf = conf)
# 这行代码被注释掉了，但如果取消注释，它将打印PySpark的版本信息。
# print("spark version is:",pyspark.__version__)
# 使用SparkContext的parallelize方法将一个Python列表转换为一个RDD（弹性分布式数据集）。这里，列表包含了一些数字，每隔三个数字取一个值，从1开始。
rdd1 = sc.parallelize(range(1,11,3))
# 使用collect方法将RDD中的所有元素收集到一个Python列表中。这里，它会返回一个包含[1, 4, 7, 10]的列表。
collect1 = rdd1.collect()
print(collect1)
# 使用reduce方法对RDD中的元素进行归约操作，这里使用的是operator.add函数，即把所有元素加起来。这里，它会返回32，因为1+4+7+10=22，再加最后一个元素10，总和为32。
s = rdd1.reduce(operator.add)
print(s)
import pyspark # 导入pyspark库，用于使用Apache Spark的大数据功能。
import operator # 导入operator模块，这个模块包含一些可以操作序列和集合的函数。
from pyspark import SparkContext, SparkConf # 从pyspark库中导入SparkContext和SparkConf类。
conf = SparkConf().setAppName("test").setMaster("local[1]") # 创建一个SparkConf对象，并设置应用程序的名称和运行模式。这里的应用名称为"test"，运行模式为"local[1]"，表示在本地模式下运行，使用一个线程。
sc = SparkContext(conf = conf) # 使用创建的SparkConf对象来创建一个SparkContext对象。SparkContext是用来在集群中执行操作的。
# print("spark version is:",pyspark.__version__) # 这行代码被注释掉了，但如果取消注释，它会打印PySpark的版本信息。
rdd1 = sc.parallelize([1,3,3,5,7,3,7,9,9,1]) # 使用SparkContext的parallelize方法将一个Python列表转换为一个RDD（弹性分布式数据集）。这里，列表包含了一些数字。
collect1 = rdd1.collect() # 使用collect方法将RDD中的所有元素收集到一个Python列表中。这里，它会返回一个包含[1, 3, 3, 5, 7, 3, 7, 9, 9, 1]的列表。
print(collect1) # 打印collect1的值。
s = rdd1.distinct().collect() # 使用distinct方法对RDD中的元素进行去重操作，然后使用collect方法将结果收集到一个Python列表中。这里，它会返回一个包含[1, 3, 5, 7, 9]的列表。
print(s) # 打印s的值。
rdd1 = sc.parallelize([1,3,3,5,7,3,7,9,9,1]) # 使用SparkContext的parallelize方法将一个Python列表转换为一个RDD（弹性分布式数据集）。这里，列表包含了一些数字。
rdd2 = sc.parallelize([11,22,33,44]) # 使用SparkContext的parallelize方法将另一个Python列表转换为一个RDD（弹性分布式数据集）。这里，列表包含了一些整数。
collect1 = rdd1.collect() # 使用collect方法将RDD rdd1中的所有元素收集到一个Python列表中。这里，它会返回一个包含[1, 3, 3, 5, 7, 3, 7, 9, 9, 1]的列表。
print(collect1) # 打印collect1的值。
collect2 = rdd2.collect() # 使用collect方法将RDD rdd2中的所有元素收集到一个Python列表中。这里，它会返回一个包含[11, 22, 33, 44]的列表。
print(collect2) # 打印collect2的值。
# 创建一个Spark配置对象，并设置应用程序的名称为"test"，运行模式为"local[1]"，即在本地模式下运行，使用一个线程。
conf = SparkConf().setAppName("test").setMaster("local[1]")
# 使用上述配置创建一个SparkContext对象，这是与Spark集群的入口点。
sc = SparkContext(conf = conf)
# 使用SparkSession的builder创建一个新的SparkSession或获取一个已存在的SparkSession。这里的appName为"LearnSpark"。
spark = SparkSession.builder.appName("LearnSpark").getOrCreate()
# 使用Spark的read方法从CSV文件读取数据，并设置header=True来识别第一行是标题行，inferSchema=True来自动推断每列的数据类型。
df = spark.read.csv("bank.csv",header=True,inferSchema=True)
# 取消了以下两行代码，这两行代码原本用于按'Age'列对数据框进行排序。
# df = df.sort('Age',ascending=True)
# df = df.orderBy(df.Age.asc())
# 选择数据框的前5行。
list1 = df.head(5)
# 将这5行的数据转换为RDD。
rdd1 = sc.parallelize(list1)
# 将RDD转换为DataFrame。
df = rdd1.toDF()
# 显示数据框的内容。
df.show()
# 显示'Age'列的统计摘要，包括平均值。
df.select('Age').summary('mean').show()
from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StructField, StringType, IntegerType
spark = SparkSession.builder.appName("LearnPySpark").getOrCreate()
# 定义第一个数据结构schema1，它包含多个字段，每个字段都有名称和数据类型。True表示字段是否可以包含null值。
schema1 = StructType([
StructField('Dateid', StringType(), True),
StructField('Theyearmonth', IntegerType(), True),
StructField('Theyear', IntegerType(), True),
StructField('Themonth', IntegerType(), True),
StructField('Thedate', IntegerType(), True),
StructField('Theweek', IntegerType(), True),
StructField('theweeks', IntegerType(), True),
StructField('thequot', IntegerType(), True),
StructField('thetenday', IntegerType(), True),
StructField('thehalfmonth', IntegerType(), True),
])
# 定义第二个数据结构schema2，它包含多个字段，每个字段都有名称和数据类型。True表示字段是否可以包含null值。
schema2 = StructType([
StructField('Ordernumber', StringType(), True),
StructField('Locationid', StringType(), True),
StructField('Dateid', StringType(), True),
])
# 定义第三个数据结构schema3，它包含多个字段，每个字段都有名称和数据类型。True表示字段是否可以包含null值。
schema3 = StructType([
StructField('Ordernumber', StringType(), True),
StructField('Rowid', IntegerType(), True),
StructField('Itemid', StringType(), True),
StructField('Qty', IntegerType(), True),
StructField('Price', IntegerType(), True),
StructField('Amount', IntegerType(), True),
])
df1 = spark.read.csv("tbDate.txt",header=False,schema=schema1,inferSchema=True)
df2 = spark.read.csv("tbStock.txt",header=False,schema=schema2,inferSchema=True)
df3 = spark.read.csv("tbStockDetail.txt",header=False,schema=schema3,inferSchema=True)
df = df1.join(df2,'Dateid','inner')
df = df.join(df3,'Ordernumber','inner')
# test1 使用sparksql分析订单数量最多的日期(年月日)，当天订单数是多少?
df.orderBy('Qty',ascending=False).select('Dateid','Qty').show(1)
# test2 使用sparksql分析所有订单总额最高的是哪一天，当天订单总额是多少
df.orderBy('Amount',ascending=False).select('Dateid','Amount').show(1)
# test3 所有交易历史记录中，最热门的 货品 是什么(即销量最高的货品)
df.groupBy('Itemid').sum("Qty").orderBy('sum(Qty)',ascending=False).show(1)
# test3 年订单数排序
df.groupBy('Theyear').sum("Qty").orderBy('sum(Qty)',ascending=False).show()
# test4 所有交易历史记录中，最热门的 货品 是什么(即销量最高的货品)
df.groupBy('Itemid').sum("Qty").orderBy('sum(Qty)',ascending=False).show(1)
# test5 单价400-500的货品有几种
print(df.select('Price','Itemid').where('Price >= 400 and Price <=500').count())
程序阅读题重点
# 使用iris.csv数据集建立鸢欺尾花分类模型，将数据集划分为8:2的训练集和测试集，使用逻辑回归模型，查看模型预测的准确率
from pyspark.sql import SparkSession
from pyspark.ml.feature import VectorAssembler
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
from pyspark.sql import functions as F
# 创建SparkSession
spark = SparkSession.builder.appName("LearnSparkML").getOrCreate()
# 读取iris.csv数据集
df = spark.read.csv("iris.csv", header=True, inferSchema=True)
# 显示数据集
df.show()
# 定义有用的特征列
usefulFeature = ['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width']
# 创建一个VectorAssembler对象，将有用的特征列转换为向量列
assembler = VectorAssembler(inputCols=usefulFeature, outputCol="features")
# 将数据集转换为适合逻辑回归模型的格式(特征向量)
goodData = assembler.transform(df)
goodData.show()
# 使用randomSplit函数将数据集划分为训练集和测试集，比例为8:2
(train, test) = goodData.randomSplit([0.8, 0.2], seed=1999)
# 打印训练集和测试集的统计信息
print('训练集统计：', train.count())
print('测试集统计：', test.count())
# 创建逻辑回归模型对象，并使用训练集进行训练
modelA = LogisticRegression(featuresCol='features', labelCol='Species', maxIter=50)
goodModel = modelA.fit(train)
# 使用训练得到的模型对测试集进行预测(将模型应用于新的数据集,达到转换或预测的目的)
yuce = goodModel.transform(test)
yuce.show()
# 创建多分类分类器评估对象，并使用准确率作为评价指标
evaluator = MulticlassClassificationEvaluator(labelCol='Species', metricName='accuracy')
# 评估模型的准确率
zhunQueLv = evaluator.evaluate(yuce)
print('逻辑回归模型准确率：', zhunQueLv)
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("LearnPySpark").getOrCreate()
df = spark.read.csv("breast_cancer.csv",header = True, inferSchema=True)
#df = df.drop('Species')
#df.show()
usefulFeature = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','AA','AB','AC','AD']
from pyspark.ml.feature import VectorAssembler
# 创建一个VectorAssembler对象，将有用的特征列转换为向量列
assembler = VectorAssembler(inputCols=usefulFeature,outputCol='features')
# 将数据集转换为特征向量
goodData=assembler.transform(df)
print('得到的assemble后的数据')
goodData.show()
# 使用randomSplit函数将数据集划分为训练集和测试集，比例为8:2
(train,test)=goodData.randomSplit([0.9,0.1],seed=1999)
print( '训练集统计：', train.count() )
print( '测试集统计：', test.count() )
print('逻辑回归模型训练：')
from pyspark.ml.classification import LogisticRegression
modelA=LogisticRegression(featuresCol='features', labelCol='AE',maxIter=50)
goodModel=modelA.fit(train)
yuce=goodModel.transform(test)
#print(yuce.rawPrediction)
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
# 创建多分类分类器评估对象，并使用准确率作为评价指标
evaluator=MulticlassClassificationEvaluator(labelCol='AE',metricName='accuracy')
zhuQueLv=evaluator.evaluate(yuce)
print('逻辑回归模型准确率：',zhuQueLv)
print('\n\n随机森林模型训练：')
from pyspark.ml.classification import RandomForestClassifier
modelForest = RandomForestClassifier(labelCol='AE', featuresCol='features',maxDepth=5)
goodModel = modelForest.fit(train)
yuce = goodModel.transform(test)
zhunQueLv=evaluator.evaluate(yuce)
print('随机森林模型准确率：',zhunQueLv)
print('\n\n梯度提升树：')
from pyspark.ml.classification import GBTClassifier
modelGbt = GBTClassifier(labelCol = 'AE',featuresCol='features')
goodModel = modelGbt.fit(train)
yuce = goodModel.transform(test)
zhunQueLv=evaluator.evaluate(yuce)
print('梯度提升树准确率：',zhunQueLv)
quit()
import pyspark
import operator
from pyspark import SparkContext, SparkConf
conf = SparkConf().setAppName("test").setMaster("local[1]")
sc = SparkContext(conf = conf)
rdd1= sc.textFile("tosort2.txt")
rdd2 = rdd1.map(lambda x: int(x))
result = rdd2.sortBy(lambda x: x, ascending=False).collect()
print(result)
# als协同过滤
from pyspark.sql import SparkSession
from pyspark.ml.evaluation import RegressionEvaluator
from pyspark.ml.recommendation import ALS
from pyspark.sql import Row
# 创建一个SparkSession对象，它是与Spark功能的入口点。如果已经存在一个SparkSession，则使用现有的，否则创建一个新的。
spark = SparkSession.builder.getOrCreate()
# 使用Spark的read方法读取一个文本文件，并将其内容作为一个RDD（弹性分布式数据集）返回。
lines = spark.read.text("sample_movielens_ratings.txt").rdd
# 使用map函数对RDD中的每一行进行处理。这里，处理是将每行的"::"分隔符将行值分割成一个列表。
parts = lines.map(lambda row: row.value.split("::"))
# 对上一步得到的列表进行进一步处理，将其转换为包含用户ID、电影ID、评分和时间戳的Row对象。
ratingsRDD = parts.map(lambda p: Row(userId=int(p[0]), movieId=int(p[1]), rating=float(p[2]), timestamp=int(p[3])))
# 使用Spark的createDataFrame方法将上一步得到的Row对象的RDD转换为DataFrame。
ratings = spark.createDataFrame(ratingsRDD)
# 使用randomSplit方法将数据随机划分为训练集和测试集，其中90%的数据用于训练，10%的数据用于测试。
(training, test) = ratings.randomSplit([0.9, 0.1])
# 创建一个交替最小二乘法（ALS）模型对象，其中maxIter是最大迭代次数，regParam是正则化参数，userCol、itemCol和ratingCol分别表示用户、物品和评分的列名。
als = ALS(maxIter=5, regParam=0.01, userCol="userId", itemCol="movieId", ratingCol="rating",coldStartStrategy="drop")
# 使用fit方法训练上一步创建的ALS模型。
model = als.fit(training)
# 使用transform方法将训练好的模型应用到测试集上，得到预测结果。
predictions = model.transform(test)
# 创建一个回归评估器对象，其中metricName是评价标准（均方根误差），labelCol是实际的评分列名，predictionCol是预测的评分列名。
evaluator = RegressionEvaluator(metricName="rmse", labelCol="rating", predictionCol="prediction")
# 使用evaluate方法计算预测结果的均方根误差。
rmse = evaluator.evaluate(predictions)
# 打印均方根误差。
print(str(rmse))
# als协同过滤并推荐
from pyspark.sql import SparkSession
from pyspark.ml.evaluation import RegressionEvaluator
# 创建一个SparkSession对象，这是与Spark功能的入口点。如果已经存在一个SparkSession，则使用现有的，否则创建一个新的。
spark = SparkSession.builder.appName('learnSparkML').getOrCreate()
# 导入ALS算法，用于协同过滤推荐。
from pyspark.ml.recommendation import ALS
# 使用Spark的read方法读取一个文本文件，并返回其RDD（弹性分布式数据集）。
lines = spark.read.text('sample_movielens_ratings.txt').rdd
# 导入Row类，用于创建具有多个字段的数据行。
from pyspark.sql import Row
# 使用map函数对RDD中的每一行进行处理。这里，处理是将每行的"::"分隔符将行值分割成一个列表。
parts = lines.map(lambda row: row.value.split('::'))
# 对上一步得到的列表进行进一步处理，将其转换为包含用户ID、电影ID、评分和时间戳的Row对象。
ratingsRDD = parts.map(lambda p: Row(userId=int(p[0]), movieId=int(p[1]), rating=float(p[2]), timestamp=int(p[3])))
# 使用Spark的createDataFrame方法将上一步得到的Row对象的RDD转换为DataFrame。
ratings = spark.createDataFrame(ratingsRDD)
# 使用randomSplit方法将数据随机划分为训练集和测试集，其中90%的数据用于训练，10%的数据用于测试。
(training, test) = ratings.randomSplit([0.9, 0.1])
# 创建一个ALS模型对象，其中maxIter是最大迭代次数，regParam是正则化参数，userCol、itemCol和ratingCol分别表示用户、物品和评分的列名。
als = ALS(maxIter=8, regParam=0.01, userCol='userId', itemCol='movieId', ratingCol='rating', coldStartStrategy='drop')
# 使用fit方法训练上一步创建的ALS模型。
model = als.fit(training)
# 使用transform方法将训练好的模型应用到测试集上，得到预测结果。
predictions = model.transform(test)
# 创建一个回归评估器对象，其中metricName是评价标准（均方根误差），labelCol是实际的评分列名，predictionCol是预测的评分列名。
evaluator = RegressionEvaluator(metricName='rmse', labelCol='rating', predictionCol='prediction')
# 使用evaluate方法计算预测结果的均方根误差。
rmse = evaluator.evaluate(predictions)
# 打印均方根误差。
print(str(rmse))
# 为每个用户推荐10部电影:
print('为每个用户推荐10部电影:')
userRecs = model.recommendForAllUsers(10)
userRecs.show()
# 为每部电影推荐10个用户:
print('为每部电影推荐10个用户:')
movieRecs = model.recommendForAllItems(10)
movieRecs.show()
# 为具体用户推荐10部电影:
print('为具体用户推荐10部电影:')
users = ratings.select(als.getUserCol()).distinct().limit(3) # 选择前三个不同的用户ID。
userSubsetRecs = model.recommendForUserSubset(users, 10) # 为这3个用户推荐10部电影。
userSubsetRecs.show() # 显示结果。
# 为电影集推荐10个用户:
print('为电影集推荐10个用户:')
movies = ratings.select(als.getItemCol()).distinct().limit(3) # 选择前三个不同的电影ID。
movieSubSetRecs = model.recommendForItemSubset(movies, 10) # 为这3部电影推荐10个用户。
movieSubSetRecs.show() # 显示结果。
8038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
