Saravanan666/pypi-org huggingface dataset:
Package: nn4mc
Neural Networks for Microcontrollers: PythonThis is a python implementation of Neural Networks for Microcontrollers (nn4mc) (originally implemented in C++) that allows for the translation of trained neural network models to C code for use in embedded systems.Development StatusPlease note that nn4mc_py is still in development and may have many bugs. We are working hard on getting everything operating seamlessly, and feel free to reach out with any questions.Using nn4mcInstallationSimply use the Python package manager pip and run the following command.pip install nn4mcUsageYou will most likely only need to import the translator moduleimportnn4mc.translatorasnnTrThen you can translate a file with the following commandnnTr.translate("path/to/file",'hdf5',"output/path")What about packages other than Keras?We currently develop instructionals on converting packages from multiple sources to Keras.Technical QuestionsPlease direct your technical questions toStack Overflowusing thenn4mctag or e-mailSarah.AguasvivasManzano@colorado.edu. Also feel free to initiate a new issue in our github repository.Getting InvolvedFor bug report or feature requests please submit aGitHub issue.For contributions please submit apull requestCiting nn4mc:We encourage to use the following citation references for academic use of nn4mc.BibTeX citation:@misc{nn4mc,
        title={Embedded Neural Networks for Robot Autonomy},
        author={Sarah {Aguasvivas Manzano} and Dana Hughes and Cooper Simpson and Radhen Patel and Nikolaus Correll},
        year={2019},
	note={International Symposium of Robotics Research (ISRR 2019)},
        eprint={1911.03848},
        archivePrefix={arXiv},
        primaryClass={cs.RO}
    }APA Format:Manzano, S. A., Hughes, D., Simpson, C., Patel, R., & Correll, N. (2019). Embedded Neural Networks for Robot Autonomy. 
