Saravanan666/pypi-org huggingface dataset:
Package: tensorflow-object-detection
tensorflow_object_detectionThis is a thin wrapper aroundTensorflow Object Detection APIfor easy installation and use. The originalinstallation procedurecontains multiple manual steps that make dependency management difficult. This repository creates a pip package that automate the installation so that you can install the API with a single pip install.Installationpip install tensorflow-object-detection[tf]Or for tensorflow with GPU support,pip install tensorflow-object-detection[tf-gpu]UsageAll the scripts from tensorflow object detection APIs work out-of-box.
You can find an example usages from the API'smodel_main.py.import object_detectionWhat's in heresetup.py: The python packaging script.PROTOCEnvironment variable should be set so thatsetup.pycan compile as
part of thesetup.pyexecution.# Download and setup all required dependencies required for tensorflow object# detection libarary to work correctly.$pythonsetup.pyinstalltf_object_detection: A git submodule pointing to the version of tensorflow object detection this thin wrapper is for.
Package: tensorflow-protobuf
TensorFlow ProtobufImagine you want to talk to your model deployed with TF-Serving using gPRC and protobuf.To convert your NumPy array, you'd need to usemake_tensor_protofunction:importtensorflowastfdefnp_to_protobuf(data):returntf.make_tensor_proto(data,shape=data.shape)Boom - you have a 2 GB dependency to deal with!TensorFlow ProtobufThis project takes only the part you actually need for that: the protobuf files (compiled).Installing itpipinstalltensorflow-protobuf==2.7.0Available versions:2.3.02.7.0Using itWith it, your code will look like that:fromtensorflow.core.frameworkimporttensor_pb2,tensor_shape_pb2,types_pb2defdtypes_as_dtype(dtype):ifdtype=="float32":returntypes_pb2.DT_FLOATraiseException("dtype%sis not supported"%dtype)defmake_tensor_proto(data):shape=data.shapedims=[tensor_shape_pb2.TensorShapeProto.Dim(size=i)foriinshape]proto_shape=tensor_shape_pb2.TensorShapeProto(dim=dims)proto_dtype=dtypes_as_dtype(data.dtype)tensor_proto=tensor_pb2.TensorProto(dtype=proto_dtype,tensor_shape=proto_shape)tensor_proto.tensor_content=data.tostring()returntensor_protodefnp_to_protobuf(data):ifdata.dtype!="float32":data=data.astype("float32")returnmake_tensor_proto(data)A bit more verbose, but without the 2GB baggage.See a full example here:example.pyHave fun!Building and compiling itTo see how we extract and compile the protobuf files, checktf-serving-proto.sh.To use it:TF_VERSION="2.3.0"./tf-serving-proto.shPublishing on PyPIIf you want to build it for other versions and publish it,
do this:exportTF_VERSION=2.7.0echo"__version__ = '${TF_VERSION}'">version.py

python-mvenvenvsourceenv/bin/activate

./tf-serving-proto.sh

pipinstallwheeltwine

pythonsetup.pysdistbdist_wheel

