Saravanan666/pypi-org huggingface dataset:
Package: deep-blue-talks
6.xxx ProjectIf Deep Blue could talk=======================With a GM mind provided by [Stockfish][stockfish].Built with the [chess python package][python-chess].Installation------------```bash$ pip install deep-blue-talks```Run---```bash$ deep-blue-talks```#### OutputIf you enter```bash> board```then you should see```bash8 ♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜7 ♟ ♟ ♟ ♟ ♟ ♟ ♟ ♟6 · · · · · · · ·5 · · · · · · · ·4 · · · · · · · ·3 · · · · · · · ·2 ♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙1 ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖a b c d e f g h>```[Nota Bene][nb]: Depending on your terminal, the colors of the pieces may be inverted. To correct this, toggle the boolean value of the `inverted` setting inside `/usr/local/bin/deep-blue-talks` with `vim` (or any lesser text editor of your choosing). This should be fixed for the 0.3 release.Play----Enter moves in [SAN][san]eg. [The Scholar's Mate][scholars mate]```bash> move e4> move e5> move Qh5> move Nc6> move Bc4> move Nf6> move Qxf7```Commands--------- **help**: see available commands- **resign**: ends the game- **fen**: get or set FEN- **move**: move a piece on the board using SAN- **ask**: ask about a particular move- **advice**: get advice for what to play next- **board**: display the chess board- **engine**: configure [UCI][uci] options for backend chess engineExample Usage-------------Interesting [FEN][fen]```bash$ ./play$ fen "r1b1kb1r/ppq2ppp/2n2n2/1Bpp4/3pP3/2N2N1P/PPP2PP1/R1BQR1K1 w kq - 0 9"$ board$ engine MultiPv 5$ advice$ ask Nh4```[HEAD]: footnote[stockfish]: http://stockfishchess.org/[python-chess]: https://github.com/niklasf/python-chess[nb]: http://en.wikipedia.org/wiki/Nota_bene[san]: http://en.wikipedia.org/wiki/Algebraic_notation_%28chess%29[scholars mate]: http://en.wikipedia.org/wiki/Scholar%27s_mate[uci]: http://wbec-ridderkerk.nl/html/UCIProtocol.html[fen]: http://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation
Package: deepblu-tools
deepblu-toolsDeepblu API toolsA set of tools to get the most out ofDeepblu.Deepblu Backup ToolRetrieves dive logs from Deepblu and exports them inUniversal Dive Data Format(UDDF), which can be imported into other applications that support it, includingSubsurface Divelog.Diving Log, a commercial dive log application for Windows, based its Deepblu import tool on this project.RequirementsMake sure you have Python 3 and pip3 installedInstallationpip3 install deepblu-toolsUsageUsage: deepblu-backup [OPTIONS]


