Saravanan666/pypi-org huggingface dataset:
Package: neptune-prophet
Neptune + Prophet integrationExperiment tracking for Prophet-trained models.What will you get with this integration?Log, organize, visualize, and compare ML experiments in a single placeMonitor model training liveVersion and query production-ready models and associated metadata (e.g., datasets)Collaborate with the team and across the organizationWhat will be logged to Neptune?parameters,forecast data frames,residual diagnostic charts,other metadataResourcesDocumentationCode example on GitHubExample project in the Neptune appRun example in Google ColabExampleBefore you startInstall and set up Neptune.Have Prophet installed.Installation# On the command line
pip install neptune-prophetLogging example# In PythonimportpandasaspdfromprophetimportProphetimportneptuneimportneptune.integrations.prophetasnpt_utils# Start a runrun=neptune.init_run(project="common/fbprophet-integration",api_token=neptune.ANONYMOUS_API_TOKEN)# Load dataset and fit modeldataset=pd.read_csv("https://raw.githubusercontent.com/facebook/prophet/main/examples/example_wp_log_peyton_manning.csv")model=Prophet()model.fit(dataset)# Log summary metadata (including model, dataset, forecast and charts)run["prophet_summary"]=npt_utils.create_summary(model=model,df=df,fcst=forecast)# Stop the runrun.stop()SupportIf you got stuck or simply want to talk to us, here are your options:Check ourFAQ page.You can submit bug reports, feature requests, or contributions directly to the repository.Chat! In the Neptune app, click the blue message icon in the bottom-right corner and send a message. A real person will talk to you ASAP (typically very ASAP).You can just shoot us an email atsupport@neptune.ai.
Package: neptune-pytorch
Neptune - PyTorch integrationExperiment tracking for PyTorch-trained models.What will you get with this integration?Log, organize, visualize, and compare ML experiments in a single placeMonitor model training liveVersion and query production-ready models and associated metadata (e.g., datasets)Collaborate with the team and across the organizationWhat will be logged to Neptune?Training metricsModel checkpointsModel predictionsOther metadataResourcesDocumentationCode example on GitHubExample project in the Neptune appExamplefromneptune_pytorchimportNeptuneLoggerrun=neptune.init_run()neptune_logger=NeptuneLogger(run,model=model,# your torch Model()log_model_diagram=True,log_gradients=True,log_parameters=True,log_freq=30,)SupportIf you got stuck or simply want to talk to us, here are your options:Check ourFAQ page.You can submit bug reports, feature requests, or contributions directly to the repository.Chat! In the Neptune app, click the blue message icon in the bottom-right corner and send a message. A real person will talk to you ASAP (typically very ASAP).You can just shoot us an email atsupport@neptune.ai.
Package: neptune-resolver-default
Basic dns resolver for Neptune DNS ServerThis is a basic dns resolver for neptune dns serverInstallationYou can install from pypi.org or clone this repoFrom PYPIpip3 install neptune_resolver_defaultFrom this repogit clone https://git.best-service.online/yurzs/neptune-default-resolver
cd neptune-default-resolver
python3 setup.py installHow to useIn Neptune config file addNEPTUNE_RESOLVER_DEFAULT = {
    'resolvers': ['1.1.1.1', '8.8.8.8'] # Your favorite DNS resolvers
}
Package: neptune-resolver-redis
# Neptune Resolver Rest
This module is made as a resolving middleware for Neptune DNS server
## Installation`pip3 install neptune_resolver_redis`## Connect to server
In config.py edit RESOLVERS variable. Add`'neptune_resolver_redis'`It will look like this`RESOLVERS =['neptune_resolver_redis']`Then you need to set settings for this resolver. Those settings are set by creating variable in config.py with capitalized module name like`NEPTUNE_RESOLVER_REST ={'host':'localhost','database': 1}`
Package: neptune-resolver-rest
Neptune Resolver RestThis module is made as a resolving middleware for Neptune DNS serverInstallationpip3 install neptune_resolver_restConnect to serverIn config.py edit RESOLVERS variable. Add'neptune_resolver_rest'It will look like thisRESOLVERS = ['neptune_resolver_rest']Then you need to set settings for this resolver. Those settings are set by creating variable in config.py with upper module name likeNEPTUNE_RESOLVER_REST = {'base_url':'https://example.com'}
Package: neptune-sacred
Neptune + Sacred IntegrationNeptune is a tool used for experiment tracking, model registry, data versioning, and live model monitoring. This integration lets you use it as a UI (frontend) for the experiments you track in Sacred.What will you get with this integration?Log, display, organize, and compare ML experiments in a single placeVersion, store, manage, and query trained models, and model building metadataRecord and monitor model training, evaluation, or production runs liveWhat will be logged to Neptune?HyperparametersLosses and metricsTraining code (Python scripts or Jupyter notebooks) and Git informationDataset versionModel configurationOther metadataExample custom dashboard in the Neptune appResourcesDocumentationCode example on GitHubExample dashboard in the Neptune appRun example in Google ColabExampleOn the command line:pip install neptune-sacredIn Python:importneptune# Start a runrun=neptune.init_run(project="common/sacred-integration",api_token=neptune.ANONYMOUS_API_TOKEN,)# Create a Sacred experimentexperiment=Experiment("image_classification",interactive=True)# Add NeptuneObserver and run the experimentexperiment.observers.append(NeptuneObserver(run=run))experiment.run()SupportIf you got stuck or simply want to talk to us, here are your options:Check ourFAQ pageYou can submit bug reports, feature requests, or contributions directly to the repository.Chat! When in the Neptune application click on the blue message icon in the bottom-right corner and send a message. A real person will talk to you ASAP (typically very ASAP),You can just shoot us an email atsupport@neptune.ai
Package: neptune-sklearn
Neptune + scikit-learn integrationExperiment tracking for scikit-learn–trained models.What will you get with this integration?Log, organize, visualize, and compare ML experiments in a single placeMonitor model training liveVersion and query production-ready models and associated metadata (e.g., datasets)Collaborate with the team and across the organizationWhat will be logged to Neptune?classifier and regressor parameters,pickled model,test predictions,test predictions probabilities,test scores,classifier and regressor visualizations, like confusion matrix, precision-recall chart, and feature importance chart,KMeans cluster labels and clustering visualizations,metadata including git summary info,other metadataResourcesDocumentationCode example on GitHubRuns logged in the Neptune appRun example in Google ColabExample# On the command line:
pip install neptune-sklearn# In Python, prepare a fitted estimatorparameters={"n_estimators":70,"max_depth":7,"min_samples_split":3}estimator=...estimator.fit(X_train,y_train)# Import Neptune and start a runimportneptunerun=neptune.init_run(project="common/sklearn-integration",api_token=neptune.ANONYMOUS_API_TOKEN,)# Log parameters and scoresrun["parameters"]=parametersy_pred=estimator.predict(X_test)run["scores/max_error"]=max_error(y_test,y_pred)run["scores/mean_absolute_error"]=mean_absolute_error(y_test,y_pred)run["scores/r2_score"]=r2_score(y_test,y_pred)# Stop the runrun.stop()SupportIf you got stuck or simply want to talk to us, here are your options:Check ourFAQ pageYou can submit bug reports, feature requests, or contributions directly to the repository.Chat! When in the Neptune application click on the blue message icon in the bottom-right corner and send a message. A real person will talk to you ASAP (typically very ASAP),You can just shoot us an email atsupport@neptune.ai
Package: neptune-tensorflow-keras
Neptune + Keras integrationExperiment tracking for Keras-trained models.What will you get with this integration?Log, organize, visualize, and compare ML experiments in a single placeMonitor model training liveVersion and query production-ready models and associated metadata (e.g., datasets)Collaborate with the team and across the organizationWhat will be logged to Neptune?hyperparameters for every run,learning curves for losses and metrics during training,hardware consumption and stdout/stderr output during training,TensorFlow tensors as images to see model predictions live,training code and Git commit information,model weights,other metadataExample charts in the Neptune UI with logged accuracy and lossResourcesDocumentationCode example on GitHubRuns logged in the Neptune appRun example in Google ColabExampleOn the command line:pip install neptune-tensorflow-kerasIn Python:importneptunefromneptune.integrations.tensorflow_kerasimportNeptuneCallbackfromneptuneimportANONYMOUS_API_TOKEN# Start a runrun=neptune.init_run(project="common/tf-keras-integration",api_token=ANONYMOUS_API_TOKEN,)# Create a NeptuneCallback instanceneptune_cbk=NeptuneCallback(run=run,base_namespace="metrics")# Pass the callback to model.fit()model.fit(x_train,y_train,epochs=5,batch_size=64,callbacks=[neptune_cbk],)# Stop the runrun.stop()SupportIf you got stuck or simply want to talk to us, here are your options:Check ourFAQ pageYou can submit bug reports, feature requests, or contributions directly to the repository.Chat! When in the Neptune application click on the blue message icon in the bottom-right corner and send a message. A real person will talk to you ASAP (typically very ASAP),You can just shoot us an email atsupport@neptune.ai
Package: neptune-xgboost
Neptune + XGBoost integrationExperiment tracking, model registry, data versioning, and live model monitoring for XGBoost trained models.What will you get with this integration?Log, display, organize, and compare ML experiments in a single placeVersion, store, manage, and query trained models, and model building metadataRecord and monitor model training, evaluation, or production runs liveWhat will be logged to Neptune?metrics,parameters,learning rate,pickled model,visualizations (feature importance chart and tree visualizations),hardware consumption (CPU, GPU, Memory),stdout and stderr logs,training code and Git commit information,other metadataExample dashboard with train-valid metrics and selected parametersResourcesDocumentationCode example on GitHubExample of a run logged in the Neptune appRun example in Google ColabExampleOn the command line:pip install xgboost>=1.3.0 neptune-xgboostIn Python:importneptuneimportxgboostasxgbfromneptune.integrations.xgboostimportNeptuneCallback# Start a runrun=neptune.init_run(project="common/xgboost-integration",api_token=neptune.ANONYMOUS_API_TOKEN,)# Create a NeptuneCallback instanceneptune_callback=NeptuneCallback(run=run,log_tree=[0,1,2,3])# Prepare datasets...data_train=xgb.DMatrix(X_train,label=y_train)# Define model parametersmodel_params={"eta":0.7,"gamma":0.001,"max_depth":9,...}# Train the model and log metadata to the run in Neptunexgb.train(params=model_params,dtrain=data_train,callbacks=[neptune_callback],)SupportIf you got stuck or simply want to talk to us, here are your options:Check ourFAQ pageYou can submit bug reports, feature requests, or contributions directly to the repository.Chat! When in the Neptune application click on the blue message icon in the bottom-right corner and send a message. A real person will talk to you ASAP (typically very ASAP),You can just shoot us an email atsupport@neptune.ai
Package: neqsim
NeqSim PythonNeqSim Python is part of theNeqSim project. NeqSim Python is a Python interface to theNeqSim Java libraryfor estimation of fluid behavior and process design for oil and gas production. NeqSim Python toolboxes (eg.thermoToolsandprocessTools) are implemented to streamline use of neqsim in Python. Examples of use are given in jupyter workbooks.ReleasesNeqSim Python is distributed as a pip package.End-users should install neqsim python with some additional packages by runningpip install neqsim[interactive]Getting StartedSee theNeqSim Python Wikifor how to use NeqSim Python via Python or in Jupyter notebooks. Also seeexamples of use of NeqSim for Gas Processing in Colab. Learn and ask questions inDiscussions for use and development of NeqSim.PrerequisitesJava version 8 or higher (Java JDK) needs to be installed. The Python packageJPypeis used to connect Python and Java. Read theinstallation requirements for Jpype. Be aware that mixing 64 bit Python with 32 bit Java and vice versa crashes on import of the jpype module. The needed Python packages are listed in theNeqSim Python dependencies page.ContributingPlease readCONTRIBUTING.mdfor details on our code of conduct, and the process for submitting pull requests.Discussion forumQuestions related to neqsim can be posted in thegithub discussion pages.VersioningNeqSim useSemVerfor versioning.LicenceNeqSim is distributed under theApache-2.0licence.AcknowledgmentsA number of master and PhD students at NTNU have contributed to development of NeqSim. We greatly acknowledge their contributions.
Package: neqsimapi-connector
NeqSimAPI-client-pythonA python package to simplify calling NeqSimAPI for end-users handling authentication.Seehttps://neqsimapi.app.radix.equinor.com/docsfor available endpoints.UsageSeehttps://github.com/equinor/neqsimapi-client-python/blob/main/example/demo.pyfor a simple demo that connects and gets data from NeqSimAPI.A short snippet is seen belowfromneqsimapi_connector.ConnectorimportConnectorasneqsim_api_connectordata={"fluid":"CO2","initial_temperature":25,"initial_pressure":15}c=neqsim_api_connector()res=c.post_result("DEMO/demo-process",data=data)print(res)Install using pipUsage of NeqSimAPI is limited to equinor users, but the package is available on pip.python -m pip install neqsimapi_connector
Package: ner
# PyNERThe Python interface to the [Stanford Named Entity Recognizer](https://github.com/dat/stanford-ner).## Project Homepage[Stanford Named Entity Recognizer](http://nlp.stanford.edu/software/CRF-NER.shtml)## Installation$ python setup.py install## Basic Usage>>> import ner
>>> tagger = ner.HttpNER(host='localhost', port=8080)
>>> tagger.get_entities("University of California is located in California, United States")
{'LOCATION': ['California', 'United States'],
 'ORGANIZATION': ['University of California']}
>>> tagger.json_entities("Alice went to the Museum of Natural History.")
'{"ORGANIZATION": ["Museum of Natural History"], "PERSON": ["Alice"]}'## Online Demo[Graphical demo of several models](http://nlp.stanford.edu:8080/ner/)## LicenseBSD License## AuthorPyNER is developed by maintained by Dat Hoang.
It can be found here:http://github.com/dat/pyner
Package: ner4opt
Ner4Opt: Named Entity Recognition for OptimizationGiven an optimization problem in natural language, Ner4Opt extracts optimization related entities from free-form text.See ourHugginFace Space Demoto test it yourself 🤗.The Ner4Opt model (CPAIOR'23,NeurIPS'22) is trained to detect six named entities:CONST_DIR: Constraint directionLIMIT: LimitOBJ_DIR: Objective directionOBJ_NAME: Objective namePARAM: ParameterVAR: VariableHere are the details of ourpre-trained modelsand thetraining procedure. Large pretrained models are hosted onHuggingFace Models.Quick Startfromner4optimportNer4Opt# Input optimization problem description as free-form textproblem_description="The Notorious Desk company wants to promote a new brand of wine and wants to market it using a total market budget of $ 87,000 . To do so , the company needs to decide how much to allocate on each of its two advertising channels : ( 1 ) morning TV show and ( 2 ) social media . Each day , it costs the company $ 1,000 and $ 2000 to run advertisement spots on morning TV show and social media respectively . The expected daily reach , based on past ratings , is 15,000 viewers for each morning show spot and 30,000 internet users for a social media spot . The chief marketer knows from her experience that both channels are key to the success of the product launch . She wants to plan at least 4 but no more than 7 morning show spots . In addition , the social media spots needs to be at least 30 due to pricing tier policy . How many times should each of the media channels be used to maximize the reach of the campaign ?"# Ner4Opt Model with options lexical, lexical_plus, semantic, hybrid (default).ner4opt=Ner4Opt(model="hybrid")# Extract a list of dictionaries corresponding to entities found in the given problem description.# Each dictionary holds keys for the following:# start (starting character index of the entity), end (ending character index of the entity)# word (entity), entity_group (entity label) and score (confidence score for the entity)entities=ner4opt.get_entities(problem_description)# Outputprint("Number of entities found: ",len(entities))# Example entity output[{'start':108,'end':114,'word':'budget','entity_group':'CONST_DIR','score':0.9919970308651846},{'start':120,'end':126,'word':'87,000','entity_group':'LIMIT','score':0.9993724035912778},{...},]InstallationNer4Opt requires Python 3.8+ and can be installed from PyPI usingpip install ner4optor by building from sourcegitclonehttps://github.com/skadio/ner4opt.gitcdner4opt
pipinstall.TestingTo run tests, execute the following from the root folder:python -m unittestCitationCitationIf you use Ner4Opt, please cite the following paper:@inproceedings {ner4opt,
    title = {Ner4Opt: Named Entity Recognition for Optimization Modelling from Natural Language}
	author = {Parag Pravin Dakle, Serdar Kadıoğlu, Karthik Uppuluri, Regina Politi, Preethi Raghavan, SaiKrishna Rallabandi, Ravisutha Srinivasamurthy}
    journal = {The 20th International Conference on the Integration of Constraint Programming, Artificial Intelligence, and Operations Research (CPAIOR 2023)},
	year = {2023},
}
Package: ner-anonymizer
NER AnonymizerThis package contains some developmental tools to anonymize a pandas dataframe.NER Anonymizer contains a classDataAnonymizerwhich handles anonymization for both free text and categorical columns in a pandas dataframe:For free text columns, it uses a pretrained model from thetransformerspackage to perform named entity recognition (NER) to pick up user specified entities such as location and person, generate a MD5 hash for the entity, replaces the entity with the hash, and stores the hash to entity in a dictionaryFor categorical columns, it simply generates a MD5 hash for every category, replaces the category with the hash, and stores the hash to category in a dictionaryThe saved dictionary can then be used for de-anonymization and the original dataset is obtained. Referential integrity is preserved as the same hash will be generated for the same category / entity.InstallationInstall the package with pippip install ner-anonymizerExample UsageThe package uses the NER modeldslim/bert-base-NERby default. To anonymize a particular pandas dataframe,df, using a pretrained NER model:import ner_anonymizer

# to anonymize
anonymizer = ner_anonymizer.DataAnoynmizer(
    pretrained_model_name="dslim/bert-base-NER",
    label_list=["O", "B-MISC", "I-MISC", "B-PER", "I-PER", "B-ORG", "I-ORG", "B-LOC", "I-LOC"],
    labels_to_anonymize=["B-PER", "I-PER", "B-LOC", "I-LOC"]
)
anonymized_df, hash_dictionary = anonymizer.anonymize(
    df=df,
    free_text_columns=["free_text_column_1", "free_text_column_2"],
    categorical_columns=["categorical_column_1"],

)

# to de-anonymize
de_anonymized_df = ner_anonymizer.de_anonymize_data(anonymized_df, hash_dictionary)You may specify for the argumentpretrained_model_nameany available pre-trained NER model from thetransformerspackage in the links below (do note that you will need to specify the labels that the NER model uses,label_list, and from that list, the labels you want to anonymize,labels_to_anonymize):https://huggingface.co/transformers/pretrained_models.htmlhttps://huggingface.co/modelsYou may also view an example notebook in the following directoryexamples/example_usage.ipynb.
Package: neraug
neraugThis python library helps you with augmenting text data for named entity recognition.Augmentation ExampleReference fromAn Analysis of Simple Data Augmentation for Named Entity RecognitionInstallationTo install the library:pipinstallneraugUsageOne of the example algorithms:DictionaryReplacement:>>>fromneraug.augmentatorimportDictionaryReplacement>>>fromneraug.schemeimportIOBES>>>ne_dic={'Tokyo Big Sight':'LOC'}>>>augmentator=DictionaryReplacement(ne_dic,str.split,IOBES)>>>x=['I','went','to','Tokyo']>>>y=['O','O','O','S-LOC']>>>x_augs,y_augs=augmentator.augment(x,y,n=1)>>>x_augs[['I','went','to','Tokyo','Big','Sight']]>>>y_augs[['O','O','O','B-LOC','I-LOC','E-LOC']]The library supports the following algorithms:DictionaryReplacementLabelWiseTokenReplacementMentionReplacementShuffleWithinSegmentand supports the following scheme:IOB2IOBESBILOUReferenceAppreciate for the following research:An Analysis of Simple Data Augmentation for Named Entity RecognitionCitation@misc{neraug,
  title={neraug: A data augmentation tool for named entity recognition},
  author={Hiroki Nakayama},
  url={https://github.com/Hironsan/neraug},
  year={2021}}
Package: nerblackbox
A High-level Library for Named Entity Recognition in Python.ResourcesSource Code:https://github.com/flxst/nerblackboxDocumentation:https://flxst.github.io/nerblackboxPyPI:https://pypi.org/project/nerblackboxInstallationpip install nerblackboxAboutTake a dataset from one of many available sources.
Then train, evaluate and apply a language model
in a few simple steps.1. DataChoose a dataset fromHuggingFace (HF), theLocal Filesystem (LF), anAnnotation Tool (AT)server, or aBuilt-in (BI)datasetdataset = Dataset("conll2003",  source="HF")  # HuggingFace
dataset = Dataset("my_dataset", source="LF")  # Local Filesystem
dataset = Dataset("swe_nerc",   source="BI")  # Built-inSet up the datasetdataset.set_up()2. TrainingDefine the training by choosing a pretrained model and a datasettraining = Training("my_training", model="bert-base-cased", dataset="conll2003")Run the training and get the performance of the fine-tuned modeltraining.run()
training.get_result(metric="f1", level="entity", phase="test")
# 0.90453. EvaluationLoad the modelmodel = Model.from_training("my_training")Evaluate the modelresults = model.evaluate_on_dataset("ehealth_kd", phase="test")
results["micro"]["entity"]["f1"]
# 0.90454. InferenceLoad the modelmodel = Model.from_training("my_training")Let the model predictmodel.predict("The United Nations has never recognised Jakarta's move.")
# [[
#  {'char_start': '4', 'char_end': '18', 'token': 'United Nations', 'tag': 'ORG'},
#  {'char_start': '40', 'char_end': '47', 'token': 'Jakarta', 'tag': 'LOC'}
# ]]There is much more to it than that! See thedocumentationto get started.FeaturesDataIntegration of Datasets from Multiple Sources (HuggingFace, Annotation Tools, ..)Support for Multiple Dataset Types (Standard, Pretokenized)Support for Multiple Annotation Schemes (IO, BIO, BILOU)Text EncodingTrainingAdaptive Fine-tuningHyperparameter SearchMultiple Runs with Different Random SeedsDetailed Analysis of Training ResultsEvaluationEvaluation of Any Model on Any DatasetInferenceVersatile Model Inference (Entity/Word Level, Probabilities, ..)OtherFull Compatibility with HuggingFaceGPU SupportLanguage AgnosticismSee thedocumentationfor details.Citation@misc{nerblackbox,
  author = {Stollenwerk, Felix},
  title  = {nerblackbox: a high-level library for named entity recognition in python},
  year   = {2021},
  url    = {https://github.com/flxst/nerblackbox},
}