Saravanan666/pypi-org huggingface dataset:
Package: diffusechain
🎨🔗Diffusechaindiffusechainis a code-first library that simplifies the generation of consistent and predictable stable diffusion based images. It acts as a wrapper around existing frameworks, abstracting the complexities and providing easy-to-use functionality. Whether you want to optimize prompts, generate consistent images, or manage storage,diffusechainhas got you covered.⬇️ Quick Installpipinstalldiffusechain⚙️ Core FeaturesPrompt Engine:Optimize your prompts using large language models (LLMs).Models/APIs:Easily interact with various UI platforms likeautomatic1111.Chains:Define sequences of functions for consistent results. Example: Generate consistent QR code images, consistent face generation.Pipelines:Train and fine-tune models. Generate LLMs, LORAs, and checkpoints.Storage:Integrated with various storage providers like AWS S3, Cloudinary, and many more.👨🏼‍💻UsageDiffusechainis designed to be used in conjunction withAutomatic1111andDiffusers. It makes it easier to interact with these libraries and allows you to easily automate image generation workflows.🤝 ContributingContributions are welcome! Please check out the todos below, and feel free to open a pull request. For more information, please see the contributing guidelines.📜 LicenseDiffusechainis licensed under the MIT License. See the LICENSE file for more details.AcknowledgementsThis project is built upon thediffusers,Automatic1111libraries by independent contributors, but it is in no way affiliated with these projects.In the initial development ofdiffusechain, we utilized code from thesdwebuiapiproject for one of our library components. We greatly appreciate the work done by the creators ofsdwebuiapiand would like to acknowledge their contribution to the open-source community.This project is meant to be used as a tool for prototyping and is still not ready for production use. Please use it responsibly.ContactAdithya S K -@adithya_s_kProject Link:https://github.com/adithya-s-k/diffusechain
Package: diffuse-my-lyrics
Diffuse My Lyrics!🎶 ➡ 🧠  ➡ 🖼️An easy way to generate images from lyricsDescriptionThis is a simple application that uses the spectacularStable Diffusionmodel to generate images from song lyrics.
So just install the library on a Colab notebook, choose your favorite song and sit back and wait for the visual interpretations of each verse!In the Cool Outputs section (only in repository README.md), I have shown some interpretations of verses that
I found very cool 😏😏😏How To UseFirst, simply install the python package in a colab notebook (right now, it's only for Colab,
but extending it to general use is trivial ... as long as you have a good GPU 😅 ).# Install the latest version of the package$pipinstall-Udiffuse-my-lyricsNow, suppose we want to feed the model with the following verses, belonging to The End, a magnificent piece by The Doors.Ride the King's highway, baby
Weird scenes inside the gold mine
Ride the highway west, baby
Ride the snake, ride the snake
To the lake, the ancient lake, baby
The snake is long, seven miles
Ride the snake, he's old, and his skin is coldAfter uploading this lyrics to the colab notebook (I am using a .txt extension), we just need to run the following
commands.# Import the Lyrics2Images classfromdiffuse_my_lyricsimportLyrics2Imagesl2i=Lyrics2Images(num_inference_steps=100)# In this case, we are indicating the model to run for 100 stepsl2i.run(input_path="/content/my_favourite_song.txt",output_path="my_favourite_song_folder")After runningLyrics2Images, a folder will be created in your colab current directory (my_favourite_song_folder),
where a series of images will be generated (one image for each verse of the lyrics).One it's finished, simply zip the folder and download it!!importshutilshutil.make_archive("zipped_folder",'zip',"my_favourite_song_folder")Argumentsmodel_id- The model id. By defaultCompVis/stable-diffusion-v1-4revision- The model revision. By defaultfp16torch_dtype- The Pytorch dtype. By defaulttorch.float16prompt- This parameter is useful if you want to add additional information to the verse. For example,digital art,HQ, etc. By defaultdigital artnum_inference_steps- The number of steps. By default50use_auth_token- This parameter determines whether to use an authentication token for Hugging Face. By defaultTrueNext StepsAdd support for generating several images instead of just one.Make the library usable in another environments (not just Colab)Create argument for using a manual seedAdd custom size of output images
Package: diffuser
MIT LicenseCopyright (c) 2021 diffuserPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: diffusion
# Python SDK for DiffusionPre-release version; not ready for production.The Diffusion Python library allows Python applications to interact with a Diffusion server.## Supported Python VersionsThe Diffusion Python SDK officially supports the following:Supported Interpreters:CPython 3.7.9 or laterCPython 3.8.6 or laterCPython 3.9.0 or laterSupported Platforms:MacOS 10.13-11.5Windows Intel 64-bitAny Linux supported by the [ManyLinux 2010/2014](https://github.com/pypa/manylinux) binary wheel standard.## Current CapabilitiesSession:
- Establish a session
- Send user ping
- Receive system pingMessaging:
- Register request handler
- Send request to path
- Send request to session
- Send request to filter
- Register filter message streamTopics:
- Topic subscriptions
- Topic creation
- Topic creation with initial topic value
- Topic removal
- Topic stream handlers
Package: diffusion-cbor
# Python SDK for Diffusion - CBOR encoderPre-release version; not ready for production.This is the CBOR encoding module for the [Python SDK for Diffusion](https://pypi.org/project/diffusion/).
It provides indefinite encoding which is the preferred variant of
CBOR, the binary protocol used to communicate with the Diffusion Server.## Supported Python VersionsThe Diffusion Python SDK officially supports the following:Supported Interpreters:CPython 3.7.9 or laterCPython 3.8.6 or laterCPython 3.9.0 or laterSupported Platforms:MacOS 10.13-11.5Windows Intel 64-bitAny Linux supported by the [ManyLinux 2010/2014](https://github.com/pypa/manylinux) binary wheel standard.## Current CapabilitiesCBOR:
- indefinite encoding
- definite encoding## Test call`python import diffusion_cbor obj ={"arbitary":["json","data", 0.0,-35]}diffusion_cbor.dumps(obj, indefinite=True) `
Package: diffusion-core
Python SDK for Diffusion - Core functionalityPre-release version; not ready for production.This is the core module for thePython SDK for Diffusion.
It provides core functionality for the Python client, in particular
the native bindings for various performance-critical functions.Supported Python VersionsThe Diffusion Python SDK officially supports the following:Supported Interpreters:CPython 3.7.9 or laterCPython 3.8.6 or laterCPython 3.9.0 or laterSupported Platforms:MacOS 10.13-11.5Windows Intel 64-bitAny Linux supported by theManyLinux 2010/2014binary wheel standard.Current CapabilitiesCBOR (the binary protocol used to communicate with the Diffusion Server):indefinite encoding (the preferred variant)definite encodingDelta encoding/decoding (used to send and receive changes in a compact, CBOR-based format)Test callpython
import diffusion_core.cbor as diffusion_cbor
obj = {"arbitary":["json", "data", 0.0, -35]}
diffusion_cbor.dumps(obj, indefinite=True)

