Saravanan666/pypi-org huggingface dataset:
Package: deepthink
DeepThinkDeepThink is a deep learning library for Python, designed as a learning project and as a resource for others looking to learn about deep learning. It provides a high-level interface for building, training, and evaluating deep learning models, as well as a range of utilities for working with data and optimizing models.FeaturesA high-level API for defining, training, and evaluating models with minimal codeUtilities for data loading, preprocessing, and model evaluationTools for debugging, profiling, and optimizing modelsA range of examples to illustrate several use casesPlease note that DeepThink is a basic deep learning library and may not have the same level of performance or support for advanced features as other more established deep learning libraries.Installationpip install deepthinkQuickstartHere is a simple example of how to use DeepThink to train a deep learning model:fromdeepthink.optimizersimportAdamfromdeepthink.layersimportDense,Conv2D,MaxPooling,Flattenfromdeepthink.modelimportModelfromdeepthink.activationsimportReLU,Softmaxfromdeepthink.utilsimportload_mnist_datafromdeepthink.lossimportCategoricalCrossEntropy# Load datasettraining_data,test_data=load_mnist_data()# Creating a modeloptimizer=Adam(0.001)model=Model(optimizer,cost=CategoricalCrossEntropy(),batch_size=64)model.add_layer(Conv2D(kernel_size=5,n_filters=8,input_shape=(64,1,28,28)))model.add_layer(ReLU())model.add_layer(MaxPooling())model.add_layer(Flatten())model.add_layer(Dense(16))model.add_layer(ReLU())model.add_layer(Dense(10))model.add_layer(Softmax())model.initialize()# Train the modelhistory=model.train(training_data,test_data,epochs=5)You can find additional examples in the examples directory.ContributingContributions are more than welcome to DeepThink! If you would like to report a bug, request a feature, or contribute code, please create an issue or submit a pull request.LicenseDeepThink is released under the MIT License.
Package: deepthread
deepthreadRich chat threads for AI agentsExplore the docs »View Demo·Report Bug·Request FeatureDeepthread enables robust chat experiences with AI agents. It offers a Python backend for managing thread state as well as a React chat interface.We supportAgentscriptfor beautiful UI experiences.BackendInstallationpip install deepthreadUsageRole ThreadsCreate a role based threadfromdeepthreadimportThreadthread=Thread()thread.post("user","Hello, Thread!")# output in openai chat schema formatprint(thread.to_oai())FrontendInstallationnpm i @agentsea/deepthreadDevelopTo testmaketestTo publishmakepublish
Package: deeptime
deeptimeDeeptime is a general purpose Python library offering various tools to estimate dynamical models
based on time-series data including conventional linear learning methods, such as Markov State
Models (MSMs), Hidden Markov Models (HMMs) and Koopman models, as well as kernel and
deep learning approaches such as VAMPnets and deep MSMs. The library is largely compatible
with scikit-learn, having a range of Estimator classes for these different models, but in
contrast to scikit-learn also provides Model classes, e.g., in the case of an MSM,
which provide a multitude of analysis methods to compute interesting thermodynamic, kinetic
and dynamical quantities, such as free energies, relaxation times and transition paths.Releases:Installation viacondarecommended,pipcompiles the library locally.conda install -c conda-forge deeptimepip install deeptimeDocumentation:deeptime-ml.github.io.Building the latest trunk version of the package:Using pip with a local clone and pulling dependencies:git clone https://github.com/deeptime-ml/deeptime.git

