Saravanan666/pypi-org huggingface dataset:
Package: deeppheno
DeepPheno: Predicting single gene loss of function phenotypesDeepPheno is a method for predicting gene-phenotype (HPO classes)
associations from gene functional annotations (GO classes) and gene
expression values.This repository contains script which were used to build and train the
DeepPheno model together with the scripts for evaluating the model's
performance.DependenciesThe code was developed and tested using python 3.7.To install python dependencies run:pip install -r requirements.txtDatahttps://bio2vec.cbrc.kaust.edu.sa/data/deeppheno/- Here you can find the data
used to train and evaluate our method.data.tar.gz - data folder with latest datasetdata-cafa2.tar.gz - CAFA2 challenge datasetpredictions.txt.gz - DeepPheno predictions for human genesScriptsThe scripts require GeneOntology and Human Phenotype Ontology in OBO Format.uni2pandas.py - This script is used to convert data from UniProt
database format to pandas dataframe.data.py - This script is used to generate training and
testing datasets.pheno.py - This script is used to train the modelevaluate_*.py - The scripts are used to compute Fmax, SminGeneDis.groovy - This script is used to compute semantic similarity
between gene and disease phenotypesRunningDownload all the files fromhttps://bio2vec.cbrc.kaust.edu.sa/data/deeppheno/data.tar.gzand place them into data folderrunpython pheno.pyto start training the modelCitationIf you use DeepPheno for your research, or incorporate our learning algorithms in your work, please cite:Maxat Kulmanov, Robert Hoehndorf; DeepPheno: Predicting single gene
knockout phenotypes. BioArxiv,https://doi.org/10.1101/839332
Package: deep-phonemizer
DeepPhonemizer is a multilingual grapheme-to-phoneme modeling library that leverages recent deep learning
technology and is optimized for usage in production systems such as TTS. In particular, the library should
be accurate, fast, easy to use. Moreover, you can train a custom model on your own dataset in a few lines of code.DeepPhonemizer is compatible with Python 3.6+ and is distributed under the MIT license.Read the documentation at:https://as-ideas.github.io/DeepPhonemizer/
Package: deeppipe-api
DeepPipe: Deep Pipeline Embeddings for AutoMLDeepPipeefficiently optimizes Machine Learning Pipelines using meta-learning. For detailed information, refer to ourpaperDeep Pipeline Embeddings for AutoMLaccepted at KDD 2023. Additionally, you can visit ourblog-postto have a friendly insight on how our method works.InstallationWe present an API for optimizing pipelines in scikit-learn based on the TensorOboe search space. You can use it to search for accurate pipelines or for benchmarking your Machine Learning model on tabular data.condacreate-ndeeppipe_envpython==3.9
pipinstalldeeppipe_apiGetting startedWe present an example using an OpenML dataset. However, it works with any tabular data typed as pandas dataframe.fromdeeppipe_api.deeppipeimportload_data,openml,DeepPipetask_id=37task=openml.tasks.get_task(task_id)X_train,X_test,y_train,y_test=load_data(task,fold=0)deep_pipe=DeepPipe(n_iters=50,#bo iterationstime_limit=3600#in seconds)deep_pipe.fit(X_train,y_train)y_pred=deep_pipe.predict(X_test)#Testscore=deep_pipe.score(X_test,y_test)print("Test acc.:",score)#print best pipelineprint(deep_pipe.model)Ensemble of PipelinesIt is possible to ensemble the best pipelines, by using a greedy approach.fromdeeppipe_api.deeppipeimportload_data,openml,DeepPipetask=openml.tasks.get_task(task_id=37)X_train,X_test,y_train,y_test=load_data(task,fold=0)deep_pipe=DeepPipe(n_iters=50,#bo iterationstime_limit=3600,#in secondscreate_ensemble=False,ensemble_size=10,)deep_pipe.fit(X_train,y_train)y_pred=deep_pipe.predict(X_test)score=deep_pipe.score(X_test,y_test)print("Test acc.:",score)Advanced UsageFor meta-trainingDeepPipeor testing other search spaces, you can refer to the foldersrc/deeppipe_api/experiments/.Our PaperIf you use this repository/package, please cite our paper:@article{arango2023deep,
  title={Deep Pipeline Embeddings for AutoML},
  author={Arango, Sebastian Pineda and Grabocka, Josif},
  journal={arXiv preprint arXiv:2305.14009},
  year={2023}
}
Package: deep-plots
Deep PlotsVisualize Your Deep Learning Training in Static Graphics.Why?Analyzing learning curvesare a standard way to evaluate the learning performances of machine learning models. There existseveral toolsfor creating live plots. This Python package focuses on producing beautiful static graphics only.Currently, only plotting fromKeras CSV log fileformat is supported.For creating the graphics,plotnineis used which is build uponMatplotlib.Installationpipinstalldeep_plotsUnfortunately, you may need to:pipinstallnumpybefore because adepedency implicitly assumes numpy is installed.Usage# create a Keras callback to log your trainingcsv_logger=keras.callbacks.CSVLogger('log.csv')# train your modelmodel.fit(X,y,...,callbacks=[csv_logger,...])# after finishing training, plot the learning curves with Deep Plotsdeep_plots.from_keras_log('log.csv','output_dir')RelatedTensorBoard: Live plots for TensorFlow,Keras.tensorboardX: Live plots for PyTorch, Chainer etc..Live Loss Plot: Live plots in Jupyter Notebooks for Keras, PyTorch etc..ContributingIf you have aquestion, found abugor want to propose a newfeature, have a look at theissues page.Pull requestsare especially welcomed when they fix bugs or improve the code quality.LicenseMIT.
Package: deepproblog
DeepProbLogDeepProbLog is an extension ofProbLogthat integrates Probabilistic Logic Programming with deep learning by introducing the neural predicate.
The neural predicate represents probabilistic facts whose probabilites are parameterized by neural networks.
For more information, consult the papers listed below.InstallationDeepProbLog can easily be installed using the following command:
Make sure the following packages are installed:pip install deepproblogTestTo make sure your installation works, install pytestpip install pytestand runpython -m deepproblog testRequirementsDeepProbLog has the following requirements:Python > 3.9ProbLogPySDDPyTorchTorchVisionApproximate InferenceTo use Approximate Inference, we have the following additional requirementsPySwipUsepip install git+https://github.com/ML-KULeuven/pyswipSWI-Prolog < 9.0.0The latter can be installed on Ubuntu with the following commands:sudo apt-add-repository ppa:swi-prolog/stable
sudo apt install swi-prolog=8.4* swi-prolog-nox=8.4* swi-prolog-x=8.4*ExperimentsThe experiments are presented in the papers are available in thesrc/deepproblog/examplesdirectory.PapersRobin Manhaeve, Sebastijan Dumancic, Angelika Kimmig, Thomas Demeester, Luc De Raedt:DeepProbLog: Neural Probabilistic Logic Programming. NeurIPS 2018: 3753-3763 (paper)Robin Manhaeve, Sebastijan Dumancic, Angelika Kimmig, Thomas Demeester, Luc De Raedt:Neural Probabilistic Logic Programming in DeepProbLog. AIJ (paper)Robin Manhaeve, Giuseppe Marra, Luc De Raedt:Approximate Inference for Neural Probabilistic Logic Programming. KR 2021LicenseCopyright 2023 KU Leuven, DTAI Research GroupLicensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
Package: deep-proto
Deep ProtoThis is the generated code for the common APIs for DEEP. This is generated from the projectintergra/deep-proto.UsageThe usage of these packages differs between server and clients. Please seeGRPC docsfor more guidance.ClientTo use this as a client:importgrpcfromdeepproto.proto.tracepoint.v1.tracepoint_pb2importSnapshotdefpollServer()# setup the connection channelchannel=grpc.secure_channel("deep:43315",grpc.ssl_channel_credentials())# create stub servicestub=PollConfigStub(channel)# create requestrequest=PollRequest()# send request and await responseresponse=stub.poll(request)defsendSnapshot()# setup the connection channelchannel=grpc.secure_channel("deep:43315",grpc.ssl_channel_credentials())# create stub servicestub=SnapshotServiceStub(channel)# create grpc snapshot messagesnapshot=Snapshot()# send snapshot, and await responseresponse=stub.send(snapshot)ServerTo use this as a server:importdeepprotoimportgrpcfromdeepproto.proto.poll.v1.poll_pb2importPollResponse,ResponseTypefromdeepproto.proto.poll.v1.poll_pb2_grpcimportPollConfigServicerfromdeepproto.proto.tracepoint.v1.tracepoint_pb2importTracePointConfig,SnapshotResponsefromdeepproto.proto.tracepoint.v1.tracepoint_pb2_grpcimportSnapshotServiceServicerdefserve():# configure GRPCserver=grpc.server(futures.ThreadPoolExecutor(max_workers=10))# register the servicesdeepproto.proto.poll.v1.poll_pb2_grpc.add_PollConfigServicer_to_server(PollServicer(),server)deepproto.proto.tracepoint.v1.tracepoint_pb2_grpc.add_SnapshotServiceServicer_to_server(SnapshotServicer(),server)# start the serverserver.add_insecure_port('[::]:43315')server.start()server.wait_for_termination()classSnapshotServicer(SnapshotServiceServicer):defsend(self,request,context):# Code to process a new snapshotreturnSnapshotResponse()classPollServicer(PollConfigServicer):defpoll(self,request,context):# code to process a poll requestreturnPollResponse()DocumentationThe documentation for this project is availablehere.LicensingThis project is licensed asAGPL-3.0-only.
Package: deep-py
ProgressBarLet us consider a few examples explaining how to use theProgressBarclass from the moduleprogress:fromdeeppy.progressimportProgressBarfromtimeimportsleepbar=ProgressBar(max=20,width=50,elapsed=True)foriinrange(10):sleep(1)bar.next()bar.finish()print()foriinrange(15):sleep(1)bar.next()Out:
Processing: [#########################                         ] 50% [elapsed: 10s; ETA: 10s]
Processing: [#####################################             ] 75% [elapsed: 15s; ETA: 5s]The class supports the context management protocol and can be used with thewithstatement. Alternative bar formats are also available:withProgressBar("Charging",max=20,width=50)asbar:foriinrange(10):sleep(1)bar.next()print()withProgressBar("FillingSquares",max=20,width=50)asbar:foriinrange(15):sleep(1)bar.next()Out:
Processing: [█████████████████████████∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙] 50% [ETA: 10s]              
Processing: [▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▣▢▢▢▢▢▢▢▢▢▢▢▢▢] 75% [ETA: 5s]Note that thenextmethod can be replaced by theshowmethod withindexargument supplied:withProgressBar("FillingCircles",max=20,width=50,eta=False)asbar:foriinrange(10):sleep(1)bar.show(i+1)Out:
Processing: [◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯] 50%ProgressSpinnerThe following examples explain how to use theProgressSpinnerclass from the moduleprogress:fromdeeppy.progressimportProgressSpinnerfromtimeimportsleep,timespinner=ProgressSpinner()since=time()whileTrue:# Do some worksleep(0.2)spinner.next()iftime()-since>5:breakAlternative spinner formats are also available:withProgressSpinner("Pie")asspinner:since=time()whileTrue:sleep(0.2)spinner.next()iftime()-since>5:breakprint()withProgressSpinner("Moon")asspinner:since=time()whileTrue:sleep(0.2)spinner.next()iftime()-since>5:breakprint()withProgressSpinner("Pixel")asspinner:since=time()whileTrue:sleep(0.2)spinner.next()iftime()-since>5:breakOut:
Processing: ◷
Processing: ◐
Processing: ⣷InstallationDownload from PyPI:pip install deep-py
Package: deeppyer
deeppyerdeeppyer is an image deepfryer written in Python usingPillowandOpenCV.NOTE: Thisrequiresat least Python v3.6 in order to run.How to useYou can either use deeppyer as a module, or straight from the command line.Command line usage$ python deeppyer.py -h

usage: deeppyer.py [-h] [-v] [-o OUTPUT] [-f] FILE

Deepfry an image.

positional arguments:
  FILE                  File to deepfry.

optional arguments:
  -h, --help            show this help message and exit
  -v, --version         Display program version.
  -o OUTPUT, --output OUTPUT
                        Filename to output to.
  -f, --flares          Try and detected faces for adding lens flares.By default, flares will try to be added to the image, unless you're using the CLI script,
in which case it is off by default.Program usagefromPILimportImageimportdeeppyer,asyncioasyncdefmain():img=Image.open('./foo.jpg')img=awaitdeeppyer.deepfry(img)img.save('./bar.jpg')loop=asyncio.get_event_loop()loop.run_until_complete(main())API Documentationasync deepfry(img: Image, type=DeepfryTypes.RED, *, flares: bool = True)Deepfry a given image.Argumentsimg(PIL.Image) - Image to apply the deepfry effect on.[type](DeepfryTypes) - Colours to apply on the image.*[flares] (bool) - Whether or not to try and detect faces for applying lens flares.Returns:PIL.Image- Deepfried image.Why?Â¯\_(ãƒ„)_/Â¯ Why notContributingIf you wish to contribute something to this, go ahead! Just please make sure to format it with flake8 + isort, and that the test(s) pass fine.TestingSimply runtests/test.pyand make sure that all the images output properly.
Package: deepqmc
DeepQMCDeepQMC implements variational quantum Monte Carlo for electrons in molecules, using deep neural networks as trial wave functions. The package is based onJAXandHaiku. Besides the core functionality, it contains an implementation of a flexible neural network wave function ansatz, that can be configured to obtain a broad range of molecular neural network wave functions. Config files for the instantiation of variants ofPauliNet,FermiNet,DeepErwinandPsiFormercan be found undersrc/deepqmc/conf/ansatz.InstallationInstall and update to the latest release usingPip:pip install -U deepqmcTo install DeepQMC from a local Git repository run:git clone https://github.com/deepqmc/deepqmc
cd deepqmc
pip install -e .[dev]If Pip complains aboutsetup.pynot being found, please update to the latest Pip version.The above installation will result in the CPU version of JAX. However, running DeepQMC on the GPU is highly recommended. To enable GPU support make sure to upgrade JAX to match the CUDA and cuDNN versions of your system. For most users this can be achieved with:# CUDA 12 installation
pip install --upgrade "jax[cuda12_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html

# CUDA 11 installation
pip install --upgrade "jax[cuda11_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.htmlIf issues arise during the JAX installation visit theJAX Install Guide.Documentation and exemplary usageFor further information about the DeepQMC package and tutorials covering the basic usage visit thedocumentation.An introduction to the methodology and exemplary experiments can be found in the associatedsoftware paper.CitationIf you use DeepQMC for your work, please cite our implementation paper:@article{10.1063/5.0157512,
    author = {Schätzle, Z. and Szabó, P. B. and Mezera, M. and Hermann, J. and Noé, F.},
    title = "{DeepQMC: An open-source software suite for variational optimization of deep-learning molecular wave functions}",
    journal = {The Journal of Chemical Physics},
    volume = {159},
    number = {9},
    pages = {094108},
    year = {2023},
    month = {09},
    issn = {0021-9606},
    doi = {10.1063/5.0157512},
    url = {https://doi.org/10.1063/5.0157512},
}The repository can be cited as:@software{deepqmc,
	author = {Hermann, J. and Schätzle, Z. and Szabó, P. B. and Mezera, M and {DeepQMC Contributors}},
	title = "{DeepQMC}",
	year = {2023},
	publisher = {Zenodo},
	copyright = {MIT},
	url = {https://github.com/deepqmc/deepqmc},
	doi = {10.5281/zenodo.3960826},
}
Package: deep-q-reg
deep-q-reg下の方に日本語の説明がありますOverviewTool to easily perform quantile regression using deep learning (pytorch).Automatically compensates for quantile order swapping defects in predicted data.Customizable granularity, from "hyper-parameter unspecified mode" to "detailed parameter settings".The number of data dimensions is set automatically at the first training with define-by-run.Example usageimportdeep_q_reg# Prepare datatrain_x=load_x_data()# [[0.538], [0.469], ...]train_y=load_y_data()# [24.0, 21.6, ...]# Parametersparams={}# This can also be omitted. See details below for specifying parameters# Deep quantile regression [deep_q_reg]dqr=deep_q_reg.Deep_Q_Reg(params)# Training [deep_q_reg]dqr.train(train_x,train_y)# Inference [deep_q_reg]pred_y=dqr.predict(test_x)Details of specifying parametersParameters are specified as follows. Omitted specifications are automatically filled in with default values.params={'normalize_x':True,# Automatic normalization of x'quant_ls':[0.25,0.5,0.75],# List of prediction target quantiles# Layer structure'layers':[{'activation':'ReLU',# Activation function name (Specify names under torch.nn such as Tanh, ReLU, Sigmoid)'out_n':32# Output dimension of the layer (Input dimension is automatically determined from training data or previous layer settings)},{'activation':'ReLU','out_n':32}],# Training parameters'mini_batch_n':10000,# Number of iterations for training (mini-batch training)'mini_batch_size':512# Mini-batch size}概要深層学習(pytorch)による分位点回帰を簡単に実施できるツール推論データにおける分位点順序の入れ替わり不具合を自動的に補正する「パラメータ等指定無し」から「詳細なパラメータ設定」まで自由なカスタマイズ粒度で扱えるデータ次元数の設定がdefine-by-runで初回学習時に自動で設定される使用例importdeep_q_reg# データ準備train_x=load_x_data()# [[0.538], [0.469], ...]train_y=load_y_data()# [24.0, 21.6, ...]# パラメータparams={}# このように省略してもよい。詳細な指定の仕方は後述# 深層分位点回帰 [deep_q_reg]dqr=deep_q_reg.Deep_Q_Reg(params)# 学習 [deep_q_reg]dqr.train(train_x,train_y)# 推論 [deep_q_reg]pred_y=dqr.predict(test_x)paramsの指定詳細paramsは下記のように指定します。省略された指定値は自動的にdefault値が補完されます。params={'normalize_x':True,# xの自動正規化'quant_ls':[0.25,0.5,0.75],# 予測対象分位点一覧# 層構成'layers':[{'activation':'ReLU',# 活性化関数名 (torch.nn配下の名前を指定する。Tanh, ReLU, Sigmoid など)'out_n':32# 層の出力次元数 (入力次元数は学習データや前層設定から自動的に判断される)},{'activation':'ReLU','out_n':32}],# 学習パラメータ'mini_batch_n':10000,# 繰り返し学習回数 (ミニバッチ学習)'mini_batch_size':512# ミニバッチのサイズ}
Package: deepqt
DeepQtHarness the power of the DeepL API with this friendly user interface.FeaturesBatch processing.Higher-level glossaries.How do they work?Apply replacements even without translating any of the text.Support for plain text and epub files.RequiresA DeepL API license, either free or pro.How do I get this?A Python installation, version3.10or higher. On Linux you will probably already have this installed. On Windows, you will likely need to set it up.Download Python | Python.orgor use your package manager (apt, pacman, dnf, chocolatey, winget etc.)InstallationDownload the latest release fromPyPI.pip install deepqtOr on Arch Linux (and derivatives) via theAUR.yay -S deepqtRun it withdeepqtfrom the terminal if installed with pip, or like any other application if installed another way.Or download a prepackaged format from thereleasespage:.whl (Manual pip installation).elf (Linux).exe (Windows)RoadmapBuild AppImage or Flatpak.
Package: deepquantiles
Deep Continuous Quantile RegressionThis package explores different approaches to learning the uncertainty,
and, more generally, the conditional distribution of the target variable. We introduce a new type of network, the "Deep Continuous Quantile Regression Network", that approximates the inverse conditional CDF directly by a mult-layer perceptron, instead of relying on variational methods which require priors on the functional form of the distribution. In many cases we find that it presents a robust alternative to well-known Mixture Density Networks`.This is particularily important whenthe mean of the target variable is not sufficient for the use casethe errors are heteroscedastic, i.e. vary depending on input featuresthe errors are skewed, making a single summary statistic such as variance inadequate.We explore two main approches:fitting a mixture density modellearning the location of conditional qunatiles,q, of the distribution.Our mixture density network exploits an implementation trick to achieve negative-log-likelihood minimisation inkeras.Same trick is useed to optimize the "pinball" loss in quantile regression networks, and in fact can be used to optimize an arbitrary loss function of(X, y, y_hat).Within the quantile-based approach, we further explore:
a. fitting a separate model to predict each quantile
b. fitting a multi-output network to predict multiple quantiles simultaneously
c. learning a regression onXandqsimultanesously, thus effectively
learning the complete (conditional) cumulative density function.InstallationInstall package from source:pip install git+https://github.com/ig248/deepquantilesOr from PyPi:pip install deepquantilesUsagefrom deepquantiles import MultiQuantileRegressor, InverseCDFRegressor, MixtureDensityRegressorAs this package is largely an experiment, please explore the Jupyter notebooks and expect to look at the source code.Contentdeepqunatiles.regressors: implementation of core algorithmsdeepquantiles.presets: a collection of pre-configured estimators and settings used in experimentsdeepquantiles.datasets: functions used for generating test datadeepquantiles.nb_utils: helper functions used in notebooksnotebooks: Jupyter notebooks with examples and experimentsTestsRunmakedev-install
makelint
maketestReferencesMixture Density Networks, Christopher M. Bishop,NCRG/94/004 (1994)
Package: deepracer-utils
Deepracer Utilities - Analyzing Your DeepRacer ModelThis is a set of utilities that will take your DeepRacer experience to the next level by allowing you to analyze your model, step by step, episode by episode. Only through analyzing what your model does will you be able to write the right reward function, choose the right action space and to tune the hyperparameters!InstallationYou can install the latest version of deepracer-utils via pip throughpip install deepracer-utilsOtherwise you can build your own version withpython3 setup.py build
python3 setup.py installAWS CLI and boto3 extensionThis package contains an extension to the AWS CLI and Boto3 that allows you to interact
with the Deepracer Console through commands starting withaws deepracer. For details runaws deepracer helpThen run this to install:python -m deepracer install-cliTo remove deepracer support from aws-cli and boto3, run:python -m deepracer remove-cliAbout the UtilitiesThe best reference on how to use the utilities can be found in thedeepracer-analysisJupyter notebooks.An overview of the different modules provided, and the key classes involved:ModuleClassDescriptiondeepracer.logsDeepRacerLogClass that is pointed to a Deepracer Model folder, locally or in an S3 bucket, and that reads in and processes trace files from simtrace or robomaker log files.deepracer.logsAnalysisUtilsClass that processes the raw log input and summarizes by episode.deepracer.logsPlottingUtilsClass that visualises the track and plots each step in an episode.deepracer.logsTrainingMetricsClass that reads in Metrics data and provides data similar to the training graph in the Console.deepracer.consoleConsoleHelperClass that reads out logfiles directly from the console, and together with e.g. TrainingMetrics can be used to visualize training progress in real time.deepracer.tracksTrackIOClass that processes track routes (.npy files) and displays waypoints graphically.deepracer.modeln/aMethods to run inference on individual images and to perform visual analysis.Other informationRefer todevelopment.mdfor instructions on coding standards, unit tests etc.Refer toexamples.mdfor usage guidance.LicenseThis project retains the license of theaws-deepracer-workshopsproject which has been forked for the initial Community contributions.
Our understanding is that it is a license more permissive than the MIT license
and allows for removing of the copyright headers. We have decided to preserve
the headers and only add copyright notice for the Community.Standards and good practices, contributingWhile doing our best to make deepracer-utils an outcome of best practices and standards,
we are using what we learn, as we learn. If you see a solution that would be better to
apply, if you see something that is a risk, do raise it with the Community. Thank you.We are open to merge requests. Please open an issue first to agree on the outcomes of
your work.ContactYou can contact Tomasz Ptak through the Community Slack:http://join.deepracing.io