python, 人工智能 2月 21,2021

精心挑选的100多种机器学习数据集

毫无疑问，每个人都知道，学习数据科学和机器学习的唯一最佳方法是通过执行各种项目来学习它们。老实说，您周围有很多现实世界的机器学习数据集，即使您不必完成全面的数据科学或机器学习课程，也可以选择练习基础数据科学和机器学习技能。但是是的，数据科学和机器学习项目绝对没有其他选择。大多数数据科学和机器学习初学者做错的事情是，他们只是专注于学习许多理论概念，而等待太长时间才能启动专注于该概念的实际实现的机器学习/数据科学项目。毫无疑问，从理论上讲清楚您的机器学习概念总会很好，但是如果没有获得相关的实际经验，您就无法期望成为企业数据科学家或机器学习工程师。在此博客的此处，我们将为您提供100多个有价值的数据集，以供机器学习（特别是对于初学者）使用，这无疑将有助于验证您的基本数据科学和机器学习技能。

机器学习中的数据集是什么？
机器学习中的数据集是实例的集合（实例是指一行数据），这些实例都共享一些共同的特征和属性。为了使机器学习模型执行不同的动作，需要两种数据集–

训练数据集-送入机器学习算法进行训练的数据。

测试数据集或验证数据集–用于评估和测试机器学习模型正在正确解释的数据。

为什么需要机器学习数据集？
机器学习算法从数据中学习。机器学习算法可识别趋势，关系并根据为训练模型而提供的大量数据进行预测。因此，数据是机器学习中的金鹅。从机器学习模型中收集的见解与数据集一样好。对于机器学习项目而言，拥有大量且更好的训练数据可带来更好而准确的模型性能。可靠的机器学习数据集非常重要，并且在精确的机器学习模型的开发中起着至关重要的作用。

可在此处免费访问已解决的机器学习Python和R代码示例（这些已为您的项目准备使用）

在哪里可以找到用于机器学习的数据集？
有大量的免费和付费资源可用于机器学习数据集。公共机器学习数据集可帮助您入门的最受欢迎资源包括–

UCI或UC Irvine机器学习数据集存储库
AWS数据集
Google数据集搜索
数据政府
微软研究开放数据
卡格勒
世界银行
但是，对于数据科学和机器学习的初学者来说，从这些网站上提供的众多选项中进行选择可能会变得势不可挡。如果您想学习机器学习，则需要一个坚实的基础，这意味着用于机器学习项目的有趣数据集，以及一些可以使用这些免费数据集的很棒的项目构想。想知道在哪里可以找到免费和公共的机器学习数据集？别无所求……无论是零售，医疗保健，银行与金融，犯罪，还是其他任何类型的机器学习数据集，我们都精选了一系列顶级机器学习数据集，以帮助您使模型成功。

面向数据科学和机器学习从业人员的100多种机器学习数据集
机器学习数据集

我们汇总了一个以领域为中心的顶级机器学习数据集列表，其中包含对数据和可以使用特定数据集进行的项目的简短描述。

零售机器学习数据集
医疗保健机器学习数据集
银行和金融机器学习数据集
社交媒体机器学习数据集
犯罪机器学习数据集

机器学习的最佳零售数据集
机器学习的零售数据集
零售交易机器学习数据集
1）在线零售数据集（英国在线商店）

如果您热衷于预处理大型零售数据集，则可能希望查找这家英国的在线公司的交易数据，该数据可以出售独特的全场合赠品。分类和聚类具有超过500,000行和8个属性，是可以使用此数据集执行的最常见的关联机器学习任务。

Download Online Retail Dataset for Machine Learning

Interesting Machine Learning Project Idea using UK Online Retail Dataset– Perform Market Basket Analysis to identify the association rules between the products.

2）零售火箭推荐系统数据集

该数据集由真实世界电子商务网站的点击流数据组成，该网站具有有关客户行为的信息，例如添加到购物车信息，交易和点击以及有关417053个唯一商品的不同商品属性的信息。数据集具有事件数据文件，其中包含有关用户在特定时间戳下对产品执行的事件（添加到购物车，交易或视图）的信息。仅当用户进行交易时，事件数据文件中的“ transaction-id”列才具有值，否则为N / A。

Download Retail Rocket Recommender System Dataset for Machine Learning

Machine Learning Project Idea using Retail Rocket Machine Learning Dataset – Build a Recommender System to predict the transaction and event pattern of a visitor.

3）用于机器学习的Instacart订单数据集

这是另一个有趣的机器学习数据集，可处理200,000多个Instacart匿名客户的杂货订单，该数据集可用于处理大型零售数据。对于每个客户，数据集均包含购买产品的顺序中4到100个订单的数据以及一天中的星期几和小时数。 XGBoost，Word2Vec和Annoy是机器学习算法，彻底改变了Instacart客户如今购买杂货的方式。

Download Instacart Orders Kaggle Dataset

使用Instacart数据集的初学者的机器学习/数据科学项目创意

客户细分–建立基于关联的机器学习模型，以了解Instacart客户的多样化组合，并针对合适的客户群体以最大程度地提高盈利能力。
市场篮子分析–开发预测性市场篮子分析机器学习模型，以确定Instacart客户将再次购买哪些产品？
4）Olist的巴西电子商务数据集

该机器学习数据集由Olist商店的10万个客户订单数据组成，其中包括卖方信息，产品元数据，客户信息和客户评论的详细信息。

Download Brazilian E-commerce Public Kaggle Dataset by Olist

使用巴西电子商务数据集的数据科学/机器学习项目构想

电子商务产品评论分析–通过分析客户给出的产品评论中的文字对Olist商店出售的产品进行评分。
分析Olist客户的购买趋势，以根据客户当前购买的商品确定客户是否打算购买相关产品。
5）机器学习的超级市场数据集

该零售数据集具有超过1000行和17列，具有一家超市公司3个月的历史销售数据，并记录了该公司三个不同分支机构的数据。该零售数据集是任何类型的预测分析项目的理想选择。

Download Supermarket Kaggle Dataset for Machine Learning

机器学习的零售图像数据集

6）MVTec密集细分的超市图像数据集

由于培训数据数量有限，并且验证和测试集中的多样性很高，因此对于机器学习而言，这是一个具有挑战性的图像数据集。它具有在700个不同场景中采集的日常产品和杂货的21K高分辨率图像，并在与行业相关的设置中以高质量注释为所有对象实例提供了像素化标签。

Download MVTec D2S Retail Dataset for Machine Learning

使用MVTec D2S数据集的计算机视觉项目构想

该零售数据集可用于语义图像分割，以覆盖自动结帐，仓库或库存系统的实际应用。经典的深度学习CNN机器学习算法最适合在像素级别对图像中的产品进行分类，以简化结帐流程。

7）上下文中的通用对象（COCO）数据集

COCO数据集共有330,000张图像，超过200,000个标签，其中包含91个东西类别，80个对象类别，150万个对象实例以及25万具有关键点的人员-COCO数据集是最流行且最具挑战性的高质量计算机视觉数据集之一。该数据集代表了我们在日常生活中遇到的各种物体的图像，被认为是转移学习的理想检查点。它是训练计算机视觉模型的基础数据集。使用COCO计算机视觉数据集训练了任何计算机视觉模型后，您就可以使用任何自定义数据集进一步调整模型以学习其他任务。

Download COCO Dataset for Machine Learning

您可以使用COCO数据集进行哪种计算机视觉项目？

对象检测-使用COCO数据集执行最具挑战性的计算机视觉任务之一，即预测图像中不同对象的位置以及存在的对象的类型。

8）弗莱堡杂货数据集

弗赖堡食品杂货零售数据集包含5000张图像，其中包含25种不同的食品杂货，每个类别至少具有97张图像，这些图像已在不同杂货店的各个部门的实际环境中捕获。

Download Freiburg Groceries Dataset

使用弗莱堡食品杂货集的计算机视觉项目构想

您可以基于杂货产品的多类对象分类构建计算机视觉模型。可以进一步微调此模型，以建立无摩擦的商店体验，类似于流行的Amazon Go商店，而无需手动结帐。

9）时尚MNIST数据集

凭借10K测试示例，60K，培训示例以及10类零售产品，分辨率为28×28灰度通道图像，这是用于深度学习和计算机视觉的MNIST数据集的最佳替代产品之一。但是，这比直接替换更具挑战性。

Download Fashion MNIST Kaggle Dataset

使用Fashion MNIST数据集的计算机视觉项目构想

通过使用Keras或TensorFlow训练简单的CNN从头开始构建模型，使用此数据集来享受您对服装分类的初体验。如果您想练习一种使用CNN机器学习算法解决图像分类问题的方法，则可以查找此数据集。

10）零售产品结帐数据集

在商店货架上有来自2000种不同产品类别的超过500,000张零售商品图像-就产品类别和产品图像数量而言，这是最大的零售图像数据集之一。

Download a Large-Scale Retail Product Checkout Kaggle Dataset

使用RPC数据集的计算机视觉项目构想