import diffusion_core.delta as diffusion_delta
orig = b'\0x00'
dest = b'\0xff'
# diff returns an object which is convertible to bytes
diff = bytes(diffusion_delta.diff(orig, dest))
# patch also returns an object which is convertible to bytes
reconstructed_dest = bytes(diffusion_delta.patch(orig, diff))
assert(dest == reconstructed_dest)
Package: diffusion-modeler
Diffusion ModelerThis app does things.Table of ContentsInstallationUsageSupportContributingInstallationClone this repository withgit clone https://github.com/dgorin1/diffusion_code_finalRunpip install -e .in the root directory of the repository to install the package and its dependenciesUsageexample cli call:fit_MDD_model \
    -i path_to/diffusion_code_final/example/tests/N13ksp_python_test.csv \
    -c path_to/diffusion_code_final/example/tests/test.yaml \
    -o /Users/josh/repos/ diffusion_code_final/output/test_finalexample yaml file:ea_bounds:-50.0-500.0geometry:plane sheetlnd0aa_bounds:--5.0-60.0domains_to_model:8# number of domains to modelmisfit_stat_list:# different misfit statistics to try-chisq-l1_frac-lnd0aa_chisq-percent_frac-l1_frac_cum-l1_moles-l2_moles-l2_frac-lnd0aaomit_value_indices:[]punish_degas_early:truetemp_add:[]time_add:[]# optimization parametersrepeat_iterations:10# number of times to repeat the optimization per domain/misfit statisticseed:0tol:0.0001popsize:15updating:deferredstrategy:best1binmutation:0.5recombination:0.7max_iters:100000SupportPleaseopen an issuefor support.ContributingPlease contribute usingGithub Flow. Create a branch, add commits, andopen a pull request.
