The Language of the Cat

Cats hide their mood in their face — but they give it away in sound. You rebuild the two-stage chain from the book: first the kind of sound, then — trained on real data — the feeling in the meow.

What it's about

Dog and horse wear their mood outwardly — in posture and face. The cat keeps it hidden. Instead it talks to us: adult cats use the meow almost only towards humans, hardly among themselves. So if we want to read a cat, we do not listen to the face but to the sound.

And the sound becomes readable like everything in this book: we turn it into an image. A spectrogram shows the frequencies of a sound over time — and then the same image recognition that otherwise tells cat from dog takes over. A hiss, a purr, a meow become numbers, and from the numbers a careful guess.

A little background

Two ears that listen one after another. The book holds two models in sequence. The first, "Beti", first sorts a sound roughly by its kind and is right in about 85 out of 100 cases. That already gives something away: a hiss sounds like stress, a purr like contentment. With the meow, though, the feeling stays open — and here the second model, "Kisha", takes over. Specialised on meows alone, it tells happy, angry and sad apart with nearly 92 per cent. From this chain came the little app CatMotion.

Why real data for the second stage? "Is it a meow at all?" is easy by sound — a few examples suffice. "How does this meow feel?" is far finer: the differences are subtle, and a model recognises them only once it has seen many meows from many cats. That is why Kisha learns from hundreds of examples instead of your handful — otherwise it would only imagine certainty.

Getting the data

1. Install the packages. pip install librosa scikit-learn numpy soundfile.
2. Download CatMeows. From Kaggle: kaggle.com/datasets/andrewmvd/cat-meow-classification (download and unzip). The meows are WAV files in the dataset/ folder. Alternatively the same data on Zenodo (record 4008297).
3. Understand the labels. Each filename begins with the situation letter: B (Brushing), I (Isolation), F (Food). The exact naming rule is on the dataset page — take a look before you go on.
4. Optional: your own test sounds. Record a few meows of your own cat (test_meow.wav) to check the finished model on fresh material.

Stage 1 — the kind of sound ("Beti")

The rough sorting is easy by sound — a few of your own recordings per kind are enough. From each sound we pull a handy row of numbers: the MFCCs, a compact fingerprint of the sound that librosa gives directly. The full code is on GitHub.

import librosa
import numpy as np
from sklearn.neighbors import KNeighborsClassifier

def features(file):
    y, sr = librosa.load(file)                   # load the sound
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
    # mean and spread over time -> a fingerprint of the sound
    return np.concatenate([mfcc.mean(axis=1), mfcc.std(axis=1)])

# a few of your own recordings per kind (kind is easy to tell apart by sound)
training = [
    ("hiss1.wav", "Hiss"),   ("hiss2.wav", "Hiss"),
    ("purr1.wav", "Purr"),   ("purr2.wav", "Purr"),
    ("chirp1.wav", "Chirp"), ("chirp2.wav", "Chirp"),
    ("meow1.wav", "Meow"),   ("meow2.wav", "Meow"),
]
X = np.array([features(f) for f, _ in training])
y = [kind for _, kind in training]

beti = KNeighborsClassifier(n_neighbors=1).fit(X, y)   # few data: nearest neighbour
print("Beti says:", beti.predict([features("test_meow.wav")])[0])

Stage 2 — the mood in the meow ("Kisha")

Now the hard part. Kisha learns not from your few recordings but from the hundreds of meows in CatMeows. We read the folder, take the situation from each filename and train — and, importantly, we check honestly on held-back data how good it really is.

import glob, os
from sklearn.model_selection import train_test_split

FOLDER = "cat-meow-classification/dataset"     # unzipped Kaggle dataset
situation = {"B": "content", "I": "unsettled", "F": "demanding"}

X, y = [], []
for file in glob.glob(os.path.join(FOLDER, "*.wav")):
    tag = os.path.basename(file)[0].upper()    # first letter = situation
    if tag in situation:
        X.append(features(file))
        y.append(situation[tag])
X = np.array(X)
print("read:", len(X), "meows")

# check honestly: hold back a quarter
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25,
                                      random_state=0, stratify=y)
kisha = KNeighborsClassifier(n_neighbors=5).fit(Xtr, ytr)
print("hits on unseen meows:", round(kisha.score(Xte, yte), 2))

# the full chain: first kind (Beti), then — only for a meow — mood (Kisha)
def interpret(file):
    kind = beti.predict([features(file)])[0]
    if kind == "Meow":
        return f"Meow — sounds {kisha.predict([features(file)])[0]}"
    return kind

print(interpret("test_meow.wav"))

Worksheet

When it sticks

Food for thought

• Always it becomes an image: face, voice, plant signal — and now the cat sound. Once a signal is a spectrogram, the same machinery reads it. One Babel fish, many species.
• The two-stage chain is a fine pattern: split a hard task into an easy and a fine one — and for the fine one fetch real data instead of fooling yourself with a few examples.
• Keep the boundary: the read sound is an expression in a situation, not proof of a feeling. Used well — to notice stress or pain early — such a reader is care; interpreted carelessly it becomes projection.

Extension

• Make spectrograms visible. Draw with librosa.display.specshow(librosa.amplitude_to_db(np.abs(librosa.stft(y)))) the image of single meows from the three situations. Do you see a difference yourself?
• Confusion matrix. Have sklearn.metrics.confusion_matrix(yte, kisha.predict(Xte)) show which situations are confused most often. Does it match your listening impression?
• A real network. Instead of KNN on MFCCs: turn each sound into a spectrogram image and train a small image network on it — the step from the number fingerprint to real image recognition from Chapter 3.