该数据集被广泛用于推进零售产品图像识别的研究，以进行自动货架审核和结帐。该数据集的高质量性质使其非常适合用于细粒度的零售产品图像分类。

是否想发展您的数据科学和机器学习技能？查看我们最新的端到端数据科学和机器学习项目以及源代码

客户评论用于机器学习的零售数据集
11）亚马逊客户评论数据集

从1995年到2015年，该机器学习数据集在数百万种产品上拥有超过130亿条客户评论，是机器学习，自然语言处理和信息检索领域的数据科学家和研究人员的福音，以了解客户体验。

Download Amazon Customer Reviews Dataset

12）妇女的电子商务服装评论数据集

这是一个匿名的数据集，因为它包含真实客户撰写的评论，并具有23486个带有10个不同功能变量的客户评论。该ML数据集提供了一个绝佳的环境，可用于解析多个维度的文本。

Download Women’s E-Commerce Clothing Reviews Dataset

13）宜家机器学习评论数据集

这是一个相当小的机器学习数据集，其中包含从Google Maps刮取的1300条最佳和最差的IKEA客户评论。这为情感分析提供了一个完美的初学者级数据集。

Download IKEA Reviews Kaggle Dataset

14）亚马逊和百思买电子产品评论数据集

该数据集专门针对百思买和亚马逊上提供的50种电子产品提供了7000多个在线评论。数据集包括审阅日期，标题，等级，来源，元数据和其他信息。

Download Amazon and Best Buy Electronic Product Reviews Dataset

15）多域情感数据集

这是一个多域数据集，包含来自许多产品类型的产品评论。超过10万条Amazon.com对产品，乐器，书籍和DVD的评论，评分介于1到5之间。

Download Multi-Domain Sentiment Kaggle Dataset

使用客户评论数据集的有趣的机器学习项目创意

使用NLP根据客户评论的内容预测收视率
研究客户反馈对产品购买过程的影响。您可以使用这些评论数据集来预测客户向其朋友推荐产品的可能性。
研究各种品牌的在线声誉。
对客户评论进行情绪分析，以识别用户对产品的情感（正面，负面或中立）。（评论情绪）
ProjectPro通过构建端到端的现实世界数据科学和机器学习项目来帮助学生学习实践技能。为有源代码的学生检查一些有趣的有趣的机器学习项目构想。

其他用于机器学习的零售数据集
16）来自维多利亚的秘密和其他组织的内衣数据

该数据集包含来自受欢迎的零售网站（如亚马逊，维多利亚的秘密，汉基·潘基，梅西百货，Btemptd，Nordstrom，American Eagle等）的600,000多种内衣产品的数据。

Download Innerwear Data from Victoria’s Secret and Others Kaggle Dataset

使用Innerwear Kaggle数据集的机器学习项目构想：

该数据集可用于分析泳装和内装产品的流行趋势。

17）电子商务项目数据

机器学习数据集包含500个SKU，以及服装品牌产品目录中的产品说明。

Download eCommerce Item Kaggle Dataset

使用电子商务项目Kaggle数据集的机器学习项目构想：

您可以使用Item数据进行的有趣的机器学习项目是构建产品推荐系统。

18）eBay在线拍卖数据集

该在线拍卖零售数据集包含拍卖信息，例如竞标价格，竞标时间，物品的拍卖价格，以及有关施华洛世奇珠子，卡地亚手表，Xbox游戏机和Palm Pilot M515 PDA的其他拍卖信息。

Download eBay Online Auctions Dataset

使用在线拍卖Kaggle数据集的机器学习项目构想：

建立机器学习模型以预测拍卖品的最终价格。从利润最大化的角度来看，预测拍卖品的最终价格对买卖双方都有利。

19）沃尔玛数据集

这是最佳的初学者级机器学习数据集之一，因为它具有最多的零售数据以及每个沃尔玛商店区域中的外部数据，例如失业率，燃料价格，CPI，是进行详细分析的理想选择。该Kaggle数据集包含2010年至2012年记录的45家沃尔玛商店的匿名历史销售数据。

Download Walmart Store Sales Kaggle Dataset

使用沃尔玛零售数据集的机器学习/数据科学项目构想

考虑假日和降价事件，消费者物价指数，季节变化以及其他影响产品销售的因素，建立一个机器学习模型来预测沃尔玛在全部门的销售。销售预测模型可帮助公司草拟有关如何满足未来需求和增加销售的计划。

20）男鞋价格数据集

该数据集包含10,000种男鞋的大集合，以及它们的销售价格，品牌名称，鞋名和其他信息。

Download Men’s Shoe Price Dataset

使用鞋价数据集的机器学习/数据科学项目构想

使用此定价数据建立机器学习模型以-

确定奢侈品牌的品牌价值
确定定价策略
确定奢侈男鞋的趋势
确定鞋子的特定功能与价格变化之间的相关性。

机器学习的最佳医疗保健数据集

用于机器学习的医疗保健数据集

1）OSIC肺纤维化进展

开源影像协会医疗保健数据集包括200例匿名的肺部基线CT扫描以及其他相关临床信息，例如基线强迫生命系数，患者性别，年龄，基线扫描后的相对周数，吸烟状况等。

Download OSIC Pulmonary Fibrosis Progression Dataset

使用OSIC Kaggle数据集的数据科学/机器学习项目构想

您可以建立机器学习模型来预测患者肺功能下降的严重程度。

2）APTOS 2019失明检测

这是在各种成像条件下捕获的眼底摄影视网膜图像的多样化且广泛的数据集。根据糖尿病性视网膜病变的严重程度，每张图片的临床评分为0到4。

Download APTOS 2019 Blindness Detection Kaggle Dataset

使用APTOS数据集的机器学习项目构想

在285万人中，有1/3患有糖尿病性视网膜病变。您可以使用此数据集建立一个机器学习模型，该模型可以在DR引起影响眼睛的并发症之前早发现DR，这将帮助数百万糖尿病患者失去视力。

3）超声神经分割数据集

这个Kaggle数据集包含5635张图像，其中的神经已由人工手动注释。它是具有挑战性的机器学习数据集之一，因为它具有减小的数据大小并且没有明显的结构特征。

Download Ultrasound Nerve Segmentation Dataset

访问带有源代码的该机器学习项目，以建立一个机器学习模型，该模型可识别超声图像中的神经结构，以分割称为臂丛（BP）的神经集合。

4）帕金森数据集

这是一个非常小的医疗数据集，大约需要39 KB的数据，并且可以对31位患者进行一系列生物医学语音测量，其中23位患有帕金森氏病。

Download Parkinson Dataset from UCI Machine Learning Repository

使用帕金森数据集的机器学习项目构想

每年印度有超过100万人受到帕金森氏病的影响。这种疾病是慢性的，无法治愈，甚至很难为医生早期诊断。您可以建立一个机器学习模型，以准确检测个体中帕金森氏病的早期发作，并基于多种因素来确定帕金森氏病患者是否健康。

5）英特尔和MobileODT宫颈癌数据集

该Kaggle数据集包含1481个训练图像和512个测试图像。考虑到此数据集的局限性，您可能必须应用各种数据增强技术来增加训练样本的数量。

Download Intel & MobileODT Cervical Cancer Dataset

使用英特尔和移动ODT宫颈癌数据集的深度学习项目构想

使用深度学习和图像分类的子宫颈类型分类-宫颈癌是致命的，但是如果在早期发现并进行适当治疗，对许多妇女来说可以挽救生命。您可以使用此Kaggle数据集构建深度学习模型，以对子宫颈类型（类型1，类型2和类型3）进行分类，以帮助医疗保健专业人员为全球女性提供更好的护理。对子宫颈类型进行分类将有助于医疗保健提供者提高女性子宫颈癌筛查的效率和质量。

6）乳房组织病理学图像数据集

实际数据集包含162个乳腺癌标本的幻灯片图像。从该数据集中提取了277,524个补丁，其中78786个属于阳性类别，而其余198、738个补丁属于阴性类别。

Download Breast Histopathology Images Dataset

使用乳房组织病理学图像数据集的深度学习项目构想

乳腺癌是最常见的癌症类型，在2018年经诊断的210万例乳腺癌病例中有627,000例死亡报告。在所有确诊的乳腺癌病例中，有80％属于浸润性导管癌（IDC）类型。早期准确诊断癌症有助于选择正确的治疗方案，并有助于提高癌症患者的生存率。您可以使用此数据集构建用于图像分类的深层CNN，以识别未标记的组织病理学图像中IDC的存在。这是一项重要的临床任务，为此，自动化模型肯定会节省时间并减少错误。

7）迷你DDSM数据集

最大的（45GB）公共乳腺摄影数据集之一，具有年龄属性，密度属性，患者的原始文件名，癌病灶轮廓二进制蒙版图像以及带有所有所需元数据的excel表。

Download Mini DDSM Kaggle Dataset

使用Mini DDSM数据集的机器学习项目

年龄估计具有多种临床应用，并且已经使用生物医学图像对人类年龄进行了一些研究。使用此数据集，您可以基于乳房X线照片图像中的胸肌段建立基于AI的模型来估计年龄。最重要的步骤是从乳房X线照片中分割胸肌，然后提取深度学习特征以建立年龄估计模型。