Package: diffusionq
diffusionqdiffusionqis a Python package designed for quantizing pre-trained diffusion models. By usingdiffusionq, you can efficiently quantize your models to save memory and accelerate inference, making it easier to deploy these models in resource-constrained environments.InstallationTo installdiffusionq, simply run the following command:pipinstalldiffusionqUsageUsing diffusionq is straightforward. Once you have a pre-trained diffusion model, you can quantize it by following these steps:fromdiffusionqimportQuantModel# Assuming 'model' is your pre-trained diffusion modelquant_model=QuantModel(model)# Now 'quant_model' is the quantized version of your original model# You can use 'quant_model' for your inference tasksFeaturesEasy Integration: Seamlessly quantize pre-trained diffusion models with just one line of code.
Memory Efficiency: Reduce the memory footprint of your models significantly.
Faster Inference: Enjoy faster model inference, especially beneficial for deploying models on edge devices.ContributingContributions to diffusionq are welcome! If you have suggestions for improvements or encounter any issues, please feel free to open an issue or submit a pull request.ContactFor any queries or further assistance with diffusionq, please reach out to Your Name.
Package: diffusion-sde
Diffusion SDE - A score-based generative modelling with SDEs packageSynthesize new images using the score-based generative models.InstallationCurrently,diffusion_sdesupports release of Python 3.7 onwards.To install the current release:$pipinstall-Udiffusion_sdeGetting StartedStart by instantiating a dataset class with a path where the custom dataset is locatedfromdiffusion_sdeimportdatasets# Specify the path of the custom dataset in the dataset classds=datasets(path_to_dataset)Then, instantiate thediffSDEclass to train the model and generate samples and pass the dataset using.set_loaders()methodfromdiffusion_sdeimportdiffSDE# Instantiate the diffSDE classcls_diff=diffSDE()# Set the dataloaders by passing the dataset instantiation as abovecls_diff.set_loaders(dataset=ds)Begin the model training using the.train()method and select the desired number of epochs for training.# Train the modelcls_diff.train(n_iters)Generate the samples from the trained model with the.generate_samples()method and specify the desired number of steps for the sampler. We suggest setting the value ofn_stepsin the range of $\sim1500$-$2000$ steps to produce high-quality samples# Generate samples from the trained modelcls_diff.generate_samples(n_steps)
Package: diffusionui
diffusion-ui-backendGradiobackend for thediffusion-uiweb frontend
using anunified Stable Diffusion diffusers pipelineThe gradio interface provides an API to generate images withStable Diffusionfor:text-to-imageimage-to-imageinpaintingDocumentationThe documentation is availablehereInstallationDetailled installation instructions are availablein the documentation.First installpytorchwith cuda support (if you have a NVIDIA GPU):conda install pytorch torchvision torchaudio cudatoolkit=11.6 -c pytorch -c conda-forgeThen install diffusionui and its dependencies:pipinstalldiffusionuiFirst UsageThe first time, you have to download the model:create an account onhttps://huggingface.coClick on this page to accept the LICENSEgenerate a token in your settingslogin on your console withhuggingface-cli loginthen download the model with:# using the low-memory model (for GPUs with low VRAM)diffusionui--low-mem--download-model# or using the full modeldiffusionui--download-modelUsageOnce the model has been downloaded, you can start the backend by running:# For the low-memory modeldiffusionui--low-mem# For the full modeldiffusionuiIt should produce an local URL for the gradio interface:Running on local URL:  http://127.0.0.1:7860/
Package: diffusion-weather
Diffusion WeatherInstallationThis library can be installed throughpipinstalldiffusion-weatherExample UsagePretrained WeightsComing soon! We plan to train a model on GFS 0.25 degree operational forecasts, as well as MetOffice NWP forecasts.
We also plan trying out adaptive meshes, and predicting future satellite imagery as well.Training DataTraining data will be available through HuggingFace Datasets for the GFS forecasts. The initial set of data is available forGFSv16 forecasts, raw observations, and FNL Analysis files from 2016 to 2022, and forERA5 Reanlaysis. MetOffice NWP forecasts we cannot
redistribute, but can be accessed throughCEDA.
Package: diffusive-solver
Diffusive_solver (version 3.0)Package for solving systems of coupled diffusion equations in a device setup using Finite
Element Method (FEM).
The package is based onFeniCSFEM project.A rigorous formulation of the mathematical problem and a description of the basic functionalities can be found inhttps://arxiv.org/abs/2011.04351.InstallationDiffusive_solver requires FEniCS. Please refer to the FEniCSinstallation
page.After installing FEniCS diffusive_solver can be obtained via pippip install diffusive-solveror downloaded from the projectrepository.ExamplesPlease refer to the projectrepositoryfor example notebooks.LicenseThe package diffusive_solver is distributed under the GNU Lesser General Public License v3 (LGPLv3).Cite asIf you use diffusive_solver for your research please citeI. Torre "Diffusive solver: a diffusion-equations solver based
on FEniCS" 	arXiv:2011.04351 (2020).
Package: diffusivity-step
SEAMM Diffusivity Plug-inA SEAMM plug-in for DiffusivityFree software: BSD-3-ClauseDocumentation:https://molssi-seamm.github.io/diffusivity_step/index.htmlCode:https://github.com/molssi-seamm/diffusivity_stepFeaturesPlease edit this section!AcknowledgementsThis package was created with themolssi-seamm/cookiecutter-seamm-plugintool, which
is based on the excellentCookiecutter.Developed by the Molecular Sciences Software Institute (MolSSI),
which receives funding from theNational Science Foundationunder
award CHE-2136142.History2023.9.5 – Changed default to using only MSDThe Helfand moments approach seems give incorrect results if the sampling time is
too long. It is not dramatic, but gives increasingly incorrect results as the
sampling time is increased. Thus using the Helfand moments is dangerous because
the results may be wrong, but not obviously so.2023.8.30 – Initial working versionA working version that has been tested somewhat. Further testing and documentation
will follow2023.5.8 – Initial development version createdPlug-in created using the SEAMM plug-in cookiecutter.
Package: diffusor
DiffusorA pure-python diffing utility using Google'sdiff-match-patch.This is a utility script for a very specific purpose, namely easy generation and application of diffs for Python-centric projects, programmatically from within Python.This tool serves exactly two functions:Create diffs between two versions of the same fileApply diffs to a fileIt works on a per-file basis.If you don't have a specific use case for this, you're probably better off using Git diffs and the ubiquitous Linuxpatchtool. Diffusor exists specifically for easing the patch-apply workflow within Python programs, nothing more, nothing less.InstallationDiffusor can be installed via pip:$pipinstalldiffusorPlease note that Diffusor requires Python 3 and will not provide backwards compatibility for Python 2 for the foreseeable future.UsageTo create a diff:diffusordiff<source_file><modified_file>-n<target_file>To apply a diff:diffusorapply<patch_file>-t<target_file>Command Line InterfaceUsage: diffusor.py [OPTIONS] COMMAND [ARGS]...

  A pure-python diffing utility using Google's diff-match-patch.

  This tool serves exactly two functions:
  1. Create diffs between two versions of the same file
  2. Apply diffs to a file

  Commands can be abbreviated by the shortest unique string.

  For example:
      diff -> d
      apply -> a

  Examples of full commands:
      diffusor diff <source_file> <modified_file> -n <target_file>
      diffusor apply <patch_file> -t <target_file>

