一、电瓶车轮胎厂家

<>
  
    
电瓶车轮胎厂家: 选择适合您的电动车轮胎

    
尽管电动车在市场上的份额越来越大，但轮胎作为电动车的重要组成部分却常常被忽视。事实上，选择适合您的电动车轮胎对您的驾驶体验和安全至关重要。在市场上，有许多电瓶车轮胎厂家提供各种不同类型和规格的轮胎，因此，选择合适的轮胎可能会变得有些困难。本文将为您提供一些关于电动车轮胎的信息和选购建议，帮助您做出明智的选择。

    
电动车轮胎的重要性

    
电动车轮胎承受着整个车辆的重量，同时也需要应对各种路况。良好的轮胎能够提供更好的操控性能、舒适性和安全性。选择合适的电动车轮胎可以帮助减少能耗、延长电池寿命，并为您的电动车提供更好的性能。

    
选择合适的电动车轮胎

    
在选择电动车轮胎时，有几个关键因素需要考虑：

    

      
1. 载重能力: 不同型号的电动车承载能力各不相同。请查阅您的电动车说明书或咨询电动车制造商，了解您的车辆所需的轮胎载重能力。
      
2. 路况适应性: 电动车通常在城市道路上行驶，但也可能遇到不同的路况，如不平整的路面、湿滑的路面等。根据您通常行驶的路况，选择具有合适胎面花纹和橡胶材质的轮胎。
      
3. 耐磨性: 电动车轮胎的耐磨性对于延长轮胎使用寿命至关重要。选择具有良好耐磨性的轮胎，可以减少更换轮胎的频率，同时降低维护成本。
      
4. 轮胎尺寸: 了解您的电动车所需的轮胎尺寸是非常重要的。正确尺寸的轮胎可以确保车辆的正常运行和安全性。
    

    
如何选择可靠的电瓶车轮胎厂家

    
选择可靠的电瓶车轮胎厂家是确保您获得优质产品和满意服务的关键。以下是选择电瓶车轮胎厂家的几个重要因素：

    

      
1. 信誉度: 选择具有良好信誉度的电瓶车轮胎厂家可以确保您获得高质量的产品。查阅在线评论和客户评价，了解厂家的声誉和客户满意度。
      
2. 经验和专业知识: 选择有丰富经验和专业知识的厂家，他们能够提供更准确的建议和更优秀的产品。
      
3. 品质保证: 选择提供品质保证的厂家，他们愿意为其产品负责并提供售后服务。
      
4. 价格和性价比: 考虑不同厂家的价格和性价比。选择合理的价格和高品质的产品。
    

    
电动车轮胎维护提示

    
一旦您选择了合适的电动车轮胎，正确的维护将有助于延长其使用寿命并保持优秀性能。以下是一些常见的维护提示：

    

      
1. 定期检查胎压: 保持适当的胎压对于电动车轮胎的正常运行至关重要。定期检查胎压，并根据需要进行充气。
      
2. 定期旋转轮胎: 对电动车轮胎进行定期旋转，可以均匀磨损轮胎，延长使用寿命。
      
3. 注意路况: 避免在恶劣的路况下行驶，如尖锐物体、坑洞等。这些都可能损坏电动车轮胎。
      
4. 清洁轮胎: 定期清洁轮胎，以去除泥土、油污和其他污染物，保持轮胎外观和性能。
    

    
结论

    
选择适合您的电动车轮胎至关重要。了解您的车辆需求，选择合适的载重能力、路况适应性、耐磨性和尺寸的轮胎。同时，选择可靠的电瓶车轮胎厂家，以保证产品质量和满意的售后服务。正确的维护也是延长轮胎寿命和保持优秀性能的关键。通过根据本文的建议，您将能够选择合适的电动车轮胎，提升驾驶体验并确保安全。
  

二、中国轮胎厂家排名

中国轮胎厂家排名：探索中国轮胎行业的竞争力

中国轮胎行业一直以来都备受关注，无论是国内还是国际市场，中国的轮胎制造商都扮演着举足轻重的角色。然而，在众多的轮胎厂家中，如何评估其实力以及排名呢？本文将带您深入了解中国轮胎厂家排名的相关信息。

1. 宏观背景

中国作为全球制造业的中心之一，其轮胎产业在过去几十年中取得了长足的发展。中国的轮胎厂家不仅满足了国内巨大的需求，还迅速成为了国际市场的重要供应商。如今，中国轮胎已经占据了全球轮胎市场的一席之地。