8）克利夫兰心脏病数据集

克利夫兰心脏病UCI数据集包含303个个体的数据，这些个体具有75个属性，其中14个属性，例如年龄，性别，静息血压，血清胆固醇，静息心电图，获得的最大心率，运动诱发的心绞痛以及其他可能的重要参数发生心血管疾病的主要危险因素。

Download Heart Disease Dataset

使用心脏病数据集的机器学习项目构想

心脏病是世界范围内死亡率和发病率的主要原因，仅在美国，每年就有61万例死亡。根据风险因素很难手动确定罹患心血管疾病的几率。在这里，机器学习可以极大地帮助您根据医疗保健行业产生的大量数据做出预测。您可以应用各种机器学习算法，例如SVM，朴素贝叶斯，XGBoost，决策树，随机森林，并使用克利夫兰心脏病机器学习数据集对它们进行比较，以预测某人是否患有心脏病。

9）行动预测数据集的机制

这是一个独特的机器学习数据集，由细胞活力数据和基因表达组成，可以访问超过5K药物的MoA注释。这个用于机器学习的数据集基于一种新颖的技术，该技术可测量人类细胞对数百种不同细胞类型池中药物的反应，从而消除了确定哪种细胞类型更适合任何给定药物的问题。

Download Mechanisms of Action (MoA) Prediction Kaggle Dataset

使用MoA预测数据集的机器学习项目构想

药物发现在疾病治疗的发展中起着至关重要的作用。机器学习被广泛用于理解疾病的潜在机制，临床标记，药物发现和验证。通过开发机器学习算法来基于药物的生物活性对药物进行分类，该数据集可用于促进药物开发。

10）世界卫生组织-医疗机器学习数据集的世界

不同国家/地区最值得信赖和最真实的医疗数据来源。通过针对霍乱，肺结核，流行性感冒和其他疾病等特定疾病的COVID -19数据和分析，世卫组织获得了全球卫生重点数据以及大多数卫生状况的趋势重点。

Download Healthcare Datasets for Machine Learning from WHO Repository

与医疗数据配合使用的其他有趣且有趣的机器学习项目创意

肺分割
糖尿病预测
接触追踪以阻止传染病的传播
癌症分类
个性化医学
预测慢性病
预测疾病暴发
分类图像数据（X射线，CT扫描等）以进行诊断护理。

最佳银行和金融机器学习数据集

机器学习的银行和金融数据集

1）桑坦德数据集

由于这是银行业务数据集，因此已被完全掩盖，仅包含数值。西班牙在线银行桑坦德银行提供了四个不同的数据集，以帮助他们使用机器学习解决各种业务挑战。

ownload Santander Customer Transaction Dataset

Download Santander Value Prediction Dataset

Download Santander Product Recommendation Dataset

Download Santander Customer Satisfaction

这些桑坦德银行数据集可用于构建端到端机器学习模型，以-

预测客户将来是否会与银行进行交易，而不管交易的金额如何。
预测客户是否会购买产品
预测客户是否有能力支付费用
预测客户是否对银行的服务感到满意。
2）房屋信贷违约风险数据集

该数据集包含7个不同的客户数据源-贷款申请数据，局数据，信用卡余额数据，以前的贷款申请数据，POS现金余额数据，EMI付款数据和局余额数据。

Download Home Credit Default Risk Kaggle Dataset

使用房屋信用违约风险Kaggle数据集的机器学习项目构想

建立机器学习模型以预测客户是否有能力偿还贷款。这些模型将帮助银行决定是否只对有能力偿还贷款的申请人批准贷款。

3）银行营业额数据集

该数据集包含针对银行的大约1万名客户的14个功能，其中20％是流失客户。

Download Bank Turnover Dataset

使用银行营业额数据集的机器学习项目

该数据集可用于预测客户流失，这是机器学习的最常见应用之一。您可以建立一个机器学习模型来预测客户是否会在未来6个月内退出银行的服务。预测客户流失将有助于银行制定保留活动和忠诚度计划以保留客户。

4）信用卡交易数据集

该欧洲信用卡数据集包含2013年9月在两天内发生的284、807笔交易和492笔欺诈交易（占所有交易的0.172％）。这是一个极具挑战性的数据集，因为它的数据不平衡，因为大多数这些交易不是欺诈性交易，因此很难检测到欺诈性交易。

Download Credit Card Fraud Transaction Kaggle Dataset

使用信用卡交易数据集的机器学习项目

信用卡欺诈是许多银行和信用卡公司的常见问题，因为大多数欺诈交易看起来与正常交易相似，并且每天在信用卡上完成大量交易，因此很难手动检测到欺诈行为。使用此金融机器学习数据集来识别欺诈性信用卡交易，以确保不会因客户未进行的交易向客户收费。

5）给我一些信用数据集

该数据集包含2008年为25万巴西借款人创建的历史数据，金融机构可以利用这些历史数据来预测信用评分并做出最佳的财务决策。

Download Give me Some Credit Kaggle Dataset

使用“给我一些信誉”数据集的机器学习项目构想

建立一个机器学习模型，以预测一个人在未来两年内遭受财务困扰的可能性。

6）两个西格玛数据集

该数据集由两个数据源组成，即Intrinio和Thomson Reuters。 Intrinio提供的培训市场数据大约有400万行，而路透社提供的培训新闻分析数据则有近900万行，使其成为可用于预测股价的最大数据集之一。

Download Two Sigma Dataset

使用两个Sigma Kaggle数据集的有趣的机器学习项目创意

股票价格通常由投资者的行为决定，而投资者则根据公共信息确定股票价格以预测股票市场的反应。在此，随着投资者对这些信息做出反应，财经新闻文章在影响股票价格方面起着至关重要的作用。该数据集可用于构建机器学习模型，以对与公司列表相关的新闻文章进行分类，并基于该模型预测那些公司的股价波动。

7）比特币历史数据集

该数据集包括从2012年1月到2020年12月的精选比特币交易数据，包括开盘价，最高价，最低价和收盘价的逐分钟更新，以及加权比特币价格，BTC量和指定货币。

Download Bitcoin Historical Dataset

使用比特币历史数据集的示例机器学习项目构想

使用此Kaggle数据集构建机器学习模型，以预测明天的比特币价格。人们可以探索使用LSTM模型来预测比特币价格。

8）简街市场数据集

如果您喜欢机器学习项目或想探索一些良好的股市数据，则此数据集可能是一个绝佳的合作机会。它包含带有匿名功能的真实股市数据，其中数据集中的每一行代表一个交易机会。

Download Jane Street Market Prediction Dataset

使用Jane Street市场预测数据集的建议的机器学习项目

使用Jane Street股票市场数据来构建定量交易机器学习模型，以使用来自全球证券交易所的真实股票市场数据来最大化回报。您还可以针对未来的实际股市数据测试机器学习模型的有效性。

9）Elo商家类别推荐

Elo是巴西的大型支付品牌，向借记卡和信用卡用户提供餐厅推荐，并根据他们的偏好提供折扣。该数据集包含有关每笔卡交易的信息，以及有关特定商人长达3个月的每张卡交易价值的数据，每张卡的新商人的交易详细信息，以及基于交易中涉及的各种商人的其他商人数据。卡交易。

Download Elo Merchant Category Recommendation Dataset

建议的Elo商家类别数据集机器学习项目

该数据集可用于查找这些促销对客户和商人有多有益。建立机器学习模型来预测客户的忠诚度分数，并帮助Elo了解客户的忠诚度，以便他们减少不必要的营销活动并为其用户创造正确的体验。

10）俄罗斯储蓄银行俄罗斯住房市场数据集

此数据集的训练数据包含有关俄罗斯最古老，最大的银行Sberbank的21000个真实交易的信息，而测试数据包含7K个真实交易以及有关该物业的其他信息。

Download Sberbank Russian Housing Market Kaggle Dataset

使用Sberbank俄罗斯住房市场数据集的机器学习项目构想

使用此丰富的银行数据集来开发机器学习模型，以预测实际房价，以便开发商，贷方和提供者在购买物业或签订租约时充满信心。这些数据还包括有关俄罗斯经济和金融部门的信息，这些信息可以帮助开发准确的模型而无需再次猜测。

探索其他100个主要的金融和经济数据集。

机器学习社交媒体数据集
用于机器学习的社交媒体公共数据集

1）Twitter美国航空情绪数据集

该社交媒体数据集具有14,640行和12个属性，并包含从Twitter刮取的美国各主要航空公司的推文。

Download Twitter US Airline Sentiment Dataset

ML项目建议的想法：使用机器学习的情感分类系统

您可以使用此数据集将航空公司的推文分类为肯定，否定或中性，以分析旅行者对航空公司的反馈。

2）Google Cloud和YouTube 8M数据集

由Google AI / Research在2016年开发的数据集，其中包含800万个YouTube视频（总计50万小时）和4.8K（每个视频平均3.4个标签）视觉标题。

Download YouTube 8M Dataset

