关于tensorflow:ChatGPT-35-和-4-后缀的-turbo32k-是什么含义

什么是 GPT-3.5-Turbo?GPT-3.5-turbo是OpenAI推出的一种自然语言解决模型,基于GPT(Generative Pre-trained Transformer)架构。它是GPT-3的一个更精简和高性能的变体。 GPT-3.5-turbo模型采纳了相似的架构和训练形式,具备弱小的语言生成和理解能力。它通过大规模的预训练数据和自监督学习来学习语言的模式和构造,并能够利用于多种自然语言解决工作,如文本生成、文本摘要、翻译、问题答复等。 相较于GPT-3模型,GPT-3.5-turbo在模型参数规模上进行了优化,能够提供更快的响应速度和更低的老本。只管模型规模较小,但它依然能够在很大水平上放弃GPT系列模型的语言了解和生成能力。 GPT-3.5-turbo是为了提供更宽泛的拜访和利用而推出的,以满足各种不同畛域和规模的自然语言解决需要。它能够作为一个通用的语言模型,用于开发应用程序、生成文本内容、提供对话交互等场景。 须要留神的是,GPT-3.5-turbo绝对于GPT-3模型来说,可能在某些工作上略显有余,但它依然是一种十分弱小和多功能的自然语言解决模型,能够应答许多理论利用中的需要。 什么是 GPT4-32k?GPT-4-32k是OpenAI打算中的下一代自然语言解决模型,它是GPT(Generative Pre-trained Transformer)系列的最新版本之一。其中的"32k"示意模型的参数量和词汇表的大小。 在自然语言解决中,参数量和词汇表大小通常是模型规模的两个重要指标。参数量示意模型中可学习的参数数量,通常以百万(Millions)或十亿(Billions)级别计算。较大的参数量通常意味着模型具备更高的表达能力和更强的语言理解能力。 而词汇表大小则示意模型可能了解和生成的不同词汇的数量。较大的词汇表能够蕴含更多的单词和短语,使模型可能解决更宽泛的语言表达。 在GPT-4-32k中,"32k"代表词汇表的大小,即词汇表中蕴含的不同单词和短语数量为32,000。这意味着模型能够了解和生成来自这32,000个单词和短语的文本。 相比之前的GPT模型,GPT-4-32k具备更大的参数量和更丰盛的词汇表。这使得它在语言生成、对话交互、文本摘要、机器翻译等自然语言解决工作中具备更高的能力和体现。

June 21, 2023 · 1 min · jiezi

关于tensorflow:Generative-AI-新世界-大型语言模型LLMs概述

在上一篇《Generative AI 新世界:文本生成畛域论文解读》中,我率领大家一起梳理了文本生成畛域(Text Generation)的次要几篇论文:InstructGPT,RLHF,PPO,GPT-3,以及 GPT-4。本期文章我将帮忙大家一起梳理另一个目前煊赫一时的话题:大型语言模型(Large Language Models,或简写为 LLMs)。 亚马逊云科技开发者社区为开发者们提供寰球的开发技术资源。这里有技术文档、开发案例、技术专栏、培训视频、流动与比赛等。帮忙中国开发者对接世界最前沿技术,观点,和我的项目,并将中国优良开发者或技术举荐给寰球云社区。如果你还没有关注/珍藏,看到这里请肯定不要匆匆划过,点这里让它成为你的技术宝库!大型语言模型指的是具备数十亿参数(B+)的预训练语言模型(例如:GPT-3, Bloom, LLaMA)。这种模型能够用于各种自然语言解决工作,如文本生成、机器翻译和自然语言了解等。 大型语言模型的这些参数是在大量文本数据上训练的。现有的大型语言模型次要采纳 Transformer 模型架构,并且在很大水平上扩大了模型大小、预训练数据和总计算量。他们能够更好地了解自然语言,并依据给定的上下文(例如 prompt)生成高质量的文本。其中某些能力(例如上下文学习)是不可预测的,只有当模型大小超过某个程度时能力察看到。 以下是 2019 年以来呈现的各种大型语言模型(百亿参数以上)时间轴,其中标黄的大模型已开源。 Source:A timeline of existing LLMs(>10B) https://arxiv.org/abs/2303.18223?trk=cndc-detail 在本期文章中,咱们将一起探讨大型语言模型的倒退历史、语料起源、数据预处理流程策略、训练应用的网络架构、最新钻研方向剖析(LLaMA、PaLM-E 等),以及在亚马逊云科技上进行大型语言模型训练的一些最佳落地实际等。 大型语言模型的倒退历史咱们首先来理解下大型语言模型的倒退历史和最新钻研方向剖析。 大型语言模型 1.0。过来五年里,自从咱们看到最后的Transformer模型 BERT、BLOOM、GPT、GPT-2、GPT-3 等的呈现,这一代的大型语言模型在 PaLM、Chinchilla 和 LLaMA 中达到了高峰。第一代 Transformers 的共同点是:它们都是在大型未加标签的文本语料库上进行预训练的。 大型语言模型 2.0。过来一年里,咱们看到许多通过预训练的大型语言模型,正在依据标记的指标数据进行微调。第二代 Transformers 的共同点是:对指标数据的微调,应用带有人工反馈的强化学习(RLHF)或者更经典的监督式学习。第二代大型语言模型的热门例子包含:InstructGPT、ChatGPT、Alpaca 和 Bard 等。 大型语言模型 3.0。过来的几个月里,这个畛域的热门主题是参数高效微调和对特定畛域数据进行预训练,这是目前进步大型语言模型计算效率和数据效率的最新办法。另外,下一代大型语言模型可能以多模态和多任务学习为核心,这将为大型语言模型带来更多簇新并冲破想象力的泛滥新性能。 在本文第二章节“大模型最新钻研方向剖析”中,咱们还会深入探讨参数微调、特定数据预训练和多模态等方向的相干停顿剖析。 近年来的大型语言模型概览 Source: https://arxiv.org/abs/2303.18223?trk=cndc-detail 上图展现了近年来大型语言模型(大于 10B 的参数)的统计数据,包含容量评估、预训练数据规模(token 数量或存储大小)和硬件资源老本。 图中,“Adaptation” 示意模型是否通过了后续微调:IT 示意指令调整,RLHF 示意通过人工反馈进行强化学习。“Evaluation” 示意模型在原始论文中是否通过了相应能力的评估:ICL 示意上下文学习(in-context learning),CoT 示意思维链(chain-of-thought)。 大型语言模型的语料起源与晚期的预训练语言模型(PLMs)相比,蕴含更多参数的大型语言模型须要更大的训练数据量,涵盖了更宽泛的内容。为了满足这种需要,曾经公布了越来越多的用于钻研的训练数据集。依据他们的内容类型,大抵可分类为六组:图书、CommonCrawl、Reddit 链接、维基百科、代码和其它。如下表所示: Source: https://arxiv.org/abs/2303.18223?trk=cndc-detail ...

June 2, 2023 · 3 min · jiezi

关于tensorflow:TensorFlowCNN实战AI图像处理入行计算机视觉

download:TensorFlow+CNN实战AI图像处理,入行计算机视觉青泥何盘盘,百步九折萦岩峦。这是形容中国山区路线险恶的古诗句,也是对那些勇攀平缓山峰的人们最实在的写照。 青泥何盘盘,百步九折萦岩峦。青泥何盘盘,青色的土地好像是天地之间的一道浅浅的沟壑,但在这片沟壑里却有着有数的谷壑和山峰。这些山峰,如同巨龙个别,高耸入云,气势磅礴。攀登这些山峰,须要克服极大的艰难和挑战,须要顶强的毅力和勇气。 百步九折萦岩峦,这是形容山脉中小路波折险恶的句子。攀登这样的山峰或者只需几分钟,但在这几分钟中,可能会经验几百次的落差,须要逾越数个水潭或者攀登平缓的悬崖峭壁。这样的旅程,十分考验人的意志品质和身体素质。然而,一旦攀到山顶,迎面而来的现象却是令人叹为观止的美景和感慨万千的壮丽。 在这样的路线上,往往会遇到许多意想不到的艰难。但正是那些险恶的山峰、波折的小路,让咱们的人生变得更加乏味和值得摸索。在攀登过程中,咱们须要放弃警惕、沉着,寻找本人后退的方向,越过每一个阻碍。只有勇敢者才可能冲破重重困难,获得胜利。 总之,青泥何盘盘,百步九折萦岩峦,形容的不仅是中国山区的自然风光,更是对那些勇攀平缓山峰的人们最实在的写照。通过攀登山峰,咱们能够锤炼本人的意志品质和身体素质,同时也能够感触到大自然的神奇与漂亮。

May 19, 2023 · 1 min · jiezi

关于tensorflow:TensorFlowCNN实战AI图像处理入行计算机视觉人生得意须尽欢

download:TensorFlow+CNN实战AI图像处理,入行计算机视觉毫无疑问,以后中国整体经济状态正在从传统经济向数字经济转型,千行百业也在减速数字化转型,特地是随着企业数据的积淀越来越宏大,对数据平台以及智能决策等新技术的需要也越来越旺盛。 国家公布的《“十四五”数字经济发展布局》中就强调:“有条件的大型企业要形成数据驱动的智能决策能力”;而科技部公布的《对于反对建设新一代人工智能示范利用场景的告诉》中,也明确使用优化决策等技术,实现生产过程等领域的智能决策。 可能看到,过来几年受疫情的冲击,企业抗危险能力、生产供应柔性、精密化经营等话题被晋升到前所未有的高度,这让企业的数字化转型更加迫切,因此要疾速的适应市场变动,就需要善用数据,让决策智能等新技术在企业的商业模式中创造出更大的价值,更好地升高未来挑战对企业造成的“不必定”的影响,由此才能在激烈的竞争中立于“不败之地”。 而作为寰球最大的企业级软件公司,以及将“数据”融入到公司“基因”和“血脉”中的甲骨文,在此过程中也通过继续的技术创新,打造了“双引擎”——即数据库和云,并且将二者实现了“融会贯通”,由此不只能够驱动更多的企业更好的拥抱决策智能,同时也能够减速泛滥企业的数字化转型步调。 正如甲骨文公司副总裁及中国区技术平台总经理吴承杨所言:“当明天数据越来越重要,在AI和ML变成寰球最热门话题的大背景下,甲骨文公司具备‘算力、数据、模型和生态’等劣势,这也让甲骨文可能帮助泛滥中国的企业在使用数据库,包含基于数据做决策的时候能够足够简略,开箱即用,未来咱们也心愿通过‘双引擎’技术的继续翻新,让千行百业能够更便当地通过数据创造出更多的新价值。 数据驱动决策大势所趋 家喻户晓,企业的数字化转型从来不是一个简略的技术问题,其目标或者本质是要将数字化的思维和方法贯穿到企业的要害场景之中,包含生产、销售、营销、服务等方面,而背地的要害就在于企业要构建数据驱动的模式,由此才能推动企业实现全面的数字化转型。 特地是随着大数据、人工智能、决策智能等技术融合日益加深,通过数据驱动打造企业智能化和精密化的经营模式已成为要害力量。从甲骨文近期公布的《寰球决策困境研究报告》中,咱们就能充分感受到这种变动,该报告对包含中国在内的17个国家/地区的14000多名员工和企业负责人开展调研,得出的论断是——做出正确决策至关重要,但非易事。 一是,数据的爆发式增长,正在阻碍企业的取得胜利。报告浮现,81%的中国受访者认为,他们正受到来自更多渠道的数据“轰炸”,这比以往任何时候都要多;超过86%的中国受访者示意,宏大的数据量使得集体和工作决策变得更加简单;更有高达90%的中国受访者示意,与日俱增的数据起源,正在有碍企业或者组织获得胜利,原因在于需要其余资源来收集所有数据,并确保在此过程中不能丢失任何数据;极大的减少了收集数据的工夫,并造成战略决策迟缓,且减少出错的机会。 二是,越来越多的企业受到了基于数据决策带来的干扰。报告指出,有76%的中国受访者示意,他们每天所做的决策数量在过来三年的工夫里减少了10倍,也有同时超过78%的中国受访者示意,因数据量过于宏大而放弃做出决策,有82%的中国企业指导者更是承认,他们对数据不足信赖,由此导致残缺无奈做出任何决策;超过92%的中国企业指导者正在蒙受决策干扰,不少指导者对过来一年所做的决策也曾感到后悔、内疚或已经质疑过自己做出的决策。 三是,利用技术创新实现数据驱动型决策的公司将是未来的趋势所在。报告中提到,有96%的中国企业指导者认为,具备合适的决策智能可能决定组织的胜利与否,背地的关键在于越来越多的指导者意识到,正确的数据和洞察可能帮助企业改恶人力资源、供应链、财务和客户体验方面的决策,同时还能在其余方面获得胜利,包含超过81%的中国受访者认为,数据驱动决策可能更好地排汇人才;78%的受访者认为,可能更好地获得投资者的青睐;而更有超过90%的中国企业指导者示意,在未来偏向于让机器人做出决策。 对此,甲骨文公司高级副总裁及亚洲区董事总经理李翰璋强调:“随着数字经济的飞速发展,企业需要更多的相干数据来获得全局视图。同时,对于负责制订决策的企业指导者而言,如果忽视这些数据背地的价值,就需自担风险。因此,企业指导者是时候重新考虑对待数据和决策的方法了。” 由此可见,在数据大爆炸的明天,对于企业而言要基于数据做出正确的决策绝不是一件容易的事件,日益减少的数据对企业而言诚然是一笔“宝藏”资源,但要真正要让数据产生价值,驱动企业做出高质量的决策,要害的“落脚点”还在于企业需要将信息、数据、洞察及口头串联起来,由此才能开释数据带来的全新价值。 减速企业拥抱决策智能 在此背景下,甲骨文基于自身在数据领域四十多年的积累和积淀,并以全新的“双引擎”技术创新形式,为企业提供收集、分析和利用数据所需的决策智能,助力企业做出现实的决策。 甲骨文公司中国区技术咨询部高级总监李珈示意:“产生决策智能的要害因素,不能仅仅只靠一种技术能够实现的。这是一门实践,需要通过技术来撑持零碎不断地练习,去理解数据,收集数据,并对这些数据进行分析,进行挖掘,而后不断根据后果去反馈,去调优,去锤炼模型,再去修改这个模型。这是一个改善决策智能的要害因素的过程,也是甲骨文心愿通过数据驱动企业决策背地所保持的逻辑。”基于此,甲骨文也正通过“双引擎”的技术创新形式,驱动和减速更多企业拥抱决策智能。 首先,甲骨文能够通过“融合数据库”的形式,让企业的数据平台能够反对所有数据类型、工作负载,以及不同的开发风格。 例如,在工作负载方面,甲骨文可能提供HTAP混合事务和分析处理能力,而这个功能 十年前甲骨文就已经推出了,发展到明天功能已经十分弱小,最为典型的如 Oracle Database In-Memory就能撑持不同的利用;此外,甲骨文也能够对不同数据类型提供反对,如关系、文档、图和空间多模数据处理。 更为要害的是,甲骨文往年刚刚公布的Oracle Database 23c 开发者版本,新减少了“JSON Relational Duality”功能,该功能不只能够让开发人员可能根据不同的使用场景抉择合适的拜访格局,而无需担心数据结构、数据映射、数据一致性或性能优化方面的问题,同时还可能基于关系数据和JSON 数据运行图形分析。也正因此,第三方分析机构IDC给与了这项功能极高的评估,指出:“Oracle JSON Relational Duality 是一个真正的革命性解决打算,可能是信息科学领域近20 年来非常重要的翻新之一。” 其次,借助甲骨文弱小的云基础设施(OCI)能力,明天企业无论是在云端还是本地的数据中心,同样也能获得雷同的“自治数据库”能力。 简略来说,过来甲骨文的自治数据库只能运行在Oracle私有云环境之中,对于很多想尝试自治数据库的企业来说是有一些难度的,但现在甲骨文买通了云端和本地的数据中心,由此让“自治数据库”的能力变得“无处不在”。 这其中翻新的“代表”就是Oracle Exadata专有云数据库一体机(Oracle Exadata Cloud@Customer,ExaCC),它既能为企业提供原有的利用数据库撑持;同时另一方面它也能以低成本、便当自助的形式帮助企业轻松部署甲骨文自治数据库。换句话说,基于ExaCC运行的多虚拟机自治数据库能够更好地利用Oracle Exadata基础设施“底座”的性能、可扩展性和可用性劣势,这样就可能让企业更加轻松部署云原生和要害工作数据库。不只如此,过来几年甲骨文还推出了很多的翻新打算,如Oracle专有云本地化解决打算(Oracle Dedicated Region Cloud@Customer),该打算可能将私有云的能力全副“搬到”客户的本地数据中心等等。 最初,甲骨文还提供Oracle 分析平台(Oracle Analytics platform),借助其内置的机器学习技术,也可能帮助企业更快实现数据分析。“Oracle Analytics的技术门槛非常低,企业可能开箱即用,而根本不需要知道它是用什么方法,什么原理帮助企业实现数据分析过程的。”李珈说。 不难看出,通过甲骨文在弱小的“融合数据库”、无处不在的“自治数据库”,以及数据库中内嵌的机器学习和人工智能,企业可能更好的在基础数据管理、增强和利用分析方面“大展身手”,更快地拥抱决策智能,让决策智能的获得变得更加简略和便利。 “双引擎”赋能千行百业 事实上,甲骨文“双引擎”的技术创新形式在决策智能领域的利用仅仅是一个“缩影”,在更大范畴,更多利用场景中,甲骨文的“双引擎”也在赋能千行百业的数字化转型。 吴承杨说:“如果说明天甲骨文和过来五年或者十年有什么不一样,最大的变动就在于咱们新增了云的引擎,这不只推动了甲骨文的业务的高速增长,更重要的是也让甲骨文成为了一家云转型胜利的公司。” 的确如此,甲骨文2023财年第三季度财报浮现,其寰球总营收为124亿美圆,若按固定汇率计算,同比增长21%;其中云服务营收到达41亿美圆,若按固定汇率计算,同比增长48%;此外,甲骨文云基础设施中的laaS业务营收为12亿美圆,若按固定汇率计算,同比增长57%。截止目前,甲骨文OCI在寰球范畴内已经部署了超过41个云区域。 因此,这也让扎根中国市场34年的甲骨文,在全新的期间能够以“双引擎”的技术创新能力,将更多先进的科技带给中国企业;同时也在保证数据安全合规的同时,能够以更低成本,更疾速部署的劣势助力千行百业减速数字化转型。 第一,从数据翻新维度看,甲骨文是寰球多数具备“算力、数据、模型和生态”等劣势的公司,因此无论是数据的治理,还是基于数据做决策智能,都是甲骨文可能施展价值的领域。 例如,在算力方面,甲骨文 OCI 在寰球具备超过41个云区域,同时具备弱小的GPU算力劣势;在数据方面,甲骨文已经做了45年的工夫,可能说甲骨文是最懂在行业中如何做数据的;在模型方面,甲骨文深耕企业级市场,做的是数据相干的大模型,自治数据库就是其中的‘集大成者’;而在生态方面,甲骨文不只是数据库公司,也是寰球最大的企业级软件公司,更是唯一一家提供完整企业级IaaS、PaaS和SaaS产品与服务的云厂商,特地是在ERP还是HCM乃至垂直行业软件方面,甲骨文都有深入布局,因此可能将企业在不同利用中的数据发掘出来,通过融合数据库弱小的能力,更好地开释数据价值进去。 第二,从企业赋能维度看,国家此前提出了“双循环”的策略,越来越多各赛道的中国企业也正在将中国的业务和翻新模式输入到海内市场,心愿寻找到更多新的商业机会,而在此过程中甲骨文也可能提供更好的私有云服务,助力企业更好的“入华出海”。 “明天越来越多的中国企业在出海的时候抉择甲骨文,这一点也印证了甲骨文在私有云上的翻新能力赢得了客户的认可,因此这也让咱们在中国私有云市场的发展速度远超寰球市场,同时也甲骨文在未来更加有自信心地服务好好中国的本地客户,同时帮助海内的客户进入到中国,比如HSBC(汇丰银行)进入中国市场时,甲骨文就是残缺满足安全合规的申请情况帮助他们实现了落地。”吴承杨说。 第三,从心态凋谢的维度看,可能看到过来几年中国市场出现了越来越多的数据库公司,对此甲骨文也是始终保持凋谢和互相学习的态度,并心愿通过自身的技术的翻新,让更多的企业意识到数据的后劲,开释好数据的价值。 对此,吴承杨示意:“咱们非常欢迎数据库这个行业有更多的厂商进入,不管在寰球还是在中国,这是非常明确的,因为甲骨文认为数据库其实是一个绝对冷门的领域,需要更多人关注,因为关注数据库就是关注数据。因此甲骨文鼓励更多的厂商投入这个领域,咱们也违心保持着凋谢的心态和同行互相学习,同时也违心把选择权交给客户做决定。” “回头来看,甲骨文在数据库领域已经做了超过45年的工夫,咱们每年研发投入在营收的15%左右,每年有超过60亿美圆用来研发,同时寰球也具备很多的客户,每年也会做大量的迭代和优化,最终的目标和愿景也很清晰——就是让数据库‘化繁为简’,简略到让企业感觉不到它的存在,简略到人人都可能使用。”吴承杨最初说。 全文总结,“数字中国”的顶层布局、中国式现代化的整体规划为整个科技产业创造了巨大的历史时机,愈减速了千行百业数字化转型的步调,而扎根中国市场34年的甲骨文,也正通过全新的“双引擎”技术创新和赋能的形式,减速中国企业数字化转型,推动中国数字经济的高质量发展,这不只是甲骨文“以行践言”推动中国企业更快拥抱决策智能,最大化开释数据价值的体现,同时也是其过来三十多年来能够深度融入中国市场,并服务好中国行业客户的核心和关键所在。

May 7, 2023 · 1 min · jiezi

关于tensorflow:TensorFlowCNN实战AI图像处理入行计算机视觉无密分享钟鼓馔玉不足贵

TensorFlow+CNN+AI: 人工智能的将来之路 download:https://www.sisuoit.com/3870.htmlTensorFlow和CNN都是当今最为风行和利用宽泛的机器学习技术,而人工智能(AI)则是它们的外围利用之一。本文将介绍TensorFlow、CNN和AI的特点和劣势,并探讨它们在理论利用中的价值和前景。 TensorFlow的特点和劣势TensorFlow是谷歌开源的机器学习框架,具备以下特点和劣势: 灵活性:TensorFlow反对多种深度学习模型,能够满足不同的需要和场景。易于应用:TensorFlow提供了丰盛的API和工具,使得开发者能够疾速构建、训练和部署模型。分布式训练:TensorFlow反对分布式训练,能够并行处理大量数据和简单模型。凋谢源代码:TensorFlow凋谢源代码,激励社区独特构建更多的利用和服务。 CNN的特点和劣势CNN是卷积神经网络,是一种深度学习模型,具备以下特点和劣势: 部分连贯:CNN应用部分连接结构,能够缩小参数数量和计算量。参数共享:CNN应用参数共享机制,能够进步模型的泛化能力。池化层:CNN应用池化层,能够缩小特色图维度和计算量。多通道:CNN能够解决多通道的输出数据,能够进步模型的表达能力。 AI的特点和劣势AI是人工智能,是指计算机程序可能模仿人类的智能行为,具备以下特点和劣势: 自动化:AI能够主动实现各种简单的工作,进步工作效率和生产力。智能化:AI能够依据人类需要和反馈进行学习和调整,一直进步本身的智能程度。个性化:AI能够依据用户的个性化需要和数据进行举荐和服务,进步用户体验和满意度。利用宽泛:AI能够利用于各个领域,如医疗、金融、教育等,为社会带来更多的价值和福利。 TensorFlow+CNN+AI在理论利用中的价值和前景TensorFlow+CNN+AI的组合能够利用于各个领域,如图像识别、语音辨认、自然语言解决等。以下是一些利用场景: 医疗:应用TensorFlow+CNN对医学影像进行辨认和剖析,辅助医生进行诊断和医治。金融:应用TensorFlow+CNN对金融数据进行剖析和预测,为投资者提供更加精确的投资决策。教育:应用TensorFlow+AI进行学习评估和个性化举荐,进步学生学习效果和教育品质。主动驾驶:应用TensorFlow+CNN对车辆周围环境进行感知和决策,实现主动驾驶性能。 总结TensorFlow+CNN+AI是人工智能畛域中备受关注和广泛应用的技术组合,它们的劣势和特点使得其在各个领域领有微小的后劲和前景。在理论利用中,须要依据不同的需要和场景进行抉择和利用,并且保障TensorFlow、CNN和AI之间的通信和交互顺畅,避免出现问题和影响应用程序的稳定性和安全性。

May 4, 2023 · 1 min · jiezi

关于tensorflow:TensorFlowCNN实战AI图像处理入行计算机视觉几处早莺争暖树

TensorFlow+CNN实战AI图像处理,入行计算机视觉-download:https://www.zxit666.com/6012/CNN:让图像识别更精准、高效的深度学习算法 卷积神经网络(CNN)是一种被广泛应用于图像识别、语音辨认、自然语言解决等畛域的深度学习算法。本文将深入探讨CNN的原理和利用,帮忙读者更好地了解并利用该算法。 什么是CNN? 卷积神经网络是一种前馈神经网络,其构造蕴含卷积层、池化层、全连贯层等组件。通过卷积操作、非线性激活函数等技术,CNN能够在数据集中提取出有用的特色,从而实现高效的图像分类、辨认等工作。 CNN的要害个性 部分连贯 - CNN采纳的是部分连贯和权值共享的形式,升高了模型的复杂度,进步了计算效率。 参数共享 - 对于同一类型的特色,CNN会应用雷同的参数进行解决,从而缩小了模型的训练工夫和存储空间。 池化操作 - CNN会对特色图进行下采样操作,从而减小特色图的大小,进步模型的鲁棒性和泛化能力。 多层次形象 - CNN通过多个卷积层和池化层的叠加,实现对数据集特色的多层次形象和提取。 CNN的利用场景 图像分类 - CNN能够通过训练模型,实现对图像进行分类、辨认等工作,如人脸识别、数字辨认等。 指标检测 - CNN能够通过候选框和区域倡议等技术,实现对指标物体的检测和定位。 语音辨认 - CNN能够通过声学建模和声学特征提取等技术,实现对语音信号的辨认和转换。 自然语言解决 - CNN能够通过词向量示意和卷积操作等技术,实现对文本序列的分类和解决。 总之,CNN是一种非常弱小的深度学习算法,其部分连贯、参数共享、池化操作等个性为用户提供了更多的抉择。把握CNN的核心技术和劣势,能够帮忙开发者更好地应用该算法,开发出更加精准、高效的应用程序。

April 29, 2023 · 1 min · jiezi

关于tensorflow:TensorFlowCNN实战AI图像处理入行计算机视觉无密

TensorFlow+CNN实战AI图像处理,入行计算机视觉 download:https://www.sisuoit.com/itkecheng/shizhankechengTensorFlow+CNN实战AI图像处理随着人工智能技术的一直倒退,AI图像处理曾经成为一个热门畛域。在泛滥的AI图像处理技术中,卷积神经网络(Convolutional Neural Network,CNN)曾经成为了最为风行和广泛应用的一种技术。而TensorFlow作为目前最为风行的深度学习框架之一,也被广泛应用于CNN的实现。本文将介绍如何应用TensorFlow实现CNN进行图像处理,并以手写数字辨认为例进行实战解说。数据集筹备首先咱们须要筹备一个适合的数据集。在这里咱们应用MNIST手写数字数据集,该数据集蕴含60000个训练样本和10000个测试样本。能够应用TensorFlow自带的mnist库进行导入。网络架构设计咱们应用的是LeNet-5网络架构,它是一个比拟根底并且易于了解的CNN网络结构。它由两个卷积层、两个池化层和三个全连贯层组成。具体构造如下: 模型构建咱们应用TensorFlow进行模型的搭建。首先,咱们须要定义输出和输入: 输出x = tf.placeholder(tf.float32, [None, 28, 28, 1])y_ = tf.placeholder(tf.float32, [None, 10])接着,咱们依照LeNet-5网络结构,顺次增加卷积层、池化层和全连贯层:# 第一卷积层W_conv1 = weight_variable([5, 5, 1, 6])b_conv1 = bias_variable([6])h_conv1 = tf.nn.relu(conv2d(x, W_conv1) + b_conv1)h_pool1 = max_pool_2x2(h_conv1)# 第二卷积层W_conv2 = weight_variable([5, 5, 6, 16])b_conv2 = bias_variable([16])h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)h_pool2 = max_pool_2x2(h_conv2)# 全连贯层1W_fc1 = weight_variable([7 * 7 * 16, 120])b_fc1 = bias_variable([120])h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*16])h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)# 全连贯层2W_fc2 = weight_variable([120, 84])b_fc2 = bias_variable([84])h_fc2 = tf.nn.relu(tf.matmul(h_fc1, W_fc2) + b_fc2)# 输入层W_fc3 = weight_variable([84, 10])b_fc3 = bias_variable([10])y_conv=tf.nn.softmax(tf.matmul(h_fc2, W_fc3) + b_fc3)其中,weight_variable和bias_variable是辅助函数,用于生成权重和偏移量的变量:# 权重变量def weight_variable(shape): initial = tf.truncated_normal(shape, stddev=0.1) return tf.Variable(initial)# 偏移量变量def bias_variable(shape): initial = tf.constant(0.1, shape=shape) return tf.Variable(initial)conv2d和max_pool_2x2别离是卷积和池化的操作函数:# 卷积操作def conv2d(x, W): return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')# 池化操作def max_pool_2x2(x): return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')训练模型接下来咱们须要进行模型的训练和测试。首先须要定义损失函数和优化器:# 损失函数 ...

