Saravanan666/pypi-org huggingface dataset:
Package: nerforpdf
NER-APICe package permet le traitemnt du texte , l'extraction des entités(inclus code swift et code imo), ainsi que le highlighting des ces entités présente dans un fichier pdfInstallationpip install nerforpdfUsage/Exemplesimportnerforpdfasnfpnerforpdf.text_preprocessing.text_preprocessing(text,accented=True,stopw=True,punctuation=True,lowercase=True,lemmatize=True,spelling=True,expand_contraction=True,urls=True)cette fonction permet de traiter le text en utilisant les foltres présents comme argumentimportnerforpdfasnfpnerforpdf.text_preprocessing.spacy_preprocessing(text,lowercase=True,stopw=True,punctuation=True,alphabetic=True,lemmatize=True,)Permet de faire du traitement du texte à l'aide de spacyimportnerforpdfasnfpnerforpdf.highlight_pdf.output(input_file)cette fonction prend en argument le chemin vers un fichier pdf , extrait les entités(code swift et imo inclus),les highlight , et enregistre le pdf highlighté dans le dossier courant sous le nom "output.pdf"API Referenceget_entities(text)Prend un texte(String) et retourne ses entitéshighlight_pdf(pdf)Prend le pdf encodé en base64 et retourne le pdf highlighté encodé en base64 ainsi que les entités détectées
Package: nerfpy
NeRFpyNeRFpy: A Python implementation and extension of Natural Extension Reference Frame.InstallUsingpipto install:# for release (stable) version
pip install nerfpy

