Saravanan666/pypi-org huggingface dataset:
Package: neugs-utils
Northeastern University Grade Scope UtilityIn progress gradescope utility used for alternative grading schemes, including mastery grading and standards grading. Additionally, contains utility functions used to make the grading process easier.FeaturesTier Mastery Grading:Focuses on mastery based grading in grading tiers, meaning
grades are corrected, so only the tests are passed in order based on groups. If any
test in a group stops, so does all grading until the previous group is fixed.Common tiers are (COMMON_ONE, COMMON_TWO, COMMON_THREE, COMMON_FOUR) which is
"Learning", "Approaching", "Meets", "Exceeds". To tag a test in a tier use the
tier decorator. An example of a common test setup with tier grading would be as followsExample:fromgradescope_utils.autograder_utils.decoratorsimportnumber,tagsfromneugs_utilsimporttier,COMMON_ONE,COMMON_TWO,COMMON_THREEclassTestOne(unittest.TestCase):@tier(COMMON_THREE)@tags("Learning")#tags should come *after* tiers if they are used at all@number(3.0)deftest_random(self):result=6foriin(6,5,61):self.assertEqual(result,i,"this is my message, that display due to TWO failing")@tier(COMMON_TWO)@number(2.0)deftest_approaching(self):result=3self.assertEqual(result,5,"this should fail")@tier(COMMON_TWO)@number(2.0)deftest_some_other_approaching(self):result=5self.assertEqual(result,5,"this should pass")@tier(COMMON_ONE)@number(1.0)deftest_valid(self):self.assertEqual(5,5,"really!")@tier(COMMON_ONE)@number(1.1)deftest_valid2(self):self.assertEqual(6,6,"really!")Given the example above, and assuming default points of 1 point per tier, the above student would earn
1 point, and will be encouraged to submit again to completed Tier Two and Tier 3In run_test.py make sure to change JSONTestRunner to TierMasteryJSONTestRunnerimportunittestfromneugs_utilsimportTierMasteryJSONTestRunnerif__name__=='__main__':suite=unittest.defaultTestLoader.discover('tests')withopen('/autograder/results/results.json','w')asf:TierMasteryJSONTestRunner(visibility='visible',stream=f).run(suite)Utilities:There are also a number of additional utility functions added in common_tests.py and context_managers.py. These are meant to be for utility to help with common grading tasks.This module is still in early stages of development!
Package: neugym
NeuGymNeuGym is a Python package for reinforcement learning environment of animal behavior modeling,
which is still under development.Documentation:https://neugym.readthedocs.io/en/latest/Mailing list:https://groups.google.com/g/neugymSource code:https://github.com/HaoZhu10015/neugymBug reports:https://github.com/HaoZhu10015/neugym/issuesTutorial:https://neugym.readthedocs.io/en/latest/tutorial.htmlInstallInstall the current release of NeuGym withpip:$ pip install neugymFor more installing options please refer toInstall.CitationIf you find this code useful for your research, please cite:@misc{HaoZhu10015_2022_NeuGym,
  author = {Hao Zhu},
  title = {NeuGym},
  year = {2022},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/HaoZhu10015/neugym}},
}Code of conductAnyone who interacts with this software in any space,
including but not limited to this GitHub repository,
must follow ourcode of conduct.
Package: neumai
Neum AIHomepage|Documentation|Discord|TwitterCore library with Neum AI components to connect, load, chunk and sink vector embeddings.Neum AIis a data platform that helps developers leverage their data to contextualize Large Language Models through Retrieval Augmented Generation (RAG)This includes
extracting data from existing data sources like document storage and NoSQL, processing the contents into vector embeddings and ingesting the vector embeddings into vector databases for similarity search.It provides you a comprehensive solution for RAG that can scale with your application and reduce the time spent integrating services like data connectors, embedding models and vector databases.Features🏭High throughput distrubted architectureto handle billions of data points. Allows high degrees of parallelization to optimize embedding generation and ingestion.🧱Built-in data connectorsto common data sources, embedding services and vector stores.🔄Real-time synchronizationof data sources to ensure your data is always up-to-date.🤝Cohesive data managementto support hybrid retrieval with metdata. Neum AI automatically augments and tracks metadata to provide rich retrieval experience.Getting StartedNeum AI CloudSign up today atdasboard.neum.ai. See ourquickstartto get started.The Neum AI Cloud supports a large-scale, distrubted architecture to run millions of documents through vector embedding. For the full set of features see:Cloud vs LocalLocal DevelopmentInstall theneumaipackage:pipinstallneumaiTo create your first data pipelines visit ourquickstart.Self-hostIf you are interested in deploying Neum AI to your own cloud contact us atfounders@tryneum.com.We will publish soon an open-source self-host that leverages the framework's architecture to do high throughput data processing.RoadmapConnectorsMySQL - SourceGitHub - SourceGoogle Drive - SourceHugging Face - EmbeddingLanceDB - SinkMilvus - SinkChroma - SinkSearchRetrieval feedbackFilter supportUnified Neum AI filtersSelf-Query Retrieval (w/ Metadata attributes generation)ExtensibilityLangchain / Llama Index Document to Neum Document converterCustom chunking and loadingExperimentalAsync metadata augmentationChat history connectorStructured (SQL and GraphQL) search connector
Package: neumai-tools
Neum AI ToolsCollection of tools made to help implement RAG pipelines. Can be used directly or through Neum AI.:exclamation:  This utilities are currently in experimental phase.ToolsSemantic Helpers: LLM based tools to help augment RAG pipelines. Includes generating semantic strategies to generate chunking code, select fields to capture as metadata and as content when leveraging RAG on top of structured data.Interop Helpers: Utilities to connect frameworks like Langchain and Llama Index with Neum AI. If there are data connectors that you want to leverage, you can use the utilities to translate interfaces.Pipeline Collection: Treat a collection of pipelines as a single entity to perform search and other actions. Allows you to silo data into pipelines with their unique set of transformations, embed model and sink and then bring them back together as a single entity to retrieve data.Dataset Evaluation: Create datasets of queries and expected outputs that you can run against a given pipeline or pipeline collection.
Package: neural-admin
OverviewNeural Dynamics custom admin is a Django app allowing to automaticly blur fields and make email agent popup on email click in django admin modelAlso it provides search only by fields first_name and last_name used as showed below:first_name-/|\-last_nameQuick startInstall using commandpipinstallneural-adminDefine your admin model and import custom adminfromneural_admin.adminimportCustomAdminclassSUserAdmin(CustomAdmin,UserAdmin):email_fields=("email",)# Pass here fields you want to open an email agent onclickblur_fields=("pin_code",)# Pass here fields you want to blur. When you click on blurred field it will show you field value.
Package: neuralart
neuralartA library and command line utility for rendering generative art from a randomly
initialized neural network.Based on the following blog posts and pages fromstudio otoroNeural Network Generative Art in JavascriptGenerating Abstract Patterns with TensorFlowNeurogramInteractive Neural Network ArtRequirementsneuralartsupports Python 3.x.Linux, Mac, and Windows are supported.Other operating systems may be compatible if the dependencies can be properly installed.DependenciesPyTorchPillowInstallationneuralartis available on PyPI,
the Python Package Index.$ pip install neuralartCommand Line UtilityThere is a command line utility for generating images. Use the--helpflag for more information.$ neuralart --helpExample$ neuralart \
      --seed 2 \
      --xres 2048 \
      --hidden-std 1.2 \
      example.pngLibrary Example UsageSeeexample.py.LicenseThe code in this repository has anMIT License.SeeLICENSE.