April 29, 2023 · 1 min · jiezi

关于tensorflow:Tensorflowjs-多分类机器学习区分企鹅种类

前言&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp在规定编码中,咱们经常会遇到须要通过多种区间判断某种物品分类。比方二手物品的定价,只管不是新品没有 SKU 然而根本的参数是少不了。想通过成色来辨别某种物品,其实次要是确定一些参数。而后依据参数数据以及参数对应成色的所有数据集归档用机器学习训练,这样机器就能够得出规定了。        &nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp机器制订规定后,咱们前面再给相应参数,他就能对成色进行分类了。以上只是打了个比如加之没有二手商品相干的数据集,所以就找了一个企鹅种类数据集,大家能够在网上搜寻 “帕尔默企鹅数据集” 就能够下载了。以下内容还是实战类,偏原理的可能前期补上。 数据集介绍背景形容 由 Kristen Gorman 博士和南极洲 LTER 的帕尔默科考站独特创立,蕴含 344 只企鹅的数据。 数据阐明 species: 三个企鹅品种:阿德利 (Adelie) 巴布亚 (Gentoo) 帽带 (Chinstrap) culmen_length_mm: 鸟的嘴峰长度 culmen_depth_mm: 鸟的嘴峰深度 flipper_length_mm: 脚掌长度 body_mass_g: 体重 island: 岛屿的名字 sex: 企鹅的性别 数据处理&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsptensorflow.js 在进行训练前,都须要对原先的数据集进行 tensor 格局 转换,为了训练品质,数据集的数值最好管制在 0 到 1 之间,所以必要时候还要对转换的 tensor 进行归一化解决。对于老手而言,这里的解决形式看集体,我就用 js 形式进行的解决。因为 "帕尔默企鹅数据集" 是 csv,我就用 js 原始的办法进行了数据转化。&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp数组索引 0 是企鹅品种 (0. 阿德利,1. 帽带 2. 巴布亚), 索引 1 岛屿 (0.Torgersen 1.Biscoe 2.Dream), 索引 2,索引 3,索引 4,索引 5 别离是企鹅嘴峰长度,企鹅嘴峰深度,脚掌长度,体重,性别。以上数据是长度的单位都是毫米,体重的单位都是克,所以数值比拟大,转化数据如下。 ...

April 26, 2023 · 4 min · jiezi

关于tensorflow:我通过-tensorflow-预测了博客的粉丝数

前言因为最近接触了 tensorflow.js,出于试一下的心态,想通过线性回归预测一下博客的粉丝走向和数量,后果翻车了。尽管场景用错中央,然而整个实战办法用在身高体重等方面的预测还是有可行性,所以就记录下来了。 需要依据某博客或论坛,抓取一下博主的拜访总量和粉丝总量,剖析其关联,训练数据,最初通过输出指定拜访数量预测吸粉总数。 Tensorflow.jsTensorflow.js 是一个能够在浏览器或 Node 环境利用 JavaScript 语法运行深度学习。让前端就能够实现相似依据图片类型的含糊搜寻,语音辨认管制网页,图片的人像辨认等性能,既加重服务器训练压力,也爱护了用户隐衷 (在非凡场景下,不必将图片传到服务器后做人像标识)。 技术清单tensorflow.jsparceltfjs-vis实战实战是须要本地有 Node 环境,并且装置了 npm 等包管理工具,对于这些的装置这里就略过了。次要是我的项目的搭起,线性回归的编码以及运行后果。. 我的项目搭建 (1). 创立我的项目目录和 package.json { "name": "tensorflow-test", "version": "1.0.0", "description": "", "main": "index.js", "dependencies": { "@tensorflow-models/speech-commands": "^0.4.0", "@tensorflow/tfjs": "^1.3.1", "@tensorflow/tfjs-node": "^1.2.9", "@tensorflow/tfjs-vis": "^1.2.0" }, "devDependencies": {}, "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "author": "", "license": "ISC", "browserslist": [ "last 1 Chrome version" ]}(2). 切换到当前目录,运行 npm install 进行装置(3). 在当前目录下创立目录和运行文件。(4). 装置 parcel,一个打包工具。npm install -g parcel-bundler ...

April 23, 2023 · 2 min · jiezi

关于tensorflow:推荐系统基于tensorflow搭建混合神经网络精准推荐

作者:韩信子@ShowMeAI 深度学习实战系列:https://www.showmeai.tech/tutorials/42 TensorFlow 实战系列:https://www.showmeai.tech/tutorials/43 本文地址:https://www.showmeai.tech/article-detail/310 申明:版权所有,转载请分割平台与作者并注明出处 珍藏ShowMeAI查看更多精彩内容 举荐零碎是预测用户对多种产品的偏好的模型,互联网时代,它在各种畛域大放异彩,从视频音乐多媒体举荐、到电商购物举荐、社交关系举荐,无处不在地晋升用户体验。 最常见的举荐零碎办法包含:基于产品特色(基于内容)、用户相似性(协同过滤等近邻算法)、个人信息(基于常识)。当然,随着神经网络的日益遍及,很多公司的业务中应用到的举荐算法曾经是上述所有办法联合的混合举荐零碎。 在本篇内容中,ShowMeAI 将给大家一一道来,从传统举荐零碎算法到前沿的旧式举荐零碎,解说原理并手把手教大家如何用代码实现。 本篇内容应用到的 MovieLens 电影举荐数据集,大家能够在 ShowMeAI 的百度网盘地址下载。 实战数据集下载(百度网盘):公众号『ShowMeAI钻研核心』回复『实战』,或者点击 这里 获取本文 [[19]基于TensorFlow搭建混合神经网络举荐零碎](https://www.showmeai.tech/art...) 『MovieLens 电影举荐数据集』 ⭐ ShowMeAI官网GitHub:https://github.com/ShowMeAI-Hub 数据集蕴含观众对电影的评分后果,有不同规模的数据集大小,咱们本篇内容中的代码通用,大家能够依据本人的计算资源状况抉择适合的数据集。 小数据集为 600 名观众对 9000部电影的 10w 个打分,也包含电影标签特色。大数据集为 280000 名观众对 110w 部电影的 2700w 评分。 本文波及的内容板块如下: 根本设置&数据预处理冷启动问题&解决基于内容的办法(tensorflow 和 numpy实现)传统协同过滤和神经协同过滤模型(tensorflow/keras 实现)混合模型模型(上下文感知,tensorflow/keras 实现) 根本设置&数据预处理 工具库导入首先,咱们导入所需工具库: # 数据读取与解决import pandas as pdimport numpy as npimport refrom datetime import datetime# 绘图import matplotlib.pyplot as pltimport seaborn as sns# 评估与预处理from sklearn import metrics, preprocessing# 深度学习from tensorflow.keras import models, layers, utils #(2.6.0) 读取数据接下来咱们读取数据。 ...

October 28, 2022 · 5 min · jiezi

关于tensorflow:win10系统-Anaconda安装tensorflow1140cpu版本

1.conda设置国内源,放慢下载速度,不然速度会十分慢conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/conda config --set show_channel_urls yes2.创立python3.6版本的虚拟环境conda create -n tf114 python=3.6 3.进入tf114环境conda activate tf114 4.用conda装置tensorflowconda install tensorflow=1.14.0 5.参考文献通过Anaconda3装置Tensorflow 1.15.0 记录 6.总结过程十分快,大略10-20分钟。我的conda版本是4.12.0

August 25, 2022 · 1 min · jiezi

关于tensorflow:Mac-M1安装tensorflow过程简单网速快的话10分钟搞定

1.macos版本12及以上2.装置arm64 macos的miniconda在此处下载。选中下图文件中的版本。 # 下载完当前在terminal顺次输出以下三个命令 chmod +x ~/Downloads/Miniforge3-MacOSX-arm64.sh sh ~/Downloads/Miniforge3-MacOSX-arm64.sh source ~/miniforge3/bin/activate3.更换conda下载源因为conda国内下载速度慢,更换为国内镜像地址。在终端中顺次输出以下两行命令。 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/conda config --set show_channel_urls yes4.新建conda环境因为我本机的conda的base环境是3.9,所以我也应用3.9创立虚拟环境在终端中输出以下命令。 conda create -n tf python==3.9切换到新环境在终端中输出以下命令。 conda activate tf5.装置tensorflow# pip下载在国内也很慢,很容易网络连接超时,-i https://pypi.tuna.tsinghua.edu.cn/simple可能切换到清华源下载# 在终端中顺次输出以下三行命令。这三行命令都是下载包,可能速度有点慢,然而切换源之后应该速度很快。conda install -c apple tensorflow-depspython -m pip install tensorflow-macos -i https://pypi.tuna.tsinghua.edu.cn/simplepython -m pip install tensorflow-metal -i https://pypi.tuna.tsinghua.edu.cn/simple6.参考文献Mac M1 装置原生tensorflow(超简略,亲测可用)

August 19, 2022 · 1 min · jiezi

关于tensorflow:MindSpore报错-ValueError-Minimum-inputs-size-0-does-not-match

1 报错形容1.1 零碎环境Hardware Environment(Ascend/GPU/CPU): GPUSoftware Environment:– MindSpore version (source or binary): 1.5.2– Python version (e.g., Python 3.7.5): 3.7.6– OS platform and distribution (e.g., Linux Ubuntu 16.04): Ubuntu 4.15.0-74-generic– GCC/Compiler version (if compiled from source): 1.2 根本信息1.2.1 脚本训练脚本是通过构建Minimum的单算子网络,计算输出Tensor对应元素的最小值。脚本如下: 01 class Net(nn.Cell): 02 def __init__(self): 03 super(Net, self).__init__() 04 self.minimum = ops.minumum() 05 def construct(self, x,y): 06 output = self.minimum(x, y) 07 return output 08 net = Net() 09 x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float64) .astype(mindspore.float32) 10 y = Tensor(np.array([3.0, 5.0, 6.0]), mindspore.float64) .astype(mindspore.float32) 11 output = net(x, y) 12 print('output', output) ...

July 15, 2022 · 2 min · jiezi

关于tensorflow:MindSpore报错ValueError-For-AvgPool-输出形状的每一维都要大于零

1 报错形容1.1 零碎环境Hardware Environment(Ascend/GPU/CPU): AscendSoftware Environment:– MindSpore version (source or binary): 1.8.0– Python version (e.g., Python 3.7.5): 3.7.6– OS platform and distribution (e.g., Linux Ubuntu 16.04): Ubuntu 4.15.0-74-generic– GCC/Compiler version (if compiled from source): 1.2 根本信息1.2.1 脚本训练脚本是通过构建AvgPool的单算子网络,对输出的多维数据进行二维均匀池化运算。脚本如下: 01 class Net(nn.Cell): 02 def __init__(self): 03 super(Net, self).__init__() 04 self.avgpool_op = ops.AvgPool(pad_mode="VALID", kernel_size=32, strides=1) 05 06 def construct(self, x): 07 result = self.avgpool_op(x) 08 return result 09 10 x = Tensor(np.arange(128 20 32 * 65).reshape(65, 32, 20, 128),mindspore.float32) 11 net = Net() 12 output = net(x) 13 print(output)1.2.2 报错这里报错信息如下: ...

July 15, 2022 · 2 min · jiezi

关于tensorflow:易学又易用就在MindSpore-v17-基于新特性的mindsporenumpy进行图像拼接

利用体验:MindSpore v1.7中MindSpore NumPy工具包提供了一系列类NumPy接口,不仅能够应用类NumPy语法在MindSpore上进行模型的搭建,还能够用其来进行图像处理操作,比方在数据加强场景下进行图像拼接 代码: import mindspore.numpy as npimport matplotlib.pyplot as plt a = plt.imread("./mindspore.jpg") 将图像沿着程度方向反复三次。print(a.shape)b=np.concatenate((a,a,a),axis=1)print(b.shape) 将图像沿着垂直方向反复两次c=np.concatenate((a,a),axis=0)print(c.shape) 将图像沿着程度方向反复两次,垂直反复三次。d=np.concatenate((a,a),axis=1)d=np.concatenate((d,d,d),axis=0)print(d.shape)fig,ax = plt.subplots(2,2)fig.set_size_inches(5,5) # 画布大小ax[0,0].imshow(a)ax[0,1].imshow(b)ax[1,0].imshow(c)ax[1,1].imshow(d)plt.tight_layout() # 主动调整间距plt.show() 效果图:

June 28, 2022 · 1 min · jiezi

关于tensorflow:基于tfjs和threejs的web端AR人脸特效

前言加强事实(Augmented Reality,简称AR)浪潮正滚滚而来,各种AR利用层出不穷——AR导航、AR购物、AR教学、AR游戏……能够说,AR正在粗浅的扭转咱们的生存。 而撑持AR的底层技术也在一直降级。AI技术的遍及,让AI能力得以轻松的接入理论利用,TensorFlow.js(tfjs)的呈现,则让前端也能在AI畛域大展身手。浏览器和挪动设施的降级,也使得Web利用具备更多的可能性。 Web 浏览器作为人们最唾手可得的人机交互终端,具备不用装置APP,“开箱即用”的人造劣势,且可能反对手机、平板、PC等多种终端运行。在这场AR技术的浪潮中,Web AR必将无可限量。 第一章 工具介绍TensorFlow.js是Google公布的用于应用 JavaScript 进行机器学习开发的库,自2018年公布以来就受到宽泛关注,有了tfjs,咱们就能够应用 JavaScript 开发机器学习模型,并间接在浏览器或 Node.js 中训练或应用机器学习模型。 Three.js是一个用于在浏览器中创立和展现3D图形的js工具库,由Ricardo Cabello在2010四月于GitHub首次公布。它基于WebGL,可能调用硬件加速,这使得在浏览器中显示简单的三维图形和动画成为可能。 第二章 重要概念咱们先来理解一些重要的概念。 Face MeshFace Mesh是一种脸部几何解决方案,蕴含468集体脸特色点。每个点具备编号,能够依据编号获取各个部位对应的特色点。(编号查问) UV MapUV是二维纹理坐标,U代表程度方向,V代表垂直方向。UV Map用来形容三维物体外表与图像纹理(Texture) 的映射关系,有了UV Map,咱们就能够将二维的图像纹理粘贴到三维的物体外表。 MatrixMatrix即矩阵,能够形容物体的平移,旋转和缩放。Three.js应用matrix来进行3D变换。 状态键状态键(morph target)在3D制作软件中,通常用来制作物体形变动画,例如一些面部动作——眨眼、张嘴等等。状态键的取值范畴是0.0到1.0,对应形变动画的起始和终止状态。通过扭转状态键的取值,就能够准确的管制形变动画。 第三章 架构设计程序的架构如图所示,过程形容如下:首先咱们须要调取Camera,取得相机画面而后通过tfjs加载人脸识别模型,并生成Face Mesh依据Face Mesh生成三角网格,并进行UV贴图,绘制面部图案通过人脸特色点计算出Matrix,和面部动作辨认加载3D模型,并对其利用Matrix,使其呈现在正确的地位管制模型做出眨眼、张嘴等面部动作 第四章 性能拆解调取Camera通过navigator.mediaDevices.enumerateDevices获取设施列表,找到videoinput,即摄像头 export async function getVideoDevices() { const devices = await navigator.mediaDevices.enumerateDevices() const videoDevices = devices.filter(item => item.kind === 'videoinput') return videoDevices}获取video stream export async function getVideoStream(deviceId: string, width?: number, height?: number) { try { const stream = await navigator.mediaDevices.getUserMedia({ video: { deviceId, width, height } }) return stream } catch (error) { return Promise.reject(error) }}咱们提前搁置一个<video>元素,通过它来接管stream,后续就能够通过这个<video>来获取视频图像 ...

May 6, 2022 · 4 min · jiezi

关于tensorflow:window10tensorflow安装

1、首先windows10下我这边环境是CPU环境,先得装置anaconda 我用国内镜像源进行装置 https://mirrors.bfsu.edu.cn/a... 装置后关上anaconda prompt进行镜像源的配置,此处也能够不进行国内源配置,依据电脑状况: conda config --add channels https://mirrors.tuna.tsinghua... conda config --set show_channel_urls yes conda create -n tensorflow python=3.7.1 --依据本人Python版本也就是TensorFlow的环境筹备 activate tensorflow --激活tensorflow 2、之后装置最新的tensorflowpip3 install -i https://mirrors.aliyun.com/py... --upgrade tensorflow --default-timeout=600 也就是--upgrade tensorflow是获取最新的镜像版本,之后--default-timeout=600是怕下载时超时,此处tensorflow尽量装置最新版本的,要不然应用的时候会提醒异样 3、装置实现后,则能够在pycharm外面进行验证应用2.0版本此处tensorflow应用session须要降版本,采坑:import tensorflow as tf tf.compat.v1.disable_eager_execution() hello = tf.constant('hello,tf') sess = tf.compat.v1.Session() print(sess.run(hello)) 当打出hello时,证实运行胜利! 心愿对大家有帮忙!

January 25, 2022 · 1 min · jiezi

关于tensorflow:一次Windows10环境上搭建Tensorflow的记录

1. 搭建Python环境长话短说,间接应用Anaconda装置Python环境以及一些罕用的软件包官网比较慢,能够应用清华的开源镜像站下载适合的版本: https://mirrors.tuna.tsinghua...本文应用的是Anaconda3-2018.12-Windows-x86_64版本 装置过程不再赘述,记得把不举荐的「配置环境变量」选项选上 装置胜利后,能够查看python版本: 2. 装置NVIDIA驱动程序官网地址:https://www.nvidia.cn/geforce... 留神:搜寻适合的驱动程序之后,会默认下载DCH版本驱动,装置时可能会呈现以下问题 所以,在下载时,须要将链接中的dch去掉,下载标准版驱动 上边那个才是标准版的,不要下载成下边的DCH版本的了 3. 装置CUDACUDA (Compute Unified Device Architecture) 是一种由NVIDIA推出的用于自家GPU的并行计算架构,该架构使GPU进行能够大量并行计算,可能解决简单的计算问题。CUDA的实质上就是一个工具包(ToolKit),本文抉择的是CUDA 10版本 装置胜利后去cmd执行nvcc -V,能够看到版本号信息 4. 装置CUDNN如上所述,CUDA并不是针对于神经网络的GPU减速库,它是面向各种须要并行计算的利用而设计的。为了可能更疾速的训练神经网络,还须要额定装置cuDNN。 NVIDIACUDA®深度神经网络库 (cuDNN) 是GPU减速的用于深度神经网络的原语库。援用cuDNN为规范例程提供了高度优化的实现,例如向前和向后卷积,池化,规范化和激活层。也就是说,能够将cuDNN了解为是一个SDK,是一个专门用于神经网络的减速包,本文抉择的是cuDNN v7.6.5.32版本 解压cnDNN压缩包,将其中的cuda文件夹复制到CUDA的装置目录中,本文应用的是默认门路: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0解压实现后,须要在零碎变量的Path变量中减少其bin门路,并将该项置顶: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\cuda\bin5. 装置TensorFlow装置Anaconda时,同时装置上了Python包管理工具pip,这里就能够间接应用pip install命令装置TensorFlow了 为了减速装置,应用-i命令装置清华源的包,本文装置的是TensorFlow GPU的2.0.0版本: pip install -U tensorflow-gpu==2.0.0 -i https://pypi.tuna.tsinghua.ed...装置时可能某些包会呈现一些谬误,比方wrapt装置失败 执行命令独自装置下那些出错的包就好了,比方: pip install -U --ignore-installed wrapt 而后重新安装TensorFlow即可 6. Hello World装置好了,连忙去Hello World一下在cmd输出ipython,而后执行 import tensorflow as tf如果呈现了numpy相干的谬误,能够是因为版本不匹配导致的应用pip show numpy命令查看到以后的numpy版本是1.15.4,而后应用清华源装置最新的numpy pip install --upgrade numpy -i https://pypi.tuna.tsinghua.ed...将版本升级为1.21.4 ...

November 9, 2021 · 1 min · jiezi

关于tensorflow:Keras分词器Tokenizer的方法介绍

Keras分词器Tokenizer的办法介绍Tokenizer是一个用于向量化文本,或将文本转换为序列(即单词在字典中的下标形成的列表,从1算起)的类。Tokenizer实际上只是生成了一个字典,并且统计了词频等信息,并没有把文本转成须要的向量示意。tok = keras.preprocessing.text.Tokenizer() 生成词典tok.fit_on_textssomestr = ['ha ha gua angry','howa ha gua excited'] tok.fit_on_texts(somestr) 查看单词索引tok.word_index 将句子序列转换成token矩阵tok.texts_to_matrixtok.texts_to_matrix(somestr)#binary的向量,如果dictionary的下标为i 的那个词在这个string中呈现了,那么就给一个1,否则给0。tok.texts_to_matrix(somestr,mode='count')#float32的向量,1换成了该词在以后句子呈现的次数 tok.texts_to_matrix(somestr,mode='freq')#loat32的向量,1换成了该词在以后句子呈现的概率的词频 句子转换成单词索引序列tok.texts_to_sequencestok.texts_to_sequences(somestr) tok.document_count 分词器被训练的文档(文本或者序列)数量tok.word_counts 依照数量由大到小Order排列的token及其数量。 迷信应用Tokenizer的办法是,首先用Tokenizer的 fit_on_texts 办法学习出文本的字典,而后word_index 就是对应的单词和数字的映射关系dict,通过这个dict能够将每个string的每个词转成数字,能够用texts_to_sequences,这是咱们须要的,而后通过padding的办法补成同样长度,在用keras中自带的embedding层进行一个向量化,并输出到LSTM中。

October 13, 2021 · 1 min · jiezi

关于tensorflow:Tensorflow保存神经网络参数有妙招Saver和Restore

摘要:这篇文章将解说TensorFlow如何保留变量和神经网络参数,通过Saver保留神经网络,再通过Restore调用训练好的神经网络。本文分享自华为云社区《[[Python人工智能] 十一.Tensorflow如何保留神经网络参数 丨【百变AI秀】](https://bbs.huaweicloud.com/b...)》,作者: eastmount。 一.保留变量通过tf.Variable()定义权重和偏置变量,而后调用tf.train.Saver()存储变量,将数据保留至本地“my_net/save_net.ckpt”文件中。 # -*- coding: utf-8 -*-"""Created on Thu Jan 2 20:04:57 2020@author: xiuzhang Eastmount CSDN"""import tensorflow as tfimport numpy as np#---------------------------------------保留文件---------------------------------------W = tf.Variable([[1,2,3], [3,4,5]], dtype=tf.float32, name='weights') #2行3列的数据b = tf.Variable([[1,2,3]], dtype=tf.float32, name='biases')# 初始化init = tf.initialize_all_variables()# 定义saver 存储各种变量saver = tf.train.Saver()# 应用Session运行初始化with tf.Session() as sess: sess.run(init) # 保留 官网保留格局为ckpt save_path = saver.save(sess, "my_net/save_net.ckpt") print("Save to path:", save_path)“Save to path: my_net/save_net.ckpt”保留胜利如下图所示: 关上内容如下图所示: 接着定义标记变量train,通过Restore操作应用咱们保留好的变量。留神,在Restore时须要定义雷同的dtype和shape,不须要再定义init。最初间接通过 saver.restore(sess, “my_net/save_net.ckpt”) 提取保留的变量并输入即可。 # -*- coding: utf-8 -*-"""Created on Thu Jan 2 20:04:57 2020@author: xiuzhang Eastmount CSDN"""import tensorflow as tfimport numpy as np# 标记变量train = False#---------------------------------------保留文件---------------------------------------# Saveif train==True: # 定义变量 W = tf.Variable([[1,2,3], [3,4,5]], dtype=tf.float32, name='weights') #2行3列的数据 b = tf.Variable([[1,2,3]], dtype=tf.float32, name='biases') # 初始化 init = tf.global_variables_initializer() # 定义saver 存储各种变量 saver = tf.train.Saver() # 应用Session运行初始化 with tf.Session() as sess: sess.run(init) # 保留 官网保留格局为ckpt save_path = saver.save(sess, "my_net/save_net.ckpt") print("Save to path:", save_path)#---------------------------------------Restore变量-------------------------------------# Restoreif train==False: # 记住在Restore时定义雷同的dtype和shape # redefine the same shape and same type for your variables W = tf.Variable(np.arange(6).reshape((2,3)), dtype=tf.float32, name='weights') #空变量 b = tf.Variable(np.arange(3).reshape((1,3)), dtype=tf.float32, name='biases') #空变量 # Restore不须要定义init saver = tf.train.Saver() with tf.Session() as sess: # 提取保留的变量 saver.restore(sess, "my_net/save_net.ckpt") # 寻找雷同名字和标识的变量并存储在W和b中 print("weights", sess.run(W)) print("biases", sess.run(b))运行代码,如果报错“NotFoundError: Restoring from checkpoint failed. This is most likely due to a Variable name or other graph key that is missing from the checkpoint. Please ensure that you have not altered the graph expected based on the checkpoint. ”,则须要重置Spyder即可。 ...

September 13, 2021 · 4 min · jiezi

关于tensorflow:TensorPytorch神经网络界的Numpy

摘要:Tensor,它能够是0维、一维以及多维的数组,你能够将它看作为神经网络界的Numpy,它与Numpy类似,二者能够共享内存,且之间的转换十分不便。本文分享自华为云社区《Tensor:Pytorch神经网络界的Numpy》,作者: 择城终老 。 TensorTensor,它能够是0维、一维以及多维的数组,你能够将它看作为神经网络界的Numpy,它与Numpy类似,二者能够共享内存,且之间的转换十分不便。 但它们也不雷同,最大的区别就是Numpy会把ndarray放在CPU中进行减速运算,而由Torch产生的Tensor会放在GPU中进行减速运算。 对于Tensor,从接口划分,咱们大抵可分为2类: torch.function:如torch.sum、torch.add等。tensor.function:如tensor.view、tensor.add等。而从是否批改本身来划分,会分为如下2类: 不批改本身数据,如x.add(y),x的数据不变,返回一个新的Tensor。批改本身数据,如x.add_(y),运算后果存在x中,x被批改。简略的了解就是办法名带不带下划线的问题。 当初,咱们来实现2个数组对应地位相加,看看其成果就近如何: import torchx = torch.tensor([1, 2])y = torch.tensor([3, 4])print(x + y)print(x.add(y))print(x)print(x.add_(y))print(x)运行之后,成果如下: 上面,咱们来正式解说Tensor的应用形式。 创立Tensor与Numpy一样,创立Tensor也有很多的办法,能够本身的函数进行生成,也能够通过列表或者ndarray进行转换,同样也能够指定维度等。具体方法如下表(数组即张量): 这里须要留神Tensor有大写的办法也有小写的办法,具体成果咱们先来看看代码: import torcht1 = torch.tensor(1)t2 = torch.Tensor(1)print("值{0},类型{1}".format(t1, t1.type()))print("值{0},类型{1}".format(t2, t2.type()))运行之后,成果如下: 其余示例如下: import torchimport numpy as npt1 = torch.zeros(1, 2)print(t1)t2 = torch.arange(4)print(t2)t3 = torch.linspace(10, 5, 6)print(t3)nd = np.array([1, 2, 3, 4])t4 = torch.from_numpy(nd)print(t4)其余例子根本与下面根本差不多,这里不在赘述。 批改Tensor维度同样的与Numpy一样,Tensor一样有维度的批改函数,具体的办法如下表所示: 示例代码如下所示: import torcht1 = torch.Tensor([[1, 2]])print(t1)print(t1.size())print(t1.dim())print(t1.view(2, 1))print(t1.view(-1))print(torch.unsqueeze(t1, 0))print(t1.numel())运行之后,成果如下: 截取元素当然,咱们创立Tensor张量,是为了应用外面的数据,那么就不可避免的须要获取数据进行解决,具体截取元素的形式如表: 示例代码如下所示: import torch# 设置随机数种子,保障每次运行后果统一torch.manual_seed(100)t1 = torch.randn(2, 3)# 打印t1print(t1)# 输入第0行数据print(t1[0, :])# 输入t1大于0的数据print(torch.masked_select(t1, t1 > 0))# 输入t1大于0的数据索引print(torch.nonzero(t1))# 获取第一列第一个值,第二列第二个值,第三列第二个值为第1行的值# 获取第二列的第二个值,第二列第二个值,第三列第二个值为第2行的值index = torch.LongTensor([[0, 1, 1], [1, 1, 1]])# 取0示意以行为索引a = torch.gather(t1, 0, index)print(a)# 反操作填0z = torch.zeros(2, 3)print(z.scatter_(1, index, a))运行之后,成果如下: ...

August 9, 2021 · 1 min · jiezi

关于tensorflow:TensorFlow随笔一

In machine learning, to improve something you often need to be able to measure it. TensorBoard is a tool for providing the measurements and visualizations needed during the machine learning workflow. It enables tracking experiment metrics like loss and accuracy, visualizing the model graph, projecting embeddings to a lower dimensional space, and much more. Using the MNIST dataset as the example, normalize the data and write a function that creates a simple Keras model for classifying the images into 10 classes. ...

August 7, 2021 · 2 min · jiezi

关于tensorflow:Tensorflow-API-一

tf.config.list_physical_devicesReturn a list of physical devices visible to the host runtime. Physical devices are hardware devices present on the host machine. By default all discovered CPU and GPU devices are considered visible. This API allows querying the physical hardware resources prior to runtime initialization. Thus, giving an opportunity to call any additional configuration APIs. This is in contrast to tf.config.list_logical_devices, which triggers runtime initialization in order to list the configured devices. ...

August 7, 2021 · 2 min · jiezi

关于tensorflow:Text-classification-with-TensorFlow-Hub-Movie-reviews

This notebook classifies movie reviews as positive or negative using the text of the review. This is an example of binary—or two-class—classification, an important and widely applicable kind of machine learning problem. The tutorial demonstrates the basic application of transfer learning with TensorFlow Hub and Keras. It uses the IMDB dataset that contains the text of 50,000 movie reviews from the Internet Movie Database. These are split into 25,000 reviews for training and 25,000 reviews for testing. The training and testing sets are balanced, meaning they contain an equal number of positive and negative reviews. ...

July 31, 2021 · 5 min · jiezi

关于tensorflow:Tensorflow日常随笔一

TensorFlow is an end-to-end open source platform for machine learning TensorFlow makes it easy for beginners and experts to create machine learning models. See the sections below to get started. https://www.tensorflow.org/tu... Tutorials show you how to use TensorFlow with complete, end-to-end examples https://www.tensorflow.org/guide Guides explain the concepts and components of TensorFlow. For beginnersThe best place to start is with the user-friendly Sequential API. You can create models by plugging together building blocks. Run the “Hello World” example below, then visit the tutorials to learn more. ...

July 31, 2021 · 2 min · jiezi

关于tensorflow:Taking-advantage-of-context-features

In the featurization tutorial we incorporated multiple features beyond just user and movie identifiers into our models, but we haven't explored whether those features improve model accuracy. Many factors affect whether features beyond ids are useful in a recommender model: Importance of context: if user preferences are relatively stable across contexts and time, context features may not provide much benefit. If, however, users preferences are highly contextual, adding context will improve the model significantly. For example, day of the week may be an important feature when deciding whether to recommend a short clip or a movie: users may only have time to watch short content during the week, but can relax and enjoy a full-length movie during the weekend. Similarly, query timestamps may play an important role in modelling popularity dynamics: one movie may be highly popular around the time of its release, but decay quickly afterwards. Conversely, other movies may be evergreens that are happily watched time and time again.Data sparsity: using non-id features may be critical if data is sparse. With few observations available for a given user or item, the model may struggle with estimating a good per-user or per-item representation. To build an accurate model, other features such as item categories, descriptions, and images have to be used to help the model generalize beyond the training data. This is especially relevant in cold-start situations, where relatively little data is available on some items or users.import osimport tempfileimport numpy as npimport tensorflow as tfimport tensorflow_datasets as tfdsimport tensorflow_recommenders as tfrsWe follow the featurization tutorial and keep the user id, timestamp, and movie title features. ...

July 30, 2021 · 5 min · jiezi

关于tensorflow:Tensorflow小技巧一

how-do-i-select-rows-from-a-dataframe-based-on-column-valuesTo select rows whose column value equals a scalar, some_value, use ==: df.loc[df['column_name'] == some_value]To select rows whose column value is in an iterable, some_values, use isin: df.loc[df['column_name'].isin(some_values)]how-do-i-sort-a-dictionary-by-valuex = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}dict(sorted(x.items(), key=lambda item: item[1]))how-can-i-count-the-occurrences-of-a-list-itemfrom collections import Counterl = ["a","b","b"]Counter(l)pandas.DataFrame.drop_duplicatesdf = pd.DataFrame({... 'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'],... 'style': ['cup', 'cup', 'cup', 'pack', 'pack'],... 'rating': [4, 4, 3.5, 15, 5]... })df.drop_duplicates(subset=['brand'])tf.data.Dataset-----as_numpy_iterator()Returns an iterator which converts all elements of the dataset to numpy. ...

