Skip to content

Text Classification

nyckel.TextClassificationFunction

Example:

from nyckel import Credentials, TextClassificationFunction

credentials = Credentials(client_id="...", client_secret="...")

func = TextClassificationFunction.create("IsToxic", credentials)
func.create_samples([
    ("This is a nice comment", "Not toxic"),
    ("Hello friend", "Not toxic"),
    ("I hate people like you", "Toxic"),
    ("Who is this? Go away!", "Toxic"),
])

predictions = func.invoke(["This example is fantastic!"])
Source code in src/nyckel/functions/classification/text_classification.py 
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
class TextClassificationFunction(ClassificationFunction):
    """
    Example:

    ```py

    from nyckel import Credentials, TextClassificationFunction

    credentials = Credentials(client_id="...", client_secret="...")

    func = TextClassificationFunction.create("IsToxic", credentials)
    func.create_samples([
        ("This is a nice comment", "Not toxic"),
        ("Hello friend", "Not toxic"),
        ("I hate people like you", "Toxic"),
        ("Who is this? Go away!", "Toxic"),
    ])

    predictions = func.invoke(["This example is fantastic!"])
    ```
    """

    def __init__(self, function_id: NyckelId, credentials: Credentials):
        self._function_id = function_id

        self._function_handler = ClassificationFunctionHandler(function_id, credentials)
        self._label_handler = ClassificationLabelHandler(function_id, credentials)
        self._url_handler = ClassificationFunctionURLHandler(function_id, credentials.server_url)
        self._sample_handler = ClassificationSampleHandler(function_id, credentials)

        assert self._function_handler.get_input_modality() == "Text"

    def __str__(self) -> str:
        return self.__repr__()

    def __repr__(self) -> str:
        status_string = f"Name: {self.name}, id: {self.function_id}, url: {self._url_handler.train_page}"
        return status_string

    @property
    def function_id(self) -> str:
        return self._function_id

    @property
    def sample_count(self) -> int:
        return self._function_handler.sample_count

    @property
    def label_count(self) -> int:
        return self._function_handler.label_count

    @property
    def name(self) -> str:
        return self._function_handler.get_name()

    @classmethod
    def create(cls, name: str, credentials: Credentials) -> "TextClassificationFunction":
        return factory.ClassificationFunctionFactory.create(name, "Text", credentials)  # type:ignore

    def delete(self) -> None:
        self._function_handler.delete()

    def invoke(
        self,
        sample_data_list: List[TextSampleData],
        model_id: str = "",
    ) -> List[ClassificationPrediction]:
        return self._sample_handler.invoke(sample_data_list, lambda x: x, model_id=model_id)

    def has_trained_model(self) -> bool:
        return self._function_handler.is_trained

    def create_labels(self, labels: Sequence[Union[ClassificationLabel, str]]) -> List[NyckelId]:
        typed_labels = [
            label if isinstance(label, ClassificationLabel) else ClassificationLabel(name=label) for label in labels
        ]
        return self._label_handler.create_labels(typed_labels)

    def list_labels(self) -> List[ClassificationLabel]:
        return self._label_handler.list_labels(self.label_count)

    def read_label(self, label_id: NyckelId) -> ClassificationLabel:
        return self._label_handler.read_label(label_id)

    def update_label(self, label: ClassificationLabel) -> ClassificationLabel:
        return self._label_handler.update_label(label)

    def delete_labels(self, label_ids: List[NyckelId]) -> None:
        return self._label_handler.delete_labels(label_ids)

    def create_samples(
        self, samples: Sequence[Union[TextClassificationSample, Tuple[TextSampleData, LabelName], TextSampleData]]  # type: ignore  # noqa: E501
    ) -> List[NyckelId]:
        typed_samples = self._wrangle_post_samples_input(samples)
        typed_samples = self._strip_label_names(typed_samples)
        self._create_labels_as_needed(typed_samples)

        return self._sample_handler.create_samples(typed_samples, lambda x: x)

    def list_samples(self) -> List[TextClassificationSample]:  # type: ignore
        samples_dict_list = self._sample_handler.list_samples(self.sample_count)
        labels = self._label_handler.list_labels(None)

        label_name_by_id = {label.id: label.name for label in labels}

        return [self._sample_from_dict(entry, label_name_by_id) for entry in samples_dict_list]  # type: ignore

    def read_sample(self, sample_id: NyckelId) -> TextClassificationSample:
        sample_dict = self._sample_handler.read_sample(sample_id)

        labels = self._label_handler.list_labels(None)
        label_name_by_id = {strip_nyckel_prefix(label.id): label.name for label in labels}  # type: ignore

        return self._sample_from_dict(sample_dict, label_name_by_id)  # type: ignore

    def update_annotation(self, sample: TextClassificationSample) -> None:  # type: ignore
        self._sample_handler.update_annotation(sample)

    def delete_samples(self, sample_ids: List[NyckelId]) -> None:
        self._sample_handler.delete_samples(sample_ids)

    def _sample_from_dict(self, sample_dict: Dict, label_name_by_id: Dict[NyckelId, str]) -> TextClassificationSample:
        if "annotation" in sample_dict:
            annotation = ClassificationAnnotation(
                label_name=label_name_by_id[strip_nyckel_prefix(sample_dict["annotation"]["labelId"])],
            )
        else:
            annotation = None
        if "prediction" in sample_dict:
            prediction = ClassificationPrediction(
                confidence=sample_dict["prediction"]["confidence"],
                label_name=label_name_by_id[strip_nyckel_prefix(sample_dict["prediction"]["labelId"])],
            )
        else:
            prediction = None
        return TextClassificationSample(
            id=strip_nyckel_prefix(sample_dict["id"]),
            data=sample_dict["data"],
            external_id=sample_dict["externalId"] if "externalId" in sample_dict else None,
            annotation=annotation,
            prediction=prediction,
        )

    def _wrangle_post_samples_input(
        self, samples: Sequence[Union[TextClassificationSample, Tuple[TextSampleData, LabelName], TextSampleData]]
    ) -> List[TextClassificationSample]:
        typed_samples: List[TextClassificationSample] = []
        for sample in samples:
            if isinstance(sample, str):
                typed_samples.append(TextClassificationSample(data=sample))
            elif isinstance(sample, (list, tuple)):
                typed_samples.append(
                    TextClassificationSample(data=sample[0], annotation=ClassificationAnnotation(label_name=sample[1]))
                )
            elif isinstance(sample, TextClassificationSample):
                typed_samples.append(sample)
            else:
                raise ValueError(f"Unknown sample type: {type(sample)}")
        return typed_samples

    def _create_labels_as_needed(self, samples: List[TextClassificationSample]) -> None:
        existing_labels = self._label_handler.list_labels(None)
        existing_label_names = {label.name for label in existing_labels}
        new_label_names = {sample.annotation.label_name for sample in samples if sample.annotation}
        missing_label_names = new_label_names - existing_label_names
        missing_labels = [ClassificationLabel(name=label_name) for label_name in missing_label_names]
        if len(missing_labels) > 0:
            self._label_handler.create_labels(missing_labels)

    def _strip_label_names(self, samples: List[TextClassificationSample]) -> List[TextClassificationSample]:
        for sample in samples:
            if sample.annotation:
                sample.annotation.label_name = sample.annotation.label_name.strip()
        return samples