Package: neuralartstudio
Getting startedLatest docs athttps://neuralartstudio.readthedocs.io/en/latest/InstallneuralartstudiopipinstallneuralartstudioIt is possible to create meaningful output with a cpu.A gpu can speed up the experiments.Running as a streamlit appCreate astreamlitapp (say in a file calledmain.py)fromneuralartstudio.streamlitimportneural_style_transferneural_style_transfer(contentpath="assets/dancing.jpg",stylepath="assets/picasso.jpg",)Note: You have to provide paths to your content and style image to start with. You can replace the content image later in the app.That's it. Now run the app with streamlitstreamlitrunmain.pyRunning from a python programToDoRunning in a Jupyter notebookToDo
Package: neuralbridge
NeuralBridgeEasy-to-use, one-liner AI model conversion tool between AI frameworks to ensure faster model development and portability with Open Neural Network Exchange (ONNX).How to InstallTo install NeuralBridge simple use:pip install neuralbridgeIn case you would like to build this project from source please consult therequirements.txtfile and thesrcdirectory.How to UseThe main use case of NeuralBridge is to convert model runtime. It converts TensorFlow and PyTorch models from one framework to another absolutely automatically. You can access runtime conversion like this:fromneuralbridgeimportconvert_modelmodel_in_other_framework=convert_model(model_in_one_framework)ExamplesYou can find additional examples in theexamplesdirectory.Converting PyTorch model into TensorFlowThis example is in theexample_tf_to_torch.pyfile.Converting TensorFlow model into PyTorchThis example is in theexample_torch_to_tf.pyfile.Old design patternsYou can find the old design patterns in the following files:old_way_onnx_to_tf.pyold_way_onnx_to_torch.pyold_way_tf_to_onnx.pyold_way_tf_to_torch.pyold_way_torch_to_onnx.pyold_way_torch_to_tf.pyRequirementsThe list of all requirements are in therequirements.txt.LicenseSee details in theLICENSE.
Package: neural-chat
neural_chatSetting Up A Basic Assistantfromneural_chatimportGenericAssistantassistant=GenericAssistant("intents.json",model_name="test_model")assistant.train_model()assistant.save_model()whileTrue:message=input("Enter a message: ").lower()ifmessage=="stop":breakelse:assistant.request(message)Also support a voice assistantfromneural_chatimportGenericAssistantassistant=GenericAssistant("intents.json",model_name="test_model",voice_assistant=True)assistant.train_model()assistant.save_model()whileTrue:message=input("Enter a message: ").lower()ifmessage=="stop":breakelse:response=assistant.request(input(">>> "))iftype(response)==str:print(response)# else: will speak the answer text and print it.#       Print function hardcoded in voice_assistant.pyBinding Functions To Requestsfromneural_chatimportGenericAssistantdeffunction_for_greetings():print("You triggered the greetings intent!")# Some action you want to takedeffunction_for_stocks():print("You triggered the stocks intent!")# Some action you want to takemappings={"greeting":function_for_greetings,"stocks":function_for_stocks}assistant=GenericAssistant("intents.json",intent_methods=mappings,model_name="test_model")assistant.train_model()assistant.save_model()whileTrue:message=input("Enter a message: ")ifmessage=="stop":breakelse:assistant.request(message)Sample intents.json File{"intents":[{"tag":"greeting","patterns":["Hi","How are you","Is anyone there?","Hello","Good day","Whats up","Hey","greetings"],"responses":["Hello!","Good to see you again!","Hi there, how can I help?"],"context_set":""},{"tag":"goodbye","patterns":["cya","See you later","Goodbye","I am Leaving","Have a Good day","bye","cao","see ya"],"responses":["Sad to see you go :(","Talk to you later","Goodbye!"],"context_set":""},{"tag":"stocks","patterns":["what stocks do I own?","how are my shares?","what companies am I investing in?","what am I doing in the markets?"],"responses":["You own the following shares: ABBV, AAPL, FB, NVDA and an ETF of the S&P 500 Index!"],"context_set":""}]}
Package: neural-data-simulator
Neural Data SimulatorThe Neural Data Simulator is a real-time system for generating electrophysiology data from behavioral data (e.g. cursor movement, arm kinematics, etc) in real-time. The NDS system can be used to test and validate closed-loop brain-computer interface systems without the need for a human in the loop, generate synthetic data for algorithm optimization, and provide a platform on which to develop BCI decoders.DocumentationSee thedocumentationfor a complete system overview, installation instructions, and API details.InstallationEnsure that Python>=3.9and<3.12is installed. Then, proceed to install LSL:# on Linux/WSL
conda install -c conda-forge liblsl