July 29, 2021 · 1 min · jiezi

关于tensorflow:在python-38-CUDA-11环境下安装tensorflow-115

tensorflow的以及全面更新到tf2,其官网显示老版本的tensorflow 1.15只反对python3.7以及cuda10,并且新版本的ubuntu的官网apt源基本没有python3.7。 较新版本的python3.8/cuda 11如果想要应用tf1.15,一种办法是从新编译,或者去下载其他人编译好的二进制whl。然而从新编译和找whl都比拟麻烦,老黄为了让新显卡用户用上tf1.15,和谷歌单干保护了一个tf1.15的库。另一种办法是应用docker,然而docker用起来稍麻烦。 库的地址为:https://github.com/NVIDIA/ten... 应用办法: # 举荐在虚拟环境下操作(非必要)# python3 -m virtualenv venv# source venv/bin/activatepip install --upgrade pippip install nvidia-pyindexpip install nvidia-tensorflow[horovod]pip install nvidia-tensorboard==1.15测试: import tensorflow as tfimport tensorboardtf.enable_eager_execution()a = tf.random.uniform([1000, 1000])b = tf.random.uniform([1000, 1000])tf.matmul(a, b)查看输入失常即可

July 15, 2021 · 1 min · jiezi

关于tensorflow:tf踩坑记NotFoundError

tf的estimator api应用起来十分不便,填充下几个函数,就能写出高度结构化的模型代码。但封装越高级,应用中一旦遇到问题,解决起来就会相当麻烦。 明天在日常炼丹中就遇到了这么一个问题。模型训练实现,导出saved model时,始终报一个key找不到对应的var。 NotFoundError (see above for traceback): Restoring from checkpoint failed. This is most likely due to a Variable name or other graph key that is missing from the checkpoint. Please ensure that you have not altered the graph expected based on the checkpoint. Original error:这种谬误个别是两次应用的graph不统一造成的。可能的起因个别有: 应用了不同版本的api,api会对变量加上一些不一样的前缀或后缀,不同的api可能解决的逻辑不统一。导致两次加载的graph不一样。checkpoint里没保留这个变量。这个个别不太会存在,须要train的变量必定须要保留。有些不须要train的变量才会呈现这种可能。这两种状况排查起来比较简单。能够用上面这个工具查看下checkpoint里的变量: /tensorflow/python/tools/inspect_checkpoint.py checkpoint_file_name个别会失去以下的输入: 这次我的谬误,就是找不到一个age_1/embeddings的变量。从输入看,save的变量名是age/embeddings,加载时却要找一个age_1/embeddings的变量。名字变了,看起来应该是第一种起因,save时和export时用了不同的图。然而我的代码train和export是在同一份代码,应用的是同一个model_fn,且在同一个环境下测试的,应该说是不会应用到不同的graph才对的。 排查了很久,最终还是在图不统一上解决了问题。estimator有两个输出函数,一个input_fn,一个model_fn,除了model_fn会构建模型graph之外,input_fn里的tensor也会增加到graph里去。而训练阶段和export阶段应用的input_fn是不统一的。export的模型是要给线上serving用的,所以在input_fn里定义了一堆placeholder作为输出,而placeholder里也有一个tensor的name被set为 ”age“,这就导致model_fn里的age/embeddings在build graph时,被改成了age_1/embeddings,再去checkpoint里查找这个变量的值,天然是找不到的。 这个问题一开始被tf的报错给误导了,始终在model_fn里查问题。报错的中央不肯定是有问题的中央,而tf1.13也不会报这种重名的问题。大多数时候咱们创立的tensor也不会给一个name,tf会主动命名一个name,主动命名有一套规定,有反复了就新生成一个name,这就导致不论是主动set的name还是人工定义的name,都不会报重名的谬误。一旦本人命名重名了,很可能会造成问题。

May 17, 2021 · 1 min · jiezi

关于tensorflow:深度学习之图像分类ResNet50学习

深度学习之图像分类ResNet50此次采纳迁徙学习并微调。个别的倡议是: 应用事后训练的模型进行特征提取:应用小型数据集时,通常的做法是利用在雷同域中的较大数据集上训练的模型中学习的特色。这是通过实例化预训练的模型并在顶部增加齐全连贯的分类器来实现的。事后训练的模型是“解冻的”,训练过程中仅更新分类器的权重。在这种状况下,卷积根底提取了与每个图像关联的所有特色,而您刚刚训练了一个分类器,该分类器依据给定的提取特色集确定图像类。 对预训练模型进行微调:为了进一步提高性能,可能须要通过微调将预训练模型的顶层从新用于新的数据集。在这种状况下,您须要调整权重,以使模型学习到特定于数据集的高级性能。通常在训练数据集很大并且与训练前的模型十分类似的原始数据集十分类似时,倡议应用此技术。 ResNet50实战官网示例代码用的二分类,猫狗分类。另外迁徙学习应用的是MobileNet V2 model。 所以这次的更改无非就是更改一下分类层,和引入ResNet即可了。 环境筹备可能有些没有用到! from tensorflow.keras.applications import ResNet50from tensorflow.keras import layersfrom tensorflow.keras.layers import Dense, GlobalAveragePooling2Dfrom tensorflow.keras import Modelfrom tensorflow.keras.preprocessing.image import ImageDataGeneratorfrom tensorflow.keras.applications.resnet50 import preprocess_inputfrom tensorflow.keras.preprocessing import imagefrom tensorflow.keras.callbacks import EarlyStoppingfrom tensorflow.keras.optimizers import Adamimport tensorflow as tfimport matplotlib.pyplot as pltimport PILimport numpy as np数据集应用的是官网的花朵图像的分类。官网也很无语,图像分类用的是花朵图像,到迁徙学习的时候又换成了狗和猫的分类。 import pathlibdataset_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"data_dir = tf.keras.utils.get_file('flower_photos', origin=dataset_url, untar=True)data_dir = pathlib.Path(data_dir)拆分数据集batch_size = 32img_height = 180img_width = 180train_ds = tf.keras.preprocessing.image_dataset_from_directory( data_dir, validation_split=0.2, subset="training", seed=123, image_size=(img_height, img_width), batch_size=batch_size)val_ds = tf.keras.preprocessing.image_dataset_from_directory( data_dir, validation_split=0.2, subset="validation", seed=123, image_size=(img_height, img_width), batch_size=batch_size)class_names = train_ds.class_namesprint(class_names)AUTOTUNE = tf.data.AUTOTUNEtrain_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)查看数据集plt.figure(figsize=(10, 10))for images, labels in train_ds.take(1): for i in range(9): ax = plt.subplot(3, 3, i + 1) plt.imshow(images[i].numpy().astype("uint8")) plt.title(class_names[labels[i]]) plt.axis("off")定义modeldata_augmentation = tf.keras.Sequential([ tf.keras.layers.experimental.preprocessing.RandomFlip('horizontal'), tf.keras.layers.experimental.preprocessing.RandomRotation(0.2),])for image, _ in train_ds.take(1): plt.figure(figsize=(10, 10)) first_image = image[0] for i in range(9): ax = plt.subplot(3, 3, i + 1) augmented_image = data_augmentation(tf.expand_dims(first_image, 0)) plt.imshow(augmented_image[0] / 255) plt.axis('off')base_model = ResNet50(include_top=False, weights='imagenet',input_shape=(180,180,3))base_model.trainable = Falseinputs = tf.keras.Input(shape=(180,180,3))x = data_augmentation(inputs)x = preprocess_input(x)x = base_model(x,training=False)print(base_model.output.shape)x = GlobalAveragePooling2D()(x)y = Dense(5, activation='softmax')(x) #final layer with softmax activationmodel = Model(inputs=inputs, outputs=y, name="ResNet50")model.summary()编译模型loss = tf.keras.losses.SparseCategoricalCrossentropy()metrics = tf.metrics.SparseCategoricalAccuracy()model.compile(optimizer='Adam', loss=loss, metrics=metrics)len(model.trainable_variables)训练模型history = model.fit(train_ds, epochs=10, validation_data=val_ds)基本上就能达到92的准确率。92/92 [==============================] - 19s 206ms/step - loss: 0.0186 - sparse_categorical_accuracy: 1.0000 - val_loss: 0.2470 - val_sparse_categorical_accuracy: 0.9292 ...

May 10, 2021 · 2 min · jiezi

关于tensorflow:深度学习之Bert中文分类学习

深度学习之Bert中文分类学习BERT试验预训练后果剖析tfhub_handle_preprocess = "https://hub.tensorflow.google.cn/tensorflow/bert_zh_preprocess/3"bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)text_test = ['我真是个蠢才啊!!']text_preprocessed = bert_preprocess_model(text_test)print(f'Keys : {list(text_preprocessed.keys())}')print(f'Shape : {text_preprocessed["input_word_ids"].shape}')print(f'Word Ids : {text_preprocessed["input_word_ids"][0, :12]}')print(f'Input Mask : {text_preprocessed["input_mask"][0, :12]}')print(f'Type Ids : {text_preprocessed["input_type_ids"][0, :12]}')打印后果 Keys : ['input_mask', 'input_type_ids', 'input_word_ids']Shape : (1, 128)Word Ids : [ 101 2769 4696 3221 702 1921 2798 1557 8013 8013 102 0]Input Mask : [1 1 1 1 1 1 1 1 1 1 1 0]Type Ids : [0 0 0 0 0 0 0 0 0 0 0 0]Shape中的128猜测应该是 最大长度。 ...

May 10, 2021 · 2 min · jiezi

关于tensorflow:深度学习之简单卷积神经网络Fashion-MNIST

Fashion MNIST分类Fashion MNIST数据集当初称之为深度学习的Hello World。代替了之前的手写体辨认了。 起因应该是深度学习的倒退,手写体辨认变得太简略了。 官网例子官网代码 尝试应用卷积神经网络来辨认官网卷积神经网络参考 获取Fashion MNIST数据import tensorflow as tffrom tensorflow import keras# Helper librariesimport numpy as npimport matplotlib.pyplot as pltprint(tf.__version__)fashion_mnist = tf.keras.datasets.fashion_mnist(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']train_images, test_images = train_images / 255.0, test_images / 255.0print(train_images.shape)定义卷积神经网络模型model = tf.keras.models.Sequential()model.add(tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28,1)))model.add(tf.keras.layers.MaxPooling2D((2, 2)))model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu'))model.add(tf.keras.layers.MaxPooling2D((2, 2)))model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu'))model.add(tf.keras.layers.Flatten())model.add(tf.keras.layers.Dense(64, activation='relu'))model.add(tf.keras.layers.Dense(10,activation='softmax'))# model = tf.keras.models.Sequential([# tf.keras.layers.Conv2D(32,kernel_size=(3,3),activation='relu', input_shape=(28, 28,1)),# tf.keras.layers.MaxPooling2D(),# tf.keras.layers.Conv2D(64,kernel_size=(5,5),activation='relu'),# tf.keras.layers.MaxPooling2D(),# tf.keras.layers.Flatten(),# tf.keras.layers.Dense(64,activation='relu'),# tf.keras.layers.Dense(10,activation='softmax')]# )model.summary()训练模型model.compile(optimizer='adam', loss=tf.keras.losses.sparse_categorical_crossentropy, metrics=['accuracy'])history = model.fit(train_images.reshape(-1,28,28,1), train_labels, epochs=10, validation_data=(test_images.reshape(-1,28,28,1), test_labels),batch_size=1000)训练后果能够看到同样的10次迭代训练,应用卷积神经网络训练的后果 ...

April 30, 2021 · 2 min · jiezi

关于tensorflow:深度学习之简单分类

深度学习之简略分类简略二元分类制作数据from sklearn.model_selection import train_test_splitfrom sklearn import datasetsimport matplotlib.pyplot as pltfrom tensorflow import kerasX,y = datasets.make_blobs(n_samples=1000,random_state=8,centers=2)plt.scatter(X[:,0],X[:,1],c=y)plt.show() 构建模型并训练model = keras.models.Sequential([ keras.layers.Dense(32,input_shape=X.shape[1:]), keras.layers.Dense(1,activation=keras.activations.sigmoid)])model.summary()model.compile(loss = keras.losses.binary_crossentropy,optimizer = keras.optimizers.RMSprop(learning_rate=0.1),metrics = [keras.metrics.Accuracy()])model.fit(X,y,validation_split=0.25,epochs = 20)查看测试数据和预测数据print(y[0:10])y_pre = model.predict(X[0:10])print(y_pre)[0 1 1 0 0 1 0 1 1 1][[0. 1. 1. 0. 0. 1. 0. 1. 1. 1.]]多分类制作数据from sklearn.model_selection import train_test_splitfrom sklearn import datasetsimport matplotlib.pyplot as pltfrom tensorflow import kerasX,y = datasets.make_blobs(n_samples=1000,random_state=8,centers=3)plt.scatter(X[:,0],X[:,1],c=y)plt.show() 构建模型并训练model = keras.models.Sequential([ keras.layers.Dense(32,input_shape=X.shape[1:], activation='relu'), keras.layers.Dense(3,activation=keras.activations.softmax)])model.summary()model.compile(loss = keras.losses.sparse_categorical_crossentropy, optimizer = keras.optimizers.Adam(), metrics=['accuracy'])model.fit(X,y,validation_split=0.25,epochs = 20)查看数据print(y[0:10])y_pre = model.predict(X[0:10])import numpy as npprint(np.reshape(y_pre,[10,3]))[1 2 1 1 1 2 1 2 1 1][[4.50088549e-03 9.95355964e-01 1.43211320e-04] [3.52771860e-03 2.17666663e-03 9.94295657e-01] [5.39137749e-04 9.99391794e-01 6.91057867e-05] [3.10646836e-03 9.93669093e-01 3.22450022e-03] [1.59081508e-04 9.99381661e-01 4.59307077e-04] [3.76076205e-04 2.09796475e-03 9.97525990e-01] [1.03477845e-02 9.88485038e-01 1.16714649e-03] [8.82121618e-04 1.39025709e-04 9.98978853e-01] [2.29390264e-02 9.75332916e-01 1.72808918e-03] [4.69710241e-04 9.99316335e-01 2.13949577e-04]]

April 13, 2021 · 1 min · jiezi

关于tensorflow:深度学习之回归模型简单线性模型

深度学习之回归模型-简略线性模型数据集生成from sklearn.model_selection import train_test_splitfrom sklearn import datasetsimport matplotlib.pyplot as pltfrom tensorflow import kerasX,y = datasets.make_regression(n_samples=10000,noise=0,random_state=8,n_informative=1,n_features=1)plt.scatter(X,y,c='blue')plt.show() 定义线性模型model = keras.models.Sequential([ keras.layers.Dense(1,input_shape = X_train.shape[1:])])model.summary() 训练模型model.compile(loss = keras.losses.mean_squared_error,optimizer=keras.optimizers.Adam(),metrics=['mse'])history = model.fit(X,y,epochs=1000,validation_split=0.25,callbacks=[keras.callbacks.EarlyStopping(patience=3)])画出损失历史图# 绘制训练 & 验证的损失值plt.plot(history.history['loss'])plt.plot(history.history['val_loss'])plt.title('Model loss')plt.ylabel('Loss')plt.xlabel('Epoch')plt.legend(['Train', 'Valid'], loc='upper left')plt.show() 查看模型是否拟合import numpy as npweights = model.get_weights()print(weights)print(weights[0][0,0])print(weights[1][0])w1 = weights[0][0,0]b1 = weights[1][0]m_x = np.array([-4,3])m_y = m_x * w1 + b1plt.plot(m_x,m_y,color = 'red')plt.scatter(X,y,c='blue')plt.show()

March 30, 2021 · 1 min · jiezi

关于tensorflow:Tensorflow基本概念

Tensorflow基本概念1.Tensor Tensorflow张量,是Tensorflow中最根底的概念,也是最次要的数据结构。它是一个N维数组。 2.Variable Tensorflow变量,个别用于示意图中的各计算参数,包含矩阵,向量等。它在图中有固定的地位。 3.placeholder Tensorflow占位符,用于示意输入输出数据的格局,容许传入指定的类型和形态的数据。 4.Session Tensorflow会话,在Tensorflow中是计算图的具体执行者,与图进行理论的交互。 5.Operation Tensorflow操作,是Tensorflow图中的节点,它的输出和输入都是Tensor。它的操作都是实现各种操作,包含算数操作、矩阵操作、神经网络构建操作等。 6.Queue Tensorflow队列,也是图中的一个节点,是一种有状态的节点。 7.QueueRunner 队列管理器,通常会应用多个线程来读取数据,而后应用一个线程来应用数据。应用队列管理器来治理这些读写队列的线程。 8.Coordinator 应用QueueRunner时,因为入队和出队由各自线程实现,且未进行同步通信,导致程序无奈失常完结的状况。为了实现线程之间的同步,须要应用Coordinator。 Tensorflow程序步骤(一)加载训练数据1.生成或导入样本数据集。2.归一化解决。3.划分样本数据集为训练样本集和测试样本集。(二)构建训练模型1.初始化超参数2.初始化变量和占位符3.定义模型构造4.定义损失函数(三)进行数据训练1.初始化模型2.加载数据进行训练(四)评估和预测1.评估机器学习模型2.调优超参数3.预测后果加载数据在Tensorflow中加载数据的形式一共有三种:预加载数据、填充数据和从文件读取数据。 预加载数据在Tensorflow中定义常量或变量来保留所有数据,例如: a = tf.constant([1, 2])b = tf.constant([3, 4])x = tf.add(a, b)因为常数会间接存储在数据流图数据结构中,在训练过程中,这个构造体可能会被复制屡次,从而导致内存的大量耗费。填充数据将数据填充到任意一个张量中。而后通过会话run()函数中的feed_dict参数进行获取数据: 当数据量大时,填充数据的形式也存在耗费内存的问题。 从CVS文件中读取数据要存文件中读取数据, 首先须要应用读取器将数据读取到队列中,而后从队列中获取数据进行解决: 1.创立队列2.创立读取器获取数据3.解决数据读取TFRecords数据Tensorflow针对解决数据量微小的利用场景进行了优化,定义了TFRecords格局。 采纳这种读取形式读取数据分为两个步骤: 1.把样本数据转换为TFRecords二进制文件。2.读取TFRecords格局。存储和加载模型Tensorflow中提供了tf.train.Saver类实现训练模型的保留和加载。 存储模型在模型的设计和训练的过程中,会耗费大量的工夫。为了升高训练过程中意外状况产生造成的不良影响,所以会对训练过程中模型进行定期存储。(模型复用,节俭整体训练工夫) saver = tf.train.Saver(max_to_keep, keep_checkpoint_event_n_hours)存储的模型,会生成四个文件: 加载模型为了保障意外中断的模型可能持续训练以及训练实现的模型加载在其余数据上间接应用,会对模型进行加载应用。 加载存储好的模型,包含了两个步骤: 1.加载模型: saver = tf.train.import_meta_graph("my_test_model-100.meta")2.加载训练参数: saver.restore(sess, tf.train.latest_checkpoint('./'))

March 11, 2021 · 1 min · jiezi

关于tensorflow:ssh连接服务器开放端口用于TensorBoard监测训练loss变化

连贯sever,transfer portssh -L 16006:127.0.0.1:6006 USER_NAME@server_ip2.服务器为 TensorBoard logdir启动过程 tensorboard --logdir OUTPUT_LOG_DIR3.在local machine 浏览器启动监控页面 http://127.0.0.1:16006

February 3, 2021 · 1 min · jiezi

关于tensorflow:tfaseq2seqTrainingSampler-理解总结

概述tfa.seq2seq.TrainingSampler,简略读取输出的训练采样器。调用trainingSampler.initialize(input_tensors)时,取各batch中time_step=0的数据,拼接成一个数据集,返回。下一次调用sampler.next_inputs函数时,会取各batch中time_step++的数据,拼接成一个数据集,返回。 举例说明官网例子修改版: import tensorflow_addons as tfaimport tensorflow as tfdef tfa_seq2seq_TrainingSampler_test(): batch_size = 2 max_time = 3 word_vector_len = 4 hidden_size = 5 sampler = tfa.seq2seq.TrainingSampler() cell = tf.keras.layers.LSTMCell(hidden_size) input_tensors = tf.random.uniform([batch_size, max_time, word_vector_len]) initial_finished, initial_inputs = sampler.initialize(input_tensors) cell_input = initial_inputs cell_state = cell.get_initial_state(initial_inputs) for time_step in tf.range(max_time): cell_output, cell_state = cell(cell_input, cell_state) sample_ids = sampler.sample(time_step, cell_output, cell_state) finished, cell_input, cell_state = sampler.next_inputs( time_step, cell_output, cell_state, sample_ids) if tf.reduce_all(finished): break print(time_step)if __name__ == '__main__': pass; tfa_seq2seq_TrainingSampler_test()以下面的代码为例, ...

February 1, 2021 · 1 min · jiezi

关于tensorflow:TensorFlow之安装篇

1.windws下linux环境搭建在windows10上装置linux子系统的步骤,详见https://www.linuxprobe.com/wi...。我抉择的Ubuntu子系统如下 环境阐明:Ubuntu 20.04.1 LTSpython 3.8(Ubuntu环境自带的) 2.装置pip $ curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py # 下载安装脚本$ sudo python3 get-pip.py # 运行装置脚本 留神这里我的环境变量是python3环境阐明:pip 21.0 3.装置tensorflow #形式1sudo pip3 install tensorflow#形式2 先下载,后装置#2.1 依据环境从https://pypi.org/project/tensorflow/2.4.1/#files下载相应文件#2.2 装置sudo pip3 install tensorflow-2.4.1-cp38-cp38-manylinux2010_x86_64.whl4.验证tensorflow import tensorflow as tftf.compat.v1.disable_eager_execution()sess = tf.compat.v1.Session()a = tf.constant(10)b = tf.constant(12)sess.run(a+b)5.参考文献[1] https://www.linuxprobe.com/wi...[2] https://www.cnblogs.com/phppe...[3] https://blog.csdn.net/sinat_3...[4] https://www.cnblogs.com/zlc36...

January 25, 2021 · 1 min · jiezi

关于tensorflow:ValueError-Unable-to-create-group-name-already-exists

问题形容:在tensorflow2.0.0下保留模型呈现的bug, File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/saving/hdf5_format.py", line 103, in save_model_to_hdf5 save_weights_to_hdf5_group(model_weights_group, model_layers) File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/saving/hdf5_format.py", line 619, in save_weights_to_hdf5_group g = f.create_group(layer.name) File "/usr/local/lib/python3.6/dist-packages/h5py/_hl/group.py", line 68, in create_group gid = h5g.create(self.id, name, lcpl=lcpl, gcpl=gcpl) File "h5py/_objects.pyx", line 54, in h5py._objects.with_phil.wrapper File "h5py/_objects.pyx", line 55, in h5py._objects.with_phil.wrapper File "h5py/h5g.pyx", line 161, in h5py.h5g.createValueError: Unable to create group (name already exists)解决办法参考此链接 ,批改模型后缀为.tf/后者降级tf版本为2.0.0以上。采纳批改模型后缀为.tf临时解决。

January 7, 2021 · 1 min · jiezi

关于tensorflow:ApacheCN-深度学习译文集-20201229-更新

新增了七个教程: TensorFlow 和 Keras 利用开发入门 零、前言一、神经网络和深度学习简介二、模型架构三、模型评估和优化四、产品化TensorFlow 图像深度学习实用指南 零、前言一、机器学习工具包二、图片数据三、经典神经网络Python 元学习实用指南 零、前言一、元学习导论二、应用连体网络的人脸和音频辨认三、原型网络及其变体四、应用 TensorFlow 的关系和匹配网络五、记忆加强神经网络六、MAML 及其变体七、元 SGD 和 Reptile八、作为优化指标的梯度一致性九、最新进展和后续步骤十、答案Python 强化学习实用指南 零、前言一、强化学习导论二、OpenAI 和 TensorFlow 入门三、马尔可夫决策过程与动静布局四、用于游戏的蒙特卡洛办法五、工夫差别学习六、多臂老虎机问题七、深度学习根底八、深度 Q 网络和 Atari 游戏九、用深度循环 Q 网络玩《覆灭兵士》十、异步劣势演员评论家网络十一、策略梯度和优化十二、Capstone 我的项目 – 将 DQN 用于赛车十三、最新进展和后续步骤十四、答案Python 智能我的项目 零、前言一、人工智能零碎的根底二、迁徙学习三、神经机器翻译四、应用 GAN 的时尚行业款式迁徙五、视频字幕利用六、智能举荐零碎七、电影评论情感剖析挪动利用八、用于客户服务的会话式 AI 聊天机器人九、应用强化学习的自主无人驾驶汽车十、深度学习视角的验证码精通 Sklearn 和 TensorFlow 预测性剖析 零、前言一、回归和分类的集成办法二、穿插验证和参数调整三、应用特色四、人工神经网络和 TensorFlow 简介五、将 TensorFlow 和深度神经网络用于预测剖析TensorFlow 2.0 的新增性能 零、前言第 1 局部:TensorFlow 2.0 - 架构和 API 更改 一、TensorFlow 2.0 入门二、Keras 默认集成和急迫执行第 2 局部:TensorFlow 2.0 - 数据和模型训练管道 ...