中国轮胎行业的发展得益于多种因素，例如对技术创新的持续投入、市场规模的扩大以及政府的支持政策等。随着海外市场对中国轮胎的认可度和需求的增加，中国轮胎厂家的竞争力也逐渐提升。

2. 中国轮胎厂家排名的依据

评估中国轮胎厂家排名的依据主要包括以下几个方面：

• 产销规模：衡量企业实力的重要指标之一，通常使用年产量和销售额来评估。
• 技术创新：不断推陈出新的技术能力是企业竞争力的重要保障。
• 产品质量：优质的产品是赢得市场和客户信任的基础。
• 市场份额：企业在国内外市场的占有率。
• 品牌知名度：广为人知的品牌往往代表着企业的声望和影响力。
• 市场竞争力：企业在市场中的竞争地位和发展趋势。

以上因素综合考量，我们可以评估出中国轮胎厂家的排名和实力。

3. 中国轮胎厂家排名的前几名

根据最新的数据和市场研究，以下是中国轮胎厂家排名的前几名：

1. 海南橡胶集团：作为中国最大的轮胎制造商之一，海南橡胶集团凭借其卓越的技术能力和品牌影响力，长期稳居中国轮胎厂家排名的榜首。
2. 青岛双星集团：作为国内最早涉足轮胎行业的企业之一，青岛双星集团凭借其雄厚的实力和不断创新的精神，一直在中国轮胎厂家中占据重要地位。
3. 中华轮胎集团：经过多年的发展，中华轮胎集团已经成为国内领先的轮胎制造商之一，其产品不仅在国内市场占有重要地位，还远销海外。
4. 普利司通中国：作为全球领先的轮胎制造商之一，普利司通在中国市场也有着强大的影响力。其高品质的产品深受消费者的喜爱。
5. 山东玉山集团：作为中国知名的轮胎制造商之一，山东玉山集团凭借其良好的品质和服务获得了广泛的赞誉。

这些企业以其专业的研发能力、先进的生产技术、稳定的市场表现以及良好的产品质量在中国轮胎行业中立于不败之地。

4. 中国轮胎行业的未来发展

中国轮胎行业作为全球轮胎市场的重要参与者，未来的发展前景令人期待。随着国内外市场需求的不断增长、技术创新的加速以及经济的持续发展，中国轮胎厂家将面临更广阔的发展机遇。

未来，中国轮胎行业将继续努力提升产品技术含量，加强品牌建设，并进一步扩大在国际市场的份额。同时，环保和可持续发展也将成为中国轮胎行业发展的重要方向。

总的来说，中国轮胎厂家的排名与实力既受制于市场需求、技术水平，也受到品牌建设、质量控制等因素的影响。未来，随着中国轮胎行业的持续发展和成熟，我们有理由相信，中国的轮胎厂家将在全球市场上继续发挥重要作用。

三、轮胎厂前景怎么样

轮胎厂前景怎么样

作为汽车行业的重要组成部分，轮胎产业一直以来都备受关注。随着我国汽车产量的不断增长和消费者对轮胎质量的要求越来越高，轮胎厂的前景也备受瞩目。那么，轮胎厂的未来发展如何呢？让我们一起来看看。

市场需求持续增长

随着我国汽车保有量的不断攀升，轮胎市场的需求也保持着良好的增长势头。根据相关数据显示，轮胎消费量每年都以一个不小的幅度增长，这意味着轮胎厂将有更大的市场空间可以发展。同时，随着消费者对轮胎安全性、耐磨性和燃油效率等方面要求的提高，轮胎企业需要不断创新，研发出更高质量的产品来满足市场需求。

技术创新助力发展

在轮胎产业中，技术始终是关键。随着科技的不断进步，轮胎产品的制造技术也在不断创新。例如，采用新材料和新工艺制造的轮胎，在抓地力、舒适性和减震效果方面都有了显著的提升。另外，智能化技术的应用也为轮胎厂带来了新的机遇。通过采用传感器、互联网等技术手段，轮胎企业可以更好地收集和分析轮胎使用数据，提供更加个性化的服务，满足消费者日益增长的个性化需求。

此外，绿色环保也成为了轮胎厂发展的重要方向。随着全球环境保护意识的提高，消费者对于环保性能良好的产品需求也在增加。因此，轮胎企业需要在研发过程中注重减少对环境的影响，推出更加环保的产品，以满足市场需求。

产业转型升级势在必行

当前，我国的轮胎产业面临着一些挑战，如产能过剩、竞争激烈等问题。为了在激烈的市场竞争中立于不败之地，轮胎厂需要进行产业转型升级。

