HMDB51

HMDB51, the Human Motion DataBase, is a set of short video clips of 51 human actions, collected by Kuehne, Jhuang, Garrote, Poggio and Serre (Karlsruhe Institute of Technology, MIT and Brown University) and presented at ICCV 2011. Most clips are cut from movies, the rest from public archives and web video (earlier official page). Each carries an action label and meta-labels describing how the action was filmed, and the dataset comes with three train/test splits that keep the clips of one source video on one side. With UCF101, it was the standard action recognition benchmark from the hand-crafted features of the early 2010s to Kinetics-pretrained networks. The paper received the PAMI Technical Committee’s Helmholtz Prize in 2021, which the committee describes as recognizing ICCV papers from ten years earlier with significant impact on computer vision research.

Purpose

The paper argues that the benchmarks of the time, KTH, Weizmann and IXMAS with 6 to 11 actions each, showed single staged actors with little clutter or occlusion, and that results on them were near ceiling: by a survey the authors cite, 12 of 21 systems scored above 90% on KTH. Web-video datasets such as UCF50 and UCF Sports were more realistic, but the authors found their sports actions separable from shape alone: with 14 joint positions annotated by crowd workers and classified from single frames, 5 clips per class of UCF Sports were classified above 98% (chance 11%). On 10 HMDB51 classes chosen to resemble UCF50’s, the same kind of single-frame joint features reached 35% (chance 10%), against 54% for motion features over the whole clip. The authors read this as evidence that HMDB51’s classes differ mainly in motion rather than static pose, and proposed the dataset both as a benchmark and as a tool for studying shape versus motion cues. A chapter titled “HMDB51: A Large Video Database for Human Motion Recognition”, whose abstract repeats the ICCV abstract except for its last sentence, appeared in High Performance Computing in Science and Engineering ’12 (Kuehne, Jhuang, Stiefelhagen & Serre, 2013); we read only its abstract, and this article follows the ICCV paper.

Dataset Size

The paper and the official pages give different clip counts:

Source	Clips
ICCV 2011 paper, contributions paragraph	6,766, at least 101 per class
ICCV 2011 paper, abstract and conclusion	“around 7,000”, “just under 7,000”
Official page (archived copies 2014–2024; current page, October 2026)	6,849
Download link text on the earlier page	“a total of 7,000 clips”, about 2 GB
Clips used in each split (split README)	5,100 (51 classes × 100)

Later papers repeat one figure or the other: Wang and Schmid (2013) and RESOUND (2018) use 6,766, Simonyan and Zisserman (2014) “6.8K”; Jhuang et al. (2013) write “more than 5,100”. We found no source that explains the difference of 83 clips between the paper and the page; counting the archive would settle it, but the files were not downloaded for this article.

The clips were normalized to a height of 240 pixels, keeping the aspect ratio, converted to 30 frames per second and compressed with the DivX 5.0 codec through ffmpeg (paper, §2.4). Annotators were asked for at least 1 second of clip and at least 60 pixels of height for the main actor (§2.1).

Classes

Students watched digitized movies, public databases such as the Prelinger archive, other internet video, and YouTube and Google videos, and marked segments showing a single unambiguous action. The first pass produced more than 60 categories; keeping those with at least 101 clips left 51 (§2.1). Each clip was validated by at least two human observers. The paper groups the classes into five types:

Group	Classes
General facial actions	smile, laugh, chew, talk
Facial actions with object manipulation	smoke, eat, drink
General body movements	cartwheel, clap hands, climb, climb stairs, dive, fall on the floor, backhand flip, handstand, jump, pull up, push up, run, sit down, sit up, somersault, stand up, turn, walk, wave
Body movements with object interaction	brush hair, catch, draw sword, dribble, golf, hit something, kick ball, pick, pour, push something, ride bike, ride horse, shoot ball, shoot bow, shoot gun, swing baseball bat, sword exercise, throw
Body movements for human interaction	fencing, hug, kick someone, kiss, punch, shake hands, sword fight

The distributed class names are shorter: flic_flac for backhand flip, fall_floor, sword for sword fight, kick for kick someone (as listed in the authors’ C2 code).

Annotation Types

• One action label per clip. Clips are trimmed to one action.
• Meta-labels describing how the action was filmed (below).
• Stabilization masks and transformations, in the stabilized version (below).
• Human bounding boxes: the earlier page linked “bounding boxes” on INRIA’s page for improved trajectories (Wang & Schmid, 2013, who used a human detector to exclude feature matches on people when estimating camera motion). They are not part of the authors’ release.

