尊敬的客户：您好！为帮助您深入了解华为云产品，探索新的技术场景，我们非常高兴地与您分享一个好消息：为了更好地服务千万开发者，华为云推出开发者认证，真正让开发者在云上作业，懂开发会开发，与开发者共成长。由华为资深研发团队精心打磨，潜心研发的《大数据入门级开发者认证》于2022年12月20日正式上线！届时请进入华为云开发者学堂-开发者认证-大数据查看产品详情，体验使用，我们非常期待您的宝贵建议。以下为该开发者认证详情，您可提前了解：产品名称: 《大数据入门级开发者认证》适合人群： 高校学生、开发工程师、运维工程师等；培训方案： 大数据技术与华为云大数据MRS服务能力及优势；技术能力： 掌握大数据关键技术、华为云MRS核心技术及云上开发实践能力；认证价值： 通过理论结合实践，增强大数据理论和实操能力 。届时我们还将开展相关开发者认证上新活动，详情请关注华为云开发者学堂论坛-热门活动 相关通知。发布日期：2022年12月20日

<获奖名单>账号名奖项名称奖品名称微信昵称liyangguang新人注册华为定制帆布包阳光wudg518视频号分享华为定制T恤何必自寻烦恼breeze_luckly视频号分享华为定制T恤坚果hid_y_w9dg_leuhuf8o视频号分享华为定制T恤小云悠悠zZyeats_liao视频号分享华为定制T恤Yeats_Liaolearner518视频号分享华为定制T恤王也lokenetwork视频号分享华为定制T恤罗上文hid_l69yzhl4cib7tny视频号抽奖华为定制渔夫帽新A4F29AE15E594C9B8E1E852B4E0ED24B视频号抽奖华为定制渔夫帽hw74606662官网抽奖华为AI音箱2edgdennisgao官网抽奖华为定制渔夫帽高达NA官网抽奖华为定制渔夫帽NA官网抽奖华为定制渔夫帽NA官网抽奖华为AI音箱2e

11月22日，华为云HCSD校园沙龙走进延安职业技术学院，专业鸿蒙开发专家对200余名高校师生关心关注的热点问题，开展现场分享交流。该沙龙由延安职业技术学院、中共延安市委网信办、华为云计算技术有限公司联合创新主办，由延安云计算大数据中心承办，旨在携华为云技术专家走进校园，提升学院师生的职业素养、专业技能和实操能力，探索数字产业前沿新技术和数字人才发展新模式。「助力产教融合」架起高校学子和“云服务”连接桥梁HCSD（Huawei Cloud Student Developers），即华为云学生开发者。该平台是由校园大使为代表的校园开发者组织，旨在帮助高校师生在华为云领域进行学习和创新。华为云HCSD校园沙龙“切实帮助师生扩大技术知识层面，不出校园就能了解行业最新动态、体验当下热门技术” 延安职业技术学院党委副书记党云萍在活动当天的发言中表示，学院高度重视数字人才培养，与华为公司有着良好的合作基础，对学院深化开放办学、完善人才培养模式、提升社会服务能力起到积极的作用。当前，延安正处在结构调整、转型发展和动力转换的关键节点，迫切需要应用大数据、云计算、人工智能、区块链等科技技术，来适应新常态、培育新动能、发展新产业，这对延安数字人才培养提出了新的要求。延安市委网信办副主任张新希望华为公司抢抓发展机遇，发挥自身优势，常态化开展校企主题培训活动，携手生态合作企业来延举办校园招聘会、双选会，助力高校数字人才精准就业，努力为延安经济社会高质量发展贡献更多智慧和力量。“华为将积极响应教育强国的国家战略，致力成为数字经济人才培养的黑土地”， 华为公司延安政企业务部总经理孙武常说，华为携手延安职院等高校，基于“平台+AI+生态”的人才培养战略，共同建设“ 政、产、学、研、转、创” 多主体、多功能、深度融合的人才培养体系，加快融入秦创原创新驱动平台，与延安各产业协同创新数字经济繁荣。「HarmonyOS实操升级」行业专家线上线下支招为顺应万物互联时代趋势，OpenHarmony应运而生，面向全场景、全连接、全智能时代，基于开源的方式，搭建一个智能终端设备操作系统的框架和平台，促进互联网与更多产业上下游相融合，重构传统产业的业务链和产业链。与此同时，各行各业将通过新技术进行数字化转型，重构体验、优化流程、使能创新，打造面向未来的核心竞争力。高校开发者如何抓住时代机遇？活动现场，华为云服务专家张浩奇针对鸿蒙入门常见问题、鸿蒙发展现状与趋势、华为云开发者认证等方面问题，进行了深入浅出的现场讲解。“鸿蒙生态生命力整这么强大吗？”“华为鸿蒙OS合作伙伴都有谁？”“入门HarmonyOS，要学的基础知识太多怎么学，碰到问题找不到人请教怎么办？”面对学生关心的这些高频问题，张浩奇也给出了耐心解答，并介绍了华为云开发者认证体系，邀请在坐学子一起“实操JS UI开发。他透露，考取入门级开发证书获的学子，还可以进入华为云产业人才库，提升就业机会。这些“干货”，引得大家兴致高昂。「华为ICT大赛」深化人才培养华为ICT大赛是华为公司面向全球大学生打造的ICT人才竞技交流赛事，旨在以赛促赛、以赛促学、以赛促发展，打造良性ICT人才生态，并已被纳入全国普通高校大学生竞赛排行榜内竞赛项目名单。华为ICT大赛2022-2023（第七届华为ICT大赛）分设有实践赛、创新赛、行业赛三大赛道，在陕西截止目前已有4000余名同学报名参赛。事实上，在红色革命圣地延安，除了校园沙龙活动，一直以来，华为都致力于携手政校企多方合作，先后落地了延安云计算大数据中心、与延大附院联合建设省级区域医疗中心等项目，并将持续投入校企合作ICT人才培养、跨境电商综合服务赋能中心，为延安市发展数字经济提供重要的基础设施，助力战略性新兴产业蓬勃发展。

新人报道，我入驻华为云社区啦

目前ambari已经停服，ambari默认只能运行在python2。7的环境上

1.登录华为云账号，首先打开数据治理中心购买页面（如果是新用户，请按照引导进行账号注册以及实名认证）。链接：cid:link_02.进入购买页面后，首先先给数据治理中心服务授权，这里选择All如下图所示；​​3.购买免费版数据治理中心套餐，操作步骤如下图所示​区域要选择华北-乌兰察布一（当前已开放免费版的区域，后续会有更多区域支持免费版的购买），版本选择免费版勾上CDM套餐增量包选择时长：9个月勾上自动续费4.确认配置后，点击立即购买会弹出订单确认页面，点击去支付即可5.免费版点击去支付后会直接显示订单支付成功6.点击返回我的订单，即可查看到刚才购买的免费版数据治理中心服务实例订单7.等待订单状态更新（需要手动刷新）为已完成后，点击链接跳转到数据治理中心服务，即可看到工作空间内刚才购买的免费实例，如下图所示。链接：https://console.huaweicloud.com/dayu/?region=cn-north-9&locale=zh-cn

