added dump, removed cnn_kwargs

Author: riapush

.gitignore

@@ -179,3 +179,4 @@ tests_logs
 tests/logs
 runs/
 vector_db*
+/wandb

autointent/modules/scoring/_cnn/cnn.py

@@ -7,7 +7,7 @@
 import numpy as np
 import numpy.typing as npt
 import torch
-from torch import nn, Tensor
+from torch import nn
 from torch.utils.data import DataLoader, TensorDataset
 
 from autointent import Context
@@ -16,31 +16,54 @@
 from autointent.modules.base import BaseScorer
 from autointent.modules.scoring._cnn.textcnn import TextCNN
 
-
 class CNNScorer(BaseScorer):
-    """Convolutional Neural Network (CNN) scorer for intent classification."""
+    """Convolutional Neural Network (CNN) scorer for intent classification.
+
+    Args:
+        max_seq_length: Maximum length of input sequences.
+        num_train_epochs: Number of training epochs.
+        batch_size: Batch size for training.
+        learning_rate: Learning rate for optimizer.
+        seed: Random seed.
+        report_to: Where to report training metrics.
+        embed_dim: Dimension of word embeddings.
+        kernel_sizes: Tuple of kernel sizes for convolutional layers.
+        num_filters: Number of filters for each convolutional layer.
+        dropout: Dropout rate.
+        pretrained_embs: Pretrained embeddings tensor (optional).
+    """
 
     name = "cnn"
     supports_multilabel = True
     supports_multiclass = True
 