Meta-labels

Each clip carries five meta-labels (§2.2). The proportions over the whole dataset are from the paper’s Figure 2:

Meta-label	Values	Share of clips
Visible body parts	full, upper, lower, head	56.3%, 30.5%, 0.8%, 12.3%
Camera motion	moving, static	59.9%, 40.1%
Camera viewpoint relative to the actor	front, back, left, right	40.8%, 18.2%, 22.1%, 19.0%
Number of people	one, two, multiple	not given
Video quality	low, medium, high (“good” in the figure)	20.8%, 62.1%, 17.1%

Quality is graded by what can be seen: high when fingers and eyes are identifiable through most of the clip, medium when the larger limbs are, low when even those are lost to motion blur or compression. The text puts camera motion at about 2/3 of the clips; the figure gives 59.9%. The earlier official page lists short abbreviations for every value (for example cm and nm for camera motion, np1 to np3 for the number of people) and calls the lowest quality grade “ok (bad)”. The current page (October 2026) lists different meta-labels: viewpoint (side, front, back, top, bottom), video quality, illumination and focal length. The last two appear in neither the paper nor the earlier page, and we found no description of how they were annotated.

The stabilized version

About 60% of the clips have camera motion, which the authors expected to disturb local motion features, so they released a second copy with the camera motion removed (§2.5). Salient features are matched between each pair of neighbouring frames, a geometric transformation is fitted with RANSAC independently for every pair, and the frames are warped and combined into a stabilized clip, in effect image stitching along time. Each stabilized clip comes with a MATLAB file holding a validity mask per frame (pixels outside it are background), the $3 \times 3$ transformation from the previous frame to the current one (the identity for the first frame), and the bounding box of the final clip (stabilization README). The clips and labels are the same as in the original release, which the current page calls the official one. Results must therefore say which version they use: the paper reports both, and Wang and Schmid (2013) used the original videos.

Splits

The protocol has three train/test splits, defined per class:

• Files. The split archive holds 153 text files, [action]_test_split[1-3].txt, one per class and split. Each line gives a clip’s file name and an id: 1 for training, 2 for testing, 0 for clips not used in that split. Every file should contain 70 ids of 1 and 30 of 2 (split README).
• Sizes. Each split therefore has $51 \times 70 = 3{,}570$ training and $51 \times 30 = 1{,}530$ test clips; the rest, 1,666 clips by the paper’s count or 1,749 by the page’s, are unused in that split. Simonyan and Zisserman (2014) describe a split as 3.7K training videos.
• Source videos. Clips from the same video file are never split between training and testing (§2.3). The paper states the rule in general and again within the per-category selection; whether it also holds across classes, when one film yields clips of several actions, it does not say. In our reading, the unused clips are what let the 70/30 counts be met exactly without breaking a source video across the two sides.
• Balanced meta-labels. Within each class, the proportions of every meta-label value are to follow the same 70/30 ratio in training and testing. A perfect balance is not always possible under the source constraint (§2.3).
• Selection. The authors generated a very large number of random splits, picked the one with the most balanced meta-label distribution, and then greedily picked the second and third splits least correlated with those already chosen, measuring correlation by normalized Hamming distance (§2.3).

There is no validation set. The paper’s HOG/HOF baseline tuned its SVM by 5-fold cross-validation on the training set (§4.1). In our reading, any validation set carved from a training split must also keep source videos together, for the reason the simulation below shows. The split archive is distributed separately from the videos; the current page links it as “Train/Test splits (3 lists)”.

Tasks

• Action recognition: 51-way classification of trimmed clips, the only task the paper defines.
• Robustness analysis: the meta-labels allow accuracy to be broken down by camera motion, viewpoint, occlusion and quality, as the paper does for its baselines.
• Pose and flow analysis on a subset: J-HMDB, below.

Evaluation

The protocol. For each split, a model is trained on the clips with id 1 and tested on those with id 2, and the score is classification accuracy on the test clips. The reported number is the mean of the three split accuracies (paper, §5.1; the same protocol is stated in Simonyan & Zisserman, 2014, §6, and Wang & Schmid, 2013, §3.3). Every test set has exactly 30 clips per class, so overall accuracy and mean per-class accuracy are the same number.

