Saravanan666/pypi-org huggingface dataset:
Package: faim-wako-searchfirst
FAIM Wako SearchFirstTable of ContentsInstallationLicenseInstallationpip install faim-wako-searchfirstUsageConfiguration is managed in aconfig.ymlfile:# Requiredfile_selection:# criteria for file selection in case of multiple channels/slices per positionchannel:C01process:# choose method how to segment, filter, and sample the objectssegment:threshold# choices: threshold, cellposefilter:[bounding_box,area,solidity,intensity]sample:centers# choices: centers, grid_overlap, dense_grid# Each subsequent section provides arguments to one of the methods defined in 'process'threshold:threshold:128include_holes:yesgaussian_sigma:2.0# optionalbounding_box:min_x:64min_y:0max_x:256max_y:190area:min_area:100max_area:10000solidity:min_solidity:0.9max_solidity:1.0intensity:target_channel:C03min_intensity:128The Python script called by Wako Automation Software needs to accept the acquisition folderfolder_pathas only parameter:importtyperfromfaim_wako_searchfirst.mainimportrundefmain(folder_path:str):run(folder=folder_path,configfile="config.yml")if__name__=="__main__":typer.run(main)Licensefaim-wako-searchfirstis distributed under the terms of theMITlicense.
Package: faircompute
Fair Compute Python ClientFair is a Python client forFair ComputeAPI.
It allows to schedule jobs, monitor their status and retrieve results.Creating Fair AccountTo use FairCompute Python Client you need to have a Fair account.
Please sign up athttps://faircompute.com.Launching a jobTo launch a job, create aFairClientinstance and callrunmethod.fromfairimportFairClientclient=FairClient('http://faircompute:8000','<email>','<password>')client.run(image='alpine',command=['echo','hello fair compute'])Developing FairThis section is for developers of FairCompute Python client library.PrerequisitesCreate virtual environment and install requirements.python3-mvenvvenvsourcevenv/bin/activate
pipinstall-rrequirements.txtTestingBy default, testing is done against client running on localhost,
so you need to start the server and at least one compute node locally.
To start the server locally seehttps://github.com/faircompute/faircompute#running-locally.Project is usingpytestfor testing. To run all tests:pytestTo run tests against remote server, setFAIRCOMPUTE_SERVER_URL,FAIRCOMPUTE_USER_EMAILandFAIRCOMPUTE_USER_PASSWORDenvironment variables:FAIRCOMPUTE_SERVER_URL=http://faircompute:8000FAIRCOMPUTE_USER_EMAIL=<email>FAIRCOMPUTE_USER_PASSWORD=<password>pytestUploading to PyPIPlease follow the instructions athttps://packaging.python.org/tutorials/packaging-projects/rm-rfdist
python3-mbuild
python3-mtwineupload--repositorytestpypidist/*
python3-mtwineuploaddist/*
Package: faircorels-demo
Welcome to FairCorels, a Python library for learning fair and interpretable models
using the Certifiably Optimal RulE ListS (CORELS) algorithm!FairCORELS uses Python, Numpy, GMP, and a C++ compiler.
GMP (GNU Multiple Precision library) is not required, but it ishighly recommended, as it improves performance.
If it is not installed, CORELS will run slower.
Package: fairdatapoint-client
fairdatapoint-clientContentsOverviewInstallationQuick TutorialIssues & ContributingLicenseOverviewfairdatapoint-client is a simple and elegant library to interact withFAIR Data Pointresources from
Python, e.g. read and write catalogs, datasets and distributions in an FDP server.The supported APIs are listed below:FDP LayersPath EndpointSpecific Resource Endpointfdp[baseURL] or [baseURL]/fdpcatalog[baseURL]/catalog[baseURL]/catalog/[catalogID]dataset[baseURL]/dataset[baseURL]/dataset/[datasetID]distribution[baseURL]/distribution[baseURL]/distribution/[distributionID]InstallationIt requires a Python version of 3.7, 3.8 or 3.9.Stable ReleaseThe fairdatapoint-client is available onPyPI,
you can install it using:pip install fairdatapoint-clientDevelopment VersionYou can also install from the latest source code, but note that the
in-development version might be unstable:git clone https://github.com/fair-data/fairdatapoint-client.git
cd fairdatapoint-client
pip install .To run tests (including coverage):pip install '.[tests]'
pytestTutorialUsing Clientfromfdpclient.clientimportClient# create a client with base URLclient=Client('http://example.org')# create metadatawithopen('catalog01.ttl')asf:data=f.read()client.create_catalog(data)# let's assume the catalogID was assigned as 'catalog01'# read metadata, return a RDF graphr=client.read_catalog('catalog01')print(r.serialize(format="turtle").decode("utf-8"))# update metadatawithopen('catalog01_update.ttl')asf:data_update=f.read()client.update_catalog('catalog01',data_update)# delete metadataclient.delete_catalog('catalog01')Using operation functionsfromfdpclientimportoperations# create metadatawithopen('catalog01.ttl')asf:data=f.read()operations.create('http://example.org/catalog',data)# read metadata, return a RDF graphr=operations.read('http://example.org/catalog/catalog01')print(r.serialize(format="turtle").decode("utf-8"))# update metadatawithopen('catalog01_update.ttl')asf:data_update=f.read()operations.update('http://example.org/catalog/catalog01',data_update)# delete metadataoperations.delete('http://example.org/catalog/catalog01')Issues and ContributingIf you have questions or find a bug, please report the issue in theGithub issue channel.If you want to contribute to the development of fairdatapoint-client, have a
look at thecontribution guidelines.
Package: fair-GPD
GPDGraphormer-based Protein Design (GPD) model deploys the Transformer on a graph-based representation of 3D protein structures and supplements it with Gaussian noise and a sequence random mask applied to node features, thereby enhancing sequence recovery and diversity. The performance of GPD model was significantly better than that of state-of-the-art model for ProteinMPNN on multiple independent tests, especially for sequence diversity.InstallQuick StartOne can use pip to directly install our packagepip install fair-GPDInstall with condaconda create -n GPD
source activate GPD
conda install pytorch==1.12.1 -c pytorch
conda install -c conda-forge mdtraj==1.9.8
conda install -c anaconda networkx==3.1Note that GPD could be used with cuda, you can install the cudatoolkit package according to your own gpu version.
Also, one could use our givenenvironment.ymlfile to create an environmentconda env create -f environment.ymlInstall with pipOne can use our givenrequirements.txtfile for pip installationpip install -r requirements.txtExamplecd example/
sh submit_example_2_fixed.sh  (simple example)
sh submit_example_1.sh (fix some residue positions)Output example:outputs/example_1_outputs/1tca.fasta> predicted model_0	acc: 0.3501577287066246	length: 317
APTGAAPPLTLPPATLRAQLAAKGASPEDLKNPVLILHGPGTDGAEDFAGFLVRLLKSKGYTPAYVDPDPN
ALDDIADDLEALALAAKYLAAGLGNKPFNVITHSLGGVALLTALAYHPELRDKIKRVVLVSPLPTGSDSLR
ALLAANTLRLLQFLSVKGSALDDAARKAGALTPLVPTTVIGHANDPLHYPTSLGSPASGAYVPDARVIDLY
SVYGPDFTVDHAEAVFSSLVRKALKAALTSSSGYARASDVGKSLRVSDPAKDLSAEQREAFLNLLAPAAAA
IANGKTGNACPPLPPEYLPAAPGAKGAGGVLTP
> predicted model_1	acc: 0.334384858044164	length: 317
APTGEPLPLLLPDATLLANVEADGADIDEVTNPVLLLHGLGSDGEEALGASLVALLKALGYTPLGVDPDPN
YTDDILDDAQALAAAARALAAGLGNKPLLVVGHSLGGVVVLLALRYNPALADLIASVILVAPAPRGSSEAR
PLIAAKILRPEDFLLLYGSALADALRAAGLDVPLVPTTVIDSADDPLHSPNALLSAESAAYVPGGTVVDLS
DIFGPDFTVSHAGAVLSPFLRKLLEAALASPTGVPREEDVGASLLDLDLAADLTAEERAAALNALAAYAAR
IAAGARFNAYPALPPELVPAAKGATDAAGTLKPaccis recovery. Recovery was the proportion of the same amino acids at equivalent position between the native sequence and the designed sequencelengthis the length of designed sequence.Training the GPD modelDatasetThe GPD model was trained using the CATH 40% sequential non-redundancy dataset, with a split ratio of 29868:1000:103 for the training, validation, and testing sets, respectively. We further evaluated the performance of GPD using 39 de novo proteins, including 14 de novo proteins that exhibit significant structural differences from proteins belonging to natural folds.data/cath-dataset-nonredundant-S40-v4_3_0.pdbis CATH 40% sequential non-redundancy dataset downloaded fromhttp://download.cathdb.info/cath/releases/all-releases/v4_3_0/non-redundant-data-sets/cath-dataset-nonredundant-S40-v4_3_0.pdb.tgzdata/sc103is 103 single chain proteinsdata/denovo39is 39 de novo proteinsdata/denovo14is 14 de novo proteinsTraining the GPD modeltrain/train_encoder3.pyIts training lasted 1 days and utilized 1 NVIDIA 40G A100 GPUs
Package: fairgrad
FairGrad: Fairness Aware Gradient DescentFairGrad, is an easy to use general purpose approach to enforce fairness for gradient descent based methods.Getting started:You can getfairgradfrom pypi, which means it can be easily installed viapip:pip install fairgradDocumentationThe documenation can be found atread the docsExample usageTo use fairgrad simply replace your pytorch cross entropy loss with fairgrad cross entropy loss.
Alongside, regular pytorch cross entropy arguments, it expects following extra arguments.y_train (np.asarray[int], Tensor, optional): All train example's corresponding label
s_train (np.asarray[int], Tensor, optional): All train example's corresponding sensitive attribute. This means if there
        are 2 sensitive attributes, with each of them being binary. For instance gender - (male and female) and
        age (above 45, below 45). Total unique sentive attributes are 4.
fairness_measure (string): Currently we support "equal_odds", "equal_opportunity", "accuracy_parity", and 
                           "demographic_parity". Note that demographic parity is only supported for binary case.
epsilon (float, optional): The slack which is allowed for the final fairness level.
fairness_rate (float, optional): Parameter which intertwines current fairness weights with sum of previous fairness rates.# Note this is short snippet. One still needs to models and iterators.# Full worked out example is available here - @TODOfromfairgrad.torchimportCrossEntropyLoss# define cross entropy losscriterion=CrossEntropyLoss(fairness_related_meta_data=fairness_related_meta_data)# Train loopforinputs,labels,protected_attributesintrain_iterator:model.train()optimizer.zero_grad()output=model(inputs)loss=criterion(output,labels,protected_attributes,mode='train')loss.backward()optimizer.step()We highly recommend tostandardize featuresby removing the mean and scaling to unit variance.
This can be done using standard scalar module in sklearn.Citation@article{maheshwari2022fairgrad,
  title={FairGrad: Fairness Aware Gradient Descent},
  author={Maheshwari, Gaurav and Perrot, Micha{\"e}l},
  journal={arXiv preprint arXiv:2206.10923},
  year={2022}
}
Package: fair-identifiers-client
fair-identifiers-clientClient SDK and CLI for the FAIR Research Identifiers Service.SummaryThe fair-identifiers-client package provides command line and SDK interfaces to the FAIR Research Identifiers Service.Pre-RequisitesBuilding and installing the fair-identifiers-client requires the use of thepipenvtool. Pre-install it with the commandpip install --user --upgrade pipenvor a similar command suitable for your installation.BuildingThe default method of building the client is simply to usemake installwhich creates the local executable filefair-identifiers-client. This default method assumes a build using Python version 3.6. Other versions of Python may be forced by setting thePYTHON_VERSIONenvironment variable prior to runningmake install. For example, the commandPYTHON_VERSION=2.7 make installwill build for use with version 2.7 of the python interpreter.At present, only python versions 2.7 and 3.6 have been tested.RunningA completed build will create an executable filefair-identifiers-clientin the base directory for the project.  Additional help running the command can be found using the commandfair-identifiers-client --help. Typically, the first command to be executed will befair-identifiers-client loginto create a cache of the credentials needed to interact with the service in subsequent invocations of the command. Thelogincommand will open a web browser which will step you through logging in with your Globus identity and for providing consent for the command line tool to perform operations on the FAIR Research Identifiers Service on your behalf.Use as an SDKThe SDK functionality is encapsulated in the source filefair_identifiers_client/identifiers_api.py. The Doc String comments on the various methods of theIdentifierClientclass describe the parameters to the operations.Examplesfrom fair_identifiers_client.identifiers_api import identifiers_client
from fair_identifiers_client.config import config
# Loads tokens stored from config
client = identifiers_client(config)
client.create_identifier(namespace='<my_namespace>', visible_to=['public'])Use as a Command Line ClientA CLI client application comes with the installation, and can be used withfair-identifiers-clientExamplesBelow are example commandsPrint information on all options for creating identifiers$ fair-identifiers-client identifier-create --helpCreate an Identifierfair-identifiers-client identifier-create --namespace <my_namespace> --visible-to publicUpdate an identifierAdd a locationfair-identifiers-client identifier-update --identifier <myidentifier> --locations https://foo.example.comAdd many fieldsfair-identifiers-client identifier-update --identifier <myidentifier> --locations https://foo.example.com https://example.com/foo --checksum-sha256 sha256checksum --checksum-md5 mymd5checksum --metadata file://foo.json<!-- @IGNORE PREVIOUS: link -->
Package: fairiskdata
FAIRisk | Improving risk estimation with open resourcesFAIRisk combines open-source globally available data related with risk scales and country preparedness for epidemic
crisis with post-COVID-19 data. It aims to facilitate the creation of preventive insights at country-level and the
suggestion of improvements to current risk modelling strategies, and assist the work of the scientific community and
decision-makers dealing with COVID-19 (or related) crisis.This repository addresses data interoperability challenges of fetching and combining several openly available sources
of multimodal data, so these can be coherently used from a centralized data model. This model was designed bearing
FAIR principles and EU's open data guidelines in mind to promote an adequate, well-documented and simplified use of
the combined data.ApproachA semantic data model was defined, following the analysis of several relevant sources, in order to typify and indentify
the most relevant concepts, while attempting to maximize its generalization. Data from 6 different sources was
organized and merged in a single data model, where each country entity is represented by up to 6 categories:Demographics: population by age group.Indicators: raw indicators' data measured for each country.Scores: indexes, scales, or scores that assist the comparison of qualitative or estimated parameters across
countries.Mortality: count of deaths by age group.COVID-19: number of cases, deaths, tests, ICU patients, hospitalizations, vaccinations, and stringency index due to
the COVID-19 pandemic.Mobility: statistics of citizens movement estimations.Check out ourarchitecture documentationfor more details.Getting startedJump to ourgetting started guide.
Data exploration, visualization, and export is also possible usingour simple streamlit application.
Also, you may read ourfull documentation.LicenseAll visualizations and code available in this repository are licensed under theCreative Commons BY-NC-SA 4.0
license.All data fetched by the methods available in this repository was produced by third-parties and is subject to the license
terms from the original third-party authors. The sources from which data was fetched are kept and made available as
metadata at all stages. Sources are also detailedhere. You should always check the license of all third-party data before use.FundingThe authors would like to acknowledge the financial support obtained from EOSCsecretariat.eu. EOSCsecretariat.eu has
received funding from the European Union's Horizon Programme call H2020-INFRAEOSC-05-2018-2019, grant Agreement
number 831644.AuthorsThese resources were developed byFraunhofer AICOS.Development team: Diana Gomes (diana.gomes@fraunhofer.pt), Catarina Pires (catarina.pires@fraunhofer.pt),
David Ribeiro (david.ribeiro@fraunhofer.pt), Duarte Folgado (duarte.folgado@fraunhofer.pt),
Ricardo Santos (ricardo.santos@fraunhofer.pt), Telmo Barbosa (telmo.barbosa@fraunhofer.pt).
Package: fairkit-learn
fairkit-learn fairness toolkitFairkit-learn is an open-source, publicly available Python toolkit designed
to help data scientists evaluate and explore machine learning models with
respect to quality and fairness metrics simultaneously.Fairkit-learn builds on top ofscikit-learn, the state-of-the-art tool suite
for data mining and data analysis, andAI Fairness 360, the state-of-the-art
Python toolkit for examining, reporting, and mitigating machine learning bias
in individual models.Fairkit-learn supports all metrics and learning algorithms available in scikit-learn and AI Fairness
360, and all of the bias mitigating pre- and post-processing algorithms available in AI Fairness 360, and provides extension points to add more metrics and algorithms.InstallationTo install fairkit-learn, run the following command:pip install fairkit-learn==1.0Using fairkit-learnSample code for how to use fairkit-learn can be found in the examples
folder in the repo.
Package: fair-lnc-evaluation
Systematic analysis of the impact of label noise correction on ML FairnessThis Python package provides an implementation of the empirical methodology to systematically evaluate the effectiveness of label noise correction techniques in ensuring the fairness of models trained on biased datasets, proposed in [1]. The methodology involves manipulating the amount of label noise and can be used with fairness benchmarks but also with standard ML datasets. Experiment tracking is done usingmlflow.InstallationYou can install the package usingpip:pipinstallfair_lnc_evaluationUsageExamples of how to use this package can be found on theexamplesfolder.ReferencesContributingContributions to this package are welcome! If you have any bug reports, feature requests, or would like to contribute with code improvements, please submit an issue or a pull request on the GitHub repository.LicenseThis package is distributed under theMIT License.Feel free to modify and expand upon this README.md template according to your specific package and the algorithms you implement.
Package: fair-loss
A fair PyTorch loss functionThe goal of this loss function is to take fairness into account during the training of a
PyTorch model. It works by adding a fairness measure to a regular loss value,
following this equation:Installationpipinstallfair-lossExampleimporttorchfromfair_lossimportFairLossmodel=torch.nn.Sequential(torch.nn.Linear(5,1),torch.nn.ReLU())data=torch.randint(0,5,(100,5),dtype=torch.float,requires_grad=True)y_true=torch.randint(0,5,(100,1),dtype=torch.float)y_pred=model(data)# Let's say the sensitive attribute is in the second dimensiondim=1criterion=FairLoss(torch.nn.MSELoss(),data[:,dim].detach().unique(),accuracy)loss=criterion(data[:,dim],y_pred,y_true)loss.backward()DocumentationSeethe documentation.
Package: fairly
fair-software.nlrecommendationsBadges1. Code repository2. License3. Community Registry4. Enable CitationOther best practicesContinuous integrationDocumentationfairlyA package to create, publish and clone research datasets.Installationfairlyrequires Python 3.8 or later, andruamel.yamlversion0.17.26or later.  It can be installed directly
using pip.pipinstallfairlyInstalling from sourceClone or download thesource
code:gitclonehttps://github.com/ITC-CRIB/fairly.gitGo to the root directory:cdfairly/Compile and install using pip:pipinstall.UsageBasic example to create a local research dataset and deposit it to a
repository:importfairly# Initialize a local datasetdataset=fairly.init_dataset('/path/dataset')# Set metadatadataset.metadata['license']='MIT'dataset.set_metadata(title='My dataset',keywords=['FAIR','research','data'],authors=['0000-0002-0156-185X',{'name':'John','surname':'Doe'}])# Add data filesdataset.includes.extend(['README.txt','*.csv','train/*.jpg'])# Save datasetdataset.save()# Upload to a data repositoryremote_dataset=dataset.upload('zenodo')Basic example to access a remote dataset and store it locally:importfairly# Open a remote datasetdataset=fairly.dataset('doi:10.4121/21588096.v1')# Get dataset informationdataset.id>>>{'id':'21588096','version':'1'}dataset.url>>>'https://data.4tu.nl/articles/dataset/.../21588096/1'dataset.size>>>33339len(dataset.files)>>>6dataset.metadata>>>Metadata({'keywords':['Earthquakes','precursor',...],...})# Update metadatadataset.metadata['keywords']=['Landslides','precursor']dataset.save_metadata()# Store dataset to a local directory (i.e. clone dataset)local_dataset=dataset.store('/path/dataset')Currently, the package supports the following research data management
platforms:ZenodoFigshareDjehuty(experimental)All research data repositories based on the listed platforms are
supported.For more details and examples, consult thepackage
documentation.TestingUnit tests can be run by usingpytestcommand in the root directory.ContributionsRead theguidelinesto know how you can be part of
this open source project.JupyterLab ExtensionAn extension for JupyerLab is being developed in adifferent
repository.CitationPlease cite this software using as follows:Girgin, S., Garcia Alvarez, M., & Urra Llanusa, J., fairly: a package
to create, publish and clone research datasets [Computer software]AcknowledgementsThis research is funded by theDutch Research Council (NWO) Open
Science
Fund,
File No. 203.001.114.Project members:Center of Expertise in Big Geodata Science, University of Twente,
Faculty ITCDigital Competence Centre, TU Delft4TU.ResearchData
Package: fairness
This repository is meant to facilitate the benchmarking of fairness aware machine learning algorithms.The associated paper is:A comparative study of fairness-enhancing interventions in machine learning by Sorelle A. Friedler, Carlos Scheidegger, Suresh Venkatasubramanian, Sonam Choudhary, Evan P. Hamilton, and Derek Roth.https://arxiv.org/abs/1802.04422To install this software run:$ pip3 install fairnessThe below instructions are still in the process of being updated to work with the new pip install-able version.To run the benchmarks:$ from fairness.benchmark import run
$ run()This will write out metrics for each dataset to the results/ directory.To generate graphs and other analysis run:$ python3 analysis.pyIf you do not yet have all the packages installed, you may need to run:$ pip install -r requirements.txtOptional:  The benchmarks rely on preprocessed versions of the datasets that have been included
in the repository.  If you would like to regenerate this preprocessing, run the below command
before running the benchmark script:$ python3 preprocess.pyTo add new datasets or algorithms, see the instructions in the readme files in those directories.OS-specific thingsOn Ubuntu(We tested on Ubuntu 16.04, your mileage may vary)You'll needpython3-dev:$ sudo apt-get install python3-devAdditional analysis-specific requirementsTo regenerate figures (this is messy right now. we're working on it)Python requirements (use pip):ggplotSystem requirements:pandoc(brew install pandocon a Mac orapt-get install pandocon Linux)R  (Mac download link:https://cran.rstudio.com/bin/macosx/R-3.4.3.pkg)R package requirements (useinstall.packages):rmarkdownstringrggplot2dplyrmagrittrcorrplotrobust