twinecheckdist/*
twineupload--repository-urlhttps://test.pypi.org/legacy/dist/*

twineuploaddist/*

rm-rftensorflow/tensorflow_serving/
rm-rftensorflow_protobuf.egg-info/build/dist/__pycache__/
rmversion.pyLICENSE
Package: tensorflow-qndex
# tensorflow-qndex[![PyPI version](https://badge.fury.io/py/tensorflow-qndex.svg)](https://badge.fury.io/py/tensorflow-qndex)
[![Python versions](https://img.shields.io/pypi/pyversions/tensorflow-qndex.svg)](setup.py)
[![Build Status](https://travis-ci.org/raviqqe/tensorflow-qndex.svg?branch=master)](https://travis-ci.org/raviqqe/tensorflow-qndex)
[![License](https://img.shields.io/badge/license-unlicense-lightgray.svg)](https://unlicense.org)[tensorflow-qnd](https://github.com/raviqqe/tensorflow-qnd)
x
[tensorflow-extenteten](https://github.com/raviqqe/tensorflow-extenteten)## License[The Unlicense](https://unlicense.org)
Package: tensorflow-radam
Keras RAdam[中文|English]Unofficial implementation ofRAdamin Keras and TensorFlow.Installpipinstallkeras-rectified-adamExternal Linktensorflow/addons:RectifiedAdamUsageimportkerasimportnumpyasnpfromkeras_radamimportRAdam# Build toy model with RAdam optimizermodel=keras.models.Sequential()model.add(keras.layers.Dense(input_shape=(17,),units=3))model.compile(RAdam(),loss='mse')# Generate toy datax=np.random.standard_normal((4096*30,17))w=np.random.standard_normal((17,3))y=np.dot(x,w)# Fitmodel.fit(x,y,epochs=5)TensorFlow without Kerasfromkeras_radam.trainingimportRAdamOptimizerRAdamOptimizer(learning_rate=1e-3)Use Warmupfromkeras_radamimportRAdamRAdam(total_steps=10000,warmup_proportion=0.1,min_lr=1e-5)Q & AAbout CorrectnessThe optimizer produces similar losses and weights to the official optimizer after 500 steps.Usetf.kerasortf-2.0AddTF_KERAS=1to environment variables to usetensorflow.python.keras.UsetheanoBackendAddKERAS_BACKEND=theanoto environment variables to enabletheanobackend.
Package: tensorflow-recommenders
TensorFlow RecommendersTensorFlow Recommenders is a library for building recommender system models
usingTensorFlow.It helps with the full workflow of building a recommender system: data
preparation, model formulation, training, evaluation, and deployment.It's built on Keras and aims to have a gentle learning curve while still giving
you the flexibility to build complex models.InstallationMake sure you have TensorFlow 2.x installed, and install frompip:pipinstalltensorflow-recommendersDocumentationHave a look at ourtutorialsandAPI reference.Quick startBuilding a factorization model for the Movielens 100K dataset is very simple
(Colab):fromtypingimportDict,Textimporttensorflowastfimporttensorflow_datasetsastfdsimporttensorflow_recommendersastfrs# Ratings data.ratings=tfds.load('movielens/100k-ratings',split="train")# Features of all the available movies.movies=tfds.load('movielens/100k-movies',split="train")# Select the basic features.ratings=ratings.map(lambdax:{"movie_id":tf.strings.to_number(x["movie_id"]),"user_id":tf.strings.to_number(x["user_id"])})movies=movies.map(lambdax:tf.strings.to_number(x["movie_id"]))# Build a model.classModel(tfrs.Model):def__init__(self):super().__init__()# Set up user representation.self.user_model=tf.keras.layers.Embedding(input_dim=2000,output_dim=64)# Set up movie representation.self.item_model=tf.keras.layers.Embedding(input_dim=2000,output_dim=64)# Set up a retrieval task and evaluation metrics over the# entire dataset of candidates.self.task=tfrs.tasks.Retrieval(metrics=tfrs.metrics.FactorizedTopK(candidates=movies.batch(128).map(self.item_model)))defcompute_loss(self,features:Dict[Text,tf.Tensor],training=False)->tf.Tensor:user_embeddings=self.user_model(features["user_id"])movie_embeddings=self.item_model(features["movie_id"])returnself.task(user_embeddings,movie_embeddings)model=Model()model.compile(optimizer=tf.keras.optimizers.Adagrad(0.5))# Randomly shuffle data and split between train and test.tf.random.set_seed(42)shuffled=ratings.shuffle(100_000,seed=42,reshuffle_each_iteration=False)train=shuffled.take(80_000)test=shuffled.skip(80_000).take(20_000)# Train.model.fit(train.batch(4096),epochs=5)# Evaluate.model.evaluate(test.batch(4096),return_dict=True)
Package: tensorflow-rocm
TensorFlow is an open source software library for high performance numerical
computation. Its flexible architecture allows easy deployment of computation
across a variety of platforms (CPUs, GPUs, TPUs), and from desktops to clusters
of servers to mobile and edge devices.Originally developed by researchers and engineers from the Google Brain team
within Google's AI organization, it comes with strong support for machine
learning and deep learning and the flexible numerical computation core is used
across many other scientific domains. TensorFlow is licensed underApache
2.0.
Package: tensorflow-rocm-enhanced
[![Python](https://img.shields.io/pypi/pyversions/tensorflow.svg?style=plastic)](https://badge.fury.io/py/tensorflow)
[![PyPI](https://badge.fury.io/py/tensorflow.svg)](https://badge.fury.io/py/tensorflow)TensorFlow is an open source software library for high performance numerical
computation. Its flexible architecture allows easy deployment of computation
across a variety of platforms (CPUs, GPUs, TPUs), and from desktops to clusters
of servers to mobile and edge devices.Originally developed by researchers and engineers from the Google Brain team
within Google’s AI organization, it comes with strong support for machine
learning and deep learning and the flexible numerical computation core is used
across many other scientific domains.
Package: tensorflow-scientific
Tensorflow ScientificIntroductionTensorFlow Scientific (TFS) is a Python library built on TensorFlow for scientific computing.
TensorFlow Scientific contains modules for integration, ODE solvers and other tasks common in science and engineering.InstallationWORK IN PROGRESSSubpackagesâ–´ Back to toptfs.integratetfs.integrate.odeinttfs.integrate.odeint_fixedtfs.solversFunctionality:tfs.quantumFunctionality:Examplesâ–´ Back to topWORK IN PROGRESSUpcoming Releasesâ–´ Back to top:fire: 0.1.0 Developer Alphatfs.integrate:fire: 0.2.0 Developer Alphatfs.solvers:fire: 0.3.0 Developer Alphatfs.quantumTO DOâ–´ Back to topPypi package badgesOfficial builds badgesIssue tracking badgescode quality badgescode coverage badgesAdd development environment to contributing.mdAdd code contributing to contributing.mdAdd Contributor License Agreement to contributing.mdAdd some examplesFAQâ–´ Back to topQ1. How do I contribute?TF-Scientific is a community led open source project. As such, the project
depends on public contributions, bug-fixes, and documentation. Please
seecontribution guidelinesfor a guide on how to
contribute. This project adheres toTensorFlow's code of conduct.
By participating, you are expected to uphold this code.
Package: tensorflow-serving-api
TensorFlow Serving is a flexible, high-performance serving system for machine
learning models, designed for production environments.TensorFlow Serving makes
it easy to deploy new algorithms and experiments, while keeping the same server
architecture and APIs. TensorFlow Serving provides out-of-the-box integration
with TensorFlow models, but can be easily extended to serve other types of
models and data.This package contains the TensorFlow Serving Python APIs.
Package: tensorflow-serving-api-gpu
TensorFlow Serving is a flexible, high-performance serving system for machine
learning models, designed for production environments.TensorFlow Serving makes
it easy to deploy new algorithms and experiments, while keeping the same server
architecture and APIs. TensorFlow Serving provides out-of-the-box integration
with TensorFlow models, but can be easily extended to serve other types of
models and data.This package contains the TensorFlow Serving Python APIs.
Package: tensorflow-serving-api-python3
Latest releaseCIInstallationSupported Python versions are:3.5and3.6.pipinstall--upgradetensorflow-serving-api-python3Supported versions of TensorflowTensorflow versionServing API versionLink to original serving packagetensorflow~=1.4.0pip install'tensorflow-serving-api-python3~=1.4.0'https://pypi.org/…/1.4.0tensorflow~=1.5.0pip install'tensorflow-serving-api-python3~=1.5.0'https://pypi.org/…/1.5.0tensorflow~=1.6.0pip install'tensorflow-serving-api-python3~=1.6.0'https://pypi.org/…/1.6.0tensorflow~=1.7.0pip install'tensorflow-serving-api-python3~=1.7.0'https://pypi.org/…/1.7.0Why?Official Serving package (https://pypi.python.org/pypi/tensorflow-serving-api) is marked as Python2-only although itsupportsPython3 (therefore you cannotpip3 installtensorflow-serving-api). This has been discussed in this thread:https://github.com/tensorflow/serving/issues/700(unfortunately, the proposal for publishing the Python3 package was rejected).This packageis only redistribution: I only downloaded Python2.whlfrom the PyPI, extracted it and added mysetup.pywith Python3 support.
Package: tensorflow-technical-indicators
tensorflow-technical-indicatorsTechnical Indicators as TF Graph Functions!- Compatible with the rest of the tensorflow ecosystem
- Super fast as tensorflow graph codepip install tensorflow-technical-indicators(Coverage % is bad because tf graphs are not traced, only the@tf.function)Usageimporttensorflow_technical_indicatorsastfti# assuming your tensors have dimensions: (time step, features[ohlcv])# where candles[:, 0] is open, candles[:, 1] high, etc..candles=[...]# you can getc=tfti.features.close(candles)rsi=tfti.rsi(candles=c,window_size=7,method='ema')# you can also pass multidimensional tensors with (time step, features)# where features = open, close# to calculate some indicator for both open and closeresult=tfti.indicator(candles,..params..)# in general# tfti.<indicator>(parameters)# check the list below to find indicator namesList of Indicatorsfromtensorflow_technical_indicatorsimport<indicator>IndicatorImplementationSMAsimple_moving_averageEMAexponential_moving_averageRSIrsiMACDmacdStochastic OscillatorBolliger BandsFibonacci RetractmentIchimoku CloudStandard DeviationAverage Directional IndexMoreTo ComeNeed more indicators? Open up a pull request or open an issue :).
Package: tensorflow-tensorboard
NOTICE: This PyPI entry has been deprecated in favor of thetensorboardname found athttps://pypi.python.org/pypi/tensorboardfor TensorBoard 1.6.0+.
Only bugfix updates on 1.5.x will be applied to this old package name.To upgrade past the version shown on this page, please ensure that youfirstpip uninstalltensorflow-tensorboardand thenpip install tensorboard.TensorBoard is a suite of web applications for inspecting and understanding
your TensorFlow runs and graphs.
Package: tensorflow-tflex
TensorFlow is an open source software library for high performance numerical
computation. Its flexible architecture allows easy deployment of computation
across a variety of platforms (CPUs, GPUs, TPUs), and from desktops to clusters
of servers to mobile and edge devices.Originally developed by researchers and engineers from the Google Brain team
within Google’s AI organization, it comes with strong support for machine
learning and deep learning and the flexible numerical computation core is used
across many other scientific domains.
Package: tensorflow-tpu
TensorFlow is an open source software library for high performance numerical
computation. Its flexible architecture allows easy deployment of computation
across a variety of platforms (CPUs, GPUs, TPUs), and from desktops to clusters
of servers to mobile and edge devices.Originally developed by researchers and engineers from the Google Brain team
within Google's AI organization, it comes with strong support for machine
learning and deep learning and the flexible numerical computation core is used
across many other scientific domains. TensorFlow is licensed underApache
2.0.
Package: tensorflow-transform-canary
TensorFlow Transformis a library for preprocessing data with TensorFlow.tf.Transformis useful for data that requires a full-pass, such as:Normalize an input value by mean and standard deviation.Convert strings to integers by generating a vocabulary over all input values.Convert floats to integers by assigning them to buckets based on the observed
data distribution.TensorFlow has built-in support for manipulations on a single example or a batch
of examples.tf.Transformextends these capabilities to support full-passes
over the example data.https://github.com/tensorflow/transform/blob/master/README.md
Package: tensorflowutil
Tensorflow utility packageinstalls and imports tensorflowwill expose several utility api that can be used commonly in multiple other machine learning and tensorflow specific projects.Install package using the main PYPI server (beware of caching problem)$pipinstalltensorflowutil==CURRENT_VERSIONInstallation verificationFinally, verify installation using the exposed entry point:$tfutil--versionShould print something like:Package: tensorflowutil 
Version: 0.1.5LimitationsGPU support?LicensePlease refer to LICENSE file for detail.
Package: tensorfont
Tensorfont is a library to help those performing numerical analysis of
font data, particular with reference to letterfitting and spacing.Here is an example session:>>> from tensorfont import Font
>>> f = Font("../atospace/kern-dump/normal/MrsEavesOT-Bold.otf")

>>> f.m_width
828.0
>>> f.baseline_ratio
0.28835063437139563

>>> f.pair_distance("A","V")
-149
>>> f.pair_kerning("A","V")
-73

>>> f.glyph("G").lsb
71

>>> m = f.glyph("G").as_matrix()
    .with_sidebearings()
    .crop_descender()
    .scale_to_height(50)
>>> m.left_contour()
array([25, 22, 20, 18, 16, 15, 14, 13, 12, 11, 10, 10,  9,  9,  8,  8,  7,
        7,  7,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  7,  7,
        7,  7,  8,  8,  9, 10, 10, 11, 12, 13, 13, 15, 16, 17, 19, 21])
>>> plt.imgshow(m) ; plt.show()
# The letter "G" is shownFull documentation is available athttps://simoncozens.github.io/tensorfont/index.html
Package: tensorfree
Tensorfree is an image classification library that provides quick and easy access to some of the latest SOTA models. Simply install, define the location of your photos and let it do everything for you.Free software: MIT licenseInstallationpip install tensorfreeYou can also install the in-development version with:pip install https://github.com/andrew-alm/tensorfree/archive/master.zipDocumentationhttps://tensorfree.readthedocs.io/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2020-11-26)First release on PyPI.
Package: tensorfuse-python
Tensorfuse SDKPython SDK package for TensorfuseUsageDefault Logging:from tensorfuse_python.tensorfuse_python import log_generic_event

status = log_generic_event(
    token=<AUTH_TOKEN>,
    log=<LOG_OBJECT>
)Logging Using IDs:from tensorfuse_python.tensorfuse_python import log_generic_event_using_ids

status = log_generic_event_using_ids(
    token=<AUTH_TOKEN>,
    teamId=<TEAM_ID>, 
    projectId=<PROJECT_ID>, 
    datasourceId=<DATASOURCE_ID>,  
    log=<LOG_OBJECT>
)Logging Using Names:from tensorfuse_python.tensorfuse_python import log_generic_event_using_names

status = log_generic_event_using_names(
    token=<AUTH_TOKEN>,
    teamName=<TEAM_NAME>, 
    projectName=<PROJECT_NAME>, 
    datasourceName=<DATASOURCE_NAME>,  
    log=<LOG_OBJECT>
)
Package: tensorgrad
TensorgradTensorGrad is a Python library that provides useful functionality for working with math, including a tensor class and autograd functionalityTensorGrad is a Python library that provides useful functionality for working with math, including a tensor class and autograd functionality. It is still under development, but it already has a number of features that make it a valuable tool for researchers and developers working with complex mathematical problems.Future featuresTensor class: A powerful and flexible tool for representing and manipulating multidimensional arrays.Autograd functionality: Automatically compute the gradients of functions involving tensors.
Package: tensorgram
A realtime remote service to get the keras callbacks to the telegram including the details of metricsFeatures:-It helps by getting the updates of your model including metrics and loss function graphs which help user the view and get to a statistical conclusion about the model remotely.It is a biggest advantage for the users who need not spend hours and hours infront of system for watching the updates of the model.Updates you get are from a telegram bot.Installation:-You can easily install this telegram using following command.pip install tensorgramDependencies/Requirements:-KerasTensorflowRequestsMatplotlibWorks on python>=3.7How to use:-Create a nueral network in keras.The sample code is as follows.from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import SGD
import numpy as np 
import keras

X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])

model = Sequential()
model.add(Dense(8, input_dim=2))
model.add(Activation('tanh'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

sgd = SGD(lr=0.1)
model.compile(loss='binary_crossentropy', optimizer=sgd,metrics=['accuracy'])Now go to Telegram app and search for @tensorgram_bot and join the channel by clicking on the chat.* This application send you the data based on the unique chat id for every user in telegram. So to get your chat id you need to go to search and type @chatid_echo_bot and click on start to get your unique chat id.Store it safely as it will be required later.Now we need to import the TensorGram from tensorgram library using following code.from tensorgram import TensorGramNow we need to create a object of TensorGram by specifying the following attributes like model name and chat id which you obtained before.tf=TensorGram("model-name","123456789")Now you can start training the model and specify the object in the callbacks.model.fit(X, y, batch_size=1, epochs=10,callbacks=[tf],verbose=1)Now if you open the telegram app you will find the updates as follows.Bug / Feature Request:-If you find a bug (gave undesired results), kindly open an issuehereby including your search query and the expected result.If you'd like to request a new function, feel free to do so by opening an issuehere. Please include sample queries and their corresponding results.Licence:-This code is licensed under the MIT license, see LICENSE.txt.Contact:-For any kind of suggesstions/ help in code Please mail me atksdkamesh99@gmail.com.
Package: tensorguard
Tensor GuardTensorGuard helps to guard against bad Tensor shapes in any tensor based library (e.g. Numpy, Pytorch, Tensorflow) using an intuitive symbolic-based syntaxInstallationpip install tensorguardBasic Usageimportnumpyasnp# could be tensorflow or torch as wellimporttensorguardastg# tensorguard = tg.TensorGuard()  #could be done in a OOP fashionimg=np.ones([64,32,32,3])flat_img=np.ones([64,1024])labels=np.ones([64])# check shape consistencytg.guard(img,"B, H, W, C")tg.guard(labels,"B, 1")# raises error because of rank mismatchtg.guard(flat_img,"B, H*W*C")# raises error because 1024 != 32*32*3# guard also returns the tensor, so it can be inlinedmean_img=tg.guard(np.mean(img,axis=0),"H, W, C")# more readable reshapesflat_img=tg.reshape(img,'B, H*W*C')# evaluate templatesasserttg.get_dims('H, W*C+1')==[32,97]Shape Template SyntaxThe shape template mini-DSL supports many different ways of specifying shapes:numbers:"64, 32, 32, 3"named dimensions:"B, width, height2, channels"wildcards:"B, *, *, *"ellipsis:"B, ..., 3"addition, subtraction, multiplication, division:"B*N, W/2, H*(C+1)"dynamic dimensions:"?, H, W, C"(only matches[None, H, W, C])Original Repo link:https://github.com/Qwlouse/shapeguard