Saravanan666/pypi-org huggingface dataset:
Package: tfdocs
TF-Docstfdocslets you generateREADME.mdfor Terraform modules based onvariables.tf.
Additionally, it can sort variable definitions.Usagetfdocs [flags] <variables.tf>Flags:-h, --help            Show this help message and exit
--name, -n            Specify a custom name for the module
--readme              Specify the name of the output file (default: README.md)
--variables           Specify the name of the file containing variables (default: variables.tf)
--source SOURCE       Specify a custom source for the module
--git-source          Only to be used together with --source to specify the source is a git repository. If true, sub directory and a place holder TAG will be appended to the source
-f                    Format and sort variables.tf file
--dry-run             Show the output without writing to the file
--versionInput fileDefault:variables.tfAll the input variables of the module must be defined in a single file. By defaulttfdocswill look for a file
namedvariables.tfin the current directory. Alternatively a custom file can be specified using the--variablesflag.Examplevariables.tfvariable"my_string"{type=stringdescription="Description of the string"default="default"}variable"my_list"{type=List(string)description="Description of the list"default=["default"]}Formatvariables.tfYou can use the-fflag to format thevariables.tffile. This will sort the variables in alphabetical order.Generated Readme fileDefault:README.mdThe module expects to have aREADME.mdfile in the current directory. If the file does not exist,tfdocswill create
one. Alternatively, a custom file can be specified using the--readmeflag.ExampleREADME.md# My moduleInsert a description of the module here.

<!-- TFDOCS START -->
module <my_module> {
source = "git@github.com:<your_name>/<your_repo>.git//<subfolder>?ref=<TAG>"
my_list = <LIST(STRING)>    # Description of the list
my_string = <STRING>        # Description of the string
}
<!-- TFDOCS END -->