首先，轮胎企业需要加大对研发创新的投入。通过引进和培养高端人才，加强与科研机构和高校的合作，不断提升自主研发能力。只有通过技术创新，才能不断提高产品质量和竞争力。

其次，轮胎企业还需要加强品牌建设和市场营销。通过塑造独特的品牌形象，提升产品知名度和美誉度。同时，加强与汽车厂商和售后市场的合作，拓展市场渠道，提高产品销售量。

此外，加强国际合作也是轮胎企业转型升级的重要举措。通过与国外先进企业进行合作，引进先进的生产技术和管理经验，提高自身的竞争力。同时，积极拓展国际市场，提升产品出口能力，实现更好的发展。

市场竞争加剧，行业洗牌势在必行

随着我国轮胎市场的发展，竞争也日趋激烈。当前，轮胎企业数量众多，但绝大部分都是规模较小的中小企业，而国内外知名大型轮胎企业则占据了市场的大部分份额。未来，随着市场竞争的加剧，行业洗牌势在必行。

在市场竞争中，只有具备一定规模的企业才能更好地应对和适应市场变化。因此，轮胎企业需要加强合并重组，实现资源整合和规模化经营。通过整合各方资源，提高市场占有率，降低生产成本，提高企业竞争力。

此外，通过提高品牌知名度和产品质量，打造自己的核心竞争力。只有具备独特的品牌形象和核心技术的企业才能在激烈的市场竞争中脱颖而出。

结语

从市场需求的持续增长到技术创新的助力发展，从产业转型升级的势在必行到市场竞争的加剧，轮胎厂的前景充满了希望和挑战。作为轮胎厂，只有不断与时俱进，加强技术创新，实现产业转型，才能在行业中立于不败之地。

四、大连轮胎厂旗下品牌

大连轮胎厂旗下品牌是中国轮胎行业的知名品牌之一。作为中国最大的轮胎制造商之一，大连轮胎厂一直以来致力于为消费者提供高品质的轮胎产品。在竞争激烈的市场中，大连轮胎厂旗下品牌凭借着卓越的技术和良好的口碑，赢得了广大消费者的认可和信赖。

大连轮胎厂旗下品牌的产品种类齐全

大连轮胎厂旗下品牌生产的轮胎产品种类齐全，涵盖了小型车辆、中型车辆、大型车辆甚至特种车辆的轮胎需求。无论是日常通勤还是越野驾驶，大连轮胎厂旗下品牌都能提供适合的轮胎选择。

技术创新是大连轮胎厂旗下品牌的核心竞争力

大连轮胎厂旗下品牌一直将技术创新作为提升产品竞争力的核心策略。他们不断投资于研发与创新，引领着中国轮胎行业的技术发展。通过引进国际先进的生产设备和工艺，大连轮胎厂旗下品牌的产品质量和性能得到了显著提升。

大连轮胎厂旗下品牌的技术创新不仅表现在轮胎材料和结构上，还体现在轮胎性能的持久稳定性、抓地力以及降低噪音等方面。他们不断探索新的材料应用，提高轮胎的防滑性能和操控性能，为消费者提供更安全、更舒适的驾驶体验。

大连轮胎厂旗下品牌的质量控制体系严格

作为中国轮胎行业的标杆企业，大连轮胎厂旗下品牌一直以来都非常注重质量控制。他们建立了一套严格的质量控制体系，从原材料采购到生产制造，再到产品检验，每一个环节都严把质量关。

大连轮胎厂旗下品牌的质量控制体系主要包括以下几个方面：

• 严格的原材料采购，确保每一批原材料符合要求。
• 先进的生产设备和工艺，保证产品的生产质量。
• 严格的产品检验标准，确保每一个产品都符合国家相关标准。
• 建立售后服务体系，及时处理消费者的投诉和需求。

大连轮胎厂旗下品牌的市场表现出色

多年来，大连轮胎厂旗下品牌在市场上的表现十分出色。无论是在国内市场还是国际市场，大连轮胎厂旗下品牌都取得了显著的成绩。

在国内市场，大连轮胎厂旗下品牌凭借卓越的产品质量和良好的口碑，赢得了广大消费者的青睐。他们的产品覆盖面广，价格适中，可靠性高，受到了无数消费者的信赖。

在国际市场，大连轮胎厂旗下品牌也取得了较大的认可度。他们的产品远销海外，打破了外国品牌在国际市场上的垄断地位。大连轮胎厂旗下品牌的出口额逐年增加，为中国的轮胎行业争光。

