Create README.md

README.md

@@ -0,0 +1,90 @@
+---
+license: apache-2.0
+---
+# Model Card for XLM-Roberta-large-reflective-conf4
+
+This is a reflectivity classification model trained to distinguish different types of reflectivity in the reports of teaching students.
+
+It was evaluated in a cross-lingual settings and was found to work well also in languages outside English -- see the results in the referenced paper.
+
+## Model Details
+
+- **Repository:** https://github.com/EduMUNI/reflection-classification
+- **Paper:** https://link.springer.com/article/10.1007/s10639-022-11254-7
+
+- **Developed by:** Jan Nehyba & Michal Stefanik, Masaryk University
+- **Model type:** Roberta-large
+- **Finetuned from model:** [XLM-R-large](https://huggingface.co/xlm-roberta-large)
+
+## Usage
+
+To match the training format, it is best to use the prepared wrapper that will format the classified sentence and its surrounding context in the expected format:
+
+```python
+from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer
+
+LABELS = ["Other", "Belief", "Perspective", "Feeling", "Experience",
+          "Reflection", "Difficulty", "Intention", "Learning"]
+
+class NeuralClassifier:
+
+    def __init__(self, model_path: str, uses_context: bool, device: str):
+        self.config = AutoConfig.from_pretrained(model_path)
+        self.device = device
+        self.model = AutoModelForSequenceClassification.from_pretrained(model_path, config=self.config).to(device)
+        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+        self.uses_context = uses_context
+
+    def predict_sentence(self, sentence: str, context: str = None):
+        if context is None and self.uses_context:
+            raise ValueError("You need to pass in context argument, including the sentence")
+
+        features = self.tokenizer(sentence, text_pair=context,
+                                  padding="max_length", truncation=True, return_tensors='pt')
+        outputs = self.model(**features.to(self.device), return_dict=True)
+        argmax = outputs.logits.argmax(dim=-1).detach().cpu().tolist()[0]
+        labels = LABELS[argmax]
+
+        return labels
+```
+
+The wrapper can be used as follows:
+```python
+classifier = NeuralClassifier(model_path="MU-NLPC/XLM-R-large-reflective-conf4", 
+                              uses_context=False,
+                              device="cpu")
+
+test_sentences = ["And one day I will be a real teacher and I will try to do the best I can for the children.",
+                  "I felt really well!",
+                  "gfagdhj gjfdjgh dg"]
+
+y_pred = [classifier.predict_sentence(sentence) for sentence in tqdm(test_sentences)]
+
+print(y_pred)
+
+>>> ['Intention', 'Feeling', 'Other']
+```
+
+### Training Data
+
+The model was trained on a [CEReD dataset](http://hdl.handle.net/11372/LRT-3573) and aims for the best possible evaluation in cross-lingual settings (on unseen languages).
+
+See the reproducible training script in the project directory: https://github.com/EduMUNI/reflection-classification
+
+## Citation
+
+If you use the model in scientific work, please acknowledge our work as follows.
+
+```bibtex
+@Article{Nehyba2022applications,
+  author={Nehyba, Jan and {\v{S}}tef{\'a}nik, Michal},
+  title={Applications of deep language models for reflective writings},
+  journal={Education and Information Technologies},
+  year={2022},
+  month={Sep},
+  day={05},
+  issn={1573-7608},
+  doi={10.1007/s10639-022-11254-7},
+  url={https://doi.org/10.1007/s10639-022-11254-7}
+}
+```