Saravanan666/pypi-org huggingface dataset:
Package: deepstochlog
DeepStochLogInstallationInstalling SWI PrologDeepStochLog requiresSWI Prologto run.
Run the following commands to install:sudo apt-add-repository ppa:swi-prolog/stable
sudo apt-get update
sudo apt-get install swi-prologInstalling DeepStochLog packageTo install DeepStochLog itself, you can download this repository and run the following command:python setup.py installRunning the examplesLocal dependenciesTo see DeepStochLog in action, please first installSWI Prolog(as explained about),
as well as the requirements listed inrequirements.txtpip install -r requirements.txtDatasetsThe datasets used in the tasks used to evaluate DeepStochLog can be found in ourinitial release.Addition exampleTo see DeepStochLog in action, navigate toexamples/additionand runaddition.py.The neural definite clause grammar specification is provided inaddition.pl.
Theaddition(N)predicate specifies/recognises that two handwritten digitsN1andN2sum toN.
The neural probabilitynn(number, [X], Y, digit)makes the neural network with namenumber(a MNIST classifier) label input image X with the digit Y.Credits & Paper citationIf use this work in an academic context, please consider citingthe following paper:The paper is also accepted toAAAI22.
Please cite that version of the paper when the proceedings are out.@article{winters2021deepstochlog,
  title={Deepstochlog: Neural stochastic logic programming},
  author={Winters, Thomas and Marra, Giuseppe and Manhaeve, Robin and De Raedt, Luc},
  journal={arXiv preprint arXiv:2106.12574},
  year={2021}
}
Package: deepstreampy
# deepstreampyA Python client for deepstream.io[![Build Status](https://travis-ci.org/YavorPaunov/deepstreampy.svg)](https://travis-ci.org/YavorPaunov/deepstreampy)
[![Coverage Status](https://coveralls.io/repos/github/YavorPaunov/deepstreampy/badge.svg)](https://coveralls.io/github/YavorPaunov/deepstreampy)
Package: deepsurfer
DeepSurferDeepSurfer is a deep-learning toolbox for analysis of human brain MRIAH:Probably good to keep this as a private repo until we decide on how we want to use this library or if we want to rename it / move it somewhere else etc. I'm still making updates, mainly to the surface related stuff as I try to finish the TopoFit paper, but definitely feel free to make changes or extensions as you see fit. I'll try to update documentation as I go along.OverviewThis package aims to 1. avoid the plague of code redundancy for building and training models and 2. make it easier to actually distribute these tools to users who don't care about the underlying implementation. It's all built on top of pytorch, which also makes things super easy to deploy.Usage:From a user standpoint, utilities/models are accessible through thedscommand, which should be added to the user's path whenever deepsurfer is installed through pip (in the future ideally). Similar to how git is organized, thedscommand is a base command that can be followed by a subcommand to access a specific tool. For example,ds trainwill train a model,ds skull-stripwill run the skull-stripping inference, etc. Thedscommand is a small executable at the top-level directory, so to get an idea of how it works, run:./dshelpInstallationIt's not on PyPi or anything yet. The only non-standard dependencies aretorch >= 1.12,surfa >= 0.5.0,scipy, andpyyaml, and the current python requirement is at least 3.7. No other steps should be necessary for running inference at this point, but if you want to actually train models, see the notes below.Training:All of the models that I've implemented so far build on thevoxsynthlibrary for image synthesis and augmentation. That's also not on pip (yet), but you can clone it from that link. It doesn't have any crazy dependencies, and it's only required for training.TopoFit:If you want to train a TopoFit model, you'll have to build the nearest-neighbor CUDA extension to speed up the optimization. It should be relatively easy if you use conda, but there are a few specific steps that need to be run -- outlined in the docstring ofthis function.DocumentationI started info-dumping everything into a single page but realized it just makes more sense to organize a bit. I copied the template I used for the surfa website into thedocs/subdirectory. It uses sphinx, which is a markdown-style documentation framework that renders to html. It's a pretty common doc method in the python world. Anyway, I set up a temporary auto-buildhere(you can't view it without an nmr account). So far I wrote an overview of how to use each tool, along with some development documentation, but for now the site is 50% just placeholder stuff as a potential outline for public facing documentation. We can always change or ditch it, but it also might be a good way to host relevant paper pages.
Package: deepsurv
DeepSurv implements a deep learning generalization of the Cox proportional hazards model using Theano and Lasagne.DeepSurv has an advantage over traditional Cox regression because it does not require ana prioriselection of covariates, but learns them adaptively.DeepSurv can be used in numerous survival analysis applications. One medical application is provided, recommend_treatment, which provides treatment recommendations for a set of patient observations.Installation:Dependencies:Theano, Lasagne, lifelines, matplotlib (for visualization) and all of their respective dependencies.Installing:You can installDeepSurvusingpip install deepsurvfrom the command line.Running the tests:After installing, you can optionally run the test suite withpy.testfrom the command line while in the module main directory.Training a Network:Training DeepSurv can be done in a few lines.
First, all you need to do is prepare the datasets to have the following keys:{
        'x': (n,d) observations (dtype = float32),
        't': (n) event times (dtype = float32),
        'e': (n) event indicators (dtype = int32)
}Then prepare a dictionary of hyper-parameters. And it takes only two lines to train a network:network = deepsurv.DeepSurv(**hyperparams)
log = network.train(train_data, valid_data, n_epochs=500)You can then evaluate its success on testing data:network.get_concordance_index(**test_data)
>> 0.62269622730138632If you have matplotlib installed, you can visualize the training and validation curves after training the network:deepsurv.plot_log(log)License:MIT LicenseCopyright (c) 2016, Jared KatzmanPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: deepsurvk
Implementation of DeepSurv using KerasMotivation•Features•Documentation•License•References•Credits:pray: MotivationDeepSurv is a Cox Proportional Hazards deep neural network used for modeling interactions between a patient's covariates and treatment effectiveness. It was originally proposed byKatzman et. al (2018)andimplemented in Theano (using Lasagne).Unfortunately,Theano is no longer supported. There have been some attempts in recreating DeepSurv in other DL platforms, such asczifan'sDeepSurv.pytorch. However, given its popularity and ease of use, I think TensorFlow 2's Keras is a great option for this task.mexchy1000 createdDeepSurv_Keras. However, it is a very raw prototype: it is not properly documented nor validated. Moreover, it is not being actively supported anymore. Therefore, I used it as a rough starting point for the development of DeepSurvK.This is my first Python package. I am sure there are many places where it could be improved. Feedback is always welcome!:tada: FeaturesImplemented using Keras (using TensorFlow 2)Includes the original datasets together with a proper description of the variablesDesigned with data as pandas DataFrames in mindVisualization tools for the most common plots for fast and easy exploration and prototypingTreatment recommender(Basic) hyperparameter optimization using grid and randomized search:bookmark_tabs: DocumentationYou can find the complete package's documentationhere. Unfortunately, I haven't had as much time as I would like to work on it. Alternatively, I strongly recommend you take look at theexample notebooks.:page_with_curl: LicenseThis package uses the MIT license:black_nib: ReferencesIf you are using DeepSurvK, please cite the original DeepSurv paper, as well as the current repository as follows:Katzman, Jared L., et al."DeepSurv: personalized treatment recommender system using a Cox proportional hazards deep neural network."BMC medical research methodology 18.1 (2018): 24. [BibTeX]Arturo Moncada-Torres. DeepSurvK. Accessed on [MONTH, 20XX].:label: CreditsThis package was developed inSpyder(a fantastic open-source Python IDE) usingCookiecutterand thearturomoncadatorres/cookiecutter-pypackageproject template.
Package: deep-svdd
# Tensorflow Implementation of Deep SVDD
This repository provides a [Tensorflow](https://www.tensorflow.org/) implementation of theDeep SVDDmethod presented in
ICML 2018 paper ”Deep One-Class Classification”.The author’s implementation ofDeep-SVDDin PyTorch is at [https://github.com/lukasruff/Deep-SVDD-PyTorch](https://github.com/lukasruff/Deep-SVDD-PyTorch).## Citation and Contact
You find a PDF of the Deep One-Class Classification ICML 2018 paper at
[http://proceedings.mlr.press/v80/ruff18a.html](http://proceedings.mlr.press/v80/ruff18a.html).## Installation
This code is written inPython 3.5and tested withTensorflow 1.12.Install using pip or clone this repository.1. Installation using pip:`bash pip installdeep-svdd`and`python from dsvdd import DeepSVDD `Clone this repository:`bash git clonehttps://github.com/nuclearboy95/Deep-SVDD-Tensorflow.git`
Package: deepsvr
Cancer genomic analysis requires accurate identification of somatic variants in sequencing data. Manual review to refine somatic variant calls is required as a final step after automated processing. However, manual variant refinement is time-consuming, costly, poorly standardized, and non-reproducible. Here, we systematized and standardized somatic variant refinement using a machine learning approach. The final model accurately recapitulated manual somatic variant refinement labels using an independent testing set and accurately predicted somatic variants confirmed by orthogonal validation sequencing data. The model improves on manual somatic variant refinement by reducing bias on calls usually subject to high inter-reviewer variability.
Package: deepsynth-gitract
deepsynth-gitractGenerate deepsynth-gitract images.InstallationUse the package managerpipto install deepsynth-gitract.pipinstalldeepsynth-gitractUsageRun on CPU (default setting)TBA-YouhavetohaveaNVIDIAGPUtorunthispackage.WeareworkingonCPUversion.Run on GPU - generation processimportdeepsynth_gitractdeepsynth_gitract.generate(name,result_dir,checkpoint_dir,num_img_per_tile,num_of_outputs,trunc_psi=0.75):""" Generate deepsynth Gastrointestinal tract images.Keyword arguments:name -- Any name to keep trac of generationsresult_dir -- A directory to save outputcheckpoint_dir -- A directory to download pre-trained checkpointsnum_img_per_tile -- Number of images per dimenstion of the gridnum_of_outputs -- Number of outputs to generatetrunc_psi -- value between 0.5 and 1.0 (default 0.75)"""Run on GPU - to generate interpolations between random pointsdeepsynth_gitract.generate_interpolation(name,result_dir,checkpoint_dir,num_img_per_tile,num_of_outputs,num_of_steps_to_interpolate,save_frames,trunc_psi=0.75):""" Generate deepsynth Gastrointestinal tract images.Keyword arguments:name -- Any name to keep trac of generationsresult_dir -- A directory to save outputcheckpoint_dir -- A directory to download pre-trained checkpointsnum_img_per_tile -- Number of images per dimenstion of the gridnum_of_outputs -- Number of outputs to generatenum_of_steps_to_interpolate -- Number of step between two random pointssave_frames -- True if you want frame by frame, otherwise .gif will be generatedtrunc_psi -- value between 0.5 and 1.0 (default 0.75)"""ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.For more details:Please contact:vajira@simula.no,michael@simula.noLicenseMIT
Package: deep-talk
Project Description** The system uses packagetext_graph_craftsbased on dependency links for building Text Graphs, that with help of a centrality algorithm likePageRank, extract relevant keyphrases, summaries and relations from text documents.ASWI-Prologbased module adds an interactive shell for talking about the document with a dialog agent that extracts for each query the most relevant sentences covering the document. Spoken dialog is also available if the OS supports it. Developed withPython 3, on OS X, but portable to Linux.**Dependencies:python 3.7 or newer, pip3, java 9.x or newer, SWI-Prolog 8.x or newer, graphvizalso, having git installed is recommended for easy updatespip3 install text_graph_craftssee how to activate other outputs in filehttps://github.com/ptarau/TextGraphCrafts/blob/master/text_graph_crafts/deepRank.pyThe second is activated withpython3 -i qpro.pyor the shorthand scriptqgo.It requires SWI-Prolog to be installed and available in the path as the executableswipland the Python to Prolog interfacepyswip, to be installed withpip3 install pyswipIt activates a Prolog process to which Python sends interactively queries about a selected document. Answers are computed by Prolog and then, if the parameterquietis off, spoken using thesayOS-level facility (available on OS X and Linux machines.Prolog relation files, generated on the Python side are associated to each document as well as the queries about it. They are stored in the same directory as the document.Try>>> t1() 
...
>>> t9()
>>> t0()

or

>>> chat('const')

to interactively chat about the US Constitution. The same
for other documents in the examples folder.

### Handling PDF documents

The easiest way to do this is to install *pdftotext*, which is part of [Poppler tools](https://poppler.freedesktop.org/).

If pdftotext is installed, you can place a file like *textrank.pdf*
already in subdirectory pdfs/ and try something similar to:pdf_chat('textrank')which activates a dialog about the TextRank paper. Alsopdf_chat('logrank')activates a dialog about *pdfs/logrank.pdf*, which describes
the architecture of the current system.

Change setting in file params.py to use the system with
other global parameter settings.
Package: deep-tcn
Temporal Convolutional Networks (Deep-TCN) in PyTorchThis repository provides an implementation of Temporal Convolutional Networks (TCN) [1] in PyTorch, with focus on
flexibility and fine-grained control over architecture parameters.Additionally, it incorporates separable convolutions
and pooling layers, contributing to the creation of more streamlined and computationally efficient networks.InstallationUsing pip:pipinstalldeep-tcnTo install the dependencies for examples, runpipinstalldeep-tcn[examples]Alternatively, you can clone the repository and install the package using poetry:poetryinstallThis time, to install the dependencies needed to run the examples, runpoetryinstall--allextrasFeaturesCausal Convolutions:Causal convolutions are employed, making the architecture suitable for sequential data.Separable Convolutions:The implementation includes support for separable convolutions, aiming to reduce the overall number of network parameters.(Channel) Pooling Layers:Channel pooling layers are integrated to further enhance the efficiency of the network by reducing dimensionality.Flexible Depth Configuration:Optionally, network depth can be increased by adding nondilated convolutions after dilated convolutional layers.Residual Blocks with Full Preactivation:Residual blocks are designed following the "full preactivation" design, according to [2]Supported Normalization Layers:Group NormalizationWeight NormalizationBatch NormalizationUsagePlease refer to the scripts underexamples/as a starting point.References[1] He et al.: Identity Mappings in Deep Residual Networks. ArXiv, 2016.Link[2] Lea et al.: Temporal Convolutional Networks: A Unified Approach to Action Segmentation. ArXiv, 2016.Link
Package: deeptech
DeeptechA library that helps with writing ai functions fast.It ships with a fullDocumentationof its API andExamples.Getting StartedPlease make sure you have pytorch installed properly as a first step.pipinstalldeeptechThen follow one of theexamplesor check out theapi documentation.Design PrinciplesThe api builds on three core parts: Data, Model or Training. Some parts which are considered core functionality that is shared among them is in the core package.Datais concerned about loading and preprocessing the data for training, evaluation and deployment.Modelis concerned with implementing the model. Everything required for the forward pass of the model is here.Trainingcontains all required for training a model on data. This includes loss, metrics, optimizers and trainers.Corecontains functionality that is shared across model, data and training.Tutorials & ExamplesStarting with tutorials and examples is usually easiest.Simple Fashion MNIST Examples:Fasion MNIST: SimpleFasion MNIST: Custom ModelFasion MNIST: Custom LossTODOFasion MNIST: Custom OptimizerFasion MNIST: Custom DatasetFashion MNISTHere is the simplest mnist example, it is so short it can be part of the main readme.fromdeeptech.data.datasetsimportFashionMNISTDatasetfromdeeptech.model.modelsimportImageClassifierSimplefromdeeptech.training.trainersimportSupervisedTrainerfromdeeptech.training.lossesimportSparseCrossEntropyFromLogitsfromdeeptech.training.optimizersimportsmart_optimizerfromdeeptech.coreimportConfig,clifromtorch.optimimportSGDclassFashionMNISTConfig(Config):def__init__(self,training_name,data_path,training_results_path):super().__init__(training_name,data_path,training_results_path)# Config of the dataself.data_dataset=FashionMNISTDataset# Config of the modelself.model_model=ImageClassifierSimpleself.model_conv_layers=[32,32,32]self.model_dense_layers=[100]self.model_classes=10# Config for trainingself.training_loss=SparseCrossEntropyLossFromLogitsself.training_optimizer=smart_optimizer(SGD)self.training_trainer=SupervisedTrainerself.training_epochs=10self.training_batch_size=32# Run with parameters parsed from commandline.# python -m deeptech.examples.mnist_simple --mode=train --input=Datasets --output=Resultsif__name__=="__main__":cli.run(FashionMNISTConfig)ContributingCurrently there are no guidelines on how to contribute, so the best thing you can do is open up an issue and get in contact that way.
In the issue we can discuss how you can implement your new feature or how to fix that nasty bug.To contribute, please fork the repositroy on github, then clone your fork. Make your changes and submit a merge request.Origin of the NameThe name is a tribute to thedeeptech:ai hackathon.
When writing the library for fast, accessible ai development, I remembered how helpfull such a library could have been for a hackathon.
Thus, I decided to name it as a tribute to that hackathon.And besides, the name does not seem to be used for any company or library and sounds cool, at least to me.
;)LicenseThis repository is under MIT License. Please see thefull license here.
Package: deeptext
deeptextA cross-platform framework for deep learning based text detection, recoginition and parsingGetting startedInstallationInstall using conda for Linux, Mac and Windows (preferred):conda install -c fcakyon deeptextInstall using pip for Linux and Mac:pip install deeptextInstallteserract-ocrfor text recognition.Basic Usage# import packageimportdeeptext# set image path and export folder directoryimage_path='idcard.png'output_dir='outputs/'# apply text detection and export detected regions to output directorydetection_result=deeptext.detect_text(image_path,output_dir)# apply text recognition to detected textsrecognition_result=deeptext.recognize_text(image_path=detection_result["text_crop_paths"])Advanced UsageYou can pass filter parameters if you want to scrap texts from image by predefined regions.# import packageimportdeeptext# set image path and export folder directoryimage_path='idcard.png'output_dir='outputs/'# define regions that you want to scrap, by quad (box) pointsfilter_params={"type":"box""boxes":[[[0.1460,0.0395],[0.8417,0.0535],[0.8412,0.1099],[0.1455,0.0959]],[[0.3467,0.3398],[0.5417,0.3535],[0.5412,0.4099],[0.3455,0.3959]]],"marigin_x":0.05,"marigin_y":0.05,"min_intersection_ratio":0.9}# or define regions that you want to scrap, by centroidsfilter_params={"type":"centroid","centers":[[0.44,0.49],[0.49,0.08]],"marigin_x":0.03,"marigin_y":0.05}# apply craft text detection in predefined regions and export detected regions to output directorydetection_result=deeptext.detect_text(image_path,output_dir,detector="craft",filter_params=filter_params)# apply tesseract (eng) text recognition to detected textsrecognition_result=deeptext.recognize_text(image_path=detection_result["text_crop_paths"],recognizer="tesseract-eng")Updates6 April, 2020: Conda package release3 April, 2020: Tesseract text recoginition and positional text scraping support30 March, 2020: Craft text detector supportTODOCraft text detection (inference)Ctpn text detection (inference)Psenet text detection (inference)Tesseract text recoginition (inference)Aster text recognition (training and inference)Moran text recognition (training and inference)Positional text scraping
Package: deeptexture
Overviewdeep_texture_representation is a python library to calculate deep texture representations (DTRs) for histology images (Cell Reports, 2022).
Fucntions for plotting the distribution of DTRs, content-based image retrieval, and supervised learning are also implemented.InstallationThe package can be installed withpip:$pipinstalldeeptextureConda environmental files including dependent libraries for various OS are availablehere.To test the successful installation,$gitclonehttps://github.com/dakomura/deep_texture_histology$cddeep_texture_histology$pythoncheck_libraries_and_quick_test.pyPrerequisitesPython version 3.6 or newer.numpytensorflowjoblibPillownmslibmatplotlibscikit-learnseabornpandascv2All the required libraries can be installed with conda yml files.
Seehttps://github.com/dakomura/dtr_envRecommended EnvironmentOSLinux (both CPU and GPU version)Mac (both CPU and GPU version for M1 and M2 chip)Windows (both CPU and GPU version)LicenseThis work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC-BY-NC-SA 4.0)For non-commercial use, please use the code under CC-BY-NC-SA.If you would like to use the code for commercial purposes, please contact us <ishum-prm@m.u-tokyo.ac.jp>.CitationIf you use this library for your research, please cite:Komura, D., Kawabe, A., Fukuta, K., Sano, K., Umezaki, T., Koda, H., Suzuki, R., Tominaga, K., Ochi, M., Konishi, H., Masakado, F., Saito, N., Sato, Y., Onoyama, T., Nishida, S., Furuya, G., Katoh, H., Yamashita, H., Kakimi, K., Seto, Y., Ushiku, T., Fukayama, M., Ishikawa, S.,“Universal encoding of pan-cancer histology by deep texture representations.”Cell Reports 38, 110424,2022.https://doi.org/10.1016/j.celrep.2022.110424DocumentationDocumentation