使用YouTube 8M数据集的数据科学和机器学习项目构想

建立模型大小小于1GB的紧凑型视频分类，以学习视频表示形式。这将有助于推进视频级注释。
建立分类机器学习模型以准确分配视频标签。
3）COVID-19 Tweets数据集

这是一个多语言的推文数据集，包含超过10亿条推文，其中包含冠状病毒，病毒，covid，ncov19，ncov2019等关键字，并带有标签，提及，主题和其他信息。

Download COVID19 Tweets Dataset

使用COVID 19数据集的建议ML项目

使用数据挖掘，网络分析和NLP分析来自该数据集的推文集，以识别人们对大流行的反应以及反应随时间的变化。您还可以利用此ML数据集来收集有关大流行初期如何传输正确信息和错误信息的见解。

4）Yelp数据集

该数据集包含5,200,000条评论，其中包含来自4个国家/地区11个地区的1,74,000家企业的信息。

Download Yelp Kaggle Dataset

您可以使用此数据集进行哪些项目以进行机器学习？

使用NLP和情感分析来找出评论中正面或负面的含义，并推断出各种情感和业务属性的含义。

5）Twitter上的客户支持

Twitter上来自顶级品牌的300万条推文的数据集。

Download Customer Support on Twitter Dataset

我可以使用此ML数据集做什么项目？

机器学习犯罪数据集

1）旧金山犯罪分类

这是一个历史数据集，包含2003年至2015年旧金山地区的12年犯罪报告。数据包括犯罪发生的日期，犯罪时间，犯罪描述，地区，地址，位置坐标和解决方案。

Download San Francisco Crime Classification Dataset

使用犯罪分类Kaggle数据集的ML项目构想

建立端到端机器学习模型，根据事件发生的位置和时间来预测犯罪事件的类别。

2）伦敦犯罪数据集

该数据集由LSOA区，月份和次要/主要类别在2008年1月至2016年12月之间的犯罪报告组成，犯罪记录为1300万行。

Download London Crime Dataset

使用London Crime Kaggle数据集的建议项目

该数据可用于分析根据一周中的某天或某个季节的犯罪发生率是否发生任何变化，或确定特定犯罪在减少或增加的自治市镇。

3）印度犯罪

该数据集包含有关2001年国家犯罪数据的完整信息，分为40多个因素。

Download Crime in India Dataset

使用此数据集的分析建议项目

该数据集可用于分析印度的犯罪模式，例如虐待儿童案件，针对SC和ST的犯罪以及其他犯罪，以根据犯罪模式发现潜在的罪犯。

4）芝加哥犯罪数据集

来自芝加哥警察局的芝加哥犯罪数据集有699万行，具有22个属性。该数据集会随着犯罪事件不断更新。

Download Chicago Crime Dataset

使用Chicago Crime Dataset的机器学习项目构想

可以利用该数据集来构建模型，以分析温度对暴力犯罪（如殴打或殴打）的影响，确定同比增长最高的犯罪类别等。

5）波士顿数据集中的犯罪

数据集由波士顿警察局提供，其中包含2015年6月以来的犯罪类型，犯罪发生的时间和地点，犯罪描述，位置坐标以及其他信息。

Download Crime in Boston Dataset

该数据集可用于构建一个模型，以识别犯罪热点和犯罪的频繁发生时间。

作者 east

python 2月 21,2021

怎样在3分钟内安装PySpark 和 Jupyter Notebook

对于大数据爱好者来说，Apache Spark是必须的。简而言之，Spark是一个快速而强大的框架，它提供了一个API，可以对弹性数据集执行大规模的分布式处理。 Jupyter Notebook是一个流行的应用程序，它使您可以编辑，运行并将Python代码共享到Web视图中。它允许您以非常灵活的方式修改和重新执行部分代码。因此，Jupyter是测试程序和原型的好工具。 Jupyter Notebook运行Python代码 Jupyter Notebook运行Python代码我为Linux用户撰写了这篇文章，但是我确信Mac OS用户也可以从中受益。为什么在Jupyter Notebook中使用PySpark？使用Spark时，大多数数据工程师建议使用Scala（这是“本机” Spark语言）或通过完整的PySpark API使用Python开发。 Python for Spark显然比Scala慢。但是，像许多开发人员一样，我喜欢Python，因为Python灵活，健壮，易学并且可以从我所有的收藏夹库中受益。我认为，Python是大数据/机器学习领域中进行原型开发的理想语言。现在，让我们开始吧。

安装pySpark

在安装pySpark之前，必须先安装Python和Spark。我在以下示例中使用的是Python 3，但您可以轻松地使其适应Python2。请访问Python官方网站进行安装。我也鼓励您建立一个virtualenv
要安装Spark，请确保您的计算机上安装了Java 8或更高版本。然后，访问Spark下载页面。选择最新的Spark版本（一个针对Hadoop的预构建包），然后直接下载。

解压缩并将其移动到您的/ opt文件夹：

$ tar -xzf spark-1.2.0-bin-hadoop2.4.tgz

$ mv spark-1.2.0-bin-hadoop2.4 /opt/spark-1.2.0

创建一个软连接

$ ln -s /opt/spark-1.2.0 /opt/spark̀

这样，您将能够下载和使用多个Spark版本。最后，告诉您的bash（或zsh等）在哪里可以找到Spark。为此，通过在〜/ .bashrc（或〜/ .zshrc）文件中添加以下几行来配置$ PATH变量：

安装Jupyter Notebook

$ pip install jupyter
$ jupyter notebook

您在Spark上的第一个Python程序
让我们检查是否在没有先使用Jupyter Notebook的情况下正确安装了PySpark。

您可能需要重新启动终端才能运行PySpark

import random
num_samples = 100000000

def inside(p):     
  x, y = random.random(), random.random()
  return x*x + y*y < 1

count = sc.parallelize(range(0, num_samples)).filter(inside).count()

pi = 4 * count / num_samples
print(pi)

sc.stop()

Jupyter使用PySpark

有两种方法可以在Jupyter Notebook中使用PySpark：

配置PySpark驱动程序以使用Jupyter Notebook：运行pyspark将自动打开Jupyter Notebook

加载常规的Jupyter Notebook并使用findSpark软件包加载PySpark

第一种选择更快，但特定于Jupyter Notebook，第二种选择是一种更广泛的方法，可以在您喜欢的IDE中使用PySpark。

方法1 —配置PySpark驱动程序
更新PySpark驱动程序环境变量：将这些行添加到〜/ .bashrc（或〜/ .zshrc）文件中。

export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS='notebook'

重启并加载：

$ pyspark

现在，此命令应在您的Web浏览器中启动Jupyter Notebook。通过单击“新建”>“ Notebooks Python [默认]”来创建一个新笔记本。

复制并粘贴我们的Pi计算脚本，然后按Shift + Enter运行它。

方法2 — FindSpark程序包
在Jupyter Notebook中使用PySpark还有另一种更通用的方法：使用findSpark包在代码中提供Spark上下文。

findSpark包并非特定于Jupyter Notebook，您也可以在自己喜欢的IDE中使用此技巧。

要安装findspark：

$ pip install findspark
$ jupyter notebook

创建一个新的Python [default]笔记本并编写以下脚本：

import findspark
findspark.init()

import pyspark
import random

sc = pyspark.SparkContext(appName="Pi")
num_samples = 100000000

def inside(p):     
  x, y = random.random(), random.random()
  return x*x + y*y < 1

count = sc.parallelize(range(0, num_samples)).filter(inside).count()

pi = 4 * count / num_samples
print(pi)

sc.stop()

输出结果：

作者 east

python 2月 13,2021

直播间机器人设计方案

设计目标

1：模拟一定人数在房间，保证房间的人气

2：不同时段房间内房间机器人的人数要有波动，防止人数不真实

3：支持房间内做活动，需要临时增加大批量的用户

4：机器人不能出现大批量进入房间，大批量退出房间的情形

设计流程

1：增加robot进程进行通知机器人进入房间退出房间的处理

2：设计给机器人分配特定的号段区间（例如：850000000-860000000）

2：robot进程读取配置文件，获取房间信息，以及房间的机器人配置信息流程

4：如有讲师在麦上，robot服务定时判断真实人数和在线人数的比例公式,判断是否需要增加或减少机器人，如果需要，则发起信令请求，消息流为：

robot->usermgrsvr->gateway->roomsvr

5:房间服务器获取到加入房间请求后，判断当前的最大机器人ID,然后从最大的机器人ID

往上累加，获取最新的机器人ID。（如果达到最高的配置860000000，则从最低850000000开始循环）。然后根据新增加机器人ID，做加入房间的处理.

6:房间服务器获取到退出房间的请求后，判断当前的最小机器人ID，然后删除指定的机器人数量

7: 如果没有讲师在麦上，robot服务逐步删除房间内的机器人，发起信令请求，消息流为：

robot->usermgrsvr->gateway->roomsvr，房间服务器处理为第6部。

配置文件

robot配置文件robot.conf如下信息：

[roomlist] #房间列表配置