Options:
  -d, --debug / -nd, --no-debug  Print debug information or only regular
                                 output

  --help                         Show this message and exit.

Commands:
  apply
  diff
Package: diffuzers
diffuzersA web ui and deployable API for🤗 diffusers.< under development, request features using issues, prs not accepted atm >If something doesnt work as expected, or if you need some features which are not available, then create request usinggithub issuesFeatures available in the app:text to imageimage to imageinstruct pix2pixtextual inversioninpaintingoutpainting (coming soon)image infostable diffusion upscalergfpganclip interrogatormore coming soon!Features available in the api:text to imageimage to imageinstruct pix2pixtextual inversioninpaintingoutpainting (via inpainting)more coming soon!InstallationTo install bleeding edge version of diffuzers, clone the repo and install it using pip.gitclonehttps://github.com/abhishekkrthakur/diffuzerscddiffuzers
pipinstall-e.Installation using pip:pipinstalldiffuzersUsageWeb AppTo run the web app, run the following command:diffuzersappAPITo run the api, run the following command:diffuzersapiStarting the API requires the following environment variables:export X2IMG_MODEL=stabilityai/stable-diffusion-2-1
export DEVICE=cudaIf you want to use inpainting:export INPAINTING_MODEL=stabilityai/stable-diffusion-2-inpaintingTo use long prompt weighting, use:export PIPELINE=lpw_stable_diffusionIf you haveOUTPUT_PATHin environment variables, all generations will be saved inOUTPUT_PATH. You can also use other (or private) huggingface models. To use private models, you must login usinghuggingface-cli login.API docs are available athost:port/docs. For example, with default settings, you can access docs at:127.0.0.1:10000/docs.All CLI Options for running the app:❯diffuzersapp--help
usage:diffuzers<command>[<args>]app[-h][--outputOUTPUT][--share][--portPORT][--hostHOST][--deviceDEVICE][--ngrok_keyNGROK_KEY]✨Rundiffuzersapp