International Symposium of Robotics Research (ISRR 2019). arXiv preprint arXiv:1911.03848.Contributors:nn4mc is supported by theCorrell Labat the University of Colorado Boulder. We also receive support from the Airforce Office of Scientific Research (AFOSR), we are very grateful for this support.
Package: nn4n
NN4N: Neural Networks for NeuroscienceSome of the most commonly used neural networks in neuroscience research are included in this project to ease the implementation process.GitHubTable of contentsAcknowledgementsChange LogsInstallInstall Using pipInstall From GitHubModelCTRNN (Continuous-Time RNN)StructureMulti-AreaMulti-Area with E/I constraintsRandom InputCriterionRNNLossOthersAcknowledgementsImmense thanks toChristopher J. Cuevafor his mentorship in developing this project. This project can't be done without his invaluable help.Change Logsv1.0.3 [stable]v1.1.0 [newest]InstallInstall using pippip install nn4nInstall from GitHubClone the repositorygit clone https://github.com/zhaozewang/NN4Neurosci.gitNavigate to the NN4Neurosci directorycd NN4Neurosci/
pip install -e .ModelCTRNNThe implementation of standard continuous-time RNN (CTRNN). This implementation supports enforcing sparsity constraints (i.e., preventing new synapses from being created) and E/I constraints (i.e., enforcing Dale's law). This ensures that the gradient descent will update synapses with biological plausible constraints.DocumentationExamplesStructureIn CTRNN implementation, the hidden layer structure can be easily controlled by specifying sparsity masks and E/I masks. We put all RNN update logic in themodelmodule and all structure-related logic in thestructuremodule to streamline the implementation process.We also emphasize on the structure more as it is often more informative to the underlying biological mechanisms. For instance, we might require different module sizes, or we require a multi-module network with E/I constraints; the implementation might be verbose and error-prone. Our following implementation will allow you to easily achieve these goals by simply specifying a few parameters.DocumentationMulti-AreaThe following implementation groups neurons into areas depending on your specification. Areas can have different sizes and different connectivities to other areas.ExamplesMulti-Area with E/I constraintsOn top of modeling brain with multi-area hidden layer, another critical constraint would be Dale's law, as proposed in the paperTraining Excitatory-Inhibitory Recurrent Neural Networks for Cognitive Tasks: A Simple and Flexible Frameworkby Song et al. 2016. TheMultiAreaEIclass in thestructuremodule is designed to implement such a connectivity matrix.Additionally, how different E/I regions connect to each other could also be tricky; we parameterized this process such that it can be controlled with only two lines of code.ExamplesRandom InputNeurons' dynamic receiving input will be heavily driven by the inputting signal. Injecting signals to only part of the neuron will result in more versatile and hierarchical dynamics. SeeA Versatile Hub Model For Efficient Information Propagation And Feature Selection. This is supported byRandomInputclassExample to be addedCriterionRNNLossThe loss function is modularized. TheRNNLossclass is designed in a modular fashion and includes the most commonly used loss functions, such as Frobenius norm on connectivity, metabolic cost, reconstruction loss, etc.DocumentationOthersFor similar projects:nn-brain
Package: nnabla-converter
File Format Converternnabla-converter enables you to convert NN models. Currently we are supporting following models:nnp (model file for nnabla and Neural Network Console)nnb (model file for nnabla c runtime)source code for nnabla c runtimeONNXTensorflow (saved model, checkpoint, and frozen graph)TFLiteInstallBefore using nnabla-converter, please use commandpip install nnabla_converterto install nnabla_converter.How to use$ nnabla_cli convert [input model] [output model]The model file is associated with the extension.
Convert from nnp to onnx:nnabla_cli convert input.nnp output.onnxConvert from nnp to tflite:nnabla_cli convert input.nnp output.tfliteand so on.For detail instruction and limitation seeDocumentation
Package: nnapec
nnapecAn emulator for the APEC modelFree software: GNU General Public License v3Documentation:https://jmichaelburgess.com/nnapecInstallationpipinstallnnapecHow toThe APEC model is incredibly slow. This is not fun.Here we provide an neural net emulator that can be used withastromodelsand3MLwhich is much faster than usingpyatomdb.importnumpyasnpfromnnapecimportget_apec_model# get an instance of the apec model# multiple instances can be usednn_apec=get_apec_model()nn_apec.redshift=1.nn_apec.redshift.fix=Truenn_apec.kT=3.nn_apec.abund=0.3energies=np.geomspace(0.1,10.,1000)photon_flux=nn_apec(energies)TODOCurrently the model is trained with theAG89abundancesWill train more models if neededCredits
Package: nn-backpropogate
# Neural-Networks
Contains Python Code for implemenation of various logic gates using BackPropogation in python
Example Implementation of AND Gate using this Module
## Code
>import NeuralNetwork
>b=NeuralNetwork.BackPropogate(“and”)
>b.selectEpochs(10000)
>b.setLearningRate(0.1)
>b.train()
>b.print(“oo”)
>b.showerror()
>b.plot()#### Print can take any of four parameter:-
* ow1-Output Weights1 Array
* ow2-Output Weights2 Array
* ob-Output Biases Array
* oo-Our Final Output
### Functions it includes-
* sigmoid
* drivative
* train -Train Different Gates Model
* showerror -Show Error Percentage from Expected Output
* plot :- Plot different Grpahs for you
* print :- Print can take 4 inputs depending on which it provides output
* selectEpochs :- To select the number of epochs(Default :-1000)
* setLearningRate :- To select the learning rate of your Model(Default-0.1)
Package: nnbench
nnbench: A small framework for benchmarking machine learning modelsWelcome to nnbench, a framework for benchmarking machine learning models.
The main goals of this project areTo provide a portable, easy-to-use solution for model evaluation that leads to better ML experiment organization, andTo integrate with experiment and metadata tracking solutions for easy adoption.On a high level, you can think of nnbench as "pytest for ML models" - you define benchmarks similarly to test cases, collect them, and selectively run them based on model type, markers, and environment info.What's new is that upon completion, you can stream the resulting data to any sink of your choice (including multiple at the same), which allows easy integration with experiment trackers and metadata stores.See thequickstartfor a lightning-quick demo, or theexamplesfor more advanced usages.Installation⚠️ nnbench is an experimental project - expect bugs and sharp edges.Install it directly from source, for example either usingpiporpoetry:pipinstallnnbench# orpoetryaddnnbenchContributingWe encourage and welcome contributions from the community to enhance the project.
Please checkdiscussionsor raise anissueon GitHub for any problems you encounter with the library.For information on the general development workflow, see thecontribution guide.LicenseThe nnbench library is distributed under theApache-2 license.
Package: nnbma
Neural network-based model approximation (nnbma)Neural network-based model approximationnnbmais a Python package that handle the creation and the training of neural networks to approximate numerical models.
In [1], it was designed and used to derive an approximation of the Meudon PDR code, a complex astrophysical numerical code.InstallationTo build your own neural network for your numerical model, we recommend installing the package.
The package can be installed withpip:pipinstallnnbmaTo reproduce the results from [1], clone the repo withgitclonegit@github.com:einigl/ism-model-nn-approximation.gitAlternatively, you can also download a zip file.This package relies onPyTorchto build neural networks.
It enables to evaluate any neural network, its gradient, and its Hessian matrix efficiently.If you do not have a Python environment compatible with the above dependencies, we advise you to create a specific conda environment to use this code (https://conda.io/projects/conda/en/latest/user-guide/).Reference[1] Palud, P. & Einig, L. & Le Petit, F. & Bron, E. & Chainais, P. & Chanussot, J. & Pety, J. & Thouvenin, P.-A. & Languignon, D. & Beslić, I. & G. Santa-Maria, M. & Orkisz, J.H. & Ségal, L. & Zakardjian, A. & Bardeau, S. & Gerin, M. & Goicoechea, J.R. & Gratier, P. & Guzman, V. (2023). Neural network-based emulation of interstellar medium models. Astronomy & Astrophysics. 10.1051/0004-6361/202347074.
Package: nn_calculator
# calculator CICD pipeline
Example project to show developers and testers what a CICD pipeline looks like
Uses python so that non-developers can participate.
Uses GitLab because it is becoming the default tool within the organisation.
Currently uses PyPI for storing artifacts.
Deployments are done to an AWS env that is created and removed after each run.Features still to add:version in fileprovision env on AWS (via terraform)deploy to envmultiple envpublish unit test and code quality reportsmanual approval for prodweb page where users can run the calculatorsmoke testAPI testUI test
Package: nncase
nncaseis a neural network compiler for AI accelerators.nncase是一个为 AI 加速器设计的神经网络编译器。技术交流 QQ 群：790699378Telegram:nncase communityInstall from binaries从二进制安装Download prebuilt binaries fromRelease.下载预编译的二进制文件Release。Build from source从源码编译Build from sourceSupported operators支持的算子TFLite opsCaffe opsONNX opsK210/K510UsageFAQ使用说明常见问题ExampleK230UsageFAQExample使用说明常见问题示例Colab runResources资源K210K210_Yolo_frameworkShts!'s Blog (Japanese)Architecture架构FeaturesSupports multiple inputs and outputs and multi-branch structureStatic memory allocation, no heap memory acquiredOperators fusion and optimizationsSupport float and quantized uint8 inferenceSupport post quantization from float model with calibration datasetFlat model with zero copy loading功能支持多输入输出网络，支持多分支结构静态内存分配，不需要堆内存算子合并和优化支持 float 和量化 uint8 推理支持训练后量化，使用浮点模型和量化校准集平坦模型，支持零拷贝加载
Package: nnClassifier
# nnClassify
Command line tool for classifying imagesToxicology – the branch of science concerned with the nature,
effects, and detection of poisons – has
traditionally relied on expensive mammalian studies.
However, due to the large number of environmental
toxins that need testing, less expensive, high
throughput alternatives are required. Planaria – a small
asexual flatworm – provide an inexpensive and scalable
solution. The small size of planaria not only makes
them inexpensive to maintain, but also easy to
image with a high-resolution camera. Researchers can
run many test simultaneously, record the planarias
reaction, and use computer vision techniques to
analyze the results in a cost-effect and timely manner.
The results of some of these tests can be analyzed
using traditional computer vision techniques;
however, many tests involve classifying features of the
planaria – such as their body shape or eyes – as
normal or abnormal. Deep convolutional neural
networks have achieved state of the art results on image
classification tasks, but they require a large training
set of images. Researchers do not have the time
or resources to hand-label sufficient images for this
technique to be effective. Using transfer-learning, we
have developed a software platform for researchers to
quickly classify images with near state-of-the-art
performance and minimal training data.
Package: nncli
nncliis a Python application that gives you access to your NextCloud
Notes account via the command line. It’s a “hard” fork ofsncli. You can access your notes via
a customizable console GUI that implements vi-like keybinds or via a
simple command line interface that you can script.Notes can be viewed/created/edited inboth anonlineandofflinemode. All changes are saved to a local cache on disk and
automatically sync’ed when nncli is brought online.More detailed documentation can be found at thehomepage.InstallationAssuming your system has bothpython3andpip3, you can
globally installnncliand its dependencies withpip3 install nncli.If you are interested in packagingnnclifor various
distributions, please consult the fileCONTRIBUTING.rstin this
repository and reach out to the mailing list with any questions.FeaturesConsole GUIfull two-way sync with NextCloud Notes performed dynamically in the
backgroundall actions logged and easily reviewedlist note titles (configurable format w/ title, date, flags, category,
keys, etc)sort notes by date, alpha by title, category, favorite on topsearch for notes using a Google style search pattern or Regular
Expressionview note contents and meta datapipe note contents to external commandcreate and edit notes (using your editor)edit note categorydelete notesfavorite/unfavorite notesvi-like keybinds (fully configurable)Colors! (fully configurable)Command Line (scripting)force a full two-way sync with NextCloud Notesall actions logged and easily reviewedlist note titles and keyssearch for notes using a Google style search pattern or Regular
Expressiondump note contentscreate a new note (via stdin or editor)import a note with raw json data (stdin or editor)edit a note (via editor)delete a notefavorite/unfavorite a noteview and edit note categoryAcknowledgementsnncli is a fork ofsncliby Eric Davis. This application further pulls
in and uses modified versions of thesimplenote.pymodule by Daniel
Schauenberg and the notes_db.py module fromnvpyby Charl P. Botha.
Package: nncore
NNCoreA lightweight machine learning toolkit for researchers.NNCore is a library that provides common functionalities for Machine Learning and Deep Learning researchers. This project aims at helping users focus more on science but not engineering during research. The essential functionalities include but are not limited to:Universal I/O APIsEfficient implementations of layers and losses that are not included in PyTorchExtended methods for distributed trainingMore powerful data loading techniquesAn engine that can take over the whole training and testing process, with all the baby-sitting works (stage control, optimizer configuration, lr scheduling, checkpoint management, metrics & tensorboard writing, etc.) done automatically. See anexamplefor details.Note that some methods in the library work with PyTorch 1.11+, but the installation of PyTorch is not necessary.Continuous IntegrationPlatform / Python Version3.83.93.103.11Ubuntu 20.04Ubuntu 22.04macOS 12.xmacOS 13.xWindows Server 2022InstallationYou may install nncore directly from PyPIpip install nncoreor manually from sourcegit clone https://github.com/yeliudev/nncore.git
cd nncore
pip install -e .Getting StartedPlease refer to ourdocumentationfor how to incorporate nncore into your projects.AcknowledgementsThis library is licensed under theMIT License. Part of the code in this project is modified frommmcvandfvcorewith many thanks to the original authors.
Package: nnde
nndennde is a package of Python modules which implement a set of neural networks which solve ordinary and partial differential equations using technique ofLagaris et al. (1998).The package is described inWinter and Weigel, 2021, the source code for the paper is in the repositoryelwinter/nnde_joss_paper.Demos are available in the repositorynnde_demos.ContactEric Wintereric.winter62@gmail.com
Package: nndesigndemos
nndesigndemosThis is a set of demonstrations paired with theNeural Network Design& Neural Network Design: Deep Learning books written in Python.Installationnndesigndemos is supported on macOS, Linux and Windows. It uses PyQt6, so your OS version needs to be compatible with it.
If you get an installation error, this is most likely the reason.ForLinuxplatform, if you meet the following or similar problems when you install the nndesigndemos or run the code after installing it:qt.qpa.plugin: Could not load the Qt platform plugin "xcb" in "" even though it was found.
This application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.

Available platform plugins are: eglfs, offscreen, wayland, wayland-egl, linuxfb, minimal, xcb, minimalegl, vkkhrdisplay, vnc.

Aborted (core dumped)you need to install a plugin first using command line:sudo apt-get install -y libxcb-cursor-devInstalling via pipThe quick way is simply to install viapip install nndesigndemos, which works in most cases.The recommended way is to create a virtual environment to avoid dependency issues. Here is an easy way to do so:python3 -m venv env
source env/bin/activate  # macOS/Linux
env\Scripts\activate.bat  # Windows
pip install nndesigndemosTo deactivate the virtual environment, just typedeactivate.UsageAll the demos start from the same main menu, which can be accessed by entering the Python Shell and runningfrom nndesigndemos import nndtoc
nndtoc()After doing so, a window will pop up, and you will be able to navigate the demos listed by book and then by chapter.There are some demos that have sound, so if you want to mute them just runnndtoc(play_sound=False)instead.The original software for these demos runs on MATLAB, so for every section of theNeural Network Designbook where you see the MATLAB logo,
there will be a corresponding Python demo in this package. The second book is in progress.If you are using multiple monitors and switching between them, you may need to restart your computer to avoid scaling issues.DependenciesThese are the packages needed to run all the demos. These specific versions are known to work, but this does not mean
older or newer versions will cause any issues.Python 3.8+PyQt6 6.5.2NumPy 1.25.2SciPy 1.11.1Matplotlib 3.7.2Licensenndesigndemos is available under MIT license.
Package: nndict
NeverNoneDictPython Dictionary that does not have None values.InstallingYou can start using nn dict by installing it using pip.pipinstallnndictUsing nndict>nndict_=nndict({"a":2,"b":None,"c":{"d":None}})>print(nndict_){'a':2,'c':{}}>nndict_=nndict({"a":2})>print(nndict_){'a':2}>nndict_["a"]=None>print(nndict_){}Running the testsMake sure you have the python versions listed in tox.ini installed. Then run tox:toxAuthorsTiago Santos-Initial work-tiago.santos@vizidox.com
Package: nndp
Dynamic Programming with Neural Networks(nndp)Marc de la Barrera i Bardalet, Tim de Silvanndpprovides a framework for solving finite horizon dynamic programming problems using neural networks that is implemented using theJAXfunctional programming paradigm andHaiku. This solution technique, introduced and described in detail byDuarte, Fonesca, Goodman, and Parker (2021), applies to problems of the following form:$$V(s_0)=\max_{a_t\in\Gamma(s_t)} E_0\left[\sum_{t=0}^T u(s_t,a_t)\right],$$$$s_{t+1}=m(s_{t},a_{t},\epsilon_t), $$$$s_0 \sim F(\cdot).$$The state vector is denoted by $s_t=(k_t, x_t)$, where $k_t$ are exogenous states and $x_t$ are endogenous states. We adopt the convention that the first exogenous state in $k_t$ is $t$. The goal is to find a policy function $\pi(s_t)$ that satisfies:$$\hat V(s_0,\pi)=E_0\left[\sum_{t=0}^T u(s_t,\pi(s_t))\right],$$$$s_{t+1}=m(s_{t},\pi(s_{t}),\epsilon_t),$$$$V(s_0)=\hat V(s_0,\pi)\quad \forall s_0.$$We parametrize $\pi(s_t)=\tilde\pi(s_t,\theta)$ as a fully connected feedforward neural network and update the networksâ€™ parameters, $\theta$, using stochastic gradient descent. To use this framework, the user only needs to write the following functions that are defined by the dynamic programming problem of interest:u(state, action): reward function for $s_t$ =stateand $a_t$ =actionm(key, state, action): state evolution equation for $s_{t+1}$ if $s_t$ =stateand $a_t$ =action.keyis a JAX RNG key used to simulate any shocks present in the model.Gamma(state): defines the set of possible actions, $a_t$, at $s_t$ =stateF(key, N): samplesNobservations from the distribution of $s_0$.keyis a JAX RNG key used to simulate any shocks present in the model.nn_to_action(state, params, nn): defines how the output of a Haiku Neural Network,nn, with parameters,params, is mapped into an action at $s_t$ =stateWe provide an example application to the income fluctations problem inexamples/income_fluctuations/main.ipynbto illustrate how this framework can be used.ReferencesDuarte, Victor, Julia Fonseca, Jonathan A. Parker, and Aaron Goodman (2021), Simple Allocation Rules and Optimal Portfolio Choice Over the Lifecycle, Working Paper.
Package: nner
model namexxxis our method used inCBLUE(Chinese Biomedical Language Understanding Evaluation), a benchmark of Nested Named Entity Recognition. We got the 2nd price of the benchmark by 2021/12/06.ApproachTODO:picture or paperUsageFirst, installPyTorch>=1.7.0. There's no restriction on GPU or CUDA.Then, install this repo as a Python package:$pipinstallnnerAPIThennerpackage provides the following methods:nner.load_NNER(model_save_path='./checkpoint/macbert-large_dict.pth', maxlen=512, c_size=9, id2c=_id2c)Returns the pretrained model. It will download the model as necessary. The model would use the first CUDA device if there's any, otherwise using CPU instead.Themodel_save_pathargument specifies the path of the pretrained model weight.Themaxlenargument specifies the max length of input sentences. The sentences longer thanmaxlenwould be cut off.Thec_sizeargument specifies the number of entity class. Here is9for CBLUE.Theid2cargument specifies the mapping between id and entity class. By default, theid2cargument for CBLUE is:_id2c = {0: 'dis', 1: 'sym', 2: 'pro', 3: 'equ', 4: 'dru', 5: 'ite', 6: 'bod', 7: 'dep', 8: 'mic'}The model returned bynner.load_NNER()supports the following methods:model.recognize(text: str, threshold=0)Given a sentence, returns a list of tuples with recognized entity, the format of the tuple is[(start_index, end_index, entity_class), ...]. Thethresholdargument specifies that the returned list only contains the recognized entity with confidence score higher thanthreshold.model.predict_to_file(in_file: str, out_file: str)Given input and output.jsonfile path, the model would do inference accordingin_file, and the recognized entity would be saved inout_file. The output file can be submitted toCBLUE. The format of input file is like:[{"text":"..."},{"text":"..."},...]ExamplesimportnnerNNER=nner.load_NNER()in_file='./CMeEE_test.json'out_file='./CMeEE_test_answer.json'NNER.predict_to_file(in_file,out_file)