Options:
  -u, --user TEXT         Deepblu username or userid
  -p, --password TEXT     Deepblu password
  -m, --max-logs INTEGER  Maximum number of logs to parse
  -d, --with-drafts       Also pull draft logs. Requires valid
                          credentials
  -o, --outfile TEXT      Write results to this file
  -f, --infile TEXT       For debugging purposes: load data
                          from JSON file instead of API
  --help                  Show this message and exit.Examplesrundeepblu-backup -u userIdto backup all your public logs without personal user information (or if you have no password, e.g. if you created your account using Facebook)rundeepblu_backup -u email -p passwordto backup all your private and public logs with personal user informationadd--with-draftsto include drafts (you will need to use email and password)add--max-logs MAXto limit the number of logs to the most recent number represented byMAXadd--outfile FILENAMEto write the resulting UDDF file toFILENAMEAlternatively, you can use theDeepblu Backup Tool web servicein the above commands, make sure you replaceemailandpasswordwith the information associated with your deepblu account, and note thatuserIdis not your username but the id as found in the URL when visiting your own profile at Deepblu.Tracked dataDive type: Freediving (apnea) or Scuba (open circuit)Dive profile: Deepblu provides a waypoint with temperature and depth every 20 secondsDate and time, visibility, average depth, maximum depth, minimum temperature, dive duration, air temperatureMedia: url, captions and timestamps of video and imagesTank: volume, gas, pressure at start and endDive computer brand and modelDiver detailsBuddiesDivespot: name, latitude and longitudeDivebase: nameNotesKnown issuesNot all data is currently being backed up (some equipment data isn't). I may add more items in the future.Deepblu Autoliker - extra/autoliker.pyLogs you in with a set of accounts defined inLOGINSand automatically likes every post, beginning with the most recent one, untilMAX_LIKESis reached or an earlier like is found.Deepblu Autofollow - extra/autofollow.jsConsole JS script to automatically add a series of Deepblu users inuserIdsto the following list of a logged-in account with tokenauthToken.
Package: deepbookpy
Sui DeepBook Python SDKPython DeepBook Client SDK for Sui blockchain - built by community withpysuiPython Sui DeepBook SDK Parametersfromdeepbookpy.utils.normalizerimportnormalize_sui_object_idCLOCK=normalize_sui_object_id("0x6")DEEPBOOK_PACKAGE_ID=normalize_sui_object_id("dee9")Install deepbookpypip install deepbookpypoetry add deepbookpyDocumentationCheck out latest deepbookpydocumentationreleaseOfficial DeepBook ResourcesOfficial Deepbook Sui WebsiteOfficial Deepbook Sui DocumentationDeepBook PackagesDeepBook Mainnet PackageDeepBook Testnet PackageDeepBook Devnet PackageAsk A QuestionJoin Our Coummunitydiscord
Package: deepbrain
DeepBrainBrain image processing tools using Deep Learning focused on speed and accuracy.Available tools:ExtractorExtract brain tissue from T1 Brain MRI (i.e skull stripping).Extractorruns a custom U-Net model trained on a variety of manual-verified skull-stripping datasets.Why chooseExtractorover others (e.g. BET FSL, ANTs, PINCRAM)?Extractorisfast. It's CNN was implemented on Tensorflow and carefully designed to be as small as possible (i.e. lower amount of parameters). See below for speed comparison. You can achieve < 2 second extraction on GPU.RunningExtractoriseasy. You don't need to provide any complicated parameters (like brain templates or prior probability masks), just with the brain MRI is enough. This is because the model was trained with a data augmentation process that involved all kind of rotations and orientations of the brain MRI. This means that the extraction will be successfull regardless the orientation of the input brain MRI. No registration process is done.Extractorisaccurate. It does not fail in some cases where others (specially BET) fails.SpeedExtractor CPU (i5 2015 MBP)Extractor GPU (Nvidia TitanXP)~20 seconds~2 secondsAccuracyExtractorachieves state-of-the art accuracy >0.97 Dice metricon the test set that is compound with a subset of entries from theCC359 dataset,NFBS datasetandADNI dataset.How to runAs command line program$deepbrain-extractor-ibrain_mri.nii.gz-o~/Desktop/output/Where:-i: the brain MRI that will be skull-stripped. It can be aniiornii.gzimage (or whatever formatnibabelsupports).-o: an output directory (does not need to exist) where the program will save thebrain_mask.niiandbrain.niifiles.Seedeepbrain-extractor -hfor more information.As pythonimportnibabelasnbfromdeepbrainimportExtractor# Load a nifti as 3d numpy image [H, W, D]img=nib.load(img_path).get_fdata()ext=Extractor()# `prob` will be a 3d numpy image containing probability# of being brain tissue for each of the voxels in `img`prob=ext.run(img)# mask can be obtained as:mask=prob>0.5Seedeepbrain-extractor -hfor more information.
Package: deepbrainz-interpreter
An open source implementation of OpenAI's ChatGPTCode interpreter.Simply ask the OpenAI model to do something and it will generate & execute the code for you.Read theblog postto find out more.CommunityJudah Cooper offered to start & curate a Discord community. Joinhere.InstallationOpen a terminal and run:pip install gpt-code-ui
gptcodeIn order to make basic dependencies available it's recommended to run the followingpipinstall
in the Python environment that is used in the shell where you rungptcode:pipinstall"numpy>=1.24,<1.25""dateparser>=1.1,<1.2""pandas>=1.5,<1.6""geopandas>=0.13,<0.14""tabulate>=0.9.0<1.0""PyPDF2>=3.0,<3.1""pdfminer>=20191125,<20191200""pdfplumber>=0.9,<0.10""matplotlib>=3.7,<3.8"User interfaceFeaturesFile uploadFile downloadContext awareness (it can refer to your previous messages)Generate codeRun code (Python kernel)Model switching (GPT-3.5 and GPT-4)Misc.Using .env for OpenAI keyYou can put a .env in the working directory to load theOPENAI_API_KEYenvironment variable.ConfigurablesSet theAPI_PORT,WEB_PORT,SNAKEMQ_PORTvariables to override the defaults.SetOPENAI_BASE_URLto change the OpenAI API endpoint that's being used (note this environment variable includes the protocolhttps://...).You can use the.env.examplein the repository (make sure yougit clonethe repo to get the file first).For Azure OpenAI Services, there are also other configurable variables like deployment name. See.env.azure-examplefor more information.
Note that model selection on the UI is currently not supported for Azure OpenAI Services.cp .env.example .env
vim .env
gptcodeDockerlocalagitook the effort of bundling the Python package in a Docker container. Check it out here:gpt-code-ui-docker.ContributingPlease do and have a look at thecontributions guide! This should be a community initiative. I'll try my best to be responsive.Thank you for your interest in this project!
Package: deepcase
DeepCASEThis repository contains the code for DeepCASE by the authors of the IEEE S&P DeepCASE [1] paper[PDF].
PleaseciteDeepCASE when using it in academic publications. Thismainbranch provides DeepCASE as an out of the box tool. For the original experiments from the paper, please checkout thespbranch.IntroductionDeepCASE introduces a semi-supervised approach for the contextual analysis of security events. This approach automatically finds correlations in sequences of security events and clusters these correlated sequences. The clusters of correlated sequences are then shown to security operators who can set policies for each sequence. Such policies can ignore sequences of unimportant events, pass sequences to a human operator for further inspection, or (in the future) automatically trigger response mechanisms. The main contribution of this work is to reduce the number of manual inspection security operators have to perform on the vast amounts of security events that they receive.DocumentationWe provide an extensive documentation including installation instructions and reference atdeepcase.readthedocs.io.References[1]van Ede, T., Aghakhani, H., Spahn, N., Bortolameotti, R., Cova, M., Continella, A., van Steen, M., Peter, A., Kruegel, C. & Vigna, G. (2022, May). DeepCASE: Semi-Supervised Contextual Analysis of Security Events. In 2022 Proceedings of the IEEE Symposium on Security and Privacy (S&P). IEEE.Bibtex@inproceedings{vanede2020deepcase,
  title={{DeepCASE: Semi-Supervised Contextual Analysis of Security Events}},
  author={van Ede, Thijs and Aghakhani, Hojjat and Spahn, Noah and Bortolameotti, Riccardo and Cova, Marco and Continella, Andrea and van Steen, Maarten and Peter, Andreas and Kruegel, Christopher and Vigna, Giovanni},
  booktitle={Proceedings of the IEEE Symposium on Security and Privacy (S&P)},
  year={2022},
  organization={IEEE}
}
Package: deepchain-apps
Table of contentsDescriptionInstallationCLIlogincreatedeployappsHow generate token to login deepchain?Getting started with AppLicensedeepchain-appspackage documentationThis Package provide aclifor creating a personnal app to deploy on the DeepChain platform.More informations on appTo leverage the apps capability, take a look at thebio-transformersandbio-datasetspackage, which provide functionnality to download biological dataset and easily use pre-trained transformers.1. InstallationIt is recommended to work with conda environnements in order to manage the specific dependencies of the package.condacreate--namedeepchain-envpython=3.7-ycondaactivatedeepchain-envpipinstalldeepchain-apps2. CLI commandsThe CLI provides 5 main commands:login: you need to supply the token provide on the plateform (PAT: personnal access token).deepchain logincreate: create a folder with a template app filedeepchain create my_applicationdeploy: the code and checkpoint are deployed on the plateform, you can select your app in the interface on the plateform.with checkpoint uploaddeepchain deploy my_application --checkpointOnly the codedeepchain deploy my_applicationapps:Get info on all local/upload appsdeepchain apps --infosRemove all local apps (files & config):deepchain apps --resetRemove a specific application (files & config):deepchain apps --delete my_applicationList all public apps:deepchain apps --publicdownload:Download locally an app deployed on deepchain hubdeepchain download user.name@mail.com/AppName AppNameHow generate token to login deepchain?If you want to deploy biology app on deepchain, you should first create a personal account ondeepchainand go to the user profile section.
As you can see below, you will be able to generate a PAT (personal access token) that you can use with the CLI command:deepchain login3. Getting started with Appdeepchain-apps template located at:https://github.com/DeepChainBio/deep-chain-appscreate new folder when usingdeepchain create myappapp structure:.
├──README.md# explain how to create an app├──__init__.py# __init__ file to create python module├──checkpoint
│├──__init__.py
│└──Optionnal:model.pt# optional: model to be used in app must be placed there├──examples
│├──app_with_checkpoint.py# example: app example with checkpoint│└──torch_classifier.py# example: show how to train a neural network with pre-trained embeddings└──src├──DESC.md# Desciption file of the application├──__init__.py├──app.py# main application script. Main class must be named App.└──tags.json# file to register the tags on the hub.LicenseThis source code is licensed under theApache 2license found in theLICENSEfile in the root directory.
Package: deepchecks
Deepchecks is a Python package for comprehensively validating your machine learning models and data with minimal effort.
This includes checks related to various types of issues, such as model performance, data integrity,
distribution mismatches, and more.What Do You Need in Order to Start Validating?Depending on your phase and what you wise to validate, you’ll need a subset of the following:Raw data (before pre-processing such as OHE, string processing, etc.), with optional labelsThe model’s training data with labelsTest data (which the model isn’t exposed to) with labelsA model compatible with scikit-learn API that you wish to validate (e.g. RandomForest, XGBoost)Deepchecks validation accompanies you from the initial phase when you
have only raw data, through the data splits, and to the final stage of
having a trained model that you wish to evaluate. Accordingly, each
phase requires different assets for the validation. See more about
typical usage scenarios and the built-in suites in thedocs.InstallationUsing pippipinstalldeepchecks#--upgrade --userUsing condacondainstall-cdeepchecksdeepchecks
Package: deepc-hunt
DeePC-HUNTData enabled predictive control hyperparameter tuning via differentiable optimization layersDeePC-HUNT is a method for optimising over the hyperparameters of DeePC, using anlaytical policy gradients. This method has been developed as part of my bachelor thesis, carried out at theautomatic control lab. Supervised byAlberto Padoan,Keith MoffatandFlorian Dorfler.Developed in a conda environment on Ubuntu 22.04 with python 3.10.Differentiable DeePC layer is inspired byDifferentiable MPCand built usingCvxpyLayers.Installationinstall via pippip install deepc_huntOr clone the repo and install viacd DeePC-HUNT && pip install -e .All extra packages necessary for running the example notebookds are in examples/requirements.txt. If needed,pip install -r examples/requirements.txtDeePC-HUNT has the following dependancies.Python3PyTorch>= 1.0CvxpyLayers>= 1.0UsageData-​enabled Predictive Control (DeePC) is a data-​driven non-​parametric algorithm for combined identification (learning) and control of dynamical systems. It leverages on the solution of the following optimization problem in a receding horizon fashionDeePC can achieve performance that rivals MPC on non-linear and stochastic systems (see here), but is highly sensitive to the choice of regularization parameters $\theta_i$. DeePC-HUNT addresses this problem by automatically tuning these parameters. The performance of DeePC-HUNT has been validated on a noisycartpoleandLTIsystem. These examples can be viewed in the notebooks in the examples directory.Cartpole - before traininghttps://github.com/michael-cummins/DeePC-HUNT/assets/72135336/1c73ca21-91c1-4669-a04d-1d9a103d9d48Cartpole - after training (episode 70)https://github.com/michael-cummins/DeePC-HUNT/assets/72135336/b6fa9948-a768-4646-b87f-018395fcc6c4
Package: deepclassifier
DeepClassifierDeepClassifier is a python package based on pytorch, which is easy-use and general for text classification task. You can install DeepClassifier bypip install -U deepclassifier。
If you want to know more information about DeepClassifier, please see thedocumentation. So let's start!🤩If you think DeepClassifier is good, please star and fork it to give me motivation to continue maintenance！🤩 And it's my pleasure that if Deepclassifier is helpful to you!🥰InstallationJust like other Python packages, DeepClassifier also can be installed through pip.The command of installation ispip install -U deepclassifier.ModelsHere is a list of models that have been integrated into DeepClassifier. In the future, we will integrate more models into DeepClassifier. Welcome to join us!🤩TextCNN:Convolutional Neural Networks for Sentence Classiﬁcation,2014 EMNLPRCNN:Recurrent Convolutional Neural Networks for Text Classification,2015,IJCAIDPCNN:Deep Pyramid Convolutional Neural Networks for Text Categorization,2017,ACLHAN:Hierarchical Attention Networks for Document Classiﬁcation, 2016,ACLBERT:BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding,2018, ACLBertTextCNN:BERT+TextCNNBertRCNN:BERT+RCNNBertDPCNN:BERT+DPCNNBertHAN:BERT+HAN
...Quick startI wiil show you that how to use DeepClassifier below.🥰 Click[here]to display the complete code.you can define model like that(take BertTexCNN model as example):👇fromdeepclassifier.modelsimportBertTextCNN# parameters of modelembedding_dim=768# if you use bert, the default is 768.dropout_rate=0.2num_class=2bert_path="/Users/codewithzichao/Desktop/bert-base-uncased/"my_model=BertTextCNN(embedding_dim=embedding_dim,dropout_rate=dropout_rate,num_class=num_class,bert_path=bert_path)optimizer=optim.Adam(my_model.parameters())loss_fn=nn.CrossEntropyLoss()After defining model, you can train/test/predict model like that:👇fromdeepclassifier.trainersimportTrainermodel_name="berttextcnn"save_path="best.ckpt"writer=SummaryWriter("logfie/1")max_norm=0.25eval_step_interval=20my_trainer=Trainer(model_name=model_name,model=my_model,train_loader=train_loader,dev_loader=dev_loader,test_loader=test_loader,optimizer=optimizer,loss_fn=loss_fn,save_path=save_path,epochs=1,writer=writer,max_norm=max_norm,eval_step_interval=eval_step_interval)# trainingmy_trainer.train()# print the best F1 value on dev setprint(my_trainer.best_f1)# testingp,r,f1=my_trainer.test()print(p,r,f1)# predictpred_data=DataLoader(pred_data,batch_size=1)pred_label=my_trainer.predict(pred_data)print(pred_label)Contact meIf you want any questions about DeepClassifier, welcome to submit issue or pull requests! And welcome to communicate with me through2843656167@qq.com.🥳
Package: deepclean
Clean old versions of Docker images.ExplanationRemove old versions of images with same name. In cases where you updated an
image (from example frompostgres:13topostgres:14) the old
image is present. Usingdocker image prunewon’t help in this case
since the image is still properly tagged.Usageusage:deepclean[-h][-iINCLUDE][-eEXCLUDE][-v][-V][-d]CleanoldversionsofDockerimages.options:-h,--helpshowthishelpmessageandexit-iINCLUDE,--includeINCLUDERegularexpressionofimagestoexclusivelyprune.-eEXCLUDE,--excludeEXCLUDERegularexpressionofimagestoignore.-v,--verboseVerboseoutput-V,--versionshowprogram's version number and exit
  -d, --dry-run         Dry-run, don'tdeleteRegularDockerenvironmentvariables(likeDOCKER_HOST)canbeused.-iand-ecanbeusedmultipletimes.LicenseThis software is licensed under the MIT license (see theLICENSE.txtfile).AuthorNimrod Adar,contact meor visit mywebsite. Patches are welcome viagit send-email. The repository is located
at:https://git.shore.co.il/nimrod/.
Package: deepcola
COLA (COmpetitive LAyers) is a Python package providing the implementation of
gradient-based competitive layers which can be used on top of deep
learning models for unsupervised tasks.TheoryTheoretical foundations can be found in our paper.If you find COLA useful in your research, please consider citing the following paper:@misc{barbiero2020topological,
    title={Topological Gradient-based Competitive Learning},
    author={Pietro Barbiero and Gabriele Ciravegna and Vincenzo Randazzo and Giansalvo Cirrincione},
    year={2020},
    eprint={2008.09477},
    archivePrefix={arXiv},
    primaryClass={stat.ML}
}ExamplesDual Competitive Layer (DCL)Vanilla Competitive Layer (VCL)Using COLAfromcolaimportDualModel,plot_confusion_matrix,scatterplot,scatterplot_dynamicX,y=...# load dataset# load custom tensorflow layersinputs=Input(shape=(d,),name='input')...outputs=...# instantiate the dual modeln=X.shape[0]# number of samplesk=...# upper bound of the desired number of prototypesmodel=DualModel(n_samples=n,k_prototypes=k,inputs=inputs,outputs=outputs,deep=False)model.compile(optimizer=optimizer)model.fit(X,y,epochs=epochs)# plot prototype dynamicsplt.figure()scatterplot_dynamic(X,model.prototypes_,y,valid=True)plt.show()# plot confusion matrix# considering the prototypes estimated in the last epochplt.figure()plot_confusion_matrix(x_pred,model.prototypes[-1],y)plt.show()# plot estimated topology# considering the prototypes estimated in the last epochplt.figure()scatterplot(x_pred,model.prototypes[-1],y,valid=True)plt.show()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: deepcolor
deepCOLOR: DEEP Generative model for single-cell COLOcalization RepresentationDeepCOLOR is intended to analyze colocalization relation ships between single cell transcriptomes, integrating them with spatial transcriptome.InstalationYou can install deepCOLOR using pip command from your shell.pipinstalldeepcolorimgaug==0.2.5UsageYou need to prepareAnnDataobjectswhich includes raw count matrix of gene expression for single cell and spatial transcriptome respectively. You can see the usage inIPython Notebook.
Package: deepcom
Research tools for communication-efficient deep learning, developed by Muhang Lan at USTC.Latest version: 0.1.0InstallationInstall using pippipinstalldeepcomCheck version numberimportdeepcomasdcprint(dc.__version__)Function listBasic toolsBatch processing with enumerating given argument values:python -m deepcom config.jsonDeep learning perspectiveConvert model parameters to a numpy array:model2params()Load a numpy array as model parameters:params2model()Communication perspectiveCalculating mutual information:mutual_info()Compression for training modelCompression for post-training modelSuRP algorithm as a sparse compression for Laplacian sequence:surp_algorithm()