Saravanan666/pypi-org huggingface dataset:
Package: tfs-pandas
TFS-PandasThis package provides reading and writing functionality forTable Format System (TFS)files.
Files are read into aTfsDataFrame, a class built on top of the famouspandas.DataFrame, which in addition to the normal behavior attaches anOrderedDictof headers to theDataFrame.See theAPI documentationfor details.InstallingInstallation is easily done viapip:python-mpipinstalltfs-pandasOne can also install in aconda/mambaenvironment via theconda-forgechannel with:condainstall-cconda-forgetfs-pandasExample UsageThe package is imported astfs, and exports top-level functions for reading and writing:importtfs# Loading a TFS file is simpledata_frame=tfs.read("path_to_input.tfs",index="index_column")# You can access and modify the headers with the .headers attributeuseful_variable=data_frame.headers["SOME_KEY"]data_frame.headers["NEW_KEY"]=some_variable# Manipulate data as you do with pandas DataFramesdata_frame["NEWCOL"]=data_frame.COL_A*data_frame.COL_B# You can check the validity of a TfsDataFrame, and choose the behavior in case of errorstfs.frame.validate(data_frame,non_unique_behavior="raise")# or choose "warn"# Writing out to disk is simple tootfs.write("path_to_output.tfs",data_frame,save_index="index_column")Reading and writing compressed files is also supported, and done automatically based on the provided file extension:importtfs# Reading a compressed file is simple, compression format is inferreddf=tfs.read("path_to_input.tfs.gz")# When writing choose the compression format by providing the appropriate file extensiontfs.write("path_to_output.tfs.bz2",df)tfs.write("path_to_output.tfs.zip",df)LicenseThis project is licensed under theMIT License- see theLICENSEfile for details.
Package: tf-spherical-hashing
Spherical HashingA Tensorflow 2 implementation ofSpherical Hashing.Spherical hashing is a way to compute a binary encoding of a feature vector while still maintaining
spatial coherence. This binary encoding can then be used for an approximate nearest neighbor
solution since the compactness of this representation allows for faster neighbor search.Usagefrom spherical_hashing import train_spherical_hashing
import tensorflow as tf

x_train = tf.random.uniform(shape=(1000, 512), minval=-10.0, maxval=10.0)
sph_model = train_spherical_hashing_model(x_train, n_bits=32)