Custom contenttfdocsreplaces only the content between the markers below with variable definitions fromvariables.tf.Markers:<!-- TFDOCS START -->and<!-- TFDOCS END -->Module SourceDefault:git-remote-origin//<subfolder>?ref=<TAG>By default, if the module is in a Git repository,tfdocswill utilize the remote origin to generate the source URL
(git://github.com/<your_name>/<your_repo>.git//<subfolder>?ref=<TAG>).Otherwise, either the source URL can be specified using the--sourceflag or if not provided it will default
to./modules/{CURRENT_DIRECTORY}.AnnotationsOverride variable typeUse#tfdocs: type=<TYPE>to override the variable type. This is useful when the type is not correctly inferred from the variable definition or when you want to customize it.Examplevariables.tfvariable"my_object"{#tfdocs: type = list(object)type=list(object({name=stringsize=numberdirectory=string}))description="Description of the string"default="default"}Note:tfdocsoverwrite an existing README.md file. It's always good to use--dry-runfirst.Authorstfdocsis created and maintained byvajeen.
Package: tfds-aihub
tfds aihubAIhub 데이터를 tfrecord 형태로 GCS에 저장/캐싱하기 위한 코드.데이터셋K-Fashion Image(k_fashion_image)Version: 1.1splitsTraining:967806Validation:120975Features:```python
  tfds.features.FeaturesDict(
      {
          "image": tfds.features.Image(shape=(None, None, 3)),
          "objects": tfds.features.Sequence({
              "type": tfds.features.ClassLabel(names=_BBOX_TYPE),
              "bbox": tfds.features.BBoxFeature(),
              "segmentation_mask": tfds.features.Image(shape=(None, None, 1)),
              # TODO style 관련 정보
          })
      }
  )
  ```
Package: tfds-defect-detection
TensorFlow Datasets for Defect DetectionTo directly jump into the code look at the sample notebookFeaturestensorflow.data.Dataset builder for defect segmentationComes with unsupervised / self-supervised SotA datasetsMVTECVISAArtificial defect generatorEvaluation data with hand labelled imagesInstallCreate a new python=3.9 env and installtfds_defect_detectionfrom pippipinstalltfds_defect_detectionExamplesimporttfds_defect_detectionastfdtfd.load()UsageAll parmetersimporttfds_defect_detectionastfdimporalbumentationsasAds=tfd.load(names=("mvtec","visa"),data_dir=Path("."),pairing_mode="result_with_contrastive_pair",# "result_only", "result_with_original"create_artificial_anomalies=True,validation_split=0.2,subset_mode="training",# "validation", "test", "holdout", Nonedrop_masks=False,width=256,height=256,repeat=True,anomaly_size=None,global_transform=A.Compose([A.RandomBrightnessContrast(),A.HueSaturationValue(),]),process_deviation=A.Compose([A.ShiftScaleRotate(shift_limit=0.01,scale_limit=0.0,rotate_limit=1.5,p=1),A.Blur(blur_limit=3),A.RandomBrightnessContrast(),A.RandomGamma(),A.HueSaturationValue(),]),anomaly_composition=A.Compose([A.RandomRotate90(),A.Transpose(),A.ShiftScaleRotate(shift_limit=0.0625,scale_limit=0.50,rotate_limit=45,p=1),A.RandomGamma(),A.OpticalDistortion(),A.GridDistortion(),A.RandomContrast(0.5,p=1),]),batch_size=9,seed=123,shuffle=True,peek=True,image_validation=False,delete_tmp=True,crop_to_aspect_ratio=True)DocsFOR API Reference seehttps://tfds-defect-detection.readthedocs.io/en/latest/autoapi/tfds_defect_detection/index.htmlCiteIf this project helped you during your work:
Until a publication is available, please cite asTobias Schiele. (2022). TFDS DD - Datasets for Defect Detection.https://github.com/thetoby9944/tfds_defect_detection.@misc{Schiele2019,
    author ={Tobias Schiele},
    title ={TFDS DD - Datasets for Defect Detection},
    year ={2022},
    publisher ={GitHub},
    journal ={GitHub repository},
    howpublished ={\url{https://github.com/thetoby9944/tfds_defect_detection}},}
Package: tfds-korean
tfds-koreanA collection of Korean Text Datasets ready to use usingTensorflow-Datasets.TensorFlow-Datasets를 이용한 한국어/한글 데이터셋 모음입니다.Dataset Catalog|pypi|CONTRIBUTING.mdUsageInstallationpipinstalltfds-koreanLoading datasetimporttensorflow_datasetsastfdsimporttfds_korean.nsmc# register nsmc datasetds=tfds.load('nsmc')train_ds=ds['train'].batch(32)test_ds=ds['test'].batch(128)# define model# ....# ....model.fit(train_ds)model.evaluate(test_ds)SeeDataset Catalog pagefor dataset list and details of each dataset.ExamplesLoading NSMC datasetTraining a classifier using Korean hate speech datasetLicensesThe license for this repository and licenses for datasets are applied separately. It is recommended to use each dataset after checking the dataset's website.본 레포지토리의 라이선스와 데이터셋의 라이선스는 별도로 적용됩니다. 데이터셋을 사용하기 전 각 데이터셋의 라이선스와 웹 사이트를 확인 후 사용하시길 권해드리며, 본 라이브러리는 데이터셋을 호스팅하거나 배포하지 않는 점을 참고부탁드립니다.
Package: tf-ecosystem
tf-ecosystemA tool for handling terraform deployments in a modular wayQuickstart$ pip install tf-ecosystem
$ tf-eco init-stack --region eu-central-1 --environment live --stack help
$ cat ~/.config/tf-ecosystem/config.ini
$ cat _eco_override.tfConfiguration ReferencefacetsFacets are variables used as required arguments and to describe the state path in an s3 backend.facets.stateA list of facets stringsfacets.optionalA subset offacets.statemarking those facets as optional.facets.compositebackendprovidersmappingsA dictionary of dictionaries where each
Package: tf-efficientdet-lite2
Object detection with tensorflow$pipinstalltf-efficientdet-lite2fromtf_efficientdet_lite2importTfEfficientdetLite2tflo=TfEfficientdetLite2(sevenzip_path=r"C:\Program Files\7-Zip\7z.exe",set_visible_devices_0=True)#works without 7-zip as welltflo.detect(r'https://images.pexels.com/photos/14139354/pexels-photo-14139354.jpeg?cs=srgb&dl=pexels-olena-bohovyk-14139354.jpg&fm=jpg&_gl=1*19indnx*_ga*ODM0MDU4MTIyLjE2NjgzMzEwODk.*_ga_8JE65Q40S6*MTY2ODMzMTA4OS4xLjEuMTY2ODMzMTA5My4wLjAuMA..',draw_results=True,draw_result_min_score=.3)tflo.get_df()aa_classaa_x_startaa_y_startaa_x_endaa_y_endaa_conf0person4491248706110.9159731cup91652110226540.6426832cup6523607324690.5616343diningtable8292112007930.5457634chair926111981760.235585....................95chair9881311882530.01221296cup8574919476160.01195497chair114972811967930.01181198spoon6513716664090.01178099spoon101329010623580.011758tflo.get_drawn_results()
Package: tfembedhub
tfembedhubConvert embeddings vectors (.txt format) into TensorFlowHub embedding lookup module.How toSave lookup keys and embeddings values in text file.Keys should be in first column. Other columns treated as embedding values. Any space-like characters allowed as columns separator.Non-existing keys will refer to "" key embeddings. You may provide embedding values for that, otherwise it will be initialized with zeros.key1 1. 2. 3.
key2 4. 5. 6.
<UNQ> 0. -1. 0.Sonvert saved embeddings into TF Hub Module with "tfembedhub-convert" command.tfembedhub-convertvectors.txtvectors-hub/Use embedding hub via columns in your estimator.fromtfembedhubtext_embedding_column,sequence_text_embedding_columnmy_words_embedding=sequence_text_embedding_column(key='sparse_key_from_features',module_spec='path/to/my/hub')# Then pass my_words_embedding to estimator "columns" list.
Package: tf-encrypts
tf-encrypt사용법 : TfEncryptdata = {'a': 123, 'b': 'b123'}
cipher = TfEncrypt(password="p@ssw0rd")
encrypted_data = cipher.encrypt(data)
decrypted_data = cipher.decrypt(encrypted_data)사용법 : TfEncryptFernetdata = {'a': 123, 'b': 'b123'}
data = "1234"
data = 3.14
cipher = TfEncryptFernet(password="p@ssw0rd")
encrypted_data = cipher.encrypt(data)
decrypted_data = cipher.decrypt(encrypted_data)사용법class A:
    a = 1
    b = 'text2'

data = A()
cipher = TfEncryptFernet(password="p@ssw0rd")
encrypted_data = cipher.encrypt(data)
decrypted_data = cipher.decrypt(encrypted_data)
Package: tfe-run-wait
tfe-run-waitCommand line utility to poll for a Terraform Enterprise run state change and apply a planned run.Usagetfe-run-wait [-h] \
        --token TOKEN \
        --organization ORGANIZATION \
        --clone-url CLONE_URL \
        --commit-sha COMMIT_SHA \
        [--branch BRANCH ] \
        [--workspace WORKSPACE] \
        [--wait-for-status WAIT_FOR_STATUS] \
        [--maximum-wait-time MAXIMUM_WAIT_TIME]

tfe-run-apply [-h] \
        --token TOKEN \
        --organization ORGANIZATION \
        --clone-url CLONE_URL \
        --commit-sha COMMIT_SHA \
        [--branch BRANCH ] \
        --comment COMMENT \
        [--confirm] \
        [--workspace WORKSPACE] \
        [--maximum-wait-time MAXIMUM_WAIT_TIME]Options--token TOKEN         Terraform Enterprise access token, default from TFE_API_TOKEN
  --organization ORGANIZATION
                        of the workspace
  --workspace WORKSPACE
                        to inspect runs for. if not specified apply to all workspaces associated with the source repo.
  --clone-url CLONE_URL
                        of source repository for the run
  --commit-sha COMMIT_SHA
                        of commit which initiated the run
  --branch BRANCH
                        of commit which initiated the run
  --wait-for-status WAIT_FOR_STATUS
                        wait state to reach, defaults to 'applied' and 'planned_and_finished'
  --maximum-wait-time MAXIMUM_WAIT_TIME
                        for state to be reached in minutes, default 45
  --confirm             requests confirmation after showing the plan. you will have to type `yes`
  --comment             to use in the apply of the planned run.
  -h, --help            show this help message and exitDescriptionFinds a Terraform Enterpise run initiated for the specified git commit and either polls for a
specific state change or apply the planned changes.tfe-run-wait will wait until the specified status is reached. By default it will wait for
the statusappliedorplanned_and_finished. When the run reaches a non specified final state,
it will exit with an error.tfe-run-apply will request terraform to apply to plan for the run. If the status of the run is
alreadyappliedorplanned_and_finished, it will exit without an error. It will not check
whether the run is in the correct state. Depending on the configuration the run should be in
the stateplanned,cost_estimatedorpolicy_checked.If no workspace is specified, you have to specify a branch; the utility will search for
all workspaces associated with the specified source repository and branch.CAVEATSthe wait and apply is single threaded.
Package: tfest
TfestTransfer function estimation with frequency response.
Python equivalent of MATLAB tfest (but the algorithm is not exactly the same)Only works wuth SISO systems for now.Installation:pipinstalltfestExample:To get a scipy transfer function:importtfest# u: input# y: outputte=tfest.tfest(u,y)# n_zeros, n_poleste.estimate(3,4,time=1)te.get_transfer_function()"time" is simulation length in seconds.
To plot its bode diagram:te.plot_bode()Default method to calculate the frequency response Y/U is H1 estimator, if you want to use H2 or frequency/frequency just set the method to "h2" or "fft" and specify the time length of the simulation (in seconds, default is 1):te.estimate(3,4,method="h2",time=1)te.estimate(3,4,method="fft",time=1)To use L1 normalization set the value of lambda l1 (default l1=0):te.estimate(3,4,time=1,l1=0.1)
Package: tff
This module provides basic interfaces for terminal I/O filter applications,
and exports some default implementations such as Scanner, Parser …etc.Installvia github$ git clone https://github.com/saitoha/tff.git
$ cd tff
$ python setup.py installor via pip$ pip install tffRequirementsPython 2.6/2.7 unix/linux versionExported InterfacesFollowing interfaces are exported from tff/interface.pytff.EventObserveradapt to event driven ECMA-35/48 parser modeltff.OutputStream:Abstructed TTY output streamtff.EventDispatcherDispatch interface of terminal sequence event oriented parsertff.Parser:Abstruct event driven Parser. dispatch parser event to event dispatchertff.PTY:Abstructed PTY deviceLicenseMIT LicenseDependentscanossahttps://github.com/saitoha/canossasentimental-skkhttps://github.com/saitoha/sentimental-skkdrcstermhttps://github.com/saitoha/drcstermsixeltermhttps://github.com/saitoha/sixeltermjacothttps://github.com/saitoha/jacot
Package: tf-fastmri-data
tf-fastmri-dataBuilt around thetf.dataAPI,tf-fastmri-dataoffers reliable, unit-tested, datasets for the fastMRI dataset.InstallationCurrently, you need to install the package from source:git clone https://github.com/zaccharieramzi/tf-fastmri-data.git
cd tf-fastmri-data
pip install .Example usefromtf_fastmri_data.datasets.cartesianimportCartesianFastMRIDatasetBuildertrain_dataset=CartesianFastMRIDatasetBuilder(path='/path/to/singlecoil_train').preprocessed_dsDataTo download the data, you need to consent to the fastMRI terms listedhere.
Afterwards, you should receive an email with data download links.You can then use the environment variableFASTMRI_DATA_DIRto indicate where your fastMRI is.
This will allow you to not have to specify the path when instantiating aFastMRIDatasetBuilder.PyTorchThe PyTorch equivalent of this library is simply theofficial fastMRI repository.
In particular, thedata folderis where you find the data utils.BenchmarkYou can run the benchmark script with the following command:FASTMRI_DATA_DIR=/path/to/fastmri python benchmark.pyCurrently the benchmark gives the following output:Multi coil with tfio loading (random slice): 0.369743709564209s per-file.
Single coil with tfio loading (random slice): 0.02855397939682007s per-file.
Multi coil with h5py loading (random slice, without preprocessing): 0.010439331208042165s per-file.
Single coil with h5py loading (random slice, without preprocessing): 0.0015996736497735258s per-file.
Single coil training with tfio loading: 0.04578723907470703s per-step.You can also see the recommendation of TensorBoard regarding the single coil dataset (with a very simple model):CitationIf you use the fastMRI data or this code in your research, please consider citing the fastMRI dataset paper:@inproceedings{zbontar2018fastMRI,
  title={{fastMRI}: An Open Dataset and Benchmarks for Accelerated {MRI}},
  author={Jure Zbontar and Florian Knoll and Anuroop Sriram and Matthew J. Muckley and Mary Bruno and Aaron Defazio and Marc Parente and Krzysztof J. Geras and Joe Katsnelson and Hersh Chandarana and Zizhao Zhang and Michal Drozdzal and Adriana Romero and Michael Rabbat and Pascal Vincent and James Pinkerton and Duo Wang and Nafissa Yakubova and Erich Owens and C. Lawrence Zitnick and Michael P. Recht and Daniel K. Sodickson and Yvonne W. Lui},
  journal = {ArXiv e-prints},
  archivePrefix = "arXiv",
  eprint = {1811.08839},
  year={2018}
}
Package: tf-focal-frequency-loss
Focal Frequency Loss - Tensorflow ImplementationThis repository provides the Tensorflow implementation for the following paper:Focal Frequency Loss for Image Reconstruction and Synthesisby Liming Jiang, Bo Dai, Wayne Wu and Chen Change Loy
in ICCV 2021.Project Page|Paper|Poster|Slides|YouTube Demo|Official PyTorch ImplementationAbstract:Image reconstruction and synthesis have witnessed remarkable progress thanks to the development of generative models. Nonetheless, gaps could still exist between the real and generated images, especially in the frequency domain. In this study, we show that narrowing gaps in the frequency domain can ameliorate image reconstruction and synthesis quality further. We propose a novel focal frequency loss, which allows a model to adaptively focus on frequency components that are hard to synthesize by down-weighting the easy ones. This objective function is complementary to existing spatial losses, offering great impedance against the loss of important frequency information due to the inherent bias of neural networks. We demonstrate the versatility and effectiveness of focal frequency loss to improve popular models, such as VAE, pix2pix, and SPADE, in both perceptual quality and quantitative performance. We further show its potential on StyleGAN2.Quick StartRunpip install tf-focal-frequency-lossfor installation. Then, the following code is all you need.importtensorflowastffromtf_focal_frequency_lossimportFocalFrequencyLossasFFLffl=FFL(loss_weight=1.0,alpha=1.0)# initialize tf.keras.layers.Layer classfake=tf.random.normal((4,3,64,64))# replace it with the predicted tensor of shape (N, C, H, W)real=tf.random.normal((4,3,64,64))# replace it with the target tensor of shape (N, C, H, W)loss=ffl(fake,real)# calculate focal frequency lossLicenseAll rights reserved. The code is released under theMIT License.
Package: tf-fourier-features
Tensorflow Fourier Feature Mapping NetworksTensorflow 2.0 implementation of Fourier Feature Mapping networks from the paperFourier Features Let Networks Learn High Frequency Functions in Low Dimensional Domains.InstallationPip install$pipinstall--upgradetf_fourier_featuresPip install (test support)$pipinstall--upgradetf_fourier_features[tests]Usagefromtf_fourier_featuresimportFourierFeatureProjectionfromtf_fourier_featuresimportFourierFeatureMLP# You should use FourierFeatureProjection right after the input layer.ip=tf.keras.layers.Input(shape=[2])x=FourierFeatureProjection(gaussian_projection=256,gaussian_scale=1.0)(ip)x=tf.keras.layers.Dense(256,activation='relu')(x)x=tf.keras.layers.Dense(3,activation='sigmoid')(x)model=tf.keras.Model(inputs=ip,outputs=x)# Or directly use the model class to build a multi layer Fourier Feature Mapping Networkmodel=FourierFeatureMLP(units=256,final_units=3,final_activation='sigmoid',num_layers=4,gaussian_projection=256,gaussian_scale=10.0)Results on Image Inpainting taskA partial implementation of the image inpainting task is available as thetrain_inpainting_fourier.pyandeval_inpainting_fourier.pyscripts inside thescriptsdirectory.Weight files are made available in the repository under theReleasetab of the project. Extract the weights and place thecheckpointsfolder at the scripts directory.These weights generates the following output after 2000 epochs of training with batch size 8192 while using only 10% of the available pixels in the image during training phase.If we train for using only 20% of the available pixels in the image during training phase -If we train for using only 30% of the available pixels in the image during training phase - .Citation@misc{tancik2020fourier,
    title={Fourier Features Let Networks Learn High Frequency Functions in Low Dimensional Domains},
    author={Matthew Tancik and Pratul P. Srinivasan and Ben Mildenhall and Sara Fridovich-Keil and Nithin Raghavan and Utkarsh Singhal and Ravi Ramamoorthi and Jonathan T. Barron and Ren Ng},
    year={2020},
    eprint={2006.10739},
    archivePrefix={arXiv},
    primaryClass={cs.CV}
}RequirementsTensorflow 2.0+Matplotlib to visualize eval result
Package: tffpy
A Python package for time-frequency fading using Gabor multipliers based on
the work in paperTime-frequency fading algorithms based on Gabor
multipliersby A. Marina Krémé, Valentin Emiya, Caroline
Chaux and Bruno Torré́sani, 2020.InstallInstall the current release withpip:pip install tffpyDownload the data fromthis link.Then run functiontffpy.utils.generate_configin order to create
a configuration file and modify it to specify the path to your data folder.
The location of the configuration file is given by functiontffpy.utils.get_config_file.For additional details, see doc/install.rst.UsageSee thedocumentation.BugsPlease report any bugs that you find through thetffpy GitLab project.You can also fork the repository and create a merge request.Source codeThe source code of tffpy is available via itsGitLab project.You can clone the git repository of the project using the command:git clone git@gitlab.lis-lab.fr:skmad-suite/tff2020.gitCopyright © 2020Laboratoire d’Informatique et SystèmesUniversité d’Aix-MarseilleCentre National de la Recherche ScientifiqueUniversité de ToulonContributorsValentin EmiyaAma Marina KréméLicenseReleased under the GNU General Public License version 3 or later
(seeLICENSE.txt).
Package: tf-frodo
FRODO: Free rejection of Out-of-distribution samplesuse FRODO simply byimport model
from tf_frodo import FRODO

model_with_frodo = FRODO(model).fit(x_validation) 

results = model_with_frodo.predict(x_test)

assert results["model_outputs"] == model(x_test)
results["FRODO"] # Rejection scores for each sample in x_test
Package: tf-gen-models
Ready to use implementations of state-of-the-art generative models in TensorFlow 2InstallationDependenciestf-gen-models requires:Python (>= 3.7, < 3.10)TensorFlow (>= 2.5)Matplotlib (>= 3.4)Pillow (>= 8.0)Thetf-gen-modelspackage is built upon TensorFlow 2. See theTensorFlow install guidefor thepip packagewhile, to enable GPU support, the useDocker containeris recommended. Alternatively, GPU-enabled TensorFlow can be easily installed using thetensorflow-gpupackage onconda-forge.User installationIf you already have a working installation of TensorFlow 2 (preferably with the GPU support enabled), the easiest way to install tf-gen-models is usingpip:pipinstalltf-gen-modelsAvailable generative modelsGenerative modelsImplementationNotebooksTrendsGAN✔️🛠️VAE❌❌Norm Flow❌❌Generative Adversarial NetworksAlgorithmsImplementationConditioning*NotebooksPaperGAN✔️🛠️✔️arXiv:1406.2661BceGAN✔️❌✔️WGAN✔️❌✔️arXiv:1701.07875WGAN_GP✔️❌✔️arXiv:1704.00028CramerGAN✔️❌✔️arXiv:1705.10743WGAN_ALP✔️❌🛠️arXiv:1907.05681*Referring to theconditional versionof GANs proposed inarXiv:1411.1784.Variational AutoencoderPlanned for release v0.2.0Normalizing FlowsPlanned for release v0.2.0Jupyter notebooksMNIST generation with GANs [GAN] [BceGAN] [WGAN] [WGAN-GP] [CramerGAN]LicenseMIT License