function_id property 

function_id: str

sample_count property 

sample_count: int

label_count property 

label_count: int

name property 

name: str

__init__ 

__init__(function_id: NyckelId, credentials: Credentials)
Source code in src/nyckel/functions/classification/text_classification.py 
44
45
46
47
48
49
50
51
52
def __init__(self, function_id: NyckelId, credentials: Credentials):
    self._function_id = function_id

    self._function_handler = ClassificationFunctionHandler(function_id, credentials)
    self._label_handler = ClassificationLabelHandler(function_id, credentials)
    self._url_handler = ClassificationFunctionURLHandler(function_id, credentials.server_url)
    self._sample_handler = ClassificationSampleHandler(function_id, credentials)

    assert self._function_handler.get_input_modality() == "Text"

create classmethod 

create(name: str, credentials: Credentials) -> TextClassificationFunction
Source code in src/nyckel/functions/classification/text_classification.py 
77
78
79
@classmethod
def create(cls, name: str, credentials: Credentials) -> "TextClassificationFunction":
    return factory.ClassificationFunctionFactory.create(name, "Text", credentials)  # type:ignore

delete 

delete() -> None
Source code in src/nyckel/functions/classification/text_classification.py 
81
82
def delete(self) -> None:
    self._function_handler.delete()

invoke 

invoke(sample_data_list: List[TextSampleData], model_id: str = '') -> List[ClassificationPrediction]
Source code in src/nyckel/functions/classification/text_classification.py 
84
85
86
87
88
89
def invoke(
    self,
    sample_data_list: List[TextSampleData],
    model_id: str = "",
) -> List[ClassificationPrediction]:
    return self._sample_handler.invoke(sample_data_list, lambda x: x, model_id=model_id)

has_trained_model 

has_trained_model() -> bool
Source code in src/nyckel/functions/classification/text_classification.py 
91
92
def has_trained_model(self) -> bool:
    return self._function_handler.is_trained

create_labels 