December 30, 2020 · 1 min · jiezi

关于tensorflow:在Windows下使用Anaconda安装TesnsorFlow-2x

作者 | 弗拉德起源 | 弗拉德(公众号:fulade_me) 下载 Anaconda首先关上Anaconda官网找到网页底部,因为最新的Anaconda反对Python3.8版本,而TesnorFlow最高反对到Python3.7,我特意查了一下Python3.8公布的工夫点,所以咱们须要点击页面的achrive去找历史版本下载。点击后进入到Anaconda的历史版本页面,咱们间接搜寻2020-10-15,找到Anaconda2-2019.10-Windows-x86_64.exe进行下载即可。 装置 Anaconda下载实现后,咱们间接双击安装文件开始装置即可,两头过程一路点击Next即可。 设置国内镜像源因为网络问题,我这里须要增加国内的清华镜像源,这样会不便咱们更疾速的下载资源。 装置实现后,咱们点击Windows按钮,会看到有一个有Anaconda3(64-bit)的文件夹,这就是咱们装置好Anaconda,而后咱们点击Anaconda Powershell Prompt命令行工具。 进入到命令行工具之后,输出 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/# 设置搜寻时显示通道地址conda config --set show_channel_urls yes就能够了。更多的conda应用办法,能够查看我的上一篇博客的后半局部 能够应用命令conda config --show,在channels字段这里显示曾经增加的源 开始装置TensorFlow咱们只须要在上一步中关上的命令行工具中输出 conda install tensorflow就能够了。因为咱们曾经配置了国内的镜像源,很快就能够装置实现。 测试装置实现后,咱们接着在关上的命令行工具中输出 import tensorflow as tftf.__version__看到有输入2.1.0就阐明咱们的装置是正确的。留神因为TensorFlow也在不停的降级中,这里输入的不肯定非要是2.1.0输入2.x就是争取的。

December 20, 2020 · 1 min · jiezi

关于tensorflow:细数最流行的人工智能深度学习常用框架不止有TensorFlowJava也可以进行人工智能开发

作者 | 弗拉德起源 | 弗拉德(公众号:fulade_me) 人工智能人工智能是计算机科学的一个分支,它希图理解智能的本质,并生产出一种新的能以人类智能类似的形式做出反馈的智能机器,该畛域的钻研包含机器人、语言辨认、图像识别、自然语言解决和专家系统等。人工智能从诞生以来,实践和技术日益成熟,应用领域也不断扩大,能够构想,将来人工智能带来的科技产品,将会是人类智慧的“容器”。人工智能能够对人的意识、思维的信息过程的模仿。人工智能不是人的智能,但能像人那样思考、也可能超过人的智能。那让咱们来看一下都有哪些人工智能开发的框框。 Theano早在2007加拿大的蒙特利尔大学就开始了Theano的开发,它最后是为了用于学术研究而设计的。尽管出身于学术界,然而在过来很长一段时间外面,Theano都是深度学习开发与钻研的行业标准。Theano其实是一个比拟底层的库,它比拟适宜数值计算和优化。反对主动函数梯度计算,反对Python接口,并且集成了Numpy。它并不只是专门用来做深度学习的,能够说Theano是Python的一个数值计算库。它也有毛病,就是不反对GPU和程度扩大。因为TensorFlow在谷歌的反对下强势崛起,Theano能够说是日渐式微,这外面的有个标志性的事件就是Theano创始人之一Ian Goodfellow,他放弃了Theano转去Google开发TensorFlow。 CaffeCaffe是由就读于加州大学伯克利分校的中国籍博士生贾扬清在2013年创立的,是一个老牌框架。贾扬清本科和硕士都是清华毕业,他对两个深度学习的框架都有奉献,一个是TensorFlow,他以前是在Google工作。在2016年贾扬清退出到Facebook,开始了Caffe框架的开发。Caffe的全称是"Convolution Architecture For Feature Extraction",意思是能用于特征提取的卷积架构,它的设计初衷其实是为了针对计算机视觉。毛病是灵活性有余的问题,为了做模型调整会用到C++和CUDA。在2017年4月,Facebook公布了Caffe2,这标记着Caffe有了一个很大的倒退。咱们能够把它看作是对Caffe更细粒度的重构,在实用的根底上减少了扩展性和灵活性。随着工夫的倒退,Facebook最初把Caffe2合并到了PyTorch下面了。 PyTorch说PyTorch之前,咱们得先说一说Torch。Torch是一个非主流的深度学习框架,它是基于Lua语言的。而当初支流的深度学习框架应用的语言根本都是Python,所以用Torch就会显得很非主流。然而Facebook的人工智能研究所应用的就是Torch,Torch十分实用于卷积神经网络,同时它的灵便度也很高。 有一个特点就是:它是命令式的,反对动静模型。大多数的机器学习框架都是反对动态图模型,也就是说在进行调试时,咱们须要先把模型定义好,而后再进行运行和计算。而Torch它的灵便度更高,它能够在运行的过程中更改图模型,这就叫做反对动静的图模型。在2017年初,Facebook在Torch的根底上,公布了一个全新的机器学习框架叫PyTorch。PyTorch能够说是Torch的Python版,减少了很多个性。2018年4月Facebook发表将Caffe2并入PyTorch,所以说Caffe2就以PyTorch的模式存在。 MXNetMXNet是亚马逊它反对的深度学习框架。MXNet尝试把两种模式无缝的联合起来,一种是在命令式编程上提供张量运算,一种是在申明式的编程反对符号表达式。这样用户就能够自在的混合来实现他们本人的想法。也就是说,它联合了动态定义计算图和动静定义计算图的劣势。另外MXNet反对的语言品种也比拟多,除了常见的想Python还有C++,要害的他对R语音也反对的很好,对Go也有反对。然而它的学习曲线会比拟高。 CNTKCNTK又名:Microsoft Cognitive Toolkit。在2016年的微软发表在给github上开源CNTK(computational Network ToolKit)。CNTK对语音和图像反对特地好,语音辨认和图像识别也比拟快。它还有着更为弱小的可扩展性,开发者能够应用多台计算机去实现GPU的扩大,从而可能更加灵便地应答大规模的试验。当然它也反对反对C#语言。 KerasKeras是一个高级封装的库,同样也十分的受欢迎。它能够跟Theano、CNTK、TensorFlow联合起来工作。它相当于架设在这些框架上的更高一层,因为更高一层,这使得它的应用十分的简略。Keras强调的就是极简主义,你只须要几行代码就能构建一个神经网络。同样它号称为反对疾速试验而生,可能把你的想法的迅速转换成为后果。它的语法的也比拟明细,文档的也提供的十分好。当然了,它也是反对Python的。 DL4JDJF4是一个基于JVM,聚焦行业利用,而且提供商业反对的分布式的深度学习框架。它的主旨就是:在正当的工夫里去解决各类波及大量数据的问题。从它的名字上不难看出,它其实是 Deep Learning For Java 的缩写,它对Java的反对是它最大的特点。它对应用Java作为开发语言的开发者来说十分敌对,它能够与Hadoop和Spark很好的联合起来,也能够应用任意数量的GPU或者CPU运行。 ChainerChainer的是一个专门为高效钻研和开发深度学习算法而设计的开源框架,它也是基于Python的深度学习框架。Chanier在"实时"使构件计算图,"边运行边定义"的办法使得构建深度学习网络的变得很灵便。也就是说,Chanier是反对动态图定义的。那这种办法能够让用户在每次迭代的时候能够依据条件去更改计算图,也很容易应用规范的调试器和分析器来调试和重构。 PaddlePaddlePaddlePaddle是百度旗下的深度学习开源平台,它反对并行分布式深度学习。在2016年9月1日百度世界大会上,过后百度的首席科学家吴恩达发表:百度的深度学习平台将对外开放,命名为PaddlePaddle。吴恩达认为PaddlePaddle比一个PaddleP要更容易让人记住,事实上也是,PaddlePaddle 比 Paddle更容易上口。百度的资深科学家,PaddlePaddle的研发负责人徐伟介绍:在PaddlePaddle的帮忙下,深度学习模型的设计如同编写伪代码一样容易,工程师只须要关注模型的高层构造,而无需放心任何琐碎的底层问题。 TensorFlowTensorFlowA machine learning platform for everyone to solve real problems。对每个人来解决事实问题的机器学习平台,这也是TensorFlow存在的主旨。它岂但在下层反对神经网络,它还很全面的反对别的机器学习的算法,像K-Means,决策树,向量积等等。它对语言的反对也很多,Python、C++、Java。在硬件层面,它也能够利用CPU,GPU进行计算。另外的谷歌还出了专门的处理器,叫TPU,也就是Tensor处理器,另外它也反对在挪动端应用。还提供了一个叫TensorBoard的可视化工具。这个工具十分弱小,它能够基于运行的一些日志和文件,可视化得把模型训练和后果展示进去。 TensorFlow提供了不同档次的接口,从低层到高层。越低的档次越灵便,越容易去管制,越高层次是越容易应用。TensorFlow反对的语言也十分多:Go、Python、C++、Java、Swift、R语音、C#、js等。还有运行在Web端的TensorFlow.js,咱们能够应用Javascript在网页端进行机器学习的训练和应用。在挪动端同样提供反对的是TensorFlowLite,咱们能够把在服务器端训练好的模型下发到挪动端(Android、iOS、树莓派等),在挪动端通过TensorFlowLite来应用。

December 17, 2020 · 1 min · jiezi

关于tensorflow:Tensorflow实战Google深度学习框架pdf

什么是TensorFlow? TensorFlow是谷歌2015年开源的支流深度学习框架,目前已在谷歌、优步(Uber)、京东、小米等科技公司广泛应用。 在当初人工智能火爆的状况下,想把握好深度学习,不仅须要较强的实践功底,还须要足够的实际和解析。在这其中,TensorFlow的库就十分丰盛。 最近很多小伙伴问我要一些 TensorFlow 相干的材料,于是我翻箱倒柜,找到了这本十分经典的电子书——《Tensorflow:实战Google深度学习框架》。 材料介绍 《Tensorflow:实战Google深度学习框架》是应用TensorFlow深度学习框架的入门参考书,旨在帮忙读者以最快、最无效的形式上手TensorFlow和深度学习。全书从理论利用问题登程,通过具体的TensorFlow样例程序介绍如何应用深度学习解决这些问题。该书蕴含了深度学习的入门常识和大量实践经验,是走进人工智能畛域的首选参考书。 如何获取? 1.辨认二维码并关注公众号「Java后端技术全栈」; 2.在公众号后盾回复关键字「931」。

December 17, 2020 · 1 min · jiezi

关于tensorflow:kerasAttributeError-local-object-has-no-attribute-value

明天用django+celery实现前端配置参数,后端异步用tensorflow训练模型时遇到了这个问题,我的版本是: OS:Windowskeras:2.3.1tensorflow:2.1.0目前中文网上能搜到的办法大都是通过降级tensorflow和keras解决,我在这里找到了不须要降级的办法:在报这个谬误的那行代码后面加上以下代码即可: `import keras.backend.tensorflow_backend as tb``tb._SYMBOLIC_SCOPE.value = True`

December 15, 2020 · 1 min · jiezi

关于tensorflow:尾调用尾递归-与-非尾递归

尾调用、尾递归、非尾递归的几个概念及非尾递归是否能够转换为尾递归。 1、 尾调用:tail call指的是一个函数的最初一条语句也是一个返回调用函数的语句,即return的是一个函数,这个函数能够是另一个函数,也能够是本身函数。def fun_b(x): x = x -1 return xdef function_a(x): x = x + 1 return fun_b(x) # 最返回的是函数2、尾递归:函数在return的时候调用本身,这种状况称为尾递归,除了调用本身不能有其余额定的。尾递归是递归的一种非凡模式,也是是尾调用的一种非凡模式(尾调用最初调用函数本身,就是一个尾递归)。尾调用不肯定是尾递归。尾递归特点: 在回归过程中不必做任何操作,编译器会利用这种特点主动生成优化的代码。(编译器发现在回归调用时通过笼罩以后的栈,而不是创立新的栈,应用来缩小栈空间的应用和缩小栈的调配开释开销)尾递归是把变动的参数传递给递归函数的变量了。递归产生时,外层函数把计算结果当成参数传给内存函数。尾递归的优化从函数调用的汇编实现很容易了解,只有不波及多余的参数(也就是不必额定的栈容量存,栈顶不必往下扩大再调用回函数),间接就能够扭转%edi,%esi的值,从新调用函数,也就是说不必任何额定的赞变量。def fun_b(x): if x == 1: return x else: return fun_b(x) # 最初返回调用的是本身函数,是尾递归,如果写成`return fun_b(x)+1`则不是尾递归3、非尾递归:把尾递归之外的其余递归调用归结为非尾递归4、栈调用的区别一般递归函数本身调用次数很多,递归层级很深,栈空间为0(n),尾递归优化后栈空间可为O(1)。上面有例子能够察看其栈占用的不同: # 这个是一个非尾递归def normal_sum(x): if x == 1: return x else: return x + normal_sum(x - 1)调用fun_sum(5)非尾递归的栈变动: normal_sum(5)5 + normal_sum(4)5 + (4 + normal_sum(3))5 + (4 + (3 + normal_sum(2)))5 + (4 + (3 + (2 + normal_sum(1))))5 + (4 + (3 + (2 + 1)))5 + (4 + (3 + 3))5 + (4 + 6)5 + 1015把下面的函数批改为尾递归的形式(尾递归是把变动的参数传递给递归函数的变量了): ...

October 20, 2020 · 1 min · jiezi

关于tensorflow:初探-TensorFlowjs

作者:Aral Roca翻译:疯狂的技术宅 原文:https://aralroca.com/blog/fir... 未经容许严禁转载 在本文中咱们来钻研怎么用 TensorFlow.js 创立根本的 AI 模型,并应用更简单的模型实现一些乏味的性能。我只是刚刚开始接触人工智能,只管不须要深刻的人工智能常识,但还是须要搞清楚一些概念才行。 什么是模型?真实世界是很简单的,咱们须要对其进行简化能力了解,能够用通过模型来进行简化,这种模型有很多种:比方世界地图,或者图表等。 比方要建设一个用来示意房子出租价格与屋宇面积关系的模型:首先要收集一些数据: 房间数量价格31310003125000423500042650005535000而后,把这些数据显示在二维图形上,把每个参数(价格,房间数量)都做为 1 个维度: 而后咱们能够画一条线,并预测 更多房间的房屋出租价格。这种模型被称为线性回归,它是机器学习中最简略的模型之一。不过这个模型还不够好: 只有 5 个数据,所以不够牢靠。只有 2 个参数(价格,房间),然而还有更多可能会影响价格的因素:比方地区、装修状况等。能够通过增加更多的数据来解决第一个问题,比方一百万个。对于第二个问题,能够增加更多维度。在二维图表中能够很容易了解数据并画一条线,在三维图中能够应用立体: 然而当数据的维度是三维呢四维甚至是 1000000 维的时候,大脑就没有方法在图表上对其进行可视化了,然而能够在维度超过三维时通过数学来计算超平面,而神经网络就是为了解决这个问题而生的。 什么是神经网络?要解什么是神经网络,须要晓得什么是神经元。真正的神经元看上去是这样的: 神经元由以下几局部组成: 树突:这是数据的输出端。轴突:这是输入端。突触(未在图中示意):该构造容许一个神经元与另一个神经元之间进行通信。它负责在轴突的神经末梢和左近神经元的树突之间传递电信号。这些突触是学习的要害,因为它们会依据用处增减电流动。机器学习中的神经元(简化): Inputs(输出) :输出的参数。Weights(权重) :像突触一样,用来通过调节神经元更好的建设线性回归。Linear function(线性函数) :每个神经元就像一个线性回归函数,对于线性回归模型,只须要一个神经元够了。Activation function(激活函数) :能够用一些激活函数来将输入从标量改为另一个非线性函数。常见的有 sigmoid、RELU 和 tanh。Output(输入) :利用激活函数后的计算输入。激活函数是十分有用的,神经网络的弱小次要归功于它。如果没有任何激活性能,就不可能失去智能的神经元网络。因为只管你的神经网络中有多个神经元,但神经网络的输入始终将是线性回归。所以须要一些机制来将各个线性回归变形为非线性的来解决非线性问题。通过激活函数能够将这些线性函数转换为非线性函数: 训练模型正如 2D 线性回归的例子所形容的,只须要在图中画一条线就能够预测新数据了。尽管如此,“深度学习”的思维是让咱们的神经网络学会画这条线。对于一条简略的线,能够用只有一个神经元的非常简单的神经网络即可,然而对于想要做更简单事件的模型,例如对两组数据进行分类这种操作,须要通过“训练”使网络学习怎么失去上面的内容: 这个过程并不简单,因为它是二维的。每个模型都用来形容一个世界,然而“训练”的概念在所有模型中都十分类似。第一步是绘制一条随机线,并在算法中通过迭代对其进行改良,每次迭代中过程中修改谬误。这种优化算法名为 Gradient Descent(梯度降落)(有着雷同概念的算法还有更简单的 SGD 或 ADAM 等)。每种算法(线性回归,对数回归等)都有不同的老本函数来度量误差,老本函数会始终收敛于某个点。它能够是凸函数或凹函数,然而最终要收敛在 0% 误差的点上。咱们的指标就是实现这一点。 当应用梯度降落算法时,先从其老本函数的某个随机点开始,然而咱们不晓得它到底在什么中央!这就像你被蒙着眼睛丢在一座山上,想要下山的话必须一步一步地走到最低点。如果地形是不规则的(例如凹函数),则降落会更加简单。 在这里不会深刻解释“梯度降落”算法,只须要记住这是训练 AI 模型过程中最小化预测误差的优化算法就足够了。这种算法须要大量的工夫和 GPU 进行矩阵乘法。通常在第一次执行时很难达到这个收敛点,因而须要修改一些超参数,例如学习率(learning rate)或增加正则化(regularization)。在梯度降落迭代之后,当误差靠近 0% 时,会靠近收敛点。这样就创立了模型,接下来就可能进行预测了。 ...

October 20, 2020 · 2 min · jiezi

关于tensorflow:TensorFlow-篇-TensorFlow-2x-基于-Keras-模型的本地训练与评估

「导语」模型的训练与评估是整个机器学习工作流程的外围环节。只有把握了正确的训练与评估办法,并灵便应用,能力使咱们更加疾速地进行试验剖析与验证,从而对模型有更加粗浅的了解。前言在上一篇 Keras 模型构建的文章中,咱们介绍了在 TensorFlow 2.x 版本中应用 Keras 构建模型的三种办法,那么本篇将在上一篇的根底上着重介绍应用 Keras 模型进行本地训练、评估以及预测的流程和办法。 Keras 模型有两种训练评估的形式,一种形式是应用模型内置 API ,如 model.fit() , model.evaluate() 和 model.predict() 等别离执行不同的操作;另一种形式是利用即时执行策略 (eager execution) 以及 GradientTape 对象自定义训练和评估流程。对所有 Keras 模型来说这两种形式都是依照雷同的原理来工作的,没有实质上的区别。在个别状况下,咱们更违心应用第一种训练评估形式,因为它更为简略,更易于应用,而在一些非凡的状况下,咱们可能会思考应用自定义的形式来实现训练与评估。 内置 API 进行训练评估端到端残缺示例上面介绍应用模型内置 API 实现的一个端到端的训练评估示例,能够认为要应用该模型去解决一个多分类问题。这里应用了函数式 API 来构建 Keras 模型,当然也能够应用 Sequential 形式以及子类化形式去定义模型。示例代码如下所示: import tensorflow as tffrom tensorflow import kerasfrom tensorflow.keras import layersimport numpy as np# Train and Test data from numpy array.x_train, y_train = ( np.random.random((60000, 784)), np.random.randint(10, size=(60000, 1)),)x_test, y_test = ( np.random.random((10000, 784)), np.random.randint(10, size=(10000, 1)),)# Reserve 10,000 samples for validation.x_val = x_train[-10000:]y_val = y_train[-10000:]x_train = x_train[:-10000]y_train = y_train[:-10000]# Model Createinputs = keras.Input(shape=(784, ), name='digits')x = layers.Dense(64, activation='relu', name='dense_1')(inputs)x = layers.Dense(64, activation='relu', name='dense_2')(x)outputs = layers.Dense(10, name='predictions')(x)model = keras.Model(inputs=inputs, outputs=outputs)# Model Compile.model.compile( # Optimizer optimizer=keras.optimizers.RMSprop(), # Loss function to minimize loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), # List of metrics to monitor metrics=['sparse_categorical_accuracy'],)# Model Training.print('# Fit model on training data')history = model.fit( x_train, y_train, batch_size=64, epochs=3, # We pass some validation for monitoring validation loss and metrics # at the end of each epoch validation_data=(x_val, y_val),)print('\nhistory dict:', history.history)# Model Evaluate.print('\n# Evaluate on test data')results = model.evaluate(x_test, y_test, batch_size=128)print('test loss, test acc:', results)# Generate predictions (probabilities -- the output of the last layer)# Model Predict.print('\n# Generate predictions for 3 samples')predictions = model.predict(x_test[:3])print('predictions shape:', predictions.shape)从代码中能够看到,要实现模型的训练与评估的整体流程,首先要构建好模型;而后要对模型进行编译 (compile),目标是指定模型训练过程中须要用到的优化器 (optimizer),损失函数 (losses) 以及评估指标 (metrics) ;接着开始进行模型的训练与穿插验证 (fit),此步骤须要提前指定好训练数据和验证数据,并设置好一些参数如 epochs 等能力持续,穿插验证操作会在每轮 (epoch) 训练完结后主动触发;最初是模型评估 (evaluate) 与预测 (predict),咱们会依据评估与预测后果来判断模型的好坏。这样一个残缺的模型训练与评估流程就实现了,上面来对示例里的一些实现细节进行开展解说。 ...

October 19, 2020 · 8 min · jiezi

关于tensorflow:Windows-环境搭建-TensorFlow-21-GPU-训练模型加速支持

写在后面最近筹备尝试跑一跑 TensorFlow GPU 训练模型,平时开发用的 MBP,无赖显卡是 AMD 只反对 CPU 训练,但恰有闲置 Win10 笔记本电脑一台显卡 NVIDIA 反对 CUDA® 。 Tensorflow GPU 训练减速须要反对 CUDA® 的 GPU 显卡,这里提到的 CUDA 指的是,是 NVIDIA 研发的一种并行计算平台和编程模型,它能够通过利用 GPU 的解决能力,可大幅晋升计算性能的技术,更多查看相干内容。 环境搭建过程整体比较简单,查找下载相干工具包须要捣腾一会。 1 硬件条件首先查看本人的显卡型号是否满足条件,TensorFlow 官网文档硬件要求提到了,CUDA® 架构为 3.5、3.7、5.2、6.0、6.1、7.0 或更高的 NVIDIA® GPU 卡。 1.1 查看显卡型号第一步查看本人的显卡型号,进入 NVIDIA 控制面板,点击零碎信息。 显卡型号为 GeForce GTX 850M,电脑比拟老很早前的。 1.2 查问显卡是否反对 CUDA®显卡型号为 GeForce GTX 850M,点击查看反对 CUDA® 的 GPU 卡列表,查看显卡型号是否在反对的列表外面。 计算能力为 5,显卡反对 CUDA ,接下来查看 CUDA 驱动版本,NVIDIA 控制面板,零碎信息的组件外面。 ...

October 17, 2020 · 2 min · jiezi

关于tensorflow:tensorflow20安装使用

Tensorflow是谷歌开源的人工智能库,有最欠缺的生态反对。是进行人工智能畛域开发和科研的必备工具。 本文在windows10下,借助Anaconda,装置Tensorflow2.0。 tensorflow2.0装置首先关上anaconda,执行 conda create --name tf2.0 python=3.7 建设一个名为tf2.0的虚拟环境。 细节不说了,参考我之前的文章,就是始终选yes,装置就行了。如果报HTTPSConnectionPool字样的谬误,是网速慢的起因,多试几次。 建设胜利进入tf2.0环境 conda activate tf2.0 装置tensorflow2.0 pip install tensorflow==2.0.0-beta1 下载的货色挺多,多等一会,最初胜利如下 应用命令行运行python,执行 import tensorflow as tf有正告然而没有报错,阐明装置胜利。正告是因为有些包的版本问题,能够疏忽。 执行个矩阵乘法的例子,能够正确给出后果。 jupyter notebookpython测试中有个很好用的工具jupyter notebook,有了这个工具能够在浏览器上输出代码,并查看后果,应用灵便,比应用命令行或者编辑.py代码文件不便,能够极大进步工作效率。 装置咱们还是在tf2.0环境装置, pip3 install jupyter notebook 应用装置胜利后执行jupyter notebook,和启动tomcat差不多 浏览器会主动关上网址 右侧的New抉择python3,进入 输出矩阵乘法例子,点击上方运行,如下 代码一行一行执行也能够,一起贴进来也能够,十分不便。最初能够保留所有代码,不必放心敞开浏览器代码失落。保留性能如下 保留格局有多种。 总结最根本的tensorflow环境就算建设好了,能够在浏览器运行谷歌官网的一些例子,建设模型,训练模型,定义损失函数,测试后果等都只须要一两行代码就能够搞定。 本人网上搜“tensorflow例子”,入门门槛不算高。 tensorflow2和tensorflow1差别很大,千万不要装置版本1了,间接学习2。

October 14, 2020 · 1 min · jiezi

关于tensorflow:mac下ssh连接docker的方法

1、进入docker中的linux须要装置ssh服务apt-get updateapt-get install openssh-server openssh-client2、设置docker的root登录权限为yes批改/etc/ssh/sshd_config文件,找到PermitRootLogin,参数批改为yes vim /etc/ssh/sshd_config3、批改docker的root明码应用passwd root命令批改root登录明码 passwd root4、确认docker中密匙是否存在,没有则须要创立如下是不存在密匙 root@c223a9d1c7a0:/home# ll /etc/sshtotal 560drwxr-xr-x 1 root root 4096 Oct 10 03:29 ./drwxr-xr-x 1 root root 4096 Oct 10 03:32 ../-rw-r--r-- 1 root root 553122 Feb 10 2018 moduli-rw-r--r-- 1 root root 1580 Feb 10 2018 ssh_config-rw-r--r-- 1 root root 3800 Oct 10 03:29 sshd_config生成主秘密匙(执行如下命令时能够一路回车): 生成rsa_key (-t示意生成的密钥所应用的加密类型;-f项后接要生成的密钥文件名)ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key生成ecdsa_keyssh-keygen -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key生成ed25519_key。ssh-keygen -t ed25519 -f /etc/ssh/ssh_host_ed25519_key5、退出容器exit命令退出容器 ...

October 10, 2020 · 1 min · jiezi

关于tensorflow:深度学习之物体检测

在给定图像或者视频中找出其中所有指标的地位,并返回每个指标的具体类别和地位信息。图片中可能有一个指标或几个指标,对于物体检测,目前深度学习网络的劣势很显著,也是以后的热门利用。 一生学习!

October 9, 2020 · 1 min · jiezi

关于tensorflow:安装tclsh

源码装置tclsh办法 下载源码到 http://www.tcl.tk/software/tc... 下载 tcl8.5.19-src.tar.gz 解压 tar -xzvf tcl8.5.19-src.tar.gz,比方下载放在了tmp目录 解压装置如下,装置到'usr/tcl'目录下 cd /tmptar -xzvf tcl8.5.19-src.tar.gzcd /tmp/tcl8.5.8/unix./configure --prefix=/usr/tclmakemake install创立软链接:创立快捷名字tclsh,放到usr/bin上面ln /usr/tcl/bin/tclsh8.5 /usr/bin/tclsh

October 9, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow中EncoderDecoder模型理解与实践