x_test = tf.random.uniform(shape=(100, 512), minval=-10.0, maxval=10.0)
bits = sph_model(x_test, apply_pack_bits=True)Installationpip install tf-spherical-hashingDevelopmentRun tests./scripts/run-tests.shPublish pip package./scripts/publish.sh
Package: tf-sprinkles
TF SprinklesSprinkles augmentation implemented in TensorFlow.BranchBuild statusCoverage statusPyPI versionmasterdevelopBased on Less Wright's Medium article,Progessive Sprinkles: a New Data
Augmentation for CNNs. See also hispost on fast.ai.To install:pip install tf_sprinklesTo use:fromtf_sprinklesimportSprinklessprinkles=Sprinkles(num_holes,side_length)Then callsprinkles(image)in the input pipeline for your image. A simple
example to get started using thecat.jpegimage located in the data folder
is:importnumpyasnpimporttensorflowastffromtf_sprinklesimportSprinklesfromPILimportImagefrommatplotlibimportpyplotaspltsprinkles=Sprinkles(num_holes=100,side_length=10)img=Image.open('test/data/cat.jpeg')img=np.asarray(img)/255.result=sprinkles(tf.constant(img,dtype=tf.float32))plt.imshow(result.numpy())Which results in the following image with sprinkles.Note that themodeflag added in version 1.1.0 can be used to specify that
sprinkles should be filled with Gaussian noise (mode='gaussian'), randomly
filled with black or white (mode='salt_pepper'), or all black (the default
ormode=None).
Package: tfstage
# TF StageA fast and canonical project setup for TensorFlow models. The most difficult part of getting started with TensorFlow isn't deep learning, it's putting together hundreds of API calls into a cohesive model.```$ tfstage --helpusage: tfstage [-h] nameTensorFlow project scaffoldingpositional arguments:name                  Project nameinstall_dependencies  Install pip dependenciesoptional arguments:-h, --help            show this help message and exit```## Usage1. Install `tfstage`:```pip install tfstage```2. Create a new empty project directory```$ mkdir my_project/$ cd my_project/```3. Run `tfstage my_project`:```$ tfstage my_projectProject created: ./my_project```4. This stubs out an entire TensorFlow project, completely runnable using a simple XOR dataset and model. For example:```$ python -m my_project.main --job-dir logs/...INFO:tensorflow:Saving checkpoints for 1 into logs/model.ckpt.INFO:tensorflow:loss = 1.20236, step = 1INFO:tensorflow:Starting evaluation at 2017-07-13-18:22:20INFO:tensorflow:Restoring parameters from logs/model.ckpt-1...```## WorkflowWhen starting a new project we run `tfstage`, run the code to verify everything works, then search and replace the `TODO` comments in the code which mark important changes.## EnvironmentHigh-level description of a new project:- main.py: defines command-line arguments and sets up [`learn_runner`](https://goo.gl/I6TwxA)- experiment.py: defines a [`tf.contrib.learn.Experiment`](https://goo.gl/nMvwLx) for training- inputs.py: defines the input pipeline for training and evaluation- model.py: defines the model, loss, and training optimization- augment.py: defines any data augmentation or feature engineering- serve.py: defines placeholders for [TensorFlow Serving](https://goo.gl/bM3jpA) and [Google Cloud ML Engine predictions](https://goo.gl/yTBv2e).In addition, several common files are created including:- README.md- requirements.txt for local _development_- setup.py for local and GCE _deployment_- .gitignore### Local Deployment```PROJECT_NAME=my_projectMODULE_NAME="${PROJECT_NAME}.main"PACKAGE_PATH="${PROJECT_NAME}/"JOB_DIR=logs/gcloud ml-engine local train \--module-name $MODULE_NAME \--package-path $PACKAGE_PATH \--job-dir $JOB_DIR \-- \[args]```### Cloud Deployment```MODULE_NAME="${PROJECT_NAME}.main"PACKAGE_PATH="${PROJECT_NAME}/"JOB_NAME="${PROJECT_NAME}_1"JOB_DIR="gs://${PROJECT_NAME}/${JOB_NAME}"REGION=us-east1gcloud ml-engine jobs submit training $JOB_NAME \--job-dir $JOB_DIR \--module-name $MODULE_NAME \--package-path $PACKAGE_PATH \--region $REGION \-- \[args]```
Package: tf-stitch
tf-stitchStarter code with best practices for different Deep Learning problems in one command.This Package provides Tensorflow 2.0 boilerplate code , for deep learning problem domains.To install, in command line enter -pip install tf-stitchView Pypi project onhttps://pypi.org/project/tf-stitch/Why use this?If you have been working in deep learning or have just started, you will find yourself writing the same imports, same training loop, same data fetching commands, same model declaration every time.Personally, found myself copy-pasting MNIST models to get started with a project.
And Even copy-pasting does not work as there are many parts of deep learning code that are needed in different combinations for different problems.This Package is created just to solve this problem for our most beloved framework Tensorflow 2.0.
Deep learning is an exciting field full of awesome ideas and new concepts popping every day.Custom stitched boiler code lets you focus on the uniqueness of your implementation and not the repetitive code.Keras and Tensorflow 2.0, because of simple API, allows you to implement many ideas in less time. This Package just aims to double(2X) that efficiency.USAGEusage: tf-stitch output_file [-d DOMAIN]
[--dataset DATASET] [--model MODEL] [--training TRAINING]
[--testing TESTING]Example -tf-stitch output_script.py -d=visionortf-stitch output_notebook.ipynb -d=nlpHereoutput_script.pyandoutput_notebook.ipynbare  the generated output files with starter code.output_fileis required for command to run.
File can have extension .py or .ipynb for generating python script or jupyter notebook.Arguments:-d , --domain DOMAINDomain problem type for selecting appropriate model
and dataset. Seetf_stitch/template.jsonfor default datasets and model for each domain option.
Current domain options are -visionnlpstructuredEither provide domain argument or dataset and model arguments- dataset DATASET:  Select any of Tensorflow datasets. Seecatalog.--model MODEL:     Select a Deep Learning Model
Current available options -conv - Convolution modelrnn - GRU sequence modeldnn - Fully connected networkcustom - Custom layer network--training TRAINING: Type of training loop.
Options -custombuilt-in--testing TESTING:   If to include testing, True or FalseExample -tf-stitch output.ipynb --dataset = cifar100 --model = conv 
--training = custom --testing = TrueAll the templates are in their respective folder intf_stitch/templates. Feel free to change templates according to your taste and also submit a pull request if it can be helpful for others as well.ContributingHey There, this project requires your feedback and contribution to improve.
You can contribute, but not restricted to, in following ways -Providing Feedback and submitting feature request.Apply best and latest TF2.0 practices.Add more template and domain options.Looking forward to hear from you : )
Package: tf-summary-reader
tf_summary_readerA package for read data from tensorflow summary filesFree software: MIT licenseDocumentation:https://tf-summary-reader.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-11-05)First release on PyPI.
Package: tfsurgeon
TFSurgeonAllows for dynamic tensorflow keras model edition.
You can install this package with pip and call it asfrom tfsurgeon import edit_model.How to useremove layers based on layer typeremove layers based on name or indexreplace layers from one type to anotherreplace specific layer (name) by another layer (callable)see docstring for examples insrc/tfsurgeon/tfsurgeon.py.importfrom tfsurgeon import edit_model
import tensorflow as tf