【直播主题】华为云FusionInsight 8.2.0 MRS新版本特性能力解读&最佳实践【回看链接】cid:link_1【直播介绍】本期直播将由华为云MRS首席架构师Sailing老师与资深工程师Haoxi老师带大家一起玩转MRS新版本，详细解读全链路实时数据湖、高性能智能化交互式引擎等新方案、新能力。调研问卷：cid:link_0

 目录  模型的保存  模型的优化  离线应用还是在线应用?   一个简单部署方案  记录项目经历,学会总结和反思  多考虑一点,如何适合更多场景  监控与迭代  模型的监控  重新开启  总结  我们的目标是业务需求，而数据挖掘产出的结果。 不管是预测型的还是关联型的，都要结合业务场景，融入到业务流程中去。  模型部署本质――回归业务！  模型如何保存？ 如何根据业务需求优化？ 如何最终上线服务？  模型的保存 模型保存的规范。  存放的位置、名字的定义、模型使用的算法、参数、数据、效果等。  模型的优化 模型训练阶段优化所追求的目标―—效果要尽量好。 模型应用阶段优化所追求的目标――在效果尽量不降低的前提下，适配应用的限制。  时延要求比较高的场景  如果业务应用无法忍受模型的响应时间，需要思考增加机器还是降低模型的复杂度以提高速度。  模型大小要求比较高的场景 期望把人脸识别模型部署到一个摄像装置的小型存储芯片上面，需要考虑降低模型的参数维度等。  离线应用还是在线应用? 如果使用新闻分类的类别标签结果，实时分发到用户App中分类模型需要部署成在线的应用服务以实时响应新的内容请求。 如果只需要对一批已有的新闻数据进行分类处理，之后只使用这些结果模型离线运行，把存储的新闻处理完，或者每隔一段时间去处理新的数据。  在线应用   一个简单部署方案  记录项目经历,学会总结和反思 从项目的需求发起,到数据准备，再到模型训练、评估、上线，这些环节都遇到了什么样的问题,我们解决了什么问题，又有哪些问题尚未解决,在时间等条件充裕的情况下还可以做哪些尝试。  多考虑一点,如何适合更多场景 我们的数据挖掘模型或结果能不能做成统一的服务,能不能应用在更多的地方  规划一个面向全公司更底层的标签体系架构以应对各种类似的业务。  监控与迭代 为了模型保持良好的效果，需要有一份迭代计划去维护和更新模型。  模型的监控  结果监控 结果监控主要是针对一些具体的指标进行监控。 还可以根据具体产出的结果在业务中的效果进行监控。  针对每天新闻的分类标签进行排名统计，来查看每个标签的占比情况与初始数据是否接近。 推荐系统中，可以对标签与CTR (点击率预估)的关系进行计算。 一些App会主动负反馈，让用户自己选择不喜欢的标签。 人工定期复审  主要针对业务需求准确率的情况进行评估。 查看当前的模型效果是否还满足业务的需求，准确率情况是否有所变化。 跟业务进行沟通评估，确认当前的情况是否需要对模型进行重新训练。  Case收集与样本积累  重新开启 准备数据阶段发现数据无法解决业务需求时,要返回去重新讨论业务需求与数据的问题。 训练模型阶段发现数据与模型无法匹配，或者如果要更换其他模型时，要回到准备数据环节。 模型评估的时候发现效果达不到预期可能要回到准备数据环节重新处理数据，甚至要回到理解业务阶段。 总结 介绍了一些关于模型保存、模型优化、模型部署的思路。讲解了关于项目总结，乃至模型监控等内容。 ———————————————— 版权声明：本文为CSDN博主「Lingxw_w」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/lxwssjszsdnr_/article/details/127487459 

kafka全部案例集合见维护宝典：https://support.huawei.com/hedex/hdx.do?docid=EDOC1100222546&lang=zh&idPath=22658044|22662728|22666212|22396131（FusionInsight HD&MRS租户面集群故障案例（6.5.X-8.X）->维护故障类->kafka->常见故障）kafka经典案例、总结、重大问题见下表：经典案例分类序号案例出现频次服务端性能问题1.1Kafka CPU使用率高排查思路及解决方案★★★★1.2异常鉴权信息量大导致集群性能下降（旧版本鉴权）★★1.3使用了与服务端版本不一致的客户端，并且开启了数据压缩★★★★1.4使用了raid方式部署，定期开启PR巡检，导致磁盘IO下降★★★★★topic异常2.1Kafka分区未同步★★★★★2.2Kafka过期数据未老化原因及解决方案★★2.3FusionInsight Kafka删除Topic失败原因及解决方案★★2.4FusionInsight Kafka创建Topic失败原因及解决方案★★★排查手段3.1如何根据strace信息定位异常连接的客户端★★3.2收集kafka-root.log查看每个broker节点的磁盘IO★★★★★3.3检测网络异常的通用方式★★★★★3.4Kafka集群性能的检测方式★★★★★3.5开启kafka-request.log日志，定位生产消费每个阶段的耗时★★★★★最佳实践4.1关于kafka的Producer的粘性分区的坑★★★

尊敬的客户：您好！ 为保证您获得最佳的学习与实验体验，华为云开发者学堂于2022年11月11日对微认证《基于Spark实现车主驾驶行为分析》进行下线优化，预计将于2022年12月12日重新上线，届时请您关注华为云开发者学堂资讯专栏-业务动态通知。为此，我们将采取以下措施：1．对于已购买该微认证并通过考试领取证书的客户，原证书在证书有效期内仍有效，并与课程优化后的证书拥有同等效力；2．对于已购买该微认证但未通过考试且仍有考试机会的客户，可在重新上线后进行新课程学习、实验，参加考试并领取证书；3．对于已购买该微认证但未完成实验操作的客户，请您关注华为云开发者学堂资讯专栏-业务动态的上线通知，待实验优化重新上线后再前往沙箱开展实验。如您有任何问题，可随时通过工单或者服务热线（+86-4000-955-988 ）与我们联系。感谢您对华为云微认证的支持！发布日期：2022年11月11日

MRS 3.1.0普通集群怎么安装开源的flink组件，求助各位大神