What the authors’ code computes. We found no separate evaluation script on the official pages. They link the authors’ C2 benchmark code, whose split reader and scoring files we read line by line at commit f8e9999 (MATLAB with CUDA and compiled SVM binaries; not run here):

• get_HMDB_split.m reads the 51 split files of one split and keeps ids 1 and 2, skipping 0.
• classification.m trains an SVM-HMM on per-frame C2 vectors, predicts a label for every frame of a test clip, and gives the clip the majority label (voting.m).
• The score is the mean of the diagonal of the row-normalized confusion matrix (formConfusionM.m), that is, mean per-class accuracy, which here equals clip accuracy.
• One run handles one split (isplit = 1 in setting_HMDB.m), so the average over the three splits is taken outside the code.

The paper does not describe the C2 classifier or the vote; on the protocol itself (which clips train and test, accuracy per split, the mean over splits), code and paper agree. The voting step belongs to this baseline, not to the protocol: other methods score whole clips directly.

Reporting conventions.

• Split 1 versus the mean. Ablations often use split 1 alone, as the two-stream paper does for its HMDB51 multi-task experiments (Table 2) and I3D for its architecture comparison (Table 2); comparisons with the state of the art use the three-split mean. The two numbers are not interchangeable.
• Original or stabilized clips, as above.
• Extra training data. The protocol does not restrict pretraining or outside data. Because HMDB51 is small, results soon depended on what was added: the two-stream paper’s temporal network on split 1 reached 46.6% trained on HMDB51 alone and 55.4% when trained jointly with UCF101 (Table 2). Tables should therefore state the pretraining data next to the score, as I3D’s Table 4 does.
• The spread across splits. The three splits share most of their training clips, and the protocol fixes them rather than sampling them, so the spread of three split accuracies is not an independent estimate of uncertainty. In our reading, it says how much the score depends on which clips were held out; statistical significance in evaluation covers how to compare methods properly.

Simulating source-video leakage

The code builds a synthetic dataset with HMDB51’s structure: 6 classes, 130 clips per class (HMDB51 averages about 133), cut from 12 source videos per class with an uneven number of clips each. A clip is 8 frames of 32 × 32 pixels in which a bright disc moves right, left, up or down, grows or shrinks (the class). The background texture, the disc’s size and its brightness belong to the source video, as scenery, actors and framing do in clips cut from one film; speed and start position vary per clip. Splits are written as HMDB51’s split files are, with ids 1, 2 and 0 and exactly 70 training and 30 test clips per class. A leaky split draws the 100 clips one by one; a source split assigns whole source videos to one side, leaving the remainder of a source unused when its clips do not fit. A 1-nearest-neighbour classifier (k-nearest neighbours) is scored on raw pixels and on frame differences, in which the static background cancels but the disc’s size and brightness remain. Each setting is scored on three splits and averaged, as the protocol prescribes, for datasets generated with seeds 0–9.

import numpy as np
from scipy.ndimage import gaussian_filter

T, H, W = 8, 32, 32                     # frames, height, width of each synthetic clip
CLASSES = ["right", "left", "up", "down", "grow", "shrink"]  # the action = how the blob moves
N_SOURCES, CLIPS_PER_CLASS = 12, 130    # HMDB51: >= 101 clips per class, about 133 on average
N_TRAIN, N_TEST = 70, 30                # per class and split, as in the HMDB51 split files
yy, xx = np.mgrid[:H, :W]

def render_clip(rng, c, src):
    """One clip: a blob moving or changing size (the class) over the background of its
    source video. Blob brightness and size also belong to the source, as actors and
    framing do in clips cut from one film."""
    bg, base_r, amp = src
    v = rng.uniform(0.8, 1.4)                                  # speed varies per clip
    y0, x0 = rng.uniform(12, 20, size=2)                       # start varies per clip
    clip = np.repeat(bg[None], T, axis=0) + 0.2 * rng.normal(size=(T, H, W))
    for t in range(T):
        dy, dx, dr = {"right": (0, v, 0), "left": (0, -v, 0), "up": (-v, 0, 0),
                      "down": (v, 0, 0), "grow": (0, 0, 0.5 * v), "shrink": (0, 0, -0.5 * v)}[CLASSES[c]]
        r = max(base_r + dr * (t - T / 2), 1.0)
        clip[t] += amp * ((yy - y0 - dy * t) ** 2 + (xx - x0 - dx * t) ** 2 <= r ** 2)
    return clip