model = tf.keras.applications.MobileNetV2(weights=None)
new_model = edit_model(
    model=model,
    replace_layers_by_types=[
        [tf.keras.layers.BatchNormalization, tf.keras.layers.LayerNormalization]
    ],
    verbose=True,
)CLIno supported yet
Package: tfsx
GoalThis lib is reponsable for retriving data and sending commands to Microsoft DevOps.InstallationTo install tfsx, run this command in your terminal:pip install tfsxUsageTo use tfsx in a Python project:fromtfs.tfsimportTFSfrompprintimportpprintfromdatetimeimportdatetimedefmain():tfs=TFS('<userkey>','<serverurl')work_itens=tfs.get_work_item_query_by_wiql_epic_user_story_product_backlog_item()pprint(len(work_itens))work_itens=tfs.get_work_item_query_by_wiql_task()pprint(len(work_itens))if__name__=="__main__":main()
Package: tftables
tftablesallows convenient access to HDF5 files with Tensorflow.
A class for reading batches of data out of arrays or tables is provided.
A secondary class wraps both the primary reader and a Tensorflow FIFOQueue for straight-forward streaming
of data from HDF5 files into Tensorflow operations.The library is backed bymultitablesfor high-speed reading of HDF5
datasets.multitablesis based on PyTables (tables), so this library can make use of any compression algorithms
that PyTables supports.LicenceThis software is distributed under the MIT licence.
See theLICENSE.txtfile for details.Installationpip install tftablesAlternatively, to install from HEAD, runpip install git+https://github.com/ghcollin/tftables.gitYou can alsodownloadorclone the repositoryand runpython setup.py installtftablesdepends onmultitables,numpyandtensorflow. The package is compatible with the latest versions of python
2 and 3.Quick startAn example of accessing a table in a HDF5 file.importtftablesimporttensorflowastfwithtf.device('/cpu:0'):# This function preprocesses the batches before they# are loaded into the internal queue.# You can cast data, or do one-hot transforms.# If the dataset is a table, this function is required.definput_transform(tbl_batch):labels=tbl_batch['label']data=tbl_batch['data']truth=tf.to_float(tf.one_hot(labels,num_labels,1,0))data_float=tf.to_float(data)returntruth,data_float# Open the HDF5 file and create a loader for a dataset.# The batch_size defines the length (in the outer dimension)# of the elements (batches) returned by the reader.# Takes a function as input that pre-processes the data.loader=tftables.load_dataset(filename='path/to/h5_file.h5',dataset_path='/internal/h5/path',input_transform=input_transform,batch_size=20)# To get the data, we dequeue it from the loader.# Tensorflow tensors are returned in the same order as input_transformationtruth_batch,data_batch=loader.dequeue()# The placeholder can then be used in your networkresult=my_network(truth_batch,data_batch)withtf.Session()assess:# This context manager starts and stops the internal threads and# processes used to read the data from disk and store it in the queue.withloader.begin(sess):for_inrange(num_iterations):sess.run(result)If the dataset is an array instead of a table. Theninput_transformcan be omitted
if no pre-processing is required. If only a single pass through the dataset is desired,
then you should passcyclic=Falsetoload_dataset.ExamplesSee theunit testsfor complete examples.ExamplesSee thehow-tofor more in-depth documentation, and theunit testsfor complete examples.DocumentationOnline documentationis available.
Ahow togives a basic overview of the library.Offline documentation can be built from thedocsfolder usingsphinx.
Package: tf-taggers
# TextFlows Taggers Module #A [TextFlows](https://github.com/xflows/textflows/) package, which contains python wrapper classes for four part-of-speech taggers, CRF tagger, TreeTagger, NLP4j and TNT.## Installation, documentation ##Please find installation instructions, examples and API reference on [Read the Docs](http://docs.textflows.org/).## Note ##Please note that this is a research project and that drastic changes can be (and are) made pretty regularly. Changes are documented in the [CHANGELOG](CHANGELOG.md).Pull requests and issues are welcome.## Contributors to the tf_tagger package code ##Matej Martinc (@matejMartinc)[Knowldge Technologies Department](http://kt.ijs.si), Jožef Stefan Institute, Ljubljana
Package: tftb
[![Documentation Status](https://readthedocs.org/projects/tftb/badge/?version=latest)](https://tftb.readthedocs.io/en/latest/?badge=latest)
[![Build Status](https://travis-ci.org/scikit-signal/tftb.svg)](https://travis-ci.org/scikit-signal/tftb)# tftbtftb (Time-frequency toolbox) is a Python module for time-frequency analysis and visualization
build with SciPy and matplotlib.The tftb project began as a Python implementation of the TFTB toolbox developed by
François Auger, Olivier Lemoine, Paulo Gonçalvès and Patrick Flandrin. While this project and the
MATLAB implementation (henceforth referred to as TFTB) are similar in the core algorithms and the
basic code organization, the very nature of the Python programming language has motivated a very
different approach in architecture of PyTFTB (differences between the two packages have been
discussed in detail [here](https://tftb.readthedocs.io/en/latest/introduction.html#comparison-of-tftb-and-pytftb)).## Installationtftb requires:Python (>= 3.5)NumPySciPyMatplotlibInstall tftb with pip as follows:`bash $ pip install tftb `
Package: tft-forecasting
tft-forecastingTemporal Fusion Transformers for Interpretable Multi-horizon Time Series Forecastinggitclonehttps://github.com/thomktz/tft-forecastingcdtft-forecastingInstall poetry and pre-commitpipinstallpoetrypre-commitInstall dependenciespoetryinstallInstall the pre-commit hookspre-commitinstallTo run the pre-commit hookspre-commitrun--all-filesTo run pytestspoetryrunpytest
Package: tft-loaded-dice
tft-loaded-diceUsageUse the resultingjsonorpip install tft-loaded-dicefromtft_loaded_diceimportbest_champions,champion_oddsbest_champions("Jayce",level=7)# [('Zilean', 0.01), ('Jayce', 0.01), ('Caitlyn', 0.01), ('Fiora', 0.005), ('Singed', 0.005), ('Ezreal', 0.005), ('Heimerdinger', 0.005), ('Seraphine', 0.005), ('Vi', 0.003333333333333333)]champion_odds("Shaco")# {'Ekko': {3: 0.0, 4: 0.075, 5: 0.1, 6: 0.15, 7: 0.175, 8: 0.175, 9: 0.15, 10: 0.1, 11: 0.06}, 'Braum': {3: 0.0, 4: 0.075, 5: 0.1, 6: 0.15, 7: 0.175, 8: 0.175, 9: 0.15, 10: 0.1, 11: 0.06}, 'Talon': {3: 0.0, 4: 0.05, 5: 0.06666666666666667, 6: 0.1, 7: 0.11666666666666665, 8: 0.11666666666666665, 9: 0.1, 10: 0.06666666666666667, 11: 0.04}, 'Shaco': {3: 0.0, 4: 0.075, 5: 0.1, 6: 0.15, 7: 0.175, 8: 0.175, 9: 0.15, 10: 0.1, 11: 0.06}, 'Twisted Fate': {3: 0.0, 4: 0.05, 5: 0.06666666666666667, 6: 0.1, 7: 0.11666666666666665, 8: 0.11666666666666665, 9: 0.1, 10: 0.06666666666666667, 11: 0.04}, 'Twitch': {3: 0.0, 4: 0.0375, 5: 0.05, 6: 0.075, 7: 0.0875, 8: 0.0875, 9: 0.075, 10: 0.05, 11: 0.03}, 'Darius': {3: 0.0, 4: 0.075, 5: 0.1, 6: 0.15, 7: 0.175, 8: 0.175, 9: 0.15, 10: 0.1, 11: 0.06}, 'Akali': {3: 0.0, 4: 0.075, 5: 0.1, 6: 0.15, 7: 0.175, 8: 0.175, 9: 0.15, 10: 0.1, 11: 0.06}, 'Katarina': {3: 0.0, 4: 0.05, 5: 0.06666666666666667, 6: 0.1, 7: 0.11666666666666665, 8: 0.11666666666666665, 9: 0.1, 10: 0.06666666666666667, 11: 0.04}, 'Zyra': {3: 0.0, 4: 0.05, 5: 0.06666666666666667, 6: 0.1, 7: 0.11666666666666665, 8: 0.11666666666666665, 9: 0.1, 10: 0.06666666666666667, 11: 0.04}}DevelopmentInstall poetryhttps://python-poetry.org/docs/#installationInstall dependenciespoetry install
poetry run pre-commit installRun testpoetry run pytest --cov=tft_loaded_dice --cov-fail-under=80 --cov-report xmlReferenceshttps://github.com/alanz132/loadedDiceOddshttps://giantslayer.tv/blogs/5261054387/correctly-using-loaded-dice/https://www.reddit.com/r/CompetitiveTFT/comments/kw4ah7/loaded_die_odds_for_every_champion/https://raw.communitydragon.org/latest/cdragon/tft/en_gb.json
Package: tftool
Ergonomic utilities for the terraform CLI.Installpython3-mpipinstalltftoolUsage# Force terraform to be a bit more Unix philosophyaliastfplan="terraform plan -refresh=false -input=false -out=/tmp/plan > /dev/null && terraform show -json /tmp/plan"aliastfapply="xargs -or0 terraform apply"aliastfimport="xargs -or0L2 terraform import"# Only create new resourcestfplan|tftooltarget--no-updates|tfapply# Automatically import new resources if their name/index matches the id.tfplan|tftoolautoimport|tfimport
Package: tft-phoebe
= PhoebePhoebe is a data gathering proxy for https://prometheus.io/[Prometheus] toolkit. Its goal is to gather metrics from systems that don't provide their own native Prometheus export, and make them available for digestion by Prometheus.== How to run an exporter[source,shell]....$ pip install tft-phoebe$ phoebe-openstack --config=<your config file> --export=<filepath or - for stdout>....Or, after checking out the sources:[source,shell]....$ poetry install$ poetry run phoebe-openstack --config=<your config file> --export=<filepath or - for stdout>....
Package: tf-train
TensorflowTrainingAdditional python package for train models withTensorflow.Installationpip install --upgrade tf-trainUsageimport tf-train as tftIn tft directly are availablekeras:tft.modelstft.lossestft.optimizerstft.metricsUse thetft.train()to train model.Args:

    train_dataset: Tensorflow Dataset object for train the model.

    model: Keras trainable model.

    epochs (int): Num of epochs of training.

    loss: Loss function.

    optimizer: Tensorflow optimizer. Default Adam with learning_rate=0.001.

    metrics: List of tensorflow mertics. Default contains Recall and Precision.
Package: tf-training-notifier
Tensorflow Training NotifierA python package which periodically notifies you of your Tensorflow job's progress.InstallationThe python package can be installed via pip.pipinstalltf-training-notifierSetupThe package relies on two envionrmnet variables ("TRAINING_NOTIFIER_TOKEN" and "TRAINING_NOTIFIER_CHAT_ID") being set. These variables point towards the Telegram bot token and the Telegram chat ID. Instructions on how to get and set those up can be foundhere.UsageSetting up the notifierimporttrainingnotifierEPOCHS=15# The default notifier which only notifies the user when the job is completed.notifier=trainingnotifier.NotifierCallback(EPOCHS)model.fit(x_train,y_train,epochs=EPOCHS,callbacks=[notifier])# Creates a notifier that will update the user ONCE (if the job takes more than 2 minutes)#  when the job is done. It will also report the loss in this message.notifier=trainingnotifier.NotifierCallback(EPOCHS,min_time="2m",metrics=["loss"])# Creates a new notifier that will notify the user, at soonest, every 10 minutes with#  the jobs ETA and loss values. If the job takes longer than 10 minutes than it will send#  a notification that the job is donenotifier=trainingnotifier.NotifierCallback(EPOCHS,epoch_updates=True,min_time="10m",metrics=["loss"])To test if the system was setup properly.# This function tests the notification system. If the target user recieves a Telegram test#  message, then the enviornment variables have been set correctly.trainingnotifier.test_notifier()
Package: tft-torch
tft-torchtft-torchis aPythonlibrary that
implements"Temporal Fusion Transformers for Interpretable Multi-horizon Time Series Forecasting"using pytorch framework. The library provides a complete implementation of a time-series multi-horizon forecasting model
with state-of-the-art performance on several benchmark datasets.This library works for Python 3.7 and higher and PyTorch 1.6.0 and higher.InstallationThis library is distributed onPyPiand can be installed usingpip.$ pip install tft-torchThe command above will automatically install all the required dependencies. Please visit theinstallationpage for more details.Getting startedCheck out thetutorialsfor a demonstration
how to use the library.DocumentationFor more information, refer to ourblogpostandcomplete documentation.ReferenceThis repository suggests an implementation of a model based on the work presented in the following paper:@misc{lim2020temporal,
      title={Temporal Fusion Transformers for Interpretable Multi-horizon Time Series Forecasting}, 
      author={Bryan Lim and Sercan O. Arik and Nicolas Loeff and Tomas Pfister},
      year={2020},
      eprint={1912.09363},
      archivePrefix={arXiv},
      primaryClass={stat.ML}
}Some parts of the implementation rely onmattsherar's TFT implementation, available as
part of theTemporal_Fusion_Transformrepository.Info for developersThe source code of the project is available onGitHub.$ git clone https://github.com/PlaytikaOSS/tft-torch.gitYou can install the library and the dependencies with one of the following commands:$ pip install .                        # install library + dependencies
$ pip install ".[develop]"             # install library + dependencies + developer-dependencies
$ pip install -r requirements.txt      # install dependencies
$ pip install -r requirements-dev.txt  # install developer-dependenciesFor creating the "pip-installable"*.whlfile, run the following command (at the root of the repository):$ python -m buildFor creating the HTML documentation of the project, run the following commands:$ cd docs
$ make clean
$ make htmlRun testsTests can be executed withpytestrunning the following commands:$ cd tests
$ pytest                                      # run all tests
$ pytest test_testmodule.py                   # run all tests within a module
$ pytest test_testmodule.py -k test_testname  # run only 1 testLicenseMIT License