# on macOS
brew install labstreaminglayer/tap/lsl

# on Windows
# should be installed automatically by pip when installing NDSInstall the NDS package with the included examples and utilities via pip:pip install "neural-data-simulator[extras]"Quick startRun the following scripts:nds_post_install_config
run_closed_loopNOTE:You might need to give permissions like network access when running the scripts.
Package: neural-diffeqs
A PyTorch-based library for the instantiation of neural differential equations.InstallationInstall fromPYPI:pipinstallneural_diffeqsAlternatively, install the development version from GitHub:gitclonehttps://github.com/mvinyard/neural-diffeqs.git;cd./neural-diffeqs
pipinstall-e.To-do and/or potential directions:Integration of neural controlled differential equations (neural CDEs).Build SDE-GANsNeural PDEsReferencesThe library builds upon the foundational research and developments in the field. We acknowledge and express our gratitude to the authors of the following key works that have shaped our understanding of neural differential equations and their applications:
Patrick Kidger, James Foster, Xuechen Li, Harald Oberhauser, Terry Lyons[1] Kidger, P., Foster, J., Li, X., Oberhauser, H., Lyons, T., (2021). Neural SDEs as Infinite-Dimensional GANs.ICML.[2] Chen, R. T. Q., Rubanova, Y., Bettencourt, J., & Duvenaud, D. K. (2018). Neural Ordinary Differential Equations.Adv Neural Inf Process Sys.[3] Dupont, E., Doucet, A., & Teh, Y. W. (2019). Augmented Neural ODEs.Adv Neural Inf Process Sys.[4] Kidger, P. (2022) On Neural Differential Equations. arXiv:2202.02435Questions or suggestions? Open anissueor send an email toMichael Vinyard.
Package: neuralDX7
FM Synth Parameter GeneratorRandom machine learning experiments related to the classic Yamaha DX7DexedDexed is a linux open source DX7 emulator and was used heavily in the testing of this projectSYXDX7 and it's similar instruments are programmable btformatfound hereundersysexformat.txtDatasetBig thanks to Bobby Blues for collectingtheseDX7 patches. This was the only data source
Package: neuralfilter
Neural FilterFunctionsneuralfilter.generate(x, force=False)x: Array with resolution $(H, W, C)$The dimension $C$ is recommended as 1.force: If you want to force this operation when the dimension $C$ is higher than 1,  set 'force' as True.neuralfilter.batch_generate(x, force=False)The batch processing mode of 'generate'.x: Array with resolution $(N, H, W, C)$The dimension $C$ is recommended as 1.force: If you want to force this operation when the dimension $C$ is higher than 1,  set 'force' as True.batch_generate(x, force=False)Usageimportnumpyasnpimporttensorflowastfimportmatplotlib.pyplotaspltimportneuralfilter(x_tr,y_tr),(x_te,y_te)=tf.keras.datasets.mnist.load_data()idx=1a=neuralfilter.generate(np.expand_dims(x_tr[idx],axis=-1))plt.figure(figsize=(9,3),dpi=100)plt.subplot(1,3,1)plt.imshow(x_tr[idx],cmap='gray')plt.xticks([],[])plt.yticks([],[])plt.subplot(1,3,2)plt.imshow(a,cmap='jet')plt.xticks([],[])plt.yticks([],[])plt.subplot(1,3,3)plt.imshow(x_tr[idx],cmap='gray')plt.imshow(a,cmap='jet',alpha=0.5)plt.xticks([],[])plt.yticks([],[])plt.tight_layout()plt.savefig('sample.png')plt.show()
Package: neuralflow
NeuralFlowDeep learning framework built with numpy (cupy)This version supports cuda 11.x verinstall$gitclonegitclonehttps://github.com/augustinLib/neuralflow.gitor# cpu-only
$ pip install neuralflow-cpu