cd deeptime
pip install .Or using pip directly on the remote:pip install git+https://github.com/deeptime-ml/deeptime.git@main
Package: deep-time-series
DeepTimeSeriesLast update Oct.19, 2022Deep learning library for time series forecasting based on PyTorch.
It is under development and the first released version will be announced soon.Why DeepTimeSeries?DeepTimeSeries is inspired by libraries such asDartsandPyTorch Forecasting. So why was DeepTimeSeries developed?The design philosophy of DeepTimeSeries is as follows:We present logical guidelines for designing various deep learning models for
time series forecastingOur main target users are intermediate-level users who need to develop
deep learning models for time series prediction.
We provide solutions to many problems that deep learning modelers face
because of the uniqueness of time series data.We additionally implement a high-level API, which allows comparatively beginners
to use models that have already been implemented.Supported ModelsModelTarget featuresNon-target featuresDeterministicProbabilisticMLPooooDilated CNNooooVanilla RNNooooLSTMooooGRUooooTransformerooooDocumentationhttps://bet-lab.github.io/DeepTimeSeries/
Package: deeptl
DeepTL is a Python package providing an easy-to-use software
for learning complex topologies with neural networks.DeepTL networks are based on a novel theory (the duality theory)
bridging
two research fields which are usually thought as disjointed:
gradient-based and competitive
neighborhood-based learning.Examples on benchmark datasetsUsing DeepTLfromdeeptlimportDeepTopologicalClusteringX,y=...# load dataset# load and fit the neural modelmodel=DeepTopologicalClustering()model.fit(X)# compute the final graph and plot the resultmodel.compute_graph()model.plot_graph(y)AuthorsPietro BarbieroLicenceCopyright 2020 Pietro Barbiero.Licensed 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 at:http://www.apache.org/licenses/LICENSE-2.0.Unless 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-toggl
DEEP TOGGLOpen source project based ontoggl_cliapis to get summaries from yourtogglprofileINSTALLClone repositoy athttps://github.com/gianscarpe/toggl_personal_evaluationInstall using pippython -m pip install .USEFrom CLI, calldeep_togglLICENSEPermission 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.f
Package: deepTools
deepTools addresses the challenge of handling the large amounts of data
that are now routinely generated from DNA sequencing centers. deepTools
contains useful modules to process the mapped reads data for multiple
quality checks, creatingnormalized coverage filesin standard
bedGraph and bigWig file formats, that allow comparison between
different files (for example, treatment and control). Finally, using
such normalized and standardized files, deepTools can create many
publication-readyvisualizationsto identify enrichments and for
functional annotations of the genome.For support or questions please make a post onBiostars. For feature requests, please open an issue ongithub.For further documentation, please see ourread the docs page.Citation:Ramírez F, Ryan DP, Grüning B, Bhardwaj V, Kilpert F, Richter AS, Heyne
S, Dündar F, Manke T.deepTools2: a next generation web server for
deep-sequencing data
analysis.Nucleic Acids Research. 2016 Apr 13:gkw257.
Package: deeptracy-core
Deeptracy CoreCore package for deeptracyProject sitehttps://github.com/bbva/deeptracyIssueshttps://github.com/bbva/deeptracy/issues/Documentationhttps://deeptracy.readthedocs.org/DockerHubhttps://hub.docker.com/r/bbvalabs/deeptracy/DescriptionThis package contains core classes for data access and plugin developmentContributing to DeeptracyYou can contribute to Deeptracy in a few different ways:Submit issues throughissue trackeron GitHub.If you wish to make code changes, or contribute something new, please follow theGitHub Forks / Pull requests model: fork the s`Deeptracy Repo <https://github.com/bbva/deeptracy/>`_, make the changes and propose it back by submitting a pull request.LicenseThis project is distributed underApache License
Package: deeptracy-core-dev
Deeptracy CoreCore package for deeptracyProject sitehttps://github.com/bbva/deeptracyIssueshttps://github.com/bbva/deeptracy/issues/Documentationhttps://deeptracy.readthedocs.org/DockerHubhttps://hub.docker.com/r/bbvalabs/deeptracy/DescriptionThis package contains core classes for data access and plugin developmentContributing to DeeptracyYou can contribute to Deeptracy in a few different ways:Submit issues throughissue trackeron GitHub.If you wish to make code changes, or contribute something new, please follow theGitHub Forks / Pull requests model: fork the s`Deeptracy Repo <https://github.com/bbva/deeptracy/>`_, make the changes and propose it back by submitting a pull request.LicenseThis project is distributed underApache License
Package: deeptrade
DeepTrade Python LibraryThe DeepTrade Python library provides convenient access to the DeepTrade API from
applications written in the Python language. It includes a pre-defined set of
classes for API resources that initialize themselves dynamically from API
responses.DocumentationSee thePython API docs.InstallationYou don't need this source code unless you want to modify the package. If you just
want to use the package, just run:pipinstall--upgradedeeptradeInstall from source with:pythonsetup.pyinstallRequirementsPython 2.7+ or Python 3.4+ (PyPy supported)UsageThe library needs to be configured with your account's secret key which is
available in your [DeepTrade Dashboard][api-keys]. Setdeeptrade.api_keyto its
value:importdeeptradedeeptrade.api_key="123abc_..."# get sentiment by datedeeptrade.Sentiment().by_date(date='2018-02-23',dataframe=True)
Package: deep-trainer
deep-trainerBaseline code to train deep neural networks.
Currently only available for PyTorch Framework.InstallPip$pipinstalldeep-trainerCondaNot yet availableGetting startedimporttorchfromdeep_trainerimportPytorchTrainer# Datasetstrainset=#....valset=#....testset=#....# Dataloaderstrain_loader=torch.utils.data.DataLoader(trainset,64,shuffle=True)val_loader=torch.data.utils.DataLoader(valset,256)test_loader=torch.data.utils.DataLoader(testset,256)# Model & devicedevice=torch.device("cuda"iftorch.cuda.is_available()else"cpu")model=#....model.to(device)# Optimizer & Scheduleroptimizer=torch.optim.Adam(model.parameters(),lr=0.001)scheduler=torch.optim.lr_scheduler.StepLR(optimizer,step_size=len(trainset)*50,0.1)# Decay by 10 every 50 epochs# Criterioncriterion=torch.nn.CrossEntropyLoss()# For classification for instance# Trainingtrainer=PytorchTrainer(model,optimizer,scheduler,save_mode="small",device=device)trainer.train(150,train_loader,criterion,val_loader=val_loader)# Testingtrainer.load("experiments/checkpoints/best.ckpt")trainer.evaluate(test_loader,criterion)Exampleexample/example.pyshow how to train a PreActResNet with Deep Trainer.Install the additional requirements and use it with:$# See hyperparameters available$pythonexample.py-h
$
$# Launch the default training$pythonexample.py
$
$# Once done (or during the training), look for default tensorboard logs$tensorboard--logdirexperiments/logs/This script is reaching around 94-95% accuracy on validation with Cifar10 and a PreActResNet18.Here are thetraining logs:Build and Deploy$python-mbuild
$python-mtwineuploaddist/*
Package: deeptranslit
DeepTranslit: Towards better transliteration for Indic languages.telugu,kannada,tamil,malayalam,marathi,hindiare the current supported languages.UsageVia docker# Start the container in backgrounddockerrun-d-p8080:8080notaitech/deeptranslit:hindi# Query from pythonimportrequestsrequests.post('http://localhost:8080/sync',json={"data":['mera naam amitab.']}).json()As python modulepipinstall--upgradedeeptranslitfromdeeptranslitimportDeepTranslit# hinditransliterator=DeepTranslit('hindi')# Single sentence predictiontransliterator.transliterate('mera naam amitab.')# [{'pred': 'मेरा नाम अमिताब.', 'prob': 0.25336900797483103}]# Multiple sentence predictiontransliterator.transliterate(['mera naam amitab.','amitab-aur-abhishek'])#[[{'pred': 'मेरा नाम अमिताब.', 'prob': 0.25336900797483103}],# [{'pred': 'अमिताब-और-अभिषेक', 'prob': 0.1027598988040056}]]Notes:Tokens (characters) not present in input space (english alphabet) are copied over to output.eg: (amitab.->अमिताब.,amitab-aur-abhishek->अमिताब-और-अभिषेक)Predictions are cached at word level. i.e: computationally,transliterate('amitab amitab')is equivalent totransliterate('amitab')ortransliterate('amitab amitab amitab')
Package: deeptree
DEEPTREEA simple Decision Tree ClassifierOverviewThis project is a custom implementation of a decision tree classifier inspired fromscikit-learn-decision-tree-classifier. The classifier is built from scratch without any external dependencies.Gini index is used by the classifier to construct the decision tree. Using the gini index for partitioning has allowed the classifier to handle both continuous and categorical features. This allows the classifier to be used in a wider range of applications and datasets.In addition, the classifier also includes a basic tree printing functionality, which can be used to visualize the tree structure and gain a better understanding of how the classifier is making its decisions.FeaturesNo external dependenciesHandles both continuous and categorical featuresUses Gini index to measure impurity of partionIncludes basic tree printing functionality for tree visualizationRequirementsPython 3.x
[Optional] Any text editor or IDE of your choice for editing the code.Installationdeeptree can be installed using the following command:pip install deeptreeorpip3 install deeptreeDependenciesdeeptree is built using only in built python libraries.FunctionalitiesThe functions in deeptree package come as part of two classes Node and Classifier. The functions are:-deeptree.Node.get_feature_midpoints(i=0)This function finds the midpoints for any continuous feature corresponding to index 'i' in the dataset.deeptree.Node.get_splitting_subsets(i=0)This function finds the splitting subsets for any discrete feature corresponding to index 'i' in the dataset.deeptree.Node.get_gini_value()This function calculates the gini value of the deeptree node.deeptree.Classifier.fit(dataset=[],label_index=-1)This function trains the decision tree classifier on the given dataset.deeptree.Classifier.predict(dataset=[]):This function predicts the labels/classes of the given dataset.deeptree.Classifier.print_tree(node, level=0)This function prints the structure of the decision tree with the details at each node.Example on how to use deeptree are provided in example.py. The example is based on theiris.datadataset downloaded fromUCI achine learning repository.LicenseMIT LicenseAcknowledgmentsThe source code for this project was created as part of one of the courseworks for MSc. Data Science program at Lancaster University. Thanks to Leandro Soriano Marcolino for his amazing classes and this coursework topic.
Package: deepts-forecasting
DeepTS_ForecastingDeepts_forecastingis a Easy-to-use package for time series forecasting with deep Learning models.
It contains a variety of models, from classics such as seq2seq to more complex deep neural networks.
The models can all be used in the same way, usingfit()andpredict()functions,Free software: MITDocumentationhttps://yunxileo.github.io/deepts_forecasting/FeaturesTODOModels listModelPaperSeq2SeqSequence to Sequence Learning with Neural NetworksDeepARDeepAR: Probabilistic Forecasting with Autoregressive Recurrent NetworksLstnetModeling Long- and Short-Term Temporal Patterns with Deep Neural NetworksMQ-RNNA Multi-Horizon Quantile Recurrent ForecasterN-BeatsN-BEATS: Neural basis expansion analysis for interpretable time series forecastingTCNAn empirical evaluation of generic convolutional and recurrent networks for sequence modelingTransformerAttention Is All You NeedInformerInformer: Beyond Efficient Transformer for Long Sequence Time-Series ForecastingAutoformerAutoformer: Decomposition Transformers with Auto-Correlation for Long-Term Series ForecastingTFTTemporal Fusion Transformers for Interpretable Multi-horizon Time Series ForecastingMAEMasked Autoencoders Are Scalable Vision LearnersLICENSEThis project is licensed under the MIT License - see the LICENSE file for details.CreditsThis package was created withCookiecutterand thezillionare/cookiecutter-pypackageproject template.
Package: deeputilities
DeepUtilitiesWhat is it?Pipeline for developing, training, and diagnosing machine learning algorithmsWhy do we need it? Why is it useful?There are standard methods for pre-processing, training, and diagnosing algorithms; why should everyone reinvent the wheel every time?Let's standardize and grow the library of diagnostics for science analyses with machine learning!General Featuresmodularity - replaceable/extensible pipeline elementsfully connected pipeline elementsgood for both TensorFlow and PyTorchRequirementspython 3.xmore, but not sure yet.ExamplePipeline FlowIngestPre-processTrainTestEvaluteReportOriginal Development TeamPraveen BalajiJoao CaldeiraCallista ChristAleksandra CiprijanovicAnand JainFrancois LanusseBrian NordMarwah RoussiAmanda WhaleyHow to contributeI'm really glad you're reading this, because we need volunteer developers to help this project come to fruition.Submitting changesPlease send aGitHub Pull Request to DeepUtilitieswith a clear list of what you've done (read more aboutpull requests). When you send a pull request, we will love you forever if you include examples. We can always use more test coverage. Please follow our coding conventions (below) and make sure all of your commits are atomic (one feature per commit).Always write a clear log message for your commits. One-line messages are fine for small changes, but bigger changes should look like this:$ git commit -m "A brief summary of the commit
> 
> A paragraph describing what changed and its impact."Coding conventionsStart reading our code and you'll get the hang of it. We optimize for readability:We indent using tabsWe ALWAYS put spaces after list items and method parameters ([1, 2, 3], not[1,2,3]), around operators (x += 1, notx+=1), and around hash arrows.This is open source software. Consider the people who will read your code, and make it look nice for them. It's sort of like driving a car: Perhaps you love doing donuts when you're alone, but with passengers the goal is to make the ride as smooth as possible.
Package: deep-utils.deduplication
Document De-DuplicationA module for creating and indexing document character trigrams.Installationpip install deep_utils.deduplicationA use case scenarioSuppose we have an elasticsearch indexmy-indexsetup inAWSwith vector namevector1of size 10000fromdeep_utils.deduplication.utilsimportes_wrapperfromdeep_utils.deduplication.vector_generatorimportcreate_trigram_vectorfromdeep_utils.deduplication.elasticsearchimportsearch_similar,add_to_indexes=es_wrapper('<aws endpoint>','aws_region')text_document:str='this is test document'vector=create_trigram_vector('en',text_document)similar_docs_resp=search_similar(10,('vector1',vector),'my-index',es)total=search_similar_resp['hits']['total']max_score=search_similar_resp['hits']['max_score']docs_ids=[x['_id']forxinsimilar_docs_resp['hits']['hits']]docs_scores=[x['_score']forxinsimilar_docs_resp['hits']['hits']]# To add document to indexresp=add_to_index(doc_id='1',vectors=dict(vector1=vector),index_name='my-index',es=es)hasError=resp['errors']MotivationCan be foundhereScriptsThere arescriptsthat generate trigrams from leads(documents) in DEEP.ModulestrigramsJust the collection of relevant trigrams foren,esandfrlanguages.fromdeep_utils.deduplication.trigramsimporten,es,fren_trigrams=en.trigrams# [' th', 'the', 'he ', ....]es_trigrams=es.trigramsfr_trigrams=fr.trigramsNOTE: The trigrams contain 10000 relevant trigrams. So, the vector created will have dimension 10000.utilsConsists of following functions:# This is a wrapper function for creating Elasticsearch objectes_wrapper(endpoint:str,region:str,profile_name:str='default')->Elasticsearch`remove_puncs_and_extra_spaces(text: str) -> str` which is used for preprocessing textsvector_generatorcreate_trigram_vector(lang:str,text:str)->List[float]create_count_vector(processed_text:str,trigrams:Dict[str,int])->List[int]normalize_count_vector(count_vector:List[int])->List[float]elasticsearchsearch_similar(similar_count:int,vector:Tuple[str,List[float]],index_name:str,es:Elasticsearch)add_to_index(doc_id:int,vectors:Dict[str,List[float]],index_name:str,es:Elasticsearch)index_exists(index_name:str,es:Es)->boolcreate_knn_vector_index(index_name:str,vector_size:int,es:Es,ignore_error:bool=False)->Tuple[bool,ErrorString]create_knn_vector_index_if_not_exists(index_name:str,vector_size:int,es:Es)->Tuple[bool,ErrorString]
Package: deepvec
Tensorflow wrapper for classificationRequirementsPython +3.xInstallationpipinstalldeepvecNotesThe library is for classification datasets (labeled).The library accepts CSV of two columns, text (sentences) column and label column (numeric data only).The library transforms text to vector, extracts features from vectors then classifies.Usagefromdeepvec.deep_vecimportDeepVecobj=DeepVec(path='/path/to/file.csv',feature='text_col',label='label_col')data_frame=obj.prepare()obj.proceed(data_frame)ContributingYou are welcome.LicenseThe library is available as open source under the terms of theMIT License.
Package: deepvelo
DeepVelo - A Deep Learning-based velocity estimation tool with cell-specific kinetic ratesThis is the official implementation of theDeepVelomethod.
DeepVelo employs cell-specific kinetic rates and provides more accurate RNA velocity estimates for complex differentiation and lineage decision events in heterogeneous scRNA-seq data. Please check out the paper for more details.InstallationpipinstalldeepveloUsing GPUThedglcpu version is installed by default. For GPU acceleration, please install a properdgl gpuversion compatible with your CUDA environment.pipuninstalldgl# remove the cpu version# replace cu101 with your desired CUDA version and run the followingpipinstall"dgl-cu101>=0.4.3,<0.7"Install the development versionWe use poetry to manage dependencies.poetryinstallThis will install the exact versions in the providedpoetry.lockfile. If you want to install the latest version for all dependencies, use the following command.poetryupdateUsageWe provide a number of notebooks in theexmaplesfolder to help you get started. DeepVelo fullly integrates withscanpyandscVelo. The basic usage is as follows:importdeepveloasdvimportscveloasscvadata=...# load your data in AnnData format# preprocess the datascv.pp.filter_and_normalize(adata,min_shared_counts=20,n_top_genes=2000)scv.pp.moments(adata,n_neighbors=30,n_pcs=30)# run DeepVelo using the default configstrainer=dv.train(adata,dv.Constants.default_configs)# this will train the model and predict the velocity vectore. The result is stored in adata.layers['velocity']. You can use trainer.model to access the model.Fitting large number of cellsIf you can not fit a large dataset into (GPU) memory using the default configs, please try setting a smallinner_batch_sizein the configs, which can reduce the memory usage and maintain the same performance.Currently the training works on the whole graph of cells, we plan to release a flexible version using graph node sampling in the near future.