Package: knodle
Knodle (Knowledge-supervised Deep Learning Framework) - a new framework for weak supervision with neural networks. It provides a modularization for separating weak data annotations, powerful deep learning models, and methods for improving weakly supervised training.More details about Knodle are in our recentpaper.Latest newsJune 2021:Our paper was accepted onACL 2021 RepL4NLP Workshop.Apr 2021: Knodle first release! :rocket:Apr 2021:Anastasiia Sedova, Andreas Stephan, Marina Speranskaya, Benjamin Roth.Knodle: Modular Weakly Supervised Learning with PyTorch(preprint).Installationpip install knodleUsageknodle offers various methods for denoising weak supervision sources and improve them. There are several methods available for denoising. Examples can be seen in the tutorials folder.There are four mandatory inputs for knodle:model_input_x: Your model features (e.g. TF-IDF values) without any labels. Shape: (n_instances x features)mapping_rules_labels_t: This matrix maps all weak rules to a label. Shape: (n_rules x n_classes)rule_matches_z: This matrix shows all applied rules on your dataset. Shape: (n_instances x n_rules)model: A PyTorch model which can take your providedmodel_input_xas input. Examples are in themodel folder.If you know which denoising method you want to use, you can directly call the corresponding module (the list of currently supported methods is providedbelow).Example for training the baseline classifier:fromknodle.model.logistic_regression_modelimportLogisticRegressionModelfromknodle.trainer.baseline.majorityimportMajorityVoteTrainerNUM_OUTPUT_CLASSES=2model=LogisticRegressionModel(model_input_x.shape[1],NUM_OUTPUT_CLASSES)trainer=MajorityVoteTrainer(model=model,mapping_rules_labels_t=mapping_rules_labels_t,model_input_x=model_input_x,rule_matches_z=rule_matches_z,dev_model_input_x=X_dev,dev_gold_labels_y=Y_dev)trainer.train()trainer.test(X_test,Y_test)A more detailed example of classifier training ishere.Main PrinciplesThe framework provides a simple tensor-driven abstraction based on PyTorch allowing researchers to efficiently develop and compare their methods. The emergence of machine learning software frameworks is the biggest enabler for the wide spread adoption of machine learning and its speed of development. With Knodle we want to empower researchers in a similar fashion.Knodle main goals:Data abstraction. The interface is a tensor-driven data abstraction which unifies a large number of input
variants and is applicable to a large number of tasks.Method independence. We distinguish between weak supervision and prediction model. This enables comparability and accounts for a domain-specific inductive biases.Accessibility. There is a high-level access to the library, that makes it easy to test existing methods, incorporate new ones and benchmark them against each other.Apart from that, Knodle includes a selection of well-known data sets from prior work in weak supervision. Knodle ecosystem provides modular access to datasets and denoising methods (that can, in turn, be combined with arbitrary deep learning models), enabling easy experimentation.Datasets currently provided in Knodle:Spam Dataset - a dataset, based on the YouTube comments dataset fromAlberto et al. (2015). Here, the task is to classify whether a text is relevant to the video or holds spam, such as adver- tisement.Spouse Dataset - relation extraction dataset is based on the Signal Media One-Million News Articles Dataset fromCorney et al. (2016).IMDb Dataset - a dataset, that consists of short movie reviews. The task is to determine whether a review holds a positive or negative sentiment.TAC-based Relation Extraction Dataset - a dataset built over Knowledge Base Population challenges in the Text Analysis Conference. For development and test purposes the corpus annotated via crowdsourcing and human labeling from KBP is used (Zhang et al. (2017). The training is done on a weakly-supervised noisy dataset based on TAC KBP corpora (Surdeanu (2013)).All datasets are added to the Knodle framework in the tensor format described above and could be dowloadedhere.
To see how the datasets were created please have a look at thededicated tutorial.Denoising MethodsThere are several denoising methods available.Trainer NameModuleDescriptionMajorityVoteTrainerknodle.trainer.baselineThis builds the baseline for all methods. No denoising takes place. The final label will be decided by using a simple majority vote approach and the provided model will be trained with these labels.AutoTrainerknodle.trainerThis incorporates all denoising methods currently provided in Knodle.KNNAggregationTrainerknodle.trainer.knn_aggregationThis method looks at the similarities in sentence values. The intuition behind it is that similar samples should be activated by the same rules which is allowed by a smoothness assumption on the target space. Similar sentences will receive the same label matches of the rules. This counteracts the problem of missing rules for certain labels.WSCrossWeighTrainerknodle.trainer.wscrossweighThis method weighs the training samples basing on how reliable their labels are. The less reliable sentences (i.e. sentences, whose weak labels are possibly wrong) are detected using a DS-CrossWeigh method, which is similar to k-fold cross-validation, and got reduced weights in further training. This counteracts the problem of wrongly classified sentences.SnorkelTrainerknodle.trainer.snorkelA wrapper of the Snorkel system, which incorporates both generative and discriminative Snorkel steps in a single call.Each of the methods has its own default config file, which will be used in training if no custom config is provided.Details about negative samplesTutorialsWe also aimed at providing the users with basic tutorials that would explain how to use our framework. All of them are stored inexamplesfolder and logically divided into two groups:tutorials that demonstrate how to prepare the input data for Knodle Framework...... on the example of a well-known ImdB dataset. A weakly supervised dataset is created by incorporating keywords as weak sources (link).... on the example of a TAC-based dataset in .conll format. A relation extraction dataset is created using entity pairs from Freebase as weak sources (link).tutorials how to work with Knodle Framework...... on the example of AutoTrainer. This trainer is to be called when user wants to train a weak classifier, but has no intention to use any specific denoising method, but rather try all currently provided in Knodle (link).... on the example of WSCrossWeighTrainer. With this trainer a weak classifier with WSCrossWeigh denoising method will be trained (link).CompatibilityCurrently the package is tested on Python 3.7. It is possible to add further versions. The CI/CD pipeline needs to be updated in that case.StructureThe structure of the code is as followsknodle
├── knodle
│    ├── evaluation
│    ├── model
│    ├── trainer
│          ├── baseline
│          ├── knn_aggregation
│          ├── snorkel
│          ├── wscrossweigh
│          └── utils
│    ├── transformation
│    └── utils
├── tests
│    ├── data
│    ├── evaluation
│    ├── trainer
│          ├── baseline
│          ├── wscrossweigh
│          ├── snorkel
│          └── utils
│    └── transformation
└── examples
     ├── data_preprocessing
           ├── imdb_dataset
           └── tac_based_dataset
     └── training
           ├── simple_auto_trainer
           └── wscrossweighLicenseLicensed under theApache 2.0 License.ContactIf you notices a problem in the code, you can report it bysubmitting an issue.If you want to share your feedback with us or take part in the project, contact us viaknodle@cs.univie.ac.at.And don't forget to follow@knodle_aion Twitter :)AuthorsAnastasiia SedovaAndreas StephanMarina SperanskayaAlessandro VolpicellaBenjamin RothCitation@misc{sedova2021knodle,
      title={Knodle: Modular Weakly Supervised Learning with PyTorch}, 
      author={Anastasiia Sedova, Andreas Stephan, Marina Speranskaya, and Benjamin Roth},
      year={2021},
      eprint={2104.11557},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}AcknowledgmentsThis research was funded by the WWTF though the project “Knowledge-infused Deep Learning for Natural Language Processing” (WWTF Vienna Research Group VRG19-008).