Seq2Seq模型次要在NLP,机器翻译,序列预测等问题上效果显著。个别状况下能够合成Seq2Seq模型为两个子模型:Encoder和Decoder。 Encoder的输出为原始的序列数据,输入为通过NN泛化的表征Tensor(惯例操作);此output便是Decoder的input。通过Encoder进行编码的raw data,再通过Decoder进行解码为另外齐全不同的output(例如:英文到中文的转换)那么在构建这样一个Seq2Seq模型须要哪几步呢? 1. 定义Encoder模型中的数据输出参数encoder_decoder_model_inputs创立并返回与模型相干的参数(tf占位符) def enc_dec_model_inputs(): inputs = tf.placeholder(tf.int32, [None, None], name='input') targets = tf.placeholder(tf.int32, [None, None], name='targets') target_sequence_length = tf.placeholder(tf.int32, [None], name='target_sequence_length') max_target_len = tf.reduce_max(target_sequence_length) return inputs, targets, target_sequence_length, max_target_leninputs占位符为了接管原始英文句子,shape==(None,None)别离示意batch size和句子长度。这里有个小trick,不同batch中句子的长度可能是不同的,所以不能设置为固定长度。通用解决办法是设置每一个batch中最长的句子长度为最大长度(必须通过Padding补齐)。targets占位符接管原始中文句子target_sequence_length占位符示意每个句子的长度,shape为None,是列张量,与批处理大小雷同。该特定值是与前面的TrainerHelper的参数,用于构建用于训练的解码器模型。max_target_len是指从所有指标句子(序列)的长度中获取最大值。target_sequence_length参数中蕴含所有句子的长度。从中获取最大值的办法是应用tf.reduce_max。2.建设Decoder模型编码模型由两个不同局部组成。第一局部是嵌入层;句子中的每个单词都将应用指定为encoding_embedding_size来泛化。这一层对文字信息压缩编码表示。第二局部是RNN层。在此实际中,在利用embedding之后,多个LSTM单元被重叠在一起。当然能够应用不同品种的RNN单元,例如GRU。 def encoding_layer(rnn_inputs, rnn_size, num_layers, keep_prob, source_vocab_size, encoding_embedding_size): """ :return: tuple (RNN output, RNN state) """ embed = tf.contrib.layers.embed_sequence(rnn_inputs, vocab_size=source_vocab_size, embed_dim=encoding_embedding_size) stacked_cells = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.DropoutWrapper(tf.contrib.rnn.LSTMCell(rnn_size), keep_prob) for _ in range(num_layers)]) outputs, state = tf.nn.dynamic_rnn(stacked_cells, embed, dtype=tf.float32) return outputs, stateembedding layer:tf.keras.layers.EmbeddingRNN layer: ...

September 22, 2020 · 3 min · jiezi

关于tensorflow:如何理解TensorFlow中name与variable-scope的区别

tf中的命名空间最近在模型的搭建中遇到tf中变量的共享空间相干问题,故记之。出于变量共享与传递的思考,TensorFlow中引入了变量(或者叫 域)命名空间的机制。此测试环境在TensorFlow1.X下:import tensorflow as tf name scope:通过调用tf.name_scope产生variable scope:通过调用tf.variable_scope产生在命名空间中创立变量有以下两种形式: tf.Variable:每次调用此函数的时候都会创立一个新的变量,如果该变量名称已存在,则会在该变量名称后增加一个后缀。tf.get_variable:以该名称创立新变量,若已存在,则检索该名称的变量并获取其援用。实例一Script: with tf.variable_scope("embeddin") as embedding_scope: testing2 = tf.Variable(tf.random_uniform((7, 10), -1.0, 1.0), name='testing2') testing3 = tf.get_variable(name='testing3', shape=[7, 10],initializer=tf.constant_initializer(1)) with tf.name_scope("optimization"): testing = tf.Variable(tf.random_uniform((7, 10), -1.0, 1.0), name='testing') testing1 = tf.get_variable(name='testing1', shape=[7, 10],initializer=tf.constant_initializer(1))Output of variable: >>> testing2<tf.Variable 'embeddin/testing2:0' shape=(7, 10) dtype=float32_ref>>>> testing3<tf.Variable 'embeddin/testing3:0' shape=(7, 10) dtype=float32_ref>>>> testing<tf.Variable 'optimization/testing:0' shape=(7, 10) dtype=float32_ref>>>> testing1<tf.Variable 'testing1:0' shape=(7, 10) dtype=float32_ref>实例一阐明在tf.name_scope中调用tf.get_variable产生的变量在调用上是不受域空间的限度的,也就是为全局变量;其余状况皆为作用域变量。 实例二Script: 1.将实例一当中的testing3改为testing2 testing3 = tf.get_variable(name='testing2', shape=[7, 10],initializer=tf.constant_initializer(1))2.将实例一当中的testing1改为testing ...

September 16, 2020 · 1 min · jiezi

关于tensorflow:tfGPUOptions相关总结

在写tf.GPUOptions之前有必要提一下tf.ConfigProto。tf.ConfigProto个别在tf建设session的时候,以config的参数传入的形式来进行session的配置。而tf.GPUOptions是作为tf.ConfigProto的参数来限度GPU资源的利用。 tf.GPUOptions应用当多人应用同一服务器,若是一个人占用了所有GPU资源,这就有点不适合了。。。以下两种办法能够正当的并行分配资源,多人应用训练互不打搅。 1.动静申请显存with tf.Graph().as_default(), tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))) as sess:#config=tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True)) for automatically applying the GPU memory# Placeholders# inside of sess......2.给GPU的显存利用率设置阈值with tf.Graph().as_default(), tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.7))) as sess:# Placeholders# inside of sess......除了以上办法还能够简略粗犷的在Python源文件运行的时候指定GPU IDCUDA_VISIBLE_DEVICES=1 python test.py

September 15, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow-卷积神经网络实用指南-iBookerApacheCN

原文:Hands-On Convolutional Neural Networks with TensorFlow协定:CC BY-NC-SA 4.0 骄傲地采纳谷歌翻译 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录TensorFlow 卷积神经网络实用指南零、前言一、TensorFlow 的设置和介绍二、深度学习和卷积神经网络三、TensorFlow 中的图像分类四、指标检测与宰割五、VGG,Inception,ResNet 和 MobileNets六、自编码器,变分自编码器和生成反抗网络七、迁徙学习八、机器学习最佳实际和故障排除九、大规模训练十、参考文献奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

September 14, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow-入门-iBookerApacheCN

原文:Getting Started with TensorFlow协定:CC BY-NC-SA 4.0 骄傲地采纳谷歌翻译 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录TensorFlow 入门零、前言一、TensorFlow 基本概念二、TensorFlow 数学运算三、机器学习入门四、神经网络简介五、深度学习六、TensorFlow GPU 编程和服务介绍TensorFlow 是一个开源软件库,用于实现机器学习和深度学习零碎。 这两个名称的前面暗藏着一系列弱小的算法,这些算法面临一个独特的挑战:使计算机学习如何自动识别简单的模式并做出最理智的决策。 机器学习算法是有监督的还是无监督的; 尽可能简化,咱们能够说最大的不同是在监督学习中,程序员批示计算机如何做某事,而在无监督学习中,计算机将本人学习所有。 相同,深度学习是机器学习钻研的一个新畛域,其目标是使机器学习更靠近人工智能指标。 这意味着深度学习算法试图像人脑一样运作。 为了在这些引人入胜的畛域进行钻研,Google 团队开发了 TensorFlow,这是本书的主题。 为了介绍 TensorFlow 的编程性能,咱们应用了 Python 编程语言。 Python 乏味且易于应用。 它是一种真正的通用语言,并且正在迅速成为任何自重程序员的必备工具。 本书的目标不是残缺地形容所有 TensorFlow 对象和办法。 取而代之的是,咱们将介绍重要的零碎概念,并疏导您尽快高效地学习。 本书的每一章都介绍了 TensorFlow 的不同方面,并附带了一些反映机器和深度学习的典型问题的编程示例。 只管 TensorFlow 既宏大又简单,但一旦您理解其根本设计和编程办法,它的设计便易于应用。 《TensorFlow 入门》的目标是帮忙您做到这一点。 享受浏览! 奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

September 11, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow-20-快速入门指南-iBookerApacheCN

原文:TensorFlow 2.0 Quick Start Guide协定:CC BY-NC-SA 4.0 骄傲地采纳谷歌翻译 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录TensorFlow 2.0 疾速入门指南零、前言第 1 局部:TensorFlow 2.00 Alpha 简介一、TensorFlow 2 简介二、Keras:TensorFlow 2 的高级 API三、TensorFlow 2 和 ANN 技术第 2 局部:TensorFlow 2.00 Alpha 中的监督和无监督学习四、TensorFlow 2 和监督机器学习五、TensorFlow 2 和无监督学习第 3 局部:TensorFlow 2.00 Alpha 的神经网络应用六、应用 TensorFlow 2 辨认图像七、TensorFlow 2 和神经格调迁徙八、TensorFlow 2 和循环神经网络九、TensorFlow 预计器和 TensorFlow HUB十、从 tf1.12 转换为 tf2介绍TensorFlow 是 Python 中最受欢迎的机器学习框架之一。 通过这本书,您将进步对 TensorFlow 最新性能的理解,并可能应用 Python 执行监督和无监督的机器学习。 顾名思义,本书旨在向读者介绍 TensorFlow 及其最新性能,包含 2.0.0 版以内的 Alpha 版本,包含急迫的执行tf.data,tf.keras,TensorFlow Hub,机器学习, 和神经网络应用。 ...

September 9, 2020 · 1 min · jiezi

关于tensorflow:面向计算机视觉的深度学习-iBookerApacheCN

原文:Deep Learning for Computer Vision协定:CC BY-NC-SA 4.0 骄傲地采纳谷歌翻译 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录面向计算机视觉的深度学习零、前言一、入门二、图像分类三、图像检索四、对象检测五、语义宰割六、相似性学习七、图像字幕八、生成模型九、视频分类十、部署奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

September 4, 2020 · 1 min · jiezi

关于tensorflow:Python-迁移学习实用指南-iBookerApacheCN

原文:Hands-On Transfer Learning with Python协定:CC BY-NC-SA 4.0 骄傲地采纳谷歌翻译 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录Python 迁徙学习实用指南零、前言一、机器学习根底二、深度学习根底三、理解深度学习架构四、迁徙学习根底五、开释迁徙学习的力量六、图像识别与分类七、文本文件分类八、音频事件辨认与分类九、DeepDream十、主动图像字幕生成器十一、图像着色奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

August 29, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow-1x-深度学习秘籍翻译完成

原文:TensorFlow 1.x Deep Learning Cookbook协定:CC BY-NC-SA 4.0 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录TensorFlow 1.x 深度学习秘籍零、前言一、TensorFlow 简介二、回归三、神经网络:感知器四、卷积神经网络五、高级卷积神经网络六、循环神经网络七、无监督学习八、自编码器九、强化学习十、挪动计算十一、生成模型和 CapsNet十二、分布式 TensorFlow 和云深度学习十三、AutoML 和学习如何学习(元学习)十四、TensorFlow 处理单元奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email:apachecn@163.com.在咱们的组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

August 16, 2020 · 1 min · jiezi

关于tensorflow:使用-TensorFlow-构建机器学习项目中文版翻译完成

原文:Building Machine Learning Projects with TensorFlow协定:CC BY-NC-SA 4.0 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录应用 TensorFlow 构建机器学习我的项目中文版一、摸索和转换数据二、聚类三、线性回归四、逻辑回归五、简略的前馈神经网络六、卷积神经网络七、循环神经网络和 LSTM八、深度神经网络九、大规模运行模型 -- GPU 和服务十、库装置和其余提醒奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

August 7, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow-深度学习中文第二版翻译完成

原文:Deep Learning with TensorFlow Second Edition协定:CC BY-NC-SA 4.0 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录TensorFlow 深度学习中文第二版一、人工神经网络二、TensorFlow v1.6 的新性能是什么?三、实现前馈神经网络四、CNN 实战五、应用 TensorFlow 实现自编码器六、RNN 和梯度隐没或爆炸问题七、TensorFlow GPU 配置八、TFLearn九、应用协同过滤的电影举荐十、OpenAI Gym奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

August 6, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow-深度学习中文第二版翻译完成

原文:Deep Learning with TensorFlow Second Edition协定:CC BY-NC-SA 4.0 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录TensorFlow 深度学习中文第二版一、人工神经网络二、TensorFlow v1.6 的新性能是什么?三、实现前馈神经网络四、CNN 实战五、应用 TensorFlow 实现自编码器六、RNN 和梯度隐没或爆炸问题七、TensorFlow GPU 配置八、TFLearn九、应用协同过滤的电影举荐十、OpenAI Gym奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

August 6, 2020 · 1 min · jiezi

关于tensorflow:精通-TensorFlow-1x翻译完成

