Saravanan666/pypi-org huggingface dataset:
Package: evops
EVOPS: library for evaluating plane segmentation algorithmsEVOPS is an open-source python library that provides various metrics for evaluating the results of the algorithms for segmenting and associating planes from point clouds collected from LIDARs and RGBD devices.List of metrics implemented in the library:Summary segmentation metricsPanopticFull statisticsInstance-based segmentation metricsPrecisionRecallF-ScoreUnder segmented ratioOver segmented ratioNoise ratioMissed ratioPoint-based segmentation metricsIntersection over Union (IoU)DiceMean of some metric for matched instancesFor more, please visit theEVOPS documentation.You can also find full information about the project on theEVOPS project website.Python quick startLibrary can be installed using the pip package manager:$# Install package$pipinstallevops

$# Check installed version of package$pipshowevopsExample of usageBelow is an example of using the precision metric:>>>fromevops.metricsimportprecision
>>>pred_labels=np.array([1,1,3,3])>>>gt_labels=np.array([2,2,0,3])>>>tp_condition="iou">>>precision(pred_labels,gt_labels,tp_condition)0.5Citation@misc{kornilova2022evops,
      title={EVOPS Benchmark: Evaluation of Plane Segmentation from RGBD and LiDAR Data}, 
      author={Anastasiia Kornilova, Dmitrii Iarosh, Denis Kukushkin, Nikolai Goncharov, Pavel Mokeev, Arthur Saliou, Gonzalo Ferrer},
      year={2022},
      eprint={2204.05799},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}LicenseThis project is licensed under the Apache License - see theLICENSEfile for details.
Package: evopy
evopyEvolutionary Strategies made simple!Use evopy to easily optimize a vector of floats in Python.🏗 InstallationAll you need to use evopy isPython 3! Run this command to fetch evopy from PyPI:pip install evopyThen you can importEvoPylike this:fromevopyimportEvoPy⏩ UsageOne-Dimensional ExampleLet's say we wanted to find the optimum of a parabola, without using exact methods from calculus! With Evopy, this is as easy as writing the following two lines:evopy=EvoPy(lambdax:pow(x,2),1)best_coordinates=evopy.run()The main ingredient here is the fitness function (the lambda). This can also be a normal function reference, just make sure that it accepts a float or an array of floats and outputs a single float. The other ingredient is the1at the end of the first line: This is the dimensionality of the inputs that you expect in your fitness function.best_coordinateswill contain an array with a single element, which is the bestxvalue the algorithm could find in the default number of generations.Multi-Dimensional ExampleIf the previous example seemed too simple to you, we can also look at the optimum of a more complex, two-dimensional function, like theRastrigin function. We don't have to modify much in our previous code snippet to get this to work:evopy=EvoPy(lambdaX:5+sum([(x**2-5*np.cos(2*np.pi*x))forxinX]),2,generations=1000,population_size=100)best_coordinates=evopy.run()Compared to the first example, we have interchanged the fitness function for a more complex one, set the dimensionality to2, and given the algorithm more time to find an optimum by setting a higher generation and individual count than the default.DocsFor more detailed information on evopy's functionality, have a look atthe docs!⛏ DevelopmentClone this repositoryand fetch all dependencies from within the cloned directory:pip install -r requirements.dev.txtRun all tests with:nosetestsTo check your code style, run:pylint evopyTo measure your code coverage, run:nosetests --with-coverage --cover-package=evopy --cover-html --cover-branches --cover-erase
Package: evo-pyzipper
pyzipperA 100% API compatible replacement for Python’szipfilethat can read and write AES encrypted zip files.
Callback function added to extracting zipfilesInstallationpipinstallpyzipperUsageimportpyzippersecret_password=b'lost art of keeping a secret'withpyzipper.AESZipFile('new_test.zip','w',compression=pyzipper.ZIP_LZMA,encryption=pyzipper.WZ_AES)aszf:zf.setpassword(secret_password)zf.writestr('test.txt',"What ever you do, don't tell anyone!")withpyzipper.AESZipFile('new_test.zip')aszf:zf.setpassword(secret_password)my_secrets=zf.read('test.txt')AES StrengthThe strength of the AES encryption can be configure to be 128, 192 or 256 bits.
By default it is 256 bits. Use thesetencryption()method to specify the
encryption kwargs:importpyzippersecret_password=b'lost art of keeping a secret'withpyzipper.AESZipFile('new_test.zip','w',compression=pyzipper.ZIP_LZMA)aszf:zf.setpassword(secret_password)zf.setencryption(pyzipper.WZ_AES,nbits=128)zf.writestr('test.txt',"What ever you do, don't tell anyone!")withpyzipper.AESZipFile('new_test.zip')aszf:zf.setpassword(secret_password)my_secrets=zf.read('test.txt')DocumentationOfficial Python ZipFile documentation is available here:https://docs.python.org/3/library/zipfile.htmlCreditsThe docs skeleton was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: evoque
Evoque is a lightweight full-featured generic text templating engine for python
with sandbox-ability, versatility and simplicity as key feature priorities.
Plus: no source file format constraints; internal processing is exclusively in
unicode; dynamic template inheritance; very simple way for templates to address,
call and transfer evaluation context; template managed in collections, each with
own settings; small footprint, with less than 1K SLOC; extremely fast.Evoque may be used stand-alone just as well as within any web application
framework, such asPylons,Django,QP.
Package: evosegment
evoSegmentThis is a tool to segment microstructural evolution from 4D tomography data (or other image data).The method is based on clustering of a 2D histogram built from the intensities in a reference state and in an evolved state.InstallationThe easiest is to install the package from PyPI usingpython3 - m pip install evosegmentIt is also possible to clone the repository, build and install a local wheel. Something like this might work:git clone https://gitlab.com/jhektor/evoSegment.git
 cd evoSegment
 python3 -m build
 python3 -m pip install -e .Using this approach will install the package in an editable way so that any changes you make to the code are reflected without reinstalling.UsageHave a look at theexample.ipynb!LicenseThis software is licensed under the GNU General Public Licence v3.0 or later.SupportSend an email tojohan.hektor@mau.seor open an issue ongitlabif you have any questions.