+mrs的端口该写什么mrs端口太多

 前言 很多大数据计算都是用SQL实现的，跑得慢时就要去优化SQL，但常常碰到让人干瞪眼的情况。 很多大数据计算都是用SQL实现的，跑得慢时就要去优化SQL，但常常碰到让人干瞪眼的情况。  比如，存储过程中有三条大概形如这样的语句执行得很慢：   select a,b,sum(x) from T group by a,b where …;     select c,d,max(y) from T group by c,d where …;    select a,c,avg(y),min(z) from T group by a,c where …; 这里的T是个有数亿行的巨大表，要分别按三种方式分组，分组的结果集都不大。  分组运算要遍历数据表，这三句SQL就要把这个大表遍历三次，对数亿行数据遍历一次的时间就不短，何况三遍。  这种分组运算中，相对于遍历硬盘的时间，CPU计算时间几乎可以忽略。如果可以在一次遍历中把多种分组汇总都计算出来，虽然CPU计算量并没有变少，但能大幅减少硬盘读取数据量，就能成倍提速了。  如果SQL支持类似这样的语法：  from T --数据来自T表   select a,b,sum(x) group by a,b where …   --遍历中的第一种分组       select c,d,max(y) group by c,d where …   --遍历中的第二种分组       select a,c,avg(y),min(z) group by a,c where …; --遍历中的第三种分组 能一次返回多个结果集，那就可以大幅提高性能了。  可惜， SQL没有这种语法，写不出这样的语句，只能用个变通的办法，就是用group a,b,c,d的写法先算出更细致的分组结果集，但要先存成一个临时表，才能进一步用SQL计算出目标结果。SQL大致如下：   create table T\_temp as select a,b,c,d,        sum(case when … then x else 0 end) sumx,        max(case when … then y else null end) maxy,         sum(case when … then y else 0 end) sumy,         count(case when … then 1 else null end) county,        min(case when … then z else null end) minz       group by a,b,c,d;  select a,b,sum(sumx) from T\_temp group by a,b where …;    select c,d,max(maxy) from T\_temp group by c,d where …;    select a,c,sum(sumy)/sum(county),min(minz) from T\_temp group by a,c where …;   这样只要遍历一次了，但要把不同的WHERE条件转到前面的case when里，代码复杂很多，也会加大计算量。而且，计算临时表时分组字段的个数变得很多，结果集就有可能很大，最后还对这个临时表做多次遍历，计算性能也快不了。大结果集分组计算还要硬盘缓存，本身性能也很差。  还可以用存储过程的数据库游标把数据一条一条fetch出来计算，但这要全自己实现一遍WHERE和GROUP的动作了，写起来太繁琐不说，数据库游标遍历数据的性能只会更差！  只能干瞪眼！  TopN运算同样会遇到这种无奈。举个例子，用Oracle的SQL写top5大致是这样的：   select \* from (select x from T order by x desc) where rownum<=5 1 表T有10亿条数据，从SQL语句来看，是将全部数据大排序后取出前5名，剩下的排序结果就没用了！大排序成本很高，数据量很大内存装不下，会出现多次硬盘数据倒换，计算性能会非常差！  避免大排序并不难，在内存中保持一个5条记录的小集合，遍历数据时，将已经计算过的数据前5名保存在这个小集合中，取到的新数据如果比当前的第5名大，则插入进去并丢掉现在的第5名，如果比当前的第5名要小，则不做动作。这样做，只要对10亿条数据遍历一次即可，而且内存占用很小，运算性能会大幅提升。  这种算法本质上是把TopN也看作与求和、计数一样的聚合运算了，只不过返回的是集合而不是单值。SQL要是能写成这样,就能避免大排序了：   select top(x,5) from T 1 然而非常遗憾，SQL没有显式的集合数据类型，聚合函数只能返回单值，写不出这种语句！  不过好在全集的TopN比较简单，虽然SQL写成那样，数据库却通常会在工程上做优化，采用上述方法而避免大排序。所以Oracle算那条SQL并不慢。  但是，如果TopN的情况复杂了，用到子查询中或者和JOIN混到一起的时候，优化引擎通常就不管用了。比如要在分组后计算每组的TopN，用SQL写出来都有点困难。Oracle的SQL写出来是这样：   select \* from (select y,x,row\_number() over (partition by y order by x desc) rn from T) where rn<=5 1 这时候，数据库的优化引擎就晕了，不会再采用上面说的把TopN理解成聚合运算的办法。只能去做排序了，结果运算速度陡降！  假如SQL的分组TopN能这样写：   select y,top(x,5) from T group by y 1 把top看成和sum一样的聚合函数，这不仅更易读，而且也很容易高速运算。  可惜，不行。  还是干瞪眼！  关联计算也是很常见的情况。以订单和多个表关联后做过滤计算为例，SQL大体是这个样子：  select o.oid,o.orderdate,o.amount  from orders o      left join city ci on o.cityid = ci.cityid      left join shipper sh on o.shid=sh.shid      left join employee e on o.eid=e.eid      left join supplier su on o.suid=su.suid  where ci.state='New York'      and e.title='manager'      and ...  订单表有几千万数据，城市、运货商、雇员、供应商等表数据量都不大。过滤条件字段可能会来自于这些表，而且是前端传参数到后台的，会动态变化。  SQL一般采用HASH JOIN算法实现这些关联，要计算 HASH 值并做比较。每次只能解析一个JOIN，有N个JOIN要执行N遍动作，每次关联后都需要保持中间结果供下一轮使用，计算过程复杂，数据也会被遍历多次，计算性能不好。  通常，这些关联的代码表都很小，可以先读入内存。如果将订单表中的各个关联字段预先做序号化处理，比如将雇员编号字段值转换为对应雇员表记录的序号。那么计算时，就可以用雇员编号字段值（也就是雇员表序号），直接取内存中雇员表对应位置的记录，性能比HASH JOIN快很多，而且只需将订单表遍历一次即可，速度提升会非常明显！  也就是能把SQL写成下面的样子：  select o.oid,o.orderdate,o.amount  from orders o      left join city c on o.cid = c.# --订单表的城市编号通过序号#关联城市表      left join shipper sh on o.shid=sh.# --订单表运货商号通过序号#关联运货商表      left join employee e on o.eid=e.# --订单表的雇员编号通过序号#关联雇员表      left join supplier su on o.suid=su.#--订单表供应商号通过序号#关联供应商表  where ci.state='New York'      and e.title='manager'      and ...  1 2 3 4 5 6 7 8 9 可惜的是，SQL 使用了无序集合概念，即使这些编号已经序号化了，数据库也无法利用这个特点，不能在对应的关联表这些无序集合上使用序号快速定位的机制，只能使用索引查找，而且数据库并不知道编号被序号化了，仍然会去计算 HASH 值和比对，性能还是很差！  有好办法也实施不了，只能再次干瞪眼！  还有高并发帐户查询，这个运算倒是很简单：  select id,amt,tdate,… from T  where id='10100'      and tdate>= to\_date('2021-01-10','yyyy-MM-dd')      and tdate    and="" …="" 1 2 3 4 5 在T表的几亿条历史数据中，快速找到某个帐户的几条到几千条明细，SQL写出来并不复杂，难点是大并发时响应速度要达到秒级甚至更快。为了提高查询响应速度，一般都会对 T 表的 id 字段建索引：  create index index_T_1 on T(id) 1 在数据库中，用索引查找单个帐户的速度很快，但并发很多时就会明显变慢。原因还是上面提到的SQL无序理论基础，总数据量很大，无法全读入内存，而数据库不能保证同一帐户的数据在物理上是连续存放的。硬盘有最小读取单位，在读不连续数据时，会取出很多无关内容，查询就会变慢。高并发访问的每个查询都慢一点，总体性能就会很差了。在非常重视体验的当下，谁敢让用户等待十秒以上？！  容易想到的办法是，把几亿数据预先按照帐户排序，保证同一帐户的数据连续存储，查询时从硬盘上读出的数据块几乎都是目标值，性能就会得到大幅提升。  但是，采用SQL体系的关系数据库并没有这个意识，不会强制保证数据存储的物理次序！这个问题不是SQL语法造成的，但也和SQL的理论基础相关，在关系数据库中还是没法实现这些算法。  那咋办？只能干瞪眼吗？  不能再用SQL和关系数据库了，要使用别的计算引擎。  开源的集算器SPL基于创新的理论基础，支持更多的数据类型和运算，能够描述上述场景中的新算法。用简单便捷的SPL写代码，在短时间内能大幅提高计算性能！  上面这些问题用SPL写出来的代码样例如下：  一次遍历计算多种分组 A    B 1    =file(“T.ctx”).open().cursor(a,b,c,d,x,y,z     2    cursor A1    =A2.select(…).groups(a,b;sum(x)) 3        //定义遍历中的第一种过滤、分组 4    cursor    =A4.select(…).groups(c,d;max(y)) 5        //定义遍历中的第二种过滤、分组 6    cursor    =A6.select(…).groupx(a,c;avg(y),min(z)) 7        //定义遍历中的第三种过滤、分组 8    …    //定义结束，开始计算三种方式的过滤、分组 用聚合的方式计算Top5 全集Top5（多线程并行计算）  A 1    =file(“T.ctx”).open() 2    =A1.cursor@m(x).total(top(-5,x),top(5,x)) 3    //top(-5,x) 计算出 x 最大的前 5 名，top(5,x) 是 x 最小的前 5 名。 分组Top5（多线程并行计算）  A 1    =file(“T.ctx”).open() 2    =A1.cursor@m(x,y).groups(y;top(-5,x),top(5,x)) 用序号做关联的SPL代码： 系统初始化  A 1    >env(city,file(“city.btx”).import@b()),env(employee,file(“employee.btx”).import@b()),… 2    //系统初始化时，几个小表读入内存 查询  A 1    =file(“orders.ctx”).open().cursor(cid,eid,…).switch(cid,city:#;eid,employee:#;…) 2    =A1.select(cid.state==“New York” && eid.title==“manager”…) 3    //先序号关联，再引用关联表字段写过滤条件 高并发帐户查询的SPL代码： 数据预处理，有序存储  A    B 1    =file(“T-original.ctx”).open().cursor(id,tdate,amt,…)     2    =A1.sortx(id)    =file(“T.ctx”) 3    =B2.create@r(#id,tdate,amt,…).append@i(A2)     4    =B2.open().index(index_id;id)     5    //将原数据排序后，另存为新表，并为帐号建立索引     帐户查询  A 1    =T.icursor(;id==10100 && tdate>=date(“2021-01-10”) && tdate2    //查询代码非常简单 除了这些简单例子，SPL还能实现更多高性能算法，比如有序归并实现订单和明细之间的关联、预关联技术实现多维分析中的多层维表关联、位存储技术实现上千个标签统计、布尔集合技术实现多个枚举值过滤条件的查询提速、时序分组技术实现复杂的漏斗分析等等。  正在为SQL性能优化头疼的小伙伴们，可以和我们一起探讨：  http://www.raqsoft.com.cn/wx/Query-run-batch-ad.html  SPL资料 SPL官网 SPL下载 SPL源代码 ———————————————— 版权声明：本文为CSDN博主「IT邦德」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/weixin_41645135/article/details/127099888 