def make_dataset(rng):
    clips, labels, sources = [], [], []
    for c in range(len(CLASSES)):
        sizes = rng.multinomial(CLIPS_PER_CLASS - 3 * N_SOURCES, np.ones(N_SOURCES) / N_SOURCES) + 3
        for s, n in enumerate(sizes):                             # uneven clips per source video
            bg = gaussian_filter(rng.normal(size=(H, W)), 2.0)
            src = (0.6 * bg / bg.std(), rng.uniform(2.5, 4.5), rng.uniform(1.0, 2.0))
            for _ in range(n):
                clips.append(render_clip(rng, c, src)); labels.append(c); sources.append(c * 100 + s)
    return np.array(clips), np.array(labels), np.array(sources)

def make_split(rng, y, src, keep_sources_together):
    """Split ids as in the HMDB51 split files: 1 = train, 2 = test, 0 = unused.
    Per class: exactly 30 test and 70 training clips; the remaining clips are unused."""
    ids = np.zeros(len(y), int)
    for c in np.unique(y):
        idx = np.flatnonzero(y == c)
        if not keep_sources_together:                          # leaky: draw clips one by one
            perm = rng.permutation(idx)
            ids[perm[:N_TEST]], ids[perm[N_TEST:N_TEST + N_TRAIN]] = 2, 1
            continue
        while True:                                            # whole source videos per side;
            test, train = [], []                               # retry if an order falls short
            for s in rng.permutation(np.unique(src[idx])):
                members = list(rng.permutation(idx[src[idx] == s]))
                if len(test) < N_TEST:
                    test += members[:N_TEST - len(test)]       # leftover clips of s: unused
                elif len(train) < N_TRAIN:
                    train += members[:N_TRAIN - len(train)]
            if len(test) == N_TEST and len(train) == N_TRAIN:
                break
        ids[test], ids[train] = 2, 1
    return ids

def nn_accuracy(X, y, ids):
    """1-nearest-neighbour accuracy on the test clips (id 2), trained on id 1 only."""
    Xtr, ytr, Xte, yte = X[ids == 1], y[ids == 1], X[ids == 2], y[ids == 2]
    d2 = (Xte ** 2).sum(1)[:, None] - 2 * Xte @ Xtr.T + (Xtr ** 2).sum(1)[None]
    return np.mean(ytr[d2.argmin(1)] == yte)

def features(clips):
    pixels = clips.reshape(len(clips), -1)
    diffs = np.diff(clips, axis=1).reshape(len(clips), -1)    # static background cancels
    return {"pixels": pixels, "frame differences": diffs}

rows = {}
for seed in range(10):
    rng = np.random.default_rng(seed)
    clips, y, src = make_dataset(rng)
    feats = features(clips)
    for together in (False, True):
        splits = [make_split(rng, y, src, together) for _ in range(3)]
        for name, X in feats.items():
            accs = [nn_accuracy(X, y, ids) for ids in splits]   # splits 1-3
            rows.setdefault((name, together), []).append(accs)
    if seed == 0:
        ids = splits[0]
        print(f"{len(y)} clips, {len(CLASSES)} classes, {N_SOURCES} source videos per class; "
              f"per split: {np.sum(ids == 1)} train, {np.sum(ids == 2)} test, "
              f"{np.sum(ids == 0)} unused; chance = {1 / len(CLASSES):.3f}")

for (name, together), accs in rows.items():
    a = np.array(accs)                       # (seed, split)
    m = a.mean(axis=1)                       # the protocol's number: mean over the 3 splits
    label = "sources kept together" if together else "clips drawn at random"
    print(f"{name:17s} {label:22s} seed 0 splits {np.round(a[0], 3)} -> mean {m[0]:.3f}; "
          f"seeds 0-9: mean {m.mean():.3f}, range {m.min():.3f}-{m.max():.3f}")

for name in ("pixels", "frame differences"):
    gap = np.array(rows[(name, False)]).mean(1) - np.array(rows[(name, True)]).mean(1)
    print(f"{name:17s} inflation from leaking, seeds 0-9: mean {gap.mean():+.3f}, "
          f"range {gap.min():+.3f} to {gap.max():+.3f}")

Output:

