Skip to content

1D-CNN

A 3-layer 1D convolutional neural network for detecting local pitch sequence patterns.

Overview

  • Type: Sequence
  • Library: PyTorch
  • Registry name: cnn1d
  • Class: CNN1DModel
  • Network: PitchCNN1D

Architecture

Input (batch, window_size, n_features)
    → Transpose to (batch, n_features, window_size)
    → Conv1d(n_features, 64, kernel=3) + ReLU + BatchNorm
    → Conv1d(64, 128, kernel=3) + ReLU + BatchNorm
    → Conv1d(128, 64, kernel=3) + ReLU + BatchNorm
    → Adaptive Max Pooling → Dropout
    → Fully connected → num_classes

Configuration

# configs/models/cnn1d.yaml
model_type: cnn1d
filters: [64, 128, 64]
kernel_size: 3
dropout: 0.3
epochs: 20
learning_rate: 0.001
batch_size: 256
Parameter Default Description
filters [64, 128, 64] Number of filters per conv layer
kernel_size 3 Convolution kernel size
dropout 0.3 Dropout rate
epochs 20 Maximum training epochs
learning_rate 0.001 Adam optimizer learning rate
batch_size 256 Training batch size
patience 5 Early stopping patience

Usage

from pitch_sequencing import get_model

model = get_model("cnn1d", {
    "filters": [64, 128, 64],
    "kernel_size": 3,
    "epochs": 20
})

model.fit(X_train, y_train, X_val=X_val, y_val=y_val)

predictions = model.predict(X_test)
probabilities = model.predict_proba(X_test)

API Reference

pitch_sequencing.models.cnn1d.CNN1DModel

Bases: BaseModel

1D-CNN wrapper implementing BaseModel interface.

Source code in src/pitch_sequencing/models/cnn1d.py 
 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
class CNN1DModel(BaseModel):
    """1D-CNN wrapper implementing BaseModel interface."""

    def __init__(self, config=None):
        config = config or {}
        self.filters = config.get("filters", [64, 128, 64])
        self.kernel_size = config.get("kernel_size", 3)
        self.dropout = config.get("dropout", 0.3)
        self.epochs = config.get("epochs", 30)
        self.lr = config.get("learning_rate", 0.001)
        self.batch_size = config.get("batch_size", 256)
        self._model = None
        self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self._history = None

    @property
    def name(self) -> str:
        return "1D-CNN"

    @property
    def model_type(self) -> str:
        return "sequence"

    def fit(self, X_train, y_train, X_val=None, y_val=None, **kwargs):
        input_features = X_train.shape[2]
        num_classes = len(np.unique(y_train))

        self._model = PitchCNN1D(
            input_features=input_features,
            num_classes=num_classes,
            filters=self.filters,
            kernel_size=self.kernel_size,
            dropout=self.dropout,
        )

        train_ds = PitchSequenceDataset(X_train, y_train)
        train_loader = DataLoader(train_ds, batch_size=self.batch_size, shuffle=True)

        if X_val is not None and y_val is not None:
            val_ds = PitchSequenceDataset(X_val, y_val)
        else:
            split = int(len(X_train) * 0.8)
            val_ds = PitchSequenceDataset(X_train[split:], y_train[split:])
        val_loader = DataLoader(val_ds, batch_size=self.batch_size, shuffle=False)

        self._history = train_torch_model(
            self._model, train_loader, val_loader,
            epochs=self.epochs, lr=self.lr, device=self._device,
        )

    def predict(self, X) -> np.ndarray:
        ds = PitchSequenceDataset(X, np.zeros(len(X), dtype=np.int64))
        loader = DataLoader(ds, batch_size=self.batch_size, shuffle=False)
        preds, _ = predict_torch_model(self._model, loader, self._device)
        return preds

    def predict_proba(self, X) -> np.ndarray:
        ds = PitchSequenceDataset(X, np.zeros(len(X), dtype=np.int64))
        loader = DataLoader(ds, batch_size=self.batch_size, shuffle=False)
        _, probs = predict_torch_model(self._model, loader, self._device)
        return probs

    def get_params(self) -> dict:
        return {
            "filters": self.filters,
            "kernel_size": self.kernel_size,
            "dropout": self.dropout,
            "epochs": self.epochs,
            "learning_rate": self.lr,
        }