实验目的1. 理解分类算法的概念以及基本思想流程;2. 熟练使用Eclipse等环境编写调试分类算法的Java代码。 实验平台操作系统：WindowsEclipse或MyEclipse 实验内容3.1 分类算法思想与流程（自己截图或文字说明）3.2 Eclipse或MyEclipse编写调试分类算法的Java代码，分析运行结果。算法思想及过程：我们统计了14天的气象数据(指标包括outlook，temperature，humidity，windy)，并已知这些天气是否打球(play)。如果给出新一天的气象指标数据:sunny,cool,high,TRUE，判断一下会不会去打球。table 1outlooktemperaturehumiditywindyplaysunnyhothighFALSEnosunnyhothighTRUEnoovercasthothighFALSEyesrainymildhighFALSEyesrainycoolnormalFALSEyesrainycoolnormalTRUEnoovercastcoolnormalTRUEyessunnymildhighFALSEnosunnycoolnormalFALSEyesrainymildnormalFALSEyessunnymildnormalTRUEyesovercastmildhighTRUEyesovercasthotnormalFALSEyesrainymildhighTRUEno这个问题当然可以用朴素贝叶斯法求解，分别计算在给定天气条件下打球和不打球的概率，选概率大者作为推测结果。现在我们使用ID3归纳决策树的方法来求解该问题。预备知识：信息熵熵是无序性（或不确定性）的度量指标。假如事件A的全概率划分是（A1,A2,...,An），每部分发生的概率是(p1,p2,...,pn)，那信息熵定义为：通常以2为底数，所以信息熵的单位是bit。补充两个对数去处公式：ID3算法构造树的基本想法是随着树深度的增加，节点的熵迅速地降低。熵降低的速度越快越好，这样我们有望得到一棵高度最矮的决策树。在没有给定任何天气信息时，根据历史数据，我们只知道新的一天打球的概率是9/14，不打的概率是5/14。此时的熵为：属性有4个：outlook，temperature，humidity，windy。我们首先要决定哪个属性作树的根节点。对每项指标分别统计：在不同的取值下打球和不打球的次数。table 2outlooktemperaturehumiditywindyplay yesno yesno yesno yesnoyesnosunny23hot22high34FALSE6295overcast40mild42normal61TRUR33  rainy32cool31        下面我们计算当已知变量outlook的值时，信息熵为多少。outlook=sunny时，2/5的概率打球，3/5的概率不打球。entropy=0.971outlook=overcast时，entropy=0outlook=rainy时，entropy=0.971而根据历史统计数据，outlook取值为sunny、overcast、rainy的概率分别是5/14、4/14、5/14，所以当已知变量outlook的值时，信息熵为：5/14 × 0.971 + 4/14 × 0 + 5/14 × 0.971 = 0.693这样的话系统熵就从0.940下降到了0.693，信息增溢gain(outlook)为0.940-0.693=0.247同样可以计算出gain(temperature)=0.029，gain(humidity)=0.152，gain(windy)=0.048。gain(outlook)最大（即outlook在第一步使系统的信息熵下降得最快），所以决策树的根节点就取outlook。接下来要确定N1取temperature、humidity还是windy?在已知outlook=sunny的情况，根据历史数据，我们作出类似table 2的一张表，分别计算gain(temperature)、gain(humidity)和gain(windy)，选最大者为N1。依此类推，构造决策树。当系统的信息熵降为0时，就没有必要再往下构造决策树了，此时叶子节点都是纯的--这是理想情况。最坏的情况下，决策树的高度为属性（决策变量）的个数，叶子节点不纯（这意味着我们要以一定的概率来作出决策）。  3 ID3算法Java实现 ID3算法实现包括四个类的设计： 一、 决策树节点类（TreeNode类），包括类属性：name（节点属性名称），rule（节点属性值域，也就是对应决策树的分裂规则），child（节点下的孩子节点），datas（当前决策下对应的样本元组）， candidateAttr（当前决策下剩余的分类属性）。 二、 最大信息增益节点计算类（Gain类）：包括属性值：D（当前决策层次下的样本数据），attrList（当前决策层次下的剩余分类属性）；包括方法：统计属性取值方法，统计属性不同取值计数方法，计算先验熵和条件熵的方法，筛选指定属性索引在指定值上的样本元组方法，通过先验熵减后验熵计算出最大信息增益值属性的方法。具体方法在程序中都已经注释，在这里只是根据需求给出方法的大致功能。 三、决策树建立类（DecisionTree类）：包括方法：计算当前样本中分类属性的取值及其计数，并由此计算出多数类，决策树节点递归构建构成，具体实现思想同课上讲授内容，在此不在重述，借助的类是增益值计算类。 四、 ID3算法测试类（TestDecisionTree类）：借助于上面决策树建立类，决策树节点之间连接已经建立完毕，下面将以上第二部分的样本数据作为测试数据，并且实现递归打印方法，输出决策树具体内容。Java代码： import java.util.List;    //计算经验熵    public class Entroy {        public double HD(List list, Object[] category){            int n = list.get(0).length;            double[] p = new double[category.length];            double HD = 0;            for(int k = 0; k                 double num = 0;                for(int i = 0; i < list.size(); i ++){                    if(list.get(i)[n-1] == category[k]){                        num++;                    }                }                p[k] = num/list.size();            }            for(int m = 0; m < category.length; m ++){              HD = HD + (-1) * p[m] * (Math.log(p[m])/Math.log(2.0));            }            return HD;        }    }        import java.util.List;    //计算条件熵    public class Conditition {        public double GD(List list,List array,  int n){            Object[] objects = array.get(n);            double gd = 0;            double[] p = new double[objects.length];            for(int k = 0; k                 double  num = 0;                for (int i = 0; i < list.size(); i++) {                    if (list.get(i)[n] == objects[k]) {                        num++;                    }                }                p[k] = num/list.size();                double h = HH(list,objects[k],n,array.get(array.size()-1));                gd = gd + p[k] * h;            }            return gd;        }        public double HH(List list, Object object, int n, Object[] category){            int m = list.get(0).length;            double HD = 0;            double[] p = new double[category.length];            for(int k = 0; k < category.length; k ++){                double num = 0, nums = 0;                for(int i = 0; i < list.size(); i ++){                    if(list.get(i)[n] == object){                        num ++;                        if(list.get(i)[m-1] == category[k]){                            nums ++;                        }                    }                }                p[k] = nums/num;            }            for(int j = 0; j < category.length; j ++) {                if (p[j] == 0) {                    HD = 0;                } else {                    HD = HD + (-1) * p[j] * (Math.log(p[j]) / Math.log(2.0));                }            }            return HD;        }    }    //输出选择的特征，返回该特征维度    public class OutPut {        public int output(double[] GD, String[] feature){            int max = 0;            for(int i = 1; i < GD.length; i ++){                if(GD[i] > GD[max]){                    max = i;                }            }            System.out.println(feature[max]);            return max;        }    }        import java.util.ArrayList;    import java.util.List;        import static java.lang.Float.NaN;    //ID3算法   import java.util.ArrayList;import java.util.List;import static java.lang.Float.NaN;public class ID3 {    public void id3(List list,  String[] feature , List array){        Entroy e = new Entroy();        int len = list.get(0).length;        Conditition c = new Conditition();        Object[] category = array.get(len-1);        double HD = e.HD(list,category);        double[] GD = new double[array.size()-1];        double[] HDA = new double[array.size()-1];        for(int i =0; i             HDA[i] = c.GD(list, array,i );            GD[i] = HD -  HDA[i];        }        OutPut outPut = new OutPut();        int max = outPut.output(GD,feature);        List>lists = new ArrayList<>();        //将数据按照特征划分为不同区域，为下一步求熵值做准备        for(int k = 0; k < array.get(max).length; k ++) {            List l = new ArrayList<>();            for (int i = 0; i < list.size(); i++) {                if (list.get(i)[max] == array.get(max)[k]){                    l.add(list.get(i));                }            }            lists.add(l);        }        boolean flag = false;        for(int i = 0; i             double[] GD1 = new double[array.size() - 1];            double[] HDA1 = new double[array.size() - 1];            for(int k = 0; k < lists.get(i).size(); k++){              if(lists.get(i).get(k)[len-1] != lists.get(i).get(0)[len-1]) {                  flag = true;              }            }            if(flag){                id3(lists.get(i),feature,array);            }        }    }}//测试import java.util.ArrayList;import java.util.List;import static java.lang.Float.NaN;public class test {    public static void main(String[] args) {        String[] feature = {"年龄","有工作","有自己的房子","信贷情况","类别"};        Object[] age ={"青年","中年","老年"};        Object[] work = {'是','否'};        Object[] house = {'是','否'};        Object[] loan = {"一般",'好',"非常好"};        Object[] category = {'是','否'};        List array = new ArrayList();        array.add(age);        array.add(work);        array.add(house);        array.add(loan);        array.add(category);        Object[] o1 = {age[0],work[1],house[1],loan[0],category[1]};        Object[] o2 = {age[0],work[1],house[1],loan[1],category[1]};        Object[] o3 = {age[0],work[0],house[1],loan[1],category[0]};        Object[] o4 = {age[0],work[0],house[0],loan[0],category[0]};        Object[] o5 = {age[0],work[1],house[1],loan[0],category[1]};        Object[] o6 = {age[1],work[1],house[1],loan[0],category[1]};        Object[] o7 = {age[1],work[1],house[1],loan[1],category[1]};        Object[] o8 = {age[1],work[0],house[0],loan[1],category[0]};        Object[] o9 = {age[1],work[1],house[0],loan[2],category[0]};        Object[] o10 = {age[1],work[1],house[0],loan[2],category[0]};        Object[] o11 = {age[2],work[1],house[0],loan[2],category[0]};        Object[] o12 = {age[2],work[1],house[0],loan[1],category[0]};        Object[] o13 = {age[2],work[0],house[1],loan[1],category[0]};        Object[] o14 = {age[2],work[0],house[1],loan[2],category[0]};        Object[] o15 = {age[2],work[1],house[1],loan[0],category[1]};        List list = new ArrayList();        list.add(o1);        list.add(o2);        list.add(o3);        list.add(o4);        list.add(o5);        list.add(o6);        list.add(o7);        list.add(o8);        list.add(o9);        list.add(o10);        list.add(o11);        list.add(o12);        list.add(o13);        list.add(o14);        list.add(o15);        ID3 id3 = new ID3();        id3.id3(list,feature,array);    }}决策树算法-例2决策树：是一种用于对实例进行分类的树形结构，可以是二叉树或非二叉树，由节点（node）和有向边（directed edge）组成。其中每个非叶子节点表示一个特征属性，叶子节点代表类别属性，它的值由根节点到叶子节点这一分支的属性值确定。使用决策树进行分类的过程，就是从根节点出发，训练数据的分支走向，直到得到叶子节点的值停止计算，这时即可输出类别。 决策树算法是从数据的属性（或者特征）出发，以属性作为基础，划分不同的类。实现决策树的算法有很多种，有ID3、C4.5和CART等算法。下面我们介绍ID3算法。 二、ID3算法 ID3算法是由Quinlan首先提出的，该算法是以信息论为基础，以信息熵和信息增益为衡量标准，从而实现对数据的归纳分类。 算法原理：设    为训练样本，对于每个样本有m个属性，用A，B，C，……来表示每一个属性。样本类别为    算法计算步骤如下：  首先，构造分类决策树。  （1）计算训练样本D的信息熵，即    Pi 表示第i个类别个数占训练样本总数的比例。  （2）分别计算每个属性的条件熵，例如计算属性A相对于D的期望信息，即：    其中，    表示属性A将D划分为v个子集。    表示第j个子集的样本数比上样本总数。  （3）计算属性A的信息增益，即    同理，重复第二步、第三步，计算出其他属性的信息增益，直至所有属性计算完成。选择信息增益最大的属性为根节点，对样本集D进行第一次分裂；然后对余下的属性重复上述的步骤，选择作为第二层节点的属性，直到找到叶子节点为止。此时，就构造出一颗决策分类树。 决策树构造完成后，就可以对待分类的样本进行分类，得到类别。 三、ID3算法实例讲解 图中数据为训练样本，现在预测E= {天气=晴，温度=适中，湿度=正常，风速=弱} 的情况下活动是取消还是进行。属性为天气、温度、湿度、风速，类别为取消和进行。   样本D的信息熵，    在天气为晴时有5种情况，发现活动取消有3种，进行有2种，计算现在的条件熵：    天气为阴时有4种情况，活动进行的有4种，则条件熵为：    天气为雨时有5种情况，活动取消的有2种，进行的有3种，则条件熵为：    由于按照天气属性不同取值划分时，天气为晴占整个情况的5/14，天气为阴占整个情况的4/14，天气为雨占整个情况的5/14，则按照天气属性不同取值划分时的带权平均值熵为：算出的结果约为0.693. 则此时的信息增益Gain（活动，天气）= H(活动) - H(活动|天气) = 0.94- 0.693 = 0.246 同理我们可以计算出按照温度属性不同取值划分后的信息增益： Gain（活动，温度）= H(活动) - H(活动|温度) = 0.94- 0.911 = 0.029 按照湿度属性不同取值划分后的信息增益： Gain（活动，湿度）= H(活动) - H(活动|湿度) = 0.94- 0.789 = 0.151 按照风速属性不同取值划分后的信息增益： Gain（活动，风速）= H(活动) - H(活动|风速) = 0.94- 0.892 = 0.048 决策树的构造就是要选择当前信息增益最大的属性来作为当前决策树的节点。因此我们选择天气属性来做为决策树根节点，这时天气属性有3取值可能：晴，阴，雨，我们发现当天气为阴时，活动全为进行因此这件事情就可以确定了，而天气为晴或雨时，活动中有进行的也有取消的，事件还无法确定，这时就需要在剩下的属性中递归再次计算活动熵和信息增益，选择信息增益最大的属性来作为下一个节点，直到整个事件能够确定下来。 最后得到的决策树如下图所示：    所以，E= {天气=晴，温度=适中，湿度=正常，风速=弱} 的情况下活动是进行。 四、ID3算法Java实现 下面是实例的Java代码实现，算法实现前，需要转换为数字向量，其中，天气有晴，阴，雨，可分配2，1，0三个值，即晴=2，阴=1，雨=0；同理，风速，强= 1，弱=0；湿度，高=1，正常=0；温度，炎热=2，正常=1，寒冷=0。————————————————版权声明：本文为CSDN博主「XiaoXiao_Yang77」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/XiaoXiao_Yang77/article/details/79262704Java代码：import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.HashMap;import java.util.HashSet;import java.util.LinkedHashMap;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.Set;/** * * @author X.H.Yang */public class TreeID3Act {    public static String[] createDataLable() {        String lable[] = {"weather", " temper", "humidity", "wind"};        return lable;    }    public static Object[][] createDataSet() {        Object set[][] = {{2, 2, 1, 0,"no"},        {2, 2, 1, 1, "no"},        {1, 2, 1, 0, "yes"},        {0, 1, 1, 0,"yes"},        {0, 0, 0, 0, "yes"},        {0, 0, 0, 1, "no"},        {1, 0, 0, 1, "yes"},        {2, 1, 1, 0, "no"},        {2, 0, 0, 0, "yes"},        {0, 1, 0, 0, "yes"},        {2, 1, 0, 1, "yes"},        {1, 1, 1, 1, "yes"},        {1, 2, 0, 0, "yes"},        {0, 1, 1, 1, "no"}};        return set;    }    public static double calcShannonEnt(Object[][] dataSet) {        double shannonEnt = 0.0;        int numEntries = dataSet.length;        HashMap labelCounts = new HashMap<>();        for (Object[] featVec : dataSet) {            String currentLabel = (String) featVec[featVec.length - 1];            if (labelCounts.get(currentLabel) == null) {                labelCounts.put(currentLabel, 1);            } else {                int i = labelCounts.get(currentLabel);                i++;                labelCounts.put(currentLabel, i);            }        }        for (Entry entry : labelCounts.entrySet()) {            double prob = (double) entry.getValue() / (double) numEntries;            shannonEnt -= prob * (Math.log(prob) / Math.log(2.0d));        }        return shannonEnt;    }    public static ArrayList splitDataSet(Object dataSet[][], int axis, Object value) {        ArrayList retDataSet = new ArrayList<>();        for (Object[] featVec : dataSet) {            Object subSet[] = null;            if (featVec[axis].equals(value)) {                subSet = new Object[dataSet[0].length - 1];                if (axis == 0) {                    System.arraycopy(featVec, 1, subSet, 0, subSet.length);                } else {                    System.arraycopy(featVec, 0, subSet, 0, axis);                    System.arraycopy(featVec, axis + 1, subSet, axis, subSet.length - axis);                }                retDataSet.add(subSet);            }        }        return retDataSet;    }    public static int chooseBestFeatureToSplit(Object dataSet[][]) {        int numFeatures = dataSet[0].length - 1;        double baseEntropy = calcShannonEnt(dataSet);        double bestInfoGain = 0.0;        int bestFeature = -1;        for (int f = 0; f < numFeatures; f++) {            HashSet uniqueVals = new HashSet<>();            for (Object set[] : dataSet) {                uniqueVals.add(set[f]);            }            double newEntropy = 0.0;            for (Object obj : uniqueVals) {                ArrayList subDataSet = splitDataSet(dataSet, f, obj);                double prob = (double) subDataSet.size() / (double) dataSet.length;                Object subSetArray[][] = new Object[subDataSet.size()][numFeatures];                for (int i = 0; i < subSetArray.length; i++) {                    System.arraycopy(subDataSet.get(i), 0, subSetArray[i], 0, numFeatures);                }                newEntropy += prob * calcShannonEnt(subSetArray);            }            double infoGain = baseEntropy - newEntropy;            if (infoGain > bestInfoGain) {                bestInfoGain = infoGain;                bestFeature = f;            }        }        return bestFeature;    }    public static String majorityCnt(String classList[]) {        HashMap classCount = new HashMap<>();        for (String vote : classList) {            if (!classCount.containsKey(vote)) {                classCount.put(vote, 1);            } else {                int i = classCount.get(vote);                i++;                classCount.put(vote, i);            }        }        LinkedHashMap sortMap = sortMapByValues(classCount);        return sortMap.entrySet().iterator().next().getKey();    }    private static Object createTree(Object dataSet[][], String labels[]) {        //classList = [example[-1] for example in dataSet]        ArrayList classList = new ArrayList();        for (Object set[] : dataSet) {            classList.add((String) set[set.length - 1]);        }        if (ListCount(classList, classList.get(0)) == classList.size()) {            return classList.get(0);        }        if (dataSet[0].length == 1) {            return majorityCnt((String[]) classList.toArray());        }        int bestFeat = chooseBestFeatureToSplit(dataSet);        String bestFeatLabel = labels[bestFeat];        HashMap myTree = new HashMap<>();        myTree.put(bestFeatLabel, new HashMap<>());        String sublabels[] = new String[labels.length - 1];        if (bestFeat == 0) {            System.arraycopy(labels, 1, sublabels, 0, sublabels.length);        } else {            System.arraycopy(labels, 0, sublabels, 0, bestFeat);            System.arraycopy(labels, bestFeat + 1, sublabels, bestFeat, sublabels.length - bestFeat);        }        HashSet uniqueVals = new HashSet<>();        for (Object set[] : dataSet) {            uniqueVals.add(set[bestFeat]);        }        for(Object value : uniqueVals){            ArrayList setlist = splitDataSet(dataSet, bestFeat, value);            int j = 0;            Object dataSetM[][] =new Object[setlist.size()][];            for(Object set[]:setlist){                dataSetM[j] = set;                j++;            }            Object tree = createTree(dataSetM,sublabels);            HashMap subtree = (HashMap) myTree.get(bestFeatLabel);            subtree.put(value, tree);        }        return myTree;    }    private static String classify(HashMap inputTree,String featLabels[],Object[] testVec){        String firstStr = (String) inputTree.keySet().iterator().next();        HashMap secondDict = (HashMap) inputTree.get(firstStr);        int featIndex = 0;        for(featIndex=0;featIndex            if(featLabels[featIndex].equals(firstStr)){                break;            }        }        Object key = testVec[featIndex];        Object valueOfFeat = secondDict.get(key);        String classLabel ="erro";        if(valueOfFeat instanceof HashMap){            classLabel = classify((HashMap) valueOfFeat, featLabels, testVec);        }else{            classLabel = (String)valueOfFeat;        }        return classLabel;    }    private static int ListCount(ArrayList classList, String key) {        int c = 0;        for (String clazz : classList) {            if (clazz.equals(key)) {                c++;            }        }        return c;    }    private static LinkedHashMap sortMapByValues(Map aMap) {        Set> mapEntries = aMap.entrySet();        //System.out.println("Values and Keys before sorting ");        //for (Entry entry : mapEntries) {        //System.out.println(entry.getValue() + " - " + entry.getKey());        //}        // used linked list to sort, because insertion of elements in linked list is faster than an array list.         List> aList = new LinkedList>(mapEntries);        // sorting the List         Collections.sort(aList, new Comparator>() {            @Override            public int compare(Entry ele1, Entry ele2) {                return -(ele1.getValue().compareTo(ele2.getValue()));            }        });        // Storing the list into Linked HashMap to preserve the order of insertion.         LinkedHashMap aMap2 = new LinkedHashMap();        for (Entry entry : aList) {            aMap2.put(entry.getKey(), entry.getValue());        }        return aMap2;    }    public static void main(String[] args) throws Exception {        Object Dataset[][] = createDataSet();        Object tree = createTree(Dataset,new String[]{"weather", " temper", "humidity", "wind"});        System.out.println(tree);        String clazz = classify((HashMap) tree,new String[]{"weather", " temper", "humidity", "wind"},new Object[]{2,1,0,0});        System.out.println(clazz);    }}