结语

大连轮胎厂旗下品牌凭借着技术创新、严格的质量控制以及出色的市场表现，成为了中国轮胎行业的佼佼者。他们以用户需求为导向，不断提高产品质量和技术水平，为广大消费者提供优质的轮胎产品。

相信在不久的将来，大连轮胎厂旗下品牌将会在国内外市场上取得更加辉煌的成绩，为中国轮胎行业作出更大的贡献。

五、ringjoy轮胎厂家？

ringjoy是乐路驰轮胎牌子。

是青岛乐路驰轮胎有限公司品牌，生产基地在东营大王镇，主要生产高性能子午线轮胎，其优点是坚固耐用、性价比高。

乐路驰主打静音舒适，同时兼具操控性，其耐磨里程在正常情况下可以行驶6至7万公里，比较适合中短途家用经济型轿车选择。乐路驰轮胎的胎质宽厚且结实，其轮辋上带有防撞保护圈，采用不对称的花纹设计，静音、耐磨，操控性能好，正常行驶在6万公里左右，比较适合喜欢开快车跑长途的车主，主要适配中高端轿车。

六、重庆轮胎厂？

重庆正新轮胎厂是正新橡胶（中国）有限公司在重庆长寿区晏家工业园区投资设立的分厂，预计11年6月投产。正新橡胶目前在全球轮胎行业排名第十名，目前发展的很迅速！

七、河南轮胎厂？