optionalarguments:-h,--helpshowthishelpmessageandexit--outputOUTPUTOutputpathisoptional,butifprovided,allgenerationswillautomaticallybesavedtothispath.--shareSharetheapp--portPORTPorttoruntheappon--hostHOSTHosttoruntheappon--deviceDEVICEDevicetouse,e.g.cpu,cuda,cuda:0,mps(form1mac)etc.--ngrok_keyNGROK_KEYNgrokkeytouseforsharingtheapp.OnlyrequiredifyouwanttosharetheappAll CLI Options for running the api:❯diffuzersapi--help
usage:diffuzers<command>[<args>]api[-h][--outputOUTPUT][--portPORT][--hostHOST][--deviceDEVICE][--workersWORKERS]✨Rundiffuzersapi

optionalarguments:-h,--helpshowthishelpmessageandexit--outputOUTPUTOutputpathisoptional,butifprovided,allgenerationswillautomaticallybesavedtothispath.--portPORTPorttoruntheappon--hostHOSTHosttoruntheappon--deviceDEVICEDevicetouse,e.g.cpu,cuda,cuda:0,mps(form1mac)etc.--workersWORKERSNumberofworkerstouseUsing private models from huggingface hubIf you want to use private models from huggingface hub, then you need to login usinghuggingface-cli logincommand.Note: You can also save your generations directly to huggingface hub if your output path points to a huggingface hub dataset repo and you have access to push to that repository. Thus, you will end up saving a lot of disk space.
Package: diffwave
DiffWaveDiffWave is a fast, high-quality neural vocoder and waveform synthesizer. It starts with Gaussian noise and converts it into speech via iterative refinement. The speech can be controlled by providing a conditioning signal (e.g. log-scaled Mel spectrogram). The model and architecture details are described inDiffWave: A Versatile Diffusion Model for Audio Synthesis.What's new (2021-04-01)fast sampling algorithm based on v3 of the DiffWave paperWhat's new (2020-10-14)new pretrained model trained for 1M stepsupdated audio samples with output from new modelStatus (2021-04-01)fast inference procedurestable traininghigh-quality synthesismixed-precision trainingmulti-GPU trainingcommand-line inferenceprogrammatic inference APIPyPI packageaudio samplespretrained modelsunconditional waveform synthesisBig thanks toZhifeng Kong(lead author of DiffWave) for pointers and bug fixes.Audio samples22.05 kHz audio samplesPretrained models22.05 kHz pretrained model(31 MB, SHA256:d415d2117bb0bba3999afabdd67ed11d9e43400af26193a451d112e2560821a8)This pre-trained model is able to synthesize speech with a real-time factor of 0.87 (smaller is faster).Pre-trained model detailstrained on 4x 1080Tidefault parameterssingle precision floating point (FP32)trained on LJSpeech dataset excluding LJ001* and LJ002*trained for 1000578 steps (1273 epochs)InstallInstall using pip:pip install diffwaveor from GitHub:git clone https://github.com/lmnt-com/diffwave.git
cd diffwave
pip install .TrainingBefore you start training, you'll need to prepare a training dataset. The dataset can have any directory structure as long as the contained .wav files are 16-bit mono (e.g.LJSpeech,VCTK). By default, this implementation assumes a sample rate of 22.05 kHz. If you need to change this value, editparams.py.python -m diffwave.preprocess /path/to/dir/containing/wavs
python -m diffwave /path/to/model/dir /path/to/dir/containing/wavs

# in another shell to monitor training progress:
tensorboard --logdir /path/to/model/dir --bind_allYou should expect to hear intelligible (but noisy) speech by ~8k steps (~1.5h on a 2080 Ti).Multi-GPU trainingBy default, this implementation uses as many GPUs in parallel as returned bytorch.cuda.device_count(). You can specify which GPUs to use by setting theCUDA_DEVICES_AVAILABLEenvironment variable before running the training module.Inference APIBasic usage:fromdiffwave.inferenceimportpredictasdiffwave_predictmodel_dir='/path/to/model/dir'spectrogram=# get your hands on a spectrogram in [N,C,W] formataudio,sample_rate=diffwave_predict(spectrogram,model_dir,fast_sampling=True)# audio is a GPU tensor in [N,T] format.Inference CLIpython -m diffwave.inference --fast /path/to/model /path/to/spectrogram -o output.wavReferencesDiffWave: A Versatile Diffusion Model for Audio SynthesisDenoising Diffusion Probabilistic ModelsCode for Denoising Diffusion Probabilistic Models