Saravanan666/pypi-org huggingface dataset:
Package: jaxa
JAXA - Jira And Xray APIThis is not intended to be a fully functioning complete API client module for Jira & Xray.
One day it may be.
For now it merely meets the criteria I need it to offer.ConfigurationEnvironment Variable ConfigurationEnvironment VariableDescriptionJAXA_JIRA_BASEURLURL for Jira Cloud. E.g.https://example.atlassian.netJAXA_JIRA_USERNAMEEmail address of user for connecting to JiraJAXA_JIRA_APITOKENAPI Token of user for connecting to JiraJAXA_JIRA_CLIENT_IDClient ID for accessing Jira XrayJAXA_JIRA_CLIENT_SECRETClient Secret for accessing Jira XrayJAXA_XRAY_BASEURLURL for XRay Cloud. E.g.https://xray.cloud.getxray.app/api/v1JAXA_PROJECT_IDID of Jira ProjectJAXA_PROJECT_NAMEName of Jira ProjectUsageTestsWarning: These tests will create tickets in Jira# Run all functional tests against supported python versions via noxpoetryrunrun-tests#poetryrunnox-sfunctional_tests-3.8

poetryrunnox-sjira_issues-3.8
Package: jaxampler
Jaxampler 🧪 - A JAX-based statistical sampling toolkitJaxampler 🧪 is a statistical sampling toolkit built on top of JAX. It provides a set of high-performance sampling
algorithms for a wide range of statistical distributions. Jaxampler is designed to be easy to use and integrate with
existing JAX workflows. It is also designed to be extensible, allowing users to easily add new sampling algorithms and
statistical distributions.Jaxampler is currently in the early stages of development and is not yet ready for production use. However, we welcome
contributions from the community to help us improve the library. If you are interested in contributing, please refer to
ourcontribution guidelines.Features🚀High-Performance Sampling: Leverage the power of JAX for high-speed, accurate sampling.🧩Versatile Algorithms: A wide range of sampling methods to suit various applications.🔗Easy Integration: Seamlessly integrates with existing JAX workflows.InstallYou may install the latest released version of Jaxampler through pip by doingpip3install--upgradejaxamplerYou may install the bleeding edge version by cloning this repo, or doingpip3install--upgradegit+https://github.com/Qazalbash/jaxamplerIf you would like to take advantage of CUDA, you will additionally need to install a specific version of JAX by doingpipinstall--upgrade"jax[cuda12_pip]"-fhttps://storage.googleapis.com/jax-releases/jax_cuda_releases.htmlRequirementsJaxampler requires Python 3.10 or later. It also requires the following packages:jax>=0.4.0jaxlib>=0.4.0
typing_extensions>=4.5.0
jaxtyping>=0.2.24
matplotlib>=3.8.0
tfp-nightly
tqdmThe test suite is based onpytest. To run the tests, one needs to install pytest and runpytestat the root
directory of this repo.Algorithms and DistributionsJaxampler currently supports the following algorithms and distributions:Monte Carlo MethodsHamiltonian Monte CarloImportance SamplingMetropolis Adjusted Langevin AlgorithmMonte Carlo Box IntegrationMonte Carlo IntegrationMultiple-Try MetropolisSequential Monte CarloVariational InferenceWang-Landau SamplingWorm AlgorithmSamplersAccept-Rejection SamplerAdaptive Accept-Rejection SamplerGibbs SamplerHastings SamplerInverse Transform SamplerMetropolis-Hastings SamplerSlice SamplerRandom VariablesBernoulliBetaBinomialBoltzmannCauchyChiExponentialGammaGeometricGumbelLaplaceLog NormalLogisticMultivariate NormalNormalParetoPoissonRademacherRayleighStudent tTriangularTruncated NormalTruncated Power LawUniformWeibullCiting JaxamplerTo cite this repository:@software{jaxampler2023github,author={Meesum Qazalbash},title={{Jaxampler}: A JAX-based statistical sampling toolkit},url={https://github.com/Qazalbash/jaxampler},version={0.0.7},year={2023}}Contributors
Package: jax-backend
jax-backendA JAX backendWARNING: This repo is in development. It was automatically generated withmkpylib. If you're reading this message, it means that I use this repo for my own purposes right now. It might not do anything at all; the default functionality isprint('TODO').If you really want to try it out, feel free. I recommend reading through thetestsand commit history to see if it does what you need, orask mefor status updates.Stay tuned!Installpip3 install -U jax-backendOr develop locally:git clone https://github.com/shawwn/jax-backend ~/jax-backend
cd ~/jax-backend
python3 setup.py developUsageimportjax_backendprint('TODO')LicenseMIT. SeeLICENSEfile.ContactA library byShawn Presser. If you found it useful, please considerjoining my patreon!My Twitter DMs are always open; you shouldsend me one! It's the best way to reach me, and I'm always happy to hear from you.Twitter:@theshawwnPatreon:https://www.patreon.com/shawwnHN:sillysaurusxWebsite:shawwn.com
Package: jax-bitempered-loss
Bi-Tempered Logistic LossOverview of the method is here:Google AI BlogpostAlso, explore the interactivevisualizationthat demonstrates the practical properties of the Bi-Tempered logistic loss.Bi-Tempered logistic loss is a generalized softmax cross-entropy loss function with bounded loss value per sample and a heavy-tail softmax probability function.Bi-tempered loss generalizes (with a bias correction term):Zhang & Sabuncu. "Generalized cross entropy loss for training deep neural networks with noisy labels." In NeurIPS 2018.which is recovered when 0.0 <= t1 <= 1.0 and t2 = 1.0. It also includes:Ding & Vishwanathan. "t-Logistic regression." In NeurIPS 2010.for t1 = 1.0 and t2 >= 1.0.Bi-tempered loss is equal to the softmax cross entropy loss when t1 = t2 = 1.0. For 0.0 <= t1 < 1.0 and t2 > 1.0, bi-tempered loss provides a more robust alternative to the cross entropy loss for handling label noise and outliers.TensorFlow and JAXA replacement for standard logistic loss function:tf.losses.softmax_cross_entropyis availableheredefbi_tempered_logistic_loss(activations,labels,t1,t2,label_smoothing=0.0,num_iters=5):"""Bi-Tempered Logistic Loss with custom gradient.Args:activations: A multi-dimensional tensor with last dimension `num_classes`.labels: A tensor with shape and dtype as activations.t1: Temperature 1 (< 1.0 for boundedness).t2: Temperature 2 (> 1.0 for tail heaviness, < 1.0 for finite support).label_smoothing: Label smoothing parameter between [0, 1).num_iters: Number of iterations to run the method.Returns:A loss tensor."""Replacements are also available for the transfer functions:Tempered version of tf.nn.sigmoid and jax.nn.sigmoid:deftempered_sigmoid(activations,t,num_iters=5):"""Tempered sigmoid function.Args:activations: Activations for the positive class for binary classification.t: Temperature > 0.0.num_iters: Number of iterations to run the method.Returns:A probabilities tensor."""Tempered version of tf.nn.softmax and jax.nn.softmax:deftempered_softmax(activations,t,num_iters=5):"""Tempered softmax function.Args:activations: A multi-dimensional tensor with last dimension `num_classes`.t: Temperature > 0.0.num_iters: Number of iterations to run the method.Returns:A probabilities tensor."""CitationWhen referencing Bi-Tempered loss, cite thispaper:@inproceedings{amid2019robust,
  title={Robust bi-tempered logistic loss based on bregman divergences},
  author={Amid, Ehsan and Warmuth, Manfred KK and Anil, Rohan and Koren, Tomer},
  booktitle={Advances in Neural Information Processing Systems},
  pages={15013--15022},
  year={2019}
}ContributionsWe are eager to collaborate with you too! Please send us a pull request or open a github issue. Please see this doc for furtherdetails
Package: jaxcam
jaxcamJaxcam is a camera library for JAX. Jaxcam is designed to accelerate research by
abstracts cameras and common operations through a simple API.This is not an officially supported Google product.Usage ExamplesBasic importsfromjaximportnumpyasjnpfromjaximportrandomimportjaxcamCreating a camera:>>camera=jaxcam.Camera.create(orientation=jnp.eye(3),position=jnp.array([0.0,0.0,5.0]),image_size=jnp.array([512,512]),focal_length=jnp.array(512))>>cameraCamera(orientation=Array([[1.,0.,0.],[0.,1.,0.],[0.,0.,1.]],dtype=float32),position=Array([0.,0.,5.],dtype=float32),focal_length=Array(512.,dtype=float32),principal_point=Array([256.,256.],dtype=float32),image_size=Array([512.,512.],dtype=float32),skew=Array(0.,dtype=float32),pixel_aspect_ratio=Array(1.,dtype=float32),radial_distortion=None,tangential_distortion=None,projection_type=<ProjectionType.PERSPECTIVE:'perspective'>,use_inverted_distortion=False)Projecting 3D world points to camera pixels:>>points=random.normal(random.PRNGKey(0),(5,3))>>pixels=jaxcam.project(camera,points)>>pixelsArray([[246.76802,48.151352],[157.49011,226.61935],[198.61266,347.66937],[311.53983,178.945],[281.20334,342.3573]],dtype=float32)
Package: jax-chmc
jax_chmcAn implementation of a family of MCMC methods on implicitly defined manifoldsThe api is similar to the one fromblackjaxbut is slightly simplified, and closer to the original MATLABimplementationby @mbrubake .Project Statusjax_chmcis still in its early phase. We are actively improving various software components.
It is still quite far from ready for everyday use and is made
available without any support at the moment.InstallationYou can install jax_chmc viapip:$pipinstalljax_chmcDevelopmentTo develop and modify jax_chmc, you need to installhatch, a tool for Python packaging and
dependency management.To  enter a virtual environment for testing or debugging, you can run:$hatchshellRunning testsGsd usesPytestfor testing. To run the tests, use the following command:$ hatch run test
Package: jax-codex
CoDeXCoDeX contains learned data compression tools for JAX.You can use this library to build your own ML models with end-to-end optimized
data compression built in. It's useful to find storage-efficient representations
of your data (images, features, examples, etc.) while only sacrificing a small
fraction of model performance.For a more in-depth introduction from a classical data compression perspective,
consider ourpaper on nonlinear transform
coding, or watch @jonycgn'stalk on learned
image compression. For an
introduction to lossy data compression from a machine learning perspective, take
a look at @yiboyang'sreview paper.Documentation & getting helpPlease post all questions or comments onDiscussions. Only fileIssuesfor actual bugs or feature
requests. On Discussions, you may get a faster answer, and you help other people
find the question or answer more easily later.InstallationTo install CoDeX viapip, run the following command:pipinstalljax-codexTo test that the installation works correctly, you can run the unit tests with:python-mcodex.all_testsOnce the command finishes, you should see a message13 passed in 2.76sor
similar in the last line.UsageWe recommend importing the library from your Python code as follows:importcodexascdxCitationIf you use this library for research purposes, please cite:@software{codex_github,
  author = "Ballé, Johannes and Hwang, Sung Jin and Agustsson, Eirikur",
  title = "{CoDeX}: Learned Data Compression in {JAX}",
  url = "http://github.com/google/codex",
  version = "0.0.1",
  year = "2022",
}In the above BibTeX entry, names are top contributors sorted by number of
commits. Please adjust version number and year according to the version that was
actually used.Note that this is not an officially supported Google product.
Package: jax-control-algorithms
controlAlgorithmsAlgorithms at the boundary of control and machine learning inJAX.This package contains routines for (feedback) control of dynamic systems and considersthe identification of dynamic systems from input/output data (learning parameters of ordinary differential equations),state estimation from input/output data with optional parameter learning, andmodel-based trajectory optimization and planning of nonlinear systems under inequality constraints.The advantage of using JAX as an underlying basis is the automatic differentiation feature. Thus, gradients no not need to be (but can) provided by the code the implements the system models. Further, the optimization libraryjaxoptis used for solving non-linear optimization problems. The routines can be jit-compiled for improved runtime performance.A typical control system that involves state estimation (optionally sensor fusion) and feedback control.Installationpip install jax-control-algorithmsLocal development install - clone repository and runpip install -e .ContentsSystem identificationA (basic) least squares-based implementation for the identification of non-linear systems implemented is provided. Herein, an ODE solver and the system model are embedded in a non-linear optimization process.An example notebook describing the identification for a pendulum is providedhttps://nbviewer.org/github/christianausb/controlAlgorithms/blob/main/examples/sysident.ipynbState trajectory estimation and system identificationA routine for estimating the state trajectory and system parameters from input/output data and a prototype model is provided.The following example demonstrates the estimation of a pendulum system using video-only data:https://nbviewer.org/github/christianausb/controlAlgorithms/blob/main/examples/state_est_pendulum.ipynbPendulum motion estimation from video recordingsThis experiment demonstrates how to combine state and parameter estimation with a deep neural autoencoder to estimate motion trajectories from video-recordings.https://github.com/christianausb/controlAlgorithms/tree/main/examples/pendulum_finderhttps://user-images.githubusercontent.com/4620523/223825323-2aa7c9f7-8d85-4b3c-aae0-8115737d95b7.mp4Trajectory optimizationA routine that implements a variant of the collocation method is provided. To ensure inequality constraints, the penality method is implemented.https://github.com/christianausb/controlAlgorithms/tree/main/examples/trajectory_optim_cart_pendulum.ipynbA solution for the pendulum-cart benchmark is shown below. Herein, the control task is to swing-up the pendulum by controlling the cart motion.https://github.com/christianausb/controlAlgorithms/assets/4620523/27e42c6d-ac39-4cbe-b7f3-5f5f7bb1b127
Package: jax-cosmo
jax-cosmoFinally a differentiable cosmology library, and it's in JAX!Have a look at theGitHub issuesto see what is needed or if you have any thoughts on the design, and don't hesitate to join theGitter roomfor discussions.TL;DRThis is whatjax-cosmoaims to do:...deflikelihood(cosmo):# Compute mean and covariance of angular Cls, for specific probesmu,cov=jax_cosmo.angular_cl.gaussian_cl_covariance_and_mean(cosmo,ell,probes)# Return likelihood valuereturnjax_cosmo.likelihood.gaussian_log_likelihood(data,mu,cov)# Compute derivatives of the likelihood with respect to cosmological parametersg=jax.grad(likelihood)(cosmo)# Compute Fisher matrix of cosmological parametersF=-jax.hessian(likelihood)(cosmo)This is how you can computegradients and hessians of any functions injax-cosmo,
all of this without any finite differences.Check out a full example here:Have a look at thedesign documentto learn more about the structure of the code.What is JAX?JAX= NumPy + autodiff + GPUJAX is a framework for automatic differentiation (like TensorFlow or PyTorch) but following the NumPy API, and using the GPU/TPU enable XLA backend.What does that mean?You write plain Python/NumPy code, no need to learn a different languageIt runs on GPU, you don't need to do anything particularYou can take derivatives of any quantity with respect to any parameters by
automatic differentiation.Checkout theJAXproject page to learn more!Installjax-cosmois pure Python, so installing is a breeze:$pipinstalljax-cosmoPhilosophyHere are some of the design guidelines:Implementation of equations should be human readable, and documentation should always live next to the implementation.Should always be trivially installable: external dependencies should be kept
to a minimum, especially the ones that require compilation or with restrictive licenses.Keep API and implementation simple and intuitive, minimize user and developer
surprise.“Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.” -Brian Kernighan, quote stolen fromhere.Contributingjax-cosmoaims to be a community effort, contributions are most welcome and
can come in several formsBug reportsAPI design suggestions(Pull) requests for more featuresExamples and notebooks of cool things that can be done with the codeYou can chime-in on any aspects of the design by proposing a PR to thedesign document. The issue page is a good place to start, but don't hesitate to come chat in the Gitter room.Please take a look at theContributing Documentfor more information.This project follows theAll Contributorsguidelines aiming at recognizing and valorizing
contributions at any levels.Contributors ✨Thanks goes to these wonderful people (emoji key):Francois Lanusse💻Santiago Casas🐛💻Austin Peel💻Minas Karamanis💻David Kirkby💻🐛Alexandre Boucaud💻Denise Lanzieri💻jecampagne🐛Yin Li💻🐛This project follows theall-contributorsspecification. Contributions of any kind welcome!
Package: jax-dimenet
Jax-DimeNet++Haiku implementation of theDimeNet++ architecture.Getting startedThis repository provides 2 interfaces for the DimeNet++ model. The first
interface allows using DimeNet++ as aJax M.D.energy_fnto run molecular
dynamics simulations. The second interface allows prediction of global molecular
properties.fromjax_dimenetimportdimenet,sparse_graph# Jax M.D. energy function:init_fn,dimenet_energy_fn=dimenet.energy_neighborlist(displacement_fn,r_cut)init_params=init_fn(random.PRNGKey(0),positions,neighbor=neighbors)energy_fn=partial(dimenet_energy_fn,init_params)# jax_md energy_fn interfaceprint('Predicted energy:',energy_fn(positions,neighbors))# Molecular property prediction:mol_graph,_=sparse_graph.sparse_graph_from_neighborlist(displacement_fn,positions,neighbors,r_cut)init_fn,property_predictor=dimenet.property_prediction(r_cut,n_targets=5)init_params=init_fn(random.PRNGKey(0),mol_graph)print('Predicted properties:',property_predictor(init_params,mol_graph))A minimum usage example is available in thenotebooks folder. For
more real-world applications of the DimeNet++ model in MD simulations, please
refer to theDiffTRerepository.InstallationYou can install Jax-DimeNet++ via pip:pip install jax-dimenetRequirementsThe repository uses the following packages:MDAnalysis
    jax>=0.2.12
    jaxlib>=0.1.65
    jax-md>=0.1.13
    dm-haiku>=0.0.4
    sympy
    chexThe code was run with Python 3.8.ContributionContributions are always welcome! Please open a pull request to discuss the code
additions.ContactFor questions, please contactstephan.thaler@tum.de.CitationIf you use this code in your own work, please consider citing the paper that
introduced this DimeNet++ implementation,@article{thaler_difftre_2021,
  title = {Learning neural network potentials from experimental data via Differentiable Trajectory Reweighting},
  author = {Thaler, Stephan and Zavadlav, Julija},
  journal={Nature Communications},
  volume={12},
  pages={6884},
  doi={10.1038/s41467-021-27241-4}
  year = {2021}
}as well as the original DimeNet++ paper.@inproceedings{klicpera_dimenetpp_2020,
  title = {Fast and Uncertainty-Aware Directional Message Passing for Non-Equilibrium Molecules},
  author = {Klicpera, Johannes and Giri, Shankari and Margraf, Johannes T. and G{\"u}nnemann, Stephan},
  booktitle={NeurIPS-W},
  year = {2020}
}
Package: jaxdl
JAXDL: JAX (Flax) Deep Learning LibraryClean state-of-the-art JAX/Flax deep learning algorithm implementations:Soft-Actor-Critic (SAC) (arXiv:1812.05905)Twin-Delayed DDPG (TD3) (arXiv:1802.09477)Transformer (arXiv:1706.03762; planned)Unified Graph Network Blocks (arXiv:1806.01261; planned)If you use JAXDL in your work, please cite this repository as follows:@misc{jaxdl,
  author = {Hart, Patrick},
  month = {10},
  doi = {10.5281/zenodo.5596512},
  title = {{JAXDL: JAX Deep Learning Algorithm Implementations.}},
  url = {https://github.com/patrickhart/jaxdl},
  year = {2021}
}Results / BenchmarkContinous Control From StatesHalfCheetah-v2Ant-v2Reacher-v2Humanoid-v2InstallationInstall JAXDL using PyPipip install jaxdl.To use MuJoCo 2.1 you need to runpip install git+https://github.com/nimrod-gileadi/mujoco-pyand place the binaries of MuJoCo in~/.mujoco/mujoco210.Examples / Getting StartedTo get started have a look in theexamples folder.To train a reinforcement learning agent runpythonexamples/run_rl.py\--mode=train\--env_name=Ant-v2\--save_dir=./tmp/\--config=./examples/configs/sac_config.pyTo visualize the trained agent usepythonexamples/run_rl.py\--mode=visualize\--env_name=Ant-v2\--save_dir=./tmp/\--config=./examples/configs/sac_config.pyTensorboardMonitor the training run using:tensorboard--logdir=/save_dir/ContributingContributions are welcome!
This repository is meant to provide clean and simple implementations – please consider this when contributing.
Package: jaxdsp
JAXdspFast, differentiable audio processors on the CPU or GPU, controlled from the browser.I'm still working on improvements and an interactive browser client, after which I'll write up a blog post.
In the meantime, thedocsdirectory has several Jupyter notebooks with plenty of examples.
TheDifferentiable Audio Processorsnotebook shows many real DSP examples, along with loss/parameter time-series.(All files underdocs/scratchare working notes, and can be ignored.)g
The goal of this project is to parameterize audio graphs, in real-time, to produce an audio stream resembling incoming audio.Built withJAX, WebRTC, WebSockets, and React.react-three-fiberprovides the WebGL backbone for
performant real-time clientside monitoring of the system.ServerDockerTo build and run the server in a Linux container:$dockerbuild.-tjaxdsp_server
$dockerrun-p8080:8080jaxdsp_server$cdserver
$pythonserver.pyClientNote:For local development of the client within the test/app(see below), the client is included as a
localfile:../clientdependency, and included in the babel transpilation for the/appbuild (
seeapp/craco.config.js).build:devin the client just symlinks thedist/jaxdsp-client.jstarget to the rootindex.jsfile.$cdclient
$npmci
$npmrunbuild# or, for a development build: `build:dev`App$cdapp
$npmci
$npmstart
Package: jax-enums
JAX_ENUMSInstallation|Examples|CiteA Jax-compatible enumerable.Installationpipinstalljax_enumsExampleclassFoo(Enumerable):BAR=0BAZ=1deff(array:jax.Array,enumerable:Enum)->jax.Array:returnarray[enumerable.value]array=jnp.zeros((2,2))enumerable=Foo.BARf(array,enumerable)jax.jit(f)(array,enumerable)Cite@misc{pignatelli2023jax_enums,
  author = {Pignatelli, Eduardo},
  title = {JAX_ENUMS: JAX-compatible enumerations},
  year = {2023},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/epignatelli/jax_enums}}
  }
Package: jax-f16
Jax F16 DynamicsInstallation•Quickstart•CitationsInstallationMake surejaxandjaxtypingare installed.
Then, either install from PyPIpipinstalljax-f16or install from githubpipinstall--upgradegit+https://github.com/mit-realm/jax-f16.gitQuickstartfromjax_f16.f16importF16f16=F16()x,u=f16.trim_state(),f16.trim_control()assertx.shape==(F16.NX,)andu.shape==(F16.NU,)xdot=f16.xdot(x,u)CitationsIf you would like to usejax-f16in a publication, please cite our paper for this implementation@inproceedings{So-RSS-23,AUTHOR={Oswin So AND Chuchu Fan},TITLE={{Solving Stabilize-Avoid Optimal Control via Epigraph Form and Deep Reinforcement Learning}},BOOKTITLE={Proceedings of Robotics: Science and Systems},YEAR={2023},}as well as the paper for the original implementation@inproceedings{heidlauf2018verification,title={Verification Challenges in F-16 Ground Collision Avoidance and Other Automated Maneuvers.},author={Heidlauf, Peter and Collins, Alexander and Bolender, Michael and Bak, Stanley},booktitle={ARCH@ ADHS},pages={208--217},year={2018}}