河南东信轮胎有限公司 河南温县大华轮胎厂河南天宝轮胎有限公司焦作轮胎厂 (河南轮胎厂）河南风神轮胎有限公司等。

八、轮胎厂什么岗位比较好

<>

轮胎厂什么岗位比较好

在当今竞争激烈的就业市场中，选择一个适合自己的职业岗位至关重要。对于想要在轮胎厂工作的人来说，了解不同岗位的特点和潜在发展机会是至关重要的。本文将讨论轮胎厂不同的岗位，以帮助您了解哪个岗位可能更适合您。

销售岗位

销售岗位是轮胎厂中至关重要的一环。销售团队负责与客户接触，推广和销售公司的产品。他们需要具备良好的沟通能力和销售技巧。销售岗位的优势有：

• 有竞争力的薪资和奖励机制。
• 培养自信心和人际交往能力。
• 为自己创造销售业绩的机会。

生产制造岗位

生产制造岗位是轮胎厂的核心部门。在这个岗位上，员工负责生产轮胎，操作生产线以及执行质量控制。选择生产制造岗位的优势包括：

• 稳定的工作，因为生产始终需要。
• 机会学习和掌握生产技术和流程。
• 培养良好的团队合作能力。

研发岗位

研发岗位是轮胎厂中需要高级技术知识的岗位。研发团队负责开发新的轮胎产品和改进现有产品。选择研发岗位的优势有：

• 参与新产品的创造和创新。
• 与技术专家和工程师团队合作。
• 为自己提供持续学习和发展的机会。

质量控制岗位

质量控制岗位在轮胎厂中非常重要。质量控制团队负责检查和测试产品，确保其符合标准和质量要求。选择质量控制岗位的优势包括：

• 谨慎和细致的工作态度。
• 保证产品质量和安全性。
• 为企业提供持续改进的建议。

供应链管理岗位

供应链管理岗位关注整个供应链的流程和协调。员工负责与供应商和分销商合作，确保物流运作的顺利。选择供应链管理岗位的优势有：

• 与供应商和分销商建立良好关系。
• 了解物流和供应链的运作方式。
• 发展谈判和沟通技巧。

总结

无论您选择哪个岗位，轮胎厂都提供了丰富的发展机会。销售岗位可以带来丰厚的回报，生产制造岗位提供稳定的工作，研发岗位可以满足创新的渴望，质量控制岗位有助于提高产品质量，供应链管理岗位可以培养协调和谈判技巧。最重要的是，选择一个岗位要符合您的兴趣、技能和个人目标。只有在适合自己的岗位上才能实现事业的成功。

九、正新轮胎厂哪个部门好

正新轮胎厂哪个部门好

正新轮胎厂是中国一家知名的轮胎制造公司，拥有多个部门，各个部门都扮演着不同的角色，为公司的发展作出了重要贡献。那么在众多部门中，到底哪个部门是最好的呢？在本文中，我们将对正新轮胎厂的几个重要部门进行介绍和对比，以便给读者一个更清晰的了解。

1. 研发部门

在正新轮胎厂，研发部门是公司的核心部门之一。该部门负责新产品的研发和技术创新，通过不断的研究和试验，提高轮胎的性能和质量。研发部门拥有一支专业的研发团队，他们具备丰富的技术经验和创新意识。通过与国内外科研机构的合作，研发部门能够不断引进先进的技术和工艺，保持正新轮胎在市场上的竞争力。

2. 生产部门

正新轮胎厂的生产部门是公司的生命线。生产部门负责轮胎的制造和生产流程的控制，保证产品的质量和交付时间。该部门拥有一支高效的生产团队，他们熟悉生产工艺，具备良好的操作技巧。生产部门采用先进的设备和技术，严格执行质量管理体系，确保每一只轮胎都符合公司的标准和要求。

3. 销售部门

销售部门是正新轮胎厂与客户之间的桥梁。该部门负责市场营销和销售业务，开拓新客户和维护老客户的关系。销售部门拥有一支专业的销售团队，他们了解市场需求，提供符合客户需求的解决方案。销售部门与研发部门和生产部门密切合作，确保产品的市场竞争力和销售额的增长。

4. 售后服务部门

售后服务部门是正新轮胎厂为客户提供的一项重要服务。该部门负责处理客户的投诉和售后问题，提供技术支持和解决方案。售后服务部门拥有一支专业的服务团队，他们具备良好的沟通能力和问题处理能力。通过及时、有效的售后服务，售后服务部门能够保持客户的满意度和忠诚度。

5. 质量控制部门

质量控制部门是保证正新轮胎产品质量的关键部门。该部门负责制定和实施质量管理体系，监控生产过程和产品质量。质量控制部门拥有一支专业的质量团队，他们熟悉相关的质量标准和检测方法。通过严格的质量控制和检测，质量控制部门能够确保产品的合格率和稳定性。

结论

正新轮胎厂的各个部门各司其职，合作紧密，为公司的发展做出了重要贡献。研发部门的创新能力、生产部门的执行力、销售部门的市场拓展能力、售后服务部门的专业服务水平和质量控制部门的严谨态度，都是正新轮胎厂取得成功的关键因素。

因此，要说哪个部门是最好的，实际上并没有标准答案。每个部门的作用都是不可或缺的，只有各个部门的密切合作和优秀团队的共同努力，才能使正新轮胎厂在激烈的市场竞争中立于不败之地。

十、mahout面试题？

之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。

训练数据：

Day Outlook Temperature Humidity Wind PlayTennis

D1 Sunny Hot High Weak No

D2 Sunny Hot High Strong No

D3 Overcast Hot High Weak Yes

D4 Rain Mild High Weak Yes

D5 Rain Cool Normal Weak Yes

D6 Rain Cool Normal Strong No

D7 Overcast Cool Normal Strong Yes

D8 Sunny Mild High Weak No

D9 Sunny Cool Normal Weak Yes

D10 Rain Mild Normal Weak Yes

D11 Sunny Mild Normal Strong Yes

D12 Overcast Mild High Strong Yes

D13 Overcast Hot Normal Weak Yes

D14 Rain Mild High Strong No

检测数据：

sunny，hot，high，weak

结果：

Yes=》 0.007039

No=》 0.027418

于是使用Java代码调用Mahout的工具类实现分类。

基本思想：

1. 构造分类数据。

2. 使用Mahout工具类进行训练，得到训练模型。

3。将要检测数据转换成vector数据。

4. 分类器对vector数据进行分类。

接下来贴下我的代码实现=》

1. 构造分类数据：

在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。

数据文件格式，如D1文件内容： Sunny Hot High Weak

2. 使用Mahout工具类进行训练，得到训练模型。

3。将要检测数据转换成vector数据。

4. 分类器对vector数据进行分类。

这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》

package myTesting.bayes;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.FileSystem;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.util.ToolRunner;

import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;

import org.apache.mahout.text.SequenceFilesFromDirectory;

import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;

public class PlayTennis1 {

private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";

/*

* 测试代码

*/

public static void main(String[] args) {

//将训练数据转换成 vector数据

makeTrainVector();

//产生训练模型

makeModel(false);

//测试检测数据

BayesCheckData.printResult();

}

public static void makeCheckVector(){

//将测试数据转换成序列化文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"testinput";

String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();

String[] params = new String[]{"-i",input,"-o",output,"-ow"};

ToolRunner.run(sffd, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("文件序列化失败！");

System.exit(1);

}

//将序列化文件转换成向量文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";

String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();

String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};

ToolRunner.run(svfsf, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("序列化文件转换成向量失败！");

System.out.println(2);

}

}

public static void makeTrainVector(){

//将测试数据转换成序列化文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"input";

String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();

String[] params = new String[]{"-i",input,"-o",output,"-ow"};

ToolRunner.run(sffd, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("文件序列化失败！");

System.exit(1);

}

//将序列化文件转换成向量文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";

String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();

String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};

ToolRunner.run(svfsf, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("序列化文件转换成向量失败！");

System.out.println(2);

}

}