create_labels(labels: Sequence[Union[ClassificationLabel, str]]) -> List[NyckelId]
Source code in src/nyckel/functions/classification/text_classification.py 
94
95
96
97
98
def create_labels(self, labels: Sequence[Union[ClassificationLabel, str]]) -> List[NyckelId]:
    typed_labels = [
        label if isinstance(label, ClassificationLabel) else ClassificationLabel(name=label) for label in labels
    ]
    return self._label_handler.create_labels(typed_labels)

list_labels 

list_labels() -> List[ClassificationLabel]
Source code in src/nyckel/functions/classification/text_classification.py 
100
101
def list_labels(self) -> List[ClassificationLabel]:
    return self._label_handler.list_labels(self.label_count)

read_label 

read_label(label_id: NyckelId) -> ClassificationLabel
Source code in src/nyckel/functions/classification/text_classification.py 
103
104
def read_label(self, label_id: NyckelId) -> ClassificationLabel:
    return self._label_handler.read_label(label_id)

update_label 

update_label(label: ClassificationLabel) -> ClassificationLabel
Source code in src/nyckel/functions/classification/text_classification.py 
106
107
def update_label(self, label: ClassificationLabel) -> ClassificationLabel:
    return self._label_handler.update_label(label)

delete_labels 

delete_labels(label_ids: List[NyckelId]) -> None
Source code in src/nyckel/functions/classification/text_classification.py 
109
110
def delete_labels(self, label_ids: List[NyckelId]) -> None:
    return self._label_handler.delete_labels(label_ids)

create_samples 

create_samples(samples: Sequence[Union[TextClassificationSample, Tuple[TextSampleData, LabelName], TextSampleData]]) -> List[NyckelId]
Source code in src/nyckel/functions/classification/text_classification.py 
112
113
114
115
116
117
118
119
def create_samples(
    self, samples: Sequence[Union[TextClassificationSample, Tuple[TextSampleData, LabelName], TextSampleData]]  # type: ignore  # noqa: E501
) -> List[NyckelId]:
    typed_samples = self._wrangle_post_samples_input(samples)
    typed_samples = self._strip_label_names(typed_samples)
    self._create_labels_as_needed(typed_samples)

    return self._sample_handler.create_samples(typed_samples, lambda x: x)

list_samples 

list_samples() -> List[TextClassificationSample]
Source code in src/nyckel/functions/classification/text_classification.py 
121
122
123
124
125
126
127
def list_samples(self) -> List[TextClassificationSample]:  # type: ignore
    samples_dict_list = self._sample_handler.list_samples(self.sample_count)
    labels = self._label_handler.list_labels(None)

    label_name_by_id = {label.id: label.name for label in labels}

    return [self._sample_from_dict(entry, label_name_by_id) for entry in samples_dict_list]  # type: ignore

read_sample 

read_sample(sample_id: NyckelId) -> TextClassificationSample
Source code in src/nyckel/functions/classification/text_classification.py 
129
130
131
132
133
134
135
def read_sample(self, sample_id: NyckelId) -> TextClassificationSample:
    sample_dict = self._sample_handler.read_sample(sample_id)

    labels = self._label_handler.list_labels(None)
    label_name_by_id = {strip_nyckel_prefix(label.id): label.name for label in labels}  # type: ignore

    return self._sample_from_dict(sample_dict, label_name_by_id)  # type: ignore

update_annotation 

update_annotation(sample: TextClassificationSample) -> None
Source code in src/nyckel/functions/classification/text_classification.py 
137
138
def update_annotation(self, sample: TextClassificationSample) -> None:  # type: ignore
    self._sample_handler.update_annotation(sample)

delete_samples 

delete_samples(sample_ids: List[NyckelId]) -> None
Source code in src/nyckel/functions/classification/text_classification.py 
140
141
def delete_samples(self, sample_ids: List[NyckelId]) -> None:
    self._sample_handler.delete_samples(sample_ids)

nyckel.TextClassificationSample dataclass

Source code in src/nyckel/functions/classification/classification.py 
60
61
62
63
64
65
66
@dataclass
class TextClassificationSample:
    data: TextSampleData
    id: Optional[NyckelId] = None
    external_id: Optional[str] = None
    annotation: Optional[ClassificationAnnotation] = None
    prediction: Optional[ClassificationPrediction] = None

data instance-attribute 

data: TextSampleData

id class-attribute instance-attribute 

id: Optional[NyckelId] = None

external_id class-attribute instance-attribute 

external_id: Optional[str] = None

annotation class-attribute instance-attribute 

annotation: Optional[ClassificationAnnotation] = None

prediction class-attribute instance-attribute 

prediction: Optional[ClassificationPrediction] = None

__init__ 

__init__(data: TextSampleData, id: Optional[NyckelId] = None, external_id: Optional[str] = None, annotation: Optional[ClassificationAnnotation] = None, prediction: Optional[ClassificationPrediction] = None) -> None

nyckel.TextSampleData module-attribute 

TextSampleData = str