Roomid=60001,60002,60003

[onlineparam]

onlinenum=20 #机器人基础在线人数

onlinerate=1-200:30;201-500:20;501-2000:10;2001-1000000000:5 #机器人数比率

假设M为真实的在线总人数

当1<=M<=200时

Totalonline = onlinenum + M * 30

当200<M<=500时

Totalonline = onlinenum + 200 * 30 + (M-200) * 20

当500<M<=2000时

Totalonline = onlinenum + 200 * 30 + 300 * 20 + (M-500) * 10

当2000<M<=1000000000时

Totalonline = onlinenum + 200 * 30 + 300 * 20 + 500 * 10 + (M-500) *5

作者 east

技术架构 2月 11,2021

C++编码规范

一、文件名命名规范

文件的名字需和承载的类之间有一定的关联性，而且常用的公共头文件需要定义得比较简短

文件名采用全部小写的方式，不允许大小写混合的方式

二、源程序文件

源文件段落依下列顺序：
序言
系统头文件引用（include）
用户头文件引用（include）
全局常量宏定义（define）
全局函数宏定义(define)
全局类型定义（typedef）
全局枚举类型定义（enums）
全局变量说明（extern）
全局变量说明（non-static）
全局变量说明（static）
函数（通常从最高层开始，按层次横向排列。如果定义较多的独立的公用函数，可以考虑按字母顺序排列。
序言内容应包括版权声明、内容描述、格式如下：

/*********************************************************************

* 功能：*****文件

* Edit History:

* 2016/04/04 – Created by David.

* 2006/04/06 – Modified by John to print output in the new form.

段落之间用空行分隔。
文件长度尽可能在1000行之内。
每行长度尽可能不要超过79列。

三、头文件

头文件开头注释：

/**
* Description: This is a test program
*/

每个头文件采用下面的形式避免被重复引用：

#ifndef EXAMPLE_H

#define EXAMPLE_H

… /* body of example.h file */

#endif /* EXAMPLE_H */

多个源文件引用的说明放入头文件中。
说明函数或外部变量的头文件应在定义该函数或变量的文件中引用。

引用头文件不要使用绝对路径。使用<filename.h>引用系统头文件；使用“filename.h””引用用户头文件。

四、数据变量说明

常量的命名规范：

常量名由全大写字母组成，单词间通过下划线来界定

成员变量的命名规范：

m+_+[变量类型]+变量名

m后带上明确表达变量意义的英文名词而不要用难以表达意义的缩写。且m后的变量名首字母必须大写。如：

class CMyGame

{

private :

CPoint m_Point;<―――普通类型

CGame* m_pGame;<―――指针类型

Int m_nGameID;<―――整数类型

}

函数参数的命名规范：

采用波浪法来定义函数参数变量。同样的，也必须使用可以明确表达变量意义的英文名词，而不仅仅是缩写。

[变量类型]+变量名

如定义一个读取文件的函数，并且用参数传入一个文件名

public boolean readFile(String strFileName)

{

…

m_sFileName = strFileName;

}

局部变量的命名规范：

采用全部小写的方式定义局部变量名。而且尽量用有意义的名词作为变量名。

局部变量不需要在前面增加变量类型标识。

public boolean readFile()

{

String filename = “e.ext”;

}

局部循环变量的命名规范：

用小写的i、j、k依次作为循环变量

如：

for (int i = 0 ; i < 10 ; i ++ )