-    def __init__(
+    def __init__( # noqa: PLR0913
         self,
         max_seq_length: int = 50,
         num_train_epochs: int = 3,
         batch_size: int = 8,
         learning_rate: float = 5e-5,
         seed: int = 0,
-        report_to: REPORTERS_NAMES | None = None,  # type: ignore[no-any-return]
-        **cnn_kwargs: dict[str, Any],
+        report_to: REPORTERS_NAMES | None = None,
+        embed_dim: int = 128,
+        kernel_sizes: tuple[int, ...] = (3, 4, 5),
+        num_filters: int = 100,
+        dropout: float = 0.1,
+        pretrained_embs: torch.Tensor | None = None,
     ) -> None:
         self.max_seq_length = max_seq_length
         self.num_train_epochs = num_train_epochs
         self.batch_size = batch_size
         self.learning_rate = learning_rate
         self.seed = seed
         self.report_to = report_to
-        self.cnn_config = cnn_kwargs
+
+        # CNN-specific parameters
+        self.embed_dim = embed_dim
+        self.kernel_sizes = kernel_sizes
+        self.num_filters = num_filters
+        self.dropout = dropout
+        self.pretrained_embs = pretrained_embs
 
         # Will be initialized during fit()
         self._model: TextCNN | None = None
@@ -53,22 +76,32 @@ def __init__(
         self._multilabel: bool = False
 
     @classmethod
-    def from_context(
+    def from_context( # noqa: PLR0913
         cls,
         context: Context,
+        max_seq_length: int = 50,
         num_train_epochs: int = 3,
         batch_size: int = 8,
         learning_rate: float = 5e-5,
         seed: int = 0,
-        **cnn_kwargs: dict[str, Any],
+        embed_dim: int = 128,
+        kernel_sizes: tuple[int, ...] = (3, 4, 5),
+        num_filters: int = 100,
+        dropout: float = 0.1,
+        pretrained_embs: torch.Tensor | None = None,
     ) -> "CNNScorer":
         return cls(
+            max_seq_length=max_seq_length,
             num_train_epochs=num_train_epochs,
             batch_size=batch_size,
             learning_rate=learning_rate,
             seed=seed,
             report_to=context.logging_config.report_to,
-            **cnn_kwargs,
+            embed_dim=embed_dim,
+            kernel_sizes=kernel_sizes,
+            num_filters=num_filters,
+            dropout=dropout,
+            pretrained_embs=pretrained_embs,
         )
 
     def fit(self, utterances: list[str], labels: ListOfLabels) -> None:
@@ -94,12 +127,12 @@ def fit(self, utterances: list[str], labels: ListOfLabels) -> None:
         self._model = TextCNN(
             vocab_size=len(self._vocab),
             n_classes=self._n_classes,
-            embed_dim=self.cnn_config.get("embed_dim", 128),
-            kernel_sizes=self.cnn_config.get("kernel_sizes", (3, 4, 5)),
-            num_filters=self.cnn_config.get("num_filters", 100),
-            dropout=self.cnn_config.get("dropout", 0.1),
+            embed_dim=self.embed_dim,
+            kernel_sizes=self.kernel_sizes,
+            num_filters=self.num_filters,
+            dropout=self.dropout,
             padding_idx=self._padding_idx,
-            pretrained_embs=self.cnn_config.get("pretrained_embs", None),
+            pretrained_embs=self.pretrained_embs,
         )
 
         # Training

autointent/modules/scoring/_cnn/textcnn.py

@@ -1,8 +1,8 @@
 """TextCNN model for text classification."""
 
-import torch
-import torch.nn.functional as F
 from torch import nn
+import torch
+import torch.nn.functional as F # noqa: N812
 
 
 class TextCNN(nn.Module):

test_main.py

@@ -0,0 +1,45 @@
+from autointent.modules.scoring._cnn.cnn import CNNScorer
+
+# Sample data
+utterances = [
+    "I love programming",
+    "I hate bugs",
+    "Python is awesome",
+    "Debugging is frustrating",
+    "Machine learning is fun",
+    "I dislike errors",
+]
+print(utterances)
+labels = [1, 0, 1, 0, 1, 0]  # 1 = positive, 0 = negative
+
+# Initialize the scorer
+scorer = CNNScorer()
+# Train the model
+print('before fit')
+scorer.fit(utterances, labels)
+
+# Test set
+test_utterances = [
+    "I enjoy coding",
+    "I find bugs annoying",
+    "AI is fascinating",
+    "Errors are frustrating",
+]
+
+# Predict probabilities
+probabilities = scorer.predict(test_utterances)
+print("Predicted Probabilities:")
+print(probabilities)
+
+# Convert probabilities to predicted labels
+predicted_labels = (probabilities > 0.5).astype(int)  # For binary classification
+print("Predicted Labels:")
+print(predicted_labels)
+
+# Expected labels for the test set
+expected_labels = [1, 0, 1, 0]
+
+# Compare predicted and expected labels
+for i, (pred, exp) in enumerate(zip(predicted_labels, expected_labels)):
+    print(f"Test Utterance {i+1}: {test_utterances[i]}")
+    print(f"Predicted: {pred}, Expected: {exp}")

tests/modules/scoring/test_cnn.py

@@ -0,0 +1,101 @@
+# import numpy as np
+# import pytest
+
+# from autointent.context.data_handler import DataHandler
+# from autointent.modules.scoring._cnn import CNNScorer
+
+
+# def test_cnn_prediction(dataset):
+#     """Test that the CNN model can fit and make predictions."""
+#     data_handler = DataHandler(dataset)
+
+#     scorer = CNNScorer(
+#         max_seq_length=50,
+#         num_train_epochs=1,
+#         batch_size=8,
+#         learning_rate=5e-5,
+#         embed_dim=128,
+#         kernel_sizes=(3, 4, 5),
+#         num_filters=100,
+#         dropout=0.1
+#     )
+#     scorer.fit(data_handler.train_utterances(0), data_handler.train_labels(0))
+
+#     test_data = [
+#         "why is there a hold on my account",
+#         "i am not sure why my account is blocked",
+#         "why is there a hold on my checking account",
+#         "i think my account is blocked",
+#         "can you tell me why is my account frozen",
+#     ]
+
+#     predictions = scorer.predict(test_data)
+
+#     assert predictions.shape[0] == len(test_data)
+#     assert predictions.shape[1] == len(set(data_handler.train_labels(0)))
+
+#     # Проверяем что предсказания в диапазоне [0, 1]
+#     assert 0.0 <= np.min(predictions) <= np.max(predictions) <= 1.0
+
+#     # Для мультиклассовой классификации сумма предсказаний должна быть ~1.0
+#     if not scorer._multilabel:
+#         for pred_row in predictions:
+#             np.testing.assert_almost_equal(np.sum(pred_row), 1.0, decimal=5)
+
+#     # Проверяем работу predict_with_metadata если метод существует
+#     if hasattr(scorer, "predict_with_metadata"):
+#         predictions, metadata = scorer.predict_with_metadata(test_data)
+#         assert len(predictions) == len(test_data)
+#         assert metadata is None
+
+
+# def test_cnn_cache_clearing(dataset):
+#     """Test that the CNN model properly handles cache clearing."""
+#     data_handler = DataHandler(dataset)
+
+#     scorer = CNNScorer(
+#         max_seq_length=50,
+#         num_train_epochs=1,
+#         batch_size=8,
+#         learning_rate=5e-5
+#     )
+#     scorer.fit(data_handler.train_utterances(0), data_handler.train_labels(0))
+
+#     test_data = ["test text"]
+
+#     # Первое предсказание
+#     scorer.predict(test_data)
+    
+#     # Очистка кэша
+#     scorer.clear_cache()
+
+#     # Проверяем что модель очищена
+#     assert not hasattr(scorer, "_model") or scorer._model is None
+#     assert not hasattr(scorer, "_vocab") or scorer._vocab is None
+
+#     # После очистки кэша предсказания должны вызывать ошибку
+#     with pytest.raises(ValueError, match="Model not trained. Call fit() first."):
+#         scorer.predict(test_data)
+
+
+# def test_cnn_multilabel(dataset_multilabel):
+#     """Test CNN scorer with multilabel data."""
+#     data_handler = DataHandler(dataset_multilabel)
+
+#     scorer = CNNScorer(
+#         max_seq_length=50,
+#         num_train_epochs=1,
+#         batch_size=8,
+#         learning_rate=5e-5
+#     )
+#     scorer.fit(data_handler.train_utterances(0), data_handler.train_labels(0))
+
+#     test_data = ["sample text for testing", "another test example"]
+#     predictions = scorer.predict(test_data)
+
+#     # Для multilabel проверяем что выходные вероятности независимы
+#     assert predictions.shape[0] == len(test_data)
+#     assert predictions.shape[1] == len(data_handler.train_labels(0)[0])
+    
+#     # Проверяем что есть предсказания не только 0 и 1
+#     assert np.any((predictions > 0) & (predictions < 1))