780 clips, 6 classes, 12 source videos per class; per split: 420 train, 180 test, 180 unused; chance = 0.167
pixels            clips drawn at random  seed 0 splits [1. 1. 1.] -> mean 1.000; seeds 0-9: mean 1.000, range 0.998-1.000
frame differences clips drawn at random  seed 0 splits [0.794 0.744 0.75 ] -> mean 0.763; seeds 0-9: mean 0.706, range 0.617-0.772
pixels            sources kept together  seed 0 splits [0.383 0.356 0.289] -> mean 0.343; seeds 0-9: mean 0.290, range 0.169-0.411
frame differences sources kept together  seed 0 splits [0.761 0.683 0.65 ] -> mean 0.698; seeds 0-9: mean 0.678, range 0.594-0.737
pixels            inflation from leaking, seeds 0-9: mean +0.710, range +0.589 to +0.831
frame differences inflation from leaking, seeds 0-9: mean +0.027, range -0.111 to +0.080

On raw pixels the leaky split is solved almost perfectly while the source split scores 0.290 on average, not far above chance. With clips drawn at random, nearly every test clip has a sibling from its source video among the training clips, and since the shared background dominates the pixel distance, the nearest neighbour is that sibling: the classifier recognizes the film, not the motion. Keeping sources together removes the siblings, and the inflation, 0.589 to 0.831 over the ten datasets, is the measure of how much of the leaky score came from them.

Frame differences remove the background but keep the disc’s size and brightness, a weaker fingerprint. Their inflation is 0.027 on average and ranges from −0.111 to +0.080, so on a single dataset it is lost among other sources of variation. In our reading, this is the harder case in practice: a model that has partly learned the action shows only a modest gain from a leaky split, which is easy to mistake for a real improvement. The three splits of seed 0 also differ from each other (0.289 to 0.383 on pixels with sources together), which is what averaging over splits is meant to smooth.

License

The current official page states “License: CC BY 4.0” (Creative Commons Attribution 4.0 International) next to the downloads, as of October 2026. The earlier page’s notice read “HMDB by H. Kuehne, H. Jhuang, E. Garrote, T. Poggio, T. Serre is licensed under a Creative Commons Attribution 4.0 International License”; the notice appears in its archived copies from 23 August 2018 onward and not in those up to 27 July 2018. Both pages ask users to cite the ICCV 2011 paper.

The clips themselves are excerpts of digitized movies, Prelinger archive films and web videos. Neither page discusses the copyright in that footage, names the source films, or says how the CC BY notice relates to it, so the terms for the video content are unclear; check with the authors before uses other than research. Neither the paper nor the pages discuss the consent or privacy of the people shown in the web videos (as of October 2026).

Limitations and Bias

• Small. A split has 3,570 training clips, about 70 per class. Simonyan and Zisserman (2014) called HMDB51’s training splits 2.6 times smaller than UCF101’s and added UCF101 data to train their temporal network; I3D’s authors attribute HMDB51’s lower scores partly to the lack of training data.
• Same scenes, different actions. Carreira and Zisserman (2017) also note that HMDB51 was built to be hard: many clips show different actions in the same scene, for example draw sword, sword and sword exercise clips taken from the same videos.
• Low resolution and quality. Clips are 240 pixels high and DivX-compressed, and a fifth are graded low quality. In the paper’s analysis, quality was the strongest factor: both baselines lost about 10 points from high- to low-quality clips (Table 4), and in a logistic regression on correctness, high quality had an odds ratio of 1.91 for HOG/HOF and 2.65 for C2 against low quality (Table 5). The text says occlusion and viewpoint had no significant influence on either system; the table agrees for HOG/HOF but gives $p = 0.007$ and $0.009$ for C2.
• Static bias, smaller than in web-only datasets. In the paper’s Table 2, scene features (gist) reached 13.4% and mean colour and grey values (with PCA) 8.8% on HMDB51 against 20.2% for HOG/HOF, drops of 33.7% and 56.4%, while on UCF Sports gist (60.0%) beat HOG/HOF (58.6%). The authors attribute the difference to YouTube sports videos being location-specific and shot from preferred vantage points. RESOUND (Li, Li & Vasconcelos, 2018, Table 1) measured representation bias as the log ratio of the accuracy of a linear classifier on frozen per-frame features to chance: 3.16 for ImageNet object features, 2.92 for scene and 2.98 for people features on HMDB51, below UCF101 (4.33, 4.09, 4.23) and Kinetics (4.51, 3.96, 4.31) but well above Diving48 (1.48, 1.26, 1.44), a dataset with a similar number of classes. By our arithmetic, assuming the natural logarithm (the paper does not state the base), the object-feature figure corresponds to about 47% accuracy with no temporal modeling at all. Dataset bias discusses such measurements.
• Unused clips. A quarter of the clips are left out of each split. Whether some clips are unused in all three, the paper does not say, and answering it needs the split files.