{

for (int j = 0 ; j <10 ; j ++ )

{

}

临时变量的命名规范：

一般情况下尽量使用有意义的变量名，如果是某变量的临时变量，可采用前面增加tmp前缀的方式。如果实在没办法，可采用tmp、temp等作为临时变量名，但不可以过多定义诸如tmp1、tmp2等变量，如果出现此情况，则必定可以采用有意义的名词代替。

int tmpserialno = mSerialNo++;

tmpserialno %= 10;

mSerialNo = tmpserialno;

枚举常量

采用波浪法加E前缀来定义枚举常量。同样的，也必须使用可以明确表达变量意义的英文名词，而不仅仅是缩写。且E后首字母必须大写

正确写法：

enum ECHARTYPE
{
    CHARTYPE_SPACE = _ISspace,
    CHARTYPE_PRINT = _ISprint,
    CHARTYPE_CNTRL = _IScntrl,
};

错误写法：

enum ECHARTYPE{ SPACE = _ISspace, PRINT = _ISprint, CNTRL = _IScntrl };

变量定义范围建议：

尽量在变量的有效范围内定义之，如果一个变量仅仅在某个函数内使用到，则把其定义为一个成员变量就是不适合的。在如某些变量只在循环内用到，则应该在循环体内定义之，而不要随意括大其定义范围。

变量类型：

基本类型(保留类型)

char	c	cMyChar;
bool	b	bMyBool;
int/short/long	n	nMyInt;
float/double	f	fMyFloat;
Long64	l	lMyLong;
String/char*(当明确知道是用作字符串的情况下)	str	strMyString
map	map	mapPlayers
vector	vec	vecPlayers
list	lst	lstPlayers
multimap	mmap	mmapState

特殊类型

Handle

hFile;

指针类型:

在变量类前增加p标识，作为标识此变量为指针类型，如：

int *pKey = NULL;

CDateTime* pDateTime = new CDateTime(0);

数组变量命名规范：

对于数组类型的变量，需要采用复数s以标识此为数组变量。如：

int m_nKeys[100];

double dValues[200];

CMyClass Strings[200];

特例：对于char buf[200]这种定义，由于其使用习惯原因，不需要采用数组前缀。

对于数组指针变量，同样在类型前增加p标识。在删除的时候，必须用delete[]的方式删除动态数组，以保证数组内的实例被调用析构函数。

CDateTime* pBirthdays = new CDateTime[20];

….

delete[] pBirthdays;

int* m_pnKeys = new int[20];

五、类说明

类名命名规范

根据各种类的类型和用途，采用不同前缀+名词的命名方式。名词采用波浪法，必须使用可以明确表达变量意义的英文名词。

前缀
普通类(C)

一般类，采用C+名词的方式命名

例如：

Class CPerson

{

Protected :

String m_strName;

String m_strNickName;
};

接口类(I)

对于无任何实现的纯虚类，称为接口类，这些类的特点都是无任何成员变量，存在需要其他实现类实现的纯虚函数。

接口类必须采用I+名词的方式命名。

例如：

class IDataInput

{

Public :

virtual ~IDataInput() {};

virtual void read() = 0;

}

结构体(T)

Struct，结构体，必须以T+名词的方式命名。

例如：

typedef struct _t_mystruct

{

Unsigned int number;

Unsigned int value;

Char name[255];

}TMyStruct,* TMyStructPtr;

模板类

模板类，必须以全小写命名。

例如：

template<class T,allocator A>

class screen : public map<T,A>

{
}

类成员的初始化（Member initialization lists）

成员的初始化必须在构造函数名的下一行开始

正确写法：

gribble::gribble()
:m_private_data(0), m_more_stuff(0), m_helper(0)
{
}

错误写法：

gribble::gribble():m_private_data(0),m_more_stuff(0), m_helper(0)
{
}

类成员变量必须采用private的定义，不允许使用public定义，并置于类定义的最后，另外用getter和setter的函数访问和修改之（在需要考虑程序大小的时候可以忽略此规则）

class CTest

{

public :

int getTopicID() //获取话题ID

{

return m_nTopicID;
}

void setTopicID(int nTopicID) //设置话题id

{

m_nTopicID = nTopicID;

}

private：

TInt m_nTopicID;

}

一个方法只完成一个任务，不要把多个任务放在一个方法中，即使那些任务非常小
功能类的方法的大小尽可能不要超过100行

六、函数说明

每个函数前加入注释块，描述函数功能、输入参数和返回值，必要时应说明其功能、用法、重要设计决策与副作用。

/**

* @description : PrintOneMsg

* @input param : nUserID — 用户ID

* @output param: nMoney– 玩家体力

* @return: 0 — success

other — false

* @exception CException reason

int PrintOneMsg((int nUserID,int & nMoney)

{

function body;

return 0;

}

函数名称原则上采用动词名词的组合形式，函数名称采用波浪法，第一个单词首字母采用小写，后面的单词的首字母采用大写

如：int getTopicID()

函数的参数个数尽可能不要超过5个。
函数体的开、闭花括号写在第一列，分别占一行。函数体的局部变量说明和代码缩进4格。
业务逻辑函数的大小尽可能不要超过200行

七、代码注释规范

为了能更好的体现代码即详细设计文档这个意图，在对代码注释的时候，需遵守下列的规范。

用“注释块”描述数据结构、算法等，放在被注释的程序段前：

* Here is a block comment.

* The opening slash-star and closing star-slash are alone on a line.

* …

“单行注释”放在被注释的程序段前，并与该程序段对齐：

if (argc > 1)

{

// Get input file frmm command line

if (freopen(argv[1], “r”, stdin) == NULL)

{

perror(argv[1]);

}

放在代码行尾的“短注释”与被注释的代码分开至少一个空格：

if (a == EXCEPTION)

{

b = TRUE; // special case

BODY

}

else

{

b = isprime(a); //works only for odd a

BODY

}

函数抛出异常注释规范

对于可能抛出异常的类方法、函数，在注释中说明所抛出异常的类名和产生异常的原因；

注释中采用如下语法

/**

* @exception fully-qualified-class-name description

fully-qualified-class-name：方法声明的异常名

description：产生异常的原因

例如：

/**

* 连接数据库

* @ exception CSQLException 数据库连接失败，具体原因请根据sqlcode查阅数据库错误代码说明

virtual bool connect()=0;

八、构造与析构

类构造函数，做非资源变量的初始化动作，原则上不进行任何可能出现错误的操作，如分配内存，调用资源等。
delete 与new ,free与malloc,delete[] 与new[]必须成对使用，否则不保证会不会出现问题。

九、异常处理

所有的异常抛出都必须以对象形式，而不是能以new 的指针形式。而捕获的时候就可以统一用引用的方式进行捕获。这样在性能和开销方面不会加大的同时，也无需关心指针的删除问题。

try

{

throw CDateTimeException(“datetime format error”);

}

catch (CDateTimeException& e)

{

cout<<e.what()<<end;

}

十、其他良好的编程习惯

缩进采用tab而不是用space；tab的缩进显示距离建议为4个空格
用一个空行来分开代码和逻辑的分组；
花括号“{”、“}”需独立一行，而不像if for等可以和括号同一行，而且必须与if等缩进相同的空间

如：if ( test == 1 )

{

}

在每个运算符和括号的前后都空一格。
无warning编译
在switch语句中出现的fall-through应加以注释：

switch (expr)

{

case ABC: //注释

{

statement

break;

}

case DEF: //注释

{

statement

break;

}

default: XYZ:

{

statement;

break;

}

作者 east

技术架构 2月 11,2021

视频直播服务器设计原则

1. 设计原则

1.1 KISS

简单就是美，用最简单的方式解决问题

1.2 客户/服务端带宽是最珍贵的

最珍贵的是客户端与服务器端的带宽，其次是客户端的CPU，再次是服务器的间的带宽，最后才是服务器的CPU。流畅是第一优先事项。

1.3 避免单点，分布式部署

避免单点进程的出现，如果必须出现，也需要保证其是所有进程中故障率最低的。系统必须支持分布式异地部署，支持平滑扩容,达到系统的高可用。

1.4 不要过早优化

做任何的优化，都必须以事实数据为前提，不要在设计阶段做一些想象中的优化。先保证业务的正常使用，即先扛住，再来优化。

1.5 层次化分布设计

每一层都应该有相应的预处理，不要把所有的处理放在最后一层。

如：客户端应处理的逻辑，应该由客户端处理完毕后再由服务器做后续的处理，不要仅仅把原始数据给到服务器。

每一层都应该有相应的安全防范，不要把所有的防范集中在某一层。

如：服务端应永远假设客户端发送来的消息包都可能是非法的；客户端应永远假设电脑的输入有恶意性的。

1.6 大系统小做

将功能复杂较大的系统，化大为小，减少模块耦合，降低相关联性，用多个独立的模块来实现整体系统的功能。

总的来说，大系统小做采用的是化繁为简、分而治之，便于开发和迅速实现；同时当某个模块出了问题时，因为相互独立，能将影响降到最低，不至于扩大影响范围。

1.7 有损服务原则

随着系统功能越来也多，系统的复杂度也越来越大，系统越来越臃肿。这是系统出错的概率就会逐渐增大。当故障异常，一定要保证系统重点功能的正常使用，防止系统零服务的现象发生，这就是有损服务理念。有损服务设计理念如下：

1：问题时，优先保证关键功能

2：非关键功能不可以影响关键功能

3：在条件允许的情况下，损失越少越好

1.8 轻重分离原则

保持接入和业务处理的分离，接入尽量轻量化，使得系统具有很好的吞吐量，处理尽量异步化，使得可以平滑扩展。

作者 east

Android 2月 11,2021

Android自定义采颜色对话框

import android.annotation.SuppressLint;
import android.app.Dialog;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.RectF;
import android.graphics.SweepGradient;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;

@SuppressLint({ “DrawAllocation” })
public class ColorPickerDialog extends Dialog {
private int mInitialColor;
private OnColorChangedListener mListener;

public ColorPickerDialog(Context paramContext,
        OnColorChangedListener paramOnColorChangedListener, int paramInt) {
    super(paramContext);
    this.mListener = paramOnColorChangedListener;
    this.mInitialColor = paramInt;
}

protected void onCreate(Bundle paramBundle) {
    super.onCreate(paramBundle);
    mListener = new OnColorChangedListener() {
        public void colorChanged(int paramAnonymousInt) {
            ColorPickerDialog.this.mListener
                    .colorChanged(paramAnonymousInt);
            ColorPickerDialog.this.dismiss();
        }
    };
    setContentView(new ColorPickerView(getContext(), mListener,
            this.mInitialColor));
    setTitle("Pick a Color");
}

private static class ColorPickerView extends View {
    private static final int CENTER_RADIUS = 32;
    private static int CENTER_X = 120;
    private static int CENTER_Y = 120;
    private static final float PI = 3.1415925F;
    private Paint mCenterPaint;
    private final int[] mColors;
    private boolean mHighlightCenter;
    private ColorPickerDialog.OnColorChangedListener mListener;
    private Paint mPaint;
    private boolean mTrackingCenter;

    ColorPickerView(
            Context paramContext,
            ColorPickerDialog.OnColorChangedListener paramOnColorChangedListener,
            int paramInt) {
        super(paramContext);
        this.mListener = paramOnColorChangedListener;
        this.mColors = new int[] { -65536, -65281, -16776961, -16711681,
                -16711936, 65280, -65536 };
        SweepGradient gradient = new SweepGradient(0.0F, 0.0F,
                this.mColors, null);
        this.mPaint = new Paint(1);
        this.mPaint.setShader(gradient);
        this.mPaint.setStyle(Paint.Style.STROKE);
        this.mPaint.setStrokeWidth(32.0F);
        this.mCenterPaint = new Paint(1);
        this.mCenterPaint.setColor(paramInt);
        this.mCenterPaint.setStrokeWidth(5.0F);
    }

    private int ave(int paramInt1, int paramInt2, float paramFloat) {
        return Math.round((paramInt2 - paramInt1) * paramFloat) + paramInt1;
    }

    private int interpColor(int[] paramArrayOfInt, float paramFloat) {
        if (paramFloat <= 0.0F) {
            return paramArrayOfInt[0];
        }
        if (paramFloat >= 1.0F) {
            return paramArrayOfInt[(paramArrayOfInt.length - 1)];
        }
        paramFloat *= (paramArrayOfInt.length - 1);
        int j = (int) paramFloat;
        paramFloat -= j;
        int i = paramArrayOfInt[j];
        j = paramArrayOfInt[(j + 1)];
        return Color.argb(ave(Color.alpha(i), Color.alpha(j), paramFloat),
                ave(Color.red(i), Color.red(j), paramFloat),
                ave(Color.green(i), Color.green(j), paramFloat),
                ave(Color.blue(i), Color.blue(j), paramFloat));
    }

    protected void onDraw(Canvas paramCanvas) {
        float f = CENTER_X - this.mPaint.getStrokeWidth() * 0.5F;
        paramCanvas.translate(CENTER_X, CENTER_X);
        paramCanvas.drawOval(new RectF(-f, -f, f, f), this.mPaint);
        paramCanvas.drawCircle(0.0F, 0.0F, 32.0F, this.mCenterPaint);
        int i;
        if (this.mTrackingCenter) {
            i = this.mCenterPaint.getColor();
            this.mCenterPaint.setStyle(Paint.Style.STROKE);
            if (this.mHighlightCenter) {
                this.mCenterPaint.setAlpha(255);
            } else {
                this.mCenterPaint.setAlpha(128);
            }
            paramCanvas.drawCircle(0.0F, 0.0F,
                    this.mCenterPaint.getStrokeWidth() + 32.0F,
                    this.mCenterPaint);
            this.mCenterPaint.setStyle(Paint.Style.FILL);
            this.mCenterPaint.setColor(i);

        }
    }

    protected void onMeasure(int paramInt1, int paramInt2) {
        setMeasuredDimension(CENTER_X * 2, CENTER_X * 2);
    }

    public boolean onTouchEvent(MotionEvent paramMotionEvent) {
        float f1 = paramMotionEvent.getX() - CENTER_X;
        float f2 = paramMotionEvent.getY() - CENTER_Y;
        boolean bool;
        if (Math.sqrt(f1 * f1 + f2 * f2) <= 32.0D) {
            bool = true;
        } else {
            bool = false;
        }
        switch (paramMotionEvent.getAction()) {
        case 0:
            return true;

        case 1:

            if (mTrackingCenter) {
                if (mTrackingCenter != bool) {
                    this.mHighlightCenter = bool;
                    invalidate();
                    return true;
                } else {
                    f2 = (float) Math.atan2(f2, f1) / 6.283185F;
                    f1 = f2;
                    if (f2 < 0.0F) {
                        f1 = f2 + 1.0F;
                    }
                    this.mCenterPaint
                            .setColor(interpColor(this.mColors, f1));
                    invalidate();
                    return true;
                }
            }
            break;

        case 2:

            if (mTrackingCenter) {
                if (bool) {
                    this.mListener.colorChanged(this.mCenterPaint
                            .getColor());
                }
                this.mTrackingCenter = false;
                invalidate();
                return true;
            }
        }

        return false;
    }
}

public static abstract interface OnColorChangedListener {
    public abstract void colorChanged(int paramInt);
}

}

作者 east

Android 2月 11,2021

Android手电筒后台Service

功能是后台service控制手电的打开和关闭。

public class ToggleFlashService extends Service {
	final String SMS_RECEIVED_STRING = "android.provider.Telephony.SMS_RECEIVED";
	AudioManager audioManager;
	int callState;
	int flashDuration;
	int flashInterval;
	boolean isCameraInUse = false;
	boolean isCameraOpen = false;
	boolean isFlashOn = false;
	Camera.Parameters params;
	Intent serviceIntent;
	TelephonyManager telephonyManager;
	Timer timer;
	TimerTask timerTask;

	public boolean isCameraInUse() {
		try {
			if ((ToggleFlashSettings.camera == null) && (!this.isCameraOpen)) {
				ToggleFlashSettings.camera = Camera.open();
				this.params = ToggleFlashSettings.camera.getParameters();
				this.isCameraOpen = true;
				return false;
			}			
		} catch (Exception localException) {
		}
		return true;
	}

	public void messageReceived() {
	}

	public IBinder onBind(Intent paramIntent) {
		return null;
	}

	public void onCreate() {
		this.telephonyManager = ((TelephonyManager) getSystemService("phone"));
		this.audioManager = ((AudioManager) getSystemService("audio"));
		this.callState = this.telephonyManager.getCallState();
		this.flashDuration = ToggleFlashPrefs
				.getCallFlashInterval(getApplicationContext());
		this.flashInterval = ToggleFlashPrefs
				.getCallFlashDuration(getApplicationContext());
		super.onCreate();
	}


	public void onDestroy() {
		Log.e("Toggle", "ToggleFlash Destroy");
		try {
			if (this.timer != null) {
				this.timer.cancel();
				this.timer = null;
			}
			if ((this.isFlashOn) && (ToggleFlashSettings.camera != null)) {
				this.isFlashOn = false;
				this.isCameraOpen = false;
				this.params = ToggleFlashSettings.camera.getParameters();
				List localList = this.params.getSupportedFlashModes();
				if ((localList.contains("torch"))
						|| (localList.contains("off"))
						|| (localList.contains("on"))) {
					this.params.setFlashMode("off");
					ToggleFlashSettings.camera.setParameters(this.params);
				}
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}			
		} catch (Exception localException) {
			if (ToggleFlashSettings.camera != null) {
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			localException.printStackTrace();
		}
	}


	public int onStartCommand(Intent paramIntent, int paramInt1, int paramInt2) {
		if (ToggleFlashSettings.camera != null) {
			ToggleFlashSettings.camera.release();
			ToggleFlashSettings.camera = null;
		}
		this.serviceIntent = paramIntent;
		this.telephonyManager.listen(new PhoneStateListener() {
			public void onCallStateChanged(int paramAnonymousInt,
					String paramAnonymousString) {
				switch (paramAnonymousInt) {
				default:
					ToggleFlashService.this.callState = 0;
					break;
				case 1:
					ToggleFlashService.this.callState = 1;
					break;
				case 2:
					ToggleFlashService.this.callState = 2;
					break;
				}

			}
		}, 32);
		this.timer = new Timer();
		this.timerTask = new TimerTask() {
			public void run() {
				ToggleFlashService.this.toggleFlash();
			}
		};
		if (this.flashDuration == 0) {
			this.timer.schedule(this.timerTask, this.flashInterval, 50L);
		} else {
			this.timer.schedule(this.timerTask, this.flashInterval,
					this.flashDuration);
		}
		return super.onStartCommand(paramIntent, paramInt1, paramInt2);
	}


	public boolean stopService(Intent paramIntent) {
		try {
			if (this.timer != null) {
				this.timer.cancel();
				this.timer = null;
			}
			if ((this.isFlashOn) && (ToggleFlashSettings.camera != null)) {
				this.isFlashOn = false;
				this.isCameraOpen = false;
				this.params = ToggleFlashSettings.camera.getParameters();
				List localList = this.params.getSupportedFlashModes();
				if ((localList.contains("torch"))
						|| (localList.contains("off"))
						|| (localList.contains("on"))) {
					this.params.setFlashMode("off");
					ToggleFlashSettings.camera.setParameters(this.params);
				}
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			this.isCameraOpen = false;
			this.isFlashOn = false;
			if (ToggleFlashSettings.camera != null) {
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			if (this.serviceIntent != null) {
				boolean bool = super.stopService(this.serviceIntent);
				return bool;
			}
		} catch (Exception localException) {
			localException.printStackTrace();
			if (ToggleFlashSettings.camera != null) {
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			ToggleFlashSettings.camera = null;
		}
		return super.stopService(paramIntent);
	}

	
	public void toggleFlash() {		
		try {
			this.isCameraInUse = isCameraInUse();
			if (this.isCameraInUse) {
				stopService(this.serviceIntent);
				Log.e("ToggleFlashServer", "is isCameraInUse ");     
				return;
			}
			if (this.callState != 1) {
				Log.e("ToggleFlashServer", "callState is 1 ");     
				return;
			}
			 List localList = this.params.getSupportedFlashModes();
			if (!this.isFlashOn) {
				if ((localList.contains("torch"))
						|| (localList.contains("off"))
						|| (localList.contains("on"))) {
					Log.e("ToggleFlashServer", "start torch.... ");    
					this.params.setFlashMode("torch");
					if (ToggleFlashSettings.camera != null) {
						ToggleFlashSettings.camera.setParameters(this.params);
						ToggleFlashSettings.camera.startPreview();
					}
				}
				this.isFlashOn = true;
				return;
			}
			
			if ((localList.contains("torch")) || (localList.contains("off"))
					|| (localList.contains("on"))) {
				this.params.setFlashMode("off");
				if (ToggleFlashSettings.camera != null) {
					ToggleFlashSettings.camera.setParameters(this.params);
					ToggleFlashSettings.camera.stopPreview();
				}
			}
			this.isFlashOn = false;
			stopService(this.serviceIntent);
			
		} catch (Exception localException) {
			localException.printStackTrace();

		}
		
	}
}


public class ToggleFlashPrefs {
	public static final String CALL_FLASH_DURATION = "call_flash_duration";
	public static final String CALL_FLASH_INTERVAL = "call_flash_interval";
	public static final String MSG_FLASH_DURATION = "msg_flash_duration";
	public static final String MSG_FLASH_INTERVAL = "msg_flash_interval";
	public static final String SERVICE_STARTED = "service_started";
	public static final String SET_ALARM_ENABLE = "set_alarm_enable";
	public static final String SET_CALL_ENABLE = "set_call_enable";
	public static final String SET_MESSAGE_ENABLE = "set_message_enable";
	public static final String SET_NOTIFICATION_ENABLE = "set_notification_enable";

	public static boolean getAlarmEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean(
				"set_alarm_enable", false);
	}

	public static boolean getCallEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean("set_call_enable",
				true);
	}

	public static int getCallFlashDuration(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("call_flash_duration",
				250);
	}

	public static int getCallFlashInterval(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("call_flash_interval",
				0);
	}

	public static int getMSGFlashDuration(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("msg_flash_duration",
				250);
	}

	public static int getMSGFlashInterval(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("msg_flash_interval",
				0);
	}

	public static boolean getMessageEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean(
				"set_message_enable", true);
	}

	public static boolean getNotificationEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean(
				"set_notification_enable", false);
	}

	public static boolean getServiceStarted(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean("service_started",
				false);
	}

	static SharedPreferences getSharedPreferences(Context paramContext) {
		return PreferenceManager.getDefaultSharedPreferences(paramContext);
	}

	public static void setAlarmEnable(Context paramContext, boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_alarm_enable", paramBoolean);
		editor.commit();
	}

	public static void setCallEnable(Context paramContext, boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_call_enable", paramBoolean);
		editor.commit();
	}

	public static void setCallFlashDuration(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("call_flash_duration", paramInt);
		editor.commit();
	}

	public static void setCallFlashInterval(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("call_flash_interval", paramInt);
		editor.commit();
	}

	public static void setMSGFlashDuration(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("msg_flash_duration", paramInt);
		editor.commit();
	}

	public static void setMSGFlashInterval(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("msg_flash_interval", paramInt);
		editor.commit();
	}

	public static void setMessageEnable(Context paramContext,
			boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_message_enable", paramBoolean);
		editor.commit();
	}

	public static void setNotificationEnable(Context paramContext,
			boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_notification_enable", paramBoolean);
		editor.commit();
	}

	public static void setServiceStarted(Context paramContext,
			boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("service_started", paramBoolean);
		editor.commit();
	}
}

作者 east

Android 2月 11,2021

Android单行文本跑马灯控件

public class AutoScrollTextView extends TextView implements OnClickListener {
public final static String TAG = AutoScrollTextView.class.getSimpleName();
private int runNum = 1;// 滚动次数
private float textLength = 0f;// 文本长度
private float viewWidth = 0f;
private float step = 0f;// 文字的横坐标
private float y = 0f;// 文字的纵坐标
private float temp_view_plus_text_length = 0.0f;// 用于计算的临时变量
private float temp_view_plus_two_text_length = 0.0f;// 用于计算的临时变量
public boolean isStarting = false;// 是否开始滚动
private Paint paint = null;// 绘图样式
private Paint paint1 = null;// 绘图样式
private String text = “”;// 文本内容
private boolean isFade = true;// 是否加影子
private float layout_width = 168f;

public float getLayout_width() {
    return layout_width;
}

public void setLayout_width(float layoutWidth) {
    layout_width = layoutWidth;
}

public boolean isFade() {
    return isFade;
}

public void setFade(boolean isFade) {
    this.isFade = isFade;
}

public AutoScrollTextView(Context context) {
    super(context);
    initView();
}

public AutoScrollTextView(Context context, AttributeSet attrs) {
    super(context, attrs);
    initView();
}

public AutoScrollTextView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    initView();
}

/** */
/**
 * 初始化控件
 */
private void initView() {
    setOnClickListener(this);
}

/** */
/**
 * 文本初始化，每次更改文本内容或者文本效果等之后都需要重新初始化一下
 */
public void init(WindowManager windowManager) {
    paint = getPaint();
    paint1 = new Paint();
    paint1.setColor(Color.WHITE);
    paint1.setTextSize(getTextSize());
    text = getText().toString();
    textLength = paint.measureText(text);
    viewWidth = layout_width * LogoActivity.screenHeight / 960;
    if (textLength > viewWidth * 2) {
        isStarting = true;
    }
    Log.e("    textLength      ", textLength + "         " + viewWidth);
    if (viewWidth == 0) {
        if (windowManager != null) {
            Display display = windowManager.getDefaultDisplay();
            viewWidth = display.getWidth();
        }
    }
    temp_view_plus_text_length = viewWidth + textLength;
    temp_view_plus_two_text_length = viewWidth + textLength * 2;
    step = temp_view_plus_text_length;
    y = getTextSize() + getPaddingTop();
}

@Override
public Parcelable onSaveInstanceState() {
    Parcelable superState = super.onSaveInstanceState();
    SavedState ss = new SavedState(superState);

    ss.step = step;
    ss.isStarting = isStarting;

    return ss;

}

@Override
public void onRestoreInstanceState(Parcelable state) {
    if (!(state instanceof SavedState)) {
        super.onRestoreInstanceState(state);
        return;
    }
    SavedState ss = (SavedState) state;
    super.onRestoreInstanceState(ss.getSuperState());

    step = ss.step;
    isStarting = ss.isStarting;

}

public static class SavedState extends BaseSavedState {
    public boolean isStarting = false;
    public float step = 0.0f;

    SavedState(Parcelable superState) {
        super(superState);
    }

    @Override
    public void writeToParcel(Parcel out, int flags) {
        super.writeToParcel(out, flags);
        out.writeBooleanArray(new boolean[] { isStarting });
        out.writeFloat(step);
    }

    public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {

        public SavedState[] newArray(int size) {
            return new SavedState[size];
        }

        @Override
        public SavedState createFromParcel(Parcel in) {
            return new SavedState(in);
        }
    };

    private SavedState(Parcel in) {
        super(in);
        boolean[] b = null;
        in.readBooleanArray(b);
        if (b != null && b.length > 0)
            isStarting = b[0];
        step = in.readFloat();
    }
}

/** */
/**
 * 开始滚动
 */
public void startScroll() {
    isStarting = true;
    invalidate();
}

/** */
/**
 * 停止滚动
 */
public void stopScroll() {
    isStarting = false;
    runNum = 1;
    invalidate();

}

@Override
public void onDraw(Canvas canvas) {
    if (isFade)canvas.drawText(text, temp_view_plus_text_length - step, y, paint1);
    canvas.drawText(text, temp_view_plus_text_length - step, y - 1, paint);
    if (!isStarting) {
        return;
    }
    step += 1;
    if (step > temp_view_plus_two_text_length) {
        step = textLength - viewWidth;
        runNum--;

    }
    if (runNum == 0 && step == temp_view_plus_text_length) {
        isStarting = false;
    }
    invalidate();

}

@Override
public void onClick(View v) {

// if (isStarting)
// stopScroll();
// else
// startScroll();

}

作者 east

Android 2月 11,2021

Android游戏加载资源通用类

开发游戏，通常需要在Assets中加载图片和多语言包，下面有个封装类。

/**
 * 图片加载类.
 * 
 * @author 凉
 * 
 */
public class Assets {
	private static Map<String, Map<String, String>> drawables = new HashMap<String, Map<String, String>>();

	private static Map<String, String> raws = new HashMap<String, String>();

	/**
	 * 如果是中文,则从drawable-zh目录加载图片.如果没有,在从drawable里面加载.
	 * 
	 * @param name
	 * @return
	 */
	public static String get(String name) {
		String result = null;
		if (isLunarSetting()) {
			Map map = (Map) drawables.get("drawable-zh");
			if (map != null) {
				String str3 = get(map, name);
				MyLog.d("", ">>>>>>>>>>>path>>>cn>>drawables:" + str3
						+ "   name:" + name);
				if (str3 != null) {
					result = str3;
				} else {
					String str4 = get((Map) drawables.get("drawable"), name);
					MyLog.d("", ">>>>>>>>>>>path>>>en>1>drawables:" + str4
							+ "   name:" + name);
					if (str4 != null) {
						result = str4;
					}
				}
			} else {
				String str2 = get((Map) drawables.get("drawable"), name);
				MyLog.d("", ">>>>>>>>>>>path>>>en>2>drawables:" + str2
						+ "   name:" + name);
				if (str2 != null) {
					result = str2;
				}
			}
		} else {
			String str1 = get((Map) drawables.get("drawable"), name);
			MyLog.d("", ">>>>>>>>>>>path>>>en>3>drawables:" + str1 + "   name:"
					+ name);
			if (str1 != null) {
				result = str1;
			}
		}
		return result;
	}

	private static String get(Map<String, String> map, String name) {
		String str = null;
		if (map.get(name + ".png") != null)
			str = (String) map.get(name + ".png");
		else {
			if (map.get(name + ".jpg") != null) {
				str = (String) map.get(name + ".jpg");
			}
		}
		return str;
	}

	private static String getLanguageEnv() {
		Locale local = Locale.getDefault();
		String language = local.getLanguage();
		String country = local.getCountry().toLowerCase();
		if ("zh".equals(language)) {
			if ("cn".equals(country))
				language = "zh-CN";
			else if ("tw".equals(country)) {
				language = "zh-TW";
			}
		} else if ("pt".equals(language)) {
			if ("br".equals(country)) {
				language = "pt-BR";
			} else if ("pt".equals(country)) {
				language = "pt-PT";
			}
		}
		return language;
	}

	/**
	 * 获取.plist资源.
	 * 
	 * @param name
	 * @return
	 */
	public static String getRaw(String name) {
		return (String) raws.get(name + ".plist");
	}

	/**
	 * 把文件夹res下面的drawable和raw下面的文件路径全部缓存起来.
	 * 
	 * @param context
	 * @throws IOException
	 */
	public static void init(Context context) throws IOException {
		String[] arraystr = context.getAssets().list("res");
		int i = arraystr.length;
		for (int j = 0; j < i; j++) {
			String str1 = arraystr[j];
			String[] strings;
			HashMap drawable;
			if (str1.startsWith("drawable")) {
				strings = context.getAssets().list("res/" + str1);
				drawable = new HashMap();
				int n = strings.length;
				for (int i1 = 0; i1 < n; i1++) {
					String str3 = strings[i1];
					drawable.put(str3, "res/" + str1 + "/" + str3);
				}
				drawables.put(str1, drawable);
			} else if (str1.equals("raw")) {
				String[] lists = context.getAssets().list("res/" + str1);
				for (String str2 : lists)
					raws.put(str2, "res/" + str1 + "/" + str2);
			}
		}
	}

	/**
	 * 是否是中文.
	 * 
	 * @return
	 */
	public static boolean isLunarSetting() {
		String str = getLanguageEnv();
		return ((str != null) && ((str.trim().equals("zh-CN")) || (str.trim()
				.equals("zh-TW"))));
	}
}

作者 east

社交	地图定位	O2O	电商	预订
阅读	多媒体	用户系统	布局	读书
图像	开源项目	签到	支付	搜索
UI控件	咨讯	联网	外卖	共享经济

热门分类