# gpu (cuda 11.x)
$ pip install neuralflowQuick guideyou can build model like this,fromneuralflow.modelimport*fromneuralflow.function_classimportReLUmodel=Model(DenseLayer(784,50),ReLU(),DenseLayer(50,10))conv_model=Model(ConvLayer(input_channel=1,output_channel=30,kernel_size=5,stride=1,padding=0),ReLU(),MaxPoolingLayer(kernel_size=2,stride=2),DenseLayer(4320,100),ReLU(),DenseLayer(100,10))model_ln=Model(EmbeddingLayer(vocab_size,wordvec_size),Dropout(dropout),LSTMLayer(wordvec_size,hidden_size),Dropout(dropout),LSTMLayer(hidden_size,hidden_size),Dropout(dropout),DenseLayer(hidden_size,vocab_size))# mixed precisionmodel_ln.mixed_precision_on()# weight tyingmodel_ln.weight_tying()and the training proceeds as follows.fromneuralflow.function_classimportReLU,CrossEntropyLossfromneuralflow.optimizerimportAdamcritic=CrossEntropyLoss()optim=Adam()pred=model(x)loss=critic(pred,y)model.backward(critic)optim.update(model)you can also train model with trainerfromneuralflow.trainerimportClassificationTrainerfromneuralflow.dataimportDataLoaderdataloader=DataLoader(train_data)trainer=ClassificationTrainer(model,critic,optim,epochs,init_lr=0.001)trainer.train(dataloader)when using gpu, set it as follows.# using gpufromneuralflowimportconfigconfig.GPU=True# using cpufromneuralflowimportconfigconfig.GPU=FalseStructureneuralflow__init__.pydata.pyfunction.pyfunction_class.pymodel.pyoptimizer.pytrainer.pyutils.pynlp__init__.pyutils.pymodel.pycv__init__.pymodel.pyepoch_noticesend_message.pytoken_generator.pydatasettestREADME.md.gitignore
Package: neuralflow-cpu
NeuralFlowDeep learning framework built with numpy (cupy)This version supports only cpuinstall$gitclonegitclonehttps://github.com/augustinLib/neuralflow.gitor# cpu-only
$ pip install neuralflow-cpu