Package: evo-spotis
EVO-SPOTISThis is Python 3 library for multi-criteria decision analysis with decision-maker preference identification based on historical datasets.InstallationDownloading and installation ofevo_spotispackage can be done using pippip install evo-spotisMethods providedmcda_methodsmodule includes:spotiswith SPOTIS method (the Stable Preference Ordering Towards Ideal Solution method)stochastic_algorithmsmodule includes:DE algorithmDE_algorithm(the Differential Evolution algorithm)The DE algorithm is applied for the identification of criteria weights (decision-maker preferences) based on a training dataset with evaluated alternatives,
including alternatives performances (training features) and their ranking (target variable). The goal (fitness) function uses the correlation coefficient
of predicted ranking with real ranking. The predicted ranking is generated using the SPOTIS method and weights calculated by the DE algorithm in each DE iteration.
It is a profit function. Therefore, higher values denote better results. Examples of use ofevo_spotisare included onGitHubinexamplesOther modules:additionsincludingrank_preferencemethod for ranking alternatives according to MCDA score.correlationscontaining:Spearman rank correlation coefficientspearman,Weighted Spearman rank correlation coefficientweighted_spearman,Pearson correlation coefficientpearson_coeff.normalizationswith methods for decision matrix normalization:linear_normalization- Linear normalization,minmax_normalization- Minimum- Maximum normalization,max_normalization- Maximum normalization,sum_normalization- Sum normalization,vector_normalization- Vector normalization.weighting_methodscontaining:entropy_weighting- Entropy objective weighting method.LicenseThe evo-spotis library is licensed under the terms of the MIT license.DocumentationDocumentation of this library with instruction for installation and usage is providedhere
Package: evostra
Evostra: Evolution Strategy for Python--------Evolution Strategy (ES) is an optimization technique based on ideas of adaptation and evolution.You can learn more about it at https://blog.openai.com/evolution-strategies/Installation--------It's compatible with both python2 and python3.Install from source:.. code-block:: bash$ python setup.py installInstall latest version from git repository using pip:.. code-block:: bash$ pip install git+https://github.com/alirezamika/evostra.gitInstall from PyPI:.. code-block:: bash$ pip install evostra(You may need to use python3 or pip3 for python3)Sample Usages--------`An AI agent learning to play flappy bird using evostra<https://github.com/alirezamika/flappybird-es>`_`An AI agent learning to walk using evostra<https://github.com/alirezamika/bipedal-es>`_How to use--------The input weights of the EvolutionStrategy module is a list of arrays (one array with any shape for each layer of the neural network), so we can use any framework to build the model and just pass the weights to ES.For example we can use Keras to build the model and pass its weights to ES, but here we use Evostra's built-in model FeedForwardNetwork which is much faster for our use case:.. code:: pythonimport numpy as npfrom evostra import EvolutionStrategyfrom evostra.models import FeedForwardNetwork# A feed forward neural network with input size of 5, two hidden layers of size 4 and output of size 3model = FeedForwardNetwork(layer_sizes=[5, 4, 4, 3])Now we define our get_reward function:.. code:: pythonsolution = np.array([0.1, -0.4, 0.5])inp = np.asarray([1, 2, 3, 4, 5])def get_reward(weights):global solution, model, inpmodel.set_weights(weights)prediction = model.predict(inp)# here our best reward is zeroreward = -np.sum(np.square(solution - prediction))return rewardNow we can build the EvolutionStrategy object and run it for some iterations:.. code:: python# if your task is computationally expensive, you can use num_threads > 1 to use multiple processes;# if you set num_threads=-1, it will use number of cores available on the machine; Here we use 1 process as the#  task is not computationally expensive and using more processes would decrease the performance due to the IPC overhead.es = EvolutionStrategy(model.get_weights(), get_reward, population_size=20, sigma=0.1, learning_rate=0.03, decay=0.995, num_threads=1)es.run(1000, print_step=100)Here's the output:.. code::iter 100. reward: -68.819312iter 200. reward: -0.218466iter 300. reward: -0.110204iter 400. reward: -0.001901iter 500. reward: -0.000459iter 600. reward: -0.000287iter 700. reward: -0.000939iter 800. reward: -0.000504iter 900. reward: -0.000522iter 1000. reward: -0.000178Now we have the optimized weights and we can update our model:.. code:: pythonoptimized_weights = es.get_weights()model.set_weights(optimized_weights)Todo--------- Add distribution support over network
Package: evostrat
EvoStratA library that makes Evolutionary Strategies (ES) simple to use.Installationpip install evostratUsagepop=PopulationImpl(...)# See complete examples for implementations.optim=torch.optim.Adam(pop.parameters())# Use any torch.optim optimizerforiinrange(N):optim.zero_grads()pop.fitness_grads(n_samples=200)# Computes approximate gradientsoptim.step()For complete examples that solves 'LunarLander-v2' see theexamples/.DescriptionEvolutionary Strategies is a powerful approach to solve reinforcement learning problems and other optimization problems where the gradients cannot be computed with backprop.
See"Evolution strategies as a scalable alternative to reinforcement learning"for an excellent introduction.In ES the objective is to maximize the expected fitness of a distribution over individuals, referred to as the population.
With a few math tricks this objective can be maximized with gradient ascent, even if the fitness function itself is not differentiable.This library offersA flexible and natural interface for ES that cleanly separates the environment, the reinforcement learning agent, the population distribution and the optimization.A plug-and-play approach for reinforcement learning agents withtorch.nn.Modulepolicy networks. Seeexamples/lunar_lander.pyandexamples/normal_lunar_lander.py.Several population distributions and variantsIndependent Normal. equivalent to OpenAI ES or PEPG depending on whether the standard deviation is fixed or learned. Seeexamples/normal_lunar_lander.pyMultivariate Normalwith a full covariance matrix. Similar to CMA-ES. Seeexamples/multivariate_normal_lunar_lander.pyCategorical. For agents with categorical parameters, demonstrating the ability to handle non-normal distributions. See theexamples/binary_lunar_lander.py.A simple interface for creating your own populations, without having to derive any gradients! Just subclassPopulationand implement the sampling process. See the built in populations for inspiration.AttributionIf you use this software in your academic work please cite@misc{palm2020,
  author = {Palm, Rasmus Berg},
  title = {EvoStrat},
  year = {2020},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/rasmusbergpalm/evostrat}}
}
Package: evotum-cripto
################################################################################ eVotUM - Electronic Voting System## README## README file with the information to install and use the eVotUM python module### Copyright (c) 2016 Universidade do Minho# José Pina Miranda - Devise Futures, Lda. (jose.miranda@devisefutures.com)### This program is free software; you can redistribute it and/or# modify it under the terms of the GNU General Public License# as published by the Free Software Foundation; either version 2# of the License, or (at your option) any later version.## This program is distributed in the hope that it will be useful,# but WITHOUT ANY WARRANTY; without even the implied warranty of# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the# GNU General Public License for more details.## You should have received a copy of the GNU General Public License# along with this program; if not, write to the Free Software# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.################################################################################eVotUM.Cripto setupA. Before installing the required python modules (see requirements.txt), please makesure that the following dependencies have been installed:For Debian and Ubuntu, the following command will ensure that the required dependencies are installed:$ sudo apt-get install build-essential libssl-dev libffi-dev python-devFor Fedora and RHEL-derivatives, the following command will ensure that the required dependencies are installed:$ sudo yum install gcc libffi-devel python-devel openssl-develB. Since random numbers are generated using eVotUM.Cripto and several systems are not ableto generate the necessary entropy (especially in Shamir Secret Sharing functions)for /dev/random, please install haveged (http://www.issihosts.com/haveged/index.html)before running eVotUM.Cripto.For Debian and Ubuntu, the following command will ensure that haveged is installed:$ sudo apt-get install havegedFor Fedora and RHEL-derivatives, the following command will ensure that haveged is installed:$ sudo yum install havegedC. To install the eVotUM.Cripto python module, please follow the following steps:1. Please run the following command: 'python setup.py build'.2. Please run the following command: 'sudo python setup.py install'.
Package: evovaq
EVOVAQEVOlutionary algorithms toolbox for VAriational Quantum circuits (EVOVAQ)is a novel evolutionary framework designed
to easily train variational quantum circuits through evolutionary techniques, and to have a simple interface between
these algorithms and quantum libraries, such as Qiskit.Optimizers in EVOVAQ:Genetic AlgorithmDifferential EvolutionMemetic AlgorithmBig Bang Big CrunchParticle Swarm OptimizationCHC AlgorithmHill ClimbingInstallationYou can install EVOVAQ viapip:pipinstallevovaqPip will handle all dependencies automatically and you will always install the latest version.
Package: evoxbench
Neural Architecture Search as Multiobjective Optimization Benchmarks: Problem Formulation and Performance Assessment[arXiv]Introduction to EvoXBenchClick on the image to watch the video.Please note that the calculation of IGD is only applicable to problems derived from search spaces that can be exhaustively evaluated (i.e., C-10/MOP1 - C-10/MOP7). This is because the true Pareto Fronts are available for such problems. For problems derived on the basis of surrogate models (i.e., C-10/MOP8 - C-10/MOP9 and IN-1K/MOP1 - IN-1K/MOP9), the true Pareto Fronts are unknown and we cannot calculate IGD.Preparation StepsDownload the following two requried files:database.zipfile
fromGoogle DriveorBaidu云盘（提取码：mhgs）data.zipfile
fromGoogle DriveorBaidu云盘（提取码：lfib）pip install evoxbenchto install the benchmark.Configure the benchmark via the following steps:fromevoxbench.database.initimportconfigconfig("Path to databae","Path to data")# For example# If you have the following structure# /home/Downloads/# └─ database/# |  |  __init__.py# |  |  db.sqlite3# |  |  ...# |# └─ data/#    └─ darts/#    └─ mnv3/#    └─ ...# Then you should do:# config("/home/Downloads/database", "/home/Downloads/data")DatabaseVisit this webpage for more information:https://github.com/liuxukun2000/evoxdatabaseSupportYou can ask any question inissues blockand upload your contribution by pulling request (PR).If you have any question,  please join the QQ group to ask questions (Group number: 297969717).AcknowledgementCodes are developed upon:NAS-Bench-101,NAS-Bench-201,NAS-Bench-301,NATS-Bench,Once for All,AutoFormer,Django,pymoo
Package: evp001
ShablonaShablona is a template project for small scientific Python projects.It contains software implementations of an analysis of some simple data, but
more importantly, it contains infrastructure for testing, documentation,
continuous integration and deployment, which can be easily adapted
to use in other projects.To get started using these components in your own software, please go to the
repositoryREADME.Licenseshablonais licensed under the terms of the MIT license. See the file
“LICENSE” for information on the history of this software, terms & conditions
for usage, and a DISCLAIMER OF ALL WARRANTIES.All trademarks referenced herein are property of their respective holders.Copyright (c) 2015–, Ariel Rokem, The University of Washington
eScience Institute.
Package: evpn
EvpnExpressVPN python native APIControlexpress VPNon your machine usingNative messagingprotocol.Setuppip3install-UevpnBasic UsagefromevpnimportExpressVpnApiimportrandomwithExpressVpnApi()asapi:locations=api.locations# get available locationsloc=random.choice(locations)api.connect(loc["id"])Examplesrandom_location.pyAboutThis library is Cross Platform (Windows,Linux,MacOSare supported)It talking to expressVPN daemon using native message protocol.DevelopmentInstall dependenciespip3 install .Install dev dependenciespip3 install .[dev]Lint itpylint --rcfile=.pylintrc --recursive=y .Test your changespython3 -m pytest .Make new PR 🚀ContributingEvery contribution is welcome. If you want to contribute but are unsure where to start, any open issues are fair game!
Package: evpsim
# ElastoViscoPlastic material SIMulator## DescriptionThe evpsim module simulates elasto-visco-plastic mechanical behavior for a given loading path (strain/stress/mixed).Simulation is performed at the scale of a single material point. It would be conceivable to couple the evpsim module with a finite element code for structural calculations, but this would require some work to reorganize the code, particularly in terms of memory management. What’s more, it would still be prohibitively expensive in terms of calculation costs compared with a dedicated implementation.## Installation### From sources`bash git clonehttps://github.com/basileMarchand/evpsim.gitcd evpsim pip install . `Or even simplier`bash pip installgit+https://github.com/basileMarchand/evpsim.git`### From PyPiComing soon## DocumentationComing soon
Package: evq
EVQEvolving Vector Quantization for Classification of On-Line Data StreamsNoteInspired by this algorithm and several others, I created a new one
called SEVQ:https://github.com/sylwekczmil/sevqInspirationImplementation done by Sylwester Czmil based on pseudocode and algorithm
description from:E. Lughofer, “Evolving Vector Quantization for Classification of On-Line
Data Streams,” 2008 International Conference on Computational
Intelligence for Modelling Control & Automation, 2008, pp.779-784, doi:
10.1109/CIMCA.2008.47.Installation# create venv and activate
# install algorithmpip3evqExample usageTraining and prediction one sample at a timefromevq.algorithmimportEVQc=EVQ(number_of_classes=2,vigilance=0.1)c.partial_fit([-2,-2],1)c.partial_fit([-1,-1],0)c.partial_fit([1,1],0)c.partial_fit([2,2],1)print(c.predict([0,0]))# 0print(c.predict([3,3]))# 1print(c.predict([-3,-3]))# 1Training and prediction on multiple samplesfromevq.algorithmimportEVQc=EVQ(number_of_classes=2,vigilance=0.1)c.fit([[-2,-2],[-1,-1],[1,1],[2,2]],[1,0,0,1],epochs=1,permute=False)print(c.predict([[0,0],[3,3],[-3,-3]]))# [0, 1, 1]
Package: evque
evque: Event Queue with Topicsevqueis a Python library that provides a simple event queue with support for topics. It allows you to manage events published to different topics and deliver them to their respective event handlers based on their delivery time.InstallationYou can installevquefrom PyPI using pip:pipinstallevqueFeaturesEvent Queue:Manage events and their delivery times in a priority queue.Topic Support:Subscribe and publish events to different topics.Singleton Instance:Share a single event queue instance across modules in your application.Usagefromevqueimportsubscribe,publish,run_until,empty,increase_clock,reset_clock,now# Subscribe to a topicdefevent_handler(arg):print(f"Event received with argument:{arg}")subscribe('topic1',event_handler)# Publish an event to be delivered at time 10publish('topic1',10,"Hello, World!")# Run events until time 15run_until(15)# Check if there are undelivered events in the queueifempty():print("No undelivered events in the queue.")LicenseThis library is licensed under the GNU General Public License v3.0. For more details, see theLICENSE.txtfile.ContributingContributions toevqueare welcome! If you find any issues or have suggestions for improvements, please open an issue or create a pull request on theGitHub repository.AcknowledgementsThe "evque" library is inspired by the concept of event queues used in discrete event simulation and event-driven programming.
Package: evspy
# evspy - 1D elasto-viscoplastic modelling of soils with swelling
A repository on elasto-viscous-swelling-plastic modelling of soils.![github-actions](https://github.com/thomasvergote/evspy/actions/workflows/python-test.yml/badge.svg)Two models are incorporated:
- a single-stage, decoupled model to model and interpret laboratory test data on soil after unloading:http://doi.org/10.1680/jgeot.20.P.106.
- a multi-stage, coupled or decoupled model that incorporates the features inferred from the decoupled model:http://dx.doi.org/10.1002/nag.3248More features are planned in the future:
- fitting module using MCMC
- documentation## Overview of models![example](/overview_of_models.png)
## Data
Empirical data is added under/data. The files are HDF5 format and contain a range of stages with metadata (such as the OCR of the test stage). See the basic_examples to load the data.loading_empirical_data.pyprovides basic functions to load the data.![example](/example_fit.png)