public static void makeModel(boolean completelyNB){

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";

String model = WORK_DIR+Path.SEPARATOR+"model";

String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";

Path in = new Path(input);

Path out = new Path(model);

Path label = new Path(labelindex);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

if(fs.exists(label)){

//boolean参数是，是否递归删除的意思

fs.delete(label, true);

}

TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();

String[] params =null;

if(completelyNB){

params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};

}else{

params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};

}

ToolRunner.run(tnbj, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("生成训练模型失败！");

System.exit(3);

}

}

}

package myTesting.bayes;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.lang.StringUtils;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.fs.PathFilter;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.LongWritable;

import org.apache.hadoop.io.Text;

import org.apache.mahout.classifier.naivebayes.BayesUtils;

import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;

import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;

import org.apache.mahout.common.Pair;

import org.apache.mahout.common.iterator.sequencefile.PathType;

import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;

import org.apache.mahout.math.RandomAccessSparseVector;

import org.apache.mahout.math.Vector;

import org.apache.mahout.math.Vector.Element;

import org.apache.mahout.vectorizer.TFIDF;

import com.google.common.collect.ConcurrentHashMultiset;

import com.google.common.collect.Multiset;

public class BayesCheckData {

private static StandardNaiveBayesClassifier classifier;

private static Map<String, Integer> dictionary;

private static Map<Integer, Long> documentFrequency;

private static Map<Integer, String> labelIndex;

public void init(Configuration conf){

try {

String modelPath = "/zhoujianfeng/playtennis/model";

String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";

String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";

String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";

dictionary = readDictionnary(conf, new Path(dictionaryPath));

documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));

labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));

NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);

classifier = new StandardNaiveBayesClassifier(model);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("检测数据构造成vectors初始化时报错。。。。");

System.exit(4);

}

}

/**

* 加载字典文件，Key: TermValue； Value：TermID

* @param conf

* @param dictionnaryDir

* @return

*/

private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {

Map<String, Integer> dictionnary = new HashMap<String, Integer>();

PathFilter filter = new PathFilter() {

@Override

public boolean accept(Path path) {

String name = path.getName();

return name.startsWith("dictionary.file");

}

};

for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {

dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());

}

return dictionnary;

}

/**

* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq

* @param conf

* @param dictionnaryDir

* @return

*/

private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {

Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();

PathFilter filter = new PathFilter() {

@Override

public boolean accept(Path path) {

return path.getName().startsWith("part-r");

}

};

for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {

documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());

}

return documentFrequency;

}

public static String getCheckResult(){

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String classify = "NaN";

BayesCheckData cdv = new BayesCheckData();

cdv.init(conf);

System.out.println("init done...............");

Vector vector = new RandomAccessSparseVector(10000);

TFIDF tfidf = new TFIDF();

//sunny，hot，high，weak

Multiset<String> words = ConcurrentHashMultiset.create();

words.add("sunny",1);

words.add("hot",1);

words.add("high",1);

words.add("weak",1);

int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数

for (Multiset.Entry<String> entry : words.entrySet()) {

String word = entry.getElement();

int count = entry.getCount();

Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，

if (StringUtils.isEmpty(wordId.toString())){

continue;

}

if (documentFrequency.get(wordId) == null){

continue;

}

Long freq = documentFrequency.get(wordId);

double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);

vector.setQuick(wordId, tfIdfValue);

}

// 利用贝叶斯算法开始分类,并提取得分最好的分类label

Vector resultVector = classifier.classifyFull(vector);

double bestScore = -Double.MAX_VALUE;

int bestCategoryId = -1;

for(Element element: resultVector.all()) {

int categoryId = element.index();

double score = element.get();

System.out.println("categoryId:"+categoryId+" score:"+score);

if (score > bestScore) {

bestScore = score;

bestCategoryId = categoryId;

}

}

classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";

return classify;

}

public static void printResult(){

System.out.println("检测所属类别是："+getCheckResult());

}

}