# for the latest version
pip install git+https://github.com/smu-tao-group/nerfpy.gitUsageFor high level usage, use NERF class to interact with PDB (read, reconstruct and write). There are also utility functions for low level usage.# interact with PDB filefromnerfpyimportNERFnerf=NERF()nerf.read_pdb(PDB_PATH)nerf.reconstruct()nerf.save_pdb(NEW_PDB_PATH)# use your own coordinates (n * 3)fromnerf.utilsimport(calc_r_from_coords,calc_alpha_from_coords,calc_psi_from_coords,reconstruct_from_internal_coords)r=calc_r_from_coords(COORDS)alpha=calc_alpha_from_coords(COORDS)psi=calc_psi_from_coords(COORDS)reconstructed_coords=reconstruct_from_internal_coords(r,alpha,psi)LicenseApache-2.0 license
Package: nerf-torch
NerfMy personal implementation of the NERF paper, with much better code. Because the original implementation has ugly code and i don't understand absolutely anything there.Paper LinkAppreciationLucidrainsAgoriansInstallpip install nerf-torchUsageimporttorchfromnerf.modelimportNerfmodel=Nerf()x=torch.randn(1,6)output=model(x)print(output)LicenseMITCitations@misc{2003.08934,Author={Ben Mildenhall and Pratul P. Srinivasan and Matthew Tancik and Jonathan T. Barron and Ravi Ramamoorthi and Ren Ng},Title={NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis},Year={2020},Eprint={arXiv:2003.08934},}
Package: nerf-toy
nerf-toyA 2D toy illustration of Neural Radiance FieldsDescription•Features•Examples•References•LicenseOriginalNo MappingBasic MappingFourier Feature MappingDescriptionnerf-toyis a 2D toy illustration of theNeural Radiance Fields. Memorizing a
2D image using an MLP is a nice problem to understand before going into solving the problem
NeRF tackles i.e. memorising a 3D scene given multiple view points.The task is to produce the(r, g, b)value of an image as a
function of(x,y)image coordinates. Our model is a coordinate-based multilayer perceptron.This is implemented using 2D convolutions with a kernel size of (1, 1), which act as "pointwise" convolutions. This
is equivalent to a densely connected multilayer perceptron for each coordinate.
Also, we use batchnorm to speed up convergence.The model is trained with the following input mappings $\gamma (\mathbf{v})$ for comparison :No mapping: $\gamma(\mathbf{v})= \mathbf{v}$.Basic mapping: $\gamma(\mathbf{v})=\left[ \cos(2 \pi \mathbf{v}),\sin(2 \pi \mathbf{v}) \right]^\mathrm{T}$.Gaussian Fourier feature mapping: $\gamma(\mathbf{v})=\left[ \cos(2 \pi \mathbf B \mathbf{v}), \sin(2 \pi \mathbf B \mathbf{v}) \right]^\mathrm{T}$,
where each entry in $\mathbf B \in \mathbb R^{m \times d}$ is sampled from $\mathcal N(0,\sigma^2)$FeaturesTransforms:Basic,Positional EncodingandGaussian Fourier FeatureData loader for any input image, where filepath, image url or bytes can be passed as inputKerasbased NeRF toy model, which can be customised based on number of layer and output channelsMetrics:PSNR,SSIMCustom training callback:PredictionVideoSaverCallback,PlotLossesAndMetricsCallbackUtility functions to read and manipulate imageExamplesThedemo notebookdemonstrates the core idea  with full model training from scratch.OriginalNo MappingBasic MappingFourier Feature MappingIt can be observed that directly regressing the(x, y)image coordinates results in blurry reconstructions.Instead, lifting the input pixel coordinates(x, y)to higher dimensions via transformations (e.g. gaussian fourier feature)
makes it easier for network to learn high frequency functions in low dimensional domains.
Training with transformed(x, y)coordinates shows dramatic improvements in the results and can preserve the sharp edges in the image.ReferencesNeRF PaperFourier Features Let Networks Learn High Frequency Functions in Low Dimensional DomainsNeural Tangent Kernel: Convergence and Generalization in Neural NetworksNeRF VideoLicenseMITImage CreditsUnsplashPOV-Ray Hall of Fame
Package: nerfviewer
nerfviewerA ipywidget for viewing the output of a nerf.InstallationYou can install usingpip:pipinstallnerfviewerIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]nerfviewerDevelopment InstallationCreate a dev environment:condacreate-nnerfviewer-dev-cconda-forgenodejsyarnpythonjupyterlab
condaactivatenerfviewer-devInstall the python. This will also build the TS package.pipinstall-e".[test, examples]"When developing your extensions, you need to manually enable your extensions with the
notebook / lab frontend. For lab, this is done by the command:jupyter labextension develop --overwrite .
yarn run buildFor classic notebook, you need to run:jupyter nbextension install --sys-prefix --symlink --overwrite --py nerfviewer
jupyter nbextension enable --sys-prefix --py nerfviewerNote that the--symlinkflag doesn't work on Windows, so you will here have to run
theinstallcommand every time that you rebuild your extension. For certain installations
you might also need another flag instead of--sys-prefix, but we won't cover the meaning
of those flags here.How to see your changesTypescript:If you use JupyterLab to develop then you can watch the source directory and run JupyterLab at the same time in different
terminals to watch for changes in the extension's source and automatically rebuild the widget.# Watch the source directory in one terminal, automatically rebuilding when neededyarnrunwatch# Run JupyterLab in another terminaljupyterlabAfter a change wait for the build to finish and then refresh your browser and the changes should take effect.Python:If you make a change to the python code then you will need to restart the notebook kernel to have it take effect.
Package: nerf-vuer
NeRF-Vuer: NeRF adaptor for the Vuer frameworkThis module adds NeRF support tovuer, a 3D visualization tool for robotics and VR applications.Installationpipinstallvuer==0.0.7-rc2
pipinstallnerf-vuer==0.0.7-rc2To Developgitclonehttps://github.com/geyang/nerf-vuer.gitcdnerf-vuer
pipinstall-e.
Package: nerfw
NerFWAboutNerFW(Nergans FrameWork)is a framework for visual novel creation. This framework
is created in an attempt to make creation of visual novels more convenient for game developers,
and at the same time to make the game harder to pirate.NerFW is based on Flask. And is creating a server which hosts the game for you.InstallationTo install the framework you need to have python 3.10 or higher installed on your computer.
Then you can install the framework using pip.pipinstallnerfwUsefull linksRead The Docs DocumentationPyPiGitHubKnown IssuesPatreon api updates creators token everytime you are logging to your campaign
Package: nerm
Nerm - No Effort Requirements ManagementNerm is a tool that automatically updates Markdown-formatted text files to track
project requirements. For each requirement, nerm will list any files and git commits
that mention it. User can specify rules for satisfying requirements, such as
each requirement must have an implementation and a test, and nerm will check that.Check out theexample requirements document.Core principlesRequirement management tool should reduce effort, not add it.
Nerm does not require boilerplate or complex formatting for the input files.Information in one place: Instead of separate reports, the cross-references
are added directly in the requirements document.InstallationEasiest way to install nerm is using Python package managerpip:pip install nermIfpipon your system is Python 2.x, usepip3instead.Once installed, you can test it works by runningnerm --help.Getting startedCreate your requirements document as a Markdown formatted file.
For each requirement, add a heading that starts with a requirement tag in format[TAG]:[ExampleReq] Example requirement
--------------------------------
This is my example requirement.When you add code or other files related to the requirement, use the tag in e.g. comments:myfunction() {
    // This function implements [ExampleReq]
}Now when you runnerm -u, the requirement document will get updated with a list of cross-references for each discovered tag.To customize the functionality, you can create aNermfile.toml.
Seefull documentationfor the available options.Also check outthe requirements documentandNermfileof this project itself.
Package: ner-metrics
NER_evalA simple implementation of strict/lenient matching to evaluate NER performance (precision, recall, F1-score) in 60 lines!This script currently only supports the IOB2 format with both strict and lenient modes.Installationpipinstallner_metricsorpipinstallgit+https://github.com/PL97/NER_eval.gitUsagefromner_metricsimportclassification_reporty_true=['B-PER','I-PER','O','B-ORG','B-ORG','O','O','B-PER','I-PER','O']y_pred=['O','B-PER','O','B-ORG','B-ORG','I-ORG','O','B-PER','I-PER','O']classification_report(tags_true=y_true,tags_pred=y_pred,mode="lenient")# for lenient matchclassification_report(tags_true=y_true,tags_pred=y_pred,mode="strict")# for strict matchExpected outputtag(lenient): PER        precision:1.0   recall:1.0      f1-score:1.0
tag(strict): PER         precision:0.5   recall:0.5      f1-score:0.5
tag(lenient): ORG        precision:1.0   recall:1.0      f1-score:1.0
tag(strict): ORG         precision:0.5   recall:0.5      f1-score:0.5The results are also saved toevaluation.jsonHow to cite this workIf you find this git repo useful, please consider citing it using the snippet below:@misc{ner_eval,author={Le Peng},title={ner_metrics: A Simple Python Snippets for NER Evaluation},howpublished={\url{https://github.com/PL97/NER_eval}},year={2022}}
Package: nerodia
IntroductionNerodia is a Python port of the Watir ruby gem.https://github.com/watir/watirSupported Python VersionsPython 2.7Python 3.4+InstallingIf you havepipon your system, you can simply install or upgrade:pip install -U nerodiaAlternately, you can download the source distribution fromPyPI(e.g. nerodia-1.0.0.tar.gz), unarchive it, and run:python setup.py installDocumentationDocumentation islocated on readthedocs.SupportSend a question to theNerodia-Generalmailing list on Google Groups. Please read these guidelines before posting.Join our Slack channelSlack has created a special slack server for the Selenium and Watir (including Nerodia) communities. You can join our Slack channel by sending Slack your emailhere. You will be sent an invitation with instructions on how to join.
Package: neroRL
neroRLneroRL is a PyTorch based research framework for Deep Reinforcement Learning specializing on Recurrent Proximal Policy Optimization.
Its focus is set on environments that are procedurally generated, while providing some usefull tools for experimenting and analyzing a trained behavior.FeaturesEnvironments:Obstacle TowerUnity ML-AgentsProcgenGym-Minigrid(Vector (one-hot) or Visual Observations (84x84x3))Gym CartPoleusing masked velocityDM BalletProximal Policy Optimization (PPO)Discrete and Multi-Discrete Action SpacesVector and Visual Observation Spaces (either alone or simultaneously)Recurrent Policies using Truncated Backpropagation Through TimeShared and None-Shared Parameters across the Policy and the Value FunctionDecoupled Proximal Policy OptimizationSame features as PPO, but the parameters, as well as the gradients, are decoupledDecoupled Advantage Actor-Critic (DAAC,Raileanu & Fergus, 2021)The actor network estimates the policy and the advantage functionObstacle Tower ChallengeOriginally, this work started out by achieving the 7th place during theObstacle Tower Challengeby using a relatively simple FFCNN. Thisvideopresents some footage of the approach and the trained behavior:Recently we published apaperat CoG 2020 (best paper candidate) that analyzes the taken approach. Additionally the model was trained on 3 level designs and was evaluated on the two left out ones. The results can be reproduced using theobstacle-tower-challengebranch.Getting StartedTo get started check out thedocs!
Package: nerpii
NerpiiNerpii is a Python library developed to perform Named Entity Recognition (NER) on structured datasets and synthesize Personal Identifiable Information (PII).NER is performed withPresidioand with aNLP modelavailable on HuggingFace, while the PII generation is based onFaker.InstallationYou can install Nerpii by using pip:pipinstallnerpiiQuickstartNamed Entity RecognitionYou can import the NamedEntityRecognizer usingfromnerpii.named_entity_recognizerimportNamedEntityRecognizerYou can create a recognizer passing as parameter a path to a csv file or a Pandas Dataframerecognizer=NamedEntityRecognizer('./csv_path.csv')Please note that if there are columns in the dataset containing names of people consisting of first and last names (e.g. John Smith), before creating a recognizer, it is necessary to split the name into two different columns calledfirst_nameandlast_nameusing the functionsplit_name().fromnerpii.named_entity_recognizerimportsplit_namedf=split_name('./csv_path.csv',name_of_column_to_split)The NamedEntityRecognizer class contains three methods to perform NER on a dataset:recognizer.assign_entities_with_presidio()which assigns Presidio entities, listedhererecognizer.assign_entities_manually()which assigns manually ZIPCODE and CREDIT_CARD_NUMBER entitiesrecognizer.assign_organization_entity_with_model()which assigns ORGANIZATION entity using aNLP modelavailable on HuggingFace.To perform NER, you have to run these three methods sequentially, as reported below:recognizer.assign_entities_with_presidio()recognizer.assign_entities_manually()recognizer.assign_organization_entity_with_model()The final output is a dictionary in which column names are given as keys and assigned entities and a confidence score as values.This dictionary can be accessed usingrecognizer.dict_global_entitiesPII generationAfter performing NER on a dataset, you can generate new PII using Faker.You can import the FakerGenerator usingfromnerpii.faker_generatorimportFakerGeneratorYou can create a generator usinggenerator=FakerGenerator(dataset,recognizer.dict_global_entities)If you want to generate Italian PII, addlang = "it"as parameter to the previous object.To generate new PII you can rungenerator.get_faker_generation()The method above can generate the following PII:addressphone numberemail naddressfirst namelast namecitystateurlzipcodecredit cardssncountryExamplesYou can find a notebook example in thenotebookfolder.
Package: nershcalculator
CalculatorDoes basic math operationsMethods :add- Adds the given number to the current number in the calculator memorysubtract- Subtracts the given number from the current number in the calculator memorymultiply- Multiplies current number in the calculator memory by the given numberdivide- Divides current number in the calculator memory by the given numberroot- Takes the given number root of the current number in the calculatorreset- Resets calculator memory, default: 0InstallationpipinstallnershcalculatorUsageAddition of numbers:>>>fromnershcalculatorimportCalculator>>>calculations=Calculator()>>>calculations.add(5)'5.0'>>>calculations.add(10)'15.0'Subtraction of numbers:>>>fromnershcalculatorimportCalculator>>>calculations=Calculator()>>>calculations.subtract(5)'-5.0'>>>calculations.subtract(10)'-15.0'Number multiplication:>>>fromnershcalculatorimportCalculator>>>calculations=Calculator(5)>>>calculations.multiply(10)'50.0'>>>calculations.multiply(5)'250.0'Number division:>>>fromnershcalculatorimportCalculator>>>calculations=Calculator(5)>>>calculations.divide(5)'1.0'>>>calculations.divide(5)'0.2'Taking n root out of a number:>>>fromnershcalculatorimportCalculator>>>calculations=Calculator(125)>>>calculations.root(3)'5.0'Resetting calculator:>>>fromnershcalculatorimportCalculator>>>calculations=Calculator()>>>calculations.add(100)'100.0'>>>calculations.reset()'0.0'ChangelogLicenseMIT
Package: nertivia4py
Nertivia4PYA Python wrapper for the Nertivia API.Support Nertivia server :https://nertivia.net/i/nertivia4pyInstallpip install nertivia4pyExampleimportnertivia4pytoken="TOKEN_HERE"prefix="!"bot=nertivia4py.Bot(prefix)@bot.eventdefon_success(event):print("Connected!")@bot.command(name="ping",description="Ping command.")defping_command(message,args):message.reply("Pong!")bot.run(token)For more examples, take a look at the examples folder in the github repo.
Package: nertivia.py
Nertivia.pyThis is the official Python API Wrapper for the Nertiva chat platform.Support Server:https://nertivia.net/i/npyInstallationYou can installnertivia.pywith pip usingpip install nertivia.pyorpip3 install nertivia.pyonce completed make sure you import it to your Python file withimport nertivia.Example Botimportnertiviatoken=""client=nertivia.Bot(debug=False)# Change to True to enable viewing of events, information@client.eventasyncdefon_ready():print("Logged in as",client.user.username)@client.eventasyncdefon_quit():print("I'm disconnected!")@client.eventasyncdefon_status_change(data):print(data)@client.eventasyncdefon_message(message):ifmessage.content.startswith("!ping"):awaitmessage.channel.send("pong")client.login(token)Planned changes to Nertivia.pyAdd support for commands for better organisationSub folder for events and commandsWrite docs for Nertivia.py
Package: nertk
nertk - Name Entity Recognition toolkitEntator class - Annotate name entities in text  inline within yourJupyter notebookin Python.1 - OverviewIn a data science or machine learning project, you may prepare and study text with name entities within a Jupyter notebook then need to annotate the data to augment the training or fix errors in your source data.Since you are already working within a Jupyter notebook, the Entator works inline allowing you to interact with your data and annotate it quickly and easily, syncing straight back to your input data arrays or matrices.Within Jupyter, you can easily home in on problem input data - perhaps only misclassified entity - so you can step through and adjust token type just for those items.The Entator widget is designed with a flexible API making it quick and easy to get started exploring your dataset, guessing how to work with your data without explicit configuration where possible.The project is currently in ALPHA development phase, and I appreciate all feedback on any problems including details on how the current code works or fails to work for the structure of your particular projects.2 - ExamplesYou can easily combine Entator's interactive components to suit your project. Here are some examples.Annotate new samplesThen set up Entator to display buttons for each label and each word in the text, click on button to change the label.fromnertkimportEntatorannotator=Entator(labels=['other','person','location'],inputs=[['John','is','going','to','Germany','tomorrow','.']])annotator.run()#get annotationannotator.targetsCorrect annotated  samplesfromnertkimportEntatorannotator=Entator(labels=['other','person','location'],inputs=[['John','is','going','to','Germany','tomorrow','.']],targets=[['person','other','other','other','location','other','other']])annotator.run()#get annotationannotator.targets3 - InstallationInstall from PyPi (recommended)pip install nertk4 - Contact for FeedbackPlease get in touch with any feedback or questions:Linkedin. It will be especially useful to understand the structure of your project and what is needed for your data annotation - e.g. extra entity types. There are many ideas on the roadmap, and your input is vital for prioritising these.5 - LicenseThis code is released under an MIT license.
Package: nerualpha
To build the SDK locally:Because I've been experiencing some issues with the build process onMac M1, I decided to use docker to install dependencies and build the SDK. I've created aDockerfilethat can be used to build the SDK.I mount the current directory to the container to have the artifacts after the build process available on the host machine in/distfolder.TheDockerfileis located in thepythondirectory. To build the SDK, run the following command:# Build the docker imagedockerbuild-tneru-sdk-python.# Build the SDKmakebuild
Package: nerv
What's new in 0.2.5AddedFunctionality for visualizing multiple experimentsHome page, consists of the experiment directories found in the input pathNavbar, includes a link to the home page, settings, GitHub, and DocsSettings, includes a theme changer that enables users to modify the application theme to their likingChangedThestartfunction now expects a directory path as input, where each subdirectory represents an experiment and contains the corresponding JSON files for visualizationfaviconNeuroimaging Results VisualizationNeuroimaging Results Visualization (NeRV) is a web interface developed in Python usingPlotly Dash,Dash Bootstrap Components, andpandasfor visualization of neuroimaging results obtained from continuous testing of neuroimaging data across software pipelines.Getting StartedInstallationExample usageDeploymentLicenseGetting StartedInstallationInstall NeRV using pip:pipinstallnervExample usageIn order for NeRV to generate and populate plots the underlying app requires access to the directory that houses subdirectories, which in turn contain the JSON files to be visualized. The path to directory can be passed to the app as input to thestartfunction.fromnervimportappapp.start("path-to-data-directory")After executing the file containing the above code snippet, a local server is started at port 8050 (by default). You can access the running NeRV application using a browser through the URLlocalhost:8050.DeploymentTo deploy your NeRV app, you can utilizeGunicorn. Simply follow the instructions outlined in the Dash documentationhere, making the necessary adjustment in the app.py module content:app.pyfromnervimportappserver=app.start("path-to-data-directory",False)Note that when thelocalparameter of thestartfunction is set toFalse, it will return theapp.serverobject. This object represents the underlying Flask server that drives the Dash application. You can utilize theapp.serverobject to customize and extend the NeRV application, going beyond the default functionality offered. For more details, refer to theFlask documentation.LicenseThis project is licensed under the terms ofMIT License.
Package: nesc
:rocket: nesc :rocket:Installpipinstall-Unescpipinstall-U--no-cache-dir-ihttps://pypi.python.org/pypinescUsagesnesc-cli --helpnesc-clinesc-cli extract4ddlnesc-cli extract4excelnesc text-match '手机号' '标准字段.txt' --model-home chinese_roformer-sim-char-ft_L-6_H-384_A-6nesc text-match-v2 '手机号' '标准字段.txt' --model-home chinese_roformer-sim-char-ft_L-6_H-384_A-6nesc-guinesc-segnesc-ocrTODO=======
History0.0.0 (2021-09-04)First release on PyPI.