Common Uses

• Fine-tuning benchmark after large-scale pretraining. Pretraining on miniKinetics and fine-tuning end to end raised two-stream I3D on split 1 from 66.4% (ImageNet-initialized, trained on HMDB51 only) to 75.9% (Carreira & Zisserman, 2017, Table 3); see transfer learning.
• Second benchmark next to UCF101 in the papers that defined deep video recognition: two-stream networks, temporal segment networks, I3D, 3D convolutional networks.
• Small-data test for self-supervised video models: VideoMAE reports its largest gain over contrastive pretraining on HMDB51.
• Robustness and cue studies, using the meta-labels and the stabilized clips.

Historical Milestones

All figures are mean accuracy over the three splits, on the original (unstabilized) clips unless noted.

• 2011, the paper’s baselines (Table 3). Laptev’s HOG/HOF features at Harris3D space-time interest points, with a bag of visual words of 8,000 words (2,000 for stabilized clips) and an RBF-kernel SVM, reached 20.44% (21.96% on stabilized clips). The C2 features of a hierarchical model of the visual cortex’s dorsal (motion) and ventral (shape) streams reached 22.83% (23.18%). Chance is 2%. Stabilization helped only marginally, and the authors compared the starting point to Caltech-101’s, where object recognition began around 16%. Motion features beat shape features in both systems: HOF 17.95% against HOG 15.01%, motion C2 21.96% against shape C2 13.40% (Table 6). The earlier official page listed the baselines as 20.0% and 23.0% (archived copies of 2014 and 2016).
• 2013, improved dense trajectories. With camera-motion compensation, Fisher vectors and human detection, Wang and Schmid reached 57.2% (Table 4), on the original videos. The improved dense trajectories paper won the Helmholtz Prize in 2023 (committee’s list).
• 2014, two-stream networks. An ImageNet-pretrained spatial network and an optical-flow temporal network, fused by an SVM, reached 59.4% (Simonyan & Zisserman, 2014, Table 4), comparable to iDT’s 57.2% in the same table but below iDT with higher-dimensional encodings (61.1%) and stacked Fisher encoding (66.8%). The same table lists the 2011 C2 system as a spatio-temporal HMAX network at 22.8%. See the two-stream paper.
• 2016, the best pre-Kinetics results. I3D’s comparison table lists temporal segment networks at 69.4% and ST-ResNet combined with iDT at 70.3% as the strongest earlier results (Carreira & Zisserman, 2017, Table 4).
• 2017, Kinetics pretraining. Two-stream I3D pretrained on Kinetics reached 80.2% (CVPR version, Table 4), a 33% reduction in misclassification against ST-ResNet with iDT by the authors’ figure; RGB-only and flow-only I3D reached 74.5% and 74.6%. Later arXiv versions report slightly different figures (I3D paper). After this, HMDB51 served mainly as a transfer target.

Related Datasets

UCF101 (2012), the sibling benchmark, has twice the classes and clips, all from YouTube, and the same rule in another form: its three splits keep each group of clips, cut from one long video, on one side. J-HMDB (Jhuang et al., 2013) selects 21 classes involving a single person (for example brush hair, catch, golf, pour, walk), trims 928 clips to the action, 36–55 per class, and annotates every frame with a 2D puppet model: joint positions, scale, viewpoint, a segmentation mask and the “puppet flow” of the body. Its three splits follow HMDB51’s rule of keeping clips of one video on one side, at close to 70:30 in clips and in source videos, though drawn at random; it serves pose-based recognition and spatio-temporal action detection. Kinetics replaced HMDB51 and UCF101 as the large benchmark and pretraining source, and Something-Something targets classes that differ in motion rather than scene, the property HMDB51’s authors claimed for its classes.

Resources

• The paper: Kuehne et al. (2011), on how the database was collected and the paper’s own analyses of low-level bias and nuisance factors.
• HMDB51 official page (Serre lab): original and stabilized clips, the split lists, the class list and the citation.
• Earlier official page (archived July 2024): meta-label table, stabilization and split READMEs, STIP features and the change log.
• C2 benchmark code by Hueihan Jhuang, with the split reader and the scoring used for the paper’s C2 baseline.
• The current page also lists third-party copies and loaders (torchvision, MMAction2, Hugging Face, Activeloop), which the authors do not host.