原文:Mastering TensorFlow 1.x协定:CC BY-NC-SA 4.0 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录精通 TensorFlow 1.x一、TensorFlow 101二、TensorFlow 的高级库三、Keras 101四、应用 TensorFlow 的经典机器学习五、应用 TensorFlow 和 Keras 的神经网络和 MLP六、应用 TensorFlow 和 Keras 的 RNN七、应用 TensorFlow 和 Keras 的工夫序列数据和 RNN八、应用 TensorFlow 和 Keras 的文本数据和 RNN九、应用 TensorFlow 和 Keras 的 CNN十、应用 TensorFlow 和 Keras 的自编码器十一、TF 服务:生产中的 TensorFlow 模型十二、迁徙学习和预训练模型十三、深度强化学习十四、生成反抗网络十五、应用 TensorFlow 集群的分布式模型十六、挪动和嵌入式平台上的 TensorFlow 模型十七、R 中的 TensorFlow 和 Keras十八、调试 TensorFlow 模型十九、张量处理单元奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们资助咱们通过平台自带的打赏性能,或点击这里(https://imgconvert.csdnimg.cn...)。 ...

August 4, 2020 · 1 min · jiezi

关于tensorflow:精通-TensorFlow-1x翻译完成

原文:Mastering TensorFlow 1.x协定:CC BY-NC-SA 4.0 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录精通 TensorFlow 1.x一、TensorFlow 101二、TensorFlow 的高级库三、Keras 101四、应用 TensorFlow 的经典机器学习五、应用 TensorFlow 和 Keras 的神经网络和 MLP六、应用 TensorFlow 和 Keras 的 RNN七、应用 TensorFlow 和 Keras 的工夫序列数据和 RNN八、应用 TensorFlow 和 Keras 的文本数据和 RNN九、应用 TensorFlow 和 Keras 的 CNN十、应用 TensorFlow 和 Keras 的自编码器十一、TF 服务:生产中的 TensorFlow 模型十二、迁徙学习和预训练模型十三、深度强化学习十四、生成反抗网络十五、应用 TensorFlow 集群的分布式模型十六、挪动和嵌入式平台上的 TensorFlow 模型十七、R 中的 TensorFlow 和 Keras十八、调试 TensorFlow 模型十九、张量处理单元奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们资助咱们通过平台自带的打赏性能,或点击这里(https://imgconvert.csdnimg.cn...)。 ...

August 4, 2020 · 1 min · jiezi

关于tensorflow:TensorFlow-机器学习秘籍中文第二版翻译完成

原文:TensorFlow Machine Learning Cookbook协定:CC BY-NC-SA 4.0 不要放心本人的形象,只关怀如何实现目标。——《准则》,生存准则 2.3.c 在线浏览ApacheCN 面试求职交换群 724187166ApacheCN 学习资源目录TensorFlow 机器学习秘籍中文第二版一、TensorFlow 入门二、TensorFlow 的形式三、线性回归四、反对向量机五、最近邻办法六、神经网络七、自然语言解决八、卷积神经网络九、循环神经网络十、将 TensorFlow 投入生产十一、更多 TensorFlow奉献指南本我的项目须要校对,欢送大家提交 Pull Request。 请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)联系方式负责人飞龙: 562826179其余在咱们的 apachecn/apachecn-tf-zh github 上提 issue.发邮件到 Email: apachecn@163.com.在咱们的 组织学习交换群 中分割群主/管理员即可.资助咱们通过平台自带的打赏性能,或点击这里。

August 3, 2020 · 1 min · jiezi

关于tensorflow:PYTHON两种判断关键字key是否在字典Dict中的方法

PYTHON两种判断关键字key是否在字典中的办法 用关键字‘in’能够判断key是否在字典dict中如果以上办法生效,这个方法必定行,应用字典外部函数__contains__(要害)来判断

July 31, 2020 · 1 min · jiezi

关于tensorflow:numpy中的字典排序sorted判断整个矩阵值xall查找元素坐标npargwhere

numpy 的all()接口判断某个矩阵是否全为某个值 >>> a[1]array([[0., 0., 0.], [0., 0., 0.]])>>> >>> >>> if a[0].all()==0:... print(a[0])排序命令sorted >>> x={}>>> x['a']=99>>> x['b']=60>>> x['c']=110>>> x{'a': 99, 'b': 60, 'c': 110}>>> sorted(x.items(), key=lambda x: x[1])[('b', 60), ('a', 99), ('c', 110)]>>> 查找元素地位 np.argwhere(condition)输入满足要求的元素的坐标索引 >>> x=np.ones(3)>>> xarray([1., 1., 1.])>>> >>> np.asarray(x)array([1., 1., 1.])>>> >>> np.argwhere(x)array([[0], [1], [2]])>>> >>> x =np.arange(6).reshape(2,3)>>> >>> np.argwhere(x)array([[0, 1], [0, 2], [1, 0], [1, 1], [1, 2]])

July 31, 2020 · 1 min · jiezi

关于tensorflow:python定义一个用户可自定义成员的结构体

构造体通常用于保留 形象对象的属性信息,次要用户单纯存贮信息,而不须要function,如下举例,学生的信息能够定义这么一个构造体在承载,拜访和新增新的属性都能够间接通过点符号进行操作。 # 构造定义,继承dict来提供性能class Student(dict): def __getattr__(self, key): return self[key] def __setattr__(self, key, value): self[key] = value# 创立构造体对象Student ason()# 给对象增加本人须要是属性ason.id = 20200101ason.name = 'Ason'ason.phone = 13990238765# 拜访属性print(ason.id, ason.name)

July 21, 2020 · 1 min · jiezi

关于tensorflow:windows最简单三行命令安装tensorflowgpu版使用anaconda无需自己安装cuda

中文网上能搜到的tensorflow-gpu装置办法都十分麻烦,须要你看你的显卡,看你的显卡驱动,去nvidia官网本人下载cuda啥的,还不肯定跟你最初装置的tensorflow兼容。包含我也被这些辣鸡文章害了,节约一下午。最初发现间接用conda装置就能主动匹配装置对应的cuda等,还能随便抉择版本,十分不便。 1.装置anaconda进入官网,拉到最上面,依据你零碎是64还是32位下载安装,个别win10都是64位。装置就按默认选项就行。 2.装置tensorflow关上Anaconda prompt,而后 1.创立tensorflow虚拟环境conda create -n tensorflow python=3.7 2.激活环境conda activate tensorflow 3.装置tensorflow以下命令默认装置合乎你的驱动的最新版tensorflow:conda install tensorflow-gpu如果想装置指定版本,比方1.10.0,应用以下命令:conda install tensorflow-gpu=1.10.0如果想装置CPU版本,应用以下命令:conda install tensorflow如果在装置过程中呈现谬误,个别是网络问题,大家懂的,应用ke-xue冲浪 4.装置实现后测试首先输出python进入python交互环境,而后输出以下代码: import tensorflow as tf print(tf.__version__)print(tf.test.is_gpu_available())预期后果应该如下图,次要是最初输入True,示意应用了GPU,这样就示意装置胜利了。

July 18, 2020 · 1 min · jiezi

关于tensorflow:GTX-1660TITensorflow20-GPU版CUDA100Anaconda3PyCharm开发环境配置

申明:这篇文章局部内容借鉴了以下文章Windows 10 下 Anaconda 轻松装置 Tensorflow 2.0 GPU 版本然而这篇文章外面有谬误和不残缺,我在此基础上进行了修改和裁减。 0.事先筹备1.良好的网络以及ke-xue-shang-net工具2.在Geforce Experience中将你的显卡驱动更新到最新版本,并记住版本号3.确保你是GTX 1660TI显卡 1.装置Anaconda首先进入Anaconda官方网站下载安装包,间接拖到页面最下方而后依照默认选项装置就行 2.装置CUDA1.首先查问官网,确认你的显卡驱动反对的CUDA版本。以下是2020年7月的反对状况:你会发现你的显卡驱动版本很可能反对到CUDA11,然而留神目前(2020年7月)tensorflow最高只反对CUDA10.0,所以最好确认以后tensorflow最新版本反对的CUDA版本 2.进入NVIDIA官网下载CUDA。各种选项参考下图,而后开始下载,此处不挂梯速度更快。下载实现后依照默认选项装置,个别装置过程中会主动增加环境变量,如果前面出问题,能够看一下环境变量中是否有CUDA10.0的环境变量 3.装置cuDNN进入官网,这里须要开发者账号,如果你有nvidia开发者账号,间接登录,没有就注册一个。抉择与CUDA10.0对应的cuDNN,如下图:与CUDA10.0对应的cuDNN版本是v7.6.5,点击后间接下载for Windows10:下载结束是一个压缩包,解压缩之后,把外面所有货色复制,而后粘贴到你的cuda10.0根目录下 NVIDIA GPU Computing Toolkit\CUDA\v10.0\4.测试CUDA关上命令提示符CMD,输出nvcc -V如果装置正确,你会看到:这就代表CUDA装置胜利 5.装置Tensorflow2.01.关上Anaconda Prompt,为Tensorflow 2.0 配置一个虚拟环境conda create -n tf2 python=3.7 2.激活环境activate tf23.装置Tensorflowpip install tensorflow-gpu==2.0.0rc1 留神:此处须要ke-xue-shang-net环境,如果你呈现hash对应谬误,超时等谬误,都是网络问题,删除tf2环境从头再来,删除环境操作方法参考我的这篇文章 6.测试Tensorflow2.0依然在tf2环境下,输出python,进入python交互环境,而后顺次输出以下测试代码: import tensorflow as tf print(tf.__version__)print(tf.test.is_gpu_available())正确后果上图,最重要的是最上面呈现True import os os.system("nvidia-smi")到此为止Tensorflow的装置完结。 7.在PyCharm中应用Tensorflow GPU版关上PyCharm,关上File->Settings–>Project->Project Interpreter,增加并应用Tensorflow虚拟环境下的python解释器,如下图:而后装置keras等你须要的包,到此就完结了,能够开始写代码了。

July 17, 2020 · 1 min · jiezi

shell-脚本批量kill进程

平时做深度学习训练任务的时候,经常需要批量启动多进程同时训练,最麻烦的就是任务刚启动就发现有一些配置参数没有配置好,需要修改配置再重新起任务。于是,如果有一个批量上次指定名字的脚本就方便多了,一键就能搞定多个进程的删除。 做些了一个可以批量删除的命令,可以在linux下执行,只需要指定需要删除的任务名称即可。原理是通过ps命令通过grep关键字找到对应的进程ID,然后执行kill删除进程。 任务名怎么获取,可以用这个命令,查看 ps ux 如下例子,删除当前运行的所有python进程 ps ux | grep -E 'python' | grep -v grep |awk '{print $2}' |xargs kill -s 9只需要替换“python”关键字为你需要删除的进程关键字即可重用该命令。

July 8, 2020 · 1 min · jiezi

python函数参数中添加默认值

python语言和C++一样,支持函数定义的时候带有默认值。但是,携带默认值的参数,都需要放在函数参数的后面,否则调用的时候会报错,提示没有默认值的参数没有赋值。 python语言,利用星号(*)可以设计一个默认值位于中间位置的默认值,主要是利用python支持通过制定参数名称的特性。 例如:""" def fun(a,b,c):... print(a, b, c)... fun(1,2,3)1 2 3def fun_with_default_value(a, b=2, c = 3):... print(a, b, c)... fun_with_default_value(1)1 2 3fun_with_default_value(1, 4)1 4 3def fun_with_default_value(a, b=2, c):... print(a, b, c)... File "<stdin>", line 1SyntaxError: non-default argument follows default argument def fun_with_default_value(a, b=2, *, c):... print(a, b, c)... fun_with_default_value(1, 5)Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: fun_with_default_value() missing 1 required keyword-only argument: 'c'fun_with_default_value(1, c=5)1 2 5fun_with_default_value(1, 3, c=5)1 3 5 ...

July 6, 2020 · 1 min · jiezi

Sklearn-与-TensorFlow-机器学习实用指南第二版

零、前言一、机器学习概览二、一个完整的机器学习项目三、分类四、训练模型五、支持向量机六、决策树七、集成学习和随机森林八、降维十、使用 Keras 搭建人工神经网络十一、训练深度神经网络十二、使用 TensorFlow 自定义模型并训练十三、使用 TensorFlow 加载和预处理数据十四、使用卷积神经网络实现深度计算机视觉十五、使用 RNN 和 CNN 处理序列十六、使用 RNN 和注意力机制进行自然语言处理十七、使用自编码器和 GAN 做表征学习和生成式学习十八、强化学习十九、规模化训练和部署 TensorFlow 模型

June 28, 2020 · 1 min · jiezi

python函数参数中独立星号的作用

python函数中间有一个(*)分隔,星号后面为命名关键字参数,星号本身不是参数。命名关键字参数,在函数调用时必须带参数名字进行调用。如下例子:

June 13, 2020 · 1 min · jiezi

linux下find命令和xargs的组合使用

June 10, 2020 · 0 min · jiezi

pytorch模型剪枝学习笔记

pytorch代码仓库 pytorch在19年11月份的时候合入了这部分剪枝的代码。pytorch提供一些直接可用的api,用户只需要传入需要剪枝的module实例和需要剪枝的参数名字,系统自动帮助完成剪枝操作,看起来接口挺简单。比如 def random_structured(module, name, amount, dim) pytorch支持的几种类型的剪枝策略: 详细分析pytorch提供了一个剪枝的抽象基类‘‘class BasePruningMethod(ABC)’,所有剪枝策略都需要继承该基类,并重载部分函数就可以了一般情况下需要重载__init__和compute_mask方法,__call__, apply_mask, apply, prune和remove不需要重载,例如官方提供的RandomUnstructured剪枝方法 基类实现的6个方法: 剪枝的API接口,可以看到支持用户自定义的剪枝mask,接口为custom_from_mask API的实现,使用classmethod的方法,剪枝策略的实例化在框架内部完成,不需要用户实例化剪枝的大只过程: 根据用户选择的剪枝API生成对应的策略实例,此时会判断需要做剪枝操作的module上是否已经挂有前向回调函数,没有则生成新的,有了就在老的上面添加,并且生成PruningContainer。从这里可以看出,对于同一个module使用多个剪枝策略时,pytorch通过PruningContainer来对剪枝策略进行管理。PruningContainer本身也是继承自BasePruningMethod。同时设置前向计算的回调,便于后续训练时调用。接着根据用户输入的module和name,找到对应的参数tensor。如果是第一次剪枝,那么需要生成_orig结尾的tensor,然后删除原始的module上的tensor。如name为bias,那么生成bias_orig存起来,然后删除module.bias属性。获取defaultmask,然后调用method.computemask生成当前策略的mask值。生成的mask会被存在特定的缓存module.register_buffer(name + "_mask", mask)。这里的compute_mask可能是两种情况:如果只有一个策略,那么调用的时候对应剪枝策略的compute_mask方法,如果一个module有多个剪枝策略组合,那么调用的应该是PruningContainer的compute_mask![file](/img/bVbHRbW)4. 执行剪枝,保存剪枝结果到module的属性,注册训练时的剪枝回调函数,剪枝完成。新的mask应用在orig的tensor上面生成新的tensor保存的对应的name属性![file](/img/bVbHRbX)remove接口pytorch还提供各类一个remove接口,目的是把之前的剪枝结果持久化,具体操作就是删除之前生成的跟剪枝相关的缓存或者是回调hook接口,设置被剪枝的name参数(如bias)为最后一次训练的值。 自己写一个剪枝策略接口也是可以的: 先写一个剪枝策略类继承BasePruningMethod然后重载基类的compute_mask方法,写自己的计算mask方法官方完整教程在这里

June 1, 2020 · 1 min · jiezi

哈工大版Dynamic-ReLU自适应参数化ReLU调参记录20Cifar109417

自适应参数化ReLU是一种动态激活函数,对所有输入不是“一视同仁”,在2019年5月3日投稿至IEEE Transactions on Industrial Electronics,2020年1月24日录用,2020年2月13日在IEEE官网公布。在之前的调参记录18中,是将深度残差网络ResNet中的所有ReLU都替换成了自适应参数化ReLU(Adaptively Parametric ReLU,APReLU)。 由于APReLU的输入特征图与输出特征图的尺寸是完全一致的,所以APReLU可以被嵌入到神经网络的任意部分。 本文将APReLU放在每个残差模块的第二个卷积层之后。这种结构与Squeeze-and-Excitation Network是非常相似的,其区别在于APReLU额外地包含了非线性变换。 同时,迭代次数也从5000个epoch减少到了500个epoch。时间耗不起。 APReLU激活函数的原理如下图所示: 整体代码如下: #!/usr/bin/env python3# -*- coding: utf-8 -*-"""Created on Tue Apr 14 04:17:45 2020Implemented using TensorFlow 1.0.1 and Keras 2.2.1Minghang Zhao, Shisheng Zhong, Xuyun Fu, Baoping Tang, Shaojiang Dong, Michael Pecht,Deep Residual Networks with Adaptively Parametric Rectifier Linear Units for Fault Diagnosis, IEEE Transactions on Industrial Electronics, 2020, DOI: 10.1109/TIE.2020.2972458,Date of Publication: 13 February 2020@author: Minghang Zhao"""from __future__ import print_functionimport kerasimport numpy as npfrom keras.datasets import cifar10from keras.layers import Dense, Conv2D, BatchNormalization, Activation, Minimumfrom keras.layers import AveragePooling2D, Input, GlobalAveragePooling2D, Concatenate, Reshapefrom keras.regularizers import l2from keras import backend as Kfrom keras.models import Modelfrom keras import optimizersfrom keras.preprocessing.image import ImageDataGeneratorfrom keras.callbacks import LearningRateSchedulerK.set_learning_phase(1)# The data, split between train and test sets(x_train, y_train), (x_test, y_test) = cifar10.load_data()x_train = x_train.astype('float32') / 255.x_test = x_test.astype('float32') / 255.x_test = x_test-np.mean(x_train)x_train = x_train-np.mean(x_train)print('x_train shape:', x_train.shape)print(x_train.shape[0], 'train samples')print(x_test.shape[0], 'test samples')# convert class vectors to binary class matricesy_train = keras.utils.to_categorical(y_train, 10)y_test = keras.utils.to_categorical(y_test, 10)# Schedule the learning rate, multiply 0.1 every 150 epochesdef scheduler(epoch): if epoch % 150 == 0 and epoch != 0: lr = K.get_value(model.optimizer.lr) K.set_value(model.optimizer.lr, lr * 0.1) print("lr changed to {}".format(lr * 0.1)) return K.get_value(model.optimizer.lr)# An adaptively parametric rectifier linear unit (APReLU)def aprelu(inputs): # get the number of channels channels = inputs.get_shape().as_list()[-1] # get a zero feature map zeros_input = keras.layers.subtract([inputs, inputs]) # get a feature map with only positive features pos_input = Activation('relu')(inputs) # get a feature map with only negative features neg_input = Minimum()([inputs,zeros_input]) # define a network to obtain the scaling coefficients scales_p = GlobalAveragePooling2D()(pos_input) scales_n = GlobalAveragePooling2D()(neg_input) scales = Concatenate()([scales_n, scales_p]) scales = Dense(channels//16, activation='linear', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(scales) scales = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(scales) scales = Activation('relu')(scales) scales = Dense(channels, activation='linear', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(scales) scales = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(scales) scales = Activation('sigmoid')(scales) scales = Reshape((1,1,channels))(scales) # apply a paramtetric relu neg_part = keras.layers.multiply([scales, neg_input]) return keras.layers.add([pos_input, neg_part])# Residual Blockdef residual_block(incoming, nb_blocks, out_channels, downsample=False, downsample_strides=2): residual = incoming in_channels = incoming.get_shape().as_list()[-1] for i in range(nb_blocks): identity = residual if not downsample: downsample_strides = 1 residual = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(residual) residual = Activation('relu')(residual) residual = Conv2D(out_channels, 3, strides=(downsample_strides, downsample_strides), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(residual) residual = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(residual) residual = Activation('relu')(residual) residual = Conv2D(out_channels, 3, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(residual) residual = aprelu(residual) # Downsampling if downsample_strides > 1: identity = AveragePooling2D(pool_size=(1,1), strides=(2,2))(identity) # Zero_padding to match channels if in_channels != out_channels: zeros_identity = keras.layers.subtract([identity, identity]) identity = keras.layers.concatenate([identity, zeros_identity]) in_channels = out_channels residual = keras.layers.add([residual, identity]) return residual# define and train a modelinputs = Input(shape=(32, 32, 3))net = Conv2D(16, 3, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(inputs)net = residual_block(net, 9, 32, downsample=False)net = residual_block(net, 1, 32, downsample=True)net = residual_block(net, 8, 32, downsample=False)net = residual_block(net, 1, 64, downsample=True)net = residual_block(net, 8, 64, downsample=False)net = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(net)net = Activation('relu')(net)net = GlobalAveragePooling2D()(net)outputs = Dense(10, activation='softmax', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(net)model = Model(inputs=inputs, outputs=outputs)sgd = optimizers.SGD(lr=0.1, decay=0., momentum=0.9, nesterov=True)model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])# data augmentationdatagen = ImageDataGenerator( # randomly rotate images in the range (deg 0 to 180) rotation_range=30, # Range for random zoom zoom_range = 0.2, # shear angle in counter-clockwise direction in degrees shear_range = 30, # randomly flip images horizontal_flip=True, # randomly shift images horizontally width_shift_range=0.125, # randomly shift images vertically height_shift_range=0.125)reduce_lr = LearningRateScheduler(scheduler)# fit the model on the batches generated by datagen.flow().model.fit_generator(datagen.flow(x_train, y_train, batch_size=100), validation_data=(x_test, y_test), epochs=500, verbose=1, callbacks=[reduce_lr], workers=4)# get resultsK.set_learning_phase(0)DRSN_train_score = model.evaluate(x_train, y_train, batch_size=100, verbose=0)print('Train loss:', DRSN_train_score[0])print('Train accuracy:', DRSN_train_score[1])DRSN_test_score = model.evaluate(x_test, y_test, batch_size=100, verbose=0)print('Test loss:', DRSN_test_score[0])print('Test accuracy:', DRSN_test_score[1])实验结果如下: ...

May 25, 2020 · 36 min · jiezi

基于函数计算的-Serverless-AI-推理

前言概述本文介绍了使用函数计算部署深度学习 AI 推理的最佳实践, 其中包括使用 FUN 工具一键部署安装第三方依赖、一键部署、本地调试以及压测评估, 全方位展现函数计算的开发敏捷特性、自动弹性伸缩能力、免运维和完善的监控设施。 1.1 DEMO 概述 通过上传一个猫或者狗的照片, 识别出这个照片里面的动物是猫还是狗 DEMO 示例效果入口: http://sz.mofangdegisn.cnDEMO 示例工程地址: https://github.com/awesome-fc/cat-dog-classify1.2 解决方案 如上图所示, 当多个用户通过对外提供的 url 访问推理服务时候,每秒的请求几百上千都没有关系, 函数计算平台会自动伸缩, 提供足够的执行实例来响应用户的请求, 同时函数计算提供了完善的监控设施来监控您的函数运行情况。 1.3. Serverless 方案与传统自建服务方案对比1.3.1 卓越的工程效率 自建服务函数计算 Serverless基础设施需要用户采购和管理无开发效率除了必要的业务逻辑开发,需要自己建立相同线上运行环境, 包括相关软件的安装、服务配置、安全更新等一系列问题只需要专注业务逻辑的开发, 配合 FUN 工具一键资源编排和部署学习上手成本可能使用 K8S 或弹性伸缩( ESS ),需要了解更多的产品、名词和参数的意义会编写对应的语言的函数代码即可1.3.2 弹性伸缩免运维 自建服务函数计算 Serverless弹性高可用需要自建负载均衡 (SLB),弹性伸缩,扩容缩容速度较 FC 慢FC系统固有毫秒级别弹性伸缩,快速实现底层扩容以应对峰值压力,免运维监控报警查询ECS 级别的 metrics提供更细粒度的函数执行情况,每次访问函数执行的 latency 和日志等, 更加完善的报警监控机制1.3.3 更低的成本 函数计算 (FC) 固有自动伸缩和负载均衡功能,用户不需要购买负载均衡 (SLB) 和弹性伸缩。具有明显波峰波谷的用户访问场景(比如只有部分时间段有请求,其他时间甚至没有请求),选择按需付费,只需为实际使用的计算资源付费。对于明显波峰波谷或者稀疏调用具有低成本优势, 同时还保持了弹性能力,以后业务规模做大以后并没有技术切换成本,同时财务成本增长配合预付费也能保持平滑。部分请求持续平稳的场景下,可以配合预付费解决按需付费较高单价问题。函数计算成本优化最佳实践文档。假设有一个在线计算服务,由于是CPU 密集型计算, 因此在这里我们将平均 CPU 利用率作为核心参考指标对成本,以一个月为周期,10台 C5 ECS 的总计算力为例,总的计算量约为 30% 场景下, 各解决方案 CPU 资源利用率使用情况示意图大致如下: ...

October 16, 2019 · 3 min · jiezi

经验拾忆纯手工-TF20的LSTM与GRUreturnsequences与returnstate参数源码

前言温馨提示:本文只适用于: 了解LSTM 和 GRU的结构,但是不懂Tensorflow20中LSTM和GRU的参数的人)额外说明看源码不等于高大上。当你各种博客翻烂,发现内容不是互相引用,就是相互"借鉴"。。。且绝望时。你可能会翻翻文档,其实有些文档写的并不是很详细。这时,看源码是你最好的理解方式。(LSTM 和 GRU 部分源码还是比较好看的) 标题写不下了: TF20 ==> Tensorflow2.0(Stable)tk ===> tensorflow.kerasLSTM 和 GRU 已经放在 tk.layers模块中。 return_sequences = Truereturn_state = True这两个参数是使用率最高的两个了, 并且LSTM 和 GRU 中都有。那它们究竟是什么意思呢???来,开始吧!进入源码方式: import tensorflow.keras as tk tk.layers.GRU() tk.layers.LSTM() 用pycharm ctrl+左键 点进源码即可~~~LSTM源码我截取了部分主干源码: ...... states = [new_h, new_c] # 很显然,第一个是横向状态h, 另一个是记忆细胞cif self.return_sequences: # 如果return_sequences设为True output = outputs # 则输出值为所有LSTM单元的 输出y,注意还没returnelse: # 如果return_sequences设为False output = last_output # 则只输出LSTM最后一个单元的信息, 注意还没returnif self.return_state: # 如果return_state设为False return [output] + list(states) # 则最终返回 上面的output + [new_h, new_c]else: # 如果return_state设为False return output # 则最终返回 只返回上面的output小技巧: 瞄准 return 关键词。 你就会非常清晰,它会返回什么了。 GRU源码......######## 我们主要看这一部分 ######################################### last_output, outputs, runtime, states = self._defun_gru_call( inputs, initial_state, training, mask)##################################################################### ......######### 下面不用看了, 这下面代码和 LSTM是一模一样的 ###################if self.return_sequences: output = outputselse: output = last_outputif self.return_state: return [output] + list(states)else: return output现在我们的寻找关键点只在于, states 是怎么得到的???你继续点进去 "self._defun_gru_call" 这个函数的源码, 你会发现 states 就直接暴露在里面 ...

October 7, 2019 · 2 min · jiezi

经验拾忆纯手工-DeepLearningMetricsNg

前言看Andrew Ng视频,总结的学习心得。虽然本篇文章可能不是那么细致入微,甚至可能有了解偏差。但是,我喜欢用更直白的方式去理解知识。 数据划分传统机器学习数据的划分传统机器学习一般都是小规模数据(几万条) 那么可以 训练集:验证集:测试集 = 6:2:2若是大规模深度学习一般都是大规模数据(几百万条) 训练集: 验证机:测试集 = 9:0.5:0.5划分 验证集 可以过早的为我们预测 指标和精度 偏差 与 方差高偏差: 训练集和测试集 loss 都比较高 (比人预测的loss高很多) (欠拟合)高方差: 训练集Loss低, 测试集 Loss高。 所以训练集和测试集 loss相差太大, 也成为(过拟合) 防止过拟合的几种方法损失函数 (惩罚项系数) 正则化(regularization)可分两种 (L1正则化惩罚 和 L2正则化惩罚)下面只以 L2为例,L2用的也是比较多的)正则化系数公式: loss = ...new_loss = loss + (/2m) * w^2w = w - learning_rate * 梯度上面公式的单调变换解释: 求梯度的时候 越大, new_loss越大, 求得的梯度越大(正比)w 减去的值就越大。 w变得就越小。w 越小, 一定程度上特征就衰减了许多。 就有效的放置了过拟合哦对应API(有两种方式): L1 = keras.regularizers.l2(0.01) # TF2 当作 keras 的 Layers定义来使用L1 = tf.nn.l2_loss(w_b) # 看到里面传递 w和b了吧, 这种是偏手动方式实现的API如果你想使用手撕实现,下面有个例子(伪代码): ...

October 3, 2019 · 4 min · jiezi

经验拾忆纯手工-Tensorflow20stable高光时刻

前言就在今天凌晨,TF20标准版,降临,可喜可贺。因此,我认为,值得记录。。。 Github URLhttps://github.com/tensorflow... "goldiegadde released this 19 hours ago" ~~ yeah 参考Beta环境我之前写过一篇2.0-GPU Beta环境, 你若连Tensorflow都每装过,那么移步:传送门:https://segmentfault.com/a/11... 更新至TF20-GPU命令pip install -U tensorflow-gpu -i https://pypi.douban.com/simple查看版本>>> import tensorflow as tf # 运行后,会输出一段关于CUDA的 INFO>>> tf.__version__'2.0.0'

October 1, 2019 · 1 min · jiezi

TensorFlow20正式Release

喜大普奔,在祖国70岁生日的这一天,TensorFlow2.0正式Release,本文主要介绍一下TensorFlow2.0的新特性。TensorFlow 1.15 官方已经宣布该版本是1.X的最后一个版本了。 主要特点和改进TensorFlow 2.0专注于简单性和易用性,具有以下更新: 使用Keras轻松构建模型,渴望执行模式在任何平台上进行生产中的稳健模型部署强大的研究实验通过减少重复并删除已经标记不再使用的端点来简化API有关2.0最佳实践的详细信息,参照the Effective 2.0 guide 这里我强调一下渴望执行模式。TensorFlow 2.0 主推的 eager execution mode 采用和解释执行图完全不同的深度学习计算方式。 类似 PyTorch 的做法,前向计算过程把对基本计算单元(operator)的调用记 录在一个内存数据结构 tape 里,随后,反向计算过程(计算 gradients 的) 可以回溯这个 tape,以此调用 operator 对应的 gradient operator。这个 tape 提供一个操作让用户可以获取每个参数的 gradient。 HighlightsTF 2.0提供Keras作为用于构建和训练模型的中央高级API。 Keras提供了一些模型构建API,例如顺序,功能和子类化以及急切的执行(用于立即迭代和直观调试)以及tf.data(用于构建可扩展的输入管道)。分发策略:TF 2.0用户将能够使用tf.distribute.Strategy API通过最少的代码更改来分发培训,从而获得出色的现成性能。它支持Keras model.fit以及自定义训练循环的分布式训练。提供多GPU支持,以及对多工作人员和Cloud TPU的实验性支持功能,而不是会话。不鼓励使用传统的声明式编程模型来构建图形并通过tf.Session执行它,并通过编写常规的Python函数来代替。使用tf.function装饰器,这些函数可以转换为图形,可以远程执行,序列化并针对性能进行优化。tf.train.Optimizers和tf.keras.Optimizers的统一。对TF2.0使用tf.keras.Optimizers。作为公共API删除了compute_gradients,使用GradientTape计算梯度。AutoGraph将Python控制流转换为TensorFlow表达式,允许用户在装饰有tf.function的函数中编写常规Python。 AutoGraph也适用于与tf.data,tf.distribute和tf.keras API一起使用的函数。交换格式与SavedModel的统一。所有TensorFlow生态系统项目(TensorFlow Lite,TensorFlow JS,TensorFlow Serving,TensorFlow Hub)都接受SavedModels。模型状态应保存到SavedModels或从SavedModels恢复。API更改:许多API符号已重命名或删除,参数名称也已更改。这些变化中的许多变化都是出于一致性和清晰性。 1.x API在compat.v1模块中仍然可用。添加环境变量TF_CUDNN_DETERMINISTIC。设置为TRUE或“ 1”将强制选择确定性cuDNN卷积和最大池算法。启用此功能后,算法选择过程本身也是确定性的。TensorFlow 2.0与kubernetes这两个在各自领域最火的框架,结合的工作其实业界已经有很多尝试了,包括谷歌的kubeflow。Distributed TensorFlow虽然提供了分布式能力,可以利用服务器集群加快训练,但是还有许多缺点: 训练时TensorFlow各个Task资源无法隔离,很有可能会导致任务间因资源抢占互相影响。缺乏调度能力,需要用户手动配置和管理任务的计算资源。集群规模大时,训练任务的管理很麻烦,要跟踪和管理每个任务的状态,需要在上层做大量开发。用户要查看各个Task的训练日志需要找出对应的服务器,并ssh过去,非常不方便。TensorFlow原生支持的后端文件系统只支持:标准Posix文件系统(比如NFS)、HDFS、GCS、memory-mapped-file。大多数企业中数据都是存在大数据平台,因此以HDFS为主。然而,HDFS的Read性能并不是很好。而这些正是Kubernetes所擅长的地方。当你试着去创建一个大规模TensorFlow集群时,发现并不轻松; 尤其是蚂蚁金服开源的ElasticDL,该项目是基于TensorFlow 2.0的Kubernetes-native 弹性分布式深度学习系统。

October 1, 2019 · 1 min · jiezi

滴滴开源DELTAAI开发者可轻松训练自然语言模型

8月2日消息,自然语言处理领域顶级会议ACL2019在意大利弗洛伦萨继续召开。会上滴滴正式宣布开源基于深度学习的语音和自然语言理解模型训练平台DELTA,以进一步帮助AI开发者创建、部署自然语言处理和语音模型,构建高效的解决方案,助力NLP应用更好落地。 DELTA是滴滴第22个开源项目。自然语言处理模型和语音模型是很多AI系统与用户交互的接口,此次滴滴正式这一开源深度学习模型训练框架,旨在进一步降低开发者创建、部署自然语言处理系统和语音模型的难度。 滴滴自然语言处理首席科学家Kevin Knight在ACL2019现场 DELTA主要基于TensorFlow构建,能同时支持NLP(自然语言处理)和语音任务及数值型特征的训练。整合了包括文本分类、命名实体识别、自然语言推理、问答、序列到序列文本生成、语音识别、说话人验证、语音情感识别等重要算法模型,形成一致的代码组织架构,整体包装统一接口。 用户准备好模型训练数据,并指定好配置Configuration,模型训练pipeline可以根据配置进行数据处理,并选择相应的任务和模型,进行模型训练。在训练结束之后,自动生成模型文件保存。该模型文件形成统一接口,可以直接上线使用,快速产品化,能让从研究到生产变得更容易。 值得注意的是,除可支持多种模型的训练,DELTA还支持灵活配置,开发者可基于DELTA搭建成多达几十种的复杂的模型;此外,DELTA在多种常用任务上提供了稳定高效的benchmark,用户可以简单快速的复现论文中的模型的结果,同时也可以在此基础上扩展新的模型。在模型构建完成后,用户可以使用DELTA的部署流程工具,迅速完成模型上线。从论文到产品部署无缝衔接。 目前AI开发者可登陆Github(https://github.com/didi/delta...,利用DELTA加快实验进度,部署用于文本分类、命名实体识别、自然语言推理、问答、序列到序列文本生成、语音识别、说话人验证、语音情感识别等任务的系统。用户亦可在滴滴的开源平台上(https://didi.github.io/)获取更多滴滴开源项目的相关信息。 实际上,NLP和语音技术在滴滴已经有广泛的应用。通过大量应用了包括自然语言处理、深度学习、知识图谱、语音、推荐等技术,滴滴自建了基于AI的智能客服系统,能利用人工智能技术辅助人工客服,提高人工客服处理问题的效率,并减少人工客服在重复、简单问题上的处理量。此外,基于语音识别以及自然语言理解技术,滴滴也在构建驾驶员语音助手,日本和澳洲的滴滴司机即将能用语音直接“免接触”接单。而在未来,这一语音助手也将支持全方位的语音交互服务,包括影音娱乐、信息查询、车内环境调节,到乘客通信、客服,甚至是加油、充电或维保服务。与此同时,滴滴也在积极推进相关能力的开放,通过提供一站式自然语言处理工具、一站式机器人开放平台,帮助行业合作伙伴更好地实现AI应用落地。

August 7, 2019 · 1 min · jiezi

第2话-TensorFlow-数据流图

1.1 什么是数据流图TensorFlow使用符号计算图,这与Theano相似,不过与Theano相比,TensorFlow 更简洁。TensorFlow 的名字本身描述了它自身的执行原理: Tensor (张量)意味着N维数组,Flow (流)意味着基于数据流图的计算。数据流图中的图就是我们所说的有向图,在图这种数据结构中包含两种基本元素:节点和边。这两种元素在数据流图中有自己各自的作用,其中节点代表对数据所做的运算或某种算子(Operation)。另外,任何一种运算都有输人/输出,因此它也可以表示数据输人的起点或输出的终点。而边表示节点与节点之间的输人1输出关系,一种特殊类型的数据沿着这些边传递。这种特殊类型的数据在TensorFlow中被称为Tensor,即张量,所谓的张量通俗点说就是多维数组。 当我们向这种图中输人张量后,节点代表的操作就会被分配到计算设备完成计算,下面就是一个简单的数据流图。 1.2 TensorFlow实现数据流图1.3 可视化数据流图

July 13, 2019 · 1 min · jiezi

TensorFlow学习笔记第三章TensorFlow入门

(基于tensorflow 1.14 c'pu版本,读者需要具有良好的python基础和线性代数知识) 第三章分别介绍TensorFlow的计算模型、数据模型和运行模型,以对TensorFlow的工作原理有一个大致的了解。 3.1 计算图————TensorFlow的计算模型计算图的概念TensorFlow这个单词由两部分组成:tensor代表张量,是数据结构;flow代表流,是计算模型。流动的事务具有有向性,计算图就是一个具有‘每一个节点都是计算图上的一个节点,而节点之间的边描述了计算之间的依赖关系’性质的有向图。 计算图的使用TensorFlow程序一般分为两个阶段。第一阶段:定义计算图中所有的计算,然后定义一个计算来得到他们的和;第二阶段:执行计算。 在TensorFlow程序中,系统会自动维护一个默认的计算图,通过tf.get_default_graph()函数可以获取这个默认的计算图 import tensorflow as tfa = tf.constant([1.0, 2.0], name='a')b = tf.constant([1.0, 2.0], name='b')result = a + b#通过a.graph属性可以查看这个张量所属的计算图。因为没有特意指定,所以这个计算图应该等于当前默认的计算图print(a.graph is tf.get_default_graph())'''输出>>>True'''除了使用默认的计算图,TensorFlow支持通过tf.Graph函数来生成新的计算图。不同计算图上的张量和运算不会共享。以下代码示意了如何通过在不同的计算图上定义和使用变量。 import tensorflow as tfg1 = tf.Graph()with g1.as_default(): v = tf.get_variable('v', shape=[1], initializer=tf.zeros_initializer)g2 = tf.Graph()with g2.as_default(): v = tf.get_variable('v', shape=[1], initializer=tf.ones_initializer)'''tf.Graph()没有实现__enter__()方法,做不到下面那优雅pythonic的写法。with tf.Graph() as g2: v = tf.get_variable('v', shape=[1], initializer=tf.ones_initializer) Traceback (most recent call last): File "D:/bb/TensorFlow/Untitled1.py", line 7, in <module> with tf.Graph() as g2:AttributeError: __enter__'''with tf.Session(graph=g1) as sess: tf.global_variables_initializer().run() with tf.variable_scope("", reuse=True): print(sess.run(tf.get_variable('v')))with tf.Session(graph=g2) as sess: tf.global_variables_initializer().run() with tf.variable_scope("", reuse=True): print(sess.run(tf.get_variable('v')))'''输出>>>[0.][1.]注:先不要管代码是什么含义,继续往下看'''TensorFlow中的计算图不仅可以隔绝张量和计算,它还提供了管理张量和计算的机制 ...

July 10, 2019 · 1 min · jiezi

tensorboard-error-unrecognized-arguments-logdirlogs

D:\Python\测试专用文件夹\logs>tensorboard -logdir=logsusage: tensorboard [-h] [--helpfull] [--logdir PATH] [--host ADDR] [--port PORT] [--purge_orphaned_data BOOL] [--reload_interval SECONDS] [--db URI] [--db_import] [--db_import_use_op] [--inspect] [--version_tb] [--tag TAG] [--event_file PATH] [--path_prefix PATH] [--window_title TEXT] [--max_reload_threads COUNT] [--reload_task TYPE] [--samples_per_plugin SAMPLES_PER_PLUGIN] [--debugger_data_server_grpc_port PORT] [--debugger_port PORT] [--master_tpu_unsecure_channel ADDR]tensorboard: error: unrecognized arguments: -logdir=logstensorboard -logdir=logs 深度学习7:TensorBoard使用方法 在上面这篇文章中提到了这种调度tensorboard的方法。 但是报了tensorboard: error: unrecognized arguments: -logdir=logs错误。 提示中有 [--logdir PATH],估计文章中用的是旧版本的方法(我现在用的是1.14,估计原作者用的是0.xx版本的) 改成 D:\Python\测试专用文件夹>tensorboard --logdir logsTensorBoard 1.14.0 at http://LAPTOP-BBMBSKKI:6006/ (Press CTRL+C to quit)就能成功运行了 ...

July 8, 2019 · 1 min · jiezi

Tensorflow-Rust实战下篇整合actixweb提供http服务

上一篇我写的文章how to use tensorflow with rust. 这一次我们看看使用tensorflow建立了什么,并通过http接口提供服务。随着Actix Web1.0版本发布,我认为用它构建一些东西将是一个很好的时机。 本文假设您对Futures及其运作方式有一定的了解。我将尽量用更简单的术语解释,但理解Futures生态系统将非常有效地帮助阅读本文。为此,我建议你从tokio开始。 有些人建议在深入Futures之前等待async/await和friends功能发布。我认为你现在应该亲自动手:异步编程总是很有挑战性。再一次为了不耐烦的人,您可以在actix-web分支上找到参考代码:https://github.com/cetra3/mtc... 一、API定义这里的API非常简单。我们想模仿我们在命令行上所做的事情:提交一张图片,返回结果是一张图片。为了使事情变得有趣,我们将提供一种方式:将边界框以JSON数组返回。 关于通过http协议提交二进制数据,我首先想到了几种选择: 只需提交原始数据即可使用multipart/form-data序列化为JSON格式提交我认为最简单是原始数据,所以让我们这样做! multipart/form-data可能ok,但是你必须处理多个图像的时候呢? JSON格式似乎有点浪费,因为您不可避免地必须使用base64或类似的方式转换二进制数据。 所以我们的API是这样的: 提交POST请求作为原始文件提交运行会话,通过MTCNN算法以提取人脸将边界框作以JSON格式返回;或者命令行示例一样,将图像叠加以JPEG格式返回。二、MTCNN的结构体(struct)在我们上一篇博客中,我们只是简单地使用main函数来执行所有操作,但我们必须一些重构才能与actix一起使用。我们希望将MTCNN行为封装为结构,可以传递和转移。最终目标是在应用程序状态下使用它。 2.1结构体(struct)定义让我们将结构包含我们想要的一切: 图版会话一些多个请求中共用的Tensor框架的输入参数首先,我们创建一个新文件mtcnn.rs并加上结构体定义。 use tensorflow::{Graph, Session, Tensor};pub struct Mtcnn { graph: Graph, session: Session, min_size: Tensor<f32>, thresholds: Tensor<f32>, factor: Tensor<f32>}然后,现在我们只是用new方法填充初始化内容。由于其中一些值的初始化并非绝对可靠,我们将返回Result: pub fn new() -> Result<Self, Box<dyn Error>> { let model = include_bytes!("mtcnn.pb"); let mut graph = Graph::new(); graph.import_graph_def(&*model, &ImportGraphDefOptions::new())?; let session = Session::new(&SessionOptions::new(), &graph)?; let min_size = Tensor::new(&[]).with_values(&[40f32])?; let thresholds = Tensor::new(&[3]).with_values(&[0.6f32, 0.7f32, 0.7f32])?; let factor = Tensor::new(&[]).with_values(&[0.709f32])?; Ok(Self { graph, session, min_size, thresholds, factor })}2.2Run方法我将在这里开始加快节奏,所以如果你遇到困难或不确定发生了什么,请查看face-detection-with-tensorflow-rust,以解释这里发生的事情。我们已经添加了所有需要跑一个会话的东西。让我们创建一个需要API做什么的方法:提交一张图片,响应一些边界框(框出人脸的位置): ...

June 29, 2019 · 6 min · jiezi

Tensorflow-与-Tensorflow-20-入门文章汇总

用最白话的语言,讲解机器学习、神经网络与深度学习示例基于 TensorFlow 1.4 和 TensorFlow 2.0 实现mnistTensorFlow入门(一) - mnist手写数字识别(网络搭建) mnist/v1 这篇博客介绍了使用 TensorFlow 搭建最简单的神经网络。包括输入输出、独热编码与损失函数,以及正确率的验证。TensorFlow入门(二) - mnist手写数字识别(模型保存加载) mnist/v2 介绍了 TensorFlow 中如何保存训练好的模型介绍了如何从某一个模型为起点继续训练介绍了模型如何加载使用,传入真实的图片如何识别TensorFlow入门(三) - mnist手写数字识别(可视化训练) mnist/v3 介绍了tensorboard的简单用法,包括标量图、直方图以及网络结构图TensorFlow入门(四) - mnist手写数字识别(制作h5py训练集) make_data_set 介绍了如何使用 numpy 制作 npy 格式的数据集介绍了如何使用 h5py 制作 HDF5 格式的数据集TensorFlow 2.0 (五) - mnist手写数字识别(CNN卷积神经网络) v4_cnn 介绍了如何搭建CNN网络,准确率达到0.99使用TensorFlow 2.0OpenAI gymTensorFlow 2.0 (六) - 监督学习玩转 OpenAI gym game gym/CartPole-v0-nn 介绍了使用纯监督学习(神经网络)来玩CartPole-v0游戏使用TensorFlow 2.0

June 21, 2019 · 1 min · jiezi

在-Google-Colab-中快速实践深度学习

本文很多是对于 Colab 官方 Welcome 系列的总结,更多人工智能与深度学习相关知识参考人工智能与深度学习实战 https://github.com/wx-chevalier/AIDL-Series 系列文章。 ColaboratoryColaboratory 是一个免费的 Jupyter 笔记本环境,不需要进行任何设置就可以使用,并且完全在云端运行。借助 Colaboratory,我们可以在浏览器中编写和执行代码、保存和共享分析结果,以及利用强大的计算资源,包含 GPU 与 TPU 来运行我们的实验代码。 Colab 能够方便地与 Google Driver 与 Github 链接,我们可以使用 Open in Colab 插件快速打开 Github 上的 Notebook,或者使用类似于 https://colab.research.google... 这样的链接打开。如果需要将 Notebook 保存回 Github,直接使用 File→Save a copy to GitHub 即可。譬如笔者所有与 Colab 相关的代码归置在了 AIDL-Workbench/colab。 依赖与运行时依赖安装Colab 提供了便捷的依赖安装功能,允许使用 pip 或者 apt-get 命令进行安装: # Importing a library that is not in Colaboratory!pip install -q matplotlib-venn!apt-get -qq install -y libfluidsynth1# Upgrading TensorFlow# To determine which version you're using:!pip show tensorflow# For the current version:!pip install --upgrade tensorflow# For a specific version:!pip install tensorflow==1.2# For the latest nightly build:!pip install tf-nightly# Install Pytorchfrom os import pathfrom wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tagplatform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())accelerator = 'cu80' if path.exists('/opt/bin/nvidia-smi') else 'cpu'!pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.4.0-{platform}-linux_x86_64.whl torchvision# Install 7zip reader libarchive# https://pypi.python.org/pypi/libarchive!apt-get -qq install -y libarchive-dev && pip install -q -U libarchiveimport libarchive# Install GraphViz & PyDot# https://pypi.python.org/pypi/pydot!apt-get -qq install -y graphviz && pip install -q pydotimport pydot# Install cartopy!apt-get -qq install python-cartopy python3-cartopyimport cartopy在 Colab 中还可以设置环境变量: ...

June 18, 2019 · 4 min · jiezi

TensorFlow-20Keras-防坑指南

TensorFlow 2.0是对1.x版本做了一次大的瘦身,Eager Execution默认开启,并且使用Keras作为默认高级API,这些改进大大降低的TensorFlow使用难度。 本文主要记录了一次曲折的使用Keras+TensorFlow2.0的BatchNormalization的踩坑经历,这个坑差点要把TF2.0的新特性都毁灭殆尽,如果你在学习TF2.0的官方教程,不妨一观。 问题的产生从教程[1]https://www.tensorflow.org/alpha/tutorials/images/transfer_learning?hl=zh-cn(讲述如何Transfer Learning)说起: IMG_SHAPE = (IMG_SIZE, IMG_SIZE, 3)# Create the base model from the pre-trained model MobileNet V2base_model = tf.keras.applications.MobileNetV2(input_shape=IMG_SHAPE, include_top=False,weights='imagenet')model = tf.keras.Sequential([ base_model, tf.keras.layers.GlobalAveragePooling2D(), tf.keras.layers.Dense(NUM_CLASSES)])简单的代码我们就复用了MobileNetV2的结构创建了一个分类器模型,接着我们就可以调用Keras的接口去训练模型: model.compile(optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate), loss='sparse_categorical_crossentropy', metrics=['sparse_categorical_accuracy'])model.summary()history = model.fit(train_batches.repeat(), epochs=20, steps_per_epoch = steps_per_epoch, validation_data=validation_batches.repeat(), validation_steps=validation_steps)输出的结果看,一起都很完美: Model: "sequential"_________________________________________________________________Layer (type) Output Shape Param #=================================================================mobilenetv2_1.00_160 (Model) (None, 5, 5, 1280) 2257984_________________________________________________________________global_average_pooling2d (Gl (None, 1280) 0_________________________________________________________________dense (Dense) (None, 2) 1281=================================================================Total params: 2,259,265Trainable params: 1,281Non-trainable params: 2,257,984_________________________________________________________________Epoch 11/20581/581 [==============================] - 134s 231ms/step - loss: 0.4208 - accuracy: 0.9484 - val_loss: 0.1907 - val_accuracy: 0.9812Epoch 12/20581/581 [==============================] - 114s 197ms/step - loss: 0.3359 - accuracy: 0.9570 - val_loss: 0.1835 - val_accuracy: 0.9844Epoch 13/20581/581 [==============================] - 116s 200ms/step - loss: 0.2930 - accuracy: 0.9650 - val_loss: 0.1505 - val_accuracy: 0.9844Epoch 14/20581/581 [==============================] - 114s 196ms/step - loss: 0.2561 - accuracy: 0.9701 - val_loss: 0.1575 - val_accuracy: 0.9859Epoch 15/20581/581 [==============================] - 119s 206ms/step - loss: 0.2302 - accuracy: 0.9715 - val_loss: 0.1600 - val_accuracy: 0.9812Epoch 16/20581/581 [==============================] - 115s 197ms/step - loss: 0.2134 - accuracy: 0.9747 - val_loss: 0.1407 - val_accuracy: 0.9828Epoch 17/20581/581 [==============================] - 115s 197ms/step - loss: 0.1546 - accuracy: 0.9813 - val_loss: 0.0944 - val_accuracy: 0.9828Epoch 18/20581/581 [==============================] - 116s 200ms/step - loss: 0.1636 - accuracy: 0.9794 - val_loss: 0.0947 - val_accuracy: 0.9844Epoch 19/20581/581 [==============================] - 115s 198ms/step - loss: 0.1356 - accuracy: 0.9823 - val_loss: 0.1169 - val_accuracy: 0.9828Epoch 20/20581/581 [==============================] - 116s 199ms/step - loss: 0.1243 - accuracy: 0.9849 - val_loss: 0.1121 - val_accuracy: 0.9875然而这种写法还是不方便Debug,我们希望可以精细的控制迭代的过程,并能够看到中间结果,所以我们训练的过程改成了这样: ...

April 30, 2019 · 5 min · jiezi

基于TensorFlowjs的JavaScript机器学习

虽然python或r编程语言有一个相对容易的学习曲线,但是Web开发人员更喜欢在他们舒适的javascript区域内做事情。目前来看,node.js已经开始向每个领域应用javascript,在这一大趋势下我们需要理解并使用JS进行机器学习。由于可用的软件包数量众多,python变得流行起来,但是JS社区也紧随其后。这篇文章会帮助初学者学习如何构建一个简单的分类器。 扩展:2019年11个javascript机器学习库 很棒的机器学习库,可以在你的下一个应用程序中添加一些人工智能!Big.bitsrc.io 创建我们可以创建一个使用tensorflow.js在浏览器中训练模型的网页。考虑到房屋的“avgareanumberofrows”,模型可以学习去预测房屋的“价格”。 为此我们要做的是: 加载数据并为培训做好准备。 定义模型的体系结构。 训练模型并在训练时监控其性能。 通过做出一些预测来评估经过训练的模型。 第一步:让我们从基础开始 创建一个HTML页面并包含JavaScript。将以下代码复制到名为index.html的HTML文件中。 <!DOCTYPE html><html><head> <title>TensorFlow.js Tutorial</title> <!-- Import TensorFlow.js --> <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@1.0.0/dist/tf.min.js"></script> <!-- Import tfjs-vis --> <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-vis@1.0.2/dist/tfjs-vis.umd.min.js"></script> <!-- Import the main script file --> <script src="script.js"></script></head><body></body></html>为代码创建javascript文件 在与上面的HTML文件相同的文件夹中,创建一个名为script.js的文件,并将以下代码放入其中。 console.log('Hello TensorFlow');测试 既然已经创建了HTML和JavaScript文件,那么就测试一下它们。在浏览器中打开index.html文件并打开devtools控制台。 如果一切正常,那么应该在devtools控制台中创建并可用两个全局变量: tf是对tensorflow.js库的引用tfvis是对tfjs vis库的引用现在你应该可以看到一条消息,上面写着“Hello TensorFlow”。如果是这样,你就可以继续下一步了。 注意:可以使用Bit来共享可重用的JS代码 Bit(GitHub上的Bit)是跨项目和应用程序共享可重用JavaScript代码的最快和最可扩展的方式。可以试一试,它是免费的: 组件发现与协作·Bit Bit是开发人员共享组件和协作,共同构建令人惊叹的软件的地方。发现共享的组件…Bit.dev 例如:Ramda用作共享组件 Ramda by Ramda·Bit 一个用于JavaScript程序员的实用函数库。-256个javascript组件。例如:等号,乘…Bit.dev 第2步:加载数据,格式化数据并可视化输入数据 我们将加载“house”数据集,可以在这里找到。它包含了特定房子的许多不同特征。对于本教程,我们只需要有关房间平均面积和每套房子价格的数据。 将以下代码添加到script.js文件中。 async function getData() { Const houseDataReq=awaitfetch('https://raw.githubusercontent.com/meetnandu05/ml1/master/house.json'); const houseData = await houseDataReq.json(); const cleaned = houseData.map(house => ({ price: house.Price, rooms: house.AvgAreaNumberofRooms, })) .filter(house => (house.price != null && house.rooms != null)); return cleaned;}这可以删除没有定义价格或房间数量的任何条目。我们可以将这些数据绘制成散点图,看看它是什么样子的。 ...

April 28, 2019 · 4 min · jiezi

Tensorflow Rust实战上篇

机器学习的一个方向是能够将它用于照片中的对象识别。这包括能够挑选动物,建筑物甚至人脸等特征。本文将引导您使用一些现有模型来使用rust和tensorflow完成人脸检测。我们将使用一个名为mtcnn的预训练模型进行人脸检测(注意:训练新模型不是我们在本文中关注的内容)。 挑战我们想要读取照片,检测到人脸,然后返回带有绘制边界框的图像。换句话说,我们想转换它(图片使用RustFest的许可,由FionaCastiñeira拍摄): Tensorflow and MTCNN最初的MTCNN模型是使用Caffe编写的,但幸运的是mtcnn有许多tensorflow python实现。我将选择tf-mtcnn,因为它是直接转换为单个图形模型文件。 首先,我们要添加tensorflow rust作为依赖。从Cargo.toml开始: [package]name = "mtcnn"version = "0.1.0"edition = "2018"[dependencies]tensorflow = "0.12.0"我们要做的是加载一个Graph,它是预先训练好的MTCNN,并运行一个会话。要点是Graph是用于计算的模型,Session是Graph的一次运行。有关这些概念的更多信息可以在这里找到。我喜欢将Graph视为大桶中的人造大脑,用途只是在您输入和输出时获得一些很棒的图像。 因此,让我们首先抓住现有的mtcnn.pb模型并尝试加载它。 Tensorflow图以protobuf格式序列化,可以使用Graph::import_graph_def加载。 use std::error::Error;use tensorflow::Graph;use tensorflow::ImportGraphDefOptions;fn main() -> Result<(), Box<dyn Error>> { //First, we load up the graph as a byte array let model = include_bytes!("mtcnn.pb"); //Then we create a tensorflow graph from the model let mut graph = Graph::new(); graph.import_graph_def(&*model, &ImportGraphDefOptions::new())? Ok(())}跑cargo run命令,我们应该看到没有任何错误: $ cargo run Compiling mtcnn v0.1.0 (~/mtcnn) Finished dev [unoptimized + debuginfo] target(s) in 0.89s Running `target/debug/mtcnn`太棒了!看起来我们可以加载此图像! ...

April 21, 2019 · 3 min · jiezi

什么是TensorBoard?

前言只有光头才能变强。文本已收录至我的GitHub仓库,欢迎Star:https://github.com/ZhongFuCheng3y/3y回顾前面:从零开始学TensorFlow【01-搭建环境、HelloWorld篇】什么是TensorFlow?TensorFlow读写数据如何理解axis?这篇文章主要讲讲TensorBoard的基本使用以及name_scope和variable_scope的区别一、入门TensorBoard首先来讲讲TensorBoard是什么吧,我当时是在官方文档里学习的,官网也放出了介绍TensorBoard的视频。我在b站搜了一把,发现也有,大家可以先去看看视频了解一下(其实已经说得很好了):https://www.bilibili.com/video/av35203293?from=search&seid=6605552834229124959为了更方便 TensorFlow 程序的理解、调试与优化,于是就有了TensorBoard 这样的的可视化工具因为我们编写出来的TensorFlow程序,建好一个神经网络,其实我们也不知道神经网络里头具体细节到底做了什么,要人工调试十分困难(就好比你无法想象出递归的所有步骤一样)。有了TensorBoard,可以将TensorFlow程序的执行步骤都显示出来,非常直观。并且,我们可以对训练的参数(比如loss值)进行统计,用图的方式来查看变化的趋势。1.1 name_scope和variable_scope在视频中其实也有提到,我们想要TensorBoard的图能够更好地展示(更加有条理),那一般我们需要对其用name_scope取名。那除了name_scope,还有一个叫做variable_scope。那他们有什么区别呢?顾名思义,name_scope是一个名称作用域,variable_scope是变量作用域。在前面文章中,创建变量有两种方式,一种是用tf.get_variable()来创建,一种是用tf.Variable()来创建。这两种创建方式也是有区别的。在 tf.name_scope下时,tf.get_variable()创建的变量名不受 name_scope 的影响,而且在未指定共享变量时,如果重名就会报错。tf.Variable()会自动检测有没有变量重名,如果有则会自行处理(自动创建一个)比如下面的代码:with tf.name_scope(’name_sp1’) as scp1: with tf.variable_scope(‘var_scp2’) as scp2: with tf.name_scope(’name_scp3’) as scp3: a = tf.Variable(‘a’) b = tf.get_variable(‘b’)等同于:with tf.name_scope(’name_sp1’) as scp1: with tf.name_scope(’name_sp2’) as scp2: with tf.name_scope(’name_scp3’) as scp3: a = tf.Variable(‘a’)with tf.variable_scope(‘var_scp2’) as scp2: b = tf.get_variable(‘b’)这里体现的是如果用get_variable的方式来创建对象,是不受name_scope所影响的。要注意的是,下面的代码会报错。因为在scp作用域下压根就没有a这个变量,同时又设置成reuse=True。这里因为的是找不到共享变量而出错!with tf.variable_scope(‘scp’, reuse=True) as scp: a = tf.get_varialbe(‘a’) #报错同样地,下面的代码也会报错,因为明明已经有共享变量了,但设置成reuse=false。所以就会报错。with tf.variable_scope(‘scp’, reuse=False) as scp: a = tf.get_varialbe(‘a’) a = tf.get_varialbe(‘a’) #报错最后,我们再来看这个例子,应该就可以看懂了。with tf.variable_scope(‘variable_scope_y’) as scope: var1 = tf.get_variable(name=‘var1’, shape=[1], dtype=tf.float32) scope.reuse_variables() # 设置共享变量 var1_reuse = tf.get_variable(name=‘var1’) var2 = tf.Variable(initial_value=[2.], name=‘var2’, dtype=tf.float32) var2_reuse = tf.Variable(initial_value=[2.], name=‘var2’, dtype=tf.float32)with tf.Session() as sess: sess.run(tf.global_variables_initializer()) print(var1.name, sess.run(var1)) print(var1_reuse.name, sess.run(var1_reuse)) print(var2.name, sess.run(var2)) print(var2_reuse.name, sess.run(var2_reuse))# 输出结果:# variable_scope_y/var1:0 [-1.59682846]# variable_scope_y/var1:0 [-1.59682846] 可以看到变量var1_reuse重复使用了var1# variable_scope_y/var2:0 [ 2.]# variable_scope_y/var2_1:0 [ 2.]参考资料:https://www.zhihu.com/question/545137281.2 TensorBoard例子下面我们来看一个TensorBoard简单的入门例子,感受一下:def learn_tensor_board_2(): # prepare the original data with tf.name_scope(‘data’): x_data = np.random.rand(100).astype(np.float32) y_data = 0.3 * x_data + 0.1 ##creat parameters with tf.name_scope(‘parameters’): with tf.name_scope(‘weights’): weight = tf.Variable(tf.random_uniform([1], -1.0, 1.0)) tf.summary.histogram(‘weight’, weight) with tf.name_scope(‘biases’): bias = tf.Variable(tf.zeros([1])) tf.summary.histogram(‘bias’, bias) ##get y_prediction with tf.name_scope(‘y_prediction’): y_prediction = weight * x_data + bias ##compute the loss with tf.name_scope(’loss’): loss = tf.reduce_mean(tf.square(y_data - y_prediction)) tf.summary.scalar(’loss’, loss) ##creat optimizer optimizer = tf.train.GradientDescentOptimizer(0.5) # creat train ,minimize the loss with tf.name_scope(’train’): train = optimizer.minimize(loss) # creat init with tf.name_scope(‘init’): init = tf.global_variables_initializer() ##creat a Session sess = tf.Session() # merged merged = tf.summary.merge_all() ##initialize writer = tf.summary.FileWriter("/Users/zhongfucheng/tensorboard/loss-2", sess.graph) sess.run(init) ## Loop for step in range(201): sess.run(train) rs = sess.run(merged) writer.add_summary(rs, step)if name == ‘main’: learn_tensor_board_2() # 启动完了之后,要在命令行上运行tensor_board的命令,指定其目录,最后我们就可以通过6006的默认端口访问我们的图。(例子来源网络,我改动了一下,出处我忘了,侵删~)接下来,我们启动一下TensorBoard,看看图是怎么样的,启动命令如下:tensorboard –logdir=/Users/zhongfucheng/tensorboard/loss-2启动成功的图:通过6006端口我们去访问一下,首先我们可以检测到loss值的变更:我们也可以查看TensorFlow程序大概的执行步骤:参数w和b的直方图:总之,TensorBoard可以方便地查看我们参数的变化,以便更好理解我们写的代码。参考资料:https://www.cnblogs.com/tengge/p/6376073.htmlhttps://www.cnblogs.com/fydeblog/p/7429344.html最后乐于输出干货的Java技术公众号:Java3y。公众号内有200多篇原创技术文章、海量视频资源、精美脑图,不妨来关注一下!觉得我的文章写得不错,不妨点一下赞! ...

April 20, 2019 · 2 min · jiezi

windows10下,零基础学习VUE(7)-- 小练习,使用lstm学习红楼梦文本,搭建前端与后端进行参数交互

!!挖坑中<template> <div class=‘index_auto’> <div style=“text-align: center;"> <h1>红楼梦风格文字生成</h1> <p>输入框填入文字作为开头,点击生成,可以续写一小段片段</p> <p> <div>创造性:越高则随意发挥行越强,也就可能越不通顺</div> <div>最大文字数:生成篇章的最大文字数量</div> </p> </div> <p><br><br></p> <div style=“display: flex; justify-content:center;"> <el-row :gutter=“30” > <el-col :span=“12”> <div class=“block”> <span class=“demonstration”>创造性</span> <el-slider show-input v-model=“tmperature” :step=“10”> </el-slider> </div> </el-col> <el-col :span=“12”><div > <span class=“demonstration”>最大文字数</span> <el-slider :max=“max_num” show-input v-model=“maxlen” :step=“50” show-stops> </el-slider> </div></el-col> <el-col :span=“12”><div> <span class=“demonstration”>生成次数</span> <el-slider :max=“max_count” show-input v-model=“gennum” :step=“1” show-stops> </el-slider> </div></el-col> <el-col :span=“12”><div> <span class=“demonstration”>测试</span> <el-slider show-input v-model=“test_to_reply” :step=“1” show-stops> </el-slider> </div></el-col> </el-row> </div> <div style=“height:400px; margin:0 auto; overflow:auto”> <el-row :gutter=“20”> <el-col :span=“10”> <div class=“grid-content”> <el-input type=“textarea” :autosize=”{ minRows: 9, maxRows: 9}” placeholder=“请输入内容” v-model=“textarea1”> </el-input> </div> </el-col> <el-col :span=“4”><div class=“grid-content” style=“display: flex; justify-content:center; align-items:Center;"> <el-button type=“success” @click=“getGentxt” round> Generate HLM TXT </el-button> </div></el-col> <el-col :span=“10”><div class=“grid-content”> <el-tabs v-model=“activeName2” type=“border-card” > <el-tab-pane v-for="(txt,index) in splittxt” :key=“index” :label=“int2string(index)” :name=“int2string(index)"><p>{{txt}}</p></el-tab-pane> </el-tabs> </div></el-col> </el-row> </div> <img v-if=“resultUrl” :src=“resultUrl” class=“avatar”> <p class=“avatar”>{{resultClass}}</p> </div></template> ...

April 15, 2019 · 1 min · jiezi

Tensorflow Lite介绍

简介Tensorflow Lite是针对移动设备和嵌入式设备的轻量化解决方案,占用空间小,低延迟。Tensorflow Lite在android8.1以上的设备上可以通过ANNA启用硬件加速。支持浮点运算和量化模型,并已针对移动平台进行优化,可以用来创建和运行自定义模型。开发者也可以在模型中添加自定义操作。FlatBuffer格式具有在移动设备运行更快的内核解释器支持通过Tensorflow训练好的模型转换为Tensorflow Lite格式(pd,h5等都可以)当支持所有优化操作时,模型小于300k,当仅支持inception v3和mobilenet模型优化时,模型小于200k预训练模型:inception v3:用于目标检测MobileNets:专门针对移动端的模型,具有低延迟,高速度,低内存,可用于图像识别,目标检测,图像分割,但是精度小于inception v3量化版本的MobileNets,通过将float-32转为int-8,在CPU上拥有更快的速度支持java,c++API以上谈到的预训练模型基于ImageNet数据集训练,支持1000种类别。如果此数据集不能满足你的项目需要,你需要准备自己的数据集和标签,使用迁移学习重新训练模型。模型结构Tensorflow Lite模型的数据格式与Tensorflow桌面端不同,需要使用Tensorflow Lite转换为.tflite格式,然后应用到移动端。模型结构:java-API:包装C++API,以便在android上使用java调用C++-API:加载Tensorflow Lite模型和解释器解释器:执行模型一系列核心操作,支持选择内核加载。全部加载300kb,不加载只有100kb在android8.1以上设备,可通过相关api进行硬件加速(硬件支持的情况下),否则在CPU执行转换模型格式Tensorflow Lite转换器支持以下格式:使用python API执行SavedModel保存的模型文件tf.keras保存的.h5模型文件转换后的GraphDef文件转换GraphDef文件Tensorflow模型一般保存为.pd或.pdtxt格式的文件,要转换为Tensorflow Lite支持的文件,首先需要进行frozen操作。此操作处理多个不同格式的文件:tf.GraphDef(pd,pdtxt):图文件,包含操作,张量,变量的定义checkpoint(.ckpt):包含变量,不包含解释器tensorflow lite(.tflite):序列化的FlatBuffer文件,包含所有需要的文件checkpoint文件包含训练权重,tf.graphdef文件包含图结构。冻结操作就是将上述文件进行合并操作使用命令行,执行该操作的示例如下:freeze_graph –input_graph=/demo/mobilenet_v1_224.pd--input_checkpoint=/demo/checkpoints/mobilenet-1001.ckpt--input_binary=True--output_graph=/demo/frozen_mobilenet_v1_224.pd--output_node_names=/demo/MobileNetV1/Predictions/Reshape_1input_binary:读取的文件是否是二进制文件,如:pd和pdtxt文件android端使用Tensorflow Lite可以使用android studio和源码编译两种方式,此处我们介绍第一种(由于你懂的原因,开vpn会比较顺利些)。安装android studioSDK大于26,NDK大于14导入工程项目,路径:tensorflow/lite/examples默认使用mobilenet模型,如要使用inception模型,先下载模型文件并拷贝至asset文件夹,然后修改Camera2BasicFragment文件:classifier = new ImageClassifierQuantizedMobileNet(getActivity())改为:classifier = new ImageClassifierFloatInception(getActivity())Tensorflow Lite转换器上图是Tensorflow Lite转换器的工作流程,清晰明了,就不做过多介绍了。此外,转换的方式有两种,python api的方式和命令行方式。从Session中导出GraphDef使用tf.Session将Tensorflow模型转为Tensorflow Lite模型import tensorflow as tfimg = tf.placeholder(name=“img”, dtype=tf.float32, shape=(1, 64, 64, 3))var = tf.get_variable(“weights”, dtype=tf.float32, shape=(1, 64, 64, 3))val = img + varout = tf.identity(val, name=“out”)with tf.Session() as sess: sess.run(tf.global_variables_initializer()) converter = tf.lite.TFLiteConverter.from_session(sess, [img], [out]) tflite_model = converter.convert() open(“converted_model.tflite”, “wb”).write(tflite_model)从file中导出GraphDef以下代码展示怎样将.pd或.pdtxt文件转为Tensorflow Lite模型支持的FlateBuffer格式文件。import tensorflow as tfgraph_def_file = “/path/to/Downloads/mobilenet_v1_1.0_224/frozen_graph.pb"input_arrays = [“input”]output_arrays = [“MobilenetV1/Predictions/Softmax”]converter = tf.lite.TFLiteConverter.from_frozen_graph( graph_def_file, input_arrays, output_arrays)tflite_model = converter.convert()open(“converted_model.tflite”, “wb”).write(tflite_model)将SaveModle导出import tensorflow as tfconverter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)tflite_model = converter.convert()open(“converted_model.tflite”, “wb”).write(tflite_model)tf.keras文件导出import tensorflow as tfconverter = tf.lite.TFLiteConverter.from_keras_model_file(“keras_model.h5”)tflite_model = converter.convert()open(“converted_model.tflite”, “wb”).write(tflite_model)量化模型import tensorflow as tfimg = tf.placeholder(name=“img”, dtype=tf.float32, shape=(1, 64, 64, 3))const = tf.constant([1., 2., 3.]) + tf.constant([1., 4., 4.])val = img + constout = tf.fake_quant_with_min_max_args(val, min=0., max=1., name=“output”)with tf.Session() as sess: converter = tf.lite.TFLiteConverter.from_session(sess, [img], [out]) converter.inference_type = tf.lite.constants.QUANTIZED_UINT8 input_arrays = converter.get_input_arrays() converter.quantized_input_stats = {input_arrays[0] : (0., 1.)} # mean, std_dev tflite_model = converter.convert() open(“converted_model.tflite”, “wb”).write(tflite_model)TensorFlow Lite Python解释器代码展示如何使用Tensorflow Lite解释器读取.tflite文件。import numpy as npimport tensorflow as tf# 加载模型并分配张量interpreter = tf.lite.Interpreter(model_path=“converted_model.tflite”)interpreter.allocate_tensors()# 获取输入输出张量input_details = interpreter.get_input_details()output_details = interpreter.get_output_details()# 随机生成测试数据,测试模型输出input_shape = input_details[0][‘shape’]input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32)interpreter.set_tensor(input_details[0][‘index’], input_data)interpreter.invoke()output_data = interpreter.get_tensor(output_details[0][‘index’])print(output_data)Tensorflow2.0转换器使用如图所示,Tensorflow2.0与之前相比,少了冻结graph模块,增加了Concrete Fn。生成concrete Fn为了将Tensorflow2.0模型转为Tensorflow Lite,模型需要导出concrete Fn。这是因为Tensorflow2.0中,eager execution是默认设置,虽然调试更加便利,但是它没有保存图,因为不能直接应用到移动设备。不过,可以使用tf.function包装,这样保存的模型就包含图,可以转换为Tensorflow Lite所需要的FlatBuffer格式文件。class BasicModel(tf.Module): def init(self): self.const = None @tf.function def pow(self, x): if self.const is None: self.const = tf.Variable(2.) return x ** self.constconcrete Fn声明的图可以被转换为Tensorflow Lite模型或者使用SaveModel导出。为了导出此方法,需要声明signature,使用方法如下:在tf.function中声明input_signature将tf.TensorSpec传值给get_concrete_funtion将input传值给get_concrete_funtionimport tensorflow as tfroot = tf.Module()# 初始化一次变量值root.var = None@tf.functiondef exported_function(x): if root.var is None: root.var = tf.Variable(tf.random.uniform([2, 2])) root.const = tf.constant([[37.0, -23.0], [1.0, 4.0]]) root.mult = tf.matmul(root.const, root.var) return root.mult * xroot.func = exported_functionconcrete_func = root.func.get_concrete_function( tf.TensorSpec([1, 1], tf.float32))Python api执行the TensorFlow Lite converterTensorflow2.0中转换Tensorflow Lite模型使用tf.lite.TFLiteConverter.from_concrete_function(),示例如下:import tensorflow as tf# 创建模型root = tf.train.Checkpoint()root.v1 = tf.Variable(3.)root.v2 = tf.Variable(2.)root.f = tf.function(lambda x: root.v1 * root.v2 * x)# 保存模型export_dir = “/tmp/test_saved_model"input_data = tf.constant(1., shape=[1, 1])to_save = root.f.get_concrete_function(input_data)tf.saved_model.save(root, export_dir, to_save)# 加载模型并获取concrete fn.model = tf.saved_model.load(export_dir)concrete_func = model.signatures[ tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]# 设置input shapeconcrete_func.inputs[0].set_shape(input_data.shape)# 转换模型converter = tf.lite.TFLiteConverter.from_concrete_function(concrete_func)tflite_model = converter.convert()TensorFlow Lite 推断TensorFlow Lite推断一般执行以下步骤:加载.tflite模型处理数据以适应模型input调用API,创建解析器,运行模型获取模型输出结果如何选择模型如图所示,大模型高精度,高延迟;小模型低精度,低延迟,模型的选择需要根据你的项目需求进行选择。 ...

April 2, 2019 · 2 min · jiezi

如何理解Axis?

前言只有光头才能变强。回顾前面:从零开始学TensorFlow【01-搭建环境、HelloWorld篇】什么是TensorFlow?TensorFlow读写数据不知道大家最开始接触到axis的时候是怎么样的,反正我是挺难理解的..我们可以发现TensorFlow的很多API都有axis这个参数,如果我们对axis不了解,压根不知道API是怎么搞的。一句话总结axis:axis可以方便我们将数据进行不同维度的处理。一、理解axis如果你像我一样,发现API中有axis这个参数,但不知道是什么意思。可能就会搜搜axis到底代表的什么意思。于是可能会类似搜到下面的信息:使用0值表示沿着每一列或行标签索引值向下执行方法(axis=0代表往跨行)使用1值表示沿着每一行或者列标签模向执行对应的方法(axis=1代表跨列)但我们又知道,我们的数组不单单只有二维的,还有三维、四维等等。一旦维数超过二维,就无法用简单的行和列来表示了。所以,可以用我下面的方式进行理解:axis=0将最开外头的括号去除,看成一个整体,在这个整体上进行运算axis=1将第二个括号去除,看成一个整体,在这个整体上进行运算…依次类推话不多说,下面以例子说明1.1二维数组之concat首先,我们来看个concat的例子,concat第一个参数接收val,第二个参数接收的是axisdef learn_concat(): # 二维数组 t1 = tf.constant([[1, 2, 3], [4, 5, 6]]) t2 = tf.constant([[7, 8, 9], [10, 11, 12]]) with tf.Session() as sess: # 二维数组针对 axis 为0 和 1 的情况 print(sess.run(tf.concat([t1, t2], 0))) print(sess.run(tf.concat([t1, t2], 1)))ok,下面以图示的方式来说明。现在我们有两个数组,分别是t1和t2:首先,我们先看axis=0的情况,也就是tf.concat([t1, t2], 0)。从上面的描述,我们知道,先把第一个括号去除,然后将其子内容看成一个整体,在这个整体下进行想对应的运算(这里我们就是concat)。所以最终的结果是:[ [1 2 3], [4 5 6], [7 8 9], [10 11 12]]接着,我们再看axis=1的情况,也就是tf.concat([t1, t2], 1)。从上面的描述,我们知道,先把第二个括号去除,然后将其子内容看成一个整体,在这个整体下进行想对应的运算(这里我们就是concat)。所以最终的结果是:[ [1, 2, 3, 7, 8, 9] [4, 5, 6, 10, 11, 12]]1.2三维数组之concat接下来我们看一下三维的情况def learn_concat(): # 三维数组 t3 = tf.constant([[[1, 2], [2, 3]], [[4, 4], [5, 3]]]) t4 = tf.constant([[[7, 4], [8, 4]], [[2, 10], [15, 11]]]) with tf.Session() as sess: # 三维数组针对 axis 为0 和 1 和 -1 的情况 print(sess.run(tf.concat([t3, t4], 0))) print(sess.run(tf.concat([t3, t4], 1))) print(sess.run(tf.concat([t3, t4], -1)))ok,下面也以图示的方式来说明。现在我们有两个数组,分别是t3和t4:首先,我们先看axis=0的情况,也就是tf.concat([t3, t4], 0)。从上面的描述,我们知道,先把第一个括号去除,然后将其子内容看成一个整体,在这个整体下进行想对应的运算(这里我们就是concat)。所以最终的结果是:[ [ [1 2] [2 3] ] [ [4 4] [5 3] ] [ [7 4] [8 4] ] [ [2 10] [15 11] ]]接着,我们再看axis=1的情况,也就是tf.concat([t3, t4], 1)。从上面的描述,我们知道,先把第二个括号去除,然后将其子内容看成一个整体,在这个整体下进行想对应的运算(这里我们就是concat)。所以最终的结果是:[ [ [1 2] [2 3] [7 4] [8 4] ] [ [4 4] [5 3] [2 10] [15 11] ]]最后,我们来看一下axis=-1这种情况,在文档也有相关的介绍:As in Python, the axis could also be negative numbers. Negative axis are interpreted as counting from the end of the rank, i.e.,axis + rank(values)-th dimension所以,对于我们三维的数组而言,那axis=-1实际上就是axis=2,下面我们再来看一下这种情况:最终的结果是:[ [ [1 2 7 4] [2 3 8 4] ] [ [4 4 2 10] [5 3 15 11] ]]除了concat以外,其实很多函数都用到了axis这个参数,再举个例子:>>> item = np.array([[1,4,8],[2,3,5],[2,5,1],[1,10,7]])>>> itemarray([[1, 4, 8], [2, 3, 5], [2, 5, 1], [1, 10, 7]])>>> item.sum(axis = 1)array([13, 10, 8, 18])>>> item.sum(axis = 0)array([ 6, 22, 21])参考资料:有关axis/axes的理解https://zhuanlan.zhihu.com/p/25761406最后下一篇是TensorBoard乐于输出干货的Java技术公众号:Java3y。公众号内有200多篇原创技术文章、海量视频资源、精美脑图,不妨来关注一下!觉得我的文章写得不错,不妨点一下赞! ...

March 27, 2019 · 2 min · jiezi

手把手教你使用TF服务将TensorFlow模型部署到生产环境

摘要: 训练好的模型不知道如何布置到生产环境?快来学习一下吧!介绍将机器学习(ML)模型应用于生产环境已成为一个火热的的话题,许多框架提供了旨在解决此问题的不同解决方案。为解决这一问题,谷歌发布了TensorFlow(TF)服务,以期待解决将ML模型部署到生产中的问题。本文提供了一个关于服务于预先训练的卷积语义分割网络的实践教程。阅读本文后,你将能够使用TF服务来部署和向TF训练的深度CNN发出请求等操作。另外,本文将概述TF服务的API及其工作原理。如果你想学习本教程并在计算机上运行示例,请完整了解本文。但是,如果你只想了解TensorFlow服务,你可以专注于前两部分。TensorFlow服务库-概述首先我们需要花一些时间来了解TF Serving如何处理ML模型的整个生命周期。在这里,我们将介绍TF服务的主要构建块,本部分的目标是提供TF服务API的介绍。如需深入了解,请访问TF服务文档页面。TensorFlow服务由一些抽象组成,这些抽象类用于不同任务的API,其中最重要的是Servable,Loader,Source和Manager,让我们来看看他们之间是如何互动的:简单来说,当TF Serving识别磁盘上的模型时,Source组件就开始工作啦,整个服务生命周期也算开始了,Source组件负责识别应加载的新模型。实际上,它会密切关注文件系统,以确定新模型版本何时到达磁盘。当它看到新版本模型时,它会为该特定版本的模型创建一个Loader。总之,Loader几乎了解模型的所有内容,包括如何加载以及如何估计模型所需的资源,例如请求的RAM和GPU内存。Loader还有一个指向磁盘上模型的指针以及用于加载它的所有必要的元数据。但是有一个问题:加载器不允许加载模型。创建Loader后,Source会将其作为Aspired Version发送给Manager。收到模型的Aspired Version后,Manager继续执行服务过程。这里有两种可能性,一个是推送第一个模型版本进行部署,在这种情况下,Manager将确保所需的资源可用,完成后,Manager会授予Loader加载模型的权限;第二是我们推出现有模型的新版本,在这种情况下,管理员必须先咨询版本策略插件,然后再继续操作,版本策略确定如何进行加载新模型版本的过程。具体来说,在第一种情况下,我们可以确保我们的系统始终可用于传入客户的请求。此时,我们同时加载了两个模型版本,只有在加载完成后,Manager才会卸载旧版本,并且可以安全地在模型之间切换。另一方面,如果我们想通过不使用额外缓冲区来节省资源,我们可以选择保留数据。最后,当客户端请求模型的handle时,管理器返回Servable的handle。在接下来的部分中,我们将介绍如何使用TF服务提供卷积神经网络(CNN)。导出服务模型为TensorFlow构建的ML模型提供服务的第一步是确保它的格式正确,为此,TensorFlow提供了SavedModel类。SavedModel是TensorFlow模型的通用序列化格式,如果你熟悉TF,则可以使用TensorFlow Saver来保留模型的变量。TensorFlow Saver提供了将模型的检查点文件保存到磁盘或从磁盘恢复的功能。实际上,SavedModel包装了TensorFlow Saver,它是导出TF模型进行服务的标准方式。SavedModel object有一些很好的功能。首先,它允许你将多个元图保存到单个SavedModel对象,换句话说,它允许我们为不同的任务提供不同的图表。例如,假设你刚刚完成了模型的训练。在大多数情况下,要执行推理,你的图表不需要某些特定于训练的操作。这些操作可能包括优化器的变量,学习速率调度张量,额外的预处理操作等。此外,你可能希望为移动部署提供量化版本的图形。在此环境中,SavedModel允许你使用不同的配置保存图形。在我们的例子中,我们有三个不同的图形和相应的标签,如“训练”、“推理”和“移动”。此外,这三个图形为了提升内存效率还共享相同的变量集。就在不久前,如果我们想在移动设备上部署TF模型时,我们需要知道输入和输出张量的名称,以便向模型提供数据或从模型获取数据。这需要强制程序员在图的所有张量中搜索他们所需的张量。如果张量没有正确命名,那么任务可能非常繁琐。为了简化操作,SavedModel提供对SignatureDefs的支持,SignatureDefs定义了TensorFlow支持的计算的签名。它确定了计算图的正确输入和输出张量,也就是说使用这些签名,你可以指定用于输入和输出的确切节点。要使用其内置的服务API,TF Serving要求模型包含一个或多个SignatureDefs。要创建此类签名,我们需要提供输入,输出和所需方法名称的定义,输入和输出表示从字符串到TensorInfo对象的映射。在这里,我们定义了默认张量,用于向图表输入数据和从图表接收数据。目前,有三种服务API:分类,预测和回归。每个签名定义都与特定的RPC API相匹配,Classification SegnatureDef用于Classify RPC API,Predict SegnatureDef用于Predict RPC API等等依此类推。对于分类签名,必须有输入张量(接收数据)和两个可能的输出张量中的至少一个:类或分数。Regression SignatureDef只需要一个张量用于输入,另一个用于输出。最后,Predict signature允许动态数量的输入和输出张量。此外,SavedModel支持数据存储,以用于ops初始化依赖于外部文件的情况,它还具有在创建SavedModel之前清除设备的机制。现在,让我们看看我们如何在实践中做到这一点。设置环境在开始之前,我们需要从Github克隆此TensorFlow DeepLab-v3。DeepLab是谷歌最好的语义分割ConvNet,网络可以将图像作为输入并输出类似掩模的图像,该图像将某些对象与背景分开。该版本的DeepLab在Pascal VOC分段数据集上进行了训练,因此,它可以分割和识别多达20个类。如果你想了解有关语义分段和DeepLab-v3的更多信息,请查看深入深度卷积语义分段网络和Deeplab_V3。与服务相关的所有文件都存在于:./deeplab_v3/serving/。在那里,你会发现两个重要的文件:deeplab_saved_model.py和deeplab_client.ipynb。在进一步研究之前,请务必下载Deeplab-v3预训练模型。前往上面的GitHub存储库,单击checkpoints链接,你应该有一个名为tboard_logs /的文件夹,其中包含16645 /文件夹。现在,我们需要创建两个Python虚拟环境,一个用于Python 3,另一个用于Python 2,请确保安装必要的依赖项。你可以在serving_requirements.txt和client_requirements.txt文件中找到它们。你可能很好奇为什么需要两个Python env,因为我们的模型DeepLab-v3是在Python 3下开发的,而TensorFlow Serving Python API仅针对Python 2发布。因此,要导出模型并运行TF服务,我们使用Python 3 env 。请注意,你可以使用bazel中的Serving API放弃Python 2 env。有关更多详细信息,请参阅TF服务实例。完成这一步后,让我们从真正重要的事情开始吧。实例教程TensorFlow提供了一个易于使用的高级实用程序类使用SavedModel,类名为SavedModelBuilder。SavedModelBuilder类提供了保存多个元图,关联变量和数据的功能。让我们来看一个如何导出Deep Segmentation CNN模型进行服务的运行示例。如上所述,要导出模型,我们使用啦SavedModelBuilder类。它将生成SavedModel协议缓冲区文件以及模型的变量和资源。让我们剖析一下代码:# Create SavedModelBuilder class# defines where the model will be exportedexport_path_base = FLAGS.export_model_direxport_path = os.path.join( tf.compat.as_bytes(export_path_base), tf.compat.as_bytes(str(FLAGS.model_version)))print(‘Exporting trained model to’, export_path)builder = tf.saved_model.builder.SavedModelBuilder(export_path)SavedModelBuilder接收(作为输入)保存模型数据的目录。这里,export_path变量是为了连接export_path_base和model_version。因此,不同的模型版本将保存在export_path_base文件夹内的单独目录中。假设我们在生产中有我们模型的基础版本,但我们想要部署它的新版本。因为我们已经提高了模型的准确性,并希望为我们的客户提供这个新版本。要导出同一模型的不同版本,我们只需将FLAGS.model_version设置为更高的整数值即可。然后将在export_path_base文件夹中创建一个不同的文件夹(保存我们模型的新版本)。现在,我们需要指定模型的输入和输出Tensors。为此,我们使用SignatureDefs,签名定义了我们要导出的模型类型。它提供了从字符串(逻辑Tensor名称)到TensorInfo对象的映射。我们的想法是,客户端可以引用签名定义的逻辑名称,而不是引用输入/输出的实际张量名称。为了服务语义分段CNN,我们将创建一个预测签名。请注意,build_signature_def()函数采用输入和输出张量的映射以及所需的API。SignatureDef需要指定:输入,输出和方法名称,我们期望输入有三个值:一图像,另外两个张量指定其尺寸(高度和宽度)。对于输出,我们只定义了一个结果-分段输出掩码。# Creates the TensorInfo protobuf objects that encapsulates the input/output tensorstensor_info_input = tf.saved_model.utils.build_tensor_info(input_tensor)tensor_info_height = tf.saved_model.utils.build_tensor_info(image_height_tensor)tensor_info_width = tf.saved_model.utils.build_tensor_info(image_width_tensor)# output tensor infotensor_info_output = tf.saved_model.utils.build_tensor_info(predictions_tf)# Defines the DeepLab signatures, uses the TF Predict API# It receives an image and its dimensions and output the segmentation maskprediction_signature = ( tf.saved_model.signature_def_utils.build_signature_def( inputs={‘images’: tensor_info_input, ‘height’: tensor_info_height, ‘width’: tensor_info_width}, outputs={‘segmentation_map’: tensor_info_output}, method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))请注意,字符串‘image’,‘height’,‘width’和‘segmentation_map’不是张量。相反,它们是引用实际张量input_tensor,image_height_tensor和image_width_tensor的逻辑名称。因此,它们可以是你喜欢的任何唯一字符串。此外,SignatureDefs中的映射与TensorInfo protobuf对象有关,而与实际张量无关。要创建TensorInfo对象,我们使用实用程序函数:tf.saved_model.utils.build_tensor_info(tensor)。现在我们调用add_meta_graph_and_variables()函数来构建SavedModel协议缓冲区对象,然后我们运行save()方法,它会将模型的快照保存到包含模型变量和资源的磁盘。builder.add_meta_graph_and_variables( sess, [tf.saved_model.tag_constants.SERVING], signature_def_map={ ‘predict_images’: prediction_signature, })# export the modelbuilder.save(as_text=True)print(‘Done exporting!’)现在我们可以运行deeplab_saved_model.py来导出我们的模型。如果一切顺利,你将看到文件夹./serving/versions/1,请注意,“1”表示模型的当前版本。在每个版本子目录中,你将看到以下文件:·saved_model.pb或saved_model.pbtxt,这是序列化的SavedModel文件。它包括模型的一个或多个图形定义,以及签名定义。·变量,该文件夹包含图形的序列化变量。现在,我们已准备好启动我们的模型服务器。为此,请运行:$ tensorflow_model_server –port=9000 –model_name=deeplab –model_base_path=<full/path/to/serving/versions/>该model_base_path指的是输出模型保存,另外,我们不在路径中指定版本文件夹,模型版本控制由TF服务处理。生成客户端请求客户端代码非常简单,看一下:deeplab_client.ipynb。首先,我们读取要发送到服务器的图像并将其转换为正确的格式。接下来,我们创建一个gRPC存根,存根允许我们调用远程服务器的方法。为此,我们将实例化prediction_service_pb2模块的beta_create_PredictionService_stub类。此时,存根保持调用远程过程的必要逻辑,就像它们是本地的一样。现在,我们需要创建和设置请求对象。由于我们的服务器实现了TensorFlow Predict API,因此我们需要解析Predict请求。要发出Predict请求,首先,我们从predict_pb2模块中实例化PredictRequest类。我们还需要指定model_spec.name和model_spec.signature_name参数。该名称参数是当我们推出的服务器定义的“模型名称”的说法,而signature_name是指分配给逻辑名称signature_def_map()的参数add_meta_graph()函数。# create the RPC stubchannel = implementations.insecure_channel(host, int(port))stub = prediction_service_pb2.beta_create_PredictionService_stub(channel)# create the request object and set the name and signature_name paramsrequest = predict_pb2.PredictRequest()request.model_spec.name = ‘deeplab’request.model_spec.signature_name = ‘predict_images’# fill in the request object with the necessary datarequest.inputs[‘images’].CopyFrom( tf.contrib.util.make_tensor_proto(image.astype(dtype=np.float32), shape=[1, height, width, 3]))request.inputs[‘height’].CopyFrom(tf.contrib.util.make_tensor_proto(height, shape=[1]))request.inputs[‘width’].CopyFrom(tf.contrib.util.make_tensor_proto(width, shape=[1]))接下来,我们必须提供服务器签名中定义的输入数据。请记住,在服务器中,我们定义了一个Predict API来预期图像以及两个标量(图像的高度和宽度)。为了将输入数据提供给请求对象,TensorFlow提供了实用程序tf.make_tensor_proto(),此方法是从Python/numpy创建的TensorProto对象,我们可以使用它将图像及其尺寸提供给请求对象。看起来我们已经准备好调用服务器了。为此,我们调用Predict()方法(使用存根)并将请求对象作为参数传递。gRPC支持:同步和异步调用。因此,如果你在处理请求时想要做一些工作,我们可以调用Predict.future()而不是Predict()。# sync requestsresult_future = stub.Predict(request, 30.)# For async requests# result_future = stub.Predict.future(request, 10.)# Do some work…# result_future = result_future.result()现在我们可以获取并享受结果。本文作者:【方向】阅读原文本文为云栖社区原创内容,未经允许不得转载。 ...

March 27, 2019 · 1 min · jiezi

TensorFlow读写数据

前言只有光头才能变强。文本已收录至我的GitHub仓库,欢迎Star:https://github.com/ZhongFuCheng3y/3y回顾前面:从零开始学TensorFlow【01-搭建环境、HelloWorld篇】什么是TensorFlow?众所周知,要训练出一个模型,首先我们得有数据。我们第一个例子中,直接使用dataset的api去加载mnist的数据。(minst的数据要么我们是提前下载好,放在对应的目录上,要么就根据他给的url直接从网上下载)。一般来说,我们使用TensorFlow是从TFRecord文件中读取数据的。TFRecord 文件格式是一种面向记录的简单二进制格式,很多 TensorFlow 应用采用此格式来训练数据所以,这篇文章来聊聊怎么读取TFRecord文件的数据。一、入门对数据集的数据进行读和写首先,我们来体验一下怎么造一个TFRecord文件,怎么从TFRecord文件中读取数据,遍历(消费)这些数据。1.1 造一个TFRecord文件现在,我们还没有TFRecord文件,我们可以自己简单写一个:def write_sample_to_tfrecord(): gmv_values = np.arange(10) click_values = np.arange(10) label_values = np.arange(10) with tf.python_io.TFRecordWriter("/Users/zhongfucheng/data/fashin/demo.tfrecord", options=None) as writer: for _ in range(10): feature_internal = { “gmv”: tf.train.Feature(float_list=tf.train.FloatList(value=[gmv_values[]])), “click”: tf.train.Feature(int64_list=tf.train.Int64List(value=[click_values[]])), “label”: tf.train.Feature(int64_list=tf.train.Int64List(value=[label_values[_]])) } features_extern = tf.train.Features(feature=feature_internal) # 使用tf.train.Example将features编码数据封装成特定的PB协议格式 # example = tf.train.Example(features=tf.train.Features(feature=features_extern)) example = tf.train.Example(features=features_extern) # 将example数据系列化为字符串 example_str = example.SerializeToString() # 将系列化为字符串的example数据写入协议缓冲区 writer.write(example_str)if name == ‘main’: write_sample_to_tfrecord()我相信大家代码应该是能够看得懂的,其实就是分了几步:生成TFRecord Writertf.train.Feature生成协议信息使用tf.train.Example将features编码数据封装成特定的PB协议格式将example数据系列化为字符串将系列化为字符串的example数据写入协议缓冲区参考资料:https://zhuanlan.zhihu.com/p/31992460ok,现在我们就有了一个TFRecord文件啦。1.2 读取TFRecord文件其实就是通过tf.data.TFRecordDataset这个api来读取到TFRecord文件,生成处dataset对象对dataset进行处理(shape处理,格式处理…等等)使用迭代器对dataset进行消费(遍历)demo代码如下:import tensorflow as tfdef read_tensorflow_tfrecord_files(): # 定义消费缓冲区协议的parser,作为dataset.map()方法中传入的lambda: def _parse_function(single_sample): features = { “gmv”: tf.FixedLenFeature([1], tf.float32), “click”: tf.FixedLenFeature([1], tf.int64), # ()或者[]没啥影响 “label”: tf.FixedLenFeature([1], tf.int64) } parsed_features = tf.parse_single_example(single_sample, features=features) # 对parsed 之后的值进行cast. gmv = tf.cast(parsed_features[“gmv”], tf.float64) click = tf.cast(parsed_features[“click”], tf.float64) label = tf.cast(parsed_features[“label”], tf.float64) return gmv, click, label # 开始定义dataset以及解析tfrecord格式 filenames = tf.placeholder(tf.string, shape=[None]) # 定义dataset 和 一些列trasformation method dataset = tf.data.TFRecordDataset(filenames) parsed_dataset = dataset.map(_parse_function) # 消费缓冲区需要定义在dataset 的map 函数中 batchd_dataset = parsed_dataset.batch(3) # 创建Iterator sample_iter = batchd_dataset.make_initializable_iterator() # 获取next_sample gmv, click, label = sample_iter.get_next() training_filenames = [ “/Users/zhongfucheng/data/fashin/demo.tfrecord”] with tf.Session() as session: # 初始化带参数的Iterator session.run(sample_iter.initializer, feed_dict={filenames: training_filenames}) # 读取文件 print(session.run(gmv))if name == ‘main’: read_tensorflow_tfrecord_files()无意外的话,我们可以输出这样的结果:[[0.] [1.] [2.]]ok,现在我们已经大概知道怎么写一个TFRecord文件,以及怎么读取TFRecord文件的数据,并且消费这些数据了。二、epoch和batchSize术语解释我在学习TensorFlow翻阅资料时,经常看到一些机器学习的术语,由于自己没啥机器学习的基础,所以很多时候看到一些专业名词就开始懵逼了。2.1epoch当一个完整的数据集通过了神经网络一次并且返回了一次,这个过程称为一个epoch。这可能使我们跟dataset.repeat()方法联系起来,这个方法可以使当前数据集重复一遍。比如说,原有的数据集是[1,2,3,4,5],如果我调用dataset.repeat(2)的话,那么我们的数据集就变成了[1,2,3,4,5],[1,2,3,4,5]所以会有个说法:假设原先的数据是一个epoch,使用repeat(5)就可以将之变成5个epoch2.2batchSize一般来说我们的数据集都是比较大的,无法一次性将整个数据集的数据喂进神经网络中,所以我们会将数据集分成好几个部分。每次喂多少条样本进神经网络,这个叫做batchSize。在TensorFlow也提供了方法给我们设置:dataset.batch(),在API中是这样介绍batchSize的:representing the number of consecutive elements of this dataset to combine in a single batch我们一般在每次训练之前,会将整个数据集的顺序打乱,提高我们模型训练的效果。这里我们用到的api是:dataset.shffle();三、再来聊聊dataset我从官网的介绍中截了一个dataset的方法图(部分):dataset的功能主要有以下三种:创建dataset实例通过文件创建(比如TFRecord)通过内存创建对数据集的数据进行变换比如上面的batch(),常见的map(),flat_map(),zip(),repeat()等等文档中一般都有给出例子,跑一下一般就知道对应的意思了。创建迭代器,遍历数据集的数据3.1 聊聊迭代器迭代器可以分为四种:单次。对数据集进行一次迭代,不支持参数化可初始化迭代使用前需要进行初始化,支持传入参数。面向的是同一个DataSet可重新初始化:同一个Iterator从不同的DataSet中读取数据DataSet的对象具有相同的结构,可以使用tf.data.Iterator.from_structure来进行初始化问题:每次 Iterator 切换时,数据都从头开始打印了可馈送(也是通过对象相同的结果来创建的迭代器)可让您在两个数据集之间切换的可馈送迭代器通过一个string handler来实现。可馈送的 Iterator 在不同的 Iterator 切换的时候,可以做到不从头开始。简单总结:1、 单次 Iterator ,它最简单,但无法重用,无法处理数据集参数化的要求。2、 可以初始化的 Iterator ,它可以满足 Dataset 重复加载数据,满足了参数化要求。3、可重新初始化的 Iterator,它可以对接不同的 Dataset,也就是可以从不同的 Dataset 中读取数据。4、可馈送的 Iterator,它可以通过 feeding 的方式,让程序在运行时候选择正确的 Iterator,它和可重新初始化的 Iterator 不同的地方就是它的数据在不同的 Iterator 切换时,可以做到不重头开始读取数据。string handler(可馈送的 Iterator)这种方式是最常使用的,我当时也写了一个Demo来使用了一下,代码如下:def read_tensorflow_tfrecord_files(): # 开始定义dataset以及解析tfrecord格式. train_filenames = tf.placeholder(tf.string, shape=[None]) vali_filenames = tf.placeholder(tf.string, shape=[None]) # 加载train_dataset batch_inputs这个方法每个人都不一样的,这个方法我就不给了。 train_dataset = batch_inputs([ train_filenames], batch_size=5, type=False, num_epochs=2, num_preprocess_threads=3) # 加载validation_dataset batch_inputs这个方法每个人都不一样的,这个方法我就不给了。 validation_dataset = batch_inputs([vali_filenames ], batch_size=5, type=False, num_epochs=2, num_preprocess_threads=3) # 创建出string_handler()的迭代器(通过相同数据结构的dataset来构建) handle = tf.placeholder(tf.string, shape=[]) iterator = tf.data.Iterator.from_string_handle( handle, train_dataset.output_types, train_dataset.output_shapes) # 有了迭代器就可以调用next方法了。 itemid = iterator.get_next() # 指定哪种具体的迭代器,有单次迭代的,有初始化的。 training_iterator = train_dataset.make_initializable_iterator() validation_iterator = validation_dataset.make_initializable_iterator() # 定义出placeholder的值 training_filenames = [ “/Users/zhongfucheng/tfrecord_test/data01aa”] validation_filenames = ["/Users/zhongfucheng/tfrecord_validation/part-r-00766"] with tf.Session() as sess: # 初始化迭代器 training_handle = sess.run(training_iterator.string_handle()) validation_handle = sess.run(validation_iterator.string_handle()) for _ in range(2): sess.run(training_iterator.initializer, feed_dict={train_filenames: training_filenames}) print(“this is training iterator —-”) for _ in range(5): print(sess.run(itemid, feed_dict={handle: training_handle})) sess.run(validation_iterator.initializer, feed_dict={vali_filenames: validation_filenames}) print(“this is validation iterator “) for _ in range(5): print(sess.run(itemid, feed_dict={vali_filenames: validation_filenames, handle: validation_handle}))if name == ‘main’: read_tensorflow_tfrecord_files()参考资料:https://blog.csdn.net/briblue/article/details/809627283.2 dataset参考资料在翻阅资料时,发现写得不错的一些博客:https://www.jianshu.com/p/91803a119f18https://irvingzhang0512.github.io/2018/04/19/tensorflow-api-2/http://www.feiguyunai.com/index.php/2017/12/25/pyhtonai-ml-dataprocess-datasetapi/最后乐于输出干货的Java技术公众号:Java3y。公众号内有200多篇原创技术文章、海量视频资源、精美脑图,不妨来关注一下!下一篇文章打算讲讲如何理解axis~觉得我的文章写得不错,不妨点一下赞! ...

March 16, 2019 · 2 min · jiezi