AVh  dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#eddddddddd Z$dde#e!e$fde#e!e$ffdZ%edejLe%Z'de#e!e$fde#e!e$ffdZ(eddd d!dddddddd"d#d$d%d&d'd(d)d*Z)dd+e#e e!e)fde#e!e)ffd,Z*ed-ejLe*Z+d+e#e e!e)fde#e!e)ffd.Z,ed/dd d!dddZ-dde#e!e-fde#e!e-ffd0Z.ed1ejLe.Z/de#e!e-fde#e!e-ffd2Z0ed3dd d!dddZ1ejdejfed4d5dde#e!e1fde#e!e1ffd6Z4ed7ejLe4Z5e4jljnZ8de#e!e1fde#e!e1ffd8Z9ed9dd d!dddddddd:d* Z:dde#e!e:fd;e#e!e:fde#e!e:ffd<Z;ed=ejLe;ZZ=ed?dd d!dddddddd"d#d$d%d&d'd(d)d*d@Z>dd+e#e e!e>fde#e!e>ffdAZ?edBejLe?Z@d+e#e e!e>fde#e!e>ffdCZAedDdd d!dddddddd'd(d)d*ZBdde#e!eBfd;e#e!eBfde#e!eBffdEZCedFejLeCZDde#e!eBfd;e#e!eBfde#e!eBffdGZEedHddZFddJe#e!ejfdKe#e!eFfdLeHde#e!ejffdMZIedNejLeIZJdJe#e!ejfdKe#e!eFfdLeHde#e!ejffdOZKedPd d!ZLedQddZMe jdfdJe#e!eLfdReMde#e!eMffdSZOedTejLeOZPdJe#e!eLfdReMde#e!eMffdUZQedVddZRddJe#e!ejfdKe#e!eRfdLeHde#e!ejffdWZSedXejLeSZ!dJe#e!ejfdKe#e!eRfdLeHde#e!ejffdYZTedZdd d!dddddddd"d#d$d%d&d'd(d)d*ZUdde#e!eUfd;e#e!eUfd[eVde#e!ejffd\ZWed]ejLeWZXde#e!eUfd;e#e!eUfd[eVde#e!ejffd^ZYed_dd`dddddddd"d#d$d%d&d'd(d)d*ZZedadddZ[edbdddd'Z\e jdfdJe#e!eZfdce#e!e[fdde\de#e!e\ffdeZ^edfejLe^Z_dJe#e!eZfdce#e!e[fdde\de#e!e\ffdgZ`edhdd`dddddddd"d#d$d%d&d'd(d)d*ZaediddZbedjddZce jdfdJe#e!eafdce#e!ebfddecde#e!ecffdkZdedlejLedZedJe#e!eafdce#e!ebfddecde#e!ecffdmZfedndd d!dddZgejdejfedodpdde#e!egfde#e!egffdqZhedrejLehZiehjljnZjde#e!egfde#e!egffdsZkedtdd d!dddZlejdejfedudvdde#e!elfde#e!elffdwZmedxejLemZnemjljnZode#e!elfde#e!elffdyZpedzdd d!dddZqejdejfed{d|dde#e!eqfde#e!eqffd}Zred~ejLerZserjljnZtde#e!eqfde#e!eqffdZuedddddZvejdejfedddd;e#e!evfde#e!evfde#e!evffdZwedejLewZxewjljnZyd;e#e!evfde#e!evfde#e!evffdZzeddd d!dddZ{ejdejfedddde#e!e{fde#e!e{ffdZ|edejLe|Z}e|jljnZ~de#e!e{fde#e!e{ffdZeddd d!ddddd Zdde#e!efd;e#e!efdeHdeHdeHdeHde#e!effdZedejLeZde#e!efd;e#e!efdeHdeHdeHdeHde#e!effdZeddd d!ddddddd'd(d)d*Zdde#e!efd;e#e!efdeHdeHdeHdeHde#e!effdZedejLeZde#e!efd;e#e!efdeHdeHdeHdeHde#e!effdZeddd d!dddddddd* Zeddd d!dddddddd* Zeddd d!dddddd Zdde#e!efd;e#e!efdRedeHdeHdeHdeHde#e!effdZedejLeZde#e!efd;e#e!efdRedeHdeHdeHdeHde#e!effdZedddZejdejfedddgeddde#e!efde#e!efde#e!efde#e!effdZedejLeZejljnZde#e!efde#e!efde#e!efde#e!effdZedddddZdde#e!ej(fde#e!ej(fde#e!efde#e!effdZedejLeZde#e!ej(fde#e!ej(fde#e!efde#e!effdZedddddZddJe#e!efde#e!ej(ffdZedejLeZdJe#e!efde#e!ej(ffdZedZedZdde#e!efdedeHde#e!effdZedejLeZde#e!efdedeHde#e!effdZedddddZdde#e!efde#e!effdZedejLeZde#e!efde#e!effdZeddd d!dddddddd"d#d$d%d&d'd(d)d*Zdde#e!efde#e!efde#e!efde#e!effdZed«ejLeZde#e!efde#e!efde#e!efde#e!effdÄZedddZedd d!Ze jVdfde#e!efde#e!efdRede#e!effdȄZedɫejLeZde#e!efde#e!efdRede#e!effdʄZedd d!ZedddZe jdfde#e!efdRede#e!effd̈́ZedΫejLeZde#e!efdRede#e!effdτZedd d!d@ZddJe#e!efde#e!effdфZedҫejLeZdJe#e!efde#e!effdӄZeddd d!dddZejdejfedd֫dde#e!efde#e!effdׄZedثejLeZejljnZde#e!efde#e!effdلZeddd d!dddZejdejfeddܫdde#e!efde#e!effd݄ZedޫejLeZejljnZde#e!efde#e!effd߄Zedddddddddd'd(d)d* Zejdejfedddgeddde#e!efde#e!efde#e!effdZedejLeëZejljnZde#e!efde#e!efde#e!effdZeddd d!dddddddd"d#d$d%d&d'd(d)d*ZedddZȐdde#e!efdKe#e!efdeHdeHde#e!eff dZedejLeɫZde#e!efdKe#e!efdeHdeHde#e!eff dZeddd d!dddddddd"d#d$d%d&d'd(d)d*ZedddZ͐dde#e!efdKe#e!efdeHdeHde#e!eff dZedejLeΫZde#e!efdKe#e!efdeHdeHde#e!eff dZedddddZedddZҐdde#e!efdKe#e!efdeHdeHde#e!eff dZedejLeӫZde#e!efdKe#e!efdeHdeHde#e!eff dZedddZedddddZאddJe#e!efde#e!efde#e!efdeHde#e!eff dZedejLeثZdJe#e!efde#e!efde#e!efdeHde#e!eff dZedddddZejdejfedddgeddde#e!efde#e!effdZedejLeܫZejljnZde#e!efde#e!effdZeddd d!dddddddd'd(d)d*Zdde#e!efd;e#e!efde#e!effdZedejLeZde#e!efd;e#e!efde#e!effdZeddd d!dddZdde#e!efd;e#e!efde#e!effdZed ejLeZde#e!efd;e#e!efde#e!effd Zed Zdde#e!efd;e#e!efd eHde#e!ejffd ZedejLeZde#e!efd;e#e!efd eHde#e!ejffdZedddddZejdejfedddgeddde#e!efde#e!effdZedejLeZejljnZde#e!efde#e!effdZedddddZejdejfedddgeddde#e!efde#e!effdZedejLeZejljnZde#e!efde#e!effdZedddddZdde#e!efde#e!effdZedejLeZde#e!efde#e!effdZed dd d!dddddddd"d#d$d%d&d'd(d)d*Zed!ddZddJe#e!efdKe#e!efdLeHde#e!effd"Zed#ejLeZdJe#e!efdKe#e!efdLeHde#e!effd$Zed%dd d!dddZdde#e!efde#e!effd&Zed'ejLeZde#e!efde#e!effd(Zed)dd d!dddZejdejfed*d*d+ged+dde#e!efde#e!effd,Zed-ejLeZejljnZde#e!efde#e!effd.Zed/ddddZdde#e!efde#e!effd0Z ed1ejLe Z de#e!efde#e!effd2Z ed3dd d!dddddddd'd(d)d*Z ejdejfed4ged4dde#e!e fd;e#e!e fde#e!e ffd5Z ed6ejLe Ze jljnZde#e!e fd;e#e!e fde#e!e ffd7Zed8ddddddddd'd(d)d* Zejdejfed9d:gd;ed<d=dde#e!efd;e#e!efde#e!effd>Zed?ejLeZejljnZde#e!efd;e#e!efde#e!effd@ZedAddddddddd'd(d)d* ZejdejfedBdCdde#e!efd;e#e!efde#e!ejffdDZedEejLeZejljnZde#e!efd;e#e!efde#e!ejffdFZedGddddddddd'd(d)d* ZejdejfedHdIdde#e!efd;e#e!efde#e!ejffdJZedKejLeZejljnZde#e!efd;e#e!efde#e!ejffdLZedMddddZ edNddZ!e jDdfdOe#e!e fdPe#e!e fdQe#e!ej(fdRe!de#e!e!ff dSZ#edTejLe#Z$dOe#e!e fdPe#e!e fdQe#e!ej(fdRe!de#e!e!ff dUZ%edVddddZ&ejdejfedWdWdXgedXdde#e!e&fde#e!e&fde#e!e&ffdYZ'edZejLe'Z(e'jljnZ)de#e!e&fde#e!e&fde#e!e&ffd[Z*ed\ddZ+dde#e!e+fde#e!e+fde#e!e+ffd]Z,ed^ejLe,Z-de#e!e+fde#e!e+fde#e!e+ffd_Z.ed`ddddZ/ejdejfedadadbgedbdde#e!e/fde#e!e/fde#e!e/ffdcZ0eddejLe0Z1e0jljnZ2de#e!e/fde#e!e/fde#e!e/ffdeZ3edfd d!Z4edgddZ5e jdfdJe#e!e4fdRe5de#e!e5ffdhZ6ediejLe6Z7dJe#e!e4fdRe5de#e!e5ffdjZ8edkdd d!ddddddd Z9dde#e!e9fde#e!e9ffdlZ:edmejLe:Z;de#e!e9fde#e!e9ffdnZ<edodd d!dddZ=dd;e#e!e=fdpe#e!e=fde#e!e=ffdqZ>edrejLe>Z?d;e#e!e=fdpe#e!e=fde#e!e=ffdsZ@edtddddZAejdejfedugdvedwdxdde#e!eAfde#e!ejffdyZBedzejLeBZCeBjljnZDde#e!eAfde#e!ejffd{ZEed|ddddZFejdejfed}gd~edddde#e!eFfde#e!ejffdZGedejLeGZHeGjljnZIde#e!eFfde#e!ejffdZJedddddZKejdejfedgdedddde#e!eKfde#e!ejffdZLedejLeLZMeLjljnZNde#e!eKfde#e!ejffdZOedddddddddd'd(d)d* ZPejdejfedddde#e!ePfd;e#e!ePfde#e!ejffdZQedejLeQZReQjljnZSde#e!ePfd;e#e!ePfde#e!ejffdZTedddddddddd'd(d)d* ZUejdejfedddde#e!eUfd;e#e!eUfde#e!ejffdZVedejLeVZWeVjljnZXde#e!eUfd;e#e!eUfde#e!ejffdZYedddddZZejdejfedddgeddde#e!eZfde#e!eZffdZ[edejLe[Z\e[jljnZ]de#e!eZfde#e!eZffdZ^edddddZ_edddZ`dde#e!e_fde#e!e_fde#e!e`fde#e!e_ffdZaedejLeaZbde#e!e_fde#e!e_fde#e!e`fde#e!e_ffdZceddd d!dddZdejdejfedddgeddde#e!edfde#e!edffdZeedejLeeZfeejljnZgde#e!edfde#e!edffdZheddd d!dddZiejdejfedddgeddde#e!eifde#e!eiffdZjedejLejZkejjljnZlde#e!eifde#e!eiffdZmejdejfedddde#e!ejfd;e#e!ejfde#e!ejffdZnedejLenZoenjljnZpde#e!ejfd;e#e!ejfde#e!ejffdZqejdejfedddde#e!ejfde#e!ejffdZredejLerZserjljnZtde#e!ejfde#e!ejffdZuejdejfedddde#e!ejfd;e#e!ejfde#e!ejffdZvedejLevZwevjljnZxde#e!ejfd;e#e!ejfde#e!ejffdZyeddd d!dddddd'd(d)d* Zzdde#e!ezfde#e!ezfdeHdeHdeHdeHde#e!ezffdƄZ{edǫejLe{Z|de#e!ezfde#e!ezfdeHdeHdeHdeHde#e!ezffdȄZ}edddddddddd"d#d$d%d&d'd(d)d*Z~edddZddJe#e!e~fdKe#e!efdLeHde#e!e~ffd˄Zed̫ejLeZdJe#e!e~fdKe#e!efdLeHde#e!e~ffd̈́Zedddddddddd'd(d)d* ZejdejfedϐdЫdde#e!efd;e#e!efde#e!effdфZedҫejLeZejljnZde#e!efd;e#e!efde#e!effdӄZeddd d!dddddddd"d#d$d%d&d'd(d)d*ZedddZddJe#e!efdKe#e!efdLeHde#e!effdքZed׫ejLeZdJe#e!efdKe#e!efdLeHde#e!effd؄Zedddddddddd"d#d$d%d&d'd(d)d*ZedddZddJe#e!efdKe#e!efdLeHde#e!effdۄZedܫejLeZdJe#e!efdKe#e!efdLeHde#e!effd݄Zedddddddddd'd(d)d* Zejdejfedߐddde#e!efd;e#e!efde#e!effdZedejLeZejljnZde#e!efd;e#e!efde#e!effdZeddddddddZdde#e!efd;e#e!efde#e!effdZedejLeZde#e!efd;e#e!efde#e!effdZeddd d!dddddddd'd(d)d*Zdde#e!efd;e#e!efde#e!effdZedejLeZde#e!efd;e#e!efde#e!effdZeddd d!dddZdde#e!efd;e#e!efde#e!effdZedejLeZde#e!efd;e#e!efde#e!effdZedddddZdde#e!efde#e!effdZedejLeZde#e!efde#e!effdZeddd d!ddddddd Zejdejfedddde#e!efde#e!effdZedejLeZejljnZde#e!efde#e!effdZedddZejdejfeddde#e!efde#e!efde#e!effdZedejLeZejljnZde#e!efde#e!efde#e!effdZedZdde#e!efd;e#e!efd eHde#e!ejffdZedejLeZde#e!efd;e#e!efd eHde#e!ejffdZedddZejdejfedddgeddde#e!efde#e!efde#e!effdZed ejLeZejljnZde#e!efde#e!efde#e!effd Zed dd d!ddddddd Zdde#e!efd;e#e!efde#e!effd Zed ejLeZde#e!efd;e#e!efde#e!effdZeddd d!dddddddd"d#d$d%d&d'd(d)d*ZedddZddJe#e!efdKe#e!efdLeHde#e!effdZedejLeZdJe#e!efdKe#e!efdLeHde#e!effdZejdgdZedd"d#d$d%d&Zedd"d#d$d%d&ZƐddJe#e!efde#e!ejfde#e!ejfdefdZedejLeȫZdJe#e!efde#e!ejfde#e!ejfdefdZejdgdZed d"d#d$d%d&Zed!d"d#d$d%d&Zed"d"d#d$d%d&Ze jdfde#e!efd;e#e!efd#e#e!ejfd$e#e!ejfd%e#e!ejfd&e#e!ejfd'efd(Zed)ejLeЫZde#e!efd;e#e!efd#e#e!ejfd$e#e!ejfd%e#e!ejfd&e#e!ejfd'efd*Zejd+gd,Zed-d"d#d$d%d&Zed.d"d#d$d%d&Zed/d"d#d$d%d&Zed0d"d#d$d%d&Ze jdIdIe jdfde#e!efde#e!efd1e#e!ejfd2e#e!ejfd3e#e!ejfd4e#e!ejfd'e֐deHdeHd5efd6Zed7ejLe٫Zde#e!efde#e!efd1e#e!ejfd2e#e!ejfd3e#e!ejfd4e#e!ejfd'e֐deHdeHd5efd8Zejd9gdZed:d"d#d$d%d&Zed;d"d#d$d%d&ZedejLeZde#e!efd;e#e!efd#e#e!ejfd$e#e!ejfd%e#e!ejfd&e#e!ejfd'efd?Zed@ddZedAddddZddBe#e!ejfdOe#e!efde#e!efde#e!efdeHde#e!eff dCZedDejLeZdBe#e!ejfdOe#e!efde#e!efde#e!efdeHde#e!eff dEZedFddddddddd'd( Zdde#e!efdGe#e!efdHe#e!efde#e!effdIZedJejLeZde#e!efdGe#e!efdHe#e!efde#e!effdKZedLd d!ZedMddZe jdfdJe#e!efdRede#e!effdNZedOejLeZdJe#e!efdRede#e!effdPZedQdd d!dddddddd'd(d)d*ZejdejfedRdde#e!efd;e#e!efde#e!effdSZedTejLeZejljnZde#e!efd;e#e!efde#e!effdUZedVdd d!ddddddd ZejdejfedWdWdXgedXdde#e!efde#e!effdYZedZejLeZejljnZde#e!efde#e!effd[Zed\dd d!dddZdd;e#e!efdpe#e!efde#e!effd]Zed^ejLeZd;e#e!efdpe#e!efde#e!effd_Zejd`dadbgZedcd"d#d$d%d&ZddJe#e!efde#e!ejfde#e!ejffddZedeejLeZdJe#e!efde#e!ejfde#e!ejffdfZejdgdadbgZedhd"d#d$d%d&ZddJe#e!efde#e!ejfde#e!ejfdeVfdiZedjejLeZdJe#e!efde#e!ejfde#e!ejfdeVfdkZ ejdlgdZ edmd"d#d$d%d&Z ednd"d#d$d%d&Z ddJe#e!e fde#e!ejfde#e!ejfdoe#e!ejfdpe#e!ejfde f dqZ edrejLe ZdJe#e!e fde#e!ejfde#e!ejfdoe#e!ejfdpe#e!ejfde f dsZejdtgdZedud"d#d$d%d&Zedvd"d#d$d%d&Ze jdfdJe#e!efde#e!ejfde#e!ejfdoe#e!ejfdpe#e!ejfdef dwZedxejLeZdJe#e!efde#e!ejfde#e!ejfdoe#e!ejfdpe#e!ejfdef dyZedzddddZejdejfed{d{d|ged|dde#e!efde#e!effd}Zed~ejLeZejljnZde#e!efde#e!effdZeddd d!ddddddd Zdde#e!efde#e!effdZedejLeZde#e!efde#e!effdZeddd d!dddZdde#e!efde#e!effdZ edejLe Z!de#e!efde#e!effdZ"eddd d!dddZ#dd;e#e!e#fdpe#e!e#fde#e!e#ffdZ$edejLe$Z%d;e#e!e#fdpe#e!e#fde#e!e#ffdZ&edddddddddd'd(d)d* Z'edddZ(ejdejfedddgeddde#e!e'fde#e!e(fde#e!e'ffdZ)edejLe)Z*e)jljnZ+de#e!e'fde#e!e(fde#e!e'ffdZ,edddddddddd'd(d)d* Z-edddZ.edddZ/dde#e!e-fde#e!e.fde#e!e/fde#e!e-ffdZ0edejLe0Z1de#e!e-fde#e!e.fde#e!e/fde#e!e-ffdZ2eddd d!dddddddd"d#d$d%d&d'd(d)d*Z3edddZ4ejdejfedddgeddde#e!e3fde#e!e4fde#e!e3ffdZ5edejLe5Z6e5jljnZ7de#e!e3fde#e!e4fde#e!e3ffdZ8edddddddddd'd(d)d* Z9edddZ:ejdejfedddgeddde#e!e9fde#e!e:fde#e!e9ffdZ;edejLe;Z<e;jljnZ=de#e!e9fde#e!e:fde#e!e9ffdZ>edddddddddd'd(d)d* Z?edddZ@edddZAdde#e!e?fde#e!e@fde#e!eAfde#e!e?ffdZBedejLeBZCde#e!e?fde#e!e@fde#e!eAfde#e!e?ffdZDeddd d!dddddddd"d#d$d%d&d'd(d)d*ZEedddZFejdejfedddgeddde#e!eEfde#e!eFfde#e!eEffdZGedejLeGZHeGjljnZIde#e!eEfde#e!eFfde#e!eEffdZJeddd d!dddddddd"d#d$d%d&d'd(d)d*ZKedddZLedddZMdde#e!eKfde#e!eLfde#e!eMfde#e!eKffdZNedejLeNZOde#e!eKfde#e!eLfde#e!eMfde#e!eKffdZPeddd d!dddddddd"d#d$d%d&d'd(d)d*ZQedddZRejdejfedddgeddde#e!eQfde#e!eRfde#e!eQffdZSed«ejLeSZTeSjljnZUde#e!eQfde#e!eRfde#e!eQffdÄZVeddd d!dddddddd"d#d$d%d&d'd(d)d*ZWedddZXedddZYdde#e!eWfde#e!eXfde#e!eYfde#e!eWffdDŽZZedȫejLeZZ[de#e!eWfde#e!eXfde#e!eYfde#e!eWffdɄZ\edʎZ]dde#e!ejfde#e!e]fd;e#e!e]fde#e!e]ffd̄Z^edͫejLe^Z_de#e!ejfde#e!e]fd;e#e!e]fde#e!e]ffd΄Z`edώZadde#e!ejfde#e!eafde#e!eafde#e!eaffdфZbedҫejLebZcde#e!ejfde#e!eafde#e!eafde#e!eaffdӄZdeddd d!dddZedde#e!eefde#e!eeffdՄZfed֫ejLefZgde#e!eefde#e!eeffdׄZheddd d!dddZidd;e#e!eifdpe#e!eifde#e!eiffdلZjedګejLejZkd;e#e!eifdpe#e!eifde#e!eiffdۄZleddd d!ddddddd Zmdde#e!emfde#e!emffd݄ZnedޫejLenZode#e!emfde#e!emffd߄Zpeddd d!dddZqejdejfedddde#e!eqfde#e!eqffdZredejLerZserjljnZtde#e!eqfde#e!eqffdZueddd d!dddZvejdejfedddde#e!evfde#e!evffdZwedejLewZxewjljnZyde#e!evfde#e!evffdZzedddZ{e jdfde#e!ej(fde#e!ej(fde#e!ej(fdRe{de#e!e{ff dZ|edejLe|Z}de#e!ej(fde#e!ej(fde#e!ej(fdRe{de#e!e{ff dZ~edddZedddddZdde#e!ejfdOe#e!efde#e!ejfde#e!efde#e!efdeHde#e!effdZedejLeZde#e!ejfdOe#e!efde#e!ejfde#e!efde#e!efdeHde#e!effdZedddZedddZdde#e!efde#e!efdeHdeHdeHdeHde#e!ejffdZedejLeZde#e!efde#e!efdeHdeHdeHdeHde#e!ejffdZedddddZedddZedddZdde#e!efde#e!efde#e!efdeHde#e!eff dZedejLeZde#e!efde#e!efde#e!efdeHde#e!eff dZedddddZed ddZed ddZdd e#e!efde#e!efde#e!efd e#e!ej(fde#e!eff d ZedejLeZd e#e!efde#e!efde#e!efd e#e!ej(fde#e!eff dZejdddgZedddddZedddZedddZdd e#e!efde#e!efde#e!efde#e!ej(ffdZedejLeZd e#e!efde#e!efde#e!efde#e!ej(ffdZedddddZedddZedddZedddZdde#e!efde#e!efde#e!efde#e!efdeHde#e!eff dZedejLeZde#e!efde#e!efde#e!efde#e!efdeHde#e!eff d Zed!ddddZed"ddZed#ddZdde#e!efde#e!efde#e!efdeHde#e!eff d$Zed%ejLeZde#e!efde#e!efde#e!efdeHde#e!eff d&Zed'ddddZed(ddZed)ddZdd e#e!efde#e!efde#e!efd e#e!ej(fde#e!eff d*Zed+ejLeZd e#e!efde#e!efde#e!efd e#e!ej(fde#e!eff d,Zejd-ddgZed.ddddZed/ddZed0ddZdd e#e!efde#e!efde#e!efde#e!ej(ffd1Zed2ejLeZd e#e!efde#e!efde#e!efde#e!ej(ffd3Zed4ddddZed5ddZed6ddZed7ddZdde#e!efde#e!efde#e!efde#e!efdeHde#e!eff d8Zed9ejLeZde#e!efde#e!efde#e!efde#e!efdeHde#e!eff d:Zed;ddddddddd'd(d)d* ZedZed?ejLeZde#e!efde#e!efde#e!efdeHde#e!eff d@ZedAddddZedBddZedCddZŐdd e#e!efde#e!efde#e!efd e#e!ej(fde#e!eff dDZedEejLeƫZǐd e#e!efde#e!efde#e!efd e#e!ej(fde#e!eff dFZejdGddgZedHddddZedIddZedJddZ̐dd e#e!efde#e!efde#e!efde#e!ej(ffdKZedLejLeͫZΐd e#e!efde#e!efde#e!efde#e!ej(ffdMZedNddddddddd'd(d)d* ZedOddZedPddZedQddZӐdde#e!efde#e!efde#e!efde#e!efdeHde#e!eff dRZedSejLeԫZՐde#e!efde#e!efde#e!efde#e!efdeHde#e!eff dTZedUdd d!dddZאdde#e!efde#e!effdVZedWejLeثZde#e!efde#e!effdXZedYdd d!dddZېdd;e#e!efdpe#e!efde#e!effdZZed[ejLeܫZd;e#e!efdpe#e!efde#e!effd\Zed]dd d!dddddddd'd(d)d*Zejdejfed^d_dde#e!efde#e!effd`ZedaejLeZejljnZde#e!efde#e!effdbZedcdd d!ddddd Zejdejfedddddegededde#e!efd;e#e!efde#e!effdfZedgejLeZejljnZde#e!efd;e#e!efde#e!effdhZedidd d!dddddddd'd(d)d*Zdde#e!efd;e#e!efde#e!effdjZedkejLeZde#e!efd;e#e!efde#e!effdlZedmdd d!dddddddd"d#d$d%d&d'd(d)d*ZednddZddJe#e!efdKe#e!efdLeHde#e!effdoZedpejLeZdJe#e!efdKe#e!efdLeHde#e!effdqZedrdd d!dddZejdejfedsdtdde#e!efde#e!effduZedvejLeZejljnZde#e!efde#e!effdwZedxdd d!dddZejdejfedydzd{dde#e!efde#e!effd|Zed}ejLeZejljnZde#e!efde#e!effd~Zeddd d!dddZdd;e#e!efdpe#e!efde#e!effdZedejLeZd;e#e!efdpe#e!efde#e!effdZeddd d!dddddddd'd(d)d*Zejdejfeddde#e!efd;e#e!efde#e!effdZedejLeZejljnZde#e!efd;e#e!efde#e!effdZedddddddZejdejfeddde#e!efd;e#e!efde#e!effdZedejLeZejljnZde#e!efd;e#e!efde#e!effdZ edddddddddd'd(d)d* Z edddZ edddZ ejdejfedddgeddde#e!e fde#e!e fde#e!e fde#e!e ffdZ edejLe Ze jljnZde#e!e fde#e!e fde#e!e fde#e!e ffdZedddddddddd'd(d)d* ZedddZedddZejdejfedddgeddde#e!efde#e!efde#e!efde#e!effdZedejLeZejljnZde#e!efde#e!efde#e!efde#e!effdZeddd d!dddddddd"d#d$d%d&d'd(d)d*ZedddZedddZejdejfedddgeddde#e!efde#e!efde#e!efde#e!effdZedejLeZejljnZde#e!efde#e!efde#e!efde#e!effdZeddd d!dddddddd"d#d$d%d&d'd(d)d*ZeddddZ edddZ!ejdejfedddgeddde#e!efde#e!e fde#e!e!fde#e!effdZ"edejLe"Z#e"jljnZ$de#e!efde#e!e fde#e!e!fde#e!effdZ%eddd d!dddZ&dde#e!e&fd;e#e!e&fde#e!e&ffdZ'edejLe'Z(de#e!e&fd;e#e!e&fde#e!e&ffdZ)eddd d!dddZ*dde#e!e*fd;e#e!e*fde#e!e*ffdZ+edejLe+Z,de#e!e*fd;e#e!e*fde#e!e*ffdZ-eddd d!dddZ.ejdejfeddde#e!e.fd;e#e!e.fde#e!e.ffdZ/edejLe/Z0e/jljnZ1de#e!e.fd;e#e!e.fde#e!e.ffdZ2edddZ3ejdejfedddgeddde#e!e3fde#e!e3fde#e!e3ffdZ4edejLe4Z5e4jljnZ6de#e!e3fde#e!e3fde#e!e3ffdZ7y(zUPython wrappers around TensorFlow ops. This file is MACHINE GENERATED! Do not edit. N) pywrap_tfe)context)core)execute)dtypes)annotation_types)op_def_registry)ops)op_def_library)deprecated_endpoints)dispatch) tf_export)TypeVarListAny) AnnotatedTV_Abs_T_atypes.BFloat16_atypes.Float32_atypes.Float64 _atypes.Half _atypes.Int16 _atypes.Int32 _atypes.Int64 _atypes.Int8xreturnc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)aComputes the absolute value of a tensor. Given a tensor `x`, this operation returns a tensor containing the absolute value of each element in `x`. For example, if x is an input element and y is an output element, this operation computes \\(y = |x|\\). Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AbsNnamectxrr!T)_contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException_abs_eager_fallback_SymbolicException_op_def_library_apply_op_helper_executemust_record_gradient_get_attr_typeinputsrecord_gradient rr!_ctxtld_resulte__op_outputs_attrs _inputs_flats R/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_math_ops.py_absrBs7    0h..0$ #\\ 11 eT1g n(88 !QX QK' ""$3%%c* +F::L  |VW. (' .'  & &- ##At,,  # #    $D""  # #   0C D C;;DD D&&D<;D<z raw_ops.Absc tj|g|tjtjtj tj tjtjtjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAbsr5attrsr"r!r)r2args_to_matching_eager_dtypesbfloat16halffloat32float64int8int16int32int64rr3r6rr!r"_attr_Tr@r?r:s rAr.r.Hs111#sW=M=Mw||]d]l]lnun}n}@G@L@LNUN[N[]d]j]jlslyly=|}-'4A, >&   VQ|6!$4 1' ""$  |VW. (' .TV_AccumulateNV2_T_atypes.Complex128_atypes.Complex64_atypes.QInt16_atypes.QInt32 _atypes.QInt8_atypes.QUInt16_atypes.QUInt8_atypes.UInt16_atypes.UInt32_atypes.UInt64 _atypes.UInt8r5cVtjxstj}|j}|jr t j |d||d|}|St|ttfst!d|zt#|}t%j&|d}t)j*d|||\}}} } | dd}t%j,rYd| j/dd| j1dd| j3df} | j4} t%j6d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYKwxYw) aReturns the element-wise sum of a list of tensors. `tf.accumulate_n_v2` performs the same operation as `tf.add_n`, but does not wait for all of its inputs to be ready before beginning to sum. This can save memory if inputs are ready at different times, since minimum temporary storage is proportional to the output size rather than the inputs size. Unlike the original `accumulate_n`, `accumulate_n_v2` is differentiable. Returns a `Tensor` of same shape and type as the elements of `inputs`. Args: inputs: A list of at least 1 `Tensor` objects with the same type in: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. A list of `Tensor` objects, each with same shape and type. shape: A `tf.TensorShape` or list of `ints`. Shape of elements of `inputs`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `inputs`. AccumulateNV2shapeN)rcr!r"CExpected list for 'inputs' argument to 'accumulate_nv2' Op, not %r.)r5rcr!Nr$)r%rr&r'rr(r)r*r+r,r-accumulate_nv2_eager_fallbackr/ isinstancelisttuple TypeErrorlenr2 make_shaper0r1r3 _get_attr_intr4get_attrr5r6) r5rcr!r8r9r:r;_attr_Nr<r=r>r?r@s rAaccumulate_nv2rpWs,    0h..0$ #\\ 11 otVWe=g n FT5M *  ')/ 0 11 K'   eW -%'88e$@!QX QK' ""$3$$S)30B0B30Gs||G,.F::L vw8 (' .5  & &- ##At,,  # #    * Dd44  # #   s0D77E> E%%E>=E>FF('F(zraw_ops.AccumulateNV2ct|ttfstd|zt |}t j |d}t jt||tjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,tj.tj0tj2tj4tj6g\}}t|}d|d|d|f}t j8dd||||}t j:rt j<d||||\}|S) Nrdrcrer$s AccumulateNV2rErFrb)rgrhrirjrkr2rlrHrIrLrMrPuint8rOrN complex64rQqint8quint8qint32rJqint16quint16uint16 complex128rKuint32uint64rr3r6) r5rcr!r"rorSr@r?r:s rArfrfs; FT5M *  ')/ 0 11 K'   eW -%33DL#Y`YhYhjqjwjwzAzGzGIPIVIVX_XdXdfmfwfwy@yFyFHOHUHUW^WeWegnguguw~wGwGIPIWIWY`YhYhjqjxjxzAzLzLNUNZNZ\c\j\jlslzlzH}~/'6f, #w 7&   -q#)s ?' ""$ vw8 (' .rT TV_Acos_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)aComputes acos of x element-wise. Provided an input tensor, the `tf.math.acos` operation returns the inverse cosine of each element of the tensor. If `y = tf.math.cos(x)` then, `x = tf.math.acos(y)`. Input range is `[-1, 1]` and the output has a range of `[0, pi]`. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AcosNr r#r$)r%rr&r'rr(r)r*r+r,r-acos_eager_fallbackr/r0r1r2r3r4r5r6r7s rAacosrs7    0h..0$ #\\ 11 fdAg n(88!$ !QX QK' ""$3%%c* +F::L  fg/ (' .'  & &- ##At,,  # #    $D""  # #   rCz raw_ops.Acosc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAcosrErFr r2rHrIrJrKrLrMrsrzrr3r6rRs rArr111#sW=M=Mw||]d]l]lnun}n}@G@Q@QSZSeSe=hi-'4A, >&   Wa F!$4 1' ""$  fg/ (' .rT TV_Acosh_Tz math.acoshacoshc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)ajComputes inverse hyperbolic cosine of x element-wise. Given an input tensor, the function computes inverse hyperbolic cosine of every element. Input range is `[1, inf]`. It returns `nan` if the input lies outside the range. ```python x = tf.constant([-2, -0.5, 1, 1.2, 200, 10000, float("inf")]) tf.math.acosh(x) ==> [nan nan 0. 0.62236255 5.9914584 9.903487 inf] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AcoshNr r#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_acoshNotImplementedacosh_eager_fallbackr/rj ValueError _dispatchr rdict OpDispatcher NOT_SUPPORTEDr0r1r2r3r4r5r6r7s rArr*    0h..0$ #\\ 11 gtQ g n,$ D DGn$ n  )::14!Aq#x QK' ""$3%%c* +F::L vw0 (' .W  & &- ##At,,  # #    % d*dg  & ! $D""  # #  z " "" 2tad+ g  ..<< <  Z    TAD) Gi,,::: n  PC&3G&D-9DD-,D-1E EG,AGGAHHz raw_ops.Acoshc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAcoshrErFrrrRs rArr2111#sW=M=Mw||]d]l]lnun}n}@G@Q@QSZSeSe=hi-'4A, >&   XqV!$4 1' ""$ vw0 (' .rTTV_Add_T_atypes.Stringyctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aReturns x + y element-wise. *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Given two input tensors, the `tf.add` operation computes the sum for every element in the tensor. Both input and output have a range `(-inf, inf)`. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`, `string`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AddNr rrr!r$)r%rr&r'rr(r)r*r+r,r-add_eager_fallbackr/r0r1r2r3r4r5r6 rrr!r8r9r:r;r<r=r>r?r@s rAaddrAs=$    0h..0$ #\\ 11 eT1a!g n(88 ad$!QX QK' ""$3%%c* +F::L  |VW. (' .'  & &- ##At,,  # #     QTt%%  # #   0CD"C==DDD))D?>D?z raw_ops.AddcVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$sAddrErFr)r2rHrIrJrKrLrMrrrNrOrPrQrsrzstringrr3r6 rrr!r"rS _inputs_Tr@r?r:s rArrrsa661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WcWcelerert{tAtACJCPCPRYRcRcelewewy@yGyGEJK'9 &1aQ, >&   VQ|6!$4 1' ""$  |VW. (' .rT TV_AddN_T_atypes.Variantctjxstj}|j}|jr t j |d||}|St|ttfst!d|zt#|}t%j&d||\}}}} | dd}t)j*rHd|j-dd|j/df} |j0} t)j2d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rY"wxYw)a Add all input tensors element wise. Inputs must be of same size and shape. ```python x = [9, 7, 10] tf.math.add_n(x) ==> 26 ``` Args: inputs: A list of at least 1 `Tensor` objects with the same type in: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `variant`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `inputs`. AddNNr :Expected list for 'inputs' argument to 'add_n' Op, not %r.)r5r!rer$)r%rr&r'rr(r)r*r+r,r-add_n_eager_fallbackr/rgrhrirjrkr0r1r2r3rmr4r5r6) r5r!r8r9r:r;ror<r=r>r?r@s rAadd_nrsy"    0h..0$ #\\ 11 fdF$g n FT5M *   & ' (( K''88vD*!QX QK' ""$3$$S)30B0B30G HF::L  fg/ (' .1  & &- ##At,,  # #    ! t''  # #   s0D E D;;EE E&&E=<E=z raw_ops.AddNct|ttfstd|zt |}t j t||tjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,tj.tj0tj2tj4tj6g\}}t|}d|d|f}t j8dd||||}t j:rt j<d||||\}|S)Nrrer$sAddNrErFr)rgrhrirjrkr2rHrIrLrMrPrrrOrNrsrQrtrurvrJrwrxryrzrKr{r|variantrr3r6)r5r!r"rorSr@r?r:s rArrs9 FT5M *   & ' (( K'33DL#Y`YhYhjqjwjwzAzGzGIPIVIVX_XdXdfmfwfwy@yFyFHOHUHUW^WeWegnguguw~wGwGIPIWIWY`YhYhjqjxjxzAzLzLNUNZNZ\c\j\jlslzlz|C|K|KHNO/'6f, #w '&   Wa F!$4 1' ""$  fg/ (' .rT TV_AddV2_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aReturns x + y element-wise. *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AddV2Nr rr$)r%rr&r'rr(r)r*r+r,r-add_v2_eager_fallbackr/r0r1r2r3r4r5r6rs rAadd_v2rs=    0h..0$ #\\ 11 gtQ#g n(881&!QX QK' ""$3%%c* +F::L vw0 (' .'  & &- ##At,,  # #    " QTt%%  # #   rz raw_ops.AddV2ctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj g\}}|\}}||g}d|f}tj"dd||||}tj$rtj&d||||\}|S)Nr$sAddV2rErFr)r2rHrIrJrKrLrMrrryr{r|rNrOrPrQrsrzrr3r6rs rArrs661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WeWegnguguw~wEwEGNGSGSU\UbUbdkdqdqszs@s@BIBSBSU\UgUgEjk'9 &1aQ, >&   XqV!$4 1' ""$ vw0 (' .rT TV_All_TidxFinputaxis keep_dimsc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rHd| j%dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aComputes the "logical and" of elements across dimensions of a tensor. Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1. Args: input: A `Tensor` of type `bool`. The tensor to reduce. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. The dimensions to reduce. Must be in the range `[-rank(input), rank(input))`. keep_dims: An optional `bool`. Defaults to `False`. If true, retain reduced dimensions with length 1. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. AllrNrr!r"Frreduction_indicesrr!Tidx)r%rr&r'rr(r)r*r+r,r-_all_eager_fallbackr/r2 make_boolr0r1r3_get_attr_boolr4r5r6 rrrr!r8r9r:r;r<r=r>r?r@s rA_allrz(    0h..0$ #\\ 11 eT5$ Y@g nI  K8)'88 Udi!QX QK' ""$3--k:F  (*F::L  |VW. (' .1  & &- ##At,,  # #    4AA  # #   0C==ED++EEEE/.E/z raw_ops.Allc|d}tj|d}tj|g|tjtj gtj\}\}t j|tj}||g}d|d|f}tjdd||||}tjrtjd||||\}|S)NFrrsAllrErFr r2rrHrIrPrQr+convert_to_tensorboolrr3r6 rrrr!r" _attr_Tidxr@r?r:s rArr@I  K8) 77gmmU\UbUbEegngtgtu*gt   5%, FJ 7&   VQ|6!$4 1' ""$  |VW. (' .rT TV_Angle_T TV_Angle_ToutToutctjxstj}|j}|jr t j |d||d|}|S|tj}tj |d}t#j$d|||\}}}} | dd}tj&rHd|j)dd|j)df} |j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)ajReturns the argument of a complex number. Given a tensor `input` of complex numbers, this operation returns a tensor of type `float` that is the argument of each element in `input`. All elements in `input` must be complex numbers of the form \\(a + bj\\), where *a* is the real part and *b* is the imaginary part. The argument returned by this operation is of the form \\(atan2(b, a)\\). For example: ``` # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j] tf.math.angle(input) ==> [2.0132, 1.056] ``` @compatibility(numpy) Equivalent to np.angle. @end_compatibility Args: input: A `Tensor`. Must be one of the following types: `complex64`, `complex128`. Tout: An optional `tf.DType` from: `tf.float32, tf.float64`. Defaults to `tf.float32`. name: A name for the operation (optional). Returns: A `Tensor` of type `Tout`. AnglerNrr!r"rrr!r$)r%rr&r'rr(r)r*r+r,r-angle_eager_fallbackr/rIrLr2 make_typer0r1r3r4r5r6 rrr!r8r9r:r;r<r=r>r?r@s rAanglerTsq:    0h..0$ #\\ 11 gtUFD2g n \ ??D   D& )$'88u4d4!QX QK' ""$3%%c*F  (*F::L vw0 (' ./  & &- ##At,,  # #    ! d411  # #   0D ED77EEE##E:9E:z raw_ops.Anglec|tj}tj|d}tj|g|tj tj gtj \}\}|g}d|d|f}tjdd||||}tjrtjd||||\}|S)Nrr$sAnglerErFr rIrLr2rrHrsrzrr3r6rrr!r"rSr@r?r:s rArrs \ ??D   D& )$55ugsWEVEVX_XjXjDmovpApAB'8E, &$ '&   XqV!$4 1' ""$ vw0 (' .rT TV_Any_Tidxc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rHd| j%dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aComputes the "logical or" of elements across dimensions of a tensor. Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1. Args: input: A `Tensor` of type `bool`. The tensor to reduce. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. The dimensions to reduce. Must be in the range `[-rank(input), rank(input))`. keep_dims: An optional `bool`. Defaults to `False`. If true, retain reduced dimensions with length 1. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. rrNrFrr)r%rr&r'rr(r)r*r+r,r-_any_eager_fallbackr/r2rr0r1r3rr4r5r6rs rA_anyrrrz raw_ops.Anyc|d}tj|d}tj|g|tjtj gtj\}\}t j|tj}||g}d|d|f}tjdd||||}tjrtjd||||\}|S)NFrrsAnyrErFrrrs rArrrrTTV_ApproximateEqual_T tolerancec tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rHd| j%dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aReturns the truth value of abs(x-y) < tolerance element-wise. Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. tolerance: An optional `float`. Defaults to `1e-05`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. ApproximateEqualrN)rr!r"h㈵>)rrrr!r$)r%rr&r'rr(r)r*r+r,r- approximate_equal_eager_fallbackr/r2 make_floatr0r1r3r4rnr5r6) rrrr!r8r9r:r;r<r=r>r?r@s rAapproximate_equalrsu    0h..0$ #\\ 11  $1k9Fg nI!!)[9)'88a1 F!QX QK' ""$3%%c*Kll;')F::L L&'; (' ./  & &- ##At,,  # #    - Q)$D::  # #   rzraw_ops.ApproximateEqualc`|d}tj|d}tj||g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\}}|\}}||g}d|d|f}tj.dd||||} tj0rtj2d||| | \} | S)Nrrr$sApproximateEqualrErFr)r2rrHrIrLrMrPrrrOrNrsrQrtrurvrJrwrxryrzrKr{r|rr3r6) rrrr!r"rSrr@r?r:s rArr sI!!)[9)661vsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjctctv}vCvCELERERT[TbTbdkdrdrt{tDtDFMFTFTV]VeVegnguguw~wIwIKRKWKWY`YgYgipiwiwEz{'9 &1aQ, +y 1&   0!L#)s ?' ""$ L&'; (' .rT TV_ArgMax_T _atypes.BoolTV_ArgMax_TidxTV_ArgMax_output_type dimension output_typec "tjxstj}|j}|jr t j |d|||d|}|S|tj}tj |d}t#j$d||||\}}} } | dd}tj&rYd| j)dd| j)dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY0wxYw)asReturns the index with the largest value across dimensions of a tensor. Note that in case of ties the identity of the return value is not guaranteed. Usage: ```python import tensorflow as tf a = [1, 10, 26.9, 2.8, 166.32, 62.3] b = tf.math.argmax(input = a) c = tf.keras.backend.eval(b) # c = 4 # here a[4] = 166.32 which is the largest element of a across axis 0 ``` Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `qint8`, `quint8`, `qint32`, `qint16`, `quint16`, `bool`. dimension: A `Tensor`. Must be one of the following types: `int16`, `int32`, `int64`. int16, int32 or int64, must be in the range `[-rank(input), rank(input))`. Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0. output_type: An optional `tf.DType` from: `tf.int16, tf.uint16, tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A `Tensor` of type `output_type`. ArgMaxrNrr!r"rrrr!r$r)r%rr&r'rr(r)r*r+r,r-arg_max_eager_fallbackr/rIrQr2rr0r1r3r4r5r6 rrrr!r8r9r:r;r<r=r>r?r@s rAarg_maxr56    0h..0$ #\\ 11 heY {Lg n--K""; >+'88 !QX QK' ""$3%%c*F  (-  /1F::L ,1 (' .3  & &- ##At,,  # #    #  $DJJ  # #   0DE#/E  E#"E#'E77F Fzraw_ops.ArgMaxc |tj}tj|d}tj|g|tj tj tjtjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tjtjtjgtj\}\}||g}d|d|d|f}tj,dd||||} tj.rtj0d||| | \} | S)Nrr$rsArgMaxrErFrrIrQr2rrHrLrMrPrrrOrNrJryrKr{r|rtrurvrwrxrrr3r6 rrrr!r"rSrr@r?r:s rArrusP--K""; >+55ugsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@BIBOBOQXQ_Q_ahaoaoqxqqAHAPAPRYR^R^Eab'8E%<+55ugsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@BIBOBOQXQ_Q_ahaoaoqxqqAHAPAPRYR^R^Eab'8E%<tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes the trignometric inverse sine of x element-wise. The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`. **Note**: The output of `tf.math.asin` will lie within the invertible range of sine, i.e [-pi/2, pi/2]. For example: ```python # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)] x = tf.constant([1.047, 0.785]) y = tf.math.sin(x) # [0.8659266, 0.7068252] tf.math.asin(y) # [1.047, 0.785] = x ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AsinNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_asinrasin_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr:    0h..0$ #\\ 11 fdAg n,# D DGn$ n  )::!$ Aq#x QK' ""$3%%c* +F::L  fg/ (' .W  & &- ##At,,  # #    $ d*dg  & $D""  # #  z " "" "dQT* g  ..<< <  Z    D14( Gi,,::: n  rz raw_ops.Asinc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAsinrErFrrrRs rArr2rrT TV_Asinh_Tz math.asinhasinhc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes inverse hyperbolic sine of x element-wise. Given an input tensor, this function computes inverse hyperbolic sine for every element in the tensor. Both input and output has a range of `[-inf, inf]`. ```python x = tf.constant([-float("inf"), -2, -0.5, 1, 1.2, 200, 10000, float("inf")]) tf.math.asinh(x) ==> [-inf -1.4436355 -0.4812118 0.8813736 1.0159732 5.991471 9.903487 inf] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AsinhNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_asinhrasinh_eager_fallbackr/rjrrr r rrrr0r1r2r3r4r5r6r7s rAr r As,    0h..0$ #\\ 11 gtQ g n,$ D DGn$ n  )::14!Aq#x QK' ""$3%%c* +F::L vw0 (' .W  & &- ##At,,  # #    % d*dg  & ! $D""  # #  z " "" 2tad+ g  ..<< <  Z    TAD) Gi,,::: n  rz raw_ops.Asinhc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAsinhrErFr rrRs rArrrrT TV_Atan_Tz math.atanatanc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes the trignometric inverse tangent of x element-wise. The `tf.math.atan` operation returns the inverse of `tf.math.tan`, such that if `y = tf.math.tan(x)` then, `x = tf.math.atan(y)`. **Note**: The output of `tf.math.atan` will lie within the invertible range of tan, i.e (-pi/2, pi/2). For example: ```python # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)] x = tf.constant([1.047, 0.785]) y = tf.math.tan(x) # [1.731261, 0.99920404] tf.math.atan(y) # [1.047, 0.785] = x ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AtanNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_atanratan_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArrrrz raw_ops.Atanc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAtanrErFrrrRs rArrrrT TV_Atan2_Tz math.atan2atan2c Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)auComputes arctangent of `y/x` element-wise, respecting signs of the arguments. This is the angle \\( \theta \in [-\pi, \pi] \\) such that \\[ x = r \cos(\theta) \\] and \\[ y = r \sin(\theta) \\] where \\(r = \sqrt{x^2 + y^2} \\). For example: >>> x = [1., 1.] >>> y = [1., -1.] >>> print((tf.math.atan2(y,x) * (180 / np.pi)).numpy()) [ 45. -45.] Args: y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. x: A `Tensor`. Must have the same type as `y`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `y`. Atan2Nr r)rrr!r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_atan2ratan2_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6) rrr!r8r9r:r;r<r=r>r?r@s rArrs'6    0h..0$ #\\ 11 gtQ#g n,$ At tGn$ n  )::1&Aq#x QK' ""$3%%c* +F::L vw0 (' .W  & &- ##At,,  # #    % a-g  & ! QTt%%  # #  z " "" 2ta140 g  ..<< <  Z    TA. Gi,,::: n  PC)5G )D0<DD0/D04E EG1AGG AH#!H#z raw_ops.Atan2cftj||g|tjtjtj tj g\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAtan2rErFr r2rHrIrJrKrLrMrr3r6) rrr!r"rSrr@r?r:s rArrUs661vsWEUEUW^WcWceletetv}wFwFEIJ'9 &1aQ, >&   XqV!$4 1' ""$ vw0 (' .rT TV_Atanh_Tz math.atanhatanhc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes inverse hyperbolic tangent of x element-wise. Given an input tensor, this function computes inverse hyperbolic tangent for every element in the tensor. Input range is `[-1,1]` and output range is `[-inf, inf]`. If input is `-1`, output will be `-inf` and if the input is `1`, output will be `inf`. Values outside the range will have `nan` as output. ```python x = tf.constant([-float("inf"), -1, -0.5, 1, 0, 0.5, 10, float("inf")]) tf.math.atanh(x) ==> [nan -inf -0.54930615 inf 0. 0.54930615 nan nan] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. AtanhNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_atanhratanh_eager_fallbackr/rjrrr r"rrrr0r1r2r3r4r5r6r7s rAr"r"es0    0h..0$ #\\ 11 gtQ g n,$ D DGn$ n  )::14!Aq#x QK' ""$3%%c* +F::L vw0 (' .W  & &- ##At,,  # #    % d*dg  & ! $D""  # #  z " "" 2tad+ g  ..<< <  Z    TAD) Gi,,::: n  rz raw_ops.Atanhc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sAtanhrErFr$rrRs rAr&r&rrTTV_BatchMatMul_Tadj_xadj_ygrad_xgrad_yctjxstj}|j}|jr$ t j |d|||d|d|d|d| } | S|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj d||||||| \} } } } | dd} tj"r{d | j%d d| j'dd| j'dd| j'dd| j'df }| j(}tj*d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||S#t j$rYwxYw) a Multiplies slices of two tensors in batches. Multiplies all slices of `Tensor` `x` and `y` (each slice can be viewed as an element of a batch), and arranges the individual results in a single output tensor of the same batch size. Each of the individual slices can optionally be adjointed (to adjoint a matrix means to transpose and conjugate it) before multiplication by setting the `adj_x` or `adj_y` flag to `True`, which are by default `False`. The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]` and `[..., r_y, c_y]`. The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where: r_o = c_x if adj_x else r_x c_o = r_y if adj_y else c_y It is computed as: output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :]) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`. 2-D or higher with shape `[..., r_x, c_x]`. y: A `Tensor`. Must have the same type as `x`. 2-D or higher with shape `[..., r_y, c_y]`. adj_x: An optional `bool`. Defaults to `False`. If `True`, adjoint the slices of `x`. Defaults to `False`. adj_y: An optional `bool`. Defaults to `False`. If `True`, adjoint the slices of `y`. Defaults to `False`. grad_x: An optional `bool`. Defaults to `False`. grad_y: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. BatchMatMulr)r*r+r,Nr)r*r+r,r!r"Frrr)r*r+r,r!r$)r%rr&r'rr(r)r*r+r,r-batch_mat_mul_eager_fallbackr/r2rr0r1r3r4rr5r6rrr)r*r+r,r!r8r9r:r;r<r=r>r?r@s rA batch_mat_mulr3sL    0h..0$ #\\ 11 mT1a%%&(F,gn ] E   UG ,% ] E   UG ,% ^ F   fh /& ^ F   fh /&'88auE&$41!QX QK' ""$3%%c*G  )7  )8  *H  * ,F ::L |VW6 (' .K  & &- ##At,,  # #    ) Qe5  # #   0"FGF55G GG%%G<;G<zraw_ops.BatchMatMulc |d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj||g|tjtj tj tjtjtjtjtjg\}} | \}}||g} d|d|d|d|d|f } tjdd| | || } tjrtjd | | | | \} | S) NFr)r*r+r,r$s BatchMatMulrErFr.)r2rrHrIrJrKrLrMrPrQrsrzrr3r6 rrr)r*r+r,r!r"rSrr@r?r:s rAr1r1s ] E   UG ,% ] E   UG ,% ^ F   fh /& ^ F   fh /&661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WdWdfmfwfwy@yKyKENO'9 &1aQ, '5'5(F F &   ^Q|#)s ?' ""$ |VW6 (' .rTTV_BatchMatMulV2_Tctjxstj}|j}|jr$ t j |d|||d|d|d|d| } | S|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj d||||||| \} } } } | dd} tj"r{d | j%d d| j'dd| j'dd| j'dd| j'df }| j(}tj*d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||S#t j$rYwxYw) aMultiplies slices of two tensors in batches. Multiplies all slices of `Tensor` `x` and `y` (each slice can be viewed as an element of a batch), and arranges the individual results in a single output tensor of the same batch size. Each of the individual slices can optionally be adjointed (to adjoint a matrix means to transpose and conjugate it) before multiplication by setting the `adj_x` or `adj_y` flag to `True`, which are by default `False`. The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]` and `[..., r_y, c_y]`. The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where: r_o = c_x if adj_x else r_x c_o = r_y if adj_y else c_y It is computed as: output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :]) *NOTE*: `BatchMatMulV2` supports broadcasting in the batch dimensions. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html). Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`, `complex64`, `complex128`. 2-D or higher with shape `[..., r_x, c_x]`. y: A `Tensor`. Must have the same type as `x`. 2-D or higher with shape `[..., r_y, c_y]`. adj_x: An optional `bool`. Defaults to `False`. If `True`, adjoint the slices of `x`. Defaults to `False`. adj_y: An optional `bool`. Defaults to `False`. If `True`, adjoint the slices of `y`. Defaults to `False`. grad_x: An optional `bool`. Defaults to `False`. grad_y: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. BatchMatMulV2r)r*r+r,Nr/Fr0r$)r%rr&r'rr(r)r*r+r,r-batch_mat_mul_v2_eager_fallbackr/r2rr0r1r3r4rr5r6r2s rAbatch_mat_mul_v2r;9sT    0h..0$ #\\ 11 otQ7E7E&(F,gn ] E   UG ,% ] E   UG ,% ^ F   fh /& ^ F   fh /&'881eF &T3!QX QK' ""$3%%c*G  )7  )8  *H  * ,F ::L vw8 (' .K  & &- ##At,,  # #    , Qe5  # #   r4zraw_ops.BatchMatMulV2cT|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj||g|tjtj tj tjtjtjtjtjtjtjtjtjtj g \}} | \}}||g} d|d|d|d|d|f } tj"dd| | || } tj$rtj&d | | | | \} | S) NFr)r*r+r,r$s BatchMatMulV2rErFr9)r2rrHrIrJrKrLrMrOrPrQrrryr{r|rsrzrr3r6r6s rAr:r:s ] E   UG ,% ] E   UG ,% ^ F   fh /& ^ F   fh /&661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WdWdfmfsfsu|uBuBDKDRDRT[TbTbdkdrdrt{tEtEGNGYGYE\]'9 &1aQ, '5'5(F F &   -q#)s ?' ""$ vw8 (' .rTTV_BatchMatMulV3_TaTV_BatchMatMulV3_TbTV_BatchMatMulV3_Toutcvtjxstj}|j} | jr& t j |d|||d|d|d|d|d|} | Stj|d}|d }tj|d}|d }tj|d}|d }tj|d}|d }tj|d}t!j"d|||||||| \} } } }|dd} tj$rd | j'd d | j'd d| j'dd| j)dd| j)dd| j)dd| j)df}| j*}tj,d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||| S#t j$rYwxYw) aMultiplies slices of two tensors in batches. Multiplies all slices of `Tensor` `x` and `y` (each slice can be viewed as an element of a batch), and arranges the individual results in a single output tensor of the same batch size. Each of the individual slices can optionally be adjointed (to adjoint a matrix means to transpose and conjugate it) before multiplication by setting the `adj_x` or `adj_y` flag to `True`, which are by default `False`. The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]` and `[..., r_y, c_y]`. The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where: r_o = c_x if adj_x else r_x c_o = r_y if adj_y else c_y It is computed as: output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :]) *NOTE*: `BatchMatMulV3` supports broadcasting in the batch dimensions. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html). Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. 2-D or higher with shape `[..., r_x, c_x]`. y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. 2-D or higher with shape `[..., r_y, c_y]`. Tout: A `tf.DType` from: `tf.bfloat16, tf.half, tf.float32, tf.float64, tf.int16, tf.int32, tf.int64, tf.complex64, tf.complex128`. If not spcified, Tout is the same type to input type. adj_x: An optional `bool`. Defaults to `False`. If `True`, adjoint the slices of `x`. Defaults to `False`. adj_y: An optional `bool`. Defaults to `False`. If `True`, adjoint the slices of `y`. Defaults to `False`. grad_x: An optional `bool`. Defaults to `False`. grad_y: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor` of type `Tout`. BatchMatMulV3rr)r*r+r,N)rr)r*r+r,r!r"F)rrrr)r*r+r,r!TaTb)r%rr&r'rr(r)r*r+r,r-batch_mat_mul_v3_eager_fallbackr/r2rrr0r1r3r4rr5r6)rrrr)r*r+r,r!r8r9r:r;r<r=r>r?r@s rAbatch_mat_mul_v3rEsVX    0h..0$ #\\ 11 otQ64%&(FN>NPWP\P\^e^m^movo~o~AHANANPWP\P\^e^k^kmtmzmz|C|I|IKRK\K\^e^p^p>st.(DQ22A3g>N>NPWP\P\^e^m^movo~o~AHANANPWP\P\^e^k^kmtmzmz|C|I|IKRK\K\^e^p^p>st.(DQQ, (D(FD'5 5(FHf 6&   -q#)s ?' ""$ vw8 (' .rT TV_Betainc_Tz math.betaincbetainc)v1abc \tjxstj}|j}|jr t j |d||||}|St||||fd}|tur|S t/j0d||||\}}} } | dd}t3j4r7d| j7df} | j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rYtt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw)alCompute the regularized incomplete beta integral \\(I_x(a, b)\\). The regularized incomplete beta integral is defined as: \\(I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}\\) where \\(B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt\\) is the incomplete beta function and \\(B(a, b)\\) is the *complete* beta function. Args: a: A `Tensor`. Must be one of the following types: `float32`, `float64`. b: A `Tensor`. Must have the same type as `a`. x: A `Tensor`. Must have the same type as `a`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. BetaincNr r)rLrMrr!r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_betaincrbetainc_eager_fallbackr/rjrrr rJrrrr0r1r2r3r4r5r6) rLrMrr!r8r9r:r;r<r=r>r?r@s rArJrJ2s7<    0h..0$ #\\ 11 iq!Q(g n,& Aq$$ Gn$ n  )::Q!qt-Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ' aD D"g  & # Q$((  # #  z " "" RQ!$7 g  ..<< <  Z    2ta15 Gi,,::: n  sPC,7G,D3?DD32D37E!E!!G7AG GAH+)H+zraw_ops.Betaincc0tj|||g|tjtjg\}}|\}}}|||g}d|f}tj dd||||} tj rtjd||| | \} | S)Nr$sBetaincrErFrOr2rHrIrLrMrr3r6) rLrMrr!r"rSrr@r?r:s rArQrQs661ay#Y`YhYhGkl'9)1aQ, >&   Zr?r@s rAbincountr[sD.    0h..0$ #\\ 11 j$T74g n(88$dD!QX QK' ""$3%%c* +F::L L&'3 (' .'  & &- ##At,,  # #    $ tW4T33  # #   0CD$C??DDD,,EEzraw_ops.Bincountctj|g|tjtjtj tj g\}\}tj|tj}tj|tj}|||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sBincountrErFrY) r2rHrIrPrQrLrMr+rrr3r6) rUrVrWr!r"rSr@r?r:s rArZrZs 77 3X_XeXegngvgvxyHyHIKL':G sGMM2#  gmm 4$tW%, >&   [!L#)s ?' ""$ L&'3 (' .rTTV_Bucketize_TcBtjxstj}|j}|jr t j |d||d|}|St|ttfst!d|z|Dcgc]}t#j$|d}}t'j(d|||\}}} } | dd}t#j*rHd| j-dd| j/df} | j0} t#j2d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYr?r@s rA bucketizeres0    0h..0$ #\\ 11 k4 jBg n Ju .  "$. / 00AKK"##B 5K*K'885ZdD!QX QK' ""$3%%c*Lll<(*F::L \674 (' .3  & &- ##At,,  # #    % JTt==  # #   Ls6D(F(E/;EE/.E/3FFFzraw_ops.Bucketizect|ttfstd|z|Dcgc]}t j |d}}t j |g|tjtjtjtjg\}\}|g}d|d|f}t jdd||||}t jrt jd||||\}|Scc}w)Nrbrar$s BucketizerErFr`)rgrhrirjr2rrHrIrPrQrLrMrr3r6) rrar!r"rdrSr@r?r:s rArcrcs Ju .  "$. / 00AKK"##B 5K*K55ugsW]]T[TaTacjcrcrt{uDuDEGH'8E, , 3&   \1\#)s ?' ""$ \674 (' .LsC7) TV_Cast_SrcTrrrVrW_atypes.Float16rr_atypes.Float8e4m3b11fnuz_atypes.Float8e4m3fn_atypes.Float8e4m3fnuz_atypes.Float8e5m2_atypes.Float8e5m2fnuzrrr _atypes.Int4rrrXrYrZr[r\_atypes.Resourcerr]r^ _atypes.UInt4r_r`r) TV_Cast_DstTrrrVrWrhrrrirjrkrlrmrrrrnrrrXrYrZr[r\rorr]r^rpr_r`rDstTTruncatec 4tjxstj}|j}|jr t j |d||d|d|}|Stj|d}|d}tj|d}t!j"d||||\}}} } | dd}tj$rYd| j'dd| j'dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY8wxYw) zCast x of type SrcT to y of DstT. Args: x: A `Tensor`. DstT: A `tf.DType`. Truncate: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor` of type `DstT`. CastrrrsN)rrrsr!r"F)rrrrsr!SrcT)r%rr&r'rr(r)r*r+r,r-cast_eager_fallbackr/r2rrr0r1r3r4rr5r6) rrrrsr!r8r9r:r;r<r=r>r?r@s rAcastrx1s    0h..0$ #\\ 11 fdAvtZCg n   D& )$ H   * 5('88!$>!QX QK' ""$c((0&  (*  ,.F::L  fg/ (' .3  & &- ##At,,  # #    $$@@  # #   s0D%%E,8EE,+E,0FFFz raw_ops.CastcLtj|d}|d}tj|d}tj|g|g\}\}|g}d|d|d|f}tjdd||||}tj rtj d||||\}|S) NrrFrsrvsCastrErFru)r2rrrHrr3r6) rrrrsr!r" _attr_SrcTr@r?r:s rArwrwbs   D& )$ H   * 5(44aS#rB*dq, Jj( C&   Wa F!$4 1' ""$  fg/ (' .rT TV_Ceil_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)aReturns element-wise smallest integer not less than x. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. CeilNr r#r$)r%rr&r'rr(r)r*r+r,r-ceil_eager_fallbackr/r0r1r2r3r4r5r6r7s rAceilrus7    0h..0$ #\\ 11 fdAg n(88!$ !QX QK' ""$3%%c* +F::L  fg/ (' .'  & &- ##At,,  # #    $D""  # #   rCz raw_ops.Ceilc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sCeilrErFr}r rRs rAr~r~111#sW=M=Mw||]d]l]lnun}n}=AB-'4A, >&   Wa F!$4 1' ""$  fg/ (' .rTTV_ClipByValue_Ttclip_value_minclip_value_maxctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj r7d| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)a.Clips tensor values to a specified min and max. Given a tensor `t`, this operation returns a tensor of the same type and shape as `t` with its values clipped to `clip_value_min` and `clip_value_max`. Any values less than `clip_value_min` are set to `clip_value_min`. Any values greater than `clip_value_max` are set to `clip_value_max`. Args: t: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. A `Tensor`. clip_value_min: A `Tensor`. Must have the same type as `t`. A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape as `t`. The minimum value to clip by. clip_value_max: A `Tensor`. Must have the same type as `t`. A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape as `t`. The maximum value to clip by. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `t`. ClipByValueNr )rrrr!r$)r%rr&r'rr(r)r*r+r,r-_clip_by_value_eager_fallbackr/r0r1r2r3r4r5r6) rrrr!r8r9r:r;r<r=r>r?r@s rA_clip_by_valuersJ,    0h..0$ #\\ 11 mT1nnFg n(88>&44A!QX QK' ""$3%%c* +F::L |VW6 (' .)  & &- ##At,,  # #    * ^^$DBB  # #   r\zraw_ops.ClipByValuec.tj|||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}}|\}}}|||g}d|f}tj,dd||||} tj.rtj0d||| | \} | S)Nr$s ClipByValuerErFrr2rHrIrLrMrPrrrOrNrsrQrtrurvrJrwrxryrzrKr{r|rr3r6) rrrr!r"rSrr@r?r:s rArrs66>>7Z\_bibqbqsztCtCELERERT[TaTacjcpcpryr~r~@G@Q@QSZS`S`biboboqxqqAHAOAOQXQaQacjcqcqszsBsBDKDRDRT[TfTfhohthtv}vDvDFMFTFTbWX'9(1%1nn^^4, >&   ^Q|#)s ?' ""$ |VW6 (' .rT TV_Complex_TTV_Complex_Toutrealimagc tjxstj}|j}|jr t j |d|||d|}|S|tj}tj |d}t#j$d||||\}}} } | dd}tj&rHd| j)dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aConverts two real numbers to a complex number. Given a tensor `real` representing the real part of a complex number, and a tensor `imag` representing the imaginary part of a complex number, this operation returns complex numbers elementwise of the form \\(a + bj\\), where *a* represents the `real` part and *b* represents the `imag` part. The input tensors `real` and `imag` must have the same shape. For example: ``` # tensor 'real' is [2.25, 3.25] # tensor `imag` is [4.75, 5.75] tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]] ``` Args: real: A `Tensor`. Must be one of the following types: `float32`, `float64`. imag: A `Tensor`. Must have the same type as `real`. Tout: An optional `tf.DType` from: `tf.complex64, tf.complex128`. Defaults to `tf.complex64`. name: A name for the operation (optional). Returns: A `Tensor` of type `Tout`. ComplexrNr)rrrr!r$)r%rr&r'rr(r)r*r+r,r-_complex_eager_fallbackr/rIrsr2rr0r1r3r4r5r6) rrrr!r8r9r:r;r<r=r>r?r@s rA_complexrsy6    0h..0$ #\\ 11 itT649g n \   D   D& )$'884d?!QX QK' ""$3%%c*F  (*F::L <2 (' ./  & &- ##At,,  # #    $ 4d66  # #   s0D ED99EEE&&E=<E=zraw_ops.Complexc|tj}tj|d}tj||g|tj tj gtj \}}|\}}||g}d|d|f}tjdd||||} tjrtjd||| | \} | S)Nrr$sComplexrErFr) rIrsr2rrHrLrMrr3r6) rrrr!r"rSrr@r?r:s rArr2 s \   D   D& )$66d|S7??\c\k\kJnpwppA'9,4, &$ '&   Z>> x = tf.complex(3.0, 4.0) >>> print((tf.raw_ops.ComplexAbs(x=x, Tout=tf.dtypes.float32, name=None)).numpy()) 5.0 Args: x: A `Tensor`. Must be one of the following types: `complex64`, `complex128`. Tout: An optional `tf.DType` from: `tf.float32, tf.float64`. Defaults to `tf.float32`. name: A name for the operation (optional). Returns: A `Tensor` of type `Tout`. ComplexAbsrNr)rrr!r$)r%rr&r'rr(r)r*r+r,r-complex_abs_eager_fallbackr/rIrLr2rr0r1r3r4r5r6) rrr!r8r9r:r;r<r=r>r?r@s rA complex_absrF sq,    0h..0$ #\\ 11 lD!VT3g n \ ??D   D& )$'8841!QX QK' ""$3%%c*F  (*F::L lFG5 (' ./  & &- ##At,,  # #    ' $Tt--  # #   rzraw_ops.ComplexAbsc|tj}tj|d}tj|g|tj tj gtj \}\}|g}d|d|f}tjdd||||}tjrtjd||||\}|S)Nrr$s ComplexAbsrErFrr)rrr!r"rSr@r?r:s rArr s \ ??D   D& )$111#sW=N=NPWPbPb [-2.25 - 4.75j, 3.25 - 5.75j] ``` Args: input: A `Tensor`. Must be one of the following types: `complex64`, `complex128`, `variant`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. ConjNr )rr!r$)r%rr&r'rr(r)r*r+r,r-conj_eager_fallbackr/r0r1r2r3r4r5r6) rr!r8r9r:r;r<r=r>r?r@s rAconjr s70    0h..0$ #\\ 11 fdE#g n(88e$(!QX QK' ""$3%%c* +F::L  fg/ (' .'  & &- ##At,,  # #    d&&  # #   rCz raw_ops.Conjc\tj|g|tjtjtj gtj\}\}|g}d|f}tj dd||||}tjrtjd||||\}|S)Nr$sConjrErFr) r2rHrIrsrzrrr3r6)rr!r"rSr@r?r:s rArr s55ugsWEVEVX_XjXjlsl{l{D~AHARARS'8E, >&   Wa F!$4 1' ""$  fg/ (' .rTTV_Cos_Tzmath.coscosc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes cos of x element-wise. Given an input tensor, this function computes cosine of every element in the tensor. Input range is `(-inf, inf)` and output range is `[-1,1]`. If input lies outside the boundary, `nan` is returned. ```python x = tf.constant([-float("inf"), -9, -0.5, 1, 1.2, 200, 10000, float("inf")]) tf.math.cos(x) ==> [nan -0.91113025 0.87758255 0.5403023 0.36235774 0.48718765 -0.95215535 nan] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. CosNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_cosrcos_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr .    0h..0$ #\\ 11 eT1g n," D DGn$ n  ):: Aq#x QK' ""$3%%c* +F::L  |VW. (' .W  & &- ##At,,  # #    # d*dg  &  $D""  # #  z " "" TAD) g  ..<< <  Z    r4!$' Gi,,::: n  rz raw_ops.Cosc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sCosrErFrrrRs rArr& 111#sW=M=Mw||]d]l]lnun}n}@G@Q@QSZSeSe=hi-'4A, >&   VQ|6!$4 1' ""$  |VW. (' .rT TV_Cosh_Tz math.coshcoshc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes hyperbolic cosine of x element-wise. Given an input tensor, this function computes hyperbolic cosine of every element in the tensor. Input range is `[-inf, inf]` and output range is `[1, inf]`. ```python x = tf.constant([-float("inf"), -9, -0.5, 1, 1.2, 2, 10, float("inf")]) tf.math.cosh(x) ==> [inf 4.0515420e+03 1.1276259e+00 1.5430807e+00 1.8106556e+00 3.7621956e+00 1.1013233e+04 inf] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. CoshNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_coshrcosh_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr5 ,    0h..0$ #\\ 11 fdAg n,# D DGn$ n  )::!$ Aq#x QK' ""$3%%c* +F::L  fg/ (' .W  & &- ##At,,  # #    $ d*dg  & $D""  # #  z " "" "dQT* g  ..<< <  Z    D14( Gi,,::: n  rz raw_ops.Coshc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sCoshrErFrrrRs rArr rrT TV_Cross_Tz linalg.crosscrossc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aCompute the pairwise cross product. `a` and `b` must be the same shape; they can either be simple 3-element vectors, or any shape where the innermost dimension is 3. In the latter case, each pair of corresponding 3-element vectors is cross-multiplied independently. Args: a: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. A tensor containing 3-element vectors. b: A `Tensor`. Must have the same type as `a`. Another tensor, of same type and shape as `a`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. CrossNr r)rLrMr!r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_crossrcross_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6) rLrMr!r8r9r:r;r<r=r>r?r@s rArr s'*    0h..0$ #\\ 11 gtQ#g n,$ At tGn$ n  )::1&Aq#x QK' ""$3%%c* +F::L vw0 (' .W  & &- ##At,,  # #    % a-g  & ! QTt%%  # #  z " "" 2ta140 g  ..<< <  Z    TA. Gi,,::: n  rz raw_ops.CrosscVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$sCrossrErFrr2rHrIrLrMrPrrrOrNrQrJryrKr{r|rr3r6) rLrMr!r"rSrr@r?r:s rArr s_661vsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@ECD'9 &1aQ, >&   XqV!$4 1' ""$ vw0 (' .rT TV_Cumprod_TTV_Cumprod_Tidx exclusivereversec dtjxstj}|j}|jr t j |d|||d|d| }|S|d}tj|d}|d}tj|d}tj d|||||\} } } } | dd}tj"rjd| j%dd| j%dd| j'dd | j'd f} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYOwxYw) aCompute the cumulative product of the tensor `x` along `axis`. By default, this op performs an inclusive cumprod, which means that the first element of the input is identical to the first element of the output: ```python tf.cumprod([a, b, c]) # => [a, a * b, a * b * c] ``` By setting the `exclusive` kwarg to `True`, an exclusive cumprod is performed instead: ```python tf.cumprod([a, b, c], exclusive=True) # => [1, a, a * b] ``` By setting the `reverse` kwarg to `True`, the cumprod is performed in the opposite direction: ```python tf.cumprod([a, b, c], reverse=True) # => [a * b * c, b * c, c] ``` This is more efficient than using separate `tf.reverse` ops. The `reverse` and `exclusive` kwargs can also be combined: ```python tf.cumprod([a, b, c], exclusive=True, reverse=True) # => [b * c, c, 1] ``` Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. A `Tensor` of type `int32` (default: 0). Must be in the range `[-rank(x), rank(x))`. exclusive: An optional `bool`. Defaults to `False`. If `True`, perform exclusive cumprod. reverse: An optional `bool`. Defaults to `False`. A `bool` (default: False). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. CumprodrrNrrr!r"Frrrrr!r$r)r%rr&r'rr(r)r*r+r,r-cumprod_eager_fallbackr/r2rr0r1r3rr4r5r6rrrrr!r8r9r:r;r<r=r>r?r@s rAcumprodr sb    0h..0$ #\\ 11 iq$ Y gnI  K8) _G   w 2''88QTY!QX QK' ""$3--k:I  +S#2D2DS2Ic((02F::L <2 (' .9  & &- ##At,,  # #    # TYdNN  # #   0D<<FE**FFFF/.F/zraw_ops.Cumprodc(|d}tj|d}|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\}\}tj|g|tj tjgtj \}\}||g}d|d|d|d|f} tj.dd|| ||} tj0rtj2d || | | \} | S) NFrrr$rsCumprodrErFrr2rrHrIrLrMrPrrrOrNrsrQrtrurvrJrwrxryrzrKr{r|rr3r6 rrrrr!r"rSrr@r?r:s rArrJ s[I  K8) _G   w 2'111#sW__goo_f_l_lnun{n{~E~K~KMTMYMY[b[l[lnun{n{}D}J}JLSLZLZ\c\j\jlsl|l|~E~L~LNUN]N]_f_m_movoAoACJCOCOQXQ_Q_ahaoao=rs-'4A 77gmmU\UbUbEegngtgtu*gtT, IwWf  &   Z [a, a + b, a + b + c] ``` By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed instead: ```python tf.cumsum([a, b, c], exclusive=True) # => [0, a, a + b] ``` By setting the `reverse` kwarg to `True`, the cumsum is performed in the opposite direction: ```python tf.cumsum([a, b, c], reverse=True) # => [a + b + c, b + c, c] ``` This is more efficient than using separate `tf.reverse` ops. The `reverse` and `exclusive` kwargs can also be combined: ```python tf.cumsum([a, b, c], exclusive=True, reverse=True) # => [b + c, c, 0] ``` Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. A `Tensor` of type `int32` (default: 0). Must be in the range `[-rank(x), rank(x))`. exclusive: An optional `bool`. Defaults to `False`. If `True`, perform exclusive cumsum. reverse: An optional `bool`. Defaults to `False`. A `bool` (default: False). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. CumsumrrNrFrr$r)r%rr&r'rr(r)r*r+r,r-cumsum_eager_fallbackr/r2rr0r1r3rr4r5r6rs rAcumsumrb sb    0h..0$ #\\ 11 ha{IygnI  K8) _G   w 2''88ADIw!QX QK' ""$3--k:I  +S#2D2DS2Ic((02F::L ,1 (' .9  & &- ##At,,  # #    " TYdNN  # #   rzraw_ops.Cumsumc(|d}tj|d}|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\}\}tj|g|tj tjgtj \}\}||g}d|d|d|d|f} tj.dd|| ||} tj0rtj2d || | | \} | S) NFrrr$rsCumsumrErFrrrs rArr s[I  K8) _G   w 2'111#sW__goo_f_l_lnun{n{~E~K~KMTMYMY[b[l[lnun{n{}D}J}JLSLZLZ\c\j\jlsl|l|~E~L~LNUN]N]_f_m_movoAoACJCOCOQXQ_Q_ahaoao=rs-'4A 77gmmU\UbUbEegngtgtu*gtT, IwWf  &   Y,f!$4 1' ""$ ,1 (' .rTTV_CumulativeLogsumexp_TTV_CumulativeLogsumexp_Tidxc dtjxstj}|j}|jr t j |d|||d|d| }|S|d}tj|d}|d}tj|d}tj d|||||\} } } } | dd}tj"rjd| j%dd| j%dd| j'dd | j'd f} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYOwxYw) aCompute the cumulative product of the tensor `x` along `axis`. By default, this op performs an inclusive cumulative log-sum-exp, which means that the first element of the input is identical to the first element of the output: ```python tf.math.cumulative_logsumexp([a, b, c]) # => [a, log(exp(a) + exp(b)), log(exp(a) + exp(b) + exp(c))] ``` By setting the `exclusive` kwarg to `True`, an exclusive cumulative log-sum-exp is performed instead: ```python tf.cumulative_logsumexp([a, b, c], exclusive=True) # => [-inf, a, log(exp(a) * exp(b))] ``` Note that the neutral element of the log-sum-exp operation is `-inf`, however, for performance reasons, the minimal value representable by the floating point type is used instead. By setting the `reverse` kwarg to `True`, the cumulative log-sum-exp is performed in the opposite direction. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. A `Tensor`. Must be one of the following types: `float16`, `float32`, `float64`. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. A `Tensor` of type `int32` (default: 0). Must be in the range `[-rank(x), rank(x))`. exclusive: An optional `bool`. Defaults to `False`. If `True`, perform exclusive cumulative log-sum-exp. reverse: An optional `bool`. Defaults to `False`. A `bool` (default: False). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. CumulativeLogsumexprrNrFrr$r)r%rr&r'rr(r)r*r+r,r-#cumulative_logsumexp_eager_fallbackr/r2rr0r1r3rr4r5r6rs rAcumulative_logsumexpr sJ    0h..0$ #\\ 11 #T1dK7gnI  K8) _G   w 2''88'.T;!QX QK' ""$3--k:I  +S#2D2DS2Ic((02F::L |VW> (' .9  & &- ##At,,  # #    0 TYdNN  # #   rzraw_ops.CumulativeLogsumexpcf|d}tj|d}|d}tj|d}tj|g|tjtj tj tjg\}\}tj|g|tjtjgtj\}\}||g}d|d|d|d|f} tjdd|| ||} tjrtjd || | | \} | S) NFrrr$rsCumulativeLogsumexprErFr r2rrHrIrJrKrLrMrPrQrr3r6rs rArr" s#I  K8) _G   w 2'111#sW=M=Mw||]d]l]lnun}n}=AB-'4A 77gmmU\UbUbEegngtgtu*gtT, IwWf  &   3Q|#)s ?' ""$ |VW> (' .rTTV_DenseBincount_TidxTV_DenseBincount_T binary_outputc  tjxstj}|j}|jr t j |d||||d|}|S|d}tj|d}tj d|||||\} } } } | dd}tj"rYd| j%dd| j%dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY$wxYw) aCounts the number of occurrences of each value in an integer array. Outputs a vector with length `size` and the same dtype as `weights`. If `weights` are empty, then index `i` stores the number of times the value `i` is counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of the value in `weights` at each index where the corresponding value in `arr` is `i`. Values in `arr` outside of the range [0, size) are ignored. Args: input: A `Tensor`. Must be one of the following types: `int32`, `int64`. 1D or 2D int `Tensor`. size: A `Tensor`. Must have the same type as `input`. non-negative int scalar `Tensor`. weights: A `Tensor`. Must be one of the following types: `int32`, `int64`, `float32`, `float64`. is an int32, int64, float32, or float64 `Tensor` with the same shape as `arr`, or a length-0 `Tensor`, in which case it acts as all weights equal to 1. binary_output: An optional `bool`. Defaults to `False`. bool; Whether the kernel should count the appearance or number of occurrences. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `weights`. DenseBincountrNrr!r"F)rrVrWrr!rr$)r%rr&r'rr(r)r*r+r,r-dense_bincount_eager_fallbackr/r2rr0r1r3r4rr5r6)rrVrWrr!r8r9r:r;r<r=r>r?r@s rAdense_bincountr: s6    0h..0$ #\\ 11 otUD'?gnM$$]OD-'88u4'44A!QX QK' ""$c((0#  %  13F::L vw8 (' .5  & &- ##At,,  # #    * wm$  # #   s0DE#D>>EEE,,FFzraw_ops.DenseBincountc|d}tj|d}tj||g|tjtj g\}}|\}}tj|g|tjtj tj tjg\}\}|||g} d|d|d|f} tjdd| | ||} tjrtjd| | | | \} | S) NFrrr$s DenseBincountrErFr) r2rrHrIrPrQrLrMrr3r6) rrVrWrr!r"r _inputs_TidxrSr@r?r:s rArr| sM$$]OD-%<tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)a8Computes Psi, the derivative of Lgamma (the log of the absolute value of `Gamma(x)`), element-wise. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. DigammaNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_digammardigamma_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr s    0h..0$ #\\ 11 iq"g n,& D DGn$ n  )::QT#Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ' d*dg  & # $D""  # #  z " "" R- g  ..<< <  Z    2tad+ Gi,,::: n  rzraw_ops.Digammac\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sDigammarErFrr rRs rArr s111#sW=M=Mw||]d]l]lnun}n}=AB-'4A, >&   Z&   VQ|6!$4 1' ""$  |VW. (' .rT TV_DivNoNan_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aReturns 0 if the denominator is zero. *NOTE*: `DivNoNan` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `half`, `float32`, `bfloat16`, `float64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. DivNoNanNr rr$)r%rr&r'rr(r)r*r+r,r-div_no_nan_eager_fallbackr/r0r1r2r3r4r5r6rs rA div_no_nanr$ s=    0h..0$ #\\ 11 j$1&g n(88a14)!QX QK' ""$3%%c* +F::L L&'3 (' .'  & &- ##At,,  # #    & QTt%%  # #   rzraw_ops.DivNoNanc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sDivNoNanrErFr) r2rHrIrKrLrJrMrsrzrr3r6rs rArrR s661vsW\\SZSbSbdkdtdtv}wFwFHOHYHY[b[m[mEpq'9 &1aQ, >&   [!L#)s ?' ""$ L&'3 (' .rT) TV_Equal_TrrrVrWrhrrrirjrkrlrmrrrrnrrrXrYrZr[r\rorr]r^rpr_r`rincompatible_shape_errorc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rHd| j%dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aReturns the truth value of (x == y) element-wise. *NOTE*: `Equal` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) ```python x = tf.constant([2, 4]) y = tf.constant(2) tf.math.equal(x, y) ==> array([True, False]) x = tf.constant([2, 4]) y = tf.constant([2, 4]) tf.math.equal(x, y) ==> array([True, True]) ``` Args: x: A `Tensor`. y: A `Tensor`. Must have the same type as `x`. incompatible_shape_error: An optional `bool`. Defaults to `True`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. EqualrNrr!r"Trrrr!r$)r%rr&r'rr(r)r*r+r,r-equal_eager_fallbackr/r2rr0r1r3r4rr5r6 rrrr!r8r9r:r;r<r=r>r?r@s rAequalrb s2    0h..0$ #\\ 11 gtQ#= "gn%#%//0HJde'8814L!QX QK' ""$3%%c*,F  !;<>F::L vw0 (' .3  & &- ##At,,  # #    ! Q)A  # #   rz raw_ops.Equalc&|d}tj|d}tj||g|g\}}|\}}||g}d|d|f}tjdd||||} tjrtj d||| | \} | S)NTrr$sEqualrErFrr2rrHrr3r6 rrrr!r"rSrr@r?r:s rArr s%#%//0HJde661vsBG'9 &1aQ, 4 &   XqV!$4 1' ""$ vw0 (' .rTTV_Erf_Tzmath.erferfc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)u)Computes the [Gauss error function](https://en.wikipedia.org/wiki/Error_function) of `x` element-wise. In statistics, for non-negative values of $x$, the error function has the following interpretation: for a random variable $Y$ that is normally distributed with mean 0 and variance $1/\sqrt{2}$, $erf(x)$ is the probability that $Y$ falls in the range $[−x, x]$. For example: >>> tf.math.erf([[1.0, 2.0, 3.0], [0.0, -1.0, -2.0]]) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. ErfNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_erfrerf_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr s*    0h..0$ #\\ 11 eT1g n," D DGn$ n  ):: Aq#x QK' ""$3%%c* +F::L  |VW. (' .W  & &- ##At,,  # #    # d*dg  &  $D""  # #  z " "" TAD) g  ..<< <  Z    r4!$' Gi,,::: n  rz raw_ops.Erfc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sErfrErFrr rRs rAr r s111#sW=M=Mw||]d]l]lnun}n}=AB-'4A, >&   VQ|6!$4 1' ""$  |VW. (' .rT TV_Erfc_Tz math.erfcerfcc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes the complementary error function of `x` element-wise. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. ErfcNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_erfcrerfc_eager_fallbackr/rjrrr r rrrr0r1r2r3r4r5r6r7s rAr r s    0h..0$ #\\ 11 fdAg n,# D DGn$ n  )::!$ Aq#x QK' ""$3%%c* +F::L  fg/ (' .W  & &- ##At,,  # #    $ d*dg  & $D""  # #  z " "" "dQT* g  ..<< <  Z    D14( Gi,,::: n  rz raw_ops.Erfcc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sErfcrErFrr rRs rArrWrrT TV_Erfinv_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)TODO: add doc. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. ErfinvNr r#r$)r%rr&r'rr(r)r*r+r,r-erfinv_eager_fallbackr/r0r1r2r3r4r5r6r7s rAerfinvrfs7    0h..0$ #\\ 11 ha!g n(88AD"!QX QK' ""$3%%c* +F::L ,1 (' .'  & &- ##At,,  # #    " $D""  # #   rCzraw_ops.Erfinvc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sErfinvrErFrr rRs rArr111#sW=M=Mw||]d]l]lnun}n}=AB-'4A, >&   Y,f!$4 1' ""$ ,1 (' .rTTV_EuclideanNorm_TTV_EuclideanNorm_Tidxc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rYd| j%dd| j'dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY"wxYw) aComputes the euclidean norm of elements across dimensions of a tensor. Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1. Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. The tensor to reduce. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. The dimensions to reduce. Must be in the range `[-rank(input), rank(input))`. keep_dims: An optional `bool`. Defaults to `False`. If true, retain reduced dimensions with length 1. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. EuclideanNormrNrFrr$r)r%rr&r'rr(r)r*r+r,r-euclidean_norm_eager_fallbackr/r2rr0r1r3rr4r5r6rs rAeuclidean_normr s*    0h..0$ #\\ 11 otUD+yJg nI  K8)'88u#,49!QX QK' ""$3--k:C  %vs/A/A&/IKF::L vw8 (' .1  & &- ##At,,  # #    * 4AA  # #   0DE!D<<EEE))F?Fzraw_ops.EuclideanNormc|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\}\}tj|g|tj tjgtj \}\}||g}d|d|d|f}tj.dd||||} tj0rtj2d||| | \} | S) NFrr$rs EuclideanNormrErFrr rrrr!r"rSrr@r?r:s rArrsFI  K8)55ugsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjctctv}vCvCELERERT[TbTbdkdrdrt{tDtDFMFTFTV]VeVegnguguw~wIwIKRKWKWY`YgYgipiwiwEz{'8E 77gmmU\UbUbEegngtgtu*gt, C&* E&   -q#)s ?' ""$ vw8 (' .rTTV_Exp_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)a]Computes exponential of x element-wise. \\(y = e^x\\). This function computes the exponential of every element in the input tensor. i.e. `exp(x)` or `e^(x)`, where `x` is the input tensor. `e` denotes Euler's number and is approximately equal to 2.718281. Output is positive for any real input. ```python x = tf.constant(2.0) tf.math.exp(x) ==> 7.389056 x = tf.constant([2.0, 8.0]) tf.math.exp(x) ==> array([7.389056, 2980.958], dtype=float32) ``` For complex numbers, the exponential value is calculated as follows: ``` e^(x+iy) = e^x * e^iy = e^x * (cos y + i sin y) ``` Let's consider complex number 1+1j as an example. e^1 * (cos 1 + i sin 1) = 2.7182818284590 * (0.54030230586+0.8414709848j) ```python x = tf.constant(1 + 1j) tf.math.exp(x) ==> 1.4686939399158851+2.2873552871788423j ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. ExpNr r#r$)r%rr&r'rr(r)r*r+r,r-exp_eager_fallbackr/r0r1r2r3r4r5r6r7s rAexpr(s8J    0h..0$ #\\ 11 eT1g n(88 !QX QK' ""$3%%c* +F::L  |VW. (' .'  & &- ##At,,  # #     $D""  # #   rCz raw_ops.Expc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sExprErFr&rrRs rAr'r'/rrT TV_Expm1_Tz math.expm1expm1c >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes `exp(x) - 1` element-wise. i.e. `exp(x) - 1` or `e^(x) - 1`, where `x` is the input tensor. `e` denotes Euler's number and is approximately equal to 2.718281. ```python x = tf.constant(2.0) tf.math.expm1(x) ==> 6.389056 x = tf.constant([2.0, 8.0]) tf.math.expm1(x) ==> array([6.389056, 2979.958], dtype=float32) x = tf.constant(1 + 1j) tf.math.expm1(x) ==> (0.46869393991588515+2.2873552871788423j) ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. Expm1Nr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_expm1rexpm1_eager_fallbackr/rjrrr r+rrrr0r1r2r3r4r5r6r7s rAr+r+>s8    0h..0$ #\\ 11 gtQ g n,$ D DGn$ n  )::14!Aq#x QK' ""$3%%c* +F::L vw0 (' .W  & &- ##At,,  # #    % d*dg  & ! $D""  # #  z " "" 2tad+ g  ..<< <  Z    TAD) Gi,,::: n  rz raw_ops.Expm1c tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sExpm1rErFr-rrRs rAr/r/rrT TV_Floor_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)a Returns element-wise largest integer not greater than x. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. FloorNr r#r$)r%rr&r'rr(r)r*r+r,r-floor_eager_fallbackr/r0r1r2r3r4r5r6r7s rAfloorr57    0h..0$ #\\ 11 gtQ g n(8814!!QX QK' ""$3%%c* +F::L vw0 (' .'  & &- ##At,,  # #    ! $D""  # #   rCz raw_ops.Floorc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sFloorrErFr3r rRs rAr4r4111#sW=M=Mw||]d]l]lnun}n}=AB-'4A, >&   XqV!$4 1' ""$ vw0 (' .rT TV_FloorDiv_T floor_divc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns x // y element-wise. *NOTE*: `floor_div` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `uint32`, `uint64`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. FloorDivNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_floor_divrfloor_div_eager_fallbackr/rjrrr r:rrrr0r1r2r3r4r5r6rs rAr:r:s'$    0h..0$ #\\ 11 j$1&g n,( At tGn$ n  )::a14)Aq#x QK' ""$3%%c* +F::L L&'3 (' .W  & &- ##At,,  # #    ) a-g  & % QTt%%  # #  z " "" r4!qt4 g  ..<< <  Z    RQT2 Gi,,::: n  rzraw_ops.FloorDivctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj g\}}|\}}||g}d|f}tj"dd||||}tj$rtj&d||||\}|S)Nr$sFloorDivrErFr<rrs rAr>r>#s661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WcWcelesesu|uBuBDKDQDQSZSaSacjcqcqszs@s@BIBSBSU\UgUgEjk'9 &1aQ, >&   [!L#)s ?' ""$ L&'3 (' .rT TV_FloorMod_T math.floormodmath.mod)rAfloormodrBmodrCrDc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns element-wise remainder of division. This follows Python semantics in that the result here is consistent with a flooring divide. E.g. `floor(x / y) * y + floormod(x, y) = x`, regardless of the signs of x and y. *NOTE*: `math.floormod` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`, `bfloat16`, `half`, `float32`, `float64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. FloorModNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_floor_modrfloor_mod_eager_fallbackr/rjrrr floor_modrrrr0r1r2r3r4r5r6rs rArIrI3s',    0h..0$ #\\ 11 j$1&g n,( At tGn$ n  )::a14)Aq#x QK' ""$3%%c* +F::L L&'3 (' .W  & &- ##At,,  # #    ) a-g  & % QTt%%  # #  z " "" r4!qt4 g  ..<< <  Z    RQT2 Gi,,::: n  rzraw_ops.FloorModcVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$sFloorModrErFrF)r2rHrIrNrOrPrQrrryr{r|rJrKrLrMrr3r6rs rArHrHsW661vsW\\SZS`S`biboboqxq~q~AHANANPWP^P^`g`n`npwp~p~@G@P@PRYR^R^`g`o`oqxq@q@ECD'9 &1aQ, >&   [!L#)s ?' ""$ L&'3 (' .rT TV_Greater_Tz math.greatergreaterc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns the truth value of (x > y) element-wise. *NOTE*: `math.greater` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Example: ```python x = tf.constant([5, 4, 6]) y = tf.constant([5, 2, 5]) tf.math.greater(x, y) ==> [False, True, True] x = tf.constant([5, 4, 6]) y = tf.constant([5]) tf.math.greater(x, y) ==> [False, False, True] ``` Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. GreaterNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_greaterrgreater_eager_fallbackr/rjrrr rLrrrr0r1r2r3r4r5r6rs rArLrLs':    0h..0$ #\\ 11 iq!%g n,& At tGn$ n  )::Q!$(Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ' a-g  & # QTt%%  # #  z " "" RQT2 g  ..<< <  Z    2ta140 Gi,,::: n  rzraw_ops.GreatercVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$sGreaterrErFrNrrs rArPrPs_661vsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@ECD'9 &1aQ, >&   Z= y) element-wise. *NOTE*: `math.greater_equal` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Example: ```python x = tf.constant([5, 4, 6, 7]) y = tf.constant([5, 2, 5, 10]) tf.math.greater_equal(x, y) ==> [True, True, True, False] x = tf.constant([5, 4, 6, 7]) y = tf.constant([5]) tf.math.greater_equal(x, y) ==> [True, False, True, True] ``` Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. GreaterEqualNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_greater_equalrgreater_equal_eager_fallbackr/rjrrr rSrrrr0r1r2r3r4r5r6rs rArSrSs':    0h..0$ #\\ 11 ndAq*g n,, At tGn$ n  )::!qt-Aq#x QK' ""$3%%c* +F::L  fg7 (' .W  & &- ##At,,  # #    - a-g  & ) QTt%%  # #  z " "" 2ta148 g  ..<< <  Z    TA6 Gi,,::: n  rzraw_ops.GreaterEqualcVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$s GreaterEqualrErFrUrrs rArWrWKs_661vsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@ECD'9 &1aQ, >&   _a #)s ?' ""$  fg7 (' .rTTV_HistogramFixedWidth_TTV_HistogramFixedWidth_dtypevalues value_rangenbinsdtypec tjxstj}|j}|jr t j |d||||d|}|S|tj}tj |d}t#j$d|||||\} } } } | dd}tj&rHd| j)dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY!wxYw)aReturn histogram of values. Given the tensor `values`, this operation returns a rank 1 histogram counting the number of entries in `values` that fall into every bin. The bins are equal width and determined by the arguments `value_range` and `nbins`. ```python # Bins will be: (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf) nbins = 5 value_range = [0.0, 5.0] new_values = [-1.0, 0.0, 1.5, 2.0, 5.0, 15] with tf.get_default_session() as sess: hist = tf.histogram_fixed_width(new_values, value_range, nbins=5) variables.global_variables_initializer().run() sess.run(hist) => [2, 1, 1, 0, 2] ``` Args: values: A `Tensor`. Must be one of the following types: `int32`, `int64`, `float32`, `float64`. Numeric `Tensor`. value_range: A `Tensor`. Must have the same type as `values`. Shape [2] `Tensor` of same `dtype` as `values`. values <= value_range[0] will be mapped to hist[0], values >= value_range[1] will be mapped to hist[-1]. nbins: A `Tensor` of type `int32`. Scalar `int32 Tensor`. Number of histogram bins. dtype: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int32`. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. HistogramFixedWidthr^Nr^r!r")r[r\r]r^r!r$)r%rr&r'rr(r)r*r+r,r-%_histogram_fixed_width_eager_fallbackr/rIrPr2rr0r1r3r4r5r6)r[r\r]r^r!r8r9r:r;r<r=r>r?r@s rA_histogram_fixed_widthrc\sD    0h..0$ #\\ 11 #T6;gn ] MME   UG ,%'88f+%*%dD!QX QK' ""$3%%c*G  )+F::L |VW> (' .1  & &- ##At,,  # #    2 +uE$HH  # #   s0D E D;;EEE))F?Fzraw_ops.HistogramFixedWidthc|tj}tj|d}tj||g|tjtj tj tjg\}}|\}}tj|tj}|||g}d|d|f} tjdd|| ||} tjrtjd|| | | \} | S)Nr^r$sHistogramFixedWidthrErFr`) rIrPr2rrHrQrLrMr+rrr3r6) r[r\r]r^r!r"rSrr@r?r:s rArbrbs ] MME   UG ,%66 7LcT[TaTacjcpcprysBsBDKDSDSTVW'9#6;   6%+u-, '5 )&   3Q|#)s ?' ""$ |VW> (' .rT TV_Igamma_Tz math.igammaigammac Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aCompute the lower regularized incomplete Gamma function `P(a, x)`. The lower regularized incomplete Gamma function is defined as: \\(P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)\\) where \\(gamma(a, x) = \int_{0}^{x} t^{a-1} exp(-t) dt\\) is the lower incomplete Gamma function. Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete Gamma function. Args: a: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. x: A `Tensor`. Must have the same type as `a`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. IgammaNr rrLrr!r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_igammarigamma_eager_fallbackr/rjrrr rfrrrr0r1r2r3r4r5r6 rLrr!r8r9r:r;r<r=r>r?r@s rArfrfs':    0h..0$ #\\ 11 ha$g n,% At tGn$ n  )::A'Aq#x QK' ""$3%%c* +F::L ,1 (' .W  & &- ##At,,  # #    & a-g  & " QTt%%  # #  z " "" BqAD1 g  ..<< <  Z    "dQ!$/ Gi,,::: n  rzraw_ops.Igammacftj||g|tjtjtj tj g\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sIgammarErFrhr  rLrr!r"rSrr@r?r:s rArkrk s661vsWEUEUW^WcWceletetv}wFwFEIJ'9 &1aQ, >&   Y,f!$4 1' ""$ ,1 (' .rTTV_IgammaGradA_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)a!Computes the gradient of `igamma(a, x)` wrt `a`. Args: a: A `Tensor`. Must be one of the following types: `float32`, `float64`. x: A `Tensor`. Must have the same type as `a`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. IgammaGradANr rir$)r%rr&r'rr(r)r*r+r,r-igamma_grad_a_eager_fallbackr/r0r1r2r3r4r5r6rls rA igamma_grad_arss=    0h..0$ #\\ 11 mT1a)g n(88ad,!QX QK' ""$3%%c* +F::L |VW6 (' .'  & &- ##At,,  # #    ) QTt%%  # #   rzraw_ops.IgammaGradAc*tj||g|tjtjg\}}|\}}||g}d|f}tj dd||||}tj rtjd||||\}|S)Nr$s IgammaGradArErFrqrSrns rArrrrFs661vsW__V]VeVeDhi'9 &1aQ, >&   ^Q|#)s ?' ""$ |VW6 (' .rT TV_Igammac_Tz math.igammacigammacc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aCompute the upper regularized incomplete Gamma function `Q(a, x)`. The upper regularized incomplete Gamma function is defined as: \\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\\) where \\(Gamma(a, x) = \int_{x}^{\infty} t^{a-1} exp(-t) dt\\) is the upper incomplete Gamma function. Note, above `P(a, x)` (`Igamma`) is the lower regularized complete Gamma function. Args: a: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. x: A `Tensor`. Must have the same type as `a`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. IgammacNr rrir$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_igammacrigammac_eager_fallbackr/rjrrr rvrrrr0r1r2r3r4r5r6rls rArvrvVs'8    0h..0$ #\\ 11 iq!%g n,& At tGn$ n  )::Q!$(Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ' a-g  & # QTt%%  # #  z " "" RQT2 g  ..<< <  Z    2ta140 Gi,,::: n  rzraw_ops.Igammaccftj||g|tjtjtj tj g\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sIgammacrErFrxr rns rArzrzs661vsWEUEUW^WcWceletetv}wFwFEIJ'9 &1aQ, >&   Z [4.75, 5.75] ``` Args: input: A `Tensor`. Must be one of the following types: `complex64`, `complex128`. Tout: An optional `tf.DType` from: `tf.float32, tf.float64`. Defaults to `tf.float32`. name: A name for the operation (optional). Returns: A `Tensor` of type `Tout`. ImagrNrrr$)r%rr&r'rr(r)r*r+r,r-imag_eager_fallbackr/rIrLr2rr0r1r3r4r5r6rs rArrq.    0h..0$ #\\ 11 fdE641g n \ ??D   D& )$'88e$T3!QX QK' ""$3%%c*F  (*F::L  fg/ (' ./  & &- ##At,,  # #    d411  # #   rz raw_ops.Imagc|tj}tj|d}tj|g|tj tj gtj \}\}|g}d|d|f}tjdd||||}tjrtjd||||\}|S)Nrr$sImagrErFrrrs rArr \ ??D   D& )$55ugsWEVEVX_XjXjDmovpApAB'8E, &$ '&   Wa F!$4 1' ""$  fg/ (' .rTTV_Inv_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)TComputes the reciprocal of x element-wise. I.e., \\(y = 1 / x\\). Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. InvNr r#r$)r%rr&r'rr(r)r*r+r,r-inv_eager_fallbackr/r0r1r2r3r4r5r6r7s rAinvrs7    0h..0$ #\\ 11 eT1g n(88 !QX QK' ""$3%%c* +F::L  |VW. (' .'  & &- ##At,,  # #     $D""  # #   rCz raw_ops.Invctj|g|tjtjtj tj tjtjtjtjtjtjg \}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sInvrErFrr2rHrIrJrKrLrMrNrOrPrQrsrzrr3r6rRs rArr2111#sW=M=Mw||]d]l]lnun}n}@G@L@LNUN[N[]d]j]jlslyly{B{L{LNUN`N`=cd-'4A, >&   VQ|6!$4 1' ""$  |VW. (' .rT TV_InvGrad_Tdyctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)Computes the gradient for the inverse of `x` wrt its input. Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy` is the corresponding input gradient. Args: y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. dy: A `Tensor`. Must have the same type as `y`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `y`. InvGradNr rrr!r$)r%rr&r'rr(r)r*r+r,r-inv_grad_eager_fallbackr/r0r1r2r3r4r5r6 rrr!r8r9r:r;r<r=r>r?r@s rAinv_gradrAs=    0h..0$ #\\ 11 iq"&g n(88Q2D*!QX QK' ""$3%%c* +F::L <2 (' .'  & &- ##At,,  # #    $ Rd&&  # #   rzraw_ops.InvGradc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sInvGradrErFrr rrr!r"rSrr@r?r:s rArrns662wgFVFVX_XdXdfmfufuw~xGxGIPIZIZ\c\n\nFqr'9 '1bR, >&   Ztjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aReturns which elements of x are finite. @compatibility(numpy) Equivalent to np.isfinite @end_compatibility Example: ```python x = tf.constant([5.0, 4.8, 6.8, np.inf, np.nan]) tf.math.is_finite(x) ==> [True, True, True, False, False] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. IsFiniteNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_is_finiteris_finite_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr~s2    0h..0$ #\\ 11 j$#g n,( D DGn$ n  )::ad$Aq#x QK' ""$3%%c* +F::L L&'3 (' .W  & &- ##At,,  # #    ) d*dg  & % $D""  # #  z " "" r4!$/ g  ..<< <  Z    R- Gi,,::: n  rzraw_ops.IsFinitec\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sIsFiniterErFrr rRs rArrs111#sW=M=Mw||]d]l]lnun}n}=AB-'4A, >&   [!L#)s ?' ""$ L&'3 (' .rT TV_IsInf_T math.is_inf)rdebugging.is_infis_infrrc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aReturns which elements of x are Inf. @compatibility(numpy) Equivalent to np.isinf @end_compatibility Example: ```python x = tf.constant([5.0, np.inf, 6.8, np.inf]) tf.math.is_inf(x) ==> [False, True, False, True] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. IsInfNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_is_infris_inf_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr2    0h..0$ #\\ 11 gtQ g n,% D DGn$ n  )::14!Aq#x QK' ""$3%%c* +F::L vw0 (' .W  & &- ##At,,  # #    & d*dg  & " $D""  # #  z " "" Bqt, g  ..<< <  Z    "dQT* Gi,,::: n  rz raw_ops.IsInfc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sIsInfrErFrr rRs rArr/r8rT TV_IsNan_T math.is_nan)rdebugging.is_nanis_nanrrc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aReturns which elements of x are NaN. @compatibility(numpy) Equivalent to np.isnan @end_compatibility Example: ```python x = tf.constant([5.0, np.nan, 6.8, np.nan, np.inf]) tf.math.is_nan(x) ==> [False, True, False, True, False] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. IsNanNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_is_nanris_nan_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr>rrz raw_ops.IsNanc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sIsNanrErFrr rRs rArrr8rT TV_Less_Tz math.lesslessc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns the truth value of (x < y) element-wise. *NOTE*: `math.less` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Example: ```python x = tf.constant([5, 4, 6]) y = tf.constant([5]) tf.math.less(x, y) ==> [False, True, False] x = tf.constant([5, 4, 6]) y = tf.constant([5, 6, 7]) tf.math.less(x, y) ==> [False, True, True] ``` Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. LessNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_lessrless_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6rs rArrs':    0h..0$ #\\ 11 fdAq"g n,# At tGn$ n  )::!qt%Aq#x QK' ""$3%%c* +F::L  fg/ (' .W  & &- ##At,,  # #    $ a-g  & QTt%%  # #  z " "" "dQ!$/ g  ..<< <  Z    D1- Gi,,::: n  rz raw_ops.LesscVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$sLessrErFrrrs rArrs_661vsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@ECD'9 &1aQ, >&   Wa F!$4 1' ""$  fg/ (' .rTTV_LessEqual_Tzmath.less_equal less_equalc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns the truth value of (x <= y) element-wise. *NOTE*: `math.less_equal` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Example: ```python x = tf.constant([5, 4, 6]) y = tf.constant([5]) tf.math.less_equal(x, y) ==> [True, True, False] x = tf.constant([5, 4, 6]) y = tf.constant([5, 6, 6]) tf.math.less_equal(x, y) ==> [True, True, True] ``` Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. LessEqualNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_less_equalrless_equal_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6rs rArrs':    0h..0$ #\\ 11 k4A'g n,) At tGn$ n  )::qAD*Aq#x QK' ""$3%%c* +F::L \674 (' .W  & &- ##At,,  # #    * a-g  & & QTt%%  # #  z " "" D15 g  ..<< <  Z    b$ad3 Gi,,::: n  rzraw_ops.LessEqualcVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$s LessEqualrErFrrrs rArrXs_661vsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@ECD'9 &1aQ, >&   \1\#)s ?' ""$ \674 (' .rT TV_Lgamma_Tz math.lgammalgammac >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aMComputes the log of the absolute value of `Gamma(x)` element-wise. For positive numbers, this function computes log((input - 1)!) for every element in the tensor. `lgamma(5) = log((5-1)!) = log(4!) = log(24) = 3.1780539` Example: ```python x = tf.constant([0, 0.5, 1, 4.5, -4, -5.6]) tf.math.lgamma(x) ==> [inf, 0.5723649, 0., 2.4537368, inf, -4.6477685] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. LgammaNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_lgammarlgamma_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArrhs0    0h..0$ #\\ 11 ha!g n,% D DGn$ n  )::AD"Aq#x QK' ""$3%%c* +F::L ,1 (' .W  & &- ##At,,  # #    & d*dg  & " $D""  # #  z " "" Bqt, g  ..<< <  Z    "dQT* Gi,,::: n  rzraw_ops.Lgammac\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sLgammarErFrr rRs rArrrrT TV_LinSpace_TTV_LinSpace_Tidxstartstopnumctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj rHd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)a7Generates values in an interval. A sequence of `num` evenly-spaced values are generated beginning at `start`. If `num > 1`, the values in the sequence increase by `(stop - start) / (num - 1)`, so that the last one is exactly `stop`. For example: ``` tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0 11.0 12.0] ``` Args: start: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 0-D tensor. First entry in the range. stop: A `Tensor`. Must have the same type as `start`. 0-D tensor. Last entry in the range. num: A `Tensor`. Must be one of the following types: `int32`, `int64`. 0-D tensor. Number of values to generate. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `start`. LinSpaceNr )rrrr!r$r)r%rr&r'rr(r)r*r+r,r-lin_space_eager_fallbackr/r0r1r2r3r4r5r6) rrrr!r8r9r:r;r<r=r>r?r@s rA lin_spacersV2    0h..0$ #\\ 11 j$tS2g n(88%d$@!QX QK' ""$3%%c*F  (*F::L L&'3 (' .)  & &- ##At,,  # #    % s411  # #   s0C""D)5DD)(D)-D==EEzraw_ops.LinSpacectj||g|tjtjtj tj g\}}|\}}tj|g|tjtjgtj\}\}|||g}d|d|f} tjdd|| ||} tjrtjd|| | | \} | S)Nr$rsLinSpacerErFr) r2rHrIrJrKrLrMrPrQrr3r6) rrrr!r"rSrrr@r?r:s rArrs66t}cGL\L\^e^j^jlsl{l{~E~M~MLPQ'9-5$66ucGMMSZS`S`Ccelerers*fss#, &* -&   [!L#)s ?' ""$ L&'3 (' .rTTV_Log_Tzmath.loglogc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)a%Computes natural logarithm of x element-wise. I.e., \\(y = \log_e x\\). Example: >>> x = tf.constant([0, 0.5, 1, 5]) >>> tf.math.log(x) See: https://en.wikipedia.org/wiki/Logarithm Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. LogNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_logrlog_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArrrrz raw_ops.Logc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sLogrErFrrrRs rArrarrT TV_Log1p_Tz math.log1plog1pc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes natural logarithm of (1 + x) element-wise. I.e., \\(y = \log_e (1 + x)\\). Example: >>> x = tf.constant([0, 0.5, 1, 5]) >>> tf.math.log1p(x) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. Log1pNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_log1prlog1p_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArrprrz raw_ops.Log1pc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sLog1prErFrrrRs rArrrrTzmath.logical_and logical_andc *tjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r&d} |j6} t3j8d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns the truth value of x AND y element-wise. Logical AND function. Requires that `x` and `y` have the same shape or have [broadcast-compatible](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) shapes. For example, `x` and `y` can be: - Two single elements of type `bool`. - One `tf.Tensor` of type `bool` and one single `bool`, where the result will be calculated by applying logical AND with the single element to each element in the larger Tensor. - Two `tf.Tensor` objects of type `bool` of the same shape. In this case, the result will be the element-wise logical AND of the two input tensors. You can also use the `&` operator instead. Usage: >>> a = tf.constant([True]) >>> b = tf.constant([False]) >>> tf.math.logical_and(a, b) >>> a & b >>> c = tf.constant([True]) >>> x = tf.constant([False, True, True, False]) >>> tf.math.logical_and(c, x) >>> c & x >>> y = tf.constant([False, False, True, True]) >>> z = tf.constant([False, True, False, True]) >>> tf.math.logical_and(y, z) >>> y & z This op also supports broadcasting >>> tf.logical_and([[True, False]], [[True], [False]]) The reduction version of this elementwise operation is `tf.math.reduce_all`. Args: x: A `tf.Tensor` of type bool. y: A `tf.Tensor` of type bool. name: A name for the operation (optional). Returns: A `tf.Tensor` of type bool with the shape that `x` and `y` broadcast to. Args: x: A `Tensor` of type `bool`. y: A `Tensor` of type `bool`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. LogicalAndNr rr)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_logical_andrlogical_and_eager_fallbackr/rjrrr rrrrr0r1r2r3r5r6rs rArrsJ    0h..0$ #\\ 11 lD!Q(g n,* At tGn$ n  )::QT+Aq#x QK' ""$ F::L lFG5 (' .W  & &- ##At,,  # #    + a-g  & ' QTt%%  # #  z " "" TA6 g  ..<< <  Z    r4!qt4 Gi,,::: n  PC5F:D+DDD#E <E F7 AF75F7:AHHzraw_ops.LogicalAndc8tj|tj}tj|tj}||g}d}t j dd||||}t j rt jd||||\}|S)Ns LogicalAndrErFrr+rrIrr2rr3r6rrr!r"r@r?r:s rArrGs Q -! Q -!Q, &   ]Al#)s ?' ""$ lFG5 (' .rTzmath.logical_not logical_notc tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r&d} |j6} t3j8d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aYReturns the truth value of `NOT x` element-wise. Example: >>> tf.math.logical_not(tf.constant([True, False])) Args: x: A `Tensor` of type `bool`. A `Tensor` of type `bool`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. LogicalNotNr rr#)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_logical_notrlogical_not_eager_fallbackr/rjrrr rrrrr0r1r2r3r5r6r7s rArrUs $    0h..0$ #\\ 11 lD!%g n,* D DGn$ n  )::&Aq#x QK' ""$ F::L lFG5 (' .W  & &- ##At,,  # #    + d*dg  & ' $D""  # #  z " "" TAD1 g  ..<< <  Z    r4!$/ Gi,,::: n  sPC3F4D(DDD E8 EF1AF1/F14AH  H zraw_ops.LogicalNotctj|tj}|g}d}t j dd||||}t j rt jd||||\}|S)Ns LogicalNotrErFrr)rr!r"r@r?r:s rArrsp Q -!, &   ]Al#)s ?' ""$ lFG5 (' .rTzmath.logical_or logical_orc *tjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r&d} |j6} t3j8d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns the truth value of x OR y element-wise. Logical OR function. Requires that `x` and `y` have the same shape or have [broadcast-compatible](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) shapes. For example, `x` and `y` can be: - Two single elements of type `bool`. - One `tf.Tensor` of type `bool` and one single `bool`, where the result will be calculated by applying logical OR with the single element to each element in the larger Tensor. - Two `tf.Tensor` objects of type `bool` of the same shape. In this case, the result will be the element-wise logical OR of the two input tensors. You can also use the `|` operator instead. Usage: >>> a = tf.constant([True]) >>> b = tf.constant([False]) >>> tf.math.logical_or(a, b) >>> a | b >>> c = tf.constant([False]) >>> x = tf.constant([False, True, True, False]) >>> tf.math.logical_or(c, x) >>> c | x >>> y = tf.constant([False, False, True, True]) >>> z = tf.constant([False, True, False, True]) >>> tf.math.logical_or(y, z) >>> y | z This op also supports broadcasting >>> tf.logical_or([[True, False]], [[True], [False]]) The reduction version of this elementwise operation is `tf.math.reduce_any`. Args: x: A `tf.Tensor` of type bool. y: A `tf.Tensor` of type bool. name: A name for the operation (optional). Returns: A `tf.Tensor` of type bool with the shape that `x` and `y` broadcast to. Args: x: A `Tensor` of type `bool`. y: A `Tensor` of type `bool`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. LogicalOrNr rr)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_logical_orrlogical_or_eager_fallbackr/rjrrr rrrrr0r1r2r3r5r6rs rArrsJ    0h..0$ #\\ 11 k4A'g n,) At tGn$ n  )::qAD*Aq#x QK' ""$ F::L \674 (' .W  & &- ##At,,  # #    * a-g  & & QTt%%  # #  z " "" D15 g  ..<< <  Z    b$ad3 Gi,,::: n  rzraw_ops.LogicalOrc8tj|tj}tj|tj}||g}d}t j dd||||}t j rt jd||||\}|S)Ns LogicalOrrErFrrrs rArr)s Q -! Q -!Q, &   \1\#)s ?' ""$ \674 (' .rT TV_MatMul_T transpose_a transpose_bgrad_agrad_bctjxstj}|j}|jr$ t j |d|||d|d|d|d| } | S|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj d||||||| \} } } } | dd} tj"r{d| j%dd| j%dd | j'd d| j%dd| j%df }| j(}tj*d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||S#t j$rYwxYw) aMultiply the matrix "a" by the matrix "b". The inputs must be two-dimensional matrices and the inner dimension of "a" (after being transposed if transpose_a is true) must match the outer dimension of "b" (after being transposed if transposed_b is true). *Note*: The default kernel implementation for MatMul on GPUs uses cublas. Args: a: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`, `complex64`, `complex128`. b: A `Tensor`. Must have the same type as `a`. transpose_a: An optional `bool`. Defaults to `False`. If true, "a" is transposed before multiplication. transpose_b: An optional `bool`. Defaults to `False`. If true, "b" is transposed before multiplication. grad_a: An optional `bool`. Defaults to `False`. grad_b: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. MatMulrrrrN)rrrrr!r"F)rLrMrrrrr!r$)r%rr&r'rr(r)r*r+r,r-mat_mul_eager_fallbackr/r2rr0r1r3rr4r5r6)rLrMrrrrr!r8r9r:r;r<r=r>r?r@s rAmat_mulr9s2    0h..0$ #\\ 11 haM; Xvx9gnK""; >+K""; >+ ^ F   fh /& ^ F   fh /&'88A T;!QX QK' ""$S// >   /c6H6H6M**84h  *,F::L ,1 (' .I  & &- ##At,,  # #    # QK[Tt==  # #   r4zraw_ops.MatMulc6|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj||g|tjtj tj tjtjtjtjtjtjtjtjtjg \}} | \}}||g} d|d|d|d|d|f } tj dd| | || } tj"rtj$d | | | | \} | S) NFrrrrr$sMatMulrErFr)r2rrHrIrJrKrLrMrPrQrrryr{r|rsrzrr3r6) rLrMrrrrr!r"rSrr@r?r:s rArrsK""; >+K""; >+ ^ F   fh /& ^ F   fh /&661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WdWdfmfsfsu|uCuCELESESU\UcUcelevevxxJxJEMN'9 &1aQ, ; {C 8VXv /&   Y,f!$4 1' ""$ ,1 (' .rTTV_Max_T TV_Max_Tidxc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rYd| j%dd| j'dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY"wxYw) aComputes the maximum of elements across dimensions of a tensor. Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1. Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. The tensor to reduce. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. The dimensions to reduce. Must be in the range `[-rank(input), rank(input))`. keep_dims: An optional `bool`. Defaults to `False`. If true, retain reduced dimensions with length 1. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. MaxrNrFrr$r)r%rr&r'rr(r)r*r+r,r-_max_eager_fallbackr/r2rr0r1r3rr4r5r6rs rA_maxr*    0h..0$ #\\ 11 eT5$ Y@g nI  K8)'88 Udi!QX QK' ""$3--k:C  %vs/A/A&/IKF::L  |VW. (' .1  & &- ##At,,  # #    4AA  # #   r!z raw_ops.Maxc|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(g\}\}tj|g|tj tjgtj \}\}||g}d|d|d|f}tj*dd||||} tj,rtj.d||| | \} | S) NFrr$rsMaxrErFrr2rrHrIrLrMrPrrrOrNrQrJryrKr{r|rtrurvrwrxrr3r6r#s rArrI  K8)55ugsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@BIBOBOQXQ_Q_ahaoaoqxqqAHAPAPEST'8E 77gmmU\UbUbEegngtgtu*gt, C&* E&   VQ|6!$4 1' ""$  |VW. (' .rT TV_Maximum_Tz math.maximummaximumc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns the max of x and y (i.e. x > y ? x : y) element-wise. Example: >>> x = tf.constant([0., 0., 0., 0.]) >>> y = tf.constant([-2., 0., 2., 5.]) >>> tf.math.maximum(x, y) Note that `maximum` supports [broadcast semantics](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) for `x` and `y`. >>> x = tf.constant([-5., 0., 0., 0.]) >>> y = tf.constant([-3.]) >>> tf.math.maximum(x, y) The reduction version of this elementwise operation is `tf.math.reduce_max` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `uint8`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. MaximumNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_maximumrmaximum_eager_fallbackr/rjrrr r rrrr0r1r2r3r4r5r6rs rAr r s'<    0h..0$ #\\ 11 iq!%g n,& At tGn$ n  )::Q!$(Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ' a-g  & # QTt%%  # #  z " "" RQT2 g  ..<< <  Z    2ta140 Gi,,::: n  rzraw_ops.MaximumcVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$sMaximumrErFr r2rHrIrJrKrLrMrNrrrOryrPr{rQr|rr3r6rs rArrCa661vsWEUEUW^WcWceletetv}wFwFHOHTHTV]VcVcelerert{tBtBDKDQDQSZSaSacjcpcpryr@r@ECD'9 &1aQ, >&   Z>> x = tf.constant([0., 0., 0., 0.]) >>> y = tf.constant([-5., -2., 0., 3.]) >>> tf.math.minimum(x, y) Note that `minimum` supports [broadcast semantics](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) for `x` and `y`. >>> x = tf.constant([-5., 0., 0., 0.]) >>> y = tf.constant([-3.]) >>> tf.math.minimum(x, y) The reduction version of this elementwise operation is `tf.math.reduce_min` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `uint8`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. MinimumNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_minimumrminimum_eager_fallbackr/rjrrr r$rrrr0r1r2r3r4r5r6rs rAr$r$s(B    0h..0$ #\\ 11 iq!%g n,& At tGn$ n  )::Q!$(Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ' a-g  & # QTt%%  # #  z " "" RQT2 g  ..<< <  Z    2ta140 Gi,,::: n  rzraw_ops.MinimumcVtj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tj rtj"d||||\}|S)Nr$sMinimumrErFr&rrs rAr(r(FrrTTV_Mod_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)akReturns element-wise remainder of division. This emulates C semantics in that the result here is consistent with a truncating divide. E.g. `tf.truncatediv(x, y) * y + truncate_mod(x, y) = x`. *NOTE*: `Mod` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `int32`, `int64`, `half`, `half`, `bfloat16`, `float32`, `float64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. ModNr rr$)r%rr&r'rr(r)r*r+r,r-mod_eager_fallbackr/r0r1r2r3r4r5r6rs rArDrDVs="    0h..0$ #\\ 11 eT1a!g n(88 ad$!QX QK' ""$3%%c* +F::L  |VW. (' .'  & &- ##At,,  # #     QTt%%  # #   rz raw_ops.Modc tj||g|tjtjtj tj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sModrErFr,) r2rHrIrPrQrKrJrLrMrr3r6rs rAr-r-s661vsW]]T[TaTacjcocoqxq}q}@G@P@PRYRaRacjcrcrEuv'9 &1aQ, >&   VQ|6!$4 1' ""$  |VW. (' .rTTV_Mul_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aReturns x * y element-wise. *NOTE*: `Multiply` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `uint32`, `uint64`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. MulNr rr$)r%rr&r'rr(r)r*r+r,r-mul_eager_fallbackr/r0r1r2r3r4r5r6rs rAmulr3rrz raw_ops.Mulctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj g\}}|\}}||g}d|f}tj"dd||||}tj$rtj&d||||\}|S)Nr$sMulrErFr1rrs rAr2r2rrT TV_MulNoNan_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aReturns x * y element-wise. Returns zero if y is zero, even if x if infinite or NaN. *NOTE*: `MulNoNan` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. MulNoNanNr rr$)r%rr&r'rr(r)r*r+r,r-mul_no_nan_eager_fallbackr/r0r1r2r3r4r5r6rs rA mul_no_nanr9s=    0h..0$ #\\ 11 j$1&g n(88a14)!QX QK' ""$3%%c* +F::L L&'3 (' .'  & &- ##At,,  # #    & QTt%%  # #   rzraw_ops.MulNoNanc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sMulNoNanrErFr7rrs rAr8r8s661vsWEUEUW^WcWceletetv}wFwFHOHYHY[b[m[mEpq'9 &1aQ, >&   [!L#)s ?' ""$ L&'3 (' .rT TV_Ndtri_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)rNdtriNr r#r$)r%rr&r'rr(r)r*r+r,r-ndtri_eager_fallbackr/r0r1r2r3r4r5r6r7s rAndtrir?r6rCz raw_ops.Ndtric\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sNdtrirErFr=r rRs rAr>r>9r8rTTV_Neg_Tz math.negativenegativec >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aVComputes numerical negative value element-wise. I.e., \\(y = -x\\). Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. NegNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_negrneg_eager_fallbackr/rjrrr negrrrr0r1r2r3r4r5r6r7s rArGrGHs    0h..0$ #\\ 11 eT1g n," D DGn$ n  ):: Aq#x QK' ""$3%%c* +F::L  |VW. (' .W  & &- ##At,,  # #    # d*dg  &  $D""  # #  z " "" TAD) g  ..<< <  Z    r4!$' Gi,,::: n  rz raw_ops.Negctj|g|tjtjtj tj tjtjtjtjtjtjg \}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sNegrErFrDrrRs rArFrFrrTTV_NextAfter_Tzmath.nextafterx1x2c Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns the next representable value of `x1` in the direction of `x2`, element-wise. This operation returns the same result as the C++ std::nextafter function. It can also return a subnormal number. @compatibility(cpp) Equivalent to C++ std::nextafter function. @end_compatibility Args: x1: A `Tensor`. Must be one of the following types: `float64`, `float32`. x2: A `Tensor`. Must have the same type as `x1`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x1`. NextAfterNr r)rJrKr!r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_next_afterrnext_after_eager_fallbackr/rjrrr next_afterrrrr0r1r2r3r4r5r6) rJrKr!r8r9r:r;r<r=r>r?r@s rArPrPs',    0h..0$ #\\ 11 k4R)g n,) RGn$ n  )::r.Aq#x QK' ""$3%%c* +F::L \674 (' .W  & &- ##At,,  # #    * r4/4!g  & & bt''  # #  z " "" DB2D9 g  ..<< <  Z    b$"$7 Gi,,::: n  rzraw_ops.NextAftercHtj||g|tjtjgtj\}}|\}}||g}d|f}tj dd||||}tj rtjd||||\}|S)Nr$s NextAfterrErFrM)r2rHrIrMrLrr3r6) rJrKr!r"rSrr@r?r:s rArOrOs66BxwX_XgXgFjlsl{l{|'9 (2rb, >&   \1\#)s ?' ""$ \674 (' .rT) TV_NotEqual_TrrrVrWrhrrrirjrkrlrmrrrrnrrrXrYrZr[r\rorr]r^rpr_r`rc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rHd| j%dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aReturns the truth value of (x != y) element-wise. *NOTE*: `NotEqual` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. y: A `Tensor`. Must have the same type as `x`. incompatible_shape_error: An optional `bool`. Defaults to `True`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. NotEqualrNrTrr$)r%rr&r'rr(r)r*r+r,r-not_equal_eager_fallbackr/r2rr0r1r3r4rr5r6rs rA not_equalrVs    0h..0$ #\\ 11 j$1&@ "gn%#%//0HJde'88a1-E!QX QK' ""$3%%c*,F  !;<>F::L L&'3 (' .5  & &- ##At,,  # #    % Q)A  # #   rzraw_ops.NotEqualc&|d}tj|d}tj||g|g\}}|\}}||g}d|d|f}tjdd||||} tjrtj d||| | \} | S)NTrr$sNotEqualrErFrTrrs rArUrU2s%#%//0HJde661vsBG'9 &1aQ, 4 &   [!L#)s ?' ""$ L&'3 (' .rTTV_Polygamma_Tzmath.polygamma polygammac Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aCompute the polygamma function \\(\psi^{(n)}(x)\\). The polygamma function is defined as: \\(\psi^{(a)}(x) = \frac{d^a}{dx^a} \psi(x)\\) where \\(\psi(x)\\) is the digamma function. The polygamma function is defined only for non-negative integer orders \\a\\. Args: a: A `Tensor`. Must be one of the following types: `float32`, `float64`. x: A `Tensor`. Must have the same type as `a`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. PolygammaNr rrir$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_polygammarpolygamma_eager_fallbackr/rjrrr rYrrrr0r1r2r3r4r5r6rls rArYrYFs'.    0h..0$ #\\ 11 k4A'g n,( At tGn$ n  )::qAD*Aq#x QK' ""$3%%c* +F::L \674 (' .W  & &- ##At,,  # #    ) a-g  & % QTt%%  # #  z " "" r4!qt4 g  ..<< <  Z    RQT2 Gi,,::: n  rzraw_ops.Polygammac*tj||g|tjtjg\}}|\}}||g}d|f}tj dd||||}tj rtjd||||\}|S)Nr$s PolygammarErFr[rSrns rAr]r]s661vsW__V]VeVeDhi'9 &1aQ, >&   \1\#)s ?' ""$ \674 (' .rTTV_Pow_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)arComputes the power of one value to another. Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for corresponding elements in `x` and `y`. For example: ``` # tensor 'x' is [[2, 2]], [3, 3]] # tensor 'y' is [[8, 16], [2, 3]] tf.pow(x, y) ==> [[256, 65536], [9, 27]] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `half`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. PowNr rr$)r%rr&r'rr(r)r*r+r,r-_pow_eager_fallbackr/r0r1r2r3r4r5r6rs rA_powrcs=(    0h..0$ #\\ 11 eT1a!g n(88 ad$!QX QK' ""$3%%c* +F::L  |VW. (' .'  & &- ##At,,  # #    QTt%%  # #   rz raw_ops.Powctj||g|tjtjtj tj tjtjtjtjtjtjg \}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sPowrErFra)r2rHrIrJrLrKrMrNrOrPrQrsrzrr3r6rs rArbrbs7661vsWEUEUW^WfWfhohthtv}wFwFHOHTHTV]VcVcelerert{tAtACJCTCTV]VhVhEkl'9 &1aQ, >&   VQ|6!$4 1' ""$  |VW. (' .rT TV_Prod_T TV_Prod_Tidxc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rYd| j%dd| j'dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY"wxYw) aComputes the product of elements across dimensions of a tensor. Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1. Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. The tensor to reduce. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. The dimensions to reduce. Must be in the range `[-rank(input), rank(input))`. keep_dims: An optional `bool`. Defaults to `False`. If true, retain reduced dimensions with length 1. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. ProdrNrFrr$r)r%rr&r'rr(r)r*r+r,r-prod_eager_fallbackr/r2rr0r1r3rr4r5r6rs rAprodrjrr!z raw_ops.Prodc|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\}\}tj|g|tj tjgtj \}\}||g}d|d|d|f}tj.dd||||} tj0rtj2d||| | \} | S) NFrr$rsProdrErFrhrr#s rAriri"rrTQuantizeDownAndShrinkRange)output output_min output_max$TV_QuantizeDownAndShrinkRange_Tinput&TV_QuantizeDownAndShrinkRange_out_type input_min input_maxout_typec .tjxstj}|j}|jr4 t j |d||||d|}t j|}|Stj |d}t#j$d|||||\} } } } | dd}tj&rHd| j)dd| j)df} | j*} tj,d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rY wxYw)aConvert the quantized 'input' tensor into a lower-precision 'output', using the actual distribution of the values to maximize the usage of the lower bit depth and adjusting the output min and max ranges accordingly. [input_min, input_max] are scalar floats that specify the range for the float interpretation of the 'input' data. For example, if input_min is -1.0f and input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0 value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f. This operator tries to squeeze as much precision as possible into an output with a lower bit depth by calculating the actual min and max values found in the data. For example, maybe that quint16 input has no values lower than 16,384 and none higher than 49,152. That means only half the range is actually needed, all the float interpretations are between -0.5f and 0.5f, so if we want to compress the data into a quint8 output, we can use that range rather than the theoretical -1.0f to 1.0f that is suggested by the input min and max. In practice, this is most useful for taking output from operations like QuantizedMatMul that can produce higher bit-depth outputs than their inputs and may have large potential output ranges, but in practice have a distribution of input values that only uses a small fraction of the possible range. By feeding that output into this operator, we can reduce it from 32 bits down to 8 with minimal loss of accuracy. Args: input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. input_min: A `Tensor` of type `float32`. The float value that the minimum quantized input value represents. input_max: A `Tensor` of type `float32`. The float value that the maximum quantized input value represents. out_type: A `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`. The type of the output. Should be a lower bit depth than Tinput. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output, output_min, output_max). output: A `Tensor` of type `out_type`. output_min: A `Tensor` of type `float32`. output_max: A `Tensor` of type `float32`. rlrtNrtr!r")rrrrsrtr!Tinput)r%rr&r'rr(!_QuantizeDownAndShrinkRangeOutput_maker)r*r+r,r--quantize_down_and_shrink_range_eager_fallbackr/r2rr0r1r3r4r5r6)rrrrsrtr!r8r9r:r;r<r=r>r?r@s rAquantize_down_and_shrink_ranger{:sV    0h..0$ #\\  11 *D%IHg277@g n  * 5('88$EY09H+/1!QX QK' ""$**84j  ,.F::L $lFGE - 3 3G <' ./  & &- ##At,,  # #    : ItOO  # #   02D!!E(4EE('E(,E==FFz"raw_ops.QuantizeDownAndShrinkRangec `tj|d}tj|g|tjtj tj tjtjg\}\}tj|tj}tj|tj}|||g}d|d|f}tjdd||||} tjrtjd||| tj!| } | S)NrtrwsQuantizeDownAndShrinkRangerFrl)r2rrHrIrtrurvrwrxr+rrLrr3r6rxry) rrrrsrtr!r" _attr_Tinputr@r?r:s rArzrzs   * 5(#::E7C'--Y`YgYgipiwiwzAzHzHJQJYJYJ\],$$Y@)$$Y@)I., lJ 9&   :A$0C"& ('""$ $lFGE - 3 3G <' .rT QuantizedAdd)zmin_zmax_zTV_QuantizedAdd_T1TV_QuantizedAdd_T2TV_QuantizedAdd_Toutputmin_xmax_xmin_ymax_yToutputc tjxstj}|j} | jr7 t j |d|||||||d| } t j| } | S|tj }t#j$|d}t'j(d|||||||| \} } } }|dd} t#j*rYd| j-dd| j-dd| j-df}| j.}t#j0d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||| S#tj$rYIwxYw)a7Returns x + y element-wise, working on quantized buffers. Args: x: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. y: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. min_x: A `Tensor` of type `float32`. The float value that the lowest quantized `x` value represents. max_x: A `Tensor` of type `float32`. The float value that the highest quantized `x` value represents. min_y: A `Tensor` of type `float32`. The float value that the lowest quantized `y` value represents. max_y: A `Tensor` of type `float32`. The float value that the highest quantized `y` value represents. Toutput: An optional `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`. Defaults to `tf.qint32`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (z, min_z, max_z). z: A `Tensor` of type `Toutput`. min_z: A `Tensor` of type `float32`. max_z: A `Tensor` of type `float32`. rrNrr!r"rrrrrrrr!T1T2)r%rr&r'rr(_QuantizedAddOutputryr)r*r+r,r-quantized_add_eager_fallbackr/rIrvr2rr0r1r3r4r5r6rrrrrrrr!r8r9r:r;r<r=r>r?r@s rA quantized_addr0    0h..0$ #\\  11 ndAq%u7g$))'2g n _nnG   w 2''88!qU%#W4A!QX QK' ""$C&&t,dC4F4Ft4L++I68F::L  fg7  % %g .' .3  & &- ##At,,  # #    ) QueUG$  # #   05E FE88FFF))G?Gzraw_ops.QuantizedAddc |tj}tj|d}tj|g|tj tj tjtjtjg\} \}tj|g|tj tj tjtjtjg\} \}tj|tj}tj|tj}tj|tj}tj|tj}||||||g} d| d| d|f} tjdd| | ||} tjrtjd| | | tj!| } | S)Nrrrs QuantizedAddr~rFr)rIrvr2rrHrtrurwrxr+rrLrr3r6rryrrrrrrrr!r"_attr_T1_attr_T2r@r?r:s rArr _nnG   w 2'22A3gmmW^^]d]k]kmtm{m{~E~M~M>PQ.(DQ22A3gmmW^^]d]k]kmtm{m{~E~M~M>PQ.(DQ   8%   8%   8%   8%QueU3, (D(Iw ?&   _a #)s ?' ""$  fg7  % %g .' .rTQuantizedMatMul)outmin_outmax_outTV_QuantizedMatMul_T1TV_QuantizedMatMul_T2TV_QuantizedMatMul_ToutputTV_QuantizedMatMul_Tactivationmin_amax_amin_bmax_b Tactivationc tjxstj} | j} | jr= t j | d| ||||||d|d|d|d| } t j| } | S|tj }t#j$|d}|d}t#j&|d}|d}t#j&|d}| tj(} t#j$| d} t+j,d|||||||||| | \}}}}|dd} t#j.rd |j1d d |j1d d|j1dd|j3dd|j3dd|j1df }|j4}t#j6d||| t j| } | S#tj$r }tj|| Yd}~nd}~wtj$rYnwxYw t|||||||||| | |  S#tj$rYwxYw) aCPerform a quantized matrix multiplication of `a` by the matrix `b`. The inputs must be two-dimensional matrices and the inner dimension of `a` (after being transposed if `transpose_a` is non-zero) must match the outer dimension of `b` (after being transposed if `transposed_b` is non-zero). Args: a: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. Must be a two-dimensional tensor. b: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. Must be a two-dimensional tensor. min_a: A `Tensor` of type `float32`. The float value that the lowest quantized `a` value represents. max_a: A `Tensor` of type `float32`. The float value that the highest quantized `a` value represents. min_b: A `Tensor` of type `float32`. The float value that the lowest quantized `b` value represents. max_b: A `Tensor` of type `float32`. The float value that the highest quantized `b` value represents. Toutput: An optional `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`. Defaults to `tf.qint32`. transpose_a: An optional `bool`. Defaults to `False`. If true, `a` is transposed before multiplication. transpose_b: An optional `bool`. Defaults to `False`. If true, `b` is transposed before multiplication. Tactivation: An optional `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`. Defaults to `tf.quint8`. The type of output produced by activation function following this operation. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (out, min_out, max_out). out: A `Tensor` of type `Toutput`. min_out: A `Tensor` of type `float32`. max_out: A `Tensor` of type `float32`. rrrrrN)rrrrr!r"F) rLrMrrrrrrrrr!rr)r%rr&r'rr(_QuantizedMatMulOutputryr)r*r+r,r- quantized_mat_mul_eager_fallbackr/rIrvr2rrrur0r1r3r4rr5r6)rLrMrrrrrrrrr!r8r9r:r;r<r=r>r?r@s rAquantized_mat_mulrslL    0h..0$ #\\  11 q!UE5%7M; ]K1g',,W5g n _nnG   w 2'K""; >+K""; >+..K""; >+'88Q!5U!&'2 '2 ?!QX QK' ""$C&&t,dC4F4Ft4L++I6   /  /  / 1F ::L <: " ( ( 1' .Q  & &- ##At,,  # #    - QueUG!{!$88  # #   s0;G""H)5HH)(H)-IIIzraw_ops.QuantizedMatMulc |tj}tj|d}|d}tj|d}|d}tj|d}| tj } tj| d} tj |g| tjtj tjtjtjg\} \}tj |g| tjtj tjtjtjg\} \}tj|tj}tj|tj}tj|tj}tj|tj}||||||g}d| d| d|d|d|d| f }tjdd ||| | }tjrtjd |||t j#|}|S) NrFrrrrrsQuantizedMatMulr~rFr)rIrvr2rrrurHrtrwrxr+rrLrr3r6rry)rLrMrrrrrrrrr!r"rrr@r?r:s rArr]s  _nnG   w 2'K""; >+K""; >+..K""; >+22A3gmmW^^]d]k]kmtm{m{~E~M~M>PQ.(DQ22A3gmmW^^]d]k]kmtm{m{~E~M~M>PQ.(DQ   8%   8%   8%   8%QueU3, (D(Iw  }k=+ G&   /<#)s ?' ""$ <: " ( ( 1' .rT QuantizedMulTV_QuantizedMul_T1TV_QuantizedMul_T2TV_QuantizedMul_Toutputc tjxstj}|j} | jr7 t j |d|||||||d| } t j| } | S|tj }t#j$|d}t'j(d|||||||| \} } } }|dd} t#j*rYd| j-dd| j-dd| j-df}| j.}t#j0d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||| S#tj$rYIwxYw)a7Returns x * y element-wise, working on quantized buffers. Args: x: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. y: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. min_x: A `Tensor` of type `float32`. The float value that the lowest quantized `x` value represents. max_x: A `Tensor` of type `float32`. The float value that the highest quantized `x` value represents. min_y: A `Tensor` of type `float32`. The float value that the lowest quantized `y` value represents. max_y: A `Tensor` of type `float32`. The float value that the highest quantized `y` value represents. Toutput: An optional `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`. Defaults to `tf.qint32`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (z, min_z, max_z). z: A `Tensor` of type `Toutput`. min_z: A `Tensor` of type `float32`. max_z: A `Tensor` of type `float32`. rrNrrrr)r%rr&r'rr(_QuantizedMulOutputryr)r*r+r,r-quantized_mul_eager_fallbackr/rIrvr2rr0r1r3r4r5r6rs rA quantized_mulrrrzraw_ops.QuantizedMulc |tj}tj|d}tj|g|tj tj tjtjtjg\} \}tj|g|tj tj tjtjtjg\} \}tj|tj}tj|tj}tj|tj}tj|tj}||||||g} d| d| d|f} tjdd| | ||} tjrtjd| | | tj!| } | S)Nrrrs QuantizedMulr~rFr)rIrvr2rrHrtrurwrxr+rrLrr3r6rryrs rArrrrTTV_RaggedBincount_TidxTV_RaggedBincount_Tsplitsc tjxstj}|j}|jr t j |d|||||d| }|S|d}tj|d}tj d||||||\} } } } | dd}tj"rYd| j%dd| j%dd| j'df} | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rY&wxYw) aCounts the number of occurrences of each value in an integer array. Outputs a vector with length `size` and the same dtype as `weights`. If `weights` are empty, then index `i` stores the number of times the value `i` is counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of the value in `weights` at each index where the corresponding value in `arr` is `i`. Values in `arr` outside of the range [0, size) are ignored. Args: splits: A `Tensor` of type `int64`. 1D int64 `Tensor`. values: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2D int `Tensor`. size: A `Tensor`. Must have the same type as `values`. non-negative int scalar `Tensor`. weights: A `Tensor`. Must be one of the following types: `int32`, `int64`, `float32`, `float64`. is an int32, int64, float32, or float64 `Tensor` with the same shape as `input`, or a length-0 `Tensor`, in which case it acts as all weights equal to 1. binary_output: An optional `bool`. Defaults to `False`. bool; Whether the kernel should count the appearance or number of occurrences. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `weights`. RaggedBincountrNrF)rr[rVrWrr!rr$)r%rr&r'rr(r)r*r+r,r-ragged_bincount_eager_fallbackr/r2rr0r1r3r4rr5r6)rr[rVrWrr!r8r9r:r;r<r=r>r?r@s rAragged_bincountrs8    0h..0$ #\\ 11 ffdG(gnM$$]OD-'88T")#%!QX QK' ""$c((0#  %  13F::L ,9 (' .7  & &- ##At,,  # #    + &$}  # #   s0DE%EEEE//FFzraw_ops.RaggedBincountcd|d}tj|d}tj||g|tjtj g\}}|\}}tj|g|tjtj tj tjg\} \}tj|tj }||||g} d|d| d|f} tjdd| | ||} tjrtjd| | | | \} | S) NFrrr$sRaggedBincountrErFr r2rrHrIrPrQrLrMr+rrr3r6) rr[rVrWrr!r"rrrSr@r?r:s rArrs)M$$]OD-%< [3, 6, 9, 12, 15] ``` Args: start: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `uint16`, `uint32`. 0-D (scalar). First entry in the sequence. limit: A `Tensor`. Must have the same type as `start`. 0-D (scalar). Upper limit of sequence, exclusive. delta: A `Tensor`. Must have the same type as `start`. 0-D (scalar). Optional. Default is 1. Number that increments `start`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `start`. RangeNr )rrrr!r)r%rr&r'rr(r)r*r+r,r-_range_eager_fallbackr/r0r1r2r3r4r5r6) rrrr!r8r9r:r;r<r=r>r?r@s rA_ranger4sD6    0h..0$ #\\ 11 gtUE52g n(88uETC!QX QK' ""$c((0 1F::L vw0 (' .'  & &- ##At,,  # #    " Dd44  # #   r\z raw_ops.Rangec>tj|||g|tjtjtj tj tjtjtjtjtjtjg tj\}}|\}}}|||g}d|f}tjdd||||} tjrtjd||| | \} | S)NrsRangerErFr)r2rHrIrJrKrLrMrNrOrPrQryr{rr3r6) rrrr!r"rrr@r?r:s rArrnsh%< [-2.25, 3.25] ``` Args: input: A `Tensor`. Must be one of the following types: `complex64`, `complex128`. Tout: An optional `tf.DType` from: `tf.float32, tf.float64`. Defaults to `tf.float32`. name: A name for the operation (optional). Returns: A `Tensor` of type `Tout`. RealrNrrr$)r%rr&r'rr(r)r*r+r,r-real_eager_fallbackr/rIrLr2rr0r1r3r4r5r6rs rArrrrz raw_ops.Realc|tj}tj|d}tj|g|tj tj gtj \}\}|g}d|d|f}tjdd||||}tjrtjd||||\}|S)Nrr$sRealrErFrrrs rArrrrT TV_RealDiv_Trealdivc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)agReturns x / y element-wise for real types. If `x` and `y` are reals, this will return the floating-point division. *NOTE*: `Div` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `uint32`, `uint64`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. RealDivNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_real_divrreal_div_eager_fallbackr/rjrrr real_divrrrr0r1r2r3r4r5r6rs rArrs'&    0h..0$ #\\ 11 iq!%g n,' At tGn$ n  )::Q!$(Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ( a-g  & $ QTt%%  # #  z " "" b$ad3 g  ..<< <  Z    BqAD1 Gi,,::: n  rzraw_ops.RealDivctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj g\}}|\}}||g}d|f}tj"dd||||}tj$rtj&d||||\}|S)Nr$sRealDivrErFrrrs rArr s661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WcWcelesesu|uBuBDKDQDQSZSaSacjcqcqszs@s@BIBSBSU\UgUgEjk'9 &1aQ, >&   Ztjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)r ReciprocalNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_reciprocalrreciprocal_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr& s    0h..0$ #\\ 11 lD!%g n,) D DGn$ n  )::&Aq#x QK' ""$3%%c* +F::L lFG5 (' .W  & &- ##At,,  # #    * d*dg  & & $D""  # #  z " "" D140 g  ..<< <  Z    b$. Gi,,::: n  rzraw_ops.Reciprocalctj|g|tjtjtj tj tjtjtjtjtjtjg \}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$s ReciprocalrErFrrrRs rArrn s111#sW=M=Mw||]d]l]lnun}n}@G@L@LNUN[N[]d]j]jlslyly{B{L{LNUN`N`=cd-'4A, >&   ]Al#)s ?' ""$ lFG5 (' .rTTV_ReciprocalGrad_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)rReciprocalGradNr rr$)r%rr&r'rr(r)r*r+r,r-reciprocal_grad_eager_fallbackr/r0r1r2r3r4r5r6rs rAreciprocal_gradr} s>    0h..0$ #\\ 11 a-g n(88A"41!QX QK' ""$3%%c* +F::L ,9 (' .'  & &- ##At,,  # #    + Rd&&  # #   rzraw_ops.ReciprocalGradc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sReciprocalGradrErFrrrs rArr s662wgFVFVX_XdXdfmfufuw~xGxGIPIZIZ\c\n\nFqr'9 '1bR, >&   .,#)s ?' ""$ ,9 (' .rTRequantizationRangernroTV_RequantizationRange_Tinputctjxstj}|j}|jr2 t j |d||||}t j|}|Stj d||||\}}} } | dd}t#j$r7d| j'df} | j(} t#j*d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||S#tj$rYwxYw)aComputes a range that covers the actual values present in a quantized tensor. Given a quantized tensor described by `(input, input_min, input_max)`, outputs a range that covers the actual values present in that tensor. This op is typically used to produce the `requested_output_min` and `requested_output_max` for `Requantize`. Args: input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. input_min: A `Tensor` of type `float32`. The float value that the minimum quantized input value represents. input_max: A `Tensor` of type `float32`. The float value that the maximum quantized input value represents. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_min, output_max). output_min: A `Tensor` of type `float32`. output_max: A `Tensor` of type `float32`. rNr )rrrrsr!rw)r%rr&r'rr(_RequantizationRangeOutputryr)r*r+r,r-#requantization_range_eager_fallbackr/r0r1r2r3r4r5r6) rrrrsr!r8r9r:r;r<r=r>r?r@s rArequantization_ranger sa,    0h..0$ #\\ 11 #T5)YHg*009g n(88Ui)2?!QX QK' ""$**84 5F::L |VW> & , ,W 5' .)  & &- ##At,,  # #    0 IDd<<  # #   s00C77D> D%%D>=D>EE('E(zraw_ops.RequantizationRangec 0tj|g|tjtjtj tj tjg\}\}tj|tj}tj|tj}|||g}d|f}tjdd||||}tjrtjd|||tj|}|S)NrwsRequantizationRangerFr)r2rHrIrtrurvrwrxr+rrLrr3r6rry) rrrrsr!r"rr@r?r:s rArr s#::E7C'--Y`YgYgipiwiwzAzHzHJQJYJYJ\],$$Y@)$$Y@)I., l #&   3Q|#)s ?' ""$ |VW> & , ,W 5' .rTRequantizationRangePerChannel"TV_RequantizationRangePerChannel_Tc .tjxstj}|j}|jr4 t j |d||||d|}t j|}|Stj |d}t#j$d|||||\} } } } | dd}tj&rHd| j)dd| j+df} | j,} tj.d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rY wxYw)aComputes requantization range per channel. Args: input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. The original input tensor. input_min: A `Tensor` of type `float32`. The minimum value of the input tensor input_max: A `Tensor` of type `float32`. The maximum value of the input tensor. clip_value_max: A `float`. The maximum value of the output that needs to be clipped. Example: set this to 6 for Relu6. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_min, output_max). output_min: A `Tensor` of type `float32`. output_max: A `Tensor` of type `float32`. rrN)rr!r")rrrrsrr!r$)r%rr&r'rr($_RequantizationRangePerChannelOutputryr)r*r+r,r-/requantization_range_per_channel_eager_fallbackr/r2rr0r1r3r4rnr5r6)rrrrsrr!r8r9r:r;r<r=r>r?r@s rA requantization_range_per_channelr !s*    0h..0$ #\\  11 -tUI#^5g5::7Cg n&&~7GH.'88'u 3<8F.2 4!QX QK' ""$3%%c*,<ll+,.F::L 'vwH 0 6 6w ?' .3  & &- ##At,,  # #    < In  # #   r|z%raw_ops.RequantizationRangePerChannelc ~tj|d}tj|g|tjtj tj tjtjgtj \}\}tj|tj}tj|tj}|||g}d|d|f}tjdd||||} tjrtjd||| tj!| } | S)Nrr$sRequantizationRangePerChannelrrFr)r2rrHrIrtrurvrwrxr+rrLrr3r6rry) rrrrsrr!r"rSr@r?r:s rArrF!s.&&~7GH.55ugsW]]T[TbTbdkdrdrt{uCuCELETETEWY`YgYgh'8E$$Y@)$$Y@)I., *N ;&   =q$0C"& ('""$ 'vwH 0 6 6w ?' .rT RequantizeTV_Requantize_TinputTV_Requantize_out_typerequested_output_minrequested_output_maxc :tjxstj}|j}|jr6 t j |d||||||d| } t j| } | Stj |d}t#j$d|||||||\} } } } | dd} tj&rHd| j)dd| j)df}| j*}tj,d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||S#tj$rY$wxYw)aAConverts the quantized `input` tensor into a lower-precision `output`. Converts the quantized `input` tensor into a lower-precision `output`, using the output range specified with `requested_output_min` and `requested_output_max`. `[input_min, input_max]` are scalar floats that specify the range for the float interpretation of the `input` data. For example, if `input_min` is -1.0f and `input_max` is 1.0f, and we are dealing with `quint16` quantized data, then a 0 value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f. Args: input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. input_min: A `Tensor` of type `float32`. The float value that the minimum quantized input value represents. input_max: A `Tensor` of type `float32`. The float value that the maximum quantized input value represents. requested_output_min: A `Tensor` of type `float32`. The float value that the minimum quantized output value represents. requested_output_max: A `Tensor` of type `float32`. The float value that the maximum quantized output value represents. out_type: A `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`. The type of the output. Should be a lower bit depth than Tinput. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output, output_min, output_max). output: A `Tensor` of type `out_type`. output_min: A `Tensor` of type `float32`. output_max: A `Tensor` of type `float32`. rrtNrvrrrrsrrrtr!rw)r%rr&r'rr(_RequantizeOutputryr)r*r+r,r-requantize_eager_fallbackr/r2rr0r1r3r4r5r6rrrrsrrrtr!r8r9r:r;r<r=r>r?r@s rA requantizer^!s@    0h..0$ #\\  11 lD%I2JJg"''0g n  * 5('88EY)+?+?'d 4!QX QK' ""$**84j  ,.F::L lFG5  # #G ,' .3  & &- ##At,,  # #    & I'; $HH  # #   s04D%%E,8EE,+E,0FFFzraw_ops.Requantizec tj|d}tj|g|tjtj tj tjtjg\}\}tj|tj}tj|tj}tj|tj}tj|tj}|||||g} d|d|f} tjdd| | ||} tjrtjd| | | tj!| } | S)Nrtrws Requantizer~rFr)r2rrHrIrtrurvrwrxr+rrLrr3r6rry) rrrrsrrrtr!r"rr@r?r:s rArr!sL   * 5(#::E7C'--Y`YgYgipiwiwzAzHzHJQJYJYJ\],$$Y@)$$Y@)//0DgooV//0DgooVI/CEYZ, lJ 9&   ]Al#)s ?' ""$ lFG5  # #G ,' .rTRequantizePerChannelTV_RequantizePerChannel_T TV_RequantizePerChannel_out_typec ^tjxstj}|j}|jr6 t j |d||||||d| } t j| } | S|tj }t#j$|d}t'j(d|||||||\} } } } | dd} t#j*rHd| j-dd| j-df}| j.}t#j0d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||S#tj$rY6wxYw)a1Requantizes input with min and max values known per channel. Args: input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`. The original input tensor. input_min: A `Tensor` of type `float32`. The minimum value of the input tensor input_max: A `Tensor` of type `float32`. The maximum value of the input tensor. requested_output_min: A `Tensor` of type `float32`. The minimum value of the output tensor requested. requested_output_max: A `Tensor` of type `float32`. The maximum value of the output tensor requested. out_type: An optional `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`. Defaults to `tf.quint8`. The quantized type of output tensor that needs to be converted. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output, output_min, output_max). output: A `Tensor` of type `out_type`. output_min: A `Tensor` of type `float32`. output_max: A `Tensor` of type `float32`. rrtNrvrr$)r%rr&r'rr(_RequantizePerChannelOutputryr)r*r+r,r-%requantize_per_channel_eager_fallbackr/rIrur2rr0r1r3r4r5r6rs rArequantize_per_channelr!s2    0h..0$ #\\  11 $dE9i2JJg,11':g n~~H   * 5('88ey*35I5I)1 >!QX QK' ""$3%%c*J  ,.F::L  fg? ' - -g 6' .9  & &- ##At,,  # #    2 I'; $HH  # #   s04D77E> E%%E>=E>FF,+F,zraw_ops.RequantizePerChannelc 6|tj}tj|d}tj|g|tj tjtj tjtjgtj \}\}tj|tj}tj|tj}tj|tj}tj|tj}|||||g} d|d|f} tjdd| | ||} tjrtjd| | | tj!| } | S)Nrtr$sRequantizePerChannelr~rFr)rIrur2rrHrtrvrwrxr+rrLrr3r6rry) rrrrsrrrtr!r"rSr@r?r:s rArr"sm ~~H   * 5(55ugsW]]T[TbTbdkdrdrt{uCuCELETETEWY`YgYgh'8E$$Y@)$$Y@)//0DgooV//0DgooVI/CEYZ, *h /&   4a #)s ?' ""$  fg? ' - -g 6' .rT TV_Rint_Tz math.rintrintc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aReturns element-wise integer closest to x. If the result is midway between two representable values, the even representable is chosen. For example: ``` rint(-1.5) ==> -2.0 rint(0.5000001) ==> 1.0 rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. RintNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_rintrrint_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr"s0    0h..0$ #\\ 11 fdAg n,# D DGn$ n  )::!$ Aq#x QK' ""$3%%c* +F::L  fg/ (' .W  & &- ##At,,  # #    $ d*dg  & $D""  # #  z " "" "dQT* g  ..<< <  Z    D14( Gi,,::: n  rz raw_ops.Rintc\tj|g|tjtjtj tj g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sRintrErFr r rRs rAr r g"rrT TV_Round_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)aRounds the values of a tensor to the nearest integer, element-wise. Rounds half to even. Also known as bankers rounding. If you want to round according to the current system rounding mode use std::cint. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. RoundNr r#r$)r%rr&r'rr(r)r*r+r,r-round_eager_fallbackr/r0r1r2r3r4r5r6r7s rAroundrv"s7    0h..0$ #\\ 11 gtQ g n(8814!!QX QK' ""$3%%c* +F::L vw0 (' .'  & &- ##At,,  # #    ! $D""  # #   rCz raw_ops.Roundctj|g|tjtjtj tj tjtjtjtjtjtjg \}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sRoundrErFrrrRs rArr"s111#sW=M=Mw||]d]l]lnun}n}@G@L@LNUN[N[]d]j]jlslyly{B{L{LNUN`N`=cd-'4A, >&   XqV!$4 1' ""$ vw0 (' .rT TV_Rsqrt_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)aCComputes reciprocal of square root of x element-wise. I.e., \\(y = 1 / \sqrt{x}\\). Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. RsqrtNr r#r$)r%rr&r'rr(r)r*r+r,r-rsqrt_eager_fallbackr/r0r1r2r3r4r5r6r7s rArsqrtr"s7    0h..0$ #\\ 11 gtQ g n(8814!!QX QK' ""$3%%c* +F::L vw0 (' .'  & &- ##At,,  # #    ! $D""  # #   rCz raw_ops.Rsqrtc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sRsqrtrErFrrrRs rArr"rrTTV_RsqrtGrad_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aComputes the gradient for the rsqrt of `x` wrt its input. Specifically, `grad = dy * -0.5 * y^3`, where `y = rsqrt(x)`, and `dy` is the corresponding input gradient. Args: y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. dy: A `Tensor`. Must have the same type as `y`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `y`. RsqrtGradNr rr$)r%rr&r'rr(r)r*r+r,r-rsqrt_grad_eager_fallbackr/r0r1r2r3r4r5r6rs rA rsqrt_gradr"s=    0h..0$ #\\ 11 k4B(g n(88qRd,!QX QK' ""$3%%c* +F::L \674 (' .'  & &- ##At,,  # #    & Rd&&  # #   rzraw_ops.RsqrtGradc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$s RsqrtGradrErFrrrs rArr#s662wgFVFVX_XdXdfmfufuw~xGxGIPIZIZ\c\n\nFqr'9 '1bR, >&   \1\#)s ?' ""$ \674 (' .rTTV_SegmentMax_TTV_SegmentMax_Tindiceszmath.segment_max segment_maxdata segment_idsc ptjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4rHd|j7dd|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aComputes the maximum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \max_j(data_j)\\) where `max` is over `j` such that `segment_ids[j] == i`. If the max is empty for a given segment ID `i`, `output[i] = 0`. Caution: On CPU, values in `segment_ids` are always validated to be sorted, and an error is thrown for indices that are not increasing. On GPU, this does not throw an error for unsorted indices. On GPU, out-of-order indices result in safe but unspecified behavior, which may include treating out-of-order indices as the same as a smaller following index.
For example: >>> c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> tf.math.segment_max(c, tf.constant([0, 0, 1])).numpy() array([[4, 3, 3, 4], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. Caution: The values are always validated to be sorted on CPU, never validated on GPU. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentMaxNr rr"r#r!r$Tindices)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_segment_maxrsegment_max_eager_fallbackr/rjrrr r!rrrr0r1r2r3r4r5r6 r"r#r!r8r9r:r;r<r=r>r?r@s rAr!r!)#@^    0h..0$ #\\ 11 lD$ 5g n.* {D"D*Gn$ n  )::4[tEAq#x QK' ""$3%%c*J  ,.F::L lFG5 (' .[  & &- ##At,,  # #    + d $d,g  & '  $D22  # #  z " "" Tt'+- g  ..<< <  " Z    r4T{N Gi,,::: n  PC:5G:E D((EEE-E--GAGGAH53H5zraw_ops.SegmentMaxctj|g|tjtjtj tj tjtjtjtjtjtjtjtjg \}\}tj|g|tj tjg\}\}||g}d|d|f}tjdd||||}tj rtj"d||||\}|S)Nr$r's SegmentMaxrErFr%r r"r#r!r"rS_attr_Tindicesr@r?r:s rAr)r)#44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_ahananpwp@p@BIBPBPRYR^R^`g`n`npwp~p~CAB'7D#+#B#BK=RUX_XeXegngtgtWw#x ..; $, *n 5&   ]Al#)s ?' ""$ lFG5 (' .rTTV_SegmentMaxV2_TTV_SegmentMaxV2_TindicesTV_SegmentMaxV2_Tnumsegments num_segmentsctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj rYd| j#dd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aL Computes the maximum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \max_j(data_j)\\) where `max` is over `j` such that `segment_ids[j] == i`. If the maximum is empty for a given segment ID `i`, it outputs the smallest possible value for the specific numeric type, `output[i] = numeric_limits::lowest()`. Note: That this op is currently only supported with jit_compile=True. Caution: On CPU, values in `segment_ids` are always validated to be sorted, and an error is thrown for indices that are not increasing. On GPU, this does not throw an error for unsorted indices. On GPU, out-of-order indices result in safe but unspecified behavior, which may include treating out-of-order indices as the same as a smaller following index. The only difference with SegmentMax is the additional input `num_segments`. This helps in evaluating the output shape in compile time. `num_segments` should be consistent with segment_ids. e.g. Max(segment_ids) should be equal to `num_segments` - 1 for a 1-d segment_ids With inconsistent num_segments, the op still runs. only difference is, the output takes the size of num_segments irrespective of size of segment_ids and data. for num_segments less than expected output size, the last elements are ignored for num_segments more than the expected output size, last elements are assigned smallest possible value for the specific numeric type. For example: >>> @tf.function(jit_compile=True) ... def test(c): ... return tf.raw_ops.SegmentMaxV2(data=c, segment_ids=tf.constant([0, 0, 1]), num_segments=2) >>> c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> test(c).numpy() array([[4, 3, 3, 4], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. The values must be less than `num_segments`. Caution: The values are always validated to be sorted on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentMaxV2Nr r"r#r4r!r$r' Tnumsegments)r%rr&r'rr(r)r*r+r,r-segment_max_v2_eager_fallbackr/r0r1r2r3r4r5r6 r"r#r4r!r8r9r:r;r<r=r>r?r@s rAsegment_max_v2r;#nt    0h..0$ #\\ 11 ndD+|Eg n(88T{%1>!QX QK' ""$3%%c*J  ,n  02F::L  fg7 (' .-  & &- ##At,,  # #    *  \$@@  # #   0C33D:D!!D:9D:>EE%$E%zraw_ops.SegmentMaxV2cbtj|g|tjtjtj tj tjtjtjtjtjtjtjtjg \}\}tj|g|tj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tjdd|| ||} tj rtj"d|| | | \} | S)Nr$r'r8s SegmentMaxV2rErFr6r r"r#r4r!r"rSr/_attr_Tnumsegmentsr@r?r:s rAr9r9$44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_ahananpwp@p@BIBPBPRYR^R^`g`n`npwp~p~CAB'7D#+#B#BK=RUX_XeXegngtgtWw#x ..;(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o| \2, *nn &   _a #)s ?' ""$  fg7 (' .rTTV_SegmentMean_TTV_SegmentMean_Tindiceszmath.segment_mean segment_meanc ptjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4rHd|j7dd|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aiComputes the mean along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \frac{\sum_j data_j}{N}\\) where `mean` is over `j` such that `segment_ids[j] == i` and `N` is the total number of values summed. If the mean is empty for a given segment ID `i`, `output[i] = 0`. Caution: On CPU, values in `segment_ids` are always validated to be sorted, and an error is thrown for indices that are not increasing. On GPU, this does not throw an error for unsorted indices. On GPU, out-of-order indices result in safe but unspecified behavior, which may include treating out-of-order indices as a smaller following index when computing the numerator of the mean.
For example: >>> c = tf.constant([[1.0,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> tf.math.segment_mean(c, tf.constant([0, 0, 1])).numpy() array([[2.5, 2.5, 2.5, 2.5], [5., 6., 7., 8.]], dtype=float32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. Caution: The values are always validated to be sorted on CPU, never validated on GPU. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentMeanNr rr&r$r')r%rr&r'rr(r)r*r+r,r-_dispatcher_for_segment_meanrsegment_mean_eager_fallbackr/rjrrr rDrrrr0r1r2r3r4r5r6r*s rArDrD$sCb    0h..0$ #\\ 11 mT46g n.+ {D"D*Gn$ n  )::DkFAq#x QK' ""$3%%c*J  ,.F::L |VW6 (' .]  & &- ##At,,  # #    , d $d,g  & (  $D22  # #  z " "" "d+(,. g  ..<< <  " Z    Dd &*, Gi,,::: n  r,zraw_ops.SegmentMeanctj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tj tjg\}\}||g}d|d|f}tj,dd||||}tj.rtj0d||||\}|S)Nr$r's SegmentMeanrErFrFrr.s rArHrH$ 44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_aharart{tAtACJCPCPRYR`R`bibpbpryrBrBDKDRDRT[TcTcelesesu|uGuGIPIUIUW^WeWegnguguCxy'7D#+#B#BK=RUX_XeXegngtgtWw#x ..; $, *n 5&   ^Q|#)s ?' ""$ |VW6 (' .rTTV_SegmentMin_TTV_SegmentMin_Tindiceszmath.segment_min segment_minc ptjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4rHd|j7dd|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aComputes the minimum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \min_j(data_j)\\) where `min` is over `j` such that `segment_ids[j] == i`. If the min is empty for a given segment ID `i`, `output[i] = 0`. Caution: On CPU, values in `segment_ids` are always validated to be sorted, and an error is thrown for indices that are not increasing. On GPU, this does not throw an error for unsorted indices. On GPU, out-of-order indices result in safe but unspecified behavior, which may include treating out-of-order indices as the same as a smaller following index.
For example: >>> c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> tf.math.segment_min(c, tf.constant([0, 0, 1])).numpy() array([[1, 2, 2, 1], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. Caution: The values are always validated to be sorted on CPU, never validated on GPU. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentMinNr rr&r$r')r%rr&r'rr(r)r*r+r,r-_dispatcher_for_segment_minrsegment_min_eager_fallbackr/rjrrr rMrrrr0r1r2r3r4r5r6r*s rArMrM$r+r,zraw_ops.SegmentMinctj|g|tjtjtj tj tjtjtjtjtjtjtjtjg \}\}tj|g|tj tjg\}\}||g}d|d|f}tjdd||||}tj rtj"d||||\}|S)Nr$r's SegmentMinrErFrOrr.s rArQrQ$r0rTTV_SegmentMinV2_TTV_SegmentMinV2_TindicesTV_SegmentMinV2_Tnumsegmentsctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj rYd| j#dd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aK Computes the minimum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \min_j(data_j)\\) where `min` is over `j` such that `segment_ids[j] == i`. If the minimum is empty for a given segment ID `i`, it outputs the largest possible value for the specific numeric type, `output[i] = numeric_limits::max()`. Note: That this op is currently only supported with jit_compile=True. Caution: On CPU, values in `segment_ids` are always validated to be sorted, and an error is thrown for indices that are not increasing. On GPU, this does not throw an error for unsorted indices. On GPU, out-of-order indices result in safe but unspecified behavior, which may include treating out-of-order indices as the same as a smaller following index. The only difference with SegmentMin is the additional input `num_segments`. This helps in evaluating the output shape in compile time. `num_segments` should be consistent with segment_ids. e.g. Max(segment_ids) should be equal to `num_segments` - 1 for a 1-d segment_ids With inconsistent num_segments, the op still runs. only difference is, the output takes the size of num_segments irrespective of size of segment_ids and data. for num_segments less than expected output size, the last elements are ignored for num_segments more than the expected output size, last elements are assigned the largest possible value for the specific numeric type. For example: >>> @tf.function(jit_compile=True) ... def test(c): ... return tf.raw_ops.SegmentMinV2(data=c, segment_ids=tf.constant([0, 0, 1]), num_segments=2) >>> c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> test(c).numpy() array([[1, 2, 2, 1], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. The values must be less than `num_segments`. Caution: The values are always validated to be sorted on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentMinV2Nr r7r$r'r8)r%rr&r'rr(r)r*r+r,r-segment_min_v2_eager_fallbackr/r0r1r2r3r4r5r6r:s rAsegment_min_v2rY %r<r=zraw_ops.SegmentMinV2cbtj|g|tjtjtj tj tjtjtjtjtjtjtjtjg \}\}tj|g|tj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tjdd|| ||} tj rtj"d|| | | \} | S)Nr$r'r8s SegmentMinV2rErFrWrr?s rArXrXg%rArTTV_SegmentProd_TTV_SegmentProd_Tindiceszmath.segment_prod segment_prodc ptjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4rHd|j7dd|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)a Computes the product along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \prod_j data_j\\) where the product is over `j` such that `segment_ids[j] == i`. If the product is empty for a given segment ID `i`, `output[i] = 1`. Caution: On CPU, values in `segment_ids` are always validated to be sorted, and an error is thrown for indices that are not increasing. On GPU, this does not throw an error for unsorted indices. On GPU, out-of-order indices result in safe but unspecified behavior, which may include treating out-of-order indices as the same as a smaller following index.
For example: >>> c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> tf.math.segment_prod(c, tf.constant([0, 0, 1])).numpy() array([[4, 6, 6, 4], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. Caution: The values are always validated to be sorted on CPU, never validated on GPU. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentProdNr rr&r$r')r%rr&r'rr(r)r*r+r,r-_dispatcher_for_segment_prodrsegment_prod_eager_fallbackr/rjrrr r]rrrr0r1r2r3r4r5r6r*s rAr]r]z%sC^    0h..0$ #\\ 11 mT46g n.+ {D"D*Gn$ n  )::DkFAq#x QK' ""$3%%c*J  ,.F::L |VW6 (' .]  & &- ##At,,  # #    , d $d,g  & (  $D22  # #  z " "" "d+(,. g  ..<< <  " Z    Dd &*, Gi,,::: n  r,zraw_ops.SegmentProdctj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tj tjg\}\}||g}d|d|f}tj,dd||||}tj.rtj0d||||\}|S)Nr$r's SegmentProdrErFr_rr.s rArara%rJrTTV_SegmentProdV2_TTV_SegmentProdV2_TindicesTV_SegmentProdV2_Tnumsegmentsctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj rYd| j#dd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aComputes the product along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \prod_j data_j\\) where the product is over `j` such that `segment_ids[j] == i`. If the product is empty for a given segment ID `i`, `output[i] = 1`. Note: That this op is currently only supported with jit_compile=True. The only difference with SegmentProd is the additional input `num_segments`. This helps in evaluating the output shape in compile time. `num_segments` should be consistent with segment_ids. e.g. Max(segment_ids) - 1 should be equal to `num_segments` for a 1-d segment_ids With inconsistent num_segments, the op still runs. only difference is, the output takes the size of num_segments irrespective of size of segment_ids and data. for num_segments less than expected output size, the last elements are ignored for num_segments more than the expected output size, last elements are assigned 1. For example: >>> @tf.function(jit_compile=True) ... def test(c): ... return tf.raw_ops.SegmentProdV2(data=c, segment_ids=tf.constant([0, 0, 1]), num_segments=2) >>> c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> test(c).numpy() array([[4, 6, 6, 4], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. The values must be less than `num_segments`. Caution: The values are always validated to be sorted on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentProdV2Nr r7r$r'r8)r%rr&r'rr(r)r*r+r,r-segment_prod_v2_eager_fallbackr/r0r1r2r3r4r5r6r:s rAsegment_prod_v2ri%snb    0h..0$ #\\ 11 otT; Fg n(88d &2?!QX QK' ""$3%%c*J  ,n  02F::L vw8 (' .-  & &- ##At,,  # #    +  \$@@  # #   r=zraw_ops.SegmentProdV2c4tj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tj,dd|| ||} tj.rtj0d|| | | \} | S)Nr$r'r8s SegmentProdV2rErFrgrr?s rArhrhI&st44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_aharart{tAtACJCPCPRYR`R`bibpbpryrBrBDKDRDRT[TcTcelesesu|uGuGIPIUIUW^WeWegnguguCxy'7D#+#B#BK=RUX_XeXegngtgtWw#x ..;(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o| \2, *nn &   -q#)s ?' ""$ vw8 (' .rTTV_SegmentSum_TTV_SegmentSum_Tindiceszmath.segment_sum segment_sumc ptjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4rHd|j7dd|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aComputes the sum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \sum_j data_j\\) where sum is over `j` such that `segment_ids[j] == i`. If the sum is empty for a given segment ID `i`, `output[i] = 0`. Caution: On CPU, values in `segment_ids` are always validated to be sorted, and an error is thrown for indices that are not increasing. On GPU, this does not throw an error for unsorted indices. On GPU, out-of-order indices result in safe but unspecified behavior, which may include treating out-of-order indices as the same as a smaller following index.
For example: >>> c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]) >>> tf.math.segment_sum(c, tf.constant([0, 0, 1])).numpy() array([[5, 5, 5, 5], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. Caution: The values are always validated to be sorted on CPU, never validated on GPU. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentSumNr rr&r$r')r%rr&r'rr(r)r*r+r,r-_dispatcher_for_segment_sumrsegment_sum_eager_fallbackr/rjrrr rmrrrr0r1r2r3r4r5r6r*s rArmrm\&r+r,zraw_ops.SegmentSumctj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tj tjg\}\}||g}d|d|f}tj,dd||||}tj.rtj0d||||\}|S)Nr$r's SegmentSumrErFrorr.s rArqrq&s 44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_aharart{tAtACJCPCPRYR`R`bibpbpryrBrBDKDRDRT[TcTcelesesu|uGuGIPIUIUW^WeWegnguguCxy'7D#+#B#BK=RUX_XeXegngtgtWw#x ..; $, *n 5&   ]Al#)s ?' ""$ lFG5 (' .rTTV_SegmentSumV2_TTV_SegmentSumV2_TindicesTV_SegmentSumV2_Tnumsegmentsctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj rYd| j#dd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aComputes the sum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output_i = \sum_j data_j\\) where sum is over `j` such that `segment_ids[j] == i`. If the sum is empty for a given segment ID `i`, `output[i] = 0`. Note that this op is currently only supported with jit_compile=True. Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor whose size is equal to the size of `data`'s first dimension. Values should be sorted and can be repeated. The values must be less than `num_segments`. Caution: The values are always validated to be sorted on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SegmentSumV2Nr r7r$r'r8)r%rr&r'rr(r)r*r+r,r-segment_sum_v2_eager_fallbackr/r0r1r2r3r4r5r6r:s rAsegment_sum_v2ry&sm>    0h..0$ #\\ 11 ndD+|Eg n(88T{%1>!QX QK' ""$3%%c*J  ,n  02F::L  fg7 (' .-  & &- ##At,,  # #    *  \$@@  # #   r=zraw_ops.SegmentSumV2c4tj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tj,dd|| ||} tj.rtj0d|| | | \} | S)Nr$r'r8s SegmentSumV2rErFrwrr?s rArxrx'ss44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_aharart{tAtACJCPCPRYR`R`bibpbpryrBrBDKDRDRT[TcTcelesesu|uGuGIPIUIUW^WeWegnguguCxy'7D#+#B#BK=RUX_XeXegngtgtWw#x ..;(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o| \2, *nn &   _a #)s ?' ""$  fg7 (' .rT) TV_Select_TrrrVrWrhrrrirjrkrlrmrrrrnrrrXrYrZr[r\rorr]r^rpr_r`r conditionctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj r7d| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aSelects elements from `x` or `y`, depending on `condition`. The `x`, and `y` tensors must all have the same shape, and the output will also have that shape. The `condition` tensor must be a scalar if `x` and `y` are scalars. If `x` and `y` are vectors or higher rank, then `condition` must be either a scalar, a vector with size matching the first dimension of `x`, or must have the same shape as `x`. The `condition` tensor acts as a mask that chooses, based on the value at each element, whether the corresponding element / row in the output should be taken from `x` (if true) or `y` (if false). If `condition` is a vector and `x` and `y` are higher rank matrices, then it chooses which row (outer dimension) to copy from `x` and `y`. If `condition` has the same shape as `x` and `y`, then it chooses which element to copy from `x` and `y`. For example: ```python # 'condition' tensor is [[True, False] # [False, True]] # 't' is [[1, 2], # [3, 4]] # 'e' is [[5, 6], # [7, 8]] select(condition, t, e) # => [[1, 6], [7, 4]] # 'condition' tensor is [True, False] # 't' is [[1, 2], # [3, 4]] # 'e' is [[5, 6], # [7, 8]] select(condition, t, e) ==> [[1, 2], [7, 8]] ``` Args: condition: A `Tensor` of type `bool`. x: A `Tensor` which may have the same shape as `condition`. If `condition` is rank 1, `x` may have higher rank, but its first dimension must match the size of `condition`. y: A `Tensor` with the same type and shape as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `t`. SelectNr r|rr;r!r$)r%rr&r'rr(r)r*r+r,r-select_eager_fallbackr/r0r1r2r3r4r5r6) r|rrr!r8r9r:r;r<r=r>r?r@s rAselectr*'sDj    0h..0$ #\\ 11 hiA/g n(88Iad<!QX QK' ""$3%%c* +F::L ,1 (' .'  & &- ##At,,  # #    " Q$00  # #   r\zraw_ops.Selectc8tj||g|g\}}|\}}tj|tj }|||g}d|f}tj dd||||} tjrtjd||| | \} | S)Nr$sSelectrErFr~ r2rHr+rrIrrr3r6) r|rrr!r"rSrr@r?r:s rArr~'s661vsBG'9 &1a$$Y =)Q", >&   Y,f!$4 1' ""$ ,1 (' .rT) TV_SelectV2_TrrrVrWrhrrrirjrkrlrmrrrrnrrrXrYrZr[r\rorr]r^rpr_r`rr;ctjxstj}|j}|jr t j |d||||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)zTODO: add doc. Args: condition: A `Tensor` of type `bool`. t: A `Tensor`. e: A `Tensor`. Must have the same type as `t`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `t`. SelectV2Nr rr$)r%rr&r'rr(r)r*r+r,r-select_v2_eager_fallbackr/r0r1r2r3r4r5r6) r|rr;r!r8r9r:r<r=r>r?r@s rA select_v2r'sC    0h..0$ #\\ 11 j$ 1a1g n(88i1>!QX QK' ""$3%%c* +F::L L&'3 (' .'  & &- ##At,,  # #    % Q$00  # #   r\zraw_ops.SelectV2c8tj||g|g\}}|\}}tj|tj }|||g}d|f}tj dd||||} tjrtjd||| | \} | S)Nr$sSelectV2rErFrr) r|rr;r!r"rSrr@r?r:s rArr's661vsBG'9 &1a$$Y =)Q", >&   [!L#)s ?' ""$ L&'3 (' .rT TV_Sigmoid_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)a<Computes sigmoid of `x` element-wise. Specifically, `y = 1 / (1 + exp(-x))`. Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SigmoidNr r#r$)r%rr&r'rr(r)r*r+r,r-sigmoid_eager_fallbackr/r0r1r2r3r4r5r6r7s rAsigmoidr's7    0h..0$ #\\ 11 iq"g n(88QT#!QX QK' ""$3%%c* +F::L <2 (' .'  & &- ##At,,  # #    # $D""  # #   rCzraw_ops.Sigmoidc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sSigmoidrErFrrrRs rArr's111#sW=M=Mw||]d]l]lnun}n}@G@Q@QSZSeSe=hi-'4A, >&   Z&   ^Q|#)s ?' ""$ |VW6 (' .rT TV_Sign_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)adReturns an element-wise indication of the sign of a number. `y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`. For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`. Example usage: >>> tf.math.sign([0., 2., -3.]) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SignNr r#r$)r%rr&r'rr(r)r*r+r,r-sign_eager_fallbackr/r0r1r2r3r4r5r6r7s rAsignrB(s7$    0h..0$ #\\ 11 fdAg n(88!$ !QX QK' ""$3%%c* +F::L  fg/ (' .'  & &- ##At,,  # #    $D""  # #   rCz raw_ops.Signctj|g|tjtjtj tj tjtjtjtjtjtjg \}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sSignrErFrrrRs rArrs(s111#sW=M=Mw||]d]l]lnun}n}@G@L@LNUN[N[]d]j]jlslyly{B{L{LNUN`N`=cd-'4A, >&   Wa F!$4 1' ""$  fg/ (' .rTTV_Sin_Tzmath.sinsinc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)arComputes sine of x element-wise. Given an input tensor, this function computes sine of every element in the tensor. Input range is `(-inf, inf)` and output range is `[-1,1]`. ```python x = tf.constant([-float("inf"), -9, -0.5, 1, 1.2, 200, 10, float("inf")]) tf.math.sin(x) ==> [nan -0.4121185 -0.47942555 0.84147096 0.9320391 -0.87329733 -0.54402107 nan] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SinNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_sinrsin_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr(s,    0h..0$ #\\ 11 eT1g n," D DGn$ n  ):: Aq#x QK' ""$3%%c* +F::L  |VW. (' .W  & &- ##At,,  # #    # d*dg  &  $D""  # #  z " "" TAD) g  ..<< <  Z    r4!$' Gi,,::: n  rz raw_ops.Sinc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sSinrErFrrrRs rArr(rrT TV_Sinh_Tz math.sinhsinhc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes hyperbolic sine of x element-wise. Given an input tensor, this function computes hyperbolic sine of every element in the tensor. Input range is `[-inf,inf]` and output range is `[-inf,inf]`. ```python x = tf.constant([-float("inf"), -9, -0.5, 1, 1.2, 2, 10, float("inf")]) tf.math.sinh(x) ==> [-inf -4.0515420e+03 -5.2109528e-01 1.1752012e+00 1.5094614e+00 3.6268604e+00 1.1013232e+04 inf] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SinhNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_sinhrsinh_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r7s rArr(rrz raw_ops.Sinhc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sSinhrErFrrrRs rArr-)rrTTV_SobolSample_dtypedim num_resultsskipc tjxstj}|j}|jr t j |d||||d|}|S|tj}tj |d}t#j$d|||||\} } } } | dd}tj&r7d| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)a<Generates points from the Sobol sequence. Creates a Sobol sequence with `num_results` samples. Each sample has dimension `dim`. Skips the first `skip` samples. Args: dim: A `Tensor` of type `int32`. Positive scalar `Tensor` representing each sample's dimension. num_results: A `Tensor` of type `int32`. Positive scalar `Tensor` of dtype int32. The number of Sobol points to return in the output. skip: A `Tensor` of type `int32`. Positive scalar `Tensor` of dtype int32. The number of initial points of the Sobol sequence to skip. dtype: An optional `tf.DType` from: `tf.float32, tf.float64`. Defaults to `tf.float32`. The type of the sample. One of: `float32` or `float64`. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. SobolSampler^Nra)rrrr^r!)r%rr&r'rr(r)r*r+r,r-sobol_sample_eager_fallbackr/rIrLr2rr0r1r3r4r5r6)rrrr^r!r8r9r:r;r<r=r>r?r@s rA sobol_sampler<)sq,    0h..0$ #\\ 11 mT3 T7EKg n ] OOE   UG ,%'883Kd"/!QX QK' ""$s))'2 3F::L |VW6 (' ./  & &- ##At,,  # #    ( {DDdDD  # #   s0C<<ED**EEEE/.E/zraw_ops.SobolSamplec|tj}tj|d}t j |tj }t j |tj }t j |tj }|||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr^s SobolSamplerErFr) rIrLr2rr+rrPrr3r6) rrrr^r!r"r@r?r:s rArru)s ] OOE   UG ,% sGMM2#&&{GMMB+  gmm 4${D), U &   ^Q|#)s ?' ""$ |VW6 (' .rTTV_SparseBincount_TidxTV_SparseBincount_Tindices dense_shapec tjxstj}|j}|jr! t j |d||||||d| } | S|d}tj|d}tj d|||||||\} } } } | dd} tj"rYd| j%dd| j%dd| j'df}| j(}tj*d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||S#t j$rY(wxYw) a%Counts the number of occurrences of each value in an integer array. Outputs a vector with length `size` and the same dtype as `weights`. If `weights` are empty, then index `i` stores the number of times the value `i` is counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of the value in `weights` at each index where the corresponding value in `arr` is `i`. Values in `arr` outside of the range [0, size) are ignored. Args: indices: A `Tensor` of type `int64`. 2D int64 `Tensor`. values: A `Tensor`. Must be one of the following types: `int32`, `int64`. 1D int `Tensor`. dense_shape: A `Tensor` of type `int64`. 1D int64 `Tensor`. size: A `Tensor`. Must have the same type as `values`. non-negative int scalar `Tensor`. weights: A `Tensor`. Must be one of the following types: `int32`, `int64`, `float32`, `float64`. is an int32, int64, float32, or float64 `Tensor` with the same shape as `input`, or a length-0 `Tensor`, in which case it acts as all weights equal to 1. binary_output: An optional `bool`. Defaults to `False`. bool; Whether the kernel should count the appearance or number of occurrences. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `weights`. SparseBincountrNrF)rr[rrVrWrr!rr$)r%rr&r'rr(r)r*r+r,r-sparse_bincount_eager_fallbackr/r2rr0r1r3r4rr5r6)rr[rrVrWrr!r8r9r:r;r<r=r>r?r@s rAsparse_bincountr)s:    0h..0$ #\\ 11 gv{D-1gnM$$]OD-'88'&&1g(5DB!QX QK' ""$c((0#  %  13F::L ,9 (' .7  & &- ##At,,  # #    + 6;g%Dd<<  # #   s0DE'EEEE22F F zraw_ops.SparseBincountc|d}tj|d}tj||g|tjtj g\}} | \}}tj|g|tjtj tj tjg\} \}tj|tj }tj|tj }|||||g} d|d| d|f} tjdd| | ||} tjrtjd| | | | \} | S) NFrrr$sSparseBincountrErFrr)rr[rrVrWrr!r"rrrSr@r?r:s rArr)sAM$$]OD-%<, JWo} M&   .,#)s ?' ""$ ,9 (' .rTTV_SparseMatMul_TaTV_SparseMatMul_Tb a_is_sparse b_is_sparsec tjxstj}|j}|jr$ t j |d|||d|d|d|d| } | S|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj d||||||| \} } } } | dd} tj"rd| j%dd| j%dd| j%dd| j%dd | j'd d | j'd f }| j(}tj*d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||S#t j$rYwxYw) a[Multiply matrix "a" by matrix "b". The inputs must be two-dimensional matrices and the inner dimension of "a" must match the outer dimension of "b". Both "a" and "b" must be `Tensor`s not `SparseTensor`s. This op is optimized for the case where at least one of "a" or "b" is sparse, in the sense that they have a large proportion of zero values. The breakeven for using this versus a dense matrix multiply on one platform was 30% zero values in the sparse matrix. The gradient computation of this operation will only take advantage of sparsity in the input gradient when that gradient comes from a Relu. Args: a: A `Tensor`. Must be one of the following types: `float32`, `bfloat16`. b: A `Tensor`. Must be one of the following types: `float32`, `bfloat16`. transpose_a: An optional `bool`. Defaults to `False`. transpose_b: An optional `bool`. Defaults to `False`. a_is_sparse: An optional `bool`. Defaults to `False`. b_is_sparse: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. SparseMatMulrrrrN)rrrrr!r"F)rLrMrrrrr!rBrC)r%rr&r'rr(r)r*r+r,r-sparse_mat_mul_eager_fallbackr/r2rr0r1r3rr4r5r6)rLrMrrrrr!r8r9r:r;r<r=r>r?r@s rAsparse_mat_mulr)s22    0h..0$ #\\  11 ndAq-{M; gnK""; >+K""; >+K""; >+K""; >+'88!qk$/[$/d<!QX QK' ""$S// >   /  /  /  &c.@.@.F HF ::L  fg7 (' .O  & &- ##At,,  # #    * QK[!{  # #   s0"FG+GGG#G66H  H zraw_ops.SparseMatMulc |d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj|g|tjtj gtj\}\}tj|g|tjtj gtj\} \}||g} d|d|d|d|d|d| f } tj dd | | || } tjrtjd | | | | \} | S) NFrrrrrBrCs SparseMatMulrErFr) r2rrHrIrLrJrr3r6) rLrMrrrrr!r"rGrHr@r?r:s rArr4*sWK""; >+K""; >+K""; >+K""; >+22A3goowO_O_=bdkdsdst.(DQ22A3goowO_O_=bdkdsdst.(DQQ, ; {m[$ &   _a #)s ?' ""$  fg7 (' .rTTV_SparseSegmentMean_TTV_SparseSegmentMean_Tidx TV_SparseSegmentMean_Tsegmentidssparse_gradientc .tjxstj}|j}|jr t j |d||||d|}|S|d}tj|d}tj d|||||\} } } } | dd}tj"rjd| j%dd| j%dd | j%d d| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY5wxYw) a,Computes the mean along sparse segments of a tensor. See `tf.sparse.segment_sum` for usage examples. Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first dimension, selecting a subset of dimension 0, specified by `indices`. Args: data: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Has same rank as `segment_ids`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Values should be sorted and can be repeated. sparse_gradient: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SparseSegmentMeanrNrr!r"Fr"rr#rr!r$r Tsegmentids)r%rr&r'rr(r)r*r+r,r-"sparse_segment_mean_eager_fallbackr/r2rr0r1r3r4rr5r6r"rr#rr!r8r9r:r;r<r=r>r?r@s rAsparse_segment_meanrT*s(    0h..0$ #\\ 11 !4w ?,gnO&&8IJ/'88$)4-<4I!QX QK' ""$3%%c*F  (-  /1B  !235F::L \67< (' .9  & &- ##At,,  # #    / o  # #   0D!!E(4EE('E(,E==FFzraw_ops.SparseSegmentMeanc|d}tj|d}tj|g|tjtj tj tjg\}\}tj|g|tjtjgtj\}\}tj|g|tjtjgtj\}\}|||g} d|d|d|d|f} tjdd| | ||} tjrtjd | | | | \} | S) NFrr$rrsSparseSegmentMeanrErFrr r"rr#rr!r"rSr_attr_Tsegmentidsr@r?r:s rArr*scO&&8IJ/44dVS7CSCSU\UaUacjcrcrt{uDuDCGH'7D#::G9cGMM[b[h[hKkmtmzmz{*jw&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^k-, &*m& 9&   11\#)s ?' ""$ \67< (' .rTTV_SparseSegmentMeanGrad_TTV_SparseSegmentMeanGrad_Tidx$TV_SparseSegmentMeanGrad_Tsegmentidsgrad output_dim0c tjxstj}|j}|jr t j |d|||||}|Stjd|||||\} } } } | dd}tj rYd| j#dd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY wxYw)a0Computes gradients for SparseSegmentMean. Returns tensor "output" with same shape as grad, except for dimension 0 whose value is output_dim0. Args: grad: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. gradient propagated to the SparseSegmentMean op. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. indices passed to the corresponding SparseSegmentMean op. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. segment_ids passed to the corresponding SparseSegmentMean op. output_dim0: A `Tensor` of type `int32`. dimension 0 of "data" passed to SparseSegmentMean op. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `grad`. SparseSegmentMeanGradNr rrr#rr!r$rr)r%rr&r'rr(r)r*r+r,r-'sparse_segment_mean_grad_eager_fallbackr/r0r1r2r3r4r5r6rrr#rr!r8r9r:r;r<r=r>r?r@s rAsparse_segment_mean_gradr*sy(    0h..0$ #\\ 11 %tT7Kgn(88dG-8-8tE!QX QK' ""$3%%c*F  (-  /1F::L vw@ (' ./  & &- ##At,,  # #    4 k$HH  # #   0C55D<D##D<;D<EE('E(zraw_ops.SparseSegmentMeanGradctj|g|tjtjtj tj g\}\}tj|g|tjtjgtj\}\}tj|g|tjtjgtj\}\}tj|tj}||||g} d|d|d|f} tjdd| | ||} tjrtjd| | | | \} | S)Nr$rrsSparseSegmentMeanGradrErFrr2rHrIrJrKrLrMrPrQr+rrr3r6 rrr#rr!r"rSrrr@r?r:s rArr*sY44dVS7CSCSU\UaUacjcrcrt{uDuDCGH'7D#::G9cGMM[b[h[hKkmtmzmz{*jw&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^k&&{GMMB+k:, &*m &   5q#)s ?' ""$ vw@ (' .rTSparseSegmentMeanGradV2rmsorted_unique_indicesTV_SparseSegmentMeanGradV2_TTV_SparseSegmentMeanGradV2_Tidx&TV_SparseSegmentMeanGradV2_Tsegmentidsdense_output_dim0c "tjxstj}|j}|jr3 t j |d|||||}t j|}|Stj d|||||\} } } } | dd}t#j$rYd| j'dd| j'dd| j'df} | j(} t#j*d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rYwxYw)aHComputes gradients for SparseSegmentMean. Returns tensor "output" with same shape as grad, except for dimension 0 whose value is the number of unique indexes in "indices". Also returns vector "sorted_unique_indices" containing the corresponding indexes from "indices". Args: grad: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. gradient propagated to the SparseSegmentMean op. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. indices passed to the corresponding SparseSegmentMean op. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. segment_ids passed to the corresponding SparseSegmentMean op. dense_output_dim0: A `Tensor` of type `int32`. dimension 0 of "data" passed to SparseSegmentMean op. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output, sorted_unique_indices). output: A `Tensor`. Has the same type as `grad`. sorted_unique_indices: A `Tensor`. Has the same type as `indices`. rNr rrr#rr!r$rr)r%rr&r'rr(_SparseSegmentMeanGradV2Outputryr)r*r+r,r-*sparse_segment_mean_grad_v2_eager_fallbackr/r0r1r2r3r4r5r6rrr#rr!r8r9r:r;r<r=r>r?r@s rAsparse_segment_mean_grad_v2r*s0    0h..0$ #\\  11 'tWkg/44W=g n(88!g/:5F(, .!QX QK' ""$3%%c*F  (-  /1F::L !<B * 0 0 9' .1  & &- ##At,,  # #    7 &7dNN  # #   01DE".E  E"!E"&E77F Fzraw_ops.SparseSegmentMeanGradV2ctj|g|tjtjtj tj g\}\}tj|g|tjtjgtj\}\}tj|g|tjtjgtj\}\}tj|tj}||||g} d|d|d|f} tjdd| | ||} tjrtjd| | | tj| } | S)Nr$rrsSparseSegmentMeanGradV2rrFr)r2rHrIrJrKrLrMrPrQr+rrr3r6rry rrr#rr!r"rSrrr@r?r:s rArr7+sh44dVS7CSCSU\UaUacjcrcrt{uDuDCGH'7D#::G9cGMM[b[h[hKkmtmzmz{*jw&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^k,,-> N.?@, &*m &   7$0C"& ('""$ !<B * 0 0 9' .rT%TV_SparseSegmentMeanWithNumSegments_T(TV_SparseSegmentMeanWithNumSegments_Tidx0TV_SparseSegmentMeanWithNumSegments_Tnumsegments/TV_SparseSegmentMeanWithNumSegments_Tsegmentidsc Vtjxstj}|j}|jr t j |d|||||d| }|S|d}tj|d}tj d||||||\} } } } | dd}tj"r{d| j%dd| j%dd | j%d d | j%d d| j'df } | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYHwxYw) aComputes the mean along sparse segments of a tensor. Like `SparseSegmentMean`, but allows missing ids in `segment_ids`. If an id is missing, the `output` tensor at that position will be zeroed. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Args: data: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Has same rank as `segment_ids`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Values should be sorted and can be repeated. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. Should equal the number of distinct segment IDs. sparse_gradient: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SparseSegmentMeanWithNumSegmentsrNrFr"rr#r4rr!r$rr8r)r%rr&r'rr(r)r*r+r,r-4sparse_segment_mean_with_num_segments_eager_fallbackr/r2rr0r1r3r4rr5r6r"rr#r4rr!r8r9r:r;r<r=r>r?r@s rA%sparse_segment_mean_with_num_segmentsrN+s0    0h..0$ #\\ 11 0$g\#4oGgnO&&8IJ/'88*w8C9Eg n(88"w0;6G)- /!QX QK' ""$3%%c*F  (-  /1F::L "L&'C + 1 1' :' .1  & &- ##At,,  # #    9 &7dNN  # #   rz raw_ops.SparseSegmentSqrtNGradV2ctj|g|tjtjtj tj g\}\}tj|g|tjtjgtj\}\}tj|g|tjtjgtj\}\}tj|tj}||||g} d|d|d|f} tjdd| | ||} tjrtjd| | | tj| } | S)Nr$rrsSparseSegmentSqrtNGradV2rrFr)r2rHrIrJrKrLrMrPrQr+rrr3r6rryrs rArr,sh44dVS7CSCSU\UaUacjcrcrt{uDuDCGH'7D#::G9cGMM[b[h[hKkmtmzmz{*jw&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^k,,-> N.?@, &*m &   8!$0C"& ('""$ "L&'C + 1 1' :' .rT&TV_SparseSegmentSqrtNWithNumSegments_T)TV_SparseSegmentSqrtNWithNumSegments_Tidx1TV_SparseSegmentSqrtNWithNumSegments_Tnumsegments0TV_SparseSegmentSqrtNWithNumSegments_Tsegmentidsc Vtjxstj}|j}|jr t j |d|||||d| }|S|d}tj|d}tj d||||||\} } } } | dd}tj"r{d| j%dd| j%dd | j%d d | j%d d| j'df } | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYHwxYw) aMComputes the sum along sparse segments of a tensor divided by the sqrt of N. N is the size of the segment being reduced. Like `SparseSegmentSqrtN`, but allows missing ids in `segment_ids`. If an id is missing, the `output` tensor at that position will be zeroed. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Args: data: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Has same rank as `segment_ids`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Values should be sorted and can be repeated. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. Should equal the number of distinct segment IDs. sparse_gradient: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. !SparseSegmentSqrtNWithNumSegmentsrNrFrr$rr8r)r%rr&r'rr(r)r*r+r,r-6sparse_segment_sqrt_n_with_num_segments_eager_fallbackr/r2rr0r1r3r4rr5r6rs rA'sparse_segment_sqrt_n_with_num_segmentsr ,s4    0h..0$ #\\ 11 14w\#4oGgnO&&8IJ/'88+$9D:F=L26 8!QX QK' ""$3%%c*F  (.  0-  /1B  !23 5F ::L +\67L (' .?  & &- ##At,,  # #    C l)$@@  # #   rz)raw_ops.SparseSegmentSqrtNWithNumSegmentsc b|d}tj|d}tj|g|tjtj tj tjg\}\}tj|g|tjtjgtj\}\}tj|g|tjtjgtj\} \}tj|g|tjtjgtj\} \}||||g} d|d|d| d| d|f } tjdd| | || } tjrtjd | | | | \} | S) NFrr$rr8rs!SparseSegmentSqrtNWithNumSegmentsrErFrrrs rArr,sO&&8IJ/44dVS7CSCSU\UaUacjcrcrt{uDuDCGH'7D#::G9cGMM[b[h[hKkmtmzmz{*jw(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o|&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^kl;, &*nm%68I &   A1$0C"& ('""$ +\67L (' .rTTV_SparseSegmentSum_TTV_SparseSegmentSum_TidxTV_SparseSegmentSum_Tsegmentidsc .tjxstj}|j}|jr t j |d||||d|}|S|d}tj|d}tj d|||||\} } } } | dd}tj"rjd| j%dd| j%dd | j%d d| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY5wxYw) aComputes the sum along sparse segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first dimension, selecting a subset of dimension 0, specified by `indices`. For example: ```python c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]]) # Select two rows, one segment. tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0])) # => [[0 0 0 0]] # Select two rows, two segment. tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1])) # => [[ 1 2 3 4] # [-1 -2 -3 -4]] # Select all rows, two segments. tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1])) # => [[0 0 0 0] # [5 6 7 8]] # Which is equivalent to: tf.segment_sum(c, tf.constant([0, 0, 1])) ``` Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Has same rank as `segment_ids`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Values should be sorted and can be repeated. sparse_gradient: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SparseSegmentSumrNrFrr$rr)r%rr&r'rr(r)r*r+r,r-!sparse_segment_sum_eager_fallbackr/r2rr0r1r3r4rr5r6rs rAsparse_segment_sumr(-sZ    0h..0$ #\\ 11  $g{?,gnO&&8IJ/'88w(3,;$H!QX QK' ""$3%%c*F  (-  /1B  !235F::L L&'; (' .9  & &- ##At,,  # #    . o  # #   rzraw_ops.SparseSegmentSumc|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjg \}\}tj|g|tj tjgtj \}\}tj|g|tj tjgtj \}\}|||g} d|d|d|d|f} tj dd| | ||} tj"rtj$d | | | | \} | S) NFrr$rrsSparseSegmentSumrErFr&r2rrHrIrLrMrPrrrOrNrQrJryrKr{r|rr3r6rs rAr'r'\-s O&&8IJ/44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_ahananpwp@p@BIBPBPRYR^R^`g`n`npwp~p~CAB'7D#::G9cGMM[b[h[hKkmtmzmz{*jw&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^k-, &*m& 9&   0!L#)s ?' ""$ L&'; (' .rTTV_SparseSegmentSumGrad_TTV_SparseSegmentSumGrad_Tidx#TV_SparseSegmentSumGrad_Tsegmentidsc tjxstj}|j}|jr t j |d|||||}|Stjd|||||\} } } } | dd}tj rYd| j#dd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY wxYw)a+Computes gradients for SparseSegmentSum. Returns tensor "output" with same shape as grad, except for dimension 0 whose value is output_dim0. Args: grad: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. gradient propagated to the SparseSegmentSum op. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. indices passed to the corresponding SparseSegmentSum op. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. segment_ids passed to the corresponding SparseSegmentSum op. output_dim0: A `Tensor` of type `int32`. dimension 0 of "data" passed to SparseSegmentSum op. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `grad`. SparseSegmentSumGradNr rr$rr)r%rr&r'rr(r)r*r+r,r-&sparse_segment_sum_grad_eager_fallbackr/r0r1r2r3r4r5r6rs rAsparse_segment_sum_gradr1s-sx(    0h..0$ #\\ 11 $dD';gn(88T7,7,7dD!QX QK' ""$3%%c*F  (-  /1F::L  fg? (' ./  & &- ##At,,  # #    3 k$HH  # #   rzraw_ops.SparseSegmentSumGradctj|g|tjtjtj tj g\}\}tj|g|tjtjgtj\}\}tj|g|tjtjgtj\}\}tj|tj}||||g} d|d|d|f} tjdd| | ||} tjrtjd| | | | \} | S)Nr$rrsSparseSegmentSumGradrErFr/rrs rAr0r0-sX44dVS7CSCSU\UaUacjcrcrt{uDuDCGH'7D#::G9cGMM[b[h[hKkmtmzmz{*jw&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^k&&{GMMB+k:, &*m &   4a #)s ?' ""$  fg? (' .rTSparseSegmentSumGradV2TV_SparseSegmentSumGradV2_TTV_SparseSegmentSumGradV2_Tidx%TV_SparseSegmentSumGradV2_Tsegmentidsc "tjxstj}|j}|jr3 t j |d|||||}t j|}|Stj d|||||\} } } } | dd}t#j$rYd| j'dd| j'dd| j'df} | j(} t#j*d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rYwxYw)aCComputes gradients for SparseSegmentSum. Returns tensor "output" with same shape as grad, except for dimension 0 whose value is the number of unique indexes in "indices". Also returns vector "sorted_unique_indices" containing the corresponding indexes from "indices". Args: grad: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. gradient propagated to the SparseSegmentSum op. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. indices passed to the corresponding SparseSegmentSum op. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. segment_ids passed to the corresponding SparseSegmentSum op. dense_output_dim0: A `Tensor` of type `int32`. dimension 0 of "data" passed to SparseSegmentSum op. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output, sorted_unique_indices). output: A `Tensor`. Has the same type as `grad`. sorted_unique_indices: A `Tensor`. Has the same type as `indices`. r3Nr rr$rr)r%rr&r'rr(_SparseSegmentSumGradV2Outputryr)r*r+r,r-)sparse_segment_sum_grad_v2_eager_fallbackr/r0r1r2r3r4r5r6rs rAsparse_segment_sum_grad_v2r:-s0    0h..0$ #\\  11 &dG[g.33G N.?@, &*m &   6$0C"& ('""$  ,A ) / / 8' .rT$TV_SparseSegmentSumWithNumSegments_T'TV_SparseSegmentSumWithNumSegments_Tidx/TV_SparseSegmentSumWithNumSegments_Tnumsegments.TV_SparseSegmentSumWithNumSegments_Tsegmentidsc Vtjxstj}|j}|jr t j |d|||||d| }|S|d}tj|d}tj d||||||\} } } } | dd}tj"r{d| j%dd| j%dd | j%d d | j%d d| j'df } | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYHwxYw) aComputes the sum along sparse segments of a tensor. Like `SparseSegmentSum`, but allows missing ids in `segment_ids`. If an id is missing, the `output` tensor at that position will be zeroed. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/sparse#Segmentation) for an explanation of segments. For example: ```python c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]]) tf.sparse_segment_sum_with_num_segments( c, tf.constant([0, 1]), tf.constant([0, 0]), num_segments=3) # => [[0 0 0 0] # [0 0 0 0] # [0 0 0 0]] tf.sparse_segment_sum_with_num_segments(c, tf.constant([0, 1]), tf.constant([0, 2], num_segments=4)) # => [[ 1 2 3 4] # [ 0 0 0 0] # [-1 -2 -3 -4] # [ 0 0 0 0]] ``` Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Has same rank as `segment_ids`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1-D tensor. Values should be sorted and can be repeated. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. Should equal the number of distinct segment IDs. sparse_gradient: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. SparseSegmentSumWithNumSegmentsrNrFrr$rr8r)r%rr&r'rr(r)r*r+r,r-3sparse_segment_sum_with_num_segments_eager_fallbackr/r2rr0r1r3r4rr5r6rs rA$sparse_segment_sum_with_num_segmentsrC.sZ    0h..0$ #\\ 11 /tW\#4oGgnO&&8IJ/'88)g7B8D;J04 6!QX QK' ""$3%%c*F  (.  0-  /1B  !23 5F ::L )<J (' .?  & &- ##At,,  # #    @ l)$@@  # #   rz'raw_ops.SparseSegmentSumWithNumSegmentscR|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjg \}\}tj|g|tj tjgtj \}\}tj|g|tj tjgtj \} \}tj|g|tj tjgtj \} \}||||g} d|d|d| d| d|f } tj dd| | || } tj"rtj$d | | | | \} | S) NFrr$rr8rsSparseSegmentSumWithNumSegmentsrErFrAr*rs rArBrBr.saO&&8IJ/44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_ahananpwp@p@BIBPBPRYR^R^`g`n`npwp~p~CAB'7D#::G9cGMM[b[h[hKkmtmzmz{*jw(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o|&.&E&E{mUX[b[h[hjqjwjwZz}D}J}J'K#^kl;, &*nm%68I &   ?$0C"& ('""$ )<J (' .rT TV_Sqrt_Tc~tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)a;Computes square root of x element-wise. I.e., \\(y = \sqrt{x} = x^{1/2}\\). Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SqrtNr r#r$)r%rr&r'rr(r)r*r+r,r-sqrt_eager_fallbackr/r0r1r2r3r4r5r6r7s rAsqrtrI.s7    0h..0$ #\\ 11 fdAg n(88!$ !QX QK' ""$3%%c* +F::L  fg/ (' .'  & &- ##At,,  # #    $D""  # #   rCz raw_ops.Sqrtc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sSqrtrErFrGrrRs rArHrH.rrT TV_SqrtGrad_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aComputes the gradient for the sqrt of `x` wrt its input. Specifically, `grad = dy * 0.5 / y`, where `y = sqrt(x)`, and `dy` is the corresponding input gradient. Args: y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. dy: A `Tensor`. Must have the same type as `y`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `y`. SqrtGradNr rr$)r%rr&r'rr(r)r*r+r,r-sqrt_grad_eager_fallbackr/r0r1r2r3r4r5r6rs rA sqrt_gradrO.=    0h..0$ #\\ 11 j$2'g n(88aBT+!QX QK' ""$3%%c* +F::L L&'3 (' .'  & &- ##At,,  # #    % Rd&&  # #   rzraw_ops.SqrtGradc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sSqrtGradrErFrMrrs rArNrN.662wgFVFVX_XdXdfmfufuw~xGxGIPIZIZ\c\n\nFqr'9 '1bR, >&   [!L#)s ?' ""$ L&'3 (' .rT TV_Square_Tz math.squaresquarec >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes square of x element-wise. I.e., \\(y = x * x = x^2\\). >>> tf.math.square([-2., 0., 3.]) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SquareNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_squarersquare_eager_fallbackr/rjrrr rTrrrr0r1r2r3r4r5r6r7s rArTrT/s$    0h..0$ #\\ 11 ha!g n,% D DGn$ n  )::AD"Aq#x QK' ""$3%%c* +F::L ,1 (' .W  & &- ##At,,  # #    & d*dg  & " $D""  # #  z " "" Bqt, g  ..<< <  Z    "dQT* Gi,,::: n  rzraw_ops.Squarectj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj g\}\}|g}d|f}tj"dd||||}tj$rtj&d||||\}|S)Nr$sSquarerErFrV)r2rHrIrJrKrLrMrNrOrPrQrrryr{r|rsrzrr3r6rRs rArXrXK/ss111#sW=M=Mw||]d]l]lnun}n}@G@L@LNUN[N[]d]j]jlslyly{B{H{HJQJXJXZaZhZhjqjxjxzAzKzKMTM_M_=bc-'4A, >&   Y,f!$4 1' ""$ ,1 (' .rTTV_SquaredDifference_Tzmath.squared_differencesquared_differencec Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aReturns conj(x - y)(x - y) element-wise. *NOTE*: `math.squared_difference` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SquaredDifferenceNr rrr$)r%rr&r'rr(r)r*r+r,r-"_dispatcher_for_squared_differencer!squared_difference_eager_fallbackr/rjrrr r[rrrr0r1r2r3r4r5r6rs rAr[r[Z/s($    0h..0$ #\\ 11 !4A/g n,1 At tGn$ n  )::qAD2Aq#x QK' ""$3%%c* +F::L \67< (' .W  & &- ##At,,  # #    2 a-g  & . QTt%%  # #  z " "" D1$= g  ..<< <  Z    b$ad"; Gi,,::: n  rzraw_ops.SquaredDifferencec tj||g|tjtjtj tj tjtjtjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sSquaredDifferencerErFr])r2rHrIrJrKrLrMrPrQrsrzrr3r6rs rAr_r_/s661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WdWdfmfwfwy@yKyKENO'9 &1aQ, >&   11\#)s ?' ""$ \67< (' .rTTV_Sub_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)a Returns x - y element-wise. *NOTE*: `tf.subtract` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Both input and output have a range `(-inf, inf)`. Example usages below. Subtract operation between an array and a scalar: >>> x = [1, 2, 3, 4, 5] >>> y = 1 >>> tf.subtract(x, y) >>> tf.subtract(y, x) Note that binary `-` operator can be used instead: >>> x = tf.convert_to_tensor([1, 2, 3, 4, 5]) >>> y = tf.convert_to_tensor(1) >>> x - y Subtract operation between an array and a tensor of same shape: >>> x = [1, 2, 3, 4, 5] >>> y = tf.constant([5, 4, 3, 2, 1]) >>> tf.subtract(y, x) **Warning**: If one of the inputs (`x` or `y`) is a tensor and the other is a non-tensor, the non-tensor input will adopt (or get casted to) the data type of the tensor input. This can potentially cause unwanted overflow or underflow conversion. For example, >>> x = tf.constant([1, 2], dtype=tf.int8) >>> y = [2**8 + 1, 2**8 + 2] >>> tf.subtract(x, y) When subtracting two input values of different shapes, `tf.subtract` follows the [general broadcasting rules](https://numpy.org/doc/stable/user/basics.broadcasting.html#general-broadcasting-rules) . The two input array shapes are compared element-wise. Starting with the trailing dimensions, the two dimensions either have to be equal or one of them needs to be `1`. For example, >>> x = np.ones(6).reshape(2, 3, 1) >>> y = np.ones(6).reshape(2, 1, 3) >>> tf.subtract(x, y) Example with inputs of different dimensions: >>> x = np.ones(6).reshape(2, 3, 1) >>> y = np.ones(6).reshape(1, 6) >>> tf.subtract(x, y) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `int64`, `complex64`, `complex128`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. SubNr rr$)r%rr&r'rr(r)r*r+r,r-sub_eager_fallbackr/r0r1r2r3r4r5r6rs rAsubre/s>n    0h..0$ #\\ 11 eT1a!g n(88 ad$!QX QK' ""$3%%c* +F::L  |VW. (' .'  & &- ##At,,  # #     QTt%%  # #   rz raw_ops.Subctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj g\}}|\}}||g}d|f}tj"dd||||}tj$rtj&d||||\}|S)Nr$sSubrErFrc)r2rHrIrJrKrLrMrrrNryrOrPrQrsrzr{r|rr3r6rs rArdrd*0s661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WcWcelesesu|uBuBDKDQDQSZS`S`bibsbsu|uGuGIPIWIWY`YgYgEjk'9 &1aQ, >&   VQ|6!$4 1' ""$  |VW. (' .rTTV_Sum_T TV_Sum_Tidxc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | dd}tj"rYd| j%dd| j'dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY"wxYw) aComputes the sum of elements across dimensions of a tensor. Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1. Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. The tensor to reduce. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. The dimensions to reduce. Must be in the range `[-rank(input), rank(input))`. keep_dims: An optional `bool`. Defaults to `False`. If true, retain reduced dimensions with length 1. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. SumrNrFrr$r)r%rr&r'rr(r)r*r+r,r-_sum_eager_fallbackr/r2rr0r1r3rr4r5r6rs rA_sumrl;0rr!z raw_ops.Sumc|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\}\}tj|g|tj tjgtj \}\}||g}d|d|d|f}tj.dd||||} tj0rtj2d||| | \} | S) NFrr$rsSumrErFrjrr#s rArkrkt0sEI  K8)55ugsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjctctv}vCvCELERERT[TbTbdkdrdrt{tDtDFMFTFTV]VeVegnguguw~wIwIKRKWKWY`YgYgipiwiwEz{'8E 77gmmU\UbUbEegngtgtu*gt, C&* E&   VQ|6!$4 1' ""$  |VW. (' .rTTV_Tan_Tzmath.tantanc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes tan of x element-wise. Given an input tensor, this function computes tangent of every element in the tensor. Input range is `(-inf, inf)` and output range is `(-inf, inf)`. If input lies outside the boundary, `nan` is returned. ```python x = tf.constant([-float("inf"), -9, -0.5, 1, 1.2, 200, 10000, float("inf")]) tf.math.tan(x) ==> [nan 0.45231566 -0.5463025 1.5574077 2.572152 -1.7925274 0.32097113 nan] ``` Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. TanNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_tanrtan_eager_fallbackr/rjrrr rorrrr0r1r2r3r4r5r6r7s rAroro0rrz raw_ops.Tanc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sTanrErFrqrrRs rArsrs0rrT TV_Tanh_Tz math.tanhznn.tanhtanhc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aComputes hyperbolic tangent of `x` element-wise. Given an input tensor, this function computes hyperbolic tangent of every element in the tensor. Input range is `[-inf, inf]` and output range is `[-1,1]`. >>> x = tf.constant([-float("inf"), -5, -0.5, 1, 1.2, 2, 3, float("inf")]) >>> tf.math.tanh(x) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. TanhNr rr#r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_tanhrtanh_eager_fallbackr/rjrrr rvrrrr0r1r2r3r4r5r6r7s rArvrv0s.    0h..0$ #\\ 11 fdAg n,# D DGn$ n  )::!$ Aq#x QK' ""$3%%c* +F::L  fg/ (' .W  & &- ##At,,  # #    $ d*dg  & $D""  # #  z " "" "dQT* g  ..<< <  Z    D14( Gi,,::: n  rz raw_ops.Tanhc tj|g|tjtjtj tj tjtjg\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sTanhrErFrxrrRs rArzrz41rrT TV_TanhGrad_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aComputes the gradient for the tanh of `x` wrt its input. Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy` is the corresponding input gradient. Args: y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. dy: A `Tensor`. Must have the same type as `y`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `y`. TanhGradNr rr$)r%rr&r'rr(r)r*r+r,r-tanh_grad_eager_fallbackr/r0r1r2r3r4r5r6rs rA tanh_gradrC1rPrzraw_ops.TanhGradc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sTanhGradrErFr~rrs rArrp1rRrTTV_TruncateDiv_T truncatedivc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)a*Returns x / y element-wise, rounded towards zero. Truncation designates that negative numbers will round fractional quantities toward zero. I.e. -7 / 5 = -1. This matches C semantics but it is different than Python semantics. See `FloorDiv` for a division function that matches Python Semantics. *NOTE*: `truncatediv` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `uint32`, `uint64`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. TruncateDivNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_truncate_divrtruncate_div_eager_fallbackr/rjrrr truncate_divrrrr0r1r2r3r4r5r6rs rArr1s',    0h..0$ #\\ 11 mT1a)g n,+ At tGn$ n  )::ad,Aq#x QK' ""$3%%c* +F::L |VW6 (' .W  & &- ##At,,  # #    , a-g  & ( QTt%%  # #  z " "" "dQ!$7 g  ..<< <  Z    D15 Gi,,::: n  rzraw_ops.TruncateDivctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj g\}}|\}}||g}d|f}tj"dd||||}tj$rtj&d||||\}|S)Nr$s TruncateDivrErFrrrs rArr1s661vsWEUEUW^WcWceletetv}wFwFHOHUHUW^WcWcelesesu|uBuBDKDQDQSZSaSacjcqcqszs@s@BIBSBSU\UgUgEjk'9 &1aQ, >&   ^Q|#)s ?' ""$ |VW6 (' .rTTV_TruncateMod_T truncatemodc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)afReturns element-wise remainder of division. This emulates C semantics in that the result here is consistent with a truncating divide. E.g. `truncate(x / y) * y + truncate_mod(x, y) = x`. *NOTE*: `truncatemod` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `int32`, `int64`, `bfloat16`, `half`, `float32`, `float64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. TruncateModNr rrr$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_truncate_modrtruncate_mod_eager_fallbackr/rjrrr truncate_modrrrr0r1r2r3r4r5r6rs rArr1s'(    0h..0$ #\\ 11 mT1a)g n,+ At tGn$ n  )::ad,Aq#x QK' ""$3%%c* +F::L |VW6 (' .W  & &- ##At,,  # #    , a-g  & ( QTt%%  # #  z " "" "dQ!$7 g  ..<< <  Z    D15 Gi,,::: n  rzraw_ops.TruncateModc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$s TruncateModrErFr) r2rHrIrPrQrJrKrLrMrr3r6rs rArr*2s661vsW]]T[TaTacjcscsu|vBvBDKDSDSU\UdUdEgh'9 &1aQ, >&   ^Q|#)s ?' ""$ |VW6 (' .rTTV_UnsortedSegmentMax_TTV_UnsortedSegmentMax_Tindices"TV_UnsortedSegmentMax_Tnumsegmentszmath.unsorted_segment_maxunsorted_segment_maxc tjxstj}|j}|jr t j |d||||}|St||||fd}|tur|S t/j0d||||\}}} } | dd}t3j4rYd| j7dd| j7dd| j7df} | j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rY#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) aComputes the maximum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. This operator is similar to `tf.math.unsorted_segment_sum`, Instead of computing the sum over segments, it computes the maximum such that: \\(output_i = \max_{j...} data[j...]\\) where max is over tuples `j...` such that `segment_ids[j...] == i`. If the maximum is empty for a given segment ID `i`, it outputs the smallest possible value for the specific numeric type, `output[i] = numeric_limits::lowest()`. If the given segment ID `i` is negative, then the corresponding value is dropped, and will not be included in the result. Caution: On CPU, values in `segment_ids` are always validated to be less than `num_segments`, and an error is thrown for out-of-bound indices. On GPU, this does not throw an error for out-of-bound indices. On Gpu, out-of-bound indices result in safe but unspecified behavior, which may include ignoring out-of-bound indices or outputting a tensor with a 0 stored in the first dimension of its shape if `num_segments` is 0.
For example: >>> c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]]) >>> tf.math.unsorted_segment_max(c, tf.constant([0, 1, 0]), num_segments=2).numpy() array([[4, 3, 3, 4], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor whose shape is a prefix of `data.shape`. The values must be less than `num_segments`. Caution: The values are always validated to be in range on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. UnsortedSegmentMaxNr rr7r$r'r8)r%rr&r'rr(r)r*r+r,r-$_dispatcher_for_unsorted_segment_maxr#unsorted_segment_max_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r:s rArr<2sjp    0h..0$ #\\ 11 "D$ \Kg n03 {L$0$8Gn$ n  )::4[+7dDAq#x QK' ""$3%%c*J  ,n  02F::L lFG= (' .c  & &- ##At,,  # #    4 lD 2D:g  & 0  \$@@  # #  z " "" "d+8D04'6 g  ..<< <  & Z    Dd 6B%O Gi,,::: n  PD7G4E!D<<EEF3FG1AG1/G14AI  I zraw_ops.UnsortedSegmentMaxcbtj|g|tjtjtj tj tjtjtjtjtjtjtjtjg \}\}tj|g|tj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tjdd|| ||} tj rtj"d|| | | \} | S)Nr$r'r8sUnsortedSegmentMaxrErFrrr?s rArr244dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_ahananpwp@p@BIBPBPRYR^R^`g`n`npwp~p~CAB'7D#+#B#BK=RUX_XeXegngtgtWw#x ..;(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o| \2, *nn &   2Al#)s ?' ""$ lFG= (' .rTTV_UnsortedSegmentMin_TTV_UnsortedSegmentMin_Tindices"TV_UnsortedSegmentMin_Tnumsegmentszmath.unsorted_segment_minunsorted_segment_minc tjxstj}|j}|jr t j |d||||}|St||||fd}|tur|S t/j0d||||\}}} } | dd}t3j4rYd| j7dd| j7dd| j7df} | j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rY#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) a Computes the minimum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. This operator is similar to `tf.math.unsorted_segment_sum`, Instead of computing the sum over segments, it computes the minimum such that: \\(output_i = \min_{j...} data_[j...]\\) where min is over tuples `j...` such that `segment_ids[j...] == i`. If the minimum is empty for a given segment ID `i`, it outputs the largest possible value for the specific numeric type, `output[i] = numeric_limits::max()`. For example: >>> c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]]) >>> tf.math.unsorted_segment_min(c, tf.constant([0, 1, 0]), num_segments=2).numpy() array([[1, 2, 2, 1], [5, 6, 7, 8]], dtype=int32) If the given segment ID `i` is negative, then the corresponding value is dropped, and will not be included in the result. Caution: On CPU, values in `segment_ids` are always validated to be less than `num_segments`, and an error is thrown for out-of-bound indices. On GPU, this does not throw an error for out-of-bound indices. On Gpu, out-of-bound indices result in safe but unspecified behavior, which may include ignoring out-of-bound indices or outputting a tensor with a 0 stored in the first dimension of its shape if `num_segments` is 0. Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor whose shape is a prefix of `data.shape`. The values must be less than `num_segments`. Caution: The values are always validated to be in range on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. UnsortedSegmentMinNr rr7r$r'r8)r%rr&r'rr(r)r*r+r,r-$_dispatcher_for_unsorted_segment_minr#unsorted_segment_min_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r:s rArr2sjh    0h..0$ #\\ 11 "D$ \Kg n03 {L$0$8Gn$ n  )::4[+7dDAq#x QK' ""$3%%c*J  ,n  02F::L lFG= (' .c  & &- ##At,,  # #    4 lD 2D:g  & 0  \$@@  # #  z " "" "d+8D04'6 g  ..<< <  & Z    Dd 6B%O Gi,,::: n  rzraw_ops.UnsortedSegmentMincbtj|g|tjtjtj tj tjtjtjtjtjtjtjtjg \}\}tj|g|tj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tjdd|| ||} tj rtj"d|| | | \} | S)Nr$r'r8sUnsortedSegmentMinrErFrrr?s rArr83rrTTV_UnsortedSegmentProd_TTV_UnsortedSegmentProd_Tindices#TV_UnsortedSegmentProd_Tnumsegmentszmath.unsorted_segment_produnsorted_segment_prodc tjxstj}|j}|jr t j |d||||}|St||||fd}|tur|S t/j0d||||\}}} } | dd}t3j4rYd| j7dd| j7dd| j7df} | j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rY#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) a Computes the product along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. This operator is similar to `tf.math.unsorted_segment_sum`, Instead of computing the sum over segments, it computes the product of all entries belonging to a segment such that: \\(output_i = \prod_{j...} data[j...]\\) where the product is over tuples `j...` such that `segment_ids[j...] == i`. For example: >>> c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]]) >>> tf.math.unsorted_segment_prod(c, tf.constant([0, 1, 0]), num_segments=2).numpy() array([[4, 6, 6, 4], [5, 6, 7, 8]], dtype=int32) If there is no entry for a given segment ID `i`, it outputs 1. If the given segment ID `i` is negative, then the corresponding value is dropped, and will not be included in the result. Caution: On CPU, values in `segment_ids` are always validated to be less than `num_segments`, and an error is thrown for out-of-bound indices. On GPU, this does not throw an error for out-of-bound indices. On Gpu, out-of-bound indices result in safe but unspecified behavior, which may include ignoring out-of-bound indices or outputting a tensor with a 0 stored in the first dimension of its shape if `num_segments` is 0. Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor whose shape is a prefix of `data.shape`. The values must be less than `num_segments`. Caution: The values are always validated to be in range on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. UnsortedSegmentProdNr rr7r$r'r8)r%rr&r'rr(r)r*r+r,r-%_dispatcher_for_unsorted_segment_prodr$unsorted_segment_prod_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r:s rArrL3skd    0h..0$ #\\ 11 #T4lLg n24 {L$0$8Gn$ n  )::Dk,8tEAq#x QK' ""$3%%c*J  ,n  02F::L |VW> (' .g  & &- ##At,,  # #    5 lD 2D:g  & 1  \$@@  # #  z "  "" !2t8C9E15(7 g  ..<< <   ( Z    Tt7C/3&5 G i,,::: n  rzraw_ops.UnsortedSegmentProdc4tj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tj,dd|| ||} tj.rtj0d|| | | \} | S)Nr$r'r8sUnsortedSegmentProdrErFrrr?s rArr3st44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_aharart{tAtACJCPCPRYR`R`bibpbpryrBrBDKDRDRT[TcTcelesesu|uGuGIPIUIUW^WeWegnguguCxy'7D#+#B#BK=RUX_XeXegngtgtWw#x ..;(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o| \2, *nn &   3Q|#)s ?' ""$ |VW> (' .rTTV_UnsortedSegmentSum_TTV_UnsortedSegmentSum_Tindices"TV_UnsortedSegmentSum_Tnumsegmentszmath.unsorted_segment_sumunsorted_segment_sumc tjxstj}|j}|jr t j |d||||}|St||||fd}|tur|S t/j0d||||\}}} } | dd}t3j4rYd| j7dd| j7dd| j7df} | j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rY#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) aComputes the sum along segments of a tensor. Read [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation) for an explanation of segments. Computes a tensor such that \\(output[i] = \sum_{j...} data[j...]\\) where the sum is over tuples `j...` such that `segment_ids[j...] == i`. Unlike `SegmentSum`, `segment_ids` need not be sorted and need not cover all values in the full range of valid values. If the sum is empty for a given segment ID `i`, `output[i] = 0`. If the given segment ID `i` is negative, the value is dropped and will not be added to the sum of the segment. `num_segments` should equal the number of distinct segment IDs. Caution: On CPU, values in `segment_ids` are always validated to be less than `num_segments`, and an error is thrown for out-of-bound indices. On GPU, this does not throw an error for out-of-bound indices. On Gpu, out-of-bound indices result in safe but unspecified behavior, which may include ignoring out-of-bound indices or outputting a tensor with a 0 stored in the first dimension of its shape if `num_segments` is 0.
>>> c = [[1,2,3,4], [5,6,7,8], [4,3,2,1]] >>> tf.math.unsorted_segment_sum(c, [0, 1, 0], num_segments=2).numpy() array([[5, 5, 5, 5], [5, 6, 7, 8]], dtype=int32) Args: data: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. segment_ids: A `Tensor`. Must be one of the following types: `int16`, `int32`, `int64`. A tensor whose shape is a prefix of `data.shape`. The values must be less than `num_segments`. Caution: The values are always validated to be in range on CPU, never validated on GPU. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `data`. UnsortedSegmentSumNr rr7r$r'r8)r%rr&r'rr(r)r*r+r,r-$_dispatcher_for_unsorted_segment_sumr#unsorted_segment_sum_eager_fallbackr/rjrrr rrrrr0r1r2r3r4r5r6r:s rArr3sjj    0h..0$ #\\ 11 "D$ \Kg n03 {L$0$8Gn$ n  )::4[+7dDAq#x QK' ""$3%%c*J  ,n  02F::L lFG= (' .c  & &- ##At,,  # #    4 lD 2D:g  & 0  \$@@  # #  z " "" "d+8D04'6 g  ..<< <  & Z    Dd 6B%O Gi,,::: n  rzraw_ops.UnsortedSegmentSumcRtj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}tj|g|tjtj tjg\}\}tj|g|tj tjgtj \}\}|||g}d|d|d|f} tj,dd|| ||} tj.rtj0d|| | | \} | S)Nr$r'r8sUnsortedSegmentSumrErFrrr?s rArrE4s44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_aharart{tAtACJCPCPRYR`R`bibpbpryrBrBDKDRDRT[TcTcelesesu|uGuGIPIUIUW^WeWegnguguCxy'7D#+#B#BK=RUX_XeXegngtgtv}wDwDXG$H ..;(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o| \2, *nn &   2Al#)s ?' ""$ lFG= (' .rT TV_Xdivy_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aVReturns 0 if x == 0, and x / y otherwise, elementwise. Args: x: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. XdivyNr rr$)r%rr&r'rr(r)r*r+r,r-xdivy_eager_fallbackr/r0r1r2r3r4r5r6rs rAxdivyrW4s=    0h..0$ #\\ 11 gtQ#g n(881&!QX QK' ""$3%%c* +F::L vw0 (' .'  & &- ##At,,  # #    ! QTt%%  # #   rz raw_ops.Xdivyc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sXdivyrErFr r2rHrIrKrJrLrMrsrzrr3r6rs rArr4661vsW\\SZScSceletetv}wFwFHOHYHY[b[m[mEpq'9 &1aQ, >&   XqV!$4 1' ""$ vw0 (' .rT TV_Xlog1py_Tctjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r7d|j#df} |j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)a]Returns 0 if x == 0, and x * log1p(y) otherwise, elementwise. Args: x: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. Xlog1pyNr rr$)r%rr&r'rr(r)r*r+r,r-xlog1py_eager_fallbackr/r0r1r2r3r4r5r6rs rAxlog1pyr4s=    0h..0$ #\\ 11 iq!%g n(88Q!$(!QX QK' ""$3%%c* +F::L <2 (' .'  & &- ##At,,  # #    # QTt%%  # #   rzraw_ops.Xlog1pyc tj||g|tjtjtj tj tjtjg\}}|\}}||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sXlog1pyrErFrrrs rArr4s661vsW\\SZScSceletetv}wFwFHOHYHY[b[m[mEpq'9 &1aQ, >&   Zr?r@s rArr!5s'(    0h..0$ #\\ 11 fdAq"g n,# At tGn$ n  )::!qt%Aq#x QK' ""$3%%c* +F::L  fg/ (' .W  & &- ##At,,  # #    $ a-g  & QTt%%  # #  z " "" "dQ!$/ g  ..<< <  Z    D1- Gi,,::: n  rz raw_ops.Zetac*tj||g|tjtjg\}}|\}}||g}d|f}tj dd||||}tj rtjd||||\}|S)Nr$sZetarErFrrS) rrr!r"rSrr@r?r:s rArrm5s661vsW__V]VeVeDhi'9 &1aQ, >&   Wa F!$4 1' ""$  fg/ (' .rT)N)FN)rN)FFFFN)FFN)TN(8__doc__ collectionstensorflow.pythonrtensorflow.python.eagerrr%rr)rr2tensorflow.python.frameworkrrItensorflow.security.fuzzing.pyr_atypesr _op_def_registryr r+r r0"tensorflow.python.util.deprecationr tensorflow.python.utilr r tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsrrrB to_raw_oprr.rUrprbrfr}rrrradd_fallback_dispatch_listadd_type_based_api_dispatcherrr_tf_type_based_dispatcherDispatchrrrrrrrrrrrrrrrBoolrrrrrrrLrrrrrrrfloatrrrrrrrQrrrrrrrrrrrrrrr r r rrrrrrrrrrrrr!r"r$r%r&r(r3r.r1r7r;r9r:r=r>r?rErArDrIrJrOrPrQrTInt32r[rYrZr^rer`rcrgrqrxrurwr{rr}r~rrrrrrrsrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r r rrrrrrrrrr rrr$r(r&r'r*r+r-r.r/r1r5r3r4r9r:r<r=r>r@rIrFrGrHrKrLrNrOrPrRrSrUrVrWrYrZrPrcr`rbrerfrhrjrkrorsrqrrrurvrxryrzr|r}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r rrrrrrrrrr!rr r#r$r&r'r(r*rDr,r-r/r3r1r2r5r9r7r8r;r?r=r>rArGrDrErFrIrPrMrNrOrRrVrTrUrXrYr[r\r]r_rcrarbrerfrjrhri namedtuplerxrprqFloat32r{rlrzrrrrrvrrrrrrrrrurrrrrrrrrrrrInt64rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r r rrrrrrrrrrrrr r!r%r(r)r1r2r3r;r6r9rBrCrDrFrGrHrKrLrMrOrPrQrSrTrUrYrWrXr[r\r]r_r`rarcrdrerirgrhrkrlrmrorprqrsrtruryrwrxr{rr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rr r rrrrrrrrrrrr rrr"r#r$r(r&r'r+r,r-r1r/r0r8r4r5r6r:r3r9r<r=r>r?rCrArBrErIrGrHrKrOrMrNrSrTrVrWrXrZr[r]r^r_rarercrdrgrhrlrjrkrnrorqrrrsrurvrxryrzr|rr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrTrArs7 67179FK3IC86%%' :13DFWYgix{JL[]k l(Ic8m $(Ic8m4L(Ti ~t~~d34 9S(]3 9SRZ]C[ 13EG[]psDFWYgixzIKZ\jl|~NP_artDFVXhjz|KL79T#Y0B%BC7Zcdgi{d{Z|7r3 12>4>>.3QR )DI?Q4Q*RirsvyKtKjL& K!35IK^`qtEGU V )Ic9n %)YsI~5N)V!y !56 9S)^4 IcS\nD] \#57KM`bsvGIWX  %% (( <!DYsJ 'Dyj7QD")&DL # /">4>>%#8977@@ Ic:o6 iPSU_P_F`  :13GI\^orCESUdfuwFHVXhjy z,9S(] #, #x-(@,PYZ]_gZgPh,\i ~t~~c23 )CM2 yh7O _hilnviv_w  K!35IK^`qtEGUWfhwyHJXZjl|~MO`brtDFVXhjy{L M 0)DIy0103PY>AZ0d!y !6749i+?!@PYZ]_hZhPi$\#57KM`bsvGIWYhjy{JLZ\ln~@PRab (iZ((YsJ-G(W`adfpapWq(T # /">4>> : YsJ7 Ic:oN4O3[_3u~@CELEQEQ@QvR3ji ~t~~d34ygll):;9SR]M]C^ko@IJMOVO[O[J[@\"\#79L M ):4>>%#89  #z/ : - _hiln{i{_|  m_oF 3 #w||+,3Ic;>N4O3[_3u~@CELEQEQ@QvR3ji ~t~~d34ygll):;9SR]M]C^ko@IJMOVO[O[J[@\" 79KMacvyJL]_mo~@OQ`bprBDTVegxzJL\^np@BQR*3(=#=>*9SRgMgCh*ty*PYZ]_f_k_kZkPl*X9978HY9Z[ #7L2L(MR[\_av\vRwEJZcdgipiuiuduZv"m%7IZ\mo}@OQ`bqsACSUegvxIK[]moAQSbc )?O_] 7/[jl|}~E~K~KRV;9S+-.;9S.EX;Y;g|;[dehje[@;z %# $^T^^G%< =)C,<"=)TWYgTgJhxM]fgjlAgA]B"m%7IZ\mo}@OQ`bqsACSUegvxIK[]moAQSbc )?OL 7/Z~E~K~KRV;9S+-.;9S.EX;Y;g|;[dehje[@;z %# $^T^^G%< =)C,<"=)TWYgTgJhxM]fgjlAgA]B" K!35IK^`qtEGU V  %% (( ;LIc9n %LYsI~5NL )&L\!y !5655>> 9S)^4 IcS\nD] \#57KM`bsvGIWX  %% (( <!EYsJ 'Eyj7QE")&EN # /">4>>%#8977@@ Ic:o6 iPSU_P_F`  K!35IK^`qtEGU V  %% (( ;LIc9n %LYsI~5NL )&L\!y !5655>> 9S)^4 IcS\nD] \#57HJ[]k l  %% (( <!JYsJ 'JIc:o,FJV_`ceo`oVpJ")&JX # /">4>>%#8977@@ Ic:o6 9S*_;U enort~o~e \#57KM`bsvGIWX  %% (( <!GYsJ 'Gyj7QG")&GR # /">4>>%#8977@@ Ic:o6 iPSU_P_F` -/ACWYlnBSUcetvEFSYs$445S)CIYDY:ZSbfStxSHLS[_Su~BDTTuUSj/i-.~t~~m/LM Ic3C.C$DSVXhShIirv@DNR\`pyz}OzOpP613EG[]psDFWYgixzIKZ\ln~@PRabW #'9"9:WyN`I`?aWimW{WOSWbfW|EFIK]F]|^Wr3 12>4>>BR3ST y6H1H'IiX[]oXoNpy}GKUYcgw@ADFXAXwY635GI]_ruFHY[ikz|KM\^ln}~35GI]_ruFHY[ikz|KM\^ln}~ 79KMacvyJL]_mo~@OQ`a[ #':":;[ #ObJb@c[lA[IM[[_[nr[AE[[dehje[@[z3 12>4>>BR3ST y6I1I'JyY\^qYqOr{PY]fjtxBFV_`cez`zV{8~'8:KL  %% (( >~y9:i Lyl*+L #|:K0LLQZ[^`l[lQmL~GHKMYHY~ZL!;)&L\ ')% &~t~~g'> ?!;;DD i\(9: ylIZ?[ `ijmo{j{`| MVWZ\hWhMi ): iPSU\UbUbPbFc nwx{~KyKoL \efikxfx\y )+<>OQ`bqr8YsN238yY\^e^k^kYkOl8t +I) *>4>>)+D E Ic>.A$B^ghkmtmzmzhz^{$| | ,Ic<' (, ,t,ajknp|k|a},\!y !569S,%67|W[ktux{GvGlH" K!35FHY[i j $Ic9n %$YsI~5N$L!y !56 9S)^4 IcS\nD] -/ACWYlnBSUcetvEGVXfhxzJL[]np@BRTdfvxGH1i%5 561 RUWgRgHh1{DEHJZEZ{[1ktuxzJuJkK1f/i-.~t~~n/MN  Ys4D/D%E W`adfvavWw JSTWYiTiJj zCDGIYDYzZ ~'8:KL +-ACVWjqj{j{CG99S,./9ylAR7S9Zi9LUVY[jVjLk9v ')% &~t~~h'? @)C,=">iPSUaPaFbjyJSTWYhThJi"+-ACVW13DFWXLSOObf49S/1249K4ktux{MvMlN4l-Y+ ,^T^^K-H I  )C,@"A I[ ktux{MvMlN  K!57JL] ^ 2 #y.)23 >9R2h!y !56 yi8  RUW`R`Ha  :13GI\^orCES T %% (( :uF9S(] #F9S(]3KF)&FPi ~t~~c2333<< )CM2 )CQYMBZ  K!35IK^`qtEGU V  %% (( ;EIc9n %EYsI~5NE )&EN!y !5655>> 9S)^4 IcS\nD] \#57HJ[]km|NP_aoqACSUegvw  %% (( >~w78gCYsJ 'CIc:o,FCV_`ceo`oVpC9)&CJ # /">4>>%#8977@@ Ic:o6 9S*_;U enort~o~e ~'9;OQdfwzKM[]ln}NP^`prBDSUfhxzJL\^np@ +_oNUyl*+U9S/=Q3RU^bUrvUMVWZ\hWhMiUn ')% &~t~~g'> ?i\(9:)CQ`L`Banr~BR[\_am\mRn*m%79MObduxIKY[jl{}LN\^np@BQSdfvxHJZ\ln}~ )?OLUi[()U3;N1OU[_UosUJSTWYdTdJeUn %# $^T^^F%; <YsK'78 #~J]@^koz~OXY\^iYiOj*##=?QSdfwzHI%&C_VefIIc+C&CDIIVY[vVvLwIDHIX\Ir{|AY|YrZIV?i =>~t~~Nb?cd9S:R5R+S[dehkFfF\GTXcgw@ADF^A^w_* 7/Z13DFWYhjyz=)C)>$>?=yQTVkQkGl=xABEGYBYxZ=jn=DMNQSeNeDf=~3 12>4>>.3QR 38M3M)NV_`cez`zV{GPQTVhQhGiz~NWX[]oXoNp$~'9;LN_aop  %% (( >~y9:i >yl*+>9S,EV;W>!;)&>@ ')% &~t~~g'> ?!;;DD i\(9: )TWYeTeJf  :13GI\^orCESUdfuwFHVXhjz|LN] ^(9S(] #( #x-(@(PYZ]_gZgPh(Ti ~t~~c23 )CM2 yh7O _hilnviv_w );=QSfhy|MO]^ ))C./)Ic=>P4Q)ajknp}k}a~)V )9' ( )C D 3 +=!> 9SR_M_C` pyz}@M{MqN x :YsJ ':Ic:o,F:ae:{DEHJQJVJVEV{W:x # /">4>>%#89Ic:o69S*_;UquFOPSU\UaUaPaFb$ :13DFWYg h %% (( ::u-.eC9S(] #C9S(]3KC/)&CJi ~t~~c2333<< )CM2 )CQYMBZ  K!35FHY[i j  %% (( ;K01f<Ic9n %<YsI~5N<2)&<|!y !5655>> 9S)^4 IcS\nD] m%79JL]_mn $i[()$3 CS9T$L %# $^T^^F%; < YsK'78  RUWbRbHc 13EG[]psDFWYgixzIKZ\jl|~NP_artDFVXhjz|KL 7/Z4)C);$;<4IcShNhDi4uy4PYZ]_qZqPr4l3 12>4>>.3QR 38J3J)KS\]`bw]wSxFJZcdgi{d{Z|" :13GI\^orCES T?9S(] #?9S(]3K?Bi ~t~~c23 )CM2 )CQYMBZ \#57KM`bsvGIWX  %% (( <\734gJYsJ 'Jyj7QJ5)&JX # /">4>>%#8977@@ Ic:o6 iPSU_P_F` \#57HJ[]k l $YsJ '$yj7Q$L # /">4>>%#89 Ic:o6 iPSU_P_F` );=QSfhy|MO]_npAPR`brtDFVXgh  %% (( {mk"@3 -.@9S-=O3P@`ijmo|j|`}@#)&@D )9' ( )B C%??HH  #}*< = )CQ^L^B_ oxy|LzLpM );=NPacqtCETVeguwGIY[km|}  %% (( ?J+[\j%(D3 -.D9S-=O3PD`ijmo|j|`}D)])&DL )9' ( )B C%??HH  #}*< = )CQ^L^B_ oxy|LzLpM ~'9;LN_aorACRTcesuEGWYikz{  %% (( >9%Lyl*+L #|:K0LL\efikrkwkwfw\xL&)&L\ ')% &~t~~g'> ?!;;DD i\(9: ylIZ?[ ktux{B{G{GvGlH /1CEVXiky|KM\^mo}OQacsuDE %% (( 1LYs$556L9SJ[E[;\Lluvy|C|H|HwHmIL2)&L\1y/0 1NO - G G P P Ic3D.D$E )TWYjTjJk |EFIKRKWKWFW|X ##=?PRcetwFG&'EXghNUN[N[bfB9S2J-J#KBZcdgjBeB[CBLUVY[b[h[hVhLiBqMBktuxzVuVkWBH?i =>~t~~Nd?ef)CAY~y9:i Jyl*+J #|:K0LJ\efikwfw\xJ!;)&JX ')% &~t~~g'> ?!;;DD i\(9: ylIZ?[ ktux{GvGlH  K!57J K ~'8:KL =D__SW5 #y.)5 5\efikwfw\x5n!y !56 yi8  \efikwfw\x  :13GI\^orCESUdfuwFHV W&9S(] #&9S(]3K&Pi ~t~~c23 )CM2 )CQYMBZ ~'9;OQdfwzKM[\ ( #|+,()CZG:X)&GR )9' ( )B C%??HH  #}*< = YWZ\c\h\hWhMi \#57HJ[]k l  %% (( =JK((3GiZ(G #w||BS8TG4L)&GR # /">4>> :99BB YsJ7 yQTV]VbVbQbGc \#57HJ[]k l  %% (( =JK((3GiZ(G #w||BS8TG4L)&GR # /">4>> :99BB YsJ7 yQTV]VbVbQbGc  K!35FHY[ikz}LN]_moAQScet u  %% (( ;LIc9n %L)CN*CLS\]`bibnbn]nSoL )&L\!y !5655>> 9S)^4 3 >9R bkloqxq}q}l}b~ )+=?PRcesvEGVXgiwyIK[]mo~ %% (( l+L)C/0LYsN?R5SLclmpryr~r~m~cL,)&L\ +I) *>4>>*+E F 'AAJJ 3+>!? IcSaNaDb r{|BIBNBN}NsO m%79JL]_mn  %% (( =mX67hFi[()F3 CS9TF 8)&FP %# $^T^^F%; <99BB YsK'78  RUWbRbHc );=NPacqr -P4YsM124)CDV:W4^ghkm}h}^~4OXY\^kYkOl4l )9' ( )B C Ic=.@$A SVXeSeIf mvwz}MxMnN ^ghkmzhz^{  :13GI\^orCES T %% (( ::u-.eE9S(] #E9S(]3KE/)&ENi ~t~~c2333<< )CM2 )CQYMBZ \#57KM`bsvGIWX  %% (( <\734gCYsJ 'Cyj7QC5)&CJ # /">4>>%#8977@@ Ic:o6 iPSU_P_F`  %% (( }-t9S',,./tIc7<<>O4Pt`ijmovo{o{j{`|t.)&tl-Y+ ,^T^^K-H I )CCLL )C,="> 9SRYR^R^M^C_ oxy|FKKzKpL  %% (( }-A9S',,./AygllIZ?[A.)&AF-Y+ ,^T^^K-H I )CCLL )C,="> iX[]d]i]iXiNj  %% (( l+t)C-.t9S',,=N3Ot_hilnunznziz_{t,)&tl +I) *>4>>*+E F 'AAJJ 3 +Yhl{JNX\luvy{FvFlG6 :13DFWYgix{JL[]km}OQ`bsuEGWYik{}L Mm_oF 4 #x-(4 #{:J0K4W[4qz{~AI|IrJ4li ~t~~d34yh7ykIY?Zgk|EFIKSFS|T"~'9;LN_aorACRTcesuEGWYikz{  %% (( >9%Myl*+M #|:K0LM\efikwfw\xM&)&M^ ')% &~t~~g'> ?!;;DD i\(9: ylIZ?[ ktux{GvGlH  K!35IK^`qtEGUWfhwyHJXZjl|~MO`brtDFVXhjy z ~H 4 #y.)43 ;L1M4Y]4s|~ACL~LtM4l!y !56yi8 #|J[@\im~GHKMVHV~W" :13DFWYgix{JL[]km}OQ`bsuEGWYik{}L Mm_oF 4 #x-(4 #{:J0K4W[4qz{~AI|IrJ4li ~t~~d34yh7ykIY?Zgk|EFIKSFS|T"~'9;LN_aorACRTcesuEGWYikz{  %% (( >9%Pyl*+P #|:K0LP\efikwfw\xP&)&Pd ')% &~t~~g'> ?!;;DD i\(9: ylIZ?[ ktux{GvGlH  :13DFWYgiwzIKZ [+9S(] #+ #x-(@+PYZ]_gZgPh+Zi ~t~~c23 )CM2 yh7O _hilnviv_w  :13GI\^orCESUdfuwFHVXhjz|LN] ^(9S(] #( #x-(@(PYZ]_gZgPh(Ti ~t~~c23 )CM2 yh7O _hilnviv_w );=QSfhy|MO]^ ()C./(Ic=>P4Q(ajknp}k}a~(T )9' ( )C D 3 +=!> 9SR_M_C` pyz}@M{MqN \#57HJ[]k l $YsJ '$yj7Q$L # /">4>>%#89 Ic:o6 iPSU_P_F`  :13GI\^orCESUdfuwFHV W %% (( ?J'>9S(] #>9S(]3K>()&>@i ~t~~c2333<< )CM2 )CQYMBZ )+<>OP %% (( E9S.01EynAT7UEenoruCpCfDE)&EN +I) *>4>>*+E F 'AAJJ )C,?"@ iPSUcPcFd t}BDRRuS ~ 13 -.19S-=O3P1ko1ENORT[T`T`O`Ea1f )9' ( )B C #}*< =)CQ^L^B_{PYZ]_f_k_kZkPl$)+<>OP %% (( !1; ?@k"E3./EIc>>Q4REbkloqlcAE#A)&EN +I) *>4>>)+D E %??HH  #~*= > 9SR`M`Ca qz{~AO|OrP  :13GI\^orCESUdfuwFHV W.Ic8m $.3=)A.QZ[^`h[hQi.`i ~t~~d34 9S(]3  #x-8P `ijmowjw`x  K!35IK^`qtEGUWfhwyHJXZjl|~MO`brtDFVXhjy z ~H 4 #y.)43 ;L1M4Y]4s|~ACL~LtM4l!y !56yi8 #|J[@\im~GHKMVHV~W %;K$:$: *%,! (//UWgiy|KM^`p(q$)01Y[km}@OQbdt*u&K)C9]4]*^Kktux{B{J{JvJlKKXabegngvgvbvXwKCiKZMY'KL^T^^\zM{|3HlCl9m{DEHJQJYJYEY{Zgpqtv}vEvEqEgFRx -k,, 13CEUWfhy|LM13CEUWfhy|LM!";=MO_apsDFVWahaoaovz:Ys$667:IcK]F]<^:gpqtv}wFwFrFhG:PYZ]_f_n_nZnPo:xABEGNGVGVBVxW:`ijmovo~o~j~`:I`:x1y/0 1NO Ic3E.E$F9UXZlUlKmvADFMFUFUAUwV_hilnun}n}i}_~GPQTV]VeVeQeGfoxy|~E~M~MyMoNYp(0//!#  79IK[]lnBRS 79IK[]lnBRS$%ACSUegvyJL\]!()IK[]mo~ARTd"enun|n|OTglY`YgYgnrX3(=#=>X9SRgMgChXqz{~AHAPAP|PrQXZcdgipixixdxZyXBKLOQXQ`Q`L`BaXjstwy@yHyHtHjIXSmXJNXbfXzXXt7)56~t~~FW7XY #7L2L(MR[\_av\vRwAJKNPWP_P_K_A`irsvxxGxGsGiHQZ[^`g`o`o[oQpyBCFHOHWHWCWyXc}LP_crP<-k,, 13CEUWfhy|LM13CEUWfhy|LM!";=MO_apsDFVWahaoaovz:Ys$667:IcK]F]<^:gpqtv}wFwFrFhG:PYZ]_f_n_nZnPo:xABEGNGVGVBVxW:`ijmovo~o~j~`:I`:x1y/0 1NO Ic3E.E$F9UXZlUlKmvADFMFUFUAUwV_hilnun}n}i}_~GPQTV]VeVeQeGfoxy|~E~M~MyMoNYp*!!9?O\35FHY[jl{|?Ic7==&89?9SRhMhCi?qz{~AW|WrX?clmprEmEcF?VZ?pyz}RzRpS?B534^T^^O5TU9S'--5G+HR[\_aw\wRxAJKNPfKfAgr{|AT|TrUfjzCDGI\D\z]&);=NPacqtCETVeguwGIYZ 5)C./5 #}BT8U5^ghkmzhz^{5LUVY[hVhLi5n # /">4>> : 3 +=!> yQTVcQcGd mvwz}JxJnK [dehjwew[x  K!57J K ~'8:KL =D__SW5 #y.)5 5\efikwfw\x5n!y !56 yi8  \efikwfw\x  ~'9;OQdfwzKM[]ln}NP^`prBDTVef  %% (( 9B #|+,B3 ;L1MB]fgjlxgx]yB)&BH ')% &~t~~h'? @#==FF yl):;  #|J[@\ luvy|HwHmI +-?AUWjl}@QSacrtCETVde %% (( "3\!BCl#>)C01>3P_K_A`>$D)&>@-Y+ ,^T^^J-G H 'AAJJ 3+?!@ PYZ]_nZnPo 35GI]_ruFHY[ij(y&9!9:( #ObJb@c(s|~ACV~VtW(T534^T^^O5TU i5H0H&I yY\^qYqOr CLMPReMeCf 4[33< " !((GIY[km|PRb!c2 #/L*L M2ZcdgipixixdxZy2GPQTV]VeVeQeGf2h?i =>~t~~Nb?cd y>[9[/\ irsvxyHyHtHjI V_`celetet`tVu (>{'='=#< ("$ &--QSceuxGIZ\l&m"7Ic;]6],^7ktux{B{J{JvJlK7XabegngvgvbvXw7IN7r!S *Q RSaSWSaSacCTD!E9SJlEl;m{DEHJQJYJYEY{Zgpqtv}vEvEqEgFX] +K***, 57GIY[jl}@PQ !9;KM]_nqBDTUBi%9 9:ByQTV]VeVeQeGfBs|~ACJCRCR~RtSBktuxzAzIzIuIkJBbkloqxq@q@l@bABMcBH-Y+ ,^T^^J-G H Ys4H/H%IV_`celetet`tVuCLMPRYRaRaMaCbzCDGIPIXIXDXzYqz{~@G@O@O{OqP\r"5k44*, $$?AQScetwHJZ[#*+MO_aqtCEVXh$i ~E~L~LSW>)C1J,J"K>XabegngvgvbvXw>ENORT[TcTcOcEd>|EFIKRKZKZFZ|[>s|}@BIBQBQ}QsR>]}>@Ay!?@PfAgh3@Y;Y1Zgpqtv}wFwFrFhGT]^acjcrcr^rTsKTUXZaZiZiUiKjBKLOQXQ`Q`L`BamM( K!35FHY[i j  %% (( ;K01fFIc9n %FYsI~5NF2)&FP!y !5655>> 9S)^4 IcS\nD] \#57KM`bsvGIWYhjy{JLZ[ 'YsJ ''yj7Q'R # /">4>>%#89 Ic:o6 iPSU_P_F` \#57KM`bsvGIWX &YsJ '&yj7Q&P # /">4>>%#89 Ic:o6 iPSU_P_F` )+=?SUhj{~OQ_`()C/0(i^@S6T(dmnqtBoBeC(T +I) *>4>>*+E F  3+>!? YsTbObEc s|~ACQ~QtR +-?ARTeguxGIXZiky{KM]_oq@A !9?O\ %% (( #5}"EFm$_i_ 45_IcSiNiDj_{DEHJYEY{Z_%G)&_B-Y+ ,^T^^K-H I )CCLL YsO/C%D S\]`bx]xSy JSTWYhThJi /1CEVXiky|KM\^mo}OQacsuDE"#=P_`&'EXghW3(9#9:WSVXpSpIqWBKLOQmLmBnW~GHKM^H^~_Wr1y/01OP   #7H2H(I XabegbYA QZ[^`|[|Q} MVWZ\mWmMn  -/ACWYlnBSUcetvEGVXfhxzJL[]np@BRTdfvxGH!";_o^ %% (( $7#HIn%by&6!67biPSUlPlFmb~GHKM]H]~^b&J)&bH/i-.~t~~l/KL +EENN i5E0E&F U^_bd{_{U| MVWZ\lWlMm +-?ARTeguxGIXZiky{KM]_oq@A !9?O\ %% (( #5}"EFm$_i_ 45_IcSiNiDj_{DEHJYEY{Z_%G)&_B-Y+ ,^T^^K-H I )CCLL YsO/C%D S\]`bx]xSy JSTWYhThJi /1CEVXiky|KM\^mo}OQacsuDE"#=P_`&'EXghW3(9#9:WSVXpSpIqWBKLOQmLmBnW~GHKM^H^~_Wr1y/01OP   #7H2H(I XabegbYA QZ[^`|[|Q} MVWZ\mWmMn  -/ACWYlnBSUcetvEGVXfhxzJL[]np@BRTdfvxGH!";_o^ %% (( $7#HIn%`y&6!67`iPSUlPlFm`~GHKM]H]~^`&J)&`D/i-.~t~~l/KL +EENN i5E0E&F U^_bd{_{U| MVWZ\lWlMm 13EG[]psDFWYgixzIKZ\jl|~NP_artDFVXhjz|KL#$?Rab '(GZi jN)C);$;<N9UXZsUsKtNENORTqOqErNBKLOQcLcBdN`3 12>4>>/3RS  38J3J)K ZcdgjCeC[D T]^ac@^@TA QZ[^`r[rQs  +-?AUWjl}@QSacrtCETVdfvxHJY[ln~@PRbdtvEF !9?O\ %% (( #5}"EFm$_i_ 45_IcSiNiDj_{DEHJYEY{Z_%G)&_B-Y+ ,^T^^K-H I )CCLL YsO/C%D S\]`bx]xSy JSTWYhThJi /1CEY[nqBDUWegvxGIXZhjz|LN]_prBDTVfhxzIJ"#=P_`&'EXgh<3(9#9:<SVXpSpIq<BKLOQmLmBn<~GHKM^H^~_<|1y/01OP   #7H2H(I XabegbYA QZ[^`|[|Q} MVWZ\mWmMn  z OiW\\ 12OykAQ7ROW`adfqaqWrOCLMPR]M]C^Ob %# $^T^^F%; < YsGLL/@%A iPSU`P`Fa fopsvAqAgB R[\_al\lRm ~ &3 #45&)CDV:W&\efikxfx\y&JSTWYfTfJg&P )9' ( )B C  #w||2C(D SVXeSeIf ktux{HvHlI YbcfhucuYv ~'9;OQdfwzKM[\ &yl*+&9S,EV;W&P ')% &~t~~g'> ? i\(9: )TWYeTeJf -/ACWYlnBSUcd(Ic#334()CIYDY:Z(jstwzJuJkK(T/i-.~t~~l/KL  9S2B-B#C SVXhShIi zCDGIYDYzZ  K!35IK^`qtEGUWfhwyHJX Y ,Ic9n %,YsI~5N,\!y !56 9S)^4 IcS\nD]  :13GI\^orCES T %% (( :uE9S(] #E9S(]3KE)&ENi ~t~~c2333<< )CM2 )CQYMBZ  K!35IK^`qtEGU V  %% (( ;EIc9n %EYsI~5NE )&EN!y !5655>> 9S)^4 IcS\nD] 57HJ[\bibqbqx|4iW]] 234)CQXQ^Q^L^B_4gpqtv}wDwDrDhE4Ma4AJKNPdKdAe4l/i-.~t~~l/KL YsGMM/A%BQZ[^`g`m`m[mQnvADFMFSFSASwT]qAJKNPdKdAe$!!9?O\35FHY[jl{|@YsGMM'9:@IcSiNiDj@zCDGIPIVIVDVzW@_hilnDiD_E@PYZ]_rZrPs@CG@]fgjlg]@@D534^T^^O5TUIc7==6H,IS\]`bx]xSyIRSVX_XeXeSeIfnwx{}SxSnT_hilnAiA_BSWgpqtvIqIgJ(13EGXY13EGXYIi%7 78IYsL^G^=_ImqIFJI^bIvzIPYZ]_f_n_nZnPoIV1y/01OP Ys4F/F%GIVY[mVmLn~BQUdhw{KTUXZaZiZiUiKj8!!9;MO`bsvDE#$?Rab#*+M`o#p 8i-C(CD8yY\^wYwOx8HQRUWwRwHx8JN8dmnqsInIdJ8t;I9:>4>>J];^_Ys4>>RjCkl)CA[<[2\gpqtwTrThUdmnqsWnWdXgpqtv}vCvCqCgDT]^ac}^}T~ "8!7!7 &'") ''EGY[lnBP Q")*K_^m"n)01Y[jl{)|&9i5Q0Q&R9]fgjmLhL^M9\efikQfQ\R9gpqtv}vCvCqCgD9vG)$EF~t~~VqGrsYsD`?`5aluvy|[w[m\ktuxz`u`kav@CELERER@RvS$)00WYkm~ARTb)c%+23]_np,A(3:;mo~AP4Q029:km|N3O/? #?d:d0e?pyz}@h{hqi?xABEGvBvxw?GPQTVFQFGG?Y]?s|}@Bg}gsh?B$Y9-W#XYgY]YgYgiNZO$P yNsIs?t@IJMOwJw@xGPQTVEQEGFV_`ceU`UVVim}FGJLqGq}r,"";=OQbduxFG$%A?Tcd$+,OQ`bq$r!7 #/F*F G7R[\_a{\{R|7LUVY[|V|L}7OS7irsvxOsOiP7r=Y;<^T^^La=bcy>U9U/VajknqKlKbL[dehjKeK[L_cs|}@BY}YsZ&&&CEWYjl}@NO!()I?\k!l(/0WYhjy(z%3Ys4O/O%P3[dehkIfI\J3YbcfhMcMYN3]fgjlslylygy]z3JSTWYtTtJu3jE#CD^T^^TnEopIcC^>^4_jstwzXuXkYhqruw\r\h]luvy{B{H{HvHlIYbcfhCcCYD"#9+"8"8 &'#) !((GI[]nqBDR!S#*+M`o#p *12[]ln}*~'9 #7T2T(U9`ijmpPkPaQ9`ijmoVjV`W9luvy{B{H{HvHlI9vI9%GHXuIvwyFcAc7doxy|_z_p`oxy|~eyeof{DEHJQJWJWEW{X$*11Y[mpACTVd*e&,34_apsB-C)4;^4_jstwzXuXkYhqruw\r\h]r{|AHANAN|NrO$(//UWik|PR`bqsBDSUceuwGIY[j(k$*12[]ln}*~'29:km|N3O/189ikz}L2M.Ty>b9b/cTnwx{~eyeofTu~BDrrusTCLMPRAMACBTTXTnwx{}axanbTl#W),U"VWeW[WeWegKXL#MiMqHq>r~GHKMtHt~uDMNQSANADBR[\_aP\PRQdhxABEGkBkxl, K!35IK^`qtEGU V &Ic9n %&YsI~5N&P!y !56 9S)^4 IcS\nD] );=QSfhy|MO]^ (3 -.(Ic=>P4Q(ajknp}k}a~(T )9' ( )B C  #}*< = 9SR_M_C` pyz}@M{MqN m%79MObduxIKY[jl{}LN\^np@BRTcd  %% (( =(#Ai[()A3 CS9TA$)&AF %# $^T^^F%; <99BB YsK'78  RUWbRbHc !!9;MOcex{LN_aoq@BQR %% (( $*CEY)Z[*+@)C)?$?@@YsTjOjEk@|EFIKaFa|b@,\)&@D;I9:>4>>J\;]^%7%Q%Q%Z%Z" 38N3N)O T]^acy^yTz KTUXZpUpKq  :13GI\^orCESUdfuwFHVXhjz|LN] ^q9S(] #q #x-(@qPYZ]_gZgPhqfi ~t~~c23 )CM2 yh7O _hilnviv_w  :13GI\^orCESUdfuwFHVXhjz|KM^`prBDTVfhw xm_oF 4 #x-(4 #{:J0K4W[4qz{~AI|IrJ4li ~t~~d34yh7ykIY?Zgk|EFIKSFS|T" :13GI\^orCES T %% (( :uF9S(] #F9S(]3KF)&FPi ~t~~c2333<< )CM2 )CQYMBZ  K!35IK^`qtEGU V  %% (( ; 6*FIc9n %FYsI~5NF+)&FP!y !5655>> 9S)^4 IcS\nD] );=QSfhy|MO]^ (3 -.(Ic=>P4Q(ajknp}k}a~(T )9' ( )B C  #}*< = 9SR_M_C` pyz}@M{MqN -/ACWYlnBSUcetvEGVXfhxzJL\^mn %% (( =EIc#334E3HXCX9YEirsvyItIjJE)&EN/i-.~t~~l/KL +EENN 9S2B-B#C  RUWgRgHh yBCFHXCXyY -/ACTVgiwzIKZ[ %% (( =CIc#334C3HXCX9YCirsvyItIjJC)&CJ/i-.~t~~l/KL +EENN 9S2B-B#C  RUWgRgHh yBCFHXCXyY "";=OQbduxFHWYhjy{IK[]moAPQ!()I?\k!l%,-QSbds%t" %% (( &,GI_+`a,-ly.E)EFlU^_beC`CVDlT]^acE^ETFlV_`ce|`|V}l.b)&l\=Y;<^T^^L`=ab';'U'U'^'^$ i=T8T.U dmnqtRoReS clmprTmTcU enortKoKeL  "";=OQbduxFHWYhjy{IK[]moAPQ!()I?\k!l%,-QSbds%t" %% (( &,GI_+`a,-hy.E)EFhU^_beC`CVDhT]^acE^ETFhV_`ce|`|V}h.b)&hT=Y;<^T^^L`=ab';'U'U'^'^$ i=T8T.U dmnqtRoReS clmprTmTcU enortKoKeL  ##=?QSgi|PRcesuDFUWfhvxHJZ\km~@PRbdtvFHWX")*K_^m"n&-.SUdfu&v# %% (( '-IKb,cd-.h #/G*G HhW`adgFbFXGhW`adfIaIWJhZcdgiAdAZBh/e)&hT?i =>~t~~Nc?de(=(W(W(`(`% y>V9V/W fopsvUqUgV fopsuXpXfY irsvxPsPiQ  "";=OQegz}NPacqsBDSUdftvFHXZik|~NP`brtDFUV!()I?\km|!}%,-QSbds%t" %% (( &,GI_+`a,-iy.E)EFiU^_beC`CVDiT]^acE^ETFiV_`ce|`|V}i.b)&iV=Y;<^T^^L`=ab';'U'U'^'^$ i=T8T.U dmnqtRoReS clmprTmTcU enortKoKeL  \#57KM`bsvGIWX %YsJ '%Ic:o,F%V_`ceo`oVp%N # /">4>>%#89 Ic:o6 9S*_;U enort~o~e ~'9;OQdfwzKM[\ %yl*+% #|:K0L%\efikwfw\x%N ')% &~t~~g'> ? i\(9: ylIZ?[ ktux{GvGlH \#57KM`bsvGIWX  %% (( <=YsJ '=Ic:o,F=V_`ceo`oVp=)&=~ # /">4>>%#8977@@ Ic:o6 9S*_;U enort~o~e  K!24E F  %% (( ;K01fBIc9n %B)CN*CBS\]`bk]kSlB2)&BH!y !5655>> 9S)^4 3 >9R bkloqzlzb{ rT