• Yarn 模式 与 电影受众分析系统

    Yarn 模式 与 电影受众分析系统

     http://www.cnblogs.com/liuwei6/p/6627750.html

    yarn模式分为两种模式：

    一、Yarn-cluster模式

          1、通过spark-submit提交spark jar包（Application）,与RM进行通信请求启动AM

          2、RM接收到请求之后，会在一个相对空闲的nodemanager中分配Container,然后再此Container中启动AM

          3、AM启动之后，会向RM进行通信，请求资源用于启动nodemagaer(相当于Worker）节点中的Executor

          4、RM分配一批Container容器到NM中，用于启动Executor

          5、AM与其他NM（worker）进行通信，启动Executor

          6、executor启动之后，就会向AM（Driver）进行反注册

          7、接下来的执行流程，就与Standalone模式的执行流程是一样的

    二、Yarn-Client模式

           1、通过spark-submit提交spark jar包（Application）,与RM进行通信请求启动AM，并且在客户端本地启动Driver进程

           2、RM接收到请求之后，会在一个相对空闲的nodemanager中分配Container,然后再此Container中启动AM

           3、AM启动之后，会向RM进行通信，请求资源用于启动nodemagaer(相当于Worker）节点中的Executor

           4、RM分配一批Container容器到NM中，用于启动Executor

           5、AM与其他NM（worker）进行通信，启动Executor

           6、Executor启动之后，就会向客户端本地的Driver进行反注册。

           7、接下来的执行流程，就与Standalone模式的执行流程是一样的。

    三、总结：

         经过上面的描述，yarn-cluster与yarn-client模式有一个很大的区别，就是Driver进程所运行的位置。

         在yarn-cluster模式中，Driver运行在AM所在节点上

         在yarn-client模式中，Driver运行在客户端本地上

         在yarn-client模式中，由于Driver运行在客户端本地，如果运行中出现Bug,那么可以在本地直接通过查Log日志来判定Bug的原因，从而对程序进行调整。

         在yarn-client模式中，由于Driver运行在AM所在节点上，如果运行中出现BUG，只能通过集群中产生的Log日志进行判定，需要用到application_id来进行查找log,过程比较麻烦。

        综上所述，yarn-client模式便于排错，一般用于测试环境，而yarn-cluster模式一般用于真实的生产环境中。

    案例分析：Spark项目案例-电影受众分析系统 

    一、 数据结构
     users.dat：
          UserID::Gender::Age::Occupation（ 职业） ::Zip-code（ 邮政编码）
     movies.dat
          MovieID::Title::Genres（ 题材）
    ratings.dat
          UserID::MovieID::Rating::Timestamp

    二、 功能需求
     1、 看过“ Lord of the Rings,The(1978) ” 用户年龄和性别分布
     2、 年龄段在“ 18-24” 的男性年轻人， 最喜欢看哪10部电影
     3、 得分最高的10部电影
     4、 看过电影最多的前10个人
     5、 女性看过最多的10部电影
     6、 男性看过最多的10部电影
     7、 年龄段在“ 45-49” 的男性观众中， 得分最高的10部电影名称
     8、 1995年最受欢迎的前3部电影的用户年龄和性别数量分布

        9、moiveid=2116这部电影各年龄段的平均影评（年龄段，平均影评分）

       10、统计最喜欢看电影的那位女士最喜欢的10部电影，观众对他们的平均影评分（电影名，影评）

    1、

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    object MovieDemo {
      var sc:SparkContext=null
      def main(args: Array[String]): Unit = {
        val conf=new SparkConf().setAppName("MovieDemo")
                  .setMaster("local")
        sc=new SparkContext(conf)
        ageAndSexCount
      }
     
      /**
        * @param sc SparkContext对象
        * @return 返回用户信息
        */
      def getUsers(sc:SparkContext):RDD[Array[String]]={
        val scobj=sc
        val users=scobj.textFile("file:///home/tg/datas/users.dat")
                      .map(_.split("::"))
        users
      }
     
      /**
        * @param sc
        * @return 返回电影信息
        */
      def getMovies(sc:SparkContext):RDD[Array[String]]={
        val scobj=sc
        val movies=scobj.textFile("file:///home/tg/datas/movies.dat")
                    .map(_.split("::"))
        movies
      }
     
      /**
        *
        * @param sc
        * @return 电影评分信息
        */
      def getRatings(sc:SparkContext):RDD[Array[String]]={
        val scobj=sc
        val ratings=scobj.textFile("file:///home/tg/datas/ratings.dat")
                  .map(_.split("::"))
        ratings
      }
     
      /**
        * 看过“Lord of the Rings,The (1978) ”用户年龄和性别(数量)分布
        */
      def ageAndSexCount: Unit ={
        //获取“Lord of the Rings,The (1978) ”这部电影的movieId
        val movies=getMovies(sc)
        val movieId=movies.filter(x=>x.length==3 && x(1).equals("Lord of the Rings, The (1978)"))
                  .map(x=>x(0).trim).toArray()(0)
        //从users.dat中获取所有user的(userid,(age,gender))
        val users=getUsers(sc)
        val usersRDD=users.map(x=>{
          (x(0),(x(2),x(1))) //(userid,(age,gender))
        })
        //获取看过"Lord of the Rings,The (1978)"这部电影的(userid,movieid)
        val ratings=getRatings(sc)
        val ratingRDD=ratings.map(x=>{
          (x(0),x(1)) //ratings数据中所有的(userid,movieid)
        }).filter(x=>x._2.equals(movieId))
     
        //将ratingRDD和usersRDD进行join操作，结果<userid,(movieid,(age,gender))>
        val userratingRDD=ratingRDD.join(usersRDD)
        println("看过“Lord of the Rings,The (1978) ”用户年龄和性别(数量)分布")
        userratingRDD.map(x=>{
          (x._2._2,1)
        }).reduceByKey(_+_)
          .foreach(println(_))
      }
    }

    2、

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    /**
        * 年龄段在“18-24”的男性年轻人，最喜欢看哪10部电影
        */
      def top10LookeMovie: Unit ={
        //获取年龄段在“18-24”的男性年轻人的userid
        val users=getUsers(sc)
        val userList=users.filter(x=>x(1).equals("M") && x(2).toInt==18)
          .map(x=>x(0)).collect()
        //注意：HashSet()后面要带小括号
        val userSet=HashSet() ++ userList
        //创建广播变量
        val broadcastUserSet=sc.broadcast(userSet)
        //统计出１８－２４岁男性喜欢看的前１０名电影的movieid和次数
        val ratings=getRatings(sc)
        val topNMovies=ratings.map(x=>(x(0),x(1))) //ratings中所有的(userid,movieid)
          //从rating数据过滤出“18-24”的男性年轻人的观影信息
          .filter(x=>broadcastUserSet.value.contains(x._1))
          .map(x=>(x._2,1))
          .reduceByKey(_+_) //(movieid,次数)
          .sortBy(_._2,false)
          .take(10) //(movieid,次数)
     
        val movies=getMovies(sc)
        //获取所有电影的(movieid,title)
        val movieTitle=movies.map(x=>(x(0),x(1))).collect().toMap
        topNMovies.map(x=>(movieTitle.getOrElse(x._1,null),x._2))
          .foreach(x=>println(x._1+"  "+x._2))
      }

    　　

    3、

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def getTenMovie: Unit ={
        val ratings=getRatings(sc)
        //获取得分最高的１０部电影的movieId
        val top10moiveid=ratings.map(x=>(x(0),x(1),x(2))) //(userid,movieid,rating)
          .map(x=>(x._2,(x._2.toInt,1))) //(movieid,(rating,1))
          .reduceByKey((x,y)=>{
          (x._1+y._1,x._2+y._2) //注意此行代码，求出了电评的总分、评价的次数
        }).map(x=>{
          (x._2._1.toDouble/x._2._2.toDouble,x._1) //(电影平均分,movieid)
        }).sortByKey(false).take(10).map(x=>x._2)
     
        //广播变量
        val broadcastMovieList=sc.broadcast(top10moiveid)
        val movies=getMovies(sc)
        val result=movies.map(x=>(x(0),x(1))) //取出全部电影的(movieid,title)
          .filter(x=>broadcastMovieList.value.contains(x._1))
          println("得分最高的10部电影是：")
        result.foreach(x=>println(x._1+"  "+x._2))
      }

    4、

    5、

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    /**
        * 女性看过最多的10部电影
        */
      def top10FaleLookMovie: Unit ={
        val users = getUsers(sc)
        //获取所有女性的userid
        val faleUserId = users.filter(x => x(1).equals("F"))
          .map(x => x(0)).collect()
        val faleUserSet = HashSet() ++ faleUserId
        //创建广播变量，里面存储所有女性的userid
        val broadcastFaleSet = sc.broadcast(faleUserSet)
     
        val ratings = getRatings(sc)
        //统计出女性看过最多的１０部电影的(movieid,观看次数)
        val top10moiveid = ratings.map(x => (x(0), x(1))) //(userid,movieid)
          //过滤出女性观影数据
          .filter(x => broadcastFaleSet.value.contains(x._1))
          .map(x => (x._2, 1)) //(movieid,1)
          .reduceByKey(_ + _)
          .sortBy(_._2, false)
          .take(10)
        val top10movieRDD=sc.parallelize(top10moiveid) //(movieid,次数)
     
        val movies=getMovies(sc)
        val allmoviesRDD=movies.map(x=>(x(0),x(1))) //(movieid,title)
        //对两个ＲＤＤ进行join操作，取二者的共同匹配项
        allmoviesRDD.join(top10movieRDD) //(movieid,(title,次数))
          .map(x=>(x._1,x._2._1,x._2._2))
          .foreach(x=>println(x._1+"  "+x._2+"  "+x._3))
      }

    6、解决方法：将女性改为男性就好了

    7、

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    /**
        * 年龄段在“45-49”的男性观众中，得分最高的10部电影名称
        */
      def top10MaleMovie: Unit ={
        //获取所有年龄段在“45-49”的男性观众的userid
        val users=getUsers(sc)
        val usersList=users.filter(x=>x(1).equals("M") && x(2).toInt==45)
            .map(x=>x(0)).collect()
        val userSet=HashSet() ++ usersList
        //创建广播变量
        val broadcastUserSet=sc.broadcast(userSet)
     
        val ratings=getRatings(sc)
        //得分最高的10部电影的(movieid,avg)
        val topmovies=ratings.map(x=>(x(0),x(1),x(2)))  //(userid,movieid,rating)
          .filter(x=>broadcastUserSet.value.contains(x._1))
          .map(x=>(x._2,(x._3.toInt,1))) //(movieid,(rating,1))
          .reduceByKey((x,y)=>{
          (x._1+y._1,x._2+y._2)
        }).map(x=>{
          val sum=x._2._1.toDouble
          val rcount=x._2._2.toDouble
          val avg=sum/rcount  //求出平均分
          (avg,x._1)
        }).sortByKey(false).take(10)
          .map(x=>(x._2,x._1))  //(movieid,avg)
        val topmoviesRDD=sc.parallelize(topmovies)
     
        val movies=getMovies(sc)
        val allmovies=movies.map(x=>(x(0),x(1))).collect().toMap
        topmoviesRDD.map(x=>(allmovies.getOrElse(x._1,null),x._2))
          .foreach(println(_))
      }

    8、第一步 统计出1995年播放电影的moviesid(substring)                title.substring(title.length-5,title.length-1).equals("1995")

         第二步从ratings中统计出1995年最受欢迎的前三部电影的movieid

         第三步 计算出观看过1995年最受欢迎的前三部电影的（userid,movieid）

         第四步 统计出1995年最受欢迎的前3部电影的观众年龄和性别数量分布

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    /**
        * 1995年最受欢迎的前3部电影的观众年龄和性别数量分布
        */
      def top3AgeAndSexCount: Unit ={
        //第一步：统计出1995年播放电影的moviesid
        val movies=getMovies(sc)
        val moviesid=movies.filter(x=>{
          var title=x(1).trim
          title.substring(title.length-5,title.length-1).equals("1995")
        }).map(x=>x(0))collect()
        val moviesidSet=HashSet()++moviesid
        //创建广播变量
        val broadcastmoviesidSet=sc.broadcast(moviesidSet)
     
        //第二步：从ratings中统计出1995年最受欢迎的前3部电影的movieid
        val ratings=getRatings(sc)
        val top3moviesid=ratings.map(x=>(x(0),x(1))) //(userid,movieid)
          .distinct() //数据去重
          //过滤出1995年观影的(userid,movieid)
          .filter(x=>broadcastmoviesidSet.value.contains(x._2))
          .map(x=>(x._2,1)) //(movieid,1)
          .reduceByKey(_+_) //(movieid,次数)
          .map(x=>(x._2,x._1))
          .sortByKey(false).take(3)
          .map(x=>x._2) //movieid
     
        val top3moviesidSet=HashSet()++top3moviesid
        val broadcasttop3moviesidSet=sc.broadcast(top3moviesidSet)
        //第三步：统计出观看过1995年最受欢迎的前3部电影的(userid,movieid)
        val top3useridmovieid=ratings.map(x=>(x(0),x(1)))//所有的(userid,movieid)
          .filter(x=>broadcasttop3moviesidSet.value.contains(x._2))
        //第四步：统计出1995年最受欢迎的前3部电影的观众年龄和性别数量分布
        val users=getUsers(sc)
        val allusers=users.map(x=>(x(0),(x(2),x(1)))) //(userid,(age,gender))
     
        top3useridmovieid.join(allusers)//(userid,(movieid,(age,gender)))
          .map(x=>(x._2._2,1)) //((age,gender),1)
          .reduceByKey(_+_)
          .map(x=>(x._1,x._2)) //((age,gender),数量)
          .foreach(println(_))
      }

    9、

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    /**
        * movieid = 2116 这部电影各年龄段的平均影评（年龄段，平均影评分）
        */
      def ageAndRating: Unit ={
        //第一步：从users中获取所有的(userid,age)
        val usersRDD=getUsers(sc)
          .map(x=>(x(0),x(2))) //(userid,age)
        //第二步：从ratings中获取观众对movieid=2116这部电影的影评(userid,rating)
        val useridratingRDD=getRatings(sc)
          .map(x=>(x(0),x(1),x(2))) //(userid,movieid,rating)
          .filter(x=>x._2.toInt==2116)
          .map(x=>(x._1,x._3)) //(userid,rating)
        //第三步：usersRDD join useridratingRDD,这两个RDD进行join操作
        usersRDD.join(useridratingRDD) //(userid,(age,rating))
          .map(x=>(x._2._1,(x._2._2.toInt,1))) //(age,(rating,1))
          .reduceByKey((x,y)=>{
          (x._1+y._1,x._2+y._2) //分别对rating和１进行累计求和
        }).map(x=>{
          val age=x._1
          val avg=x._2._1.toDouble/x._2._2.toDouble
          (age,avg)
        }).foreach(x=>println(x._1+"  "+x._2))
      }

    10、第一步：统计最喜欢看电影的那位女士的userid   第二步：那位女士最喜欢的10部电影的movieid  第三步：观众对这10部电影的平均影评

     //将小数保留两位，四舍五入
      def twoNum(num:Double):String={
        val df = new DecimalFormat("#.00");
        val res=df.format(num)
        res
      }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    /**
        * 统计最喜欢看电影的那位女士最喜欢的10部电影，
        * 观众对它们的平均影评分(电影名，影评)
        */
      def titleAndRating: Unit ={
        //第一步：统计最喜欢看电影的那位女士的userid
        //从users中获取所有女性的userid
        val users=getUsers(sc)
        val faleusersid=users.filter(x=>x(1).equals("F"))
          .map(x=>x(0)).collect()
        val faleuseridSet=HashSet()++faleusersid
        val broadcastfaleidSet=sc.broadcast(faleuseridSet)
     
        val ratings=getRatings(sc)
        val fuserid=ratings.map(x=>(x(0),x(1))) //(userid,movieid)
          .distinct()
          //过滤出所有女性的观影数据
          .filter(x=>broadcastfaleidSet.value.contains(x._1))
          .map(x=>(x._1,1))  //(userid,1)
          .reduceByKey(_+_)
          .map(x=>(x._2,x._1))
          .sortByKey(false).take(1)
          .map(x=>x._2) //此userid是最喜欢看电影的那位女士的userid
     
        val broadfuesrid=sc.broadcast(fuserid)
     
        //第二步：那位女士最喜欢的10部电影的moviesid
        val top10moviesid=ratings.filter(x=>x(0).equals(broadfuesrid.value(0)))
          .map(x=>(x(1),(x(2).toInt,1))) //(movieid,(rating,1))
          .reduceByKey((x,y)=>{
          (x._1+y._1,x._2+y._2)
        }).map(x=>{
          val movieid=x._1
          val avg=x._2._1.toDouble/x._2._2.toDouble
          (avg,movieid)
        }).sortByKey(false).take(10)
          .map(x=>x._2)  //movieids
     
        val top10moviesidSet=HashSet()++top10moviesid
        val broadtop10moviesSet=sc.broadcast(top10moviesidSet)
     
        //第三步：观众对这10部电影的平均影评，影评保留两位小数，四舍五入
        val top10moviesavg=ratings.map(x=>(x(1),x(2))) //(movieid,rating)
          .filter(x=>broadtop10moviesSet.value.contains(x._1))
          .map(x=>(x._1,(x._2.toInt,1))) //(movieid,(rating,1))
          .reduceByKey((x,y)=>{
          (x._1+y._1,x._2+y._2)
        }).map(x=>{
          val movieid=x._1
          val avg=x._2._1.toDouble/x._2._2.toDouble
          val resavg=twoNum(avg)//对平均影评保留两位小数
          (movieid,resavg)  //(movieid,平均分)
        })
        //(电影名,影评)
        val movies=getMovies(sc)
        val allmovies=movies.map(x=>(x(0),x(1))) //(movieid,title)
     
        allmovies.join(top10moviesavg) //(movieid,(title,平均分))
          .map(x=>(x._2._1,x._2._2)) //(title,平均分)
          .foreach(println(_))
      }
  • 相关阅读:
    json 总结
    Django---admin简单功能
    Django---Models
    Django---Template（模板）
    Django---URL、Views
    Django---定义、MVC和MTV模式、命令行工具、配置文件settings
    必学算法
    一个虚拟社交公司的融资历程
    分布式系统，本文引用“courage”的博客
    mysql语句
  • 原文地址：https://www.cnblogs.com/hd-zg/p/6908919.html
Copyright © 2020-2023  润新知