# gpu (cuda 11.x)
$ pip install neuralflowQuick guideyou can build model like this,fromneuralflow.modelimportModel,DenseLayer,ConvLayer,MaxPoolingLayerfromneuralflow.function_classimportReLUmodel=Model(DenseLayer(784,50),ReLU(),DenseLayer(50,10))conv_model=Model(ConvLayer(input_channel=1,output_channel=30,kernel_size=5,stride=1,padding=0),ReLU(),MaxPoolingLayer(kernel_size=2,stride=2),DenseLayer(4320,100),ReLU(),DenseLayer(100,10))and the training proceeds as follows.fromneuralflow.function_classimportReLU,CrossEntropyLossfromneuralflow.optimizerimportAdamcritic=CrossEntropyLoss()optim=Adam()pred=model(x)loss=critic(pred,y)model.backward(critic)optim.update(model)you can also train model with trainerfromneuralflow.trainerimportClassificationTrainerfromneuralflow.dataimportDataLoaderdataloader=DataLoader(train_data)trainer=ClassificationTrainer(model,critic,optim,epochs,init_lr=0.001)trainer.train(dataloader)when using gpu, set it as follows.# using gpufromneuralflowimportconfigconfig.GPU=True# using cpufromneuralflowimportconfigconfig.GPU=FalseStructureneuralflow__init__.pydata.pyfunction.pyfunction_class.pymodel.pyoptimizer.pytrainer.pyutils.pynlp__init__.pyutils.pymodel.pyepoch_noticesend_message.pytoken_generator.pydatasettestREADME.md.gitignore
Package: neural-fmri
Documentation and examples:http://azraq27.github.com/neuralThis library contains helper functions for doing analyses on fMRI data in Python.In comparison to other Python libraries designed to interact with fMRI data
(e.g., NIPY and PyNIfTI), this library is not intended to interact directly with
the data in any way, just to provide helpful wrapper functions and shortcut methods to
make your life easier.Since the author uses primarily AFNI, most of the functions are written that way,
but don’t specifically have to be that way…
Package: neuralgym011
NeuralGym is born for fast prototyping of experimental ideas on deep learning.[![ReadTheDoc](https://readthedocs.org/projects/neuralgym/badge/?version=latest)](http://neuralgym.readthedocs.io)Due to rapid/messy development and stability concerns, currently only limited modules are released for reproducing other repositories.## Document[ReadTheDocs: NeuralGym](http://neuralgym.readthedocs.io)## Installationpip install git+https://github.com/JiahuiYu/neuralgym
Package: neuralgym11
NeuralGym is born for fast prototyping of experimental ideas on deep learning.[![ReadTheDoc](https://readthedocs.org/projects/neuralgym/badge/?version=latest)](http://neuralgym.readthedocs.io)Due to rapid/messy development and stability concerns, currently only limited modules are released for reproducing other repositories.## Document[ReadTheDocs: NeuralGym](http://neuralgym.readthedocs.io)## Installationpip install git+https://github.com/JiahuiYu/neuralgym
Package: neuralgym111
NeuralGym is born for fast prototyping of experimental ideas on deep learning.[![ReadTheDoc](https://readthedocs.org/projects/neuralgym/badge/?version=latest)](http://neuralgym.readthedocs.io)Due to rapid/messy development and stability concerns, currently only limited modules are released for reproducing other repositories.## Document[ReadTheDocs: NeuralGym](http://neuralgym.readthedocs.io)## Installationpip install git+https://github.com/JiahuiYu/neuralgym
Package: neural-homomorphic-vocoder
neural-homomorphic-vocoderA neural vocoder based on source-filter model called neural homomorphic vocoderInstallpipinstallneural-homomorphic-vocoderUsageUsage for NeuralHomomorphicVocoder classInputz: Gaussian noisex: mel-filterbankcf0: continuous f0uv: u/v symbolimporttorchfromnhvimportNeuralHomomorphicVocodernet=NeuralHomomorphicVocoder(fs=24000,# sampling frequencyfft_size=1024,# size for impuluse responce of LTVhop_size=256,# hop size in each mel-filterbank framein_channels=80,# input channels (i.e., dimension of mel-filterbank)conv_channels=256,# channel size of LTV filterccep_size=222,# output ccep size of LTV filterout_channels=1,# output size of networkkernel_size=3,# kernel size of LTV filterdilation_size=1,# dilation size of LTV filtergroup_size=8,# group size of LTV filterfmin=80,# min freq. for melspcfmax=7600,# max freq. for melspc (recommend to use full-band)roll_size=24,# frame size to get median to estimate logspc from melspcn_ltv_layers=3,# # layers for LTV ccep generatorn_postfilter_layers=4,# # layers for output postfiltern_ltv_postfilter_layers=1,# # layers for LTV postfilter (if ddsconv)harmonic_amp=0.1,# amplitude of sinusoidalsnoise_std=0.03# standard deviation of Gaussian noiseuse_causal=False,# use causal conv LTV filteruse_reference_mag=False,# use reference logspc calculated from melspcuse_tanh=False,# apply tanh to output else linearuse_uvmask=False,# apply uv-based mask to harmonicuse_weight_norm=True,# apply weight norm to conv1d layerconv_type="original"# LTV generator network type ["original", "ddsconv"]postfilter_type=None,# postfilter network type ["None", "normal", "ddsconv"]ltv_postfilter_type=None,# LTV postfilter network type \# ["None", "normal", "ddsconv"]ltv_postfilter_kernel_size=128# kernel_size for LTV postfilterscaler_file=None# path to .pkl for internal scaling of melspc# (dict["mlfb"] = sklearn.preprocessing.StandardScaler)conv_type="original"postfilter_type="ddsconv"ltv_postfilter_type="conv"ltv_postfilter_kernel_size=128scaler_file=None)B,T,D=3,100,in_channels# batch_size, n_frames, n_melsz=torch.randn(B,1,T*hop_size)x=torch.randn(B,T,D)cf0=torch.randn(B,T,1)uv=torch.randn(B,T,1)y=net(z,torch.cat([x,cf0,uv],dim=-1))# z: (B, 1, T * hop_size), c: (B, D+2, T)y=net._forward(z,x,cf0,uv)y=net.inference(c)# for evaluationFeaturesTrain usingkan-bayashi/ParallelWaveGANwith continuous F0 and uv symbolsSupport depth-wise separable convolutionSupport incremental inferenceReferences@article{liu20,title={Neural Homomorphic Vocoder},author={Z.~Liu and K.~Chen and K.~Yu},journal={Proc. Interspeech 2020},pages={240--244},year={2020}}