一、Hadoop常见的三种运行模式1、单机模式（独立模式）（Local或Standalone  Mode）　　默认情况下Hadoop就是处于该模式，用于开发和调式。不对配置文件进行修改。使用本地文件系统，而不是分布式文件系统。　　Hadoop不会启动NameNode、DataNode、JobTracker、TaskTracker等守护进程，Map()和Reduce()任务作为同一个进程的不同部分来执行的。　　用于对MapReduce程序的逻辑进行调试，确保程序的正确。2、伪分布式模式（Pseudo-Distrubuted Mode）　　Hadoop的守护进程运行在本机机器，模拟一个小规模的集群，在一台主机模拟多主机。　　Hadoop启动NameNode、DataNode、JobTracker、TaskTracker这些守护进程都在同一台机器上运行，是相互独立的Java进程。　　在这种模式下，Hadoop使用的是分布式文件系统，各个作业也是由JobTraker服务，来管理的独立进程。在单机模式之上增加了代码调试功能，允许检查内存使用情况，HDFS输入输出，以及其他的守护进程交互。类似于完全分布式模式，因此，这种模式常用来开发测试Hadoop程序的执行是否正确。3、全分布式集群模式（Full-Distributed Mode）　　Hadoop的守护进程运行在一个集群上　Hadoop的守护进程运行在由多台主机搭建的集群上，是真正的生产环境。下载并解压Hadoop、JDK安装包并配置好环境变量、节点域名解析、防火墙、端口等组成相互连通的网络。进入Hadoop的解压目录,编辑hadoop-env.sh文件(注意不同版本后配置文件的位置有所变化)编辑Hadoop中配置文件core-site.xml（Hadoop集群的特性，作用于全部进程及客户端）、hdfs-site.xml（配置HDFS集群的工作属性）、mapred-site.xml（配置MapReduce集群的属性）、yarn-site.xml四个核心配置文件配置ssh,生成密钥,使到ssh可以免密码连接localhost，把各从节点生成的公钥添加到主节点的信任列表。格式化HDFS后 使用./start-all.sh启动Hadoop集群二、Hadoop常见组件Hadoop由HDFS、Yarn、Mapreduce三个核心模块组成，分别负责分布式存储、资源分配和管理、分布式计算。1、Hadoop-HDFS模块HDFS:是一种分布式存储系统，采用Master和Slave的主从结构，主要由NameNode和DataNode组成。HDFS会将文件按固定大小切成若干块，分布式存储在所有DataNode中，每个文件块可以有多个副本，默认副本数为3。NameNode: Master节点，负责元数据的管理，处理客户端请求。DataNode: Slave节点，负责数据的存储和读写操作。2、Hadoop-Yarn模块Yarn:是一种分布式资源调度框架，采用Master和Slave的主从结构，主要由ResourceManager . ApplicationMaster和NodeManager组成，负责整个集群的资源管理和调度。ResourceManager:是一个全局的资源管理器，负责整个集群的资源管理和分配。ApplicationMaster:当用户提交应用程序时启动，负责向ResourceManager申请资源和应用程序的管理。NodeManager:运行在Slave节点，负责该节点的资源管理和使用。Container: Yarn的资源抽象，是执行具体应用的基本单位，任何一个Job或应用程序必须运行在一个或多个Container中。3、Hadoop-Mapreduce模块Mapreduce:是一种分布式计算框架，主要由Map和Reduce两个阶段组成。支持将一个计算任务划分为多个子任务，分散到各集群节点并行计算。Map阶段:将初始数据分成多份，由多个map任务并行处理。Reduce阶段:收集多个Map任务的输出结果并进行合并，最终形成一个文件作为reduce阶段的结果。全分布式集群模式（Full-Distributed Mode）搭建【基本环境】三台鲲鹏km1.2xlarge.8内存优化型 8vCPUs | 64GB  CentOS 7.6 64bit with ARM   CPU:Huawei Kunpeng 920 2.6GHz其中jack20节点作为NameNode, Node1、 Node2作为DataNode,而Node1也作为辅助NameNode ( Secondary NameNode )。【基本流程】下载并解压Hadoop、JDK安装包并配置好环境变量、节点域名解析、防火墙、端口进入Hadoop的解压目录,编辑hadoop-env.sh文件(注意不同版本后配置文件的位置有所变化)编辑Hadoop中配置文件core-site.xml、hdfs-site.xml、mapred-site.xml、yarn-site.xml四个核心配置文件配置ssh,生成密钥,使到ssh可以免密码连接localhost 格式化HDFS后 使用./start-all.sh启动Hadoop集群关闭防火墙和selinux（1）各个节点都执行命令关闭防火墙：systemctl stop firewalldsystemctl disable firewalldsystemctl status firewalld（2）关闭selinux进入selinux的config文件，将selinux原来的强制模式（enforcing）修改为关闭模式（disabled）setenforce 0getenforcesed -i 's#SELINUX=enforcing#SELINUX=disabled#g' /etc/sysconfig/selinuxgrep SELINUX=disabled /etc/sysconfig/selinuxcat /etc/sysconfig/selinux1.安装openJDK-1.8.01.1. 下载安装openJDK-1.8.0下载openJDK-1.8.0并安装到指定目录（如“/home”）。进入目录：cd /home下载openJDK-1.8.0并安装：wget https://sandbox-experiment-resource-north-4.obs.cn-north-4.myhuaweicloud.com/hadoop-performance-tuning/OpenJDK8U-jdk_aarch64_linux_hotspot_8u252b09.tar.gz#解压tar -zxf OpenJDK8U-jdk_aarch64_linux_hotspot_8u252b09.tar.gz1.2. 配置环境变量执行如下命令，打开/etc/profile文件：vim /etc/profile点击键盘"Shift+g"移动光标至文件末尾，单击键盘“i”键进入编辑模式，在代码末尾回车下一行，添加如下内容：export JAVA_HOME=/home/jdk8u252-b09export PATH=$JAVA_HOME/bin:$PATHexport CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar添加完成，单击键盘ESC退出编辑，键入“:wq”回车保存并退出。 1.3. 环境变量生效使环境变量生效：source /etc/profile验证openJDK-1.8.0安装是否成功：java -version1.4.配置域名解析vim /etc/hosts2.安装dstat资源监控工具yum install dstat-0.7.2-12.el7 -y验证dstat是否安装成功：dstat -V3. 部署hadoop-3.1.13. 1. 获取hadoop-3.1.1软件包①下载hadoop-3.1.1安装包到/home目录下：cd /homewget https://sandbox-experiment-resource-north-4.obs.cn-north-4.myhuaweicloud.com/hadoop-performance-tuning/hadoop-3.1.1.tar.gz#解压hadoop-3.1.1tar -zxvf hadoop-3.1.1.tar.gz②建立软链接ln -s hadoop-3.1.1 hadoop③配置hadoop环境变量，打开/etc/profile文件：vim /etc/profile点击键盘"Shift+g"移动光标至文件末尾，单击键盘“i”键进入编辑模式，在代码末尾回车下一行，添加如下内容：export HADOOP_HOME=/home/hadoopexport PATH=$HADOOP_HOME/bin:$PATH添加完成，单击键盘ESC退出编辑，键入“:wq”回车保存并退出。④使环境变量生效：source /etc/profile⑤验证hadoop安装是否成功：hadoop version执行结果如下图所示，表示安装成功：3.2. 修改hadoop配置文件hadoop所有的配置文件都在$HADOOP_HOME/etc/hadoop目录下，修改以下配置文件前，需要切换到"$HADOOP_HOME/etc/hadoop"目录。cd $HADOOP_HOME/etc/hadoop/①修改hdfs-env.xml打开hadoop-env.sh文件：vim hadoop-env.sh找到hadoop-env.sh的第54行中的java目录（在命令模式下输入“:set nu”，查看行数），输入java的安装目录（），然后删除行左端“#”取消注释，并保存退出② 修改core-site.xml打开core-site.xml文件vim core-site.xml在标签之间添加如下代码并保存退出 fs.defaultFS hdfs://jack20:9000/ 设定NameNode的主机名及端口 hadoop.tmp.dir /home/hadoop/tmp/hadoop-${user.name} 指定hadoop 存储临时文件的目录 hadoop.proxyuser.hadoop.hosts * 配置该superUser允许通过代理的用户 hadoop.proxyuser.hadoop.groups * 配置该superUser允许通过代理用户所属组 ③ 修改hdfs-site.xml，打开hdfs-site.xml文件vim hdfs-site.xml在标签之间添加如下代码并保存退出 dfs.namenode.http-address jack20:50070 NameNode 地址和端口 dfs.namenode.secondary.http-address node1:50090 Secondary NameNode地址和端口 dfs.replication 3 设定 HDFS 存储文件的副本个数，默认为3 dfs.namenode.name.dir file:///home/hadoop/hadoop3.1/hdfs/name NameNode用来持续存储命名空间和交换日志的本地文件系统路径 dfs.datanode.data.dir file:///home/hadoop/hadoop3.1/hdfs/data DataNode在本地存储块文件的目录列表 dfs.namenode.checkpoint.dir file:///home/hadoop/hadoop3.1/hdfs/namesecondary 设置 Secondary NameNode存储临时镜像的本地文件系统路径。如果这是一个用逗号分隔的文件列表，则镜像将会冗余复制到所有目录 dfs.webhdfs.enabled true 是否允许网页浏览HDFS文件 dfs.stream-buffer-size 1048576 默认是4 KB，作为Hadoop缓冲区，用于Hadoop读HDFS的文件和写HDFS的文件， 还有map的输出都用到了这个缓冲区容量（如果太大了map和reduce任务可能会内存溢出） ④修改mapred-site.xml打开mapred-site.xml文件：vim mapred-site.xml在标签之间添加如下代码并保存退出 mapreduce.jobhistory.address jack20:10020 指定历史服务器端地址和端口 mapreduce.jobhistory.webapp.address jack20:19888 历史服务器web端地址和端口 mapreduce.application.classpath /home/hadoop/etc/hadoop, /home/hadoop/share/hadoop/common/*, /home/hadoop/share/hadoop/common/lib/*, /home/hadoop/share/hadoop/hdfs/*, /home/hadoop/share/hadoop/hdfs/lib/*, /home/hadoop/share/hadoop/mapreduce/*, /home/hadoop/share/hadoop/mapreduce/lib/*, /home/hadoop/share/hadoop/yarn/*, /home/hadoop/share/hadoop/yarn/lib/* mapreduce.map.memory.mb 6144 map container配置的内存的大小（调整到合适大小防止物理内存溢出） mapreduce.reduce.memory.mb 6144 reduce container配置的内存的大小（调整到合适大小防止物理内存溢出） yarn.app.mapreduce.am.env HADOOP_MAPRED_HOME=/home/hadoop mapreduce.map.env HADOOP_MAPRED_HOME=/home/hadoop mapreduce.reduce.env HADOOP_MAPRED_HOME=/home/hadoop ⑤修改yarn-site.xml打开yarn-site.xml文件：vim yarn-site.xml在标签之间添加如下代码并保存退出 yarn.resourcemanager.hostname jack20 指定ResourceManager的主机名 yarn.nodemanager.resource.memory-mb 53248 NodeManager总的可用物理内存。 注意：该参数是不可修改的，一旦设置，整个运行过程中不可动态修改。 该参数的默认值是8192MB，即使你的机器内存不够8192MB，YARN也会按照这些内存来使用， 因此，这个值通过一定要配置。 yarn.nodemanager.aux-services mapreduce_shuffle 指定MapReduce走shuffle yarn.nodemanager.aux-services.mapreduce.shuffle.class org.apache.hadoop.mapred.ShuffleHandler yarn.resourcemanager.address jack20:8032 指定ResourceManager对客户端暴露的地址和端口，客户端通过该地址向RM提交应用程序，杀死应用程序等 yarn.resourcemanager.scheduler.address jack20:8030 指定ResourceManager对ApplicationMaster暴露的访问地址。ApplicationMaster通过该地址向RM申请资源、释放资源等 yarn.resourcemanager.resource-tracker.address jack20:8031 指定ResourceManager对NodeManager暴露的地址。NodeManager通过该地址向RM汇报心跳，领取任务等 yarn.resourcemanager.admin.address jack20:8033 指定ResourceManager 对管理员暴露的访问地址。管理员通过该地址向RM发送管理命令等 yarn.resourcemanager.webapp.address jack20:8088 指定ResourceManager对外web UI地址。用户可通过该地址在浏览器中查看集群各类信息 yarn.log-aggregation-enable true 开启日志聚集功能 yarn.log.server.url http://jack20:19888/jobhistory/logs 设置日志聚集服务器地址 yarn.log-aggregation.retain-seconds 604800 设置日志保留时间为7天 ⑥将各个节点加入到workersecho jack20 > workersecho node1 > workersecho node2 > workers⑦修改dfs和yarn的启动脚本，添加root用户权限（1）打开start-dfs.sh和stop-dfs.sh文件：vim /home/hadoop/sbin/start-dfs.shvim /home/hadoop/sbin/stop-dfs.sh单击键盘“i”键进入编辑模式，在两个配置文件的第一行添加并保存退出：HDFS_DATANODE_USER=rootHDFS_DATANODE_SECURE_USER=hdfsHDFS_NAMENODE_USER=rootHDFS_SECONDARYNAMENODE_USER=root（2）打开start-yarn.sh 和 stop-yarn.sh文件vim /home/hadoop/sbin/start-yarn.shvim /home/hadoop/sbin/stop-yarn.sh单击键盘“i”键进入编辑模式，在两个配置文件的第一行添加并保存退出：YARN_RESOURCEMANAGER_USER=rootHADOOP_SECURE_DN_USER=yarnYARN_NODEMANAGER_USER=root4.集群配置&节点间免密登录（1）连通性测试（2）从主节点同步各个节点域名解析文件scp /etc/hosts node1:/etc/hostsscp /etc/hosts node2:/etc/hosts（3） 配置各节点间SSH免密登录分别在三台服务器中输入命令生成私钥和公钥（提示输入时按回车即可）：ssh-keygen -t rsajack20：node1：node2：然后分别在三台服务器上输入命令以复制公钥到服务器中：ssh-copy-id -i ~/.ssh/id_rsa.pub root@jack20ssh-copy-id -i ~/.ssh/id_rsa.pub root@node1ssh-copy-id -i ~/.ssh/id_rsa.pub root@node2①继续连接：输入“yes”回车；②输入密码（输入密码时，命令行窗口不会显示密码，输完之后直接回车）查看所有协商的秘钥SSH免密登录测试：Jack20->node1->node2->jack20->node2->node1->jack20（4） 复制hadoop到各datanode并修改把jack20的hadoop目录、jdk目录、/etc/hosts、/etc/profile复制到node1，node2节点cd $HADOOP_HOME/..#hadoop目录scp -r hadoop node1:/homescp -r hadoop node2:/home #java目录scp -r jdk8u252-b09 node1:/homescp -r jdk8u252-b09 node2:/home登录修改各服务器java和haoop环境变量vim /etc/profile点击键盘"Shift+g"移动光标至文件末尾，单击键盘“i”键进入编辑模式，在代码末尾回车下一行，添加如下内容并保存退出：export JAVA_HOME=/home/jdk8u252-b09export PATH=$JAVA_HOME/bin:$PATHexport CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jarexport HADOOP_HOME=/home/hadoopexport PATH=$HADOOP_HOME/bin:$PATH使环境变量生效：source /etc/profile5.启动hadoop注意：如果启动报错，请检查hadoop配置文件是否配置有误。第一次启动前一定要格式化HDFS：hdfs namenode -format注意：提示信息的倒数第2行出现“>= 0”表示格式化成功，如图。在Linux中，0表示成功，1表示失败。因此，如果返回“1”，就应该好好分析前面的错误提示信息，一 般来说是前面配置文件和hosts文件的问题，修改后同步到其他节点上以保持相同环境，再接着执行格式化操作执行脚本命令群起节点cd /home/hadoop/sbin#群起节点./start-all.sh       启动HDFS后，可以发现jack20节点作为NameNode, Node1、 Node2作为DataNode,而Node1也作为辅助NameNode ( Secondary NameNode )。可以通过jps命令在各节点上验证HDFS是否启动。jps 也是Windows中的命令，表示开启的Java进程如果出现下图所示的结果，就表示验证成功。客户端Web访问测试：（1）RMwebUI界面http://IP:8088（2）NameNode的webUI界面http://IP:500706.集群基准测试（1）使用Hadoop自带的WordCount例子/share/Hadoop/mapredu icehadoop-mapreduce-examples-3.1.1.jar验证集群#创建目录，目录/data/wordcount用来存储Hadoop自带的WordCount例子的数据文件，运行这个MapReduce任务的结果输出到目录中的/output/wordcount文件中hdfs dfs -mkdir -p /data/wordcounthdfs dfs -mkdir -p /output/ #将本地文件上传到HDFS中(这里上传一个配置文件),执行如下命令hdfs dfs -put /home/hadoop/etc/hadoop/core-site.xml /data/wordcount可以查看，上传后的文件情况，执行如下命令hdfs dfs -ls /data/wordcount下面运行WordCount案例，执行如下命令hadoop jar /home/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.1.jar wordcount /data/wordcount /output/wordcount（2）DFSIO测试使用hadoop的DFSIO写入50个文件，每个文件1000Mhadoop jar /home/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.1.1-tests.jar TestDFSIO -write -nrFiles 50 -filesize 1000可以在RMwebUI界面查看当前任务的基本情况，包括内存使用量，CPU使用量等在NameNode的webUI界面查看刚刚DFSIO测试的各个节点HDFS占用情况（3）计算圆周率的大小hadoop jar /home/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.1.1-tests.jar pi 20 20静静等待结果就可以~