Saravanan666/pypi-org huggingface dataset:
Package: neuroboom
Neuroboom is a suite of Python 3 tools for analysing neuron reconstructions within Connectomic initiatives.
This package is currently designed to operate on neuron recontructions within theCATMAIDorNeuprintplatforms.These two different platforms reflect the two available connectomic efforts in the fruit fly, Drosophila melanogaster:theFull Adult Female Brain (FAFB)Zhenget al., 2018,CelltheHemibrain, Schefferet al., 2020,eLifeHave I seen this before?Some code incorporated within the neuroboom package has been presented in scientific papers, most notably thedendrogramfunctions:Integration of Parallel Opposing Memories Underlies Memory Extinction, J. Felsenberget al., 2018,CellInput Connectivity Reveals Additional Heterogeneity of Dopaminergic Reinforcement in Drosophila, N. Otto,MW Pleijzieret al., 2018,Current BiologyConvergence of distinct subpopulations of mechanosensory neurons onto a neural circuit that elicits grooming, S. Hampelet al., 2020,biorXivDocumentationneuroboom is on readthedocsFeaturesDendrograms: 2D graph representations of neurons.
* Available in static renderings for scientific papers / representations
* Interactive renderings for exploratory analysesComing soon:synaptic focalisationelectrotonic modelling
Package: neuro-bump-version
neuro-bump-versionBump neu-ro tag to the next versionInstallationInstall withpipxinuserspace to access the tool
everywhere:$ pipx install neuro-bump-versionUsageChange the current folder to cloned git project (or a subfolder).Runneuro-bump-versionto create a next tag using Neu.ro versioning schema (see below).
Only projects withuse_scm_versionconfigured are supported.Versioning schemaThe schema should conform SemVer, CalVer, and Python PEP 440.We useYY.MM(.NN)naming whereYYis the last 2 digits of year,MMis the month
number without trailing zero, NN is an incremental number instead, resetting this number
to zero every month.Zero incremental number is omitted.For example, the first release in October will be21.10(implicit trailing zero),
the next is21.10.1,21.10.2and so on until November.
The first release in November should be21.11.
Package: neurocache
NeurocacheA library for augmenting language models with external caching mechanismsRequirementsPython 3.6+PyTorch 1.13.0+Transformers 4.25.0+InstallationpipinstallneurocacheGetting startedimporttorchfromtransformersimportAutoModelForCausalLM,AutoTokenizerfromneurocacheimport(NeurocacheModelForCausalLM,OnDeviceCacheConfig,)model_name="facebook/opt-350m"model=AutoModelForCausalLM.from_pretrained(model_name)tokenizer=AutoTokenizer.from_pretrained(model_name)cache_layer_idx=model.config.num_hidden_layers-5config=OnDeviceCacheConfig(cache_layers=[cache_layer_idx,cache_layer_idx+3],attention_layers=list(range(cache_layer_idx,model.config.num_hidden_layers)),compression_factor=8,topk=8,)model=NeurocacheModelForCausalLM(model,config)input_text=["Hello, my dog is cute","Hello, my cat is cute"]tokenized_input=tokenizer(input_text,return_tensors="pt")tokenized_input["start_of_sequence"]=torch.tensor([0,1]).bool()outputs=model(**tokenized_input)Supported model typesfrom neurocache.utils import NEUROCACHE_SUPPORTED_MODELS
print(NEUROCACHE_SUPPORTED_MODELS)

[
  "opt",
  "llama",
  "mistral",
  "gptj",
]
Package: neuro-cli
PrefaceWelcome to Neuro CLI tool forhttps://neu.ro/.
Package ship command line tool calledneuro. With it you can:Execute and debug jobsManipulate DataMake some funContributingFor OSX users install coreutils to properly interpret shell commands:brew install coreutilsBefore you begin, it is recommended to have clean virtual environment installed:python-mvenv.envsource.env/bin/activateDevelopment flow:Install dependencies:make setupReformat code:make formatLint:make lintRun tests:make testRun end-to-end tests:make e2e
Package: neurocode
🔎 OverviewA minimalistic Python library for EEG/MEG deep learning research, primarely focused on self-supervised learning.📦 InstallationEither clone this repository and perform a local install accordinglygit clone https://github.com/neurocode-ai/neurocode.git
cd neurocode
poetry installor install the most recent release from the Python Package Index (PyPI).pip install neurocode🚀 Example usageBelow you can see an example adapted for a SSL training workflow using the SimCLR framework.importtorchfrompytorch_metric_learningimportlossesfromneurocode.datasetsimportSimulatedDataset,RecordingDatasetfromneurocode.samplersimportSignalSamplerfromneurocode.modelsimportSignalNetfromneurocode.trainingimportSimCLRfromneurocode.datautilimportmanifold_plot,history_plotsample_data=SimulatedDataset("sample",seed=7815891891337)sample_data.read_from_file("MEG/sample/sample_audvis_raw.fif")# create random extrapolated data from the raw MEG recording,# you need to provide a location to a forward solution (source space) to usesample_data.simulate("MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif")dataset=RecordingDataset(sample_data.data(),sample_data.labels(),sfreq=200)train,valid=dataset.train_valid_split(split=0.75)samplers={'train':SignalSampler(train.data(),train.labels(),train.info(),...),'valid':SignalSampler(valid.data(),valid.labels(),valid.info(),...),}device="cuda"iftorch.cuda.is_available()else"cpu"model=SignalNet(...)optimizer=torch.optim.Adam(model.parameters(),...)scheduler=torch.optim.lr_scheduler.CosineAnnealingLR(optimizer,...)criterion=losses.NTXentLoss()# train the neural network using the self-supervised learning SimCLR framework,# save or plot the history to see training loss evolutionsimclr=SimCLR(model,device,...)history=simclr.fit(samplers,save_model=True)📋 LicenseAll code is to be held under a general MIT license, please seeLICENSEfor specific information.
Package: neurocombat-sklearn
NeuroCombat-sklearnImplementation of Combat harmonization method in scikit-learn compatible format.The Combat harmonization/normalization method uses an parametric empirical Bayes framework to robustly adjust data for site/batch effects.
The scikit-learn compatible format was used to facilitates the use of this harmonization method in machine learning projects.This repository is developed byWalter Hugo Lopez Pinayaat King's College London and community contributors.InstallationRequirementsPython (>= 3.5)Scikit-Learn(>= 0.21.0)User installationIf you already have a working installation of numpy and scipy,
the easiest way to install neurocombat-sklearn is usingpip:pip install neurocombat-sklearnCitationIf you find this code useful for your research, please cite:@article{fortin2018harmonization,
  title={Harmonization of cortical thickness measurements across scanners and sites},
  author={Fortin, Jean-Philippe and Cullen, Nicholas and Sheline, Yvette I and Taylor, Warren D and Aselcioglu, Irem and Cook, Philip A and Adams, Phil and Cooper, Crystal and Fava, Maurizio and McGrath, Patrick J and others},
  journal={Neuroimage},
  volume={167},
  pages={104--120},
  year={2018},
  publisher={Elsevier}
}

@article{johnson2007adjusting,
  title={Adjusting batch effects in microarray expression data using empirical Bayes methods},
  author={Johnson, W Evan and Li, Cheng and Rabinovic, Ariel},
  journal={Biostatistics},
  volume={8},
  number={1},
  pages={118--127},
  year={2007},
  publisher={Oxford University Press}
}DisclaimerBased on:https://github.com/ncullen93/neuroCombathttps://github.com/nih-fmrif/nielson_abcd_2018https://github.com/Jfortin1/ComBatHarmonization
Package: neuroconv
Automatically convert neurophysiology data to NWBExplore our documentation »Table of ContentsAboutInstallationDocumentationLicenseAboutNeuroConv is a Python package for converting neurophysiology data in a variety of proprietary formats to theNeurodata Without Borders (NWB)standard.Features:Reads data from 40 popular neurophysiology data formats and writes to NWB using best practices.Extracts relevant metadata from each format.Handles large data volume by reading datasets piece-wise.Minimizes the size of the NWB files by automatically applying chunking and lossless compression.Supports ensembles of multiple data streams, and supports common methods for temporal alignment of streams.InstallationWe always recommend installing and running Python packages in a clean environment. One way to do this is viaconda environments:condacreate--name<givetheenvironmentaname>--python<chooseaversionofPythontouse>
condaactivate<environmentname>To install the latest stable release ofneuroconvthough PyPI, run:pipinstallneuroconvTo install the current unreleasedmainbranch (requiresgitto be installed in your environment, such was viaconda install git), run:pipinstallgit+https://github.com/catalystneuro/neuroconv.git@mainNeuroConv also supports a variety of extra dependencies that can be specified inside square brackets, such aspipinstallneuroconv[dandi]which will then install extra dependencies related to usage of the DANDI CLI (such as automatic upload to theDANDI Archive).You can read more about these options in the maininstallation guide.DocumentationSee ourReadTheDocs pagefor full documentation, including a gallery of all supported formats.LicenseNeuroConv is distributed under the BSD3 License. SeeLICENSEfor more information.
Package: neurocurator
Getting Started|Upgrade|Releases|Roadmap|StatusFor the Annotation Viewer or the integration with
theOpenMinTeDplatform, please refer
to
thisbranch.NeuroCuratorDesktop application to perform systematic and collaborative curation of
neuroscientific literature.This is a Graphical User Interface (GUI) for the Python moduleNeuroAnnotation Toolbox (NAT).This framework has been described in details in the following
open-access paper:https://doi.org/10.3389/fninf.2017.00027.With NeuroCurator, annotations are: - traceable, - reusable across
projects, - structured with controlled vocabularies.Getting StartedInstallationAfter havinginstalled Git and ImageMagick 6:pip3installneurocuratorIf you would like to simplify the installation with Miniconda:condacreate--namencpython=3.7condaactivatenccondainstallbeautifulsoup4gitpythonlxmlnumpypandasscipypipinstallneurocuratorRequirementsSystem side:Python 3.4+Qt 5.11+Git 1.7.0+ImageMagick
6Miniconda(optional)Python side:NATPyQt5NumPypandasWandLaunchneurocuratorIf you have used Miniconda:condaactivatencneurocuratorUpgradepipinstall--upgradeneurocuratorIf you have used Miniconda:condaactivatencpipinstall--upgradeneurocuratorReleasesVersions and their notable changes are listed in thereleases
section.RoadmapOngoingMake the annotations publishable into aBlue Brain
Nexusinstance.Stabilize NeuroCurator and NAT (Software Architecture).TODOIntegrate fully theAnnotation
Viewerinto NeuroCurator.Semi-automate the Knowledge Extraction process.Done(latest first)Remove legacy dependencies in NeuroCurator (Qt 4 and Python 3.4).Integrate OpenMinTeD annotations into the literature curation
framework.Visualize NeuroCurator and OpenMinTeD annotations directly on PDFs.Make NeuroCurator easily installable, especially by scientists.Updated on 20.07.18.StatusCreated during 2016.Ongoing stabilization and reengineering in the branchrefactor-architecture.The branchrefactor-architectureisnotintended to be used by
end-users.New features, bug fixes and improvements are done on the reengineered
code sections.When a reengineered code section is stable, it’s merged into the branchmasterand a release is published.
Package: neurodocker
NeurodockerNeurodockeris a command-line program that generates custom Dockerfiles and Singularity recipes for neuroimaging and minifies existing containers.Please see our websitehttps://www.repronim.org/neurodockerfor more information.InstallationUse theNeurodockerDocker image (recommended):dockerrun--rmrepronim/neurodocker:0.7.0--helpThe Docker images were moved torepronim/neurodockerfromkaczmarj/neurodocker.This project can also be installed withpip:pipinstallneurodocker
neurodocker--helpIf thepip installcommand above gives a permissions error, install as a non-root user:pipinstall--userneurodockerNote: it is not yet possible to minimize Docker containers using theNeurodockerDocker image.Developer installationClone the repository and install in editable mode.git clone https://github.com/ReproNim/neurodocker
cd neurodocker
python -m pip install --no-cache-dir --editable .[all]Before committing changes, initializepre-commitwithpre-commit install. This will format code with each commit to keep the style consistent.Neurodockerusesblackfor formatting.
Package: neurodynex
Neuronal Dynamics: Python ExercisesThis repository contains python exercises accompanying the bookNeuronal Dynamicsby Wulfram Gerstner, Werner M. Kistler, Richard Naud and Liam Paninski. References to relevant chapters will be added in theTeaching Materialssection of the book homepage.Exercises & DocumentationThe full documentation and the exercisescan be found at readthedocs.QuickstartTo install the exercises with anaconda/miniconda execute:condainstall-cbrian-team-cepfl-lcnneurodynexTo install the exercises usingpipsimply execute:pipinstall--upgradeneurodynexLicenseThis free software: you can redistribute it and/or modify it under the terms of the GNU General Public License 2.0 as published by the Free Software Foundation. You should have received a copy of the GNU General Public License along with the repository. If not, seehttp://www.gnu.org/licenses/.Should you reuse and publish the code for your own purposes, please point to the webpagehttp://neuronaldynamics.epfl.chor cite the book:Wulfram Gerstner, Werner M. Kistler, Richard Naud, and Liam Paninski. Neuronal Dynamics: From Single Neurons to Networks and Models of Cognition. Cambridge University Press, 2014.Contributors (alphabetically)Parima Ahmadipouranari (LCN, EPFL)Bernd Illing (LCN, EPFL)Marco Lehmann (LCN, EPFL)Alexander Seeholzer (LCN, EPFL)Hesam Setareh (LCN, EPFL)Lorric Ziegler (LCN, EPFL)DisclaimerYou can download, use and modify the software we provide here. It has been tested but it can still contain errors.The content of this site can change at any moment. We may change, add or remove code/exercises without notification.Bug reportsDid you find a bug? Open an issue ongithub. Thank you!
Package: neuroevobench
NeuroEvoBench: Benchmarking Neuroevolution Methods for Machine Learning Applications 🦕 🦖 🐢This repository contains benchmark results, helper scripts, ES configurations and logs for testing the performance of evolutionary strategies inevosaxandEvoJAX.The benchmark is meant to facilitate benchmarking of evolutionary optimization (EO) methods specifically tailored towards neuroevolution methods.All task evaluations are written in JAX so that population evaluations can be parallelized on accelerators (GPU/TPU). This reduces the evaluation times significantly.You can get started here 👉Installation & Setup# Create a clean conda environment
conda create -n es_bench python=3.9
source activate es_bench
# Install a GPU/TPU compatible jax/jaxlib version
pip install "jax[cuda11_cudnn82]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
# Install the neuroevobench benchmark from PyPi
pip install neuroevobenchTask AvailabilityBasicNeuroEvoBenchUsageIndividual Benchmark TasksNote that the strategy to be evaluated has to follow theevosaxask-tellAPI.fromevosaximportStrategiesfromneuroevobench.problems.cifarimportCifarPolicyfromneuroevobench.problems.cifarimportCifarTaskfromneuroevobench.problems.cifarimportCifarEvaluator# 1. Create policy for task (CNN classifier)policy=CifarPolicy()# 2. Define train/test task based on configs/eval settingstrain_task=CifarTask(config.task_config.batch_size,test=False)test_task=CifarTask(10000,test=True)# 3. Setup task evaluator with strategy and policyevaluator=CifarEvaluator(policy=policy,train_task=train_task,test_task=test_task,popsize=config.popsize,es_strategy=Strategies[config.strategy_name],es_config=config.es_config,es_params=config.es_params,seed_id=config.seed_id,log=log,)# 4. Run the ES loop with loggingevaluator.run(config.num_generations,config.eval_every_gen)Running Parameter Search SweepsPlease visitneuroevobench-analysisfor example configurations used for the 10 EO baselines and 9 neuroevolution tasks.You can execute random search sweeps, multi-seed evaluations for the best found settings and individual training runs via the following command line shortcuts:neb-search --config_fname ${CONFIG_FNAME} --seed_id ${SEED_ID} --experiment_dir ${EXPERIMENT_DIR}
neb-eval --config_fname ${CONFIG_FNAME} --seed_id ${SEED_ID} --experiment_dir ${EXPERIMENT_DIR}
neb-run --config_fname ${CONFIG_FNAME} --seed_id ${SEED_ID} --experiment_dir ${EXPERIMENT_DIR}
Package: neuro-flow
Getting startedneuro-flowis a tool that simplifies daily jobs on the Neu.ro platform.Neuro Flow provides users the ability to create YAML files that configure routine things, for example, starting a Jupiter Notebook on the platform, starting a training pipeline, opening a file browser for remote storage, etc.The tool builds required Docker images and starts all necessary Neu.ro jobs under the hood, while the user doesn't have to type all requiredneurooptions and manually manage the pipeline scenarios.InstallationThe tool is hosted on PyPI and can be installed bypipas a regular Python project:$pipinstallneuro-flowUse the--upgradeoption to upgrading Neuro Flow to the latest version:$pipinstall--upgradeneuro-flow
Package: neurogenome
NeuroGenomeis a bioinspired open-source project that allows you to create artificial neural networks with a genetic code.InstallationSettings exampleExamplesLicenseInstallationpipinstallneurogenomeSettings example# gene localization schemeschema_0=[[["i0","i1","i0","i1"],["h1","h0","h1","h0"]],[["i2","i3","i2","i3"],["h3","h2","h3","h2"]],[["o0","o1"],["o1","o0"]]]# hyperparametersSETTINGS={"population size":50,"number of leaders":5,"select by":"max","number of input nodes per gene":5,"number of hidden nodes per gene":4,"number of output nodes per gene":3,"schema":schema_0,}Examplesin the pipelineLicenseMIT
Package: neuroglancer-annotation-ui
Google’s [Neuroglancer](https://github.com/google/neuroglancer) is an incredibly useful tool for connectomics and large 3d datasets, and a fork developed by the Seung lab is critical to the connectomics proofreading infrastructure here. One of Neuroglancer’s best features is an incredibly robust python scripting interface, allowing a lot of programmatic interaction with states.This is a set of tools designed to ease the programmatic generation of Neuroglancer states and close the loop between analysis and raw data. One component is an extension of the Neuroglancer ‘viewer’ object with a number of convenience functions for frequent operations and added functions to interact with new features in the Seung-lab fork such as a graphene segmentation layer backend. The other component, StateBuilder, is a framework to easily specify how to buid neuroglancer states out of schematized dataframes or numpy-style data. It’s also designed to operate easily with [DashDataFrame](https://github.com/AllenInstitute/DashDataFrame) to interactively explore complex data.
Package: neuroglancer-scripts
neuroglancer-scriptsTools for converting volumetric images and surface meshes to the pre-computed format ofNeuroglancer.InstallationThe easiest way to install the latest stable version of neuroglancer-scripts is
throughpip. Using a virtual environment is recommended:python3-mvenvvenv/.venv/bin/activatepipinstallneuroglancer-scriptsUsageSee thedocumentation.DevelopmentThe code is hosted onhttps://github.com/HumanBrainProject/neuroglancer-scripts.Useful commands for development:gitclonehttps://github.com/HumanBrainProject/neuroglancer-scripts.git# Install in a virtual environmentcdneuroglancer-scriptspython3-mvenvvenv/.venv/bin/activatepipinstall-e.[dev]# Testspytest# run testspytest--cov=neuroglancer_scripts--cov-report=html# detailed test coverage reporttox# run tests under all supported Python versions# Please install pre-commit if you intend to contributepre-commitinstall# install the pre-commit hookContributingThis repository usespre-committo ensure that all committed code follows minimal quality standards. Please install it and configure it to run as a pre-commit hook in your local repository (see above). Also, please note that the code quality checks may need a more recent version of Python than that required by neuroglancer_scripts itself (> 3.8 at the time of this writing).
Package: neurohive-devops-tools
InfoSet of various scripts which were used in '19-'20 to operate some integrations in CI pipelines.It previously was distributed via PIP package, now it's a python-based Docker container.InstallationHandyJust use a docker container, e.g.:docker build . -t devops-integration-tools
docker run --rm -ti devops-integration-toolsManualBuild a package:pip install setuptools wheel
python ./setup.py  sdist bdist_wheelThen upload to PyPI:twine upload ./dist/*Then install it somewhere:pip install devops-integration-tools
Package: neuroimagingtools
Basic Neuroimaging functionality for Nifti, Gifti, Cifti
Data structures. Basic useful functions missing from nibabel and nilearnInstallationOver pip, you can install the package, using the command:
pip install neuroimagingtoolsCoordinate transforms and nifti (volume) utilitiesaffine_transform: Affine Coordinate transform with individual x,y,z coordinatesaffine_transform_mat: Affine coordinate transform with coordinates in matrix formatcoords_to_linvidxs: Safe transform of coordinates to linear voxel indiceseuclidean_dist_sq: Squared Euclidean distance between coordinate pairssample_img: Sample volume at arbitrary locations with nearest-neighbor or trilinear interpolationcheck_voxel_range: Check of voxel coordinates are within an imageGifti Utilitiesmake_func_gifti: Make a new functional giftiImagemake_label_gifti: Make a new label giftiImage (with label table)get_gifti_column_names: Extract column names from giftiget_gifti_anatomical_struct: Extract Anatomical_structure_primaryget_gifti_labels: Get label names and colorsCifti Utilitiesjoin_giftis_to_cifti: Joins a left- and right-hemispheric Gifti into a single CIFTIsplit_cifti_to_giftis: Splits CIFTI into a left- and right-hemispheric Giftivolume_from_cifti: Extracts Nifti-volume data from a Cifti filesurf_from_cifti: Extract the surface-based data from a Cifti fileColor utilitiesread_lut: Read a lookup table filesave_lut: Save a lookup table filesave_cmap: Save a FSLeyes colormap fileBorder utilitiesBorder: Border classBorder.get_coords: Get coordinates for a borderread_borders: Read a workbench border filesave_borders: Save a workbench border fileproject_border: Project coordinates to a surfaceresample_border: Resample a border with regularly spacingFor documentation, see:https://nitools.readthedocs.io/en/latest/
Package: neurol
Neurol is a python package for implementing Brain-Computer Interfaces in a modular manner. With the help of tools in this package, you will be able define the behavior of your intended BCI and easily implement it. AneurolBCI is defined by a number of components:Aclassifierwhich decodes brain data into some kind of 'brain-state'Anactionwhich provides feedback depending on the decoded 'brain-state'An optionalcalibratorwhich runs at startup and modifies the operation of the BCIAn optionaltransformerwhich transforms the currentbufferof data into the form expected by theclassifierTheneurolBCI manages an incoming stream of brain data and uses the above user-defined functions to run a brain-computer interface.The package includes generic utility functions to aid in creatingclassifier's,transfromer's, andcalibrator's for common BCI use-cases. It also comes prepackaged with a growing list of trained machine learning models for common BCI classification tasks.Installationneurolcan be easily installed usingpip:$ pip install neurolDocumentationPlease findneurol's documentationhere.You can also find example notebooks in theexamplesdirectory.ContactIf you have questions or would like to discuss this package, please don't hesitate to contact me.Awni Altabaa -awni.altabaa@queensu